systelab-components/types/systelab-components.d.ts

systelab-components is a set of components that use wide accepted and adopted standard technologies like Angular and Bootstrap, as well as other popular libraries. Please read the ATTRIBUTION.md file for a complete list of dependencies.

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 ApplicationHeaderCompon