import * as i0 from '@angular/core';
import { OnDestroy, OnChanges, ElementRef, SimpleChanges, EventEmitter, OnInit, Renderer2, ChangeDetectorRef, QueryList, Injector, Type, PipeTransform, AfterViewInit, DoCheck, TemplateRef, AfterContentInit, ComponentFactoryResolver, ComponentRef, ModuleWithProviders } from '@angular/core';
import * as i94 from '@angular/cdk/overlay';
import { Overlay, OverlayKeyboardDispatcher, OverlayRef } from '@angular/cdk/overlay';
import { Observable } from 'rxjs';
import * as i97 from 'systelab-translate';
import { I18nService } from 'systelab-translate';
import { GridOptions, IHeaderParams, IAfterGuiAttachedParams, RowModelType, GridApi, ColDef, IsFullWidthRowParams, RowSelectionOptions, GridReadyEvent, GetRowIdParams, RowSelectedEvent, IDatasource, IGetRowsParams } from 'ag-grid-community';
import * as i98 from 'ag-grid-angular';
import { AgRendererComponent, IHeaderAngularComp, AgEditorComponent } from 'ag-grid-angular';
import { PreferencesService } from 'systelab-preferences';
import * as i91 from 'primeng/datepicker';
import { DatePicker } from 'primeng/datepicker';
import { PrimeNG } from 'primeng/config';
import * as i93 from '@angular/cdk/drag-drop';
import { CdkDragDrop } from '@angular/cdk/drag-drop';
import * as i92 from 'primeng/autocomplete';
import { AutoComplete } from 'primeng/autocomplete';
import { AnimationEvent } from '@angular/animations';
import { SafeHtml, DomSanitizer } from '@angular/platform-browser';
import * as i89 from '@angular/common';
import * as i90 from '@angular/forms';
import { UntypedFormControl, ValidationErrors, Validator } from '@angular/forms';
import * as i95 from 'primeng/contextmenu';
import * as i96 from 'angular-split';
import * as i99 from '@angular/cdk/tree';
import { NestedTreeControl } from '@angular/cdk/tree';
import { ArrayDataSource } from '@angular/cdk/collections';

type ToastType = 'warning' | 'info' | 'success' | 'error';
declare enum ToastPosition {
    topCenter = "top-center",
    bottomCenter = "bottom-center",
    topEnd = "top-end",
    bottomEnd = "bottom-end"
}
interface ToastAction {
    label: string;
    callback: () => void;
}
declare class ToastData {
    text?: string;
    title?: string;
    body?: string;
    type: ToastType;
    action?: ToastAction;
}
declare enum ToastSize {
    small = "small",
    large = "large"
}
interface ToastConfig {
    autoWidth?: boolean;
    fixedSize?: ToastSize;
    showCloseButton?: boolean;
    timeout: number;
    position?: ToastPosition;
    maxWidth?: number;
    maxHeight?: number;
    maxSimultaneousToasts?: number;
}
declare const DEFAULT_TOAST_CONFIG: ToastConfig;

interface SystelabDialogConfig {
    dialogsDraggableByDefault?: boolean;
}

interface AppConfig {
    productionMode: boolean;
    toast?: ToastConfig;
    dialogConfig?: SystelabDialogConfig;
}

type TooltipPlacement = 'top' | 'right' | 'bottom' | 'left';
declare class TooltipContentComponent {
    content: string;
    placement: TooltipPlacement;
    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TooltipContentComponent, "ng-component", never, { "content": { "alias": "content"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; }, {}, never, never, false, never>;
}
declare class TooltipDirective implements OnDestroy, OnChanges {
    private readonly el;
    private readonly overlay;
    static readonly DEFAULT_PLACEMENT: TooltipPlacement;
    static readonly DEFAULT_DELAY = 1000;
    systelabTooltip: string | undefined;
    systelabTooltipHtml: string | undefined;
    systelabTooltipPlacement: TooltipPlacement | undefined;
    systelabTooltipDelay: number;
    systelabTooltipHideDelay: number;
    systelabTooltipOnFocus: boolean;
    private overlayRef;
    private tooltipRef;
    private showTimeout;
    private hideTimeout;
    private scrollListener;
    constructor(el: ElementRef, overlay: Overlay);
    onMouseEnter(): void;
    onMouseLeave(): void;
    onFocus(): void;
    onBlur(): void;
    ngOnChanges(_changes: SimpleChanges): void;
    ngOnDestroy(): void;
    private scheduleShow;
    private scheduleHide;
    private show;
    private updateContent;
    private disposeOverlay;
    private clearShowTimeout;
    private clearHideTimeout;
    private clearTimeouts;
    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TooltipDirective, "[systelabTooltip],[systelabTooltipHtml]", never, { "systelabTooltip": { "alias": "systelabTooltip"; "required": false; }; "systelabTooltipHtml": { "alias": "systelabTooltipHtml"; "required": false; }; "systelabTooltipPlacement": { "alias": "systelabTooltipPlacement"; "required": false; }; "systelabTooltipDelay": { "alias": "systelabTooltipDelay"; "required": false; }; "systelabTooltipHideDelay": { "alias": "systelabTooltipHideDelay"; "required": false; }; "systelabTooltipOnFocus": { "alias": "systelabTooltipOnFocus"; "required": false; }; }, {}, never, never, false, never>;
}

declare class SliderComponent {
    min: number;
    max: number;
    step: number;
    continuous: boolean;
    value: number;
    valueChange: EventEmitter<any>;
    element: ElementRef;
    sliderChangeEvent(event: any): void;
    sliderInputEvent(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SliderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SliderComponent, "systelab-slider", never, { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "continuous": { "alias": "continuous"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, false, never>;
}

declare class SliderDoubleRangeComponent {
    min: number;
    max: number;
    step: number;
    continuous: boolean;
    minValue: number;
    maxValue: number;
    minValueChange: EventEmitter<any>;
    maxValueChange: EventEmitter<any>;
    firstRange: ElementRef;
    secondRange: ElementRef;
    minGap: number;
    clicked: boolean;
    firstSliderInputEvent(): void;
    sliderOneChangeEvent(): void;
    secondSliderInputEvent(): void;
    sliderTwoChangeEvent(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SliderDoubleRangeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SliderDoubleRangeComponent, "systelab-slider-double-range", never, { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "continuous": { "alias": "continuous"; "required": false; }; "minValue": { "alias": "minValue"; "required": false; }; "maxValue": { "alias": "maxValue"; "required": false; }; }, { "minValueChange": "minValueChange"; "maxValueChange": "maxValueChange"; }, never, never, false, never>;
}

declare class SwitchComponent {
    private checked;
    get isChecked(): boolean;
    set isChecked(val: boolean);
    isCheckedChange: EventEmitter<any>;
    disabled: boolean;
    onToggle(): void;
    doKeyDown(event: KeyboardEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SwitchComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SwitchComponent, "systelab-switch", never, { "isChecked": { "alias": "isChecked"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "isCheckedChange": "isCheckedChange"; }, never, never, false, never>;
}

declare class ContextMenuActionData {
    elementId: string;
    actionId: string;
    constructor(elementId: string, actionId: string);
}

declare abstract class AbstractContextMenuOption<T, K> {
    actionId: string;
    actionText: string;
    action?: T;
    isActionEnabled?: K;
    isDivider?: boolean;
    iconClass?: string;
    backgroundIconColor?: string;
    iconColor?: string;
    isIconEnabled?: K;
    childrenContextMenuOptions?: Array<AbstractContextMenuOption<T, K>>;
    iconFontSize?: string;
    hasChildren(): boolean;
}

type ContextMenuActionFunction = (data: ContextMenuActionData) => void;
type ContextMenuIsEnabledFunction = (elementId: string, actionId: string) => boolean;
declare class ContextMenuOption extends AbstractContextMenuOption<ContextMenuActionFunction, ContextMenuIsEnabledFunction> {
    actionId: string;
    actionText: string;
    action?: ContextMenuActionFunction;
    isActionEnabled?: ContextMenuIsEnabledFunction;
    isDivider?: boolean;
    iconClass?: string;
    backgroundIconColor?: string;
    iconColor?: string;
    isIconEnabled?: ContextMenuIsEnabledFunction;
    childrenContextMenuOptions?: Array<ContextMenuOption>;
    iconFontSize?: string;
    constructor(actionId: string, actionText: string, action?: ContextMenuActionFunction, isActionEnabled?: ContextMenuIsEnabledFunction, isDivider?: boolean, iconClass?: string, backgroundIconColor?: string, iconColor?: string, isIconEnabled?: ContextMenuIsEnabledFunction, childrenContextMenuOptions?: Array<ContextMenuOption>, iconFontSize?: string);
}

declare abstract class AbstractContextComponent<T> implements OnInit, OnDestroy {
    protected el: ElementRef;
    protected myRenderer: Renderer2;
    protected cdr: ChangeDetectorRef;
    dropdownParent: ElementRef;
    dropdownMenuElement: ElementRef;
    dropdownElement: ElementRef;
    ngcontent: ElementRef;
    action: EventEmitter<any>;
    elementID: string;
    fontSize: string;
    fontColor: string;
    isEmbedded: boolean;
    overflow: boolean;
    destroyWheelListener: Function;
    destroyMouseListener: Function;
    destroyKeyListener: Function;
    scrollHandler: any;
    isOpened: boolean;
    protected previousActionId: string;
    protected previousShownMenu: Array<string>;
    protected previousMenuWidth: Array<number>;
    protected lastMenuLevel: number;
    protected constructor(el: ElementRef, myRenderer: Renderer2, cdr: ChangeDetectorRef);
    ngOnInit(): void;
    onResize(event: any): void;
    isDropDownOpened(): boolean;
    protected loop(x: number, y: number): void;
    showDropDown(x: number, y: number): void;
    resetDropDownPositionAndHeight(): void;
    protected getFirstChildLeft(selectedChild: ElementRef): number;
    protected getFirstChildLeftWithLevels(selectedChild: ElementRef, optionLevel: number, previousMenuWidth: Array<number>): number;
    protected getFirstChildTop(event: any, selectedChild: ElementRef): number;
    actionsAfterCloseDropDown(): void;
    closeDropDown(): void;
    protected addListeners(): void;
    protected handleKeyboardEvents(event: KeyboardEvent): void;
    protected handleWheelEvents(event: WheelEvent): void;
    protected handleMouseEvents(event: MouseEvent): void;
    protected scroll(event: any): void;
    protected checkTargetAndClose(target: any): void;
    ngContentStopPropagation(event: any): void;
    protected checkIfNgContent(target: any): boolean;
    protected addScrollHandler(): void;
    protected removeScrollHandler(): void;
    ngOnDestroy(): void;
    dotsClicked(event: MouseEvent): void;
    protected hideDivUntilIsPositioned(x: number, y: number): void;
    open(event: MouseEvent): void;
    toggle(elementID: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractContextComponent<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractContextComponent<any>, never, never, { "elementID": { "alias": "elementID"; "required": false; }; "fontSize": { "alias": "fontSize"; "required": false; }; "fontColor": { "alias": "fontColor"; "required": false; }; "isEmbedded": { "alias": "isEmbedded"; "required": false; }; "overflow": { "alias": "overflow"; "required": false; }; }, { "action": "action"; }, never, never, true, never>;
}

declare abstract class AbstractContextMenuComponent<T> extends AbstractContextComponent<T> implements OnInit {
    childDropdownMenuElement: QueryList<ElementRef>;
    scrollableList: ElementRef;
    action: EventEmitter<any>;
    readonly levelSeparator = "_|_";
    hasIcons: boolean;
    private contextMenuOptionsList;
    set contextMenuOptions(value: Array<T>);
    get contextMenuOptions(): Array<T>;
    ngOnInit(): void;
    dotsClicked(event: MouseEvent): void;
    open(event: MouseEvent): void;
    doClick(event: any, elementID: string, action: ContextMenuOption, parent?: ContextMenuOption): void;
    doClickWithAction(event: any, elementID: string, actionId: string): void;
    doMouseOver(event: any, elementID: string, actionId: string): void;
    getSelfReference(): AbstractContextMenuComponent<T>;
    getMenuLevel(actionId: string): number;
    getOptionDetailsActionId(actionId: string): string;
    getOptionDetailsHasChildren(actionId: string): boolean;
    showSubmenu(event: any, actionId: string, selectedChild: ElementRef, elementId: string): void;
    protected checkIfHasIcons(): void;
    protected checkTargetAndClose(target: any): void;
    protected hideSubmenus(untilLevel: number): void;
    abstract openWithOptions(event: MouseEvent, newContextMenuOptions: Array<T>): void;
    abstract isEnabled(elementId: string, actionId: string): boolean;
    abstract isIconEnabled(elementId: string, actionId: string): boolean;
    abstract executeAction(event: any, elementId: string, actionId: string, parentAction?: string): void;
    protected abstract existsAtLeastOneActionEnabled(): boolean;
    protected abstract getOption(actionId: string): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractContextMenuComponent<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractContextMenuComponent<any>, never, never, { "contextMenuOptions": { "alias": "contextMenuOptions"; "required": false; }; }, { "action": "action"; }, never, never, true, never>;
}

declare class ContextMenuComponent extends AbstractContextMenuComponent<ContextMenuOption> implements OnInit, OnDestroy {
    protected el: ElementRef;
    protected myRenderer: Renderer2;
    protected cdr: ChangeDetectorRef;
    constructor(el: ElementRef, myRenderer: Renderer2, cdr: ChangeDetectorRef);
    openWithOptions(event: MouseEvent, newContextMenuOptions: Array<ContextMenuOption>): void;
    getSelfReference(): AbstractContextMenuComponent<ContextMenuOption>;
    protected existsAtLeastOneActionEnabled(): boolean;
    isEnabled(elementId: string, actionId: string): boolean;
    isIconEnabled(elementId: string, actionId: string): boolean;
    executeAction(event: any, elementId: string, actionId: string): void;
    protected checkIfHasIcons(): void;
    protected getOption(actionId: string, parentAction?: string): ContextMenuOption;
    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ContextMenuComponent, "systelab-context-menu", never, {}, {}, never, ["*"], false, never>;
}

declare class ContextMenuSubmenuItemComponent {
    action: ContextMenuOption;
    actionName: string;
    hasIcons: boolean;
    hasChildren: boolean;
    readonly levelSeparator = "_|_";
    contextMenuOriginal: AbstractContextMenuComponent<ContextMenuOption>;
    parentId: string;
    elementID: string;
    childDropdownMenuElement: QueryList<ElementRef>;
    constructor();
    doMouseOver(event: any, elementID: string, actionId: string): void;
    doClickWithAction(event: any, elementID: string, actionId: string): void;
    getAction(childActionId: String): string;
    isEnabled(elementId: string, actionId: string): boolean;
    isIconEnabled(elementId: string, actionId: string): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuSubmenuItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ContextMenuSubmenuItemComponent, "systelab-context-menu-submenu-item", never, { "action": { "alias": "action"; "required": false; }; "actionName": { "alias": "actionName"; "required": false; }; "hasIcons": { "alias": "hasIcons"; "required": false; }; "hasChildren": { "alias": "hasChildren"; "required": false; }; "contextMenuOriginal": { "alias": "contextMenuOriginal"; "required": false; }; "parentId": { "alias": "parentId"; "required": false; }; "elementID": { "alias": "elementID"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ContextPanelComponent extends AbstractContextComponent<ContextMenuOption> implements OnInit, OnDestroy {
    protected el: ElementRef;
    protected myRenderer: Renderer2;
    protected cdr: ChangeDetectorRef;
    constructor(el: ElementRef, myRenderer: Renderer2, cdr: ChangeDetectorRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<ContextPanelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ContextPanelComponent, "systelab-context-panel", never, {}, {}, never, [".header-content", ".main-content"], false, never>;
}

interface ModalComponent<SystelabModalContext> {
}
declare class SystelabModalContext {
    dialogClass: string;
    width: number;
    height: number;
    minWidth: number;
    minHeight: number;
    maxWidth: number;
    maxHeight: number;
    widthRelative: string;
    heightRelative: string;
    minWidthRelative: string;
    minHeightRelative: string;
    maxWidthRelative: string;
    maxHeightRelative: string;
    positionX: any;
    positionY: any;
    fullScreen: boolean;
    isBlocking: boolean;
    keyboard: any;
    isContextDialog: boolean;
    showClose: boolean;
    setDefaultSize(w: number, h: number): void;
}

declare class DialogService {
    private readonly overlay;
    private injector;
    static readonly breakpointMedium = 768;
    constructor(overlay: Overlay, injector: Injector);
    showDialog(component: Type<any>, parameters: SystelabModalContext): Observable<any>;
    private getConfig;
    private createInjector;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DialogService>;
}

declare class MessagePopupIcon {
    cssClass: string;
    cssPropertiesClass?: string;
    constructor(cssClass: string, cssPropertiesClass?: string);
}
declare class MessageWithIconComponent {
    static readonly MESSAGE_QUESTION = 1;
    static readonly MESSAGE_ERROR = 2;
    static readonly MESSAGE_WARNING = 3;
    static readonly MESSAGE_INFO = 4;
    message: string;
    type: number;
    icon: MessagePopupIcon;
    getIcon(): string;
    getColor(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<MessageWithIconComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MessageWithIconComponent, "systelab-message-with-icon", never, { "message": { "alias": "message"; "required": false; }; "type": { "alias": "type"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; }, {}, never, never, false, never>;
}

declare class MessagePopupButton {
    title: string;
    returnValue: any;
    cssClass?: string;
    focus: boolean;
    constructor(title: string, returnValue: any, cssClass?: string, focus?: boolean);
}
declare class MessagePopupService {
    protected i18nService: I18nService;
    protected dialogService: DialogService;
    private overlayDispatcher;
    static readonly breakpointMedium = 500;
    constructor(i18nService: I18nService, dialogService: DialogService, overlayDispatcher: OverlayKeyboardDispatcher);
    showErrorPopup(titleDescription: string, errorDescription: string, modalClass?: string, width?: number, height?: number): Observable<any>;
    showWarningPopup(titleDescription: string, warningDescription: string, modalClass?: string, width?: number, height?: number): Observable<any>;
    showInformationPopup(titleDescription: string, messageDescription: string, modalClass?: string, width?: number, height?: number): Observable<any>;
    showYesNoQuestionPopup(titleDescription: string, messageDescription: string, modalClass?: string, width?: number, height?: number, template?: string): Observable<any>;
    showCustomQuestionPopup(titleDescription: string, messageDescription: string, modalClass?: string, width?: number, height?: number, buttons?: MessagePopupButton[], icon?: MessagePopupIcon): Observable<any>;
    showAskAgainPopup(titleDescription: string, messageDescription: string, modalClass?: string, width?: number, height?: number, buttons?: MessagePopupButton[], icon?: MessagePopupIcon, messageAskAgain?: string): Observable<any>;
    protected showPopup(title: string, type: number, message: string, modalClass?: string, width?: number, height?: number, buttons?: MessagePopupButton[], icon?: MessagePopupIcon, messageAskAgain?: string): Observable<any>;
    private getButtonsTemplate;
    private isPopupAlreadyShowed;
    static ɵfac: i0.ɵɵFactoryDeclaration<MessagePopupService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MessagePopupService>;
}

declare class DialogRef<T extends SystelabModalContext> {
    private overlayRef;
    context: T;
    private static readonly ESCAPE_KEY;
    private subject;
    private subscription;
    constructor(overlayRef: OverlayRef, context: T);
    closeAllDialogs(): void;
    close(value?: any): void;
    getResult(): Observable<any>;
    disable(): void;
    enable(): void;
}

declare class MessagePopupViewContext extends SystelabModalContext {
    fullScreen: boolean;
    maxWidth: number;
    minWidth: number;
    maxHeight: number;
    minHeight: number;
    title: string;
    msg: string;
    icon: MessagePopupIcon;
    type: number;
    color: string;
    buttons: MessagePopupButton[];
    askAgain: boolean;
    msgAskAgain: string;
}
declare class MessagePopupViewComponent implements ModalComponent<MessagePopupViewContext> {
    dialog: DialogRef<MessagePopupViewContext>;
    parameters: MessagePopupViewContext;
    hasAnyButtonFocus: boolean;
    checkAskAgain: boolean;
    constructor(dialog: DialogRef<MessagePopupViewContext>);
    static getParameters(): MessagePopupViewContext;
    close(value?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MessagePopupViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MessagePopupViewComponent, "dialog-view", never, {}, {}, never, never, false, never>;
}

declare class DataFilterPipe implements PipeTransform {
    transform(input: any[], searchString: string): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<DataFilterPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<DataFilterPipe, "datafilter", false>;
}

declare class TwoListItem {
    displayName: string;
    colId: string;
    isSelected: boolean;
    isVisible: boolean;
    constructor(displayName: string, colId: string, isSelected: boolean, isVisible: boolean);
}
declare class CurrentSelectionStatus {
    available: Array<TwoListItem>;
    visible: Array<TwoListItem>;
    constructor(available: Array<TwoListItem>, visible: Array<TwoListItem>);
    selectAvailable(element: TwoListItem, filteredList: Array<TwoListItem>, isShiftKey: boolean, isControlKey: boolean): void;
    selectVisible(element: TwoListItem, filteredList: Array<TwoListItem>, isShiftKey: boolean, isControlKey: boolean): void;
    clearAll(): void;
    private select;
    private selectRange;
    private selectSingle;
    private clear;
}

declare class TwoListComponent {
    _available: Array<TwoListItem>;
    get available(): Array<TwoListItem>;
    set available(list: Array<TwoListItem>);
    _visible: Array<TwoListItem>;
    get visible(): Array<TwoListItem>;
    set visible(list: Array<TwoListItem>);
    visibleChange: EventEmitter<TwoListItem[]>;
    availableChange: EventEmitter<TwoListItem[]>;
    initialAvailableColumns: Array<TwoListItem>;
    defaultVisibleColumns: Array<TwoListItem>;
    defaultHiddenColumns: Array<TwoListItem>;
    dragAndDropEnabled: boolean;
    firstListSearch: string;
    secondListSearch: string;
    currentSelectionStatus: CurrentSelectionStatus;
    constructor();
    add(): void;
    addAll(): void;
    removeAll(): void;
    remove(): void;
    private refresh;
    private sort;
    setDefaultColumnValues(): void;
    removeItemsFromList(list: Array<any>, itemsToRemove: Array<any>): Array<any>;
    selectAvailableItem(element: TwoListItem, ev: KeyboardEvent): void;
    moveSelectedItemsFromAvailableToVisible(element: TwoListItem, ev: Event): void;
    moveSelectedItemsFromVisibleToAvailable(element: TwoListItem): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwoListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwoListComponent, "systelab-two-list", never, { "available": { "alias": "available"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "initialAvailableColumns": { "alias": "initialAvailableColumns"; "required": false; }; "defaultVisibleColumns": { "alias": "defaultVisibleColumns"; "required": false; }; "defaultHiddenColumns": { "alias": "defaultHiddenColumns"; "required": false; }; "dragAndDropEnabled": { "alias": "dragAndDropEnabled"; "required": false; }; }, { "visibleChange": "visibleChange"; "availableChange": "availableChange"; }, never, never, false, never>;
}

declare class GridContextMenuActionData<T> {
    elementId: string;
    actionId: string;
    data: T;
    gridOptions: GridOptions;
    multipleSelectedData?: Array<T>;
    constructor(elementId: string, actionId: string, data: T, gridOptions: GridOptions, multipleSelectedData?: Array<T>);
}

type GridContextMenuActionFunction<T> = (data: GridContextMenuActionData<T>) => void;
type GridContextMenuIsEnabledFunction<T> = (data: T) => boolean;
declare class GridContextMenuOption<T> extends AbstractContextMenuOption<GridContextMenuActionFunction<T>, GridContextMenuIsEnabledFunction<T>> {
    actionId: string;
    actionText: string;
    action?: GridContextMenuActionFunction<T>;
    isActionEnabled?: GridContextMenuIsEnabledFunction<T>;
    isDivider?: boolean;
    iconClass?: string;
    backgroundIconColor?: string;
    iconColor?: string;
    childrenContextMenuOptions?: Array<GridContextMenuOption<T>>;
    iconFontSize?: string;
    constructor(actionId: string, actionText: string, action?: GridContextMenuActionFunction<T>, isActionEnabled?: GridContextMenuIsEnabledFunction<T>, isDivider?: boolean, iconClass?: string, backgroundIconColor?: string, iconColor?: string, childrenContextMenuOptions?: Array<GridContextMenuOption<T>>, iconFontSize?: string);
}

interface GridRowMenuActionHandler {
    isContextMenuOptionEnabled(elementId: string, actionId: string): boolean;
    executeContextMenuAction(elementId: string, actionId: string): void;
}
declare class GridContextMenuComponent<T> extends AbstractContextMenuComponent<GridContextMenuOption<T>> {
    protected el: ElementRef;
    protected myRenderer: Renderer2;
    protected cdr: ChangeDetectorRef;
    protected actionHandler: GridRowMenuActionHandler;
    constructor(el: ElementRef, myRenderer: Renderer2, cdr: ChangeDetectorRef);
    setActionManager(actionHandler: GridRowMenuActionHandler): void;
    setRowIndex(rowIndex: number): void;
    openWithOptions(event: MouseEvent, newContextMenuOptions: Array<GridContextMenuOption<T>>): void;
    protected existsAtLeastOneActionEnabled(): boolean;
    isIconEnabled(elementId: string, actionId: string): boolean;
    isEnabled(elementId: string, actionId: string): boolean;
    executeAction(event: any, elementId: string, actionId: string): void;
    protected getOption(actionId: string): GridContextMenuOption<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<GridContextMenuComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GridContextMenuComponent<any>, "systelab-grid-context-menu", never, {}, {}, never, ["*"], false, never>;
}

declare class GridColumnsOptions {
    available: Array<TwoListItem>;
    visible: Array<TwoListItem>;
    initialAvailableColumns: Array<TwoListItem>;
    defaultVisibleColumns?: Array<TwoListItem>;
    defaultHiddenColumns?: Array<TwoListItem>;
}

interface GridHeaderMenuActionHandler {
    executeHeaderContextMenuAction(elementId: string, actionId: string, headerData: Object): void;
    isHeaderContextMenuOptionEnabled(elementId: string, actionId: string, headerData: Object): boolean;
}
declare class GridHeaderContextMenu<Object> extends AbstractContextMenuComponent<GridContextMenuOption<Object>> {
    protected el: ElementRef;
    protected myRenderer: Renderer2;
    protected cdr: ChangeDetectorRef;
    actionHandler: GridHeaderMenuActionHandler;
    headerData: Object;
    constructor(el: ElementRef, myRenderer: Renderer2, cdr: ChangeDetectorRef);
    refresh(params: IHeaderParams): boolean;
    afterGuiAttached?(params?: IAfterGuiAttachedParams): void;
    setActionManager(actionHandler: GridHeaderMenuActionHandler): void;
    setHeaderData(headerData: Object): void;
    openWithOptions(event: MouseEvent, newContextMenuOptions: Array<GridContextMenuOption<Object>>): void;
    protected existsAtLeastOneActionEnabled(): boolean;
    isEnabled(elementId: string, actionId: string): boolean;
    isIconEnabled(elementId: string, actionId: string): boolean;
    executeAction(event: any, elementId: string, actionId: string): void;
    showSubmenu(event: any, actionId: string, selectedChild: ElementRef, elementId: string): void;
    protected getOption(actionId: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GridHeaderContextMenu<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GridHeaderContextMenu<any>, "systelab-grid-header-context-menu", never, {}, {}, never, ["*"], false, never>;
}

type rowSelectionType = 'single' | 'multiple';
declare abstract class AbstractGrid<T> implements OnInit, GridRowMenuActionHandler, GridHeaderMenuActionHandler {
    protected preferencesService: PreferencesService;
    protected i18nService: I18nService;
    protected dialogService: DialogService;
    static readonly contextMenuColId = "contextMenu";
    static readonly selectionColId = "ag-Grid-SelectionColumn";
    static readonly clientSideRowModelType: RowModelType;
    gridOptions: GridOptions;
    gridApi: GridApi;
    overlayNoRowsTemplate: any;
    overlayLoadingTemplate: any;
    startCellEditorWithTab: boolean;
    headerMenu: Array<GridContextMenuOption<Object>>;
    menu: Array<GridContextMenuOption<T>>;
    preferenceName: string;
    multipleSelection: boolean;
    showChecks: boolean;
    headerCheckboxSelection: boolean;
    set rowData(value: Array<T>);
    get rowData(): Array<T>;
    noRowsText: any;
    loadingText: any;
    removeSelectionOnOpenContextMenu: boolean;
    autoSizeColumnsToContent: boolean;
    autoResizableScroll: boolean;
    action: EventEmitter<any>;
    clickRow: EventEmitter<any>;
    rowDragEnd: EventEmitter<any>;
    viewportChanged: EventEmitter<any>;
    rowSelected: EventEmitter<any>;
    hiddenElement: ElementRef;
    popupmenu: GridContextMenuComponent<T>;
    headerPopupMenu: GridHeaderContextMenu<Object>;
    allowRowManaged: boolean;
    protected firstSizeToFitExecuted: boolean;
    private calculatedGridState;
    private scrollTimeout;
    private _rowData;
    protected savedRowIndex: number;
    protected savedRowCount: number;
    protected constructor(preferencesService: PreferencesService, i18nService: I18nService, dialogService: DialogService);
    ngOnInit(): void;
    protected getInitialGridOptions(): GridOptions;
    protected onCellEditingStarted(event: any): void;
    onModelUpdated(event: any): any;
    private calculateVisibleRows;
    private isViewingBottom;
    private restoreForAddedRows;
    private restoreForDeletedRows;
    restoreScrollPosition(): void;
    doGridReady(event: any): void;
    protected saveColumnsStateInPreferences(): void;
    protected loadColumnsStateFromPreferences(): void;
    onSortChanged(): void;
    private loadColumnsState;
    private setColumnWidthToFitContent;
    private getContextMenuColumnDef;
    private getCheckColumnDef;
    protected abstract getColumnDefs(): Array<any>;
    protected getColumnDefsWithOptions(): Array<ColDef>;
    protected hideHeader(): boolean;
    protected getIsFullWidthRow(isFullWidthRowParams: IsFullWidthRowParams): boolean;
    getFullWidthCellRenderer(): any;
    protected getGridOptionsPreferencesPrefix(): string;
    executeContextMenuAction(elementId: string, actionId: string): void;
    isContextMenuOptionEnabled(elementId: string, actionId: string): boolean;
    executeHeaderContextMenuAction(elementId: string, actionId: string, headerData: any): void;
    isHeaderContextMenuOptionEnabled(elementId: string, actionId: string, headerData: any): boolean;
    protected isColResizeEnabled(): boolean;
    private suppressColumnSizeToFit;
    onRowSelected(event: any): void;
    protected getRowSelectionType(): RowSelectionOptions;
    getSelectedRows(): Array<T>;
    getSelectedRow(): T;
    selectRow(index: number): void;
    doClick(event: any): void;
    doColumnResized(event: any): void;
    doViewportChanged(): void;
    doGridSizeChanged(event: any): void;
    showOptions(canHideAllColumns?: boolean): void;
    protected getGridColumnOptions(gridApi: GridApi, columnDefs: Array<any>): GridColumnsOptions;
    protected applyGridColumnOptions(gridApi: GridApi, columnOptions: GridColumnsOptions): void;
    dotsClicked(rowIndex: number, data: T | Array<T>, event: MouseEvent): void;
    headerDotsClicked(headerData: Object, event: MouseEvent): void;
    protected existsAtLeastOneHeaderActionEnabled(data: Object | Array<Object>): boolean;
    protected existsAtLeastOneActionEnabled(data: T | Array<T> | Object | Array<Object>): boolean;
    private isMenuOptionEnabled;
    onRowDragEnd(event: any): void;
    protected getContextMenuColumnWidth(): number;
    protected getCheckColumnWidth(): number;
    private onBodyScroll;
    private doAutoSizeManagement;
    private updateSavedScrollState;
    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractGrid<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractGrid<any>, never, never, { "headerMenu": { "alias": "headerMenu"; "required": false; }; "menu": { "alias": "menu"; "required": false; }; "preferenceName": { "alias": "preferenceName"; "required": false; }; "multipleSelection": { "alias": "multipleSelection"; "required": false; }; "showChecks": { "alias": "showChecks"; "required": false; }; "headerCheckboxSelection": { "alias": "headerCheckboxSelection"; "required": false; }; "rowData": { "alias": "rowData"; "required": false; }; "noRowsText": { "alias": "noRowsText"; "required": false; }; "loadingText": { "alias": "loadingText"; "required": false; }; "removeSelectionOnOpenContextMenu": { "alias": "removeSelectionOnOpenContextMenu"; "required": false; }; "autoSizeColumnsToContent": { "alias": "autoSizeColumnsToContent"; "required": false; }; "autoResizableScroll": { "alias": "autoResizableScroll"; "required": false; }; }, { "action": "action"; "clickRow": "clickRow"; "rowDragEnd": "rowDragEnd"; "viewportChanged": "viewportChanged"; "rowSelected": "rowSelected"; }, never, never, true, never>;
}

declare class GridContextMenuCellRendererComponent<T> implements AgRendererComponent {
    protected container: AbstractGrid<T>;
    fontSize: string;
    fontColor: string;
    rowIndex: number;
    data: T;
    agInit(params: any): void;
    dotsClicked(event: MouseEvent): void;
    refresh(params: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<GridContextMenuCellRendererComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GridContextMenuCellRendererComponent<any>, "systelab-grid-context-menu-cell-renderer", never, {}, {}, never, never, false, never>;
}

declare class GridHeaderContextMenuComponent<T> implements IHeaderAngularComp {
    headerName: string;
    headerData: any;
    protected container: AbstractGrid<T>;
    agInit(params: IHeaderParams): void;
    refresh(params: IHeaderParams): boolean;
    dotsClicked(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GridHeaderContextMenuComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GridHeaderContextMenuComponent<any>, "systelab-grid-header-context-menu-cell-renderer", never, {}, {}, never, never, false, never>;
}

declare class GridColumnOptionsDialogParameters extends SystelabModalContext {
    width: number;
    height: number;
    columnOptions: GridColumnsOptions;
    canHideAllColumns: boolean;
}
declare class GridColumnOptionsDialog implements ModalComponent<GridColumnOptionsDialogParameters>, AfterViewInit {
    dialog: DialogRef<GridColumnOptionsDialogParameters>;
    protected i18nService: I18nService;
    gridColumnOptionsDialogParameters: GridColumnOptionsDialogParameters;
    availableColumns: Array<TwoListItem>;
    visibleColumns: Array<TwoListItem>;
    initialAvailableColumns: Array<TwoListItem>;
    private readonly canHideAllColumns;
    constructor(dialog: DialogRef<GridColumnOptionsDialogParameters>, i18nService: I18nService);
    isSubmitDisabled(): boolean;
    submit(): void;
    close(): void;
    static getParameters(): GridColumnOptionsDialogParameters;
    getTabTitle(code: string): string;
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GridColumnOptionsDialog, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GridColumnOptionsDialog, "grid-column-options-dialog", never, {}, {}, never, never, false, never>;
}

declare class ComboBoxInputRenderer {
    selectedData: any;
    initialParams: any;
    private _id;
    set id(value: number | string);
    get id(): number | string;
    private _description;
    set description(value: string);
    get description(): string;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<ComboBoxInputRenderer, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ComboBoxInputRenderer, never, never, { "selectedData": { "alias": "selectedData"; "required": false; }; "initialParams": { "alias": "initialParams"; "required": false; }; "id": { "alias": "id"; "required": false; }; "description": { "alias": "description"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ColorCellRendererComponent extends ComboBoxInputRenderer implements AgRendererComponent, AfterViewInit {
    agGridParams: any;
    border: string;
    agInit(params: any): void;
    refresh(params: any): boolean;
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ColorCellRendererComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ColorCellRendererComponent, "systelab-cell-colorpicker", never, {}, {}, never, never, false, never>;
}

declare class ComboTreeNode<T> {
    nodeData: T;
    level: number;
    description?: string;
    constructor(pNodeData?: T, pLevel?: number);
}
declare abstract class AbstractApiTreeComboBox<T> extends AbstractComboBox<ComboTreeNode<T>> implements AgRendererComponent, OnInit, OnDestroy {
    myRenderer: Renderer2;
    chref: ChangeDetectorRef;
    preferencesService?: PreferencesService;
    static readonly FAVOURITEID = "favourite";
    isParentSelectable: boolean;
    isAllSelectable: boolean;
    totalItemsLoaded: boolean;
    isFirstTime: boolean;
    isTree: boolean;
    modelUpdated: boolean;
    protected constructor(myRenderer: Renderer2, chref: ChangeDetectorRef, preferencesService?: PreferencesService);
    ngOnInit(): void;
    protected configGrid(): void;
    getInstance(): ComboTreeNode<T>;
    getDescriptionField(level?: any): string;
    getCodeField(level?: any): string;
    getIdField(level?: any): string;
    abstract getData(): Observable<Array<T>>;
    abstract getTotalItems(): number;
    abstract getLevelDescriptionField(level: number): string;
    abstract getLevelIdField(level: number): string;
    abstract getAllNodeId(): string | number;
    abstract getAllNodeDescription(): string;
    abstract getSelectionPrefix(level: number): string;
    protected getFavouriteText(): string;
    getLabelForLevel(comboTreeNode: ComboTreeNode<T>): string;
    closeDropDown(): void;
    doGridReady(event: GridReadyEvent): void;
    onModelUpdated(): void;
    setDropdownHeight(items?: number): void;
    getRows(): Observable<ComboTreeNode<T>[]>;
    protected checkIfIsFavourite(id: string | number): void;
    protected toggleFavourite(): void;
    onRowSelected(event: any): void;
    protected addRemoveToMultipleSelectedItem(event: any): void;
    protected selectUnselectChildTree(event: any): void;
    protected selectUnselectParentTree(event: any): void;
    onSelectionChanged(event: any): void;
    refresh(params: any): boolean;
    private getFavouriteElements;
    protected getRowNodeId(item: GetRowIdParams | ComboTreeNode<ComboTreeNode<T>>): string | number | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractApiTreeComboBox<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractApiTreeComboBox<any>, never, never, { "isParentSelectable": { "alias": "isParentSelectable"; "required": false; }; "isAllSelectable": { "alias": "isAllSelectable"; "required": false; }; }, {}, never, never, true, never>;
}

declare abstract class AbstractComboBox<T> implements AgRendererComponent, OnInit, OnDestroy {
    myRenderer: Renderer2;
    chRef: ChangeDetectorRef;
    preferencesService?: PreferencesService;
    static ROW_HEIGHT: number;
    static DROPDOWN_MENU_MARGIN: number;
    input: ElementRef;
    filterInput: ElementRef;
    comboId: string;
    customInputRenderer: any;
    initialParams: any;
    filter: boolean;
    multipleSelection: boolean;
    listSelectedValues: boolean;
    allElement: boolean;
    rowData: any;
    fontFamily: string;
    fontSize: string;
    fontWeight: string;
    fontStyle: string;
    withIcon: boolean;
    withDeleteOption: boolean;
    defaultIdValue: string | number;
    defaultDescription: string;
    defaultCode: string;
    iconClass: string;
    inputColor: string;
    iconColor: string;
    tabindex: number;
    deleteIconClass: string;
    withEmptyValue: boolean;
    iconSide: string;
    getAllFieldIDValue(): string | number;
    getAllFieldDescriptionValue(): string;
    getAllCodeFieldValue(): string;
    getAllInstance(): T;
    _values: Array<any>;
    set values(newValues: Array<any>);
    get values(): Array<any>;
    isDisabled: boolean;
    expandToParentContainerHeight: boolean;
    change: EventEmitter<any>;
    idChange: EventEmitter<any>;
    descriptionChange: EventEmitter<any>;
    levelChange: EventEmitter<any>;
    allowEditInput: boolean;
    emptyElement: boolean;
    selectDeselectAll: boolean;
    withFavourites: boolean;
    preferenceName: string;
    isFavourite: boolean;
    favouriteList: Array<string | number>;
    isTree: boolean;
    _id: number | string;
    set id(value: number | string);
    get id(): number | string;
    _description: string;
    set description(value: string);
    get description(): string;
    _level: number;
    set level(value: number);
    get level(): number;
    _fieldToShow: string;
    set fieldToShow(value: string);
    get fieldToShow(): string;
    fieldToShowChange: EventEmitter<any>;
    _code: string;
    set code(value: string);
    get code(): string;
    codeChange: EventEmitter<any>;
    _multipleSelectedItemList: Array<T>;
    set multipleSelectedItemList(value: Array<T>);
    get multipleSelectedItemList(): Array<T>;
    multipleSelectedItemListChange: EventEmitter<any>;
    multipleSelectedIDListChange: EventEmitter<any>;
    selectedItemChange: EventEmitter<any>;
    comboboxElement: ElementRef;
    dropdownToogleElement: ElementRef;
    dropdownMenuElement: ElementRef;
    dropdownElement: ElementRef;
    inputElement: ElementRef;
    hiddenElement: ElementRef;
    filterValue: string;
    currentSelected: any;
    selectionChanged: boolean;
    gridOptions: GridOptions;
    gridApi: GridApi;
    columnDefs: Array<any>;
    params: any;
    top: number;
    left: number;
    windowResized: boolean;
    isDropdownOpened: boolean;
    windowScrollHandler: any;
    private calculatedGridState;
    private scrollTimeout;
    constructor(myRenderer: Renderer2, chRef: ChangeDetectorRef, preferencesService?: PreferencesService);
    ngOnInit(): void;
    private setStyle;
    protected setDescriptionAndCodeWhenMultiple(value: Array<T>): void;
    protected initializeFavouriteList(): void;
    protected configGrid(): void;
    protected getRowNodeId(item: GetRowIdParams | ComboTreeNode<T>): string | number | undefined;
    protected configGridData(): void;
    protected setRowHeight(): void;
    abstract getInstance(): T;
    abstract getDescriptionField(): string;
    abstract getCodeField(): string;
    abstract getIdField(): string;
    refresh(params: any): boolean;
    agInit(params: any): void;
    getInputHeight(): {
        height: string;
    };
    protected getComboPreferencesPrefix(): string;
    doToggleFavourite(event: MouseEvent): void;
    deleteValueSelected(event: MouseEvent): void;
    onComboClicked(event: any): void;
    onComboKeyArrowDown(event: any): void;
    onComboKeyArrowUp(event: any): void;
    protected toggleFavourite(): void;
    setDropdownWidth(): void;
    isDropDownOpen(): boolean;
    closeDropDown(): void;
    resetDropDownPositionAndHeight(): void;
    loop(): void;
    protected transferFocusToGrid(): void;
    onCellKeyDown(e: any): void;
    showDropDown(): void;
    clickDropDownMenu(e: Event): void;
    setDropdownHeight(): void;
    protected getTotalItemsInCombo(): number;
    protected getTotalItemsForDropdownHeight(): number;
    setDropdownPosition(): void;
    getSelectedRow(): T;
    doSearch(event: any): void;
    doFilter(): void;
    doSelectAll(): void;
    doDeselectAll(): void;
    onSelectionChanged(event: any): void;
    protected checkIfIsFavourite(id: string | number): void;
    onModelUpdated(): void;
    setGridSize(): void;
    onRowSelected(event: RowSelectedEvent): void;
    private unselectAllNodesInGridOptions;
    private unselectNodeAllInGridOptions;
    setCodeDescriptionById(): void;
    onResize(): void;
    protected isComboBoxScrolling(element: HTMLElement): boolean;
    protected scroll(event: any): void;
    protected addWindowScrollHandler(): void;
    protected removeWindowScrollHandler(): void;
    protected addGridScrollHandler(): void;
    protected removeGridScrollHandler(): void;
    ngOnDestroy(): void;
    removeItem(item: T): void;
    private selectionItemListToIDList;
    checkMultipleSelectionClosed(): void;
    doGridReady(event: GridReadyEvent): void;
    private onBodyScroll;
    protected doAutoSizeManagement(event?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractComboBox<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractComboBox<any>, never, never, { "customInputRenderer": { "alias": "customInputRenderer"; "required": false; }; "initialParams": { "alias": "initialParams"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "multipleSelection": { "alias": "multipleSelection"; "required": false; }; "listSelectedValues": { "alias": "listSelectedValues"; "required": false; }; "allElement": { "alias": "allElement"; "required": false; }; "rowData": { "alias": "rowData"; "required": false; }; "fontFamily": { "alias": "fontFamily"; "required": false; }; "fontSize": { "alias": "fontSize"; "required": false; }; "fontWeight": { "alias": "fontWeight"; "required": false; }; "fontStyle": { "alias": "fontStyle"; "required": false; }; "withIcon": { "alias": "withIcon"; "required": false; }; "withDeleteOption": { "alias": "withDeleteOption"; "required": false; }; "defaultIdValue": { "alias": "defaultIdValue"; "required": false; }; "defaultDescription": { "alias": "defaultDescription"; "required": false; }; "defaultCode": { "alias": "defaultCode"; "required": false; }; "iconClass": { "alias": "iconClass"; "required": false; }; "inputColor": { "alias": "inputColor"; "required": false; }; "iconColor": { "alias": "iconColor"; "required": false; }; "tabindex": { "alias": "tabindex"; "required": false; }; "deleteIconClass": { "alias": "deleteIconClass"; "required": false; }; "withEmptyValue": { "alias": "withEmptyValue"; "required": false; }; "iconSide": { "alias": "iconSide"; "required": false; }; "values": { "alias": "values"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "expandToParentContainerHeight": { "alias": "expandToParentContainerHeight"; "required": false; }; "allowEditInput": { "alias": "allowEditInput"; "required": false; }; "emptyElement": { "alias": "emptyElement"; "required": false; }; "selectDeselectAll": { "alias": "selectDeselectAll"; "required": false; }; "withFavourites": { "alias": "withFavourites"; "required": false; }; "preferenceName": { "alias": "preferenceName"; "required": false; }; "id": { "alias": "id"; "required": false; }; "description": { "alias": "description"; "required": false; }; "level": { "alias": "level"; "required": false; }; "fieldToShow": { "alias": "fieldToShow"; "required": false; }; "code": { "alias": "code"; "required": false; }; "multipleSelectedItemList": { "alias": "multipleSelectedItemList"; "required": false; }; }, { "change": "change"; "idChange": "idChange"; "descriptionChange": "descriptionChange"; "levelChange": "levelChange"; "fieldToShowChange": "fieldToShowChange"; "codeChange": "codeChange"; "multipleSelectedItemListChange": "multipleSelectedItemListChange"; "multipleSelectedIDListChange": "multipleSelectedIDListChange"; "selectedItemChange": "selectedItemChange"; }, never, never, true, never>;
}

declare class ColorComboBox extends AbstractComboBox<ComboBoxInputRenderer> implements OnInit {
    myRenderer: Renderer2;
    constructor(myRenderer: Renderer2, chRef: ChangeDetectorRef);
    ngOnInit(): void;
    getInstance(): ComboBoxInputRenderer;
    getDescriptionField(): string;
    getCodeField(): string;
    getIdField(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ColorComboBox, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ColorComboBox, "systelab-colorpicker", never, {}, {}, never, never, false, never>;
}

declare class ApplicationHeaderMenuEntry {
    optionName: string;
    isDivider: boolean;
    action?: any;
    constructor(optionName: string, isDivider: boolean, action?: any);
}
declare class ApplicationHeaderComponent {
    protected dialogService: DialogService;
    userName: string;
    userFullName: string;
    title: string;
    logoIcon: string;
    menuBars: boolean;
    menu: ApplicationHeaderMenuEntry[];
    constructor(dialogService: DialogService);
    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ApplicationHeaderComponent, "systelab-app-header", never, { "userName": { "alias": "userName"; "required": false; }; "userFullName": { "alias": "userFullName"; "required": false; }; "title": { "alias": "title"; "required": false; }; "logoIcon": { "alias": "logoIcon"; "required": false; }; "menuBars": { "alias": "menuBars"; "required": false; }; "menu": { "alias": "menu"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class ApplicationSidebarTab {
    id: string;
    name: string;
    isSelected: boolean;
    subMenu?: ApplicationSidebarTab[];
    action?: (id: string) => void;
    icon?: string;
    constructor(id: string, name: string, isSelected: boolean, subMenu?: ApplicationSidebarTab[], action?: (id: string) => void, icon?: string);
}
declare class ApplicationSidebarAction {
    name: string;
    action: any;
    icon?: string;
    constructor(name: string, action: any, icon?: string);
}
declare class ApplicationSidebarComponent {
}

declare class ApplicationSidebarLargeComponent implements OnInit {
    actions: ApplicationSidebarAction[];
    tabs: ApplicationSidebarTab[];
    selected: EventEmitter<any>;
    constructor();
    ngOnInit(): void;
    private checkSubMenuSelected;
    selectTab(id: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationSidebarLargeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ApplicationSidebarLargeComponent, "systelab-app-sidebar-large", never, { "actions": { "alias": "actions"; "required": false; }; "tabs": { "alias": "tabs"; "required": false; }; }, { "selected": "selected"; }, never, never, false, never>;
}

declare class ApplicationSidebarSmallComponent {
    actions: ApplicationSidebarAction[];
    tabs: ApplicationSidebarTab[];
    selected: EventEmitter<any>;
    constructor();
    selectTab(id: string): void;
    executeTabAction(tab: ApplicationSidebarTab): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationSidebarSmallComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ApplicationSidebarSmallComponent, "systelab-app-sidebar-small", never, { "actions": { "alias": "actions"; "required": false; }; "tabs": { "alias": "tabs"; "required": false; }; }, { "selected": "selected"; }, never, never, false, never>;
}

declare class ApplicationFrameComponent {
    protected i18nService: I18nService;
    sidebar: ApplicationSidebarLargeComponent;
    sidebarSmall: ApplicationSidebarSmallComponent;
    userName: string;
    userFullName: string;
    title: string;
    menuBars: boolean;
    logoIcon: string;
    menu: ApplicationHeaderMenuEntry[];
    actions: ApplicationSidebarAction[];
    tabs: ApplicationSidebarTab[];
    showSideBar: boolean;
    largeSideBar: boolean;
    selected: EventEmitter<any>;
    constructor(i18nService: I18nService);
    doSelect(id: string): void;
    continueSelect(id: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationFrameComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ApplicationFrameComponent, "systelab-app-frame", never, { "userName": { "alias": "userName"; "required": false; }; "userFullName": { "alias": "userFullName"; "required": false; }; "title": { "alias": "title"; "required": false; }; "menuBars": { "alias": "menuBars"; "required": false; }; "logoIcon": { "alias": "logoIcon"; "required": false; }; "menu": { "alias": "menu"; "required": false; }; "actions": { "alias": "actions"; "required": false; }; "tabs": { "alias": "tabs"; "required": false; }; "showSideBar": { "alias": "showSideBar"; "required": false; }; "largeSideBar": { "alias": "largeSideBar"; "required": false; }; }, { "selected": "selected"; }, never, ["[header-content]", "[main-content]"], false, never>;
}

declare class ButtonComponent {
    private element;
    action: EventEmitter<any>;
    disabled: boolean;
    type: 'regular' | 'primary' | 'warning' | 'danger' | 'success' | 'link';
    size: 'small' | 'medium' | 'large';
    constructor(element: ElementRef);
    getId(): any;
    doClick(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonComponent, "systelab-button", never, { "disabled": { "alias": "disabled"; "required": false; }; "type": { "alias": "type"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, { "action": "action"; }, never, ["*"], false, never>;
}

declare class ToggleButtonComponent {
    private element;
    private checked;
    get isChecked(): boolean;
    set isChecked(val: boolean);
    isCheckedChange: EventEmitter<any>;
    disabled: boolean;
    constructor(element: ElementRef);
    getId(): any;
    doToggle(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToggleButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToggleButtonComponent, "systelab-toggle-button", never, { "isChecked": { "alias": "isChecked"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "isCheckedChange": "isCheckedChange"; }, never, ["*"], false, never>;
}

declare class Element$6 {
    id: string;
    description: string;
    constructor(id: string, description: string);
}
declare class AllYesNoSelect extends AbstractComboBox<Element$6> implements OnInit {
    chRef: ChangeDetectorRef;
    i18nService: I18nService;
    private readonly descriptionAll;
    private readonly descriptionYes;
    private readonly descriptionNo;
    constructor(myRenderer: Renderer2, chRef: ChangeDetectorRef, i18nService: I18nService);
    ngOnInit(): void;
    getInstance(): Element$6;
    getDescriptionField(): string;
    getCodeField(): string;
    getIdField(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<AllYesNoSelect, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AllYesNoSelect, "systelab-all-yes-no-select", never, {}, {}, never, never, false, never>;
}

declare class Element$5 {
    id: string;
    description: string;
    constructor(id: string, description: string);
}
declare class NoYesSelect extends AbstractComboBox<Element$5> implements AfterViewInit {
    myRenderer: Renderer2;
    chRef: ChangeDetectorRef;
    i18nService: I18nService;
    reverseValues: boolean;
    constructor(myRenderer: Renderer2, chRef: ChangeDetectorRef, i18nService: I18nService);
    ngAfterViewInit(): void;
    getInstance(): Element$5;
    getDescriptionField(): string;
    getCodeField(): string;
    getIdField(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<NoYesSelect, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NoYesSelect, "systelab-no-yes-select", never, { "reverseValues": { "alias": "reverseValues"; "required": false; }; }, {}, never, never, false, never>;
}

declare class Element$4 {
    id: string;
    description: string;
    constructor(id: string, description: string);
}
declare class PeriodSelect extends AbstractComboBox<Element$4> implements AfterViewInit {
    myRenderer: Renderer2;
    chRef: ChangeDetectorRef;
    i18nService: I18nService;
    constructor(myRenderer: Renderer2, chRef: ChangeDetectorRef, i18nService: I18nService);
    ngAfterViewInit(): void;
    getInstance(): Element$4;
    getDescriptionField(): string;
    getCodeField(): string;
    getIdField(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<PeriodSelect, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PeriodSelect, "systelab-period-select", never, {}, {}, never, never, false, never>;
}

declare class Element$3 {
    id: string;
    description: string;
    constructor(id: string, description: string);
}
declare class TimeUnitSelectComponent extends AbstractComboBox<Element$3> implements AfterViewInit {
    myRenderer: Renderer2;
    chRef: ChangeDetectorRef;
    i18nService: I18nService;
    showEmptyOption: boolean;
    showMinutesOption: boolean;
    showHoursOption: boolean;
    showWeeksOption: boolean;
    constructor(myRenderer: Renderer2, chRef: ChangeDetectorRef, i18nService: I18nService);
    ngAfterViewInit(): void;
    getInstance(): Element$3;
    getDescriptionField(): string;
    getCodeField(): string;
    getIdField(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TimeUnitSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TimeUnitSelectComponent, "systelab-time-unit-select", never, { "showEmptyOption": { "alias": "showEmptyOption"; "required": false; }; "showMinutesOption": { "alias": "showMinutesOption"; "required": false; }; "showHoursOption": { "alias": "showHoursOption"; "required": false; }; "showWeeksOption": { "alias": "showWeeksOption"; "required": false; }; }, {}, never, never, false, never>;
}

declare class Element$2 {
    id: string;
    description: string;
    constructor(id: string, description: string);
}
declare class GenderSelect extends AbstractComboBox<Element$2> implements OnInit {
    myRenderer: Renderer2;
    chRef: ChangeDetectorRef;
    i18nService: I18nService;
    showAll: boolean;
    showUnknown: boolean;
    private readonly descriptionAll;
    private readonly descriptionUnknown;
    private readonly descriptionMale;
    private readonly descriptionFemale;
    constructor(myRenderer: Renderer2, chRef: ChangeDetectorRef, i18nService: I18nService);
    ngOnInit(): void;
    getInstance(): Element$2;
    getDescriptionField(): string;
    getCodeField(): string;
    getIdField(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<GenderSelect, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GenderSelect, "systelab-gender-select", never, { "showAll": { "alias": "showAll"; "required": false; }; "showUnknown": { "alias": "showUnknown"; "required": false; }; }, {}, never, never, false, never>;
}

declare class TouchSpinValues {
    value: number;
    min: number;
    max: number;
    step: number;
    isDecimal: boolean;
    precision: number;
    constructor(value: number, min: number, max: number, step?: number, isDecimal?: boolean, precision?: number);
    getPrecision(): number;
}

declare class TouchspinComponent {
    private validKeys;
    error: boolean;
    disabled: boolean;
    fillUnitsWithZero: boolean | number;
    tabindex: number;
    private _spinValues;
    protected _valueStr: string;
    isInGrid: boolean;
    private previousValue;
    get value(): number;
    set value(val: number);
    valueChange: EventEmitter<number>;
    change: EventEmitter<any>;
    get spinValues(): TouchSpinValues;
    set spinValues(val: TouchSpinValues);
    get valueStr(): string;
    set valueStr(val: string);
    valueStrChange: EventEmitter<string>;
    minus(): void;
    plus(): void;
    doCheckKey(event: KeyboardEvent): boolean;
    doKeyDown(event: KeyboardEvent): void;
    checkValue(valueStr: string): void;
    private saveValueAndEmit;
    static ɵfac: i0.ɵɵFactoryDeclaration<TouchspinComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TouchspinComponent, "systelab-spinner", never, { "error": { "alias": "error"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "fillUnitsWithZero": { "alias": "fillUnitsWithZero"; "required": false; }; "tabindex": { "alias": "tabindex"; "required": false; }; "isInGrid": { "alias": "isInGrid"; "required": false; }; "value": { "alias": "value"; "required": false; }; "spinValues": { "alias": "spinValues"; "required": false; }; "valueStr": { "alias": "valueStr"; "required": false; }; }, { "valueChange": "valueChange"; "change": "change"; "valueStrChange": "valueStrChange"; }, never, never, false, never>;
}

declare class Element$1 {
    id: string;
    description: string;
    constructor(id: string, description: string);
}
declare class ModulabSelect extends AbstractComboBox<Element$1> {
    myRenderer: Renderer2;
    chRef: ChangeDetectorRef;
    preferencesService?: PreferencesService;
    constructor(myRenderer: Renderer2, chRef: ChangeDetectorRef, preferencesService?: PreferencesService);
    getInstance(): Element$1;
    getDescriptionField(): string;
    getCodeField(): string;
    getIdField(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModulabSelect, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModulabSelect, "systelab-select", never, {}, {}, never, never, false, never>;
}

declare class DataTransformerService {
    processShortcuts(date: string, fromDateForRelative: Date): Date;
    infereDate(date: string, dateFormat: string): Date;
    private getDayLength;
    private getFormattedDate;
    private checkMonthNumber;
    private checkDayNumber;
    private getDateSeparator;
    private removeSeparator;
    static ɵfac: i0.ɵɵFactoryDeclaration<DataTransformerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DataTransformerService>;
}

declare class DatepickerComponent implements OnInit, AfterViewInit, DoCheck {
    protected myRenderer: Renderer2;
    protected i18nService: I18nService;
    protected dataTransformerService: DataTransformerService;
    protected config: PrimeNG;
    disabled: boolean;
    error: boolean;
    required: boolean;
    inputExpandHeight: boolean;
    markPreviousAfterDate: boolean;
    inputFontSize: number;
    showTodayButton: boolean;
    inline: boolean;
    minDate: Date;
    maxDate: Date;
    warnDaysBefore: number;
    warnDaysAfter: number;
    autofocus: boolean;
    fromDateForRelativeDates: Date;
    tabindex: number;
    withIntegratedTime: boolean;
    onlyTime: boolean;
    showOtherMonths: boolean;
    selectOtherMonths: boolean;
    dateFormat: string;
    keepInvalid: boolean;
    get currentDate(): Date;
    set currentDate(value: Date);
    currentDateChange: EventEmitter<Date>;
    currentCalendar: DatePicker;
    inputChanged: boolean;
    protected _currentDate: Date;
    previousAfterDate: boolean;
    tooFarDate: boolean;
    language: any;
    currentDocSize: number;
    currentLanguage: string;
    inputElement: ElementRef;
    focusEvt: FocusEvent;
    isTablet: boolean;
    datepickerId: string;
    formatError: boolean;
    private headerElement;
    constructor(myRenderer: Renderer2, i18nService: I18nService, dataTransformerService: DataTransformerService, config: PrimeNG);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    private addIconToDatepicker;
    ngDoCheck(): void;
    selectDate(): void;
    changeDate(): void;
    private parseTime;
    private infereDate;
    onInput(event: KeyboardEvent): void;
    saveEventOnFocus(evt: FocusEvent): void;
    repositionateCalendar(element?: ElementRef): void;
    nextMonth(): void;
    prevMonth(): void;
    nextYear(): void;
    prevYear(): void;
    clearDate(event: any): void;
    setTodayDate(): void;
    closeDatepicker(): void;
    private checkPreviousAfterDate;
    private checkTooFarDate;
    private getLanguage;
    static ɵfac: i0.ɵɵFactoryDeclaration<DatepickerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DatepickerComponent, "systelab-datepicker", never, { "disabled": { "alias": "disabled"; "required": false; }; "error": { "alias": "error"; "required": false; }; "required": { "alias": "required"; "required": false; }; "inputExpandHeight": { "alias": "inputExpandHeight"; "required": false; }; "markPreviousAfterDate": { "alias": "markPreviousAfterDate"; "required": false; }; "inputFontSize": { "alias": "inputFontSize"; "required": false; }; "showTodayButton": { "alias": "showTodayButton"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "warnDaysBefore": { "alias": "warnDaysBefore"; "required": false; }; "warnDaysAfter": { "alias": "warnDaysAfter"; "required": false; }; "autofocus": { "alias": "autofocus"; "required": false; }; "fromDateForRelativeDates": { "alias": "fromDateForRelativeDates"; "required": false; }; "tabindex": { "alias": "tabindex"; "required": false; }; "withIntegratedTime": { "alias": "withIntegratedTime"; "required": false; }; "onlyTime": { "alias": "onlyTime"; "required": false; }; "showOtherMonths": { "alias": "showOtherMonths"; "required": false; }; "selectOtherMonths": { "alias": "selectOtherMonths"; "required": false; }; "dateFormat": { "alias": "dateFormat"; "required": false; }; "keepInvalid": { "alias": "keepInvalid"; "required": false; }; "currentDate": { "alias": "currentDate"; "required": false; }; }, { "currentDateChange": "currentDateChange"; }, never, never, false, never>;
}

declare class DatepickerTimeComponent extends DatepickerComponent {
    get currentDate(): Date;
    resetTimeWhenChangingCurrentDate: boolean;
    showCalendar: boolean;
    touchSpinHourValues: TouchSpinValues;
    touchSpinMinutesValues: TouchSpinValues;
    constructor(myRenderer: Renderer2, i18nService: I18nService, dataTransformerService: DataTransformerService, config: PrimeNG);
    set currentDate(value: Date);
    currentHoursChanged(value: number): void;
    currentMinutesChanged(value: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DatepickerTimeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DatepickerTimeComponent, "systelab-date-time", never, { "currentDate": { "alias": "currentDate"; "required": false; }; "resetTimeWhenChangingCurrentDate": { "alias": "resetTimeWhenChangingCurrentDate"; "required": false; }; "showCalendar": { "alias": "showCalendar"; "required": false; }; }, {}, never, never, false, never>;
}

declare class SearcherDialogParameters<T> extends SystelabModalContext {
    valueToSearch: string;
    searcher: AbstractSearcher<T>;
    showCloseButton: boolean;
    showSelectedRowsInSubmitButton: boolean;
    isTeeSearcher: boolean;
    debounceTime: number;
    searchByStartWithAsDefault: boolean;
}

declare abstract class AbstractSearcher<T> {
    id: number | string;
    multipleSelectedItemList: Array<T>;
    multipleSelection: boolean;
    treeSearcher: boolean;
    parentSelectable: boolean;
    useIdInMultipleSelectionGrid: boolean;
    protected constructor();
    abstract getDialogParameters(): SearcherDialogParameters<T>;
    abstract getData(valueToSearch: string, page: number, pageNumber: number, useCode?: boolean): Observable<Array<T>>;
    abstract getTotalItems(): number;
    abstract getColumnDefs(): Array<any>;
    hideHeader(): boolean;
    getPropertyToShow(): string;
    abstract getIdField(): string;
    abstract getCodeField(): string;
    abstract getDescriptionField(): string;
    abstract getTextForSearcherLabel(): string;
    abstract getTitleForDialog(): string;
    abstract getGridOptionsPreferencesPrefix(): string;
    getIsFullWidthRow(isFullWidthRowParams: IsFullWidthRowParams): boolean;
    getFullWidthCellRenderer(): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractSearcher<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractSearcher<any>, never, never, {}, {}, never, never, true, never>;
}

declare abstract class AbstractApiGrid<T> extends AbstractGrid<T> implements IDatasource {
    protected preferencesService: PreferencesService;
    protected i18nService: I18nService;
    protected dialogService: DialogService;
    constructor(preferencesService: PreferencesService, i18nService: I18nService, dialogService: DialogService);
    protected getInitialGridOptions(): GridOptions;
    abstract getTotalItems(): number;
    doGridReady(event: any): void;
    protected abstract getData(page: number, itemsPerPage: number): Observable<Array<T>>;
    getRows(params: IGetRowsParams): void;
    protected putPage(page: Array<T>, totalItems: number, params: IGetRowsParams): void;
    refresh(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractApiGrid<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractApiGrid<any>, never, never, {}, {}, never, never, true, never>;
}

declare class SearcherTableComponent<T> extends AbstractApiGrid<T> implements OnInit {
    protected preferencesService: PreferencesService;
    protected i18nService: I18nService;
    protected dialogService: DialogService;
    valueForSearch: string;
    searchForContain: boolean;
    searcher: AbstractSearcher<T>;
    gridReady: EventEmitter<boolean>;
    constructor(preferencesService: PreferencesService, i18nService: I18nService, dialogService: DialogService);
    ngOnInit(): void;
    protected getColumnDefs(): Array<any>;
    protected hideHeader(): boolean;
    doGridReady(event: any): void;
    protected getIsFullWidthRow(isFullWidthRowParams: IsFullWidthRowParams): boolean;
    getFullWidthCellRenderer(): any;
    protected getContextMenuOptions(): Array<any>;
    getTotalItems(): number;
    protected getData(page: number, itemsPerPage: number): Observable<Array<T>>;
    refreshTable(): void;
    focusFirstRow(): void;
    getSelectedElements(): Array<T>;
    protected getGridOptionsPreferencesPrefix(): string;
    onModelUpdated(event: any): void;
    private getSelectionField;
    onRowSelected(event: RowSelectedEvent): void;
    private addElementToMultipleSelectedItemList;
    private onEnterPressedCallback;
    static ɵfac: i0.ɵɵFactoryDeclaration<SearcherTableComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SearcherTableComponent<any>, "systelab-internal-searcher-table", never, { "valueForSearch": { "alias": "valueForSearch"; "required": false; }; "searchForContain": { "alias": "contains"; "required": false; }; "searcher": { "alias": "searcher"; "required": false; }; }, { "gridReady": "gridReady"; }, never, never, false, never>;
}

declare class SearcherDialog<T> implements ModalComponent<SearcherDialogParameters<T>>, AfterViewInit {
    dialog: DialogRef<SearcherDialogParameters<T>>;
    protected i18nService: I18nService;
    tableComponent: SearcherTableComponent<T>;
    valueToSearchInput: ElementRef;
    parameters: SearcherDialogParameters<T>;
    searchingValue: string;
    searchLabel: string;
    titleForDialog: string;
    multipleSelection: boolean;
    showClose: boolean;
    searchByContains: boolean;
    constructor(dialog: DialogRef<SearcherDialogParameters<T>>, i18nService: I18nService);
    ngAfterViewInit(): void;
    setFocusToInput(): void;
    close(): void;
    submit(): void;
    setFocusToGrid(event: KeyboardEvent): void;
    refreshSearch(): void;
    selectOnClick(data: T): void;
    getSelectedElements(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SearcherDialog<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SearcherDialog<any>, "systelab-searcher-dialog", never, {}, {}, never, never, false, never>;
}

interface DaySlot {
    date?: Date;
    day: number;
    isHoliday: boolean;
}
declare class CalendarTableComponent implements OnChanges {
    protected i18nService: I18nService;
    currentDate: Date;
    days: DaySlot[];
    useLongDays: boolean;
    templateRef: TemplateRef<any>;
    language: any;
    daysHeader: string[];
    rows: DaySlot[][];
    constructor(i18nService: I18nService);
    ngOnChanges(): void;
    refresh(): void;
    protected defineHeaderDays(): void;
    protected getLanguage(): void;
    private generateDays;
    private putDaySlotsIntoArray;
    private getLoadDay;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarTableComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarTableComponent, "systelab-calendar-table", never, { "currentDate": { "alias": "currentDate"; "required": false; }; "days": { "alias": "days"; "required": false; }; "useLongDays": { "alias": "useLongDays"; "required": false; }; }, {}, ["templateRef"], never, false, never>;
}

declare class CalendarDialogParameters extends SystelabModalContext {
    width: number;
    height: number;
    headerDescription: string;
}
declare class CalendarDialog implements ModalComponent<CalendarDialogParameters> {
    dialog: DialogRef<CalendarDialogParameters>;
    private i18nService;
    calendar: CalendarTableComponent;
    parameters: CalendarDialogParameters;
    currentDate: Date;
    days: DaySlot[];
    constructor(dialog: DialogRef<CalendarDialogParameters>, i18nService: I18nService);
    static getParameters(): CalendarDialogParameters;
    close(): void;
    selectDaySlot(daySlot: DaySlot): void;
    doSomething(data: any): void;
    changeYear(yearFactor: number): void;
    changeMonth(monthFactor: number): void;
    private getData;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarDialog, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarDialog, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class CalendarHeaderComponent {
    private i18nService;
    currentDate: Date;
    previousYear: EventEmitter<any>;
    previousMonth: EventEmitter<any>;
    nextMonth: EventEmitter<any>;
    nextYear: EventEmitter<any>;
    constructor(i18nService: I18nService);
    doPreviousYear(): void;
    doPreviousMonth(): void;
    doNextMonth(): void;
    doNextYear(): void;
    getTitle(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarHeaderComponent, "systelab-calendar-header", never, { "currentDate": { "alias": "currentDate"; "required": false; }; }, { "previousYear": "previousYear"; "previousMonth": "previousMonth"; "nextMonth": "nextMonth"; "nextYear": "nextYear"; }, never, never, false, never>;
}

declare class CalendarFooterComponent {
    private i18nService;
    currentDate: Date;
    onClearDate: EventEmitter<void>;
    constructor(i18nService: I18nService);
    clearDate(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarFooterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarFooterComponent, "systelab-calendar-footer", never, { "currentDate": { "alias": "currentDate"; "required": false; }; }, { "onClearDate": "onClearDate"; }, never, never, false, never>;
}

declare class TabComponent {
    protected elementRef: ElementRef;
    title: string;
    titleHtml: string;
    active: boolean;
    id: string;
    warning: boolean;
    constructor(elementRef: ElementRef);
    setVisible(visible: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TabComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TabComponent, "systelab-tab", never, { "title": { "alias": "title"; "required": false; }; "titleHtml": { "alias": "titleHtml"; "required": false; }; "active": { "alias": "active"; "required": false; }; "id": { "alias": "id"; "required": false; }; "warning": { "alias": "warning"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class TabsComponent implements AfterContentInit {
    tabs: QueryList<TabComponent>;
    showTabBackground: boolean;
    shrink: boolean;
    paintFocus: boolean;
    select: EventEmitter<string>;
    ngAfterContentInit(): void;
    doSelectTab(tab: TabComponent): void;
    doSelectTabById(tabId: string): void;
    private selectTab;
    private deactivateAllTabs;
    doKeyDown(event: KeyboardEvent, tab: TabComponent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TabsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TabsComponent, "systelab-tabs", never, { "showTabBackground": { "alias": "showTabBackground"; "required": false; }; "shrink": { "alias": "shrink"; "required": false; }; "paintFocus": { "alias": "paintFocus"; "required": false; }; }, { "select": "select"; }, ["tabs"], ["*"], false, never>;
}

declare class DialogHeaderComponent implements AfterViewInit {
    private config;
    withClose: boolean;
    withInfo: boolean;
    withProgressBar: boolean;
    withTextProgressBar: boolean;
    withHome: boolean;
    withMinimize: boolean;
    withDrag: boolean;
    close: EventEmitter<any>;
    info: EventEmitter<any>;
    home: EventEmitter<any>;
    minimize: EventEmitter<any>;
    textProgress: string;
    progress: number;
    private on;
    private here;
    constructor(config: AppConfig);
    ngAfterViewInit(): void;
    doClose(): void;
    doInfo(): void;
    doHome(): void;
    doMinimize(): void;
    go(n: number, textProgress?: string): void;
    private move;
    private place;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogHeaderComponent, [{ optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogHeaderComponent, "systelab-dialog-header", never, { "withClose": { "alias": "withClose"; "required": false; }; "withInfo": { "alias": "withInfo"; "required": false; }; "withProgressBar": { "alias": "withProgressBar"; "required": false; }; "withTextProgressBar": { "alias": "withTextProgressBar"; "required": false; }; "withHome": { "alias": "withHome"; "required": false; }; "withMinimize": { "alias": "withMinimize"; "required": false; }; "withDrag": { "alias": "withDrag"; "required": false; }; }, { "close": "close"; "info": "info"; "home": "home"; "minimize": "minimize"; }, never, ["*"], false, never>;
}

declare class DialogBottomComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogBottomComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogBottomComponent, "systelab-dialog-bottom", never, {}, {}, never, ["*"], false, never>;
}

declare class LoadingComponent {
    useClassic: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LoadingComponent, "systelab-loading", never, { "useClassic": { "alias": "useClassic"; "required": false; }; }, {}, never, never, false, never>;
}

declare class FileSelectorComponent {
    private _fileName;
    private _file;
    private _fileList;
    fileNameChange: EventEmitter<string>;
    fileChange: EventEmitter<File>;
    fileListChange: EventEmitter<FileList>;
    showButtonOnDisable: boolean;
    multipleSelection: boolean;
    disabled: boolean;
    get fileName(): string;
    set fileName(name: string);
    get file(): File;
    set file(file: File);
    get fileList(): FileList;
    set fileList(fileList: FileList);
    selectFile(files: FileList): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileSelectorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FileSelectorComponent, "systelab-file-selector", never, { "showButtonOnDisable": { "alias": "showButtonOnDisable"; "required": false; }; "multipleSelection": { "alias": "multipleSelection"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "fileName": { "alias": "fileName"; "required": false; }; "file": { "alias": "file"; "required": false; }; "fileList": { "alias": "fileList"; "required": false; }; }, { "fileNameChange": "fileNameChange"; "fileChange": "fileChange"; "fileListChange": "fileListChange"; }, never, never, false, never>;
}

declare class TimelineEvent {
    title: string;
    publishingDate: Date;
    text: string;
    inverted: boolean;
    icon: string;
    extraText: string;
    richExtraText: string;
    data: Object;
    color: string;
    constructor(title: string, publishingDate: Date, text: string);
    getIcon(): string;
    getColor(): string;
}
declare class TimelineComponent {
    protected i18nService: I18nService;
    events: TimelineEvent[];
    timelineClick: EventEmitter<TimelineEvent>;
    constructor(i18nService: I18nService);
    getPrintableDate(event: TimelineEvent): string;
    doClick(timelineEvent: TimelineEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TimelineComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TimelineComponent, "systelab-timeline", never, { "events": { "alias": "events"; "required": false; }; }, { "timelineClick": "timelineClick"; }, never, never, false, never>;
}

declare class ComboBoxInputRendererComponent implements OnChanges, AfterViewInit, OnDestroy {
    componentFactoryResolver: ComponentFactoryResolver;
    target: any;
    componentType: any;
    id: number | string;
    description: string;
    selectedData: any;
    initialParams: any;
    cmpRef: ComponentRef<ComboBoxInputRenderer>;
    private isViewInitialized;
    constructor(componentFactoryResolver: ComponentFactoryResolver);
    ngOnChanges(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private updateComponent;
    private updateComponentInputs;
    static ɵfac: i0.ɵɵFactoryDeclaration<ComboBoxInputRendererComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ComboBoxInputRendererComponent, "combobox-input-renderer", never, { "componentType": { "alias": "componentType"; "required": false; }; "id": { "alias": "id"; "required": false; }; "description": { "alias": "description"; "required": false; }; "selectedData": { "alias": "selectedData"; "required": false; }; "initialParams": { "alias": "initialParams"; "required": false; }; }, {}, never, never, false, never>;
}

declare class NavbarItem {
    id: number;
    text: string;
    image: string;
    floatImage: boolean;
    isSelected: boolean;
    isEnabled: boolean;
    action: any;
    target?: string;
    url?: string;
    backgroundColor?: string;
    fontColor?: string;
    constructor(id: number, text: string, image: string, floatImage: boolean, isSelected: boolean, isEnabled: boolean, action: any, target?: string, url?: string, backgroundColor?: string, fontColor?: string);
}
declare class NavbarComponent {
    items: NavbarItem[];
    isVertical: boolean;
    backgroundColor: any;
    backgroundHoverColor: string;
    borderColor: string;
    activeColor: string;
    activeFontColor: string;
    fontHoverColor: string;
    fontColor: string;
    align: string;
    id: string;
    hideBottomBorder: boolean;
    hideTopBorder: boolean;
    hideRightBorder: boolean;
    hideLeftBorder: boolean;
    padding: string;
    hovered: number;
    constructor();
    noop(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NavbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NavbarComponent, "systelab-navbar", never, { "items": { "alias": "items"; "required": false; }; "isVertical": { "alias": "isVertical"; "required": false; }; "backgroundColor": { "alias": "backgroundColor"; "required": false; }; "backgroundHoverColor": { "alias": "backgroundHoverColor"; "required": false; }; "borderColor": { "alias": "borderColor"; "required": false; }; "activeColor": { "alias": "activeColor"; "required": false; }; "activeFontColor": { "alias": "activeFontColor"; "required": false; }; "fontHoverColor": { "alias": "fontHoverColor"; "required": false; }; "fontColor": { "alias": "fontColor"; "required": false; }; "align": { "alias": "align"; "required": false; }; "id": { "alias": "id"; "required": false; }; "hideBottomBorder": { "alias": "hideBottomBorder"; "required": false; }; "hideTopBorder": { "alias": "hideTopBorder"; "required": false; }; "hideRightBorder": { "alias": "hideRightBorder"; "required": false; }; "hideLeftBorder": { "alias": "hideLeftBorder"; "required": false; }; "padding": { "alias": "padding"; "required": false; }; }, {}, never, never, false, never>;
}

declare class BreadcrumbSubItem {
    id: string;
    text: string;
    action: any;
    url?: string;
    constructor(id: string, text: string, action: any, url?: string);
}
declare class BreadcrumbItem {
    id: string;
    text: string;
    isActive: boolean;
    action: any;
    subItems?: BreadcrumbSubItem[];
    url?: string;
    constructor(id: string, text: string, isActive: boolean, action: any, subItems?: BreadcrumbSubItem[], url?: string);
}
declare class BreadcrumbComponent {
    items: BreadcrumbItem[];
    backgroundColor: string;
    fontColor: string;
    itemMaxWidth: string;
    subItemMaxWidth: string;
    constructor();
    noop(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BreadcrumbComponent, "systelab-breadcrumb", never, { "items": { "alias": "items"; "required": false; }; "backgroundColor": { "alias": "backgroundColor"; "required": false; }; "fontColor": { "alias": "fontColor"; "required": false; }; "itemMaxWidth": { "alias": "itemMaxWidth"; "required": false; }; "subItemMaxWidth": { "alias": "subItemMaxWidth"; "required": false; }; }, {}, never, never, false, never>;
}

declare class Month {
    month: number;
    text: string;
    year: number;
    isActive: boolean;
    constructor(month: number, text: string, year: number, isActive: boolean);
}
declare class MonthSelectorComponent implements OnInit {
    private i18nService;
    maxDate: Date;
    minDate: Date;
    currentDate: Date;
    disabled: boolean;
    private _selectedMonth;
    get selectedMonth(): Month;
    selectedMonthChange: EventEmitter<any>;
    set selectedMonth(value: Month);
    months: Array<Month>;
    isOpened: boolean;
    monthNames: any[];
    constructor(i18nService: I18nService);
    ngOnInit(): void;
    setMonthsNames(year: number): void;
    onClicked(e: any): void;
    hideSelector(): void;
    getMonths(): void;
    addYear(num: number): void;
    checkDateIntoIntervals(date: Date): boolean;
    onClickedMonth(month: Month): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonthSelectorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MonthSelectorComponent, "systelab-month-selector", never, { "maxDate": { "alias": "maxDate"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "currentDate": { "alias": "currentDate"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "selectedMonth": { "alias": "selectedMonth"; "required": false; }; }, { "selectedMonthChange": "selectedMonthChange"; }, never, never, false, never>;
}

declare class Week {
    week: number;
    text: string;
    day: number;
    month: number;
    year: number;
    isActive: boolean;
    constructor(week: number, text: string, day: number, month: number, year: number, isActive: boolean);
}
declare class WeekSelectorComponent implements OnInit {
    private i18nService;
    maxDate: Date;
    minDate: Date;
    currentDate: Date;
    disabled: boolean;
    private _selectedWeek;
    get selectedWeek(): Week;
    selectedWeekChange: EventEmitter<any>;
    set selectedWeek(value: Week);
    weeks: Array<Week>;
    months: Array<Month>;
    isOpened: boolean;
    monthNames: any[];
    daysNames: any[];
    constructor(i18nService: I18nService);
    ngOnInit(): void;
    onClicked(e: any): void;
    hideSelector(): void;
    getMonths(): void;
    getWeeks(): void;
    onClickedWeek(week: Week): void;
    onClickedMonth(month: Month): void;
    addYear(num: number): void;
    addMonth(num: number): void;
    checkDateIntoIntervals(date: Date): boolean;
    getWeeksInMonth(monthActual: number, yearActual: number): any[];
    getWeek(yearActual: any, monthActual: any, dayActual: any, isGregorian: any): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<WeekSelectorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WeekSelectorComponent, "systelab-week-selector", never, { "maxDate": { "alias": "maxDate"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "currentDate": { "alias": "currentDate"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "selectedWeek": { "alias": "selectedWeek"; "required": false; }; }, { "selectedWeekChange": "selectedWeekChange"; }, never, never, false, never>;
}

declare class Point {
    x: number;
    y: number;
    constructor(x: number, y: number);
}
declare class SignatureCanvasComponent implements AfterViewInit {
    private _code;
    private _signature;
    sign: ElementRef;
    img: ElementRef;
    downPath: string;
    href: string;
    verificationActive: boolean;
    isCanvasEmpty: boolean;
    private cx;
    width: number;
    height: number;
    withCodeVerification: boolean;
    isDownloadable: boolean;
    isIncorrectCode: boolean;
    get signature(): string;
    signatureChange: EventEmitter<any>;
    set signature(value: string);
    finish: EventEmitter<any>;
    dofinish(): void;
    get code(): string;
    codeChange: EventEmitter<any>;
    set code(value: string);
    ngAfterViewInit(): void;
    configureCanvas(): void;
    captureEvents(canvas: HTMLCanvasElement): void;
    draw(previousPoint: Point, currentPoint: Point): void;
    downloadImage(): void;
    cleanCanvas(): void;
    finishDrawing(): void;
    returnCanvas(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SignatureCanvasComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SignatureCanvasComponent, "systelab-signature-canvas", never, { "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "withCodeVerification": { "alias": "withCodeVerification"; "required": false; }; "isDownloadable": { "alias": "isDownloadable"; "required": false; }; "isIncorrectCode": { "alias": "isIncorrectCode"; "required": false; }; "signature": { "alias": "signature"; "required": false; }; "code": { "alias": "code"; "required": false; }; }, { "signatureChange": "signatureChange"; "finish": "finish"; "codeChange": "codeChange"; }, never, never, false, never>;
}

declare class PercentageCircleComponent {
    value: number;
    text: string;
    color: any;
    static ɵfac: i0.ɵɵFactoryDeclaration<PercentageCircleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PercentageCircleComponent, "systelab-percentage-circle", never, { "value": { "alias": "value"; "required": false; }; "text": { "alias": "text"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CheckboxCellRendererComponent implements AgRendererComponent {
    private params;
    isCheckboxActive: boolean;
    hideCheckbox: boolean;
    showDisabled: boolean;
    id: string;
    agInit(params: any): void;
    refresh(params: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxCellRendererComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxCellRendererComponent, "systelab-checkbox-cell", never, {}, {}, never, never, false, never>;
}

declare class SpinnerCellEditorComponent implements AgEditorComponent {
    params: any;
    id: string;
    agInit(params: any): void;
    getValue(): any;
    refresh(params: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SpinnerCellEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SpinnerCellEditorComponent, "systelab-spinner-cell-editor", never, {}, {}, never, never, false, never>;
}

declare class WizardStep {
    step: number;
    description: string;
    optionalText?: string;
    visited: boolean;
}
declare class WizardStepsComponent {
    steps: Array<WizardStep>;
    roundedStep: boolean;
    allowNavigation: boolean;
    private _currentStep;
    get currentStep(): number;
    currentStepChange: EventEmitter<any>;
    set currentStep(value: number);
    action: EventEmitter<any>;
    doAction(step: any): void;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<WizardStepsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WizardStepsComponent, "systelab-wizard-steps", never, { "steps": { "alias": "steps"; "required": false; }; "roundedStep": { "alias": "roundedStep"; "required": false; }; "allowNavigation": { "alias": "allowNavigation"; "required": false; }; "currentStep": { "alias": "currentStep"; "required": false; }; }, { "currentStepChange": "currentStepChange"; "action": "action"; }, never, never, false, never>;
}

declare abstract class AbstractSortableListComponent<T> {
    elementsList: Array<T>;
    secondListSearch: string;
    dragAndDropEnabled: boolean;
    elementsListChange: EventEmitter<T[]>;
    deleteWithSupr: boolean;
    showIcon: boolean;
    constructor();
    dbClickSelectedItem(element: T): void;
    getDescription(element: T): string;
    getSelectionFieldValue(element: T): boolean;
    handleDragEnter(event: any): boolean;
    handleDragOver(event: any): boolean;
    handleDragLeave(event: any): boolean;
    selectElement(element: T, ev: KeyboardEvent): void;
    getSelectedRows(): Array<T>;
    removeElement(element: T, event: KeyboardEvent): void;
    dropped(event: CdkDragDrop<T[]>): void;
    abstract getDescriptionField(element?: T): string;
    abstract getSelectionField(element?: T): string;
    abstract getIcon(element?: T): string;
    private handleDrag;
    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractSortableListComponent<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractSortableListComponent<any>, never, never, { "elementsList": { "alias": "elementsList"; "required": false; }; "secondListSearch": { "alias": "secondListSearch"; "required": false; }; "dragAndDropEnabled": { "alias": "dragAndDropEnabled"; "required": false; }; }, { "elementsListChange": "elementsListChange"; }, never, never, true, never>;
}

declare class TwoListSortableListComponent extends AbstractSortableListComponent<TwoListItem> {
    currentSelectionStatus: CurrentSelectionStatus;
    secondListSearch: string;
    dbClick: EventEmitter<TwoListItem>;
    constructor();
    getDescriptionField(): string;
    getSelectionField(): string;
    getIcon(item: TwoListItem): string;
    selectElement(element: TwoListItem, ev: KeyboardEvent): void;
    dbClickSelectedItem(element: TwoListItem): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TwoListSortableListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TwoListSortableListComponent, "systelab-two-list-sortable-list", never, { "currentSelectionStatus": { "alias": "currentSelectionStatus"; "required": false; }; "secondListSearch": { "alias": "secondListSearch"; "required": false; }; }, { "dbClick": "dbClick"; }, never, never, false, never>;
}

declare class SpinnerCellRendererComponent implements AgRendererComponent {
    params: any;
    agInit(params: any): void;
    refresh(params: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SpinnerCellRendererComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SpinnerCellRendererComponent, "systelab-spinner-cell-renderer", never, {}, {}, never, never, false, never>;
}

declare class InputCellEditorComponent implements AgEditorComponent {
    params: any;
    id: string;
    isEditable: boolean;
    agInit(params: any): void;
    getValue(): any;
    refresh(params: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputCellEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputCellEditorComponent, "systelab-input-cell-editor", never, {}, {}, never, never, false, never>;
}

declare class DecimalInputCellEditorComponent implements AgEditorComponent {
    params: any;
    decimalValue: number;
    id: string;
    isEditable: boolean;
    agInit(params: any): void;
    getValue(): any;
    refresh(params: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<DecimalInputCellEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DecimalInputCellEditorComponent, "systelab-decimal-input-cell-editor", never, {}, {}, never, never, false, never>;
}

declare class CheckboxCellEditorComponent implements AgEditorComponent, AfterViewInit {
    private params;
    isCheckboxActive: boolean;
    id: string;
    private singleClickEdit;
    ngAfterViewInit(): void;
    agInit(params: any): void;
    getValue(): any;
    doOnChange(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxCellEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxCellEditorComponent, "systelab-checkbox-cell", never, {}, {}, never, never, false, never>;
}

declare class AbstractTreeListboxRendererComponent implements AgRendererComponent {
    params: any;
    isCheckboxActive: boolean;
    id: string;
    description: string;
    level: number;
    isMultipleSelection: boolean;
    checkId: string;
    agInit(params: any): void;
    refresh(params: any): boolean;
    changeValue(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractTreeListboxRendererComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AbstractTreeListboxRendererComponent, "abstract-listbox-renderer", never, {}, {}, never, never, false, never>;
}

declare class ContextMenuItemComponent {
    action: ContextMenuOption;
    hasIcons: boolean;
    isEnabled: boolean;
    isIconEnabled: boolean;
    hasChildren: boolean;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ContextMenuItemComponent, "systelab-context-menu-item", never, { "action": { "alias": "action"; "required": false; }; "hasIcons": { "alias": "hasIcons"; "required": false; }; "isEnabled": { "alias": "isEnabled"; "required": false; }; "isIconEnabled": { "alias": "isIconEnabled"; "required": false; }; "hasChildren": { "alias": "hasChildren"; "required": false; }; }, {}, never, never, false, never>;
}

declare class NumPadComponent {
    dialogService: DialogService;
    protected _value: string;
    isPassword: boolean;
    autofocus: boolean;
    placeholder: string;
    onClickSelectValue: boolean;
    valueChange: EventEmitter<string>;
    change: EventEmitter<string>;
    get value(): string;
    set value(value: string);
    input: ElementRef<HTMLInputElement>;
    constructor(dialogService: DialogService);
    openNumPadDialog(): void;
    doEnter(): void;
    focus(): void;
    blur(): void;
    private getNumPadElement;
    doSelectValue(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NumPadComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NumPadComponent, "systelab-numpad", never, { "isPassword": { "alias": "isPassword"; "required": false; }; "autofocus": { "alias": "autofocus"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "onClickSelectValue": { "alias": "onClickSelectValue"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; "change": "change"; }, never, never, false, never>;
}

declare class NumPadDialogParameters extends SystelabModalContext {
    value: string;
    width: number;
    height: number;
    isPassword: boolean;
}
declare class NumPadDialog implements ModalComponent<NumPadDialogParameters> {
    dialog: DialogRef<NumPadDialogParameters>;
    protected inputElement: ElementRef;
    value: string;
    dialogParameters: NumPadDialogParameters;
    searchingValue: string;
    titleForDialog: string;
    showClose: boolean;
    isPassword: boolean;
    static getParameters(): NumPadDialogParameters;
    constructor(dialog: DialogRef<NumPadDialogParameters>);
    close(): void;
    accept(): void;
    pushButton(value: string): void;
    deleteNumber(): void;
    cleanInput(): void;
    doKeyPress(event: KeyboardEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NumPadDialog, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NumPadDialog, "ng-component", never, {}, {}, never, never, false, never>;
}

declare abstract class AbstractListBox<T> implements OnInit {
    rowData: any;
    gridOptions: GridOptions;
    gridApi: GridApi;
    hiddenElement: ElementRef;
    _values: Array<T>;
    set values(newValues: Array<T>);
    get values(): Array<T>;
    rowDrag: boolean;
    isDisabled: boolean;
    _selectedItem: T;
    set selectedItem(value: T);
    get selectedItem(): T;
    selectedItemChange: EventEmitter<T>;
    multipleSelectedIDListChange: EventEmitter<any>;
    rowDragEnd: EventEmitter<any>;
    selectFirstItem: boolean;
    multipleSelection: boolean;
    showAll: boolean;
    hideChecks: boolean;
    protected _multipleSelectedItemList: Array<T>;
    private calculatedGridState;
    private scrollTimeout;
    set multipleSelectedItemList(value: Array<T>);
    get multipleSelectedItemList(): Array<T>;
    multipleSelectedItemListChange: EventEmitter<any>;
    protected constructor();
    protected abstract getIdField(level?: number): string;
    protected abstract getDescriptionField(level?: number): string;
    abstract getInstance(): T;
    ngOnInit(): void;
    protected getInitialGridOptions(): GridOptions;
    protected getRowNodeId(item: GetRowIdParams): string | number | undefined;
    private getSelectionColumnDefs;
    protected getColumnDefsWithOptions(): Array<any>;
    protected getCheckColumnWidth(): number;
    getAllFieldID(): number | string;
    getAllFieldDescription(): string;
    cleanSelection(): void;
    protected addSuppressSizeToFitToColumnsWithWidthDefined(colDefs: ColDef[]): void;
    doGridReady(event: any): void;
    private onBodyScroll;
    protected doAutoSizeManagement(event?: any): void;
    doGridSizeChanged(event: any): void;
    doClick(row: any): void;
    onRowSelected(event: RowSelectedEvent): void;
    onModelUpdated(pEvent: any): any;
    protected selectItemInGrid(): void;
    private selectionItemListToIDList;
    private unselectAllNodes;
    private unselectNodeAll;
    onRowDragEnd(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractListBox<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractListBox<any>, never, never, { "rowData": { "alias": "rowData"; "required": false; }; "values": { "alias": "values"; "required": false; }; "rowDrag": { "alias": "rowDrag"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "selectedItem": { "alias": "selectedItem"; "required": false; }; "selectFirstItem": { "alias": "selectFirstItem"; "required": false; }; "multipleSelection": { "alias": "multipleSelection"; "required": false; }; "showAll": { "alias": "showAll"; "required": false; }; "hideChecks": { "alias": "hideChecks"; "required": false; }; "multipleSelectedItemList": { "alias": "multipleSelectedItemList"; "required": false; }; }, { "selectedItemChange": "selectedItemChange"; "multipleSelectedIDListChange": "multipleSelectedIDListChange"; "rowDragEnd": "rowDragEnd"; "multipleSelectedItemListChange": "multipleSelectedItemListChange"; }, never, never, true, never>;
}

declare class Element {
    id: string;
    description: string;
    constructor(id: string, description: string);
}
declare class SystelabGenderListBox extends AbstractListBox<Element> {
    i18nService: I18nService;
    showAll: boolean;
    constructor(i18nService: I18nService);
    ngOnInit(): void;
    getAllFieldID(): number | string;
    getAllFieldDescription(): string;
    getIdField(): string;
    getDescriptionField(): string;
    getInstance(): Element;
    getDescriptionForGender(gender: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SystelabGenderListBox, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SystelabGenderListBox, "systelab-gender-listbox", never, { "showAll": { "alias": "showAll"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ComboboxFavouriteRendererComponent implements AgRendererComponent {
    isFavourite: boolean;
    label: string;
    favouriteList: Array<string>;
    agInit(params: any): void;
    refresh(params: any): boolean;
    protected checkIfIsFavourite(params: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ComboboxFavouriteRendererComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ComboboxFavouriteRendererComponent, "combobox-favourite-renderer", never, {}, {}, never, never, false, never>;
}

declare class ListBoxElement {
    id: string;
    description: string;
    constructor(id: string, description: string);
}
declare class ModulabListBox extends AbstractListBox<ListBoxElement> {
    constructor();
    getInstance(): ListBoxElement;
    getDescriptionField(): string;
    getIdField(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModulabListBox, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModulabListBox, "systelab-listbox", never, {}, {}, never, never, false, never>;
}

declare class DateRangepicker {
    private _fromDate;
    private _toDate;
    minDate: Date;
    maxDate: Date;
    disabled: boolean;
    get fromDate(): Date;
    set fromDate(value: Date);
    get toDate(): Date;
    set toDate(value: Date);
    toDateChange: EventEmitter<Date>;
    fromDateChange: EventEmitter<Date>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateRangepicker, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DateRangepicker, "systelab-date-range-picker", never, { "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "fromDate": { "alias": "fromDate"; "required": false; }; "toDate": { "alias": "toDate"; "required": false; }; }, { "toDateChange": "toDateChange"; "fromDateChange": "fromDateChange"; }, never, never, false, never>;
}

declare class PaginatorComponent implements OnInit, OnChanges {
    totalPages: number;
    page: number;
    pagesToShow: number;
    showNextPreviousButtons: boolean;
    showFirstLastButtons: boolean;
    pageChange: EventEmitter<number>;
    pages: number[];
    private static calculateVisiblePages;
    private static calculateStartPage;
    private static calculateEndPage;
    private static calculateLinkPages;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    goFirst(): void;
    goPrevious(): void;
    goNext(): void;
    goLast(): void;
    goToPage(page: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PaginatorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PaginatorComponent, "systelab-paginator", never, { "totalPages": { "alias": "totalPages"; "required": false; }; "page": { "alias": "page"; "required": false; }; "pagesToShow": { "alias": "pagesToShow"; "required": false; }; "showNextPreviousButtons": { "alias": "showNextPreviousButtons"; "required": false; }; "showFirstLastButtons": { "alias": "showFirstLastButtons"; "required": false; }; }, { "pageChange": "pageChange"; }, never, never, false, never>;
}

declare class PaginatorPageComponent {
    icon: string;
    pageNumber: string;
    selected: boolean;
    disabled: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<PaginatorPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PaginatorPageComponent, "systelab-paginator-page", never, { "icon": { "alias": "icon"; "required": false; }; "pageNumber": { "alias": "pageNumber"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ChipButtonItem {
    id: number;
    name: string;
    isChecked: boolean;
    constructor(id: number, name: string, isChecked?: boolean);
}
declare class ChipButtonComponent {
    protected messagePopupService: MessagePopupService;
    protected i18nService: I18nService;
    changeButton: EventEmitter<any>;
    selectButton: EventEmitter<any>;
    buttonRemoved: EventEmitter<any>;
    buttonAdded: EventEmitter<any>;
    buttonList: ChipButtonItem[];
    deleteConfirmationTitle: string;
    deleteConfirmationMessage: string;
    showAddButton: boolean;
    isRemoveEnabled: boolean;
    disabled: boolean;
    private lastValue;
    constructor(messagePopupService: MessagePopupService, i18nService: I18nService);
    onClick(item: ChipButtonItem): void;
    selectItem(item: ChipButtonItem): void;
    removeButtonItem(item: ChipButtonItem, event: Event): void;
    addButtonITem(): void;
    changeButtonItem(item: ChipButtonItem): void;
    private removeElement;
    static ɵfac: i0.ɵɵFactoryDeclaration<ChipButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ChipButtonComponent, "systelab-chip-button", never, { "buttonList": { "alias": "buttonList"; "required": false; }; "deleteConfirmationTitle": { "alias": "deleteConfirmationTitle"; "required": false; }; "deleteConfirmationMessage": { "alias": "deleteConfirmationMessage"; "required": false; }; "showAddButton": { "alias": "showAddButton"; "required": false; }; "isRemoveEnabled": { "alias": "isRemoveEnabled"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "changeButton": "changeButton"; "selectButton": "selectButton"; "buttonRemoved": "buttonRemoved"; "buttonAdded": "buttonAdded"; }, never, never, false, never>;
}

declare class AutofocusDirective implements AfterContentInit {
    private el;
    autoFocus: boolean;
    constructor(el: ElementRef);
    ngAfterContentInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AutofocusDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AutofocusDirective, "[autoFocus]", never, { "autoFocus": { "alias": "autoFocus"; "required": false; }; }, {}, never, never, false, never>;
}

interface IStackedBar {
    id: string | number;
    value: number;
    color?: string;
    colorClass?: string;
    tooltipText?: string;
}
declare class StackedBarCellRendererComponent implements AgRendererComponent {
    params: any;
    barClick: (rowData: any, id: string | number) => void;
    total: number;
    width: number;
    stackedBars: Array<IStackedBar>;
    agInit(params: any): void;
    refresh(params: any): boolean;
    doBarClick(event: MouseEvent, stackedBar: IStackedBar): void;
    private initModel;
    private getMaxValue;
    private getTotal;
    private getWidth;
    static ɵfac: i0.ɵɵFactoryDeclaration<StackedBarCellRendererComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StackedBarCellRendererComponent, "systelab-stacked-bar-cell", never, {}, {}, never, never, false, never>;
}

declare class ChipsComponent {
    filtered: EventEmitter<string[]>;
    autoComplete: AutoComplete;
    texts: Array<string>;
    disabled: boolean;
    readonly: boolean;
    results: Array<string>;
    private newData;
    private _filter;
    get filter(): Array<string>;
    set filter(event: Array<string>);
    search(event: any): void;
    onKeyEnter(event: KeyboardEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ChipsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ChipsComponent, "systelab-chips", never, { "texts": { "alias": "texts"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; }, { "filtered": "filtered"; }, never, never, false, never>;
}

declare class SpyMenuItem {
    id: string;
    text: string;
    hidden: (() => boolean) | boolean;
    disabled: (() => boolean) | boolean;
    constructor(id: string, text: string);
}

declare class SpyMenuComponent {
    items: Array<SpyMenuItem>;
    sectionSelected: string;
    doClick(item: SpyMenuItem): void;
    isItemDisabled(item: SpyMenuItem): boolean;
    isItemHidden(item: SpyMenuItem): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SpyMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SpyMenuComponent, "systelab-spy-menu", never, { "items": { "alias": "items"; "required": false; }; "sectionSelected": { "alias": "sectionSelected"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ScrollSpyDirective implements AfterViewInit {
    private readonly _el;
    spiedTags: Array<string>;
    querySelector: string;
    sectionChange: EventEmitter<string>;
    private currentSection;
    private observer;
    constructor(_el: ElementRef);
    ngOnDestroy(): void;
    ngAfterViewInit(): void;
    private handleIntersect;
    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollSpyDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ScrollSpyDirective, "[scrollSpy]", never, { "spiedTags": { "alias": "spiedTags"; "required": false; }; "querySelector": { "alias": "querySelector"; "required": false; }; }, { "sectionChange": "sectionChange"; }, never, never, false, never>;
}

type ToastAnimationState = 'default' | 'closing';

interface ToastItem {
    id: string;
    data: ToastData;
    iconClass: string;
    toastClass: string;
    title: string;
    body: string;
    hasAction: boolean;
    showClose: boolean;
    animationState: ToastAnimationState;
    timerId?: number;
    onClose?: () => void;
}
declare class ToastComponent {
    private readonly _cdr;
    items: ToastItem[];
    onEmpty?: () => void;
    constructor(_cdr: ChangeDetectorRef);
    addToast(data: ToastData, config: ToastConfig, onClose?: () => void): string;
    removeToast(id: string): void;
    closeToast(item: ToastItem): void;
    onActionClick(item: ToastItem): void;
    onFadeFinished(event: AnimationEvent, item: ToastItem): void;
    private _startClose;
    private _remove;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToastComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToastComponent, "systelab-toast", never, {}, {}, never, never, false, never>;
}

interface ToggleSelectorOption {
    id: string;
    name: string;
}
declare class ToggleSelectorComponent {
    options: Array<ToggleSelectorOption>;
    currentOption: string;
    currentOptionChange: EventEmitter<string>;
    select: EventEmitter<ToggleSelectorOption>;
    selectOption(option: ToggleSelectorOption): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToggleSelectorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToggleSelectorComponent, "systelab-toggle-selector", never, { "options": { "alias": "options"; "required": false; }; "currentOption": { "alias": "currentOption"; "required": false; }; }, { "currentOptionChange": "currentOptionChange"; "select": "select"; }, never, never, false, never>;
}

declare class KeyupDebounceDirective implements OnInit, OnDestroy {
    private el;
    keyupDebounceTime: number;
    keyupDebounced: EventEmitter<any>;
    private debouncer;
    private subscription;
    constructor(el: ElementRef);
    ngOnInit(): void;
    ngOnDestroy(): void;
    keyupEvent(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KeyupDebounceDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<KeyupDebounceDirective, "[keyup-debounce]", never, { "keyupDebounceTime": { "alias": "keyupDebounceTime"; "required": false; }; }, { "keyupDebounced": "keyupDebounced"; }, never, never, false, never>;
}

declare class DraggableDirective implements OnInit {
    private readonly element;
    model: any;
    draggableOptions: any;
    zoom: number;
    draggableClick: EventEmitter<any>;
    finalPosition: EventEmitter<any>;
    currentPosition: EventEmitter<any>;
    private currentlyDragged;
    private currentlyResizing;
    constructor(element: ElementRef);
    onClick(event: any): void;
    ngOnInit(): void;
    private doCurrentlyResizingUpdate;
    private doDragEnd;
    private doDragMove;
    static ɵfac: i0.ɵɵFactoryDeclaration<DraggableDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DraggableDirective, "[draggable]", never, { "model": { "alias": "model"; "required": false; }; "draggableOptions": { "alias": "draggableOptions"; "required": false; }; "zoom": { "alias": "zoom"; "required": false; }; }, { "draggableClick": "draggableClick"; "finalPosition": "finalPosition"; "currentPosition": "currentPosition"; }, never, never, false, never>;
}

declare class ResizableDirective implements OnInit {
    private element;
    model: any;
    resizableOptions: any;
    zoom: number;
    resizeClick: EventEmitter<any>;
    finalSize: EventEmitter<any>;
    currentSize: EventEmitter<any>;
    private currentlyDragged;
    private currentlyResizing;
    constructor(element: ElementRef);
    onClick(event: any): void;
    ngOnInit(): void;
    private doResizeEnd;
    private doCurrentlyDraggedUpdate;
    private doResizeMove;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResizableDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ResizableDirective, "[resizable]", never, { "model": { "alias": "model"; "required": false; }; "resizableOptions": { "alias": "resizableOptions"; "required": false; }; "zoom": { "alias": "zoom"; "required": false; }; }, { "resizeClick": "resizeClick"; "finalSize": "finalSize"; "currentSize": "currentSize"; }, never, never, false, never>;
}

declare enum ActionButtonType {
    BUTTON = 0,
    TOGGLE_BUTTON = 1,
    DROP_DOWN = 2
}
interface ActionButton {
    action: string;
    label: string;
    tooltip?: string;
    type: ActionButtonType;
    state?: {
        checked?: boolean;
        disabled: boolean;
    };
}
declare class ImageViewerComponent implements OnInit {
    private readonly chref;
    private readonly elementRef;
    private readonly sanitizer;
    imageSrc: string;
    imageTitle: string;
    overlayText: string;
    actionButtons: ActionButton[];
    imageFilters: string;
    showSaveButton: boolean;
    showZoomByAreaButton: boolean;
    showAdjustButton: boolean;
    showZoomScale: boolean;
    showSliderToolTip: boolean;
    sliderZoomMin: number;
    sliderZoomMax: number;
    sliderZoomStep: number;
    transparentBackgroundForButtons: boolean;
    overlapImageWithButtons: boolean;
    allowBorderColor: string;
    clickActionButton: EventEmitter<string>;
    clickOverlayText: EventEmitter<any>;
    imageViewerWrapper: ElementRef;
    imageViewerImg: ElementRef;
    zoomEnabled: boolean;
    dragEnabled: boolean;
    imgParams: {
        sliderZoomPct: any;
        filter: any;
        top: number;
        left: number;
        width: any;
        height: any;
    };
    zoomSelector: {
        visible: boolean;
        allow: boolean;
        top: any;
        left: any;
        width: any;
        height: any;
    };
    zoomScale: {
        totalWidth: any;
        sliderThumb: number;
        chunks: number;
        marks: {
            marginLeft: number;
            label: string;
        }[];
    };
    actionButtonType: any;
    safeHtml: SafeHtml;
    filteredUrl: string;
    imageWidth: string;
    private zoomArea;
    private viewPort;
    private image;
    private wrapper;
    private imageClicked;
    constructor(chref: ChangeDetectorRef, elementRef: ElementRef, sanitizer: DomSanitizer);
    ngOnInit(): void;
    doMouseDown(event: any): void;
    doMouseMove(event: MouseEvent): void;
    doMouseUp(): void;
    getWidth(): string;
    getFilter(): string;
    setFilter(filter: string): void;
    doAdjust(): void;
    toggleZoomByArea(): void;
    sliderZoomChanged(): void;
    setInitialValues(): void;
    isFilterEnabled(action: string): boolean;
    getDropMainDownLabel(dropDownLabel: string): string;
    getDropDownLabels(dropDownLabel: string): string[];
    getDropDownAction(dropDownActions: string, i: number): string;
    getFilterUrl(): string;
    private initializeCommonParameters;
    private initializeZoomByAreaAction;
    private initializeDragAction;
    private updateZoomSelector;
    private resizeZoomSelectorAndImage;
    private getTargetMagnification;
    private getSliderMarkMarginByZoomFactor;
    private scrollViewport;
    private deactivateZoomSelector;
    private activateZoomSelector;
    private getSliderPct;
    private imageOverflowViewport;
    private scaleImage;
    private getInitialZoom;
    static ɵfac: i0.ɵɵFactoryDeclaration<ImageViewerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ImageViewerComponent, "systelab-image-viewer", never, { "imageSrc": { "alias": "imageSrc"; "required": false; }; "imageTitle": { "alias": "imageTitle"; "required": false; }; "overlayText": { "alias": "overlayText"; "required": false; }; "actionButtons": { "alias": "actionButtons"; "required": false; }; "imageFilters": { "alias": "imageFilters"; "required": false; }; "showSaveButton": { "alias": "showSaveButton"; "required": false; }; "showZoomByAreaButton": { "alias": "showZoomByAreaButton"; "required": false; }; "showAdjustButton": { "alias": "showAdjustButton"; "required": false; }; "showZoomScale": { "alias": "showZoomScale"; "required": false; }; "showSliderToolTip": { "alias": "showSliderToolTip"; "required": false; }; "sliderZoomMin": { "alias": "sliderZoomMin"; "required": false; }; "sliderZoomMax": { "alias": "sliderZoomMax"; "required": false; }; "sliderZoomStep": { "alias": "sliderZoomStep"; "required": false; }; "transparentBackgroundForButtons": { "alias": "transparentBackgroundForButtons"; "required": false; }; "overlapImageWithButtons": { "alias": "overlapImageWithButtons"; "required": false; }; "allowBorderColor": { "alias": "allowBorderColor"; "required": false; }; }, { "clickActionButton": "clickActionButton"; "clickOverlayText": "clickOverlayText"; }, never, never, false, never>;
}

declare class TranslationHelper {
    i18nService: I18nService;
    constructor(i18nService: I18nService);
    getLanguageFromLocale(locale: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TranslationHelper, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TranslationHelper>;
}

declare class NumberHelper {
    private i18nService;
    private translationHelper;
    constructor(i18nService: I18nService, translationHelper: TranslationHelper);
    getStringFromNumber(numberToString: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<NumberHelper, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NumberHelper>;
}

declare class NumpadDecimalNumericDirective {
    private el;
    protected i18nService: I18nService;
    private numberHelper;
    private decimalSeparator;
    constructor(el: ElementRef, i18nService: I18nService, numberHelper: NumberHelper);
    keyup(event: KeyboardEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NumpadDecimalNumericDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NumpadDecimalNumericDirective, "[systelabNumPadDecimalNumericDirective]", never, {}, {}, never, never, false, never>;
}

declare class PositiveIntegerInputCellEditorComponent implements AgEditorComponent {
    value: string;
    isEditable: boolean;
    params: any;
    agInit(params: any): void;
    getValue(): any;
    onKeyDown(event: KeyboardEvent): void;
    refresh(params: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<PositiveIntegerInputCellEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PositiveIntegerInputCellEditorComponent, "systelab-positive-integer-input-cell-editor", never, {}, {}, never, never, false, never>;
}

declare class TestIdDirective implements OnChanges {
    private config;
    private renderer;
    private el;
    label: string;
    private readonly productionMode;
    constructor(config: any, renderer: Renderer2, el: ElementRef);
    ngOnChanges(): void;
    private addE2EAttribute;
    static ɵfac: i0.ɵɵFactoryDeclaration<TestIdDirective, [{ optional: true; }, null, null]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TestIdDirective, "[systelabTestId]", never, { "label": { "alias": "systelabTestId"; "required": false; }; }, {}, never, never, false, never>;
}

declare class SearcherTreeHeaderRendererComponent implements AgRendererComponent {
    params: any;
    agInit(params: any): void;
    refresh(params: any): boolean;
    doClick(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SearcherTreeHeaderRendererComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SearcherTreeHeaderRendererComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class Accordion implements OnInit {
    private readonly preferenceService;
    headerTitle: string;
    preferenceName: string;
    contentMaxHeight: number;
    withOverflow: boolean;
    headerColor: string;
    iconColor: string;
    isCollapsed: boolean;
    private preferenceSuffix;
    constructor(preferenceService: PreferencesService);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<Accordion, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<Accordion, "systelab-accordion", never, { "headerTitle": { "alias": "headerTitle"; "required": false; }; "preferenceName": { "alias": "preferenceName"; "required": false; }; "contentMaxHeight": { "alias": "contentMaxHeight"; "required": false; }; "withOverflow": { "alias": "withOverflow"; "required": false; }; "headerColor": { "alias": "headerColor"; "required": false; }; "iconColor": { "alias": "iconColor"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare const factory: () => void;
declare class SystelabComponentsModule {
    constructor(instance: any);
    static forRoot(conf?: AppConfig): ModuleWithProviders<SystelabComponentsModule>;
    static forChild(): ModuleWithProviders<SystelabComponentsModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SystelabComponentsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SystelabComponentsModule, [typeof TooltipDirective, typeof TooltipContentComponent, typeof SliderComponent, typeof SliderDoubleRangeComponent, typeof SwitchComponent, typeof ContextMenuComponent, typeof ContextMenuSubmenuItemComponent, typeof ContextPanelComponent, typeof MessagePopupViewComponent, typeof DataFilterPipe, typeof TwoListComponent, typeof GridContextMenuComponent, typeof GridContextMenuCellRendererComponent, typeof GridHeaderContextMenuComponent, typeof GridHeaderContextMenu, typeof GridColumnOptionsDialog, typeof ColorCellRendererComponent, typeof ColorComboBox, typeof ApplicationFrameComponent, typeof ApplicationHeaderComponent, typeof ApplicationSidebarLargeComponent, typeof ApplicationSidebarSmallComponent, typeof ButtonComponent, typeof ToggleButtonComponent, typeof AllYesNoSelect, typeof NoYesSelect, typeof PeriodSelect, typeof TimeUnitSelectComponent, typeof GenderSelect, typeof TouchspinComponent, typeof ModulabSelect, typeof DatepickerComponent, typeof DatepickerTimeComponent, typeof SearcherDialog, typeof CalendarDialog, typeof SearcherTableComponent, typeof CalendarHeaderComponent, typeof CalendarTableComponent, typeof CalendarFooterComponent, typeof TabsComponent, typeof TabComponent, typeof DialogHeaderComponent, typeof DialogBottomComponent, typeof LoadingComponent, typeof FileSelectorComponent, typeof TimelineComponent, typeof MessageWithIconComponent, typeof ComboBoxInputRendererComponent, typeof NavbarComponent, typeof BreadcrumbComponent, typeof WeekSelectorComponent, typeof MonthSelectorComponent, typeof SignatureCanvasComponent, typeof PercentageCircleComponent, typeof CheckboxCellRendererComponent, typeof SpinnerCellEditorComponent, typeof WizardStepsComponent, typeof TwoListSortableListComponent, typeof SpinnerCellRendererComponent, typeof InputCellEditorComponent, typeof DecimalInputCellEditorComponent, typeof CheckboxCellEditorComponent, typeof AbstractTreeListboxRendererComponent, typeof ContextMenuItemComponent, typeof NumPadComponent, typeof NumPadDialog, typeof SystelabGenderListBox, typeof ComboboxFavouriteRendererComponent, typeof ModulabListBox, typeof DateRangepicker, typeof PaginatorComponent, typeof PaginatorPageComponent, typeof ChipButtonComponent, typeof AutofocusDirective, typeof StackedBarCellRendererComponent, typeof ChipsComponent, typeof SpyMenuComponent, typeof ScrollSpyDirective, typeof ToastComponent, typeof ToggleSelectorComponent, typeof KeyupDebounceDirective, typeof DraggableDirective, typeof ResizableDirective, typeof ImageViewerComponent, typeof NumpadDecimalNumericDirective, typeof PositiveIntegerInputCellEditorComponent, typeof NumpadDecimalNumericDirective, typeof TestIdDirective, typeof SearcherTreeHeaderRendererComponent, typeof Accordion], [typeof i89.CommonModule, typeof i90.FormsModule, typeof i91.DatePickerModule, typeof i92.AutoCompleteModule, typeof i93.DragDropModule, typeof i94.OverlayModule, typeof i95.ContextMenuModule, typeof i96.AngularSplitModule, typeof i97.SystelabTranslateModule, typeof i98.AgGridModule, typeof i99.CdkTreeModule], [typeof SliderComponent, typeof SliderDoubleRangeComponent, typeof SwitchComponent, typeof ContextMenuComponent, typeof ContextPanelComponent, typeof TwoListComponent, typeof GridHeaderContextMenuComponent, typeof GridHeaderContextMenu, typeof ColorCellRendererComponent, typeof ColorComboBox, typeof ApplicationHeaderComponent, typeof ApplicationSidebarLargeComponent, typeof ApplicationSidebarSmallComponent, typeof ApplicationFrameComponent, typeof AllYesNoSelect, typeof NoYesSelect, typeof PeriodSelect, typeof TimeUnitSelectComponent, typeof GenderSelect, typeof DatepickerComponent, typeof TouchspinComponent, typeof ModulabSelect, typeof DatepickerTimeComponent, typeof SearcherDialog, typeof CalendarDialog, typeof ButtonComponent, typeof ToggleButtonComponent, typeof SearcherTableComponent, typeof CalendarHeaderComponent, typeof CalendarTableComponent, typeof CalendarFooterComponent, typeof TabsComponent, typeof TabComponent, typeof DialogHeaderComponent, typeof DialogBottomComponent, typeof LoadingComponent, typeof FileSelectorComponent, typeof TimelineComponent, typeof NavbarComponent, typeof MessageWithIconComponent, typeof BreadcrumbComponent, typeof WeekSelectorComponent, typeof MonthSelectorComponent, typeof SignatureCanvasComponent, typeof PercentageCircleComponent, typeof i96.SplitComponent, typeof ComboBoxInputRendererComponent, typeof TooltipDirective, typeof CheckboxCellRendererComponent, typeof SpinnerCellEditorComponent, typeof WizardStepsComponent, typeof TwoListSortableListComponent, typeof DataFilterPipe, typeof SpinnerCellRendererComponent, typeof InputCellEditorComponent, typeof DecimalInputCellEditorComponent, typeof CheckboxCellEditorComponent, typeof AbstractTreeListboxRendererComponent, typeof ContextMenuItemComponent, typeof NumPadComponent, typeof NumPadDialog, typeof SystelabGenderListBox, typeof ComboboxFavouriteRendererComponent, typeof ModulabListBox, typeof GridContextMenuComponent, typeof DateRangepicker, typeof PaginatorComponent, typeof i98.AgGridAngular, typeof ChipButtonComponent, typeof AutofocusDirective, typeof StackedBarCellRendererComponent, typeof ChipsComponent, typeof SpyMenuComponent, typeof ScrollSpyDirective, typeof ToastComponent, typeof ToggleSelectorComponent, typeof KeyupDebounceDirective, typeof DraggableDirective, typeof ResizableDirective, typeof ImageViewerComponent, typeof NumpadDecimalNumericDirective, typeof TestIdDirective, typeof NumpadDecimalNumericDirective, typeof PositiveIntegerInputCellEditorComponent, typeof SearcherTreeHeaderRendererComponent, typeof Accordion]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SystelabComponentsModule>;
}

declare abstract class AbstractGenericSearcherComponent<T> implements OnInit {
    dialogService: DialogService;
    abstractSearcher: AbstractSearcher<T>;
    searcherDialogParameters: SearcherDialogParameters<T>;
    multipleSelection: boolean;
    isDisabled: boolean;
    _id: number | string;
    protected _multipleSelectedItemList: Array<T>;
    get multipleSelectedItemList(): Array<T>;
    set multipleSelectedItemList(value: Array<T>);
    multipleSelectedItemListChange: EventEmitter<any>;
    set id(value: number | string);
    get id(): number | string;
    _description: string;
    set description(value: string);
    get description(): string;
    _code: string;
    set code(value: string);
    get code(): string;
    idChange: EventEmitter<any>;
    descriptionChange: EventEmitter<any>;
    codeChange: EventEmitter<any>;
    selectedHasChanged: EventEmitter<any>;
    protected constructor(dialogService: DialogService, abstractSearcher: AbstractSearcher<T>);
    ngOnInit(): void;
    openSearchDialog(): void;
    upDateField(value: T): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractGenericSearcherComponent<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractGenericSearcherComponent<any>, never, never, { "multipleSelection": { "alias": "multipleSelection"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "multipleSelectedItemList": { "alias": "multipleSelectedItemList"; "required": false; }; "id": { "alias": "id"; "required": false; }; "description": { "alias": "description"; "required": false; }; "code": { "alias": "code"; "required": false; }; }, { "multipleSelectedItemListChange": "multipleSelectedItemListChange"; "idChange": "idChange"; "descriptionChange": "descriptionChange"; "codeChange": "codeChange"; "selectedHasChanged": "selectedHasChanged"; }, never, never, true, never>;
}

declare abstract class AbstractSearcherComponent<T> extends AbstractGenericSearcherComponent<T> {
    dialogService: DialogService;
    abstractSearcher: AbstractSearcher<T>;
    valueToSearch: ElementRef;
    fontFamily: string;
    fontSize: string;
    fontWeight: string;
    fontStyle: string;
    tabindex: number;
    searchingValue: string;
    withButton: boolean;
    isManagement: boolean;
    height: any;
    protected constructor(dialogService: DialogService, abstractSearcher: AbstractSearcher<T>);
    set description(value: string);
    getWidth(): {
        width: string;
        'min-width': string;
        'line-height': number;
        'padding-left': number;
        'padding-right': number;
    };
    getInputHeight(): {
        height: string;
    };
    getLineHeight(): {
        'line-height': string;
    };
    openSearchDialog(): void;
    doSearch(): void;
    upDateField(value: T): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractSearcherComponent<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractSearcherComponent<any>, never, never, { "fontFamily": { "alias": "fontFamily"; "required": false; }; "fontSize": { "alias": "fontSize"; "required": false; }; "fontWeight": { "alias": "fontWeight"; "required": false; }; "fontStyle": { "alias": "fontStyle"; "required": false; }; "tabindex": { "alias": "tabindex"; "required": false; }; "withButton": { "alias": "withButton"; "required": false; }; "isManagement": { "alias": "isManagement"; "required": false; }; "height": { "alias": "height"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LoadingService {
    protected loadingList: boolean[];
    setLoading(): void;
    removeLoading(): void;
    isLoading(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LoadingService>;
}

declare abstract class AbstractApiComboBox<T> extends AbstractComboBox<T> implements AgRendererComponent, OnInit, OnDestroy {
    myRenderer: Renderer2;
    chref: ChangeDetectorRef;
    preferencesService?: PreferencesService;
    startsWith: string;
    params: any;
    totalItemsLoaded: boolean;
    constructor(myRenderer: Renderer2, chref: ChangeDetectorRef, preferencesService?: PreferencesService);
    protected configGrid(): void;
    protected configGridData(): void;
    abstract getData(page: number, itemsPerPage: number, startsWithParameter: string): Observable<Array<T>>;
    abstract getTotalItems(): number;
    refresh(params: any): boolean;
    loop(): void;
    protected getTotalItemsInCombo(): number;
    doSearch(event: any): void;
    getRows(params: IGetRowsParams): void;
    private getElements;
    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractApiComboBox<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractApiComboBox<any>, never, never, {}, {}, never, never, true, never>;
}

declare class KeyName {
    static readonly backspace = "Backspace";
    static readonly enter = "Enter";
    static readonly escape = "Escape";
    static readonly tab = "Tab";
    static readonly arrowUp = "ArrowUp";
    static readonly arrowDown = "ArrowDown";
    static readonly shift = "Shift";
}
declare abstract class AutocompleteApiComboBox<T> extends AbstractApiComboBox<T> implements AgRendererComponent {
    myRenderer: Renderer2;
    chref: ChangeDetectorRef;
    preferencesService?: PreferencesService;
    startsWith: string;
    debounceTime: number;
    withClearOption: boolean;
    constructor(myRenderer: Renderer2, chref: ChangeDetectorRef, preferencesService?: PreferencesService);
    doSearch(event: any): void;
    setDropdownHeight(): void;
    onInputClicked(event: MouseEvent): void;
    onInputNavigate(event: any): void;
    onCellKeyDown(e: any): void;
    onComboClicked(event: MouseEvent): void;
    closeDropDown(): void;
    getRows(params: IGetRowsParams): void;
    protected doSearchText(text: string): void;
    protected resetComboSelection(): void;
    private openDropDown;
    inputIsEmpty(): boolean;
    clearText(event: MouseEvent): void;
    onEnterDoSelect(event: KeyboardEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AutocompleteApiComboBox<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AutocompleteApiComboBox<any>, never, never, { "debounceTime": { "alias": "debounceTime"; "required": false; }; "withClearOption": { "alias": "withClearOption"; "required": false; }; }, {}, never, never, true, never>;
}

declare abstract class AbstractApiListBox<T> extends AbstractListBox<T> implements IDatasource {
    abstract getInstance(): T;
    protected constructor();
    protected getInitialGridOptions(): GridOptions;
    abstract getTotalItems(): number;
    protected abstract getData(page: number, itemsPerPage: number): Observable<Array<T>>;
    getRows(params: IGetRowsParams): void;
    private getElements;
    refresh(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractApiListBox<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractApiListBox<any>, never, never, {}, {}, never, never, true, never>;
}

declare class TreeListBoxElement<T> {
    nodeData: T;
    level: number;
    selected: boolean;
    constructor(pNodeData?: T, pLevel?: number, pSelected?: boolean);
}
declare abstract class AbstractApiTreeListBox<T> extends AbstractListBox<TreeListBoxElement<T>> implements OnInit {
    hiddenElement: ElementRef;
    isParentSelectable: boolean;
    updateHierarchy: boolean;
    selectedTreeItemChange: EventEmitter<TreeListBoxElement<T>>;
    selectedIDListChange: EventEmitter<string>;
    columnDefs: Array<any>;
    treeValues: Array<TreeListBoxElement<T>>;
    _selectedTreeItem: TreeListBoxElement<T>;
    paddingSingleSelection: number;
    set selectedTreeItem(value: TreeListBoxElement<T>);
    get selectedTreeItem(): TreeListBoxElement<T>;
    set selectedIDList(value: string);
    get selectedIDList(): string;
    protected _selectedIDList: string;
    protected constructor();
    ngOnInit(): void;
    doGridReady(event: any): void;
    cleanSelection(): void;
    doClick(row: any): void;
    changeValues(event: any): void;
    addSelectedItem(selected: TreeListBoxElement<T>): void;
    removeElement(seleccionado: TreeListBoxElement<T>): void;
    containsElement(seleccionado: TreeListBoxElement<T>): boolean;
    onModelUpdated(pEvent: any): void;
    protected configGrid(): void;
    protected getRowNodeId(item: GetRowIdParams): string | number | undefined;
    protected getRows(): void;
    protected loadValues(dataVector: Array<T>): void;
    protected initSelectionList(): void;
    protected selectTreeItemInGrid(): void;
    protected selectUnselectChildTree(event: any): void;
    protected selectUnselectParentTree(event: any): void;
    protected addRemoveToMultipleSelectedItem(event: any): void;
    protected abstract getData(): Observable<Array<T>>;
    protected abstract getSelectionPrefix(level: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractApiTreeListBox<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractApiTreeListBox<any>, never, never, { "isParentSelectable": { "alias": "isParentSelectable"; "required": false; }; "updateHierarchy": { "alias": "updateHierarchy"; "required": false; }; "selectedTreeItem": { "alias": "selectedTreeItem"; "required": false; }; "selectedIDList": { "alias": "selectedIDList"; "required": false; }; }, { "selectedTreeItemChange": "selectedTreeItemChange"; "selectedIDListChange": "selectedIDListChange"; }, never, never, true, never>;
}

declare abstract class AbstractAddRemoveList<T> extends AbstractSortableListComponent<T> implements OnInit {
    elementsList: Array<T>;
    buttonsOnBottom: boolean;
    isDisabled: boolean;
    showChecks: boolean;
    showSelectedRowsInRemoveButton: boolean;
    checkId: string;
    constructor();
    ngOnInit(): void;
    add(): void;
    remove(): void;
    getDescription(element: T): string;
    preventDefault(event: any): boolean;
    getSelectedElements(): string;
    selectElement(element: T, ev: KeyboardEvent): void;
    selectCheckbox(element: T): void;
    abstract getDescriptionField(element: T): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractAddRemoveList<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractAddRemoveList<any>, never, never, { "elementsList": { "alias": "elementsList"; "required": false; }; "buttonsOnBottom": { "alias": "buttonsOnBottom"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "showChecks": { "alias": "showChecks"; "required": false; }; "showSelectedRowsInRemoveButton": { "alias": "showSelectedRowsInRemoveButton"; "required": false; }; }, {}, never, never, true, never>;
}

declare class TreeNode<T = any> {
    label?: string;
    data?: T;
    icon?: string;
    status?: string;
    expandedIcon?: any;
    collapsedIcon?: any;
    children?: TreeNode<T>[];
    parent?: TreeNode<T>;
    leaf?: boolean;
    expanded?: boolean;
    styleClass?: string;
    selectable?: boolean;
    isNodeSelected?: boolean;
    key?: string;
}

declare abstract class AbstractTree implements OnInit {
    nodeSelected: EventEmitter<TreeNode<any>>;
    defaultExpandedIcon: string;
    defaultCollapsedIcon: string;
    _tree: TreeNode[];
    dataSource: ArrayDataSource<TreeNode<any>>;
    treeControl: NestedTreeControl<TreeNode<any>, TreeNode<any>>;
    selectedNode: TreeNode;
    get tree(): TreeNode[];
    set tree(newTree: Array<TreeNode>);
    constructor();
    ngOnInit(): void;
    hasChild: (_: number, node: TreeNode) => boolean;
    doClick(node: TreeNode): void;
    private _processData;
    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractTree, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractTree, never, never, { "tree": { "alias": "tree"; "required": false; }; }, { "nodeSelected": "nodeSelected"; }, never, never, true, never>;
}

declare class ToastRef {
    readonly id: string;
    private readonly _dismiss;
    constructor(dismissFn: () => void);
    close(): void;
}

interface ShowToastOptions {
    title: string;
    body?: string;
    action?: ToastAction;
    config?: Partial<ToastConfig>;
}
declare class ToastService {
    private readonly appConfig;
    private readonly overlay;
    private readonly parentInjector;
    private _activeToasts;
    private _config;
    private readonly _containers;
    constructor(appConfig: any, overlay: Overlay, parentInjector: Injector);
    setConfig(config: ToastConfig): void;
    getConfig(): ToastConfig;
    showError(text: string): void;
    showWarning(text: string): void;
    showInformation(text: string): void;
    showSuccess(text: string): void;
    showErrorMessage(options: ShowToastOptions | string): ToastRef;
    showWarningMessage(options: ShowToastOptions | string): ToastRef;
    showInformationMessage(options: ShowToastOptions | string): ToastRef;
    showSuccessMessage(options: ShowToastOptions | string): ToastRef;
    dismissAll(): void;
    dismiss(id: string): void;
    getActiveToasts(): ToastRef[];
    private show;
    private validateContent;
    private _getOrCreateContainer;
    private createPositionStrategy;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToastService, [{ optional: true; }, null, null]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ToastService>;
}

declare const emailValidator: (control: UntypedFormControl) => ValidationErrors | null;
declare class EmailValidatorDirective implements Validator {
    validate(control: UntypedFormControl): ValidationErrors | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<EmailValidatorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EmailValidatorDirective, "[systelab-emailValidator]", never, {}, {}, never, never, false, never>;
}

declare const phoneValidator: (control: UntypedFormControl) => ValidationErrors | null;
declare class PhoneValidatorDirective implements Validator {
    validate(control: UntypedFormControl): ValidationErrors | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<PhoneValidatorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PhoneValidatorDirective, "[systelab-phoneValidator]", never, {}, {}, never, never, false, never>;
}

declare const urlValidator: (control: UntypedFormControl) => ValidationErrors | null;
declare class UrlValidatorDirective implements Validator {
    validate(control: UntypedFormControl): ValidationErrors | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<UrlValidatorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<UrlValidatorDirective, "[systelab-urlValidator]", never, {}, {}, never, never, false, never>;
}

declare class ThemeService {
    private document;
    constructor(document: Document);
    setTheme(name?: string, agGridTheme?: string): void;
    getThemes(): Array<string>;
    private setGridTheme;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ThemeService>;
}

export { AbstractAddRemoveList, AbstractApiComboBox, AbstractApiGrid, AbstractApiListBox, AbstractApiTreeComboBox, AbstractApiTreeListBox, AbstractComboBox, AbstractGenericSearcherComponent, AbstractGrid, AbstractListBox, AbstractSearcher, AbstractSearcherComponent, AbstractSortableListComponent, AbstractTree, AbstractTreeListboxRendererComponent, Accordion, ActionButtonType, AllYesNoSelect, ApplicationFrameComponent, ApplicationHeaderComponent, ApplicationHeaderMenuEntry, ApplicationSidebarAction, ApplicationSidebarComponent, ApplicationSidebarLargeComponent, ApplicationSidebarSmallComponent, ApplicationSidebarTab, AutocompleteApiComboBox, AutofocusDirective, BreadcrumbComponent, BreadcrumbItem, BreadcrumbSubItem, ButtonComponent, CalendarDialog, CalendarDialogParameters, CalendarFooterComponent, CalendarHeaderComponent, CalendarTableComponent, CheckboxCellEditorComponent, CheckboxCellRendererComponent, ChipButtonComponent, ChipButtonItem, ChipsComponent, ColorCellRendererComponent, ColorComboBox, ComboBoxInputRenderer, ComboBoxInputRendererComponent, ComboTreeNode, ComboboxFavouriteRendererComponent, ContextMenuActionData, ContextMenuComponent, ContextMenuItemComponent, ContextMenuOption, ContextPanelComponent, CurrentSelectionStatus, DEFAULT_TOAST_CONFIG, DataFilterPipe, DateRangepicker, DatepickerComponent, DatepickerTimeComponent, DecimalInputCellEditorComponent, DialogBottomComponent, DialogHeaderComponent, DialogRef, DialogService, DraggableDirective, EmailValidatorDirective, FileSelectorComponent, GenderSelect, GridColumnsOptions, GridContextMenuActionData, GridContextMenuCellRendererComponent, GridContextMenuComponent, GridContextMenuOption, GridHeaderContextMenu, GridHeaderContextMenuComponent, ImageViewerComponent, InputCellEditorComponent, KeyName, KeyupDebounceDirective, ListBoxElement, LoadingComponent, LoadingService, MessagePopupButton, MessagePopupIcon, MessagePopupService, MessagePopupViewComponent, MessagePopupViewContext, MessageWithIconComponent, ModulabListBox, ModulabSelect, Month, MonthSelectorComponent, NavbarComponent, NavbarItem, NoYesSelect, NumPadComponent, NumPadDialog, NumPadDialogParameters, NumpadDecimalNumericDirective, PaginatorComponent, PercentageCircleComponent, PeriodSelect, PhoneValidatorDirective, Point, PositiveIntegerInputCellEditorComponent, ResizableDirective, ScrollSpyDirective, SearcherDialog, SearcherDialogParameters, SearcherTableComponent, SearcherTreeHeaderRendererComponent, SignatureCanvasComponent, SliderComponent, SliderDoubleRangeComponent, SpinnerCellEditorComponent, SpinnerCellRendererComponent, SpyMenuComponent, SpyMenuItem, StackedBarCellRendererComponent, SwitchComponent, SystelabComponentsModule, SystelabGenderListBox, SystelabModalContext, TabComponent, TabsComponent, TestIdDirective, ThemeService, TimeUnitSelectComponent, TimelineComponent, TimelineEvent, ToastComponent, ToastData, ToastPosition, ToastRef, ToastService, ToastSize, ToggleButtonComponent, ToggleSelectorComponent, TooltipContentComponent, TooltipDirective, TouchSpinValues, TouchspinComponent, TreeListBoxElement, TreeNode, TwoListComponent, TwoListItem, TwoListSortableListComponent, UrlValidatorDirective, Week, WeekSelectorComponent, WizardStep, WizardStepsComponent, emailValidator, factory, phoneValidator, urlValidator };
export type { ActionButton, ContextMenuActionFunction, ContextMenuIsEnabledFunction, DaySlot, GridContextMenuActionFunction, GridContextMenuIsEnabledFunction, GridHeaderMenuActionHandler, GridRowMenuActionHandler, IStackedBar, ModalComponent, ShowToastOptions, ToastAction, ToastConfig, ToastType, ToggleSelectorOption, rowSelectionType };