import * as rxjs from 'rxjs';
import { Subject, Observable } from 'rxjs';
import * as i0 from '@angular/core';
import { Injector, NgZone, Renderer2, ChangeDetectorRef, OnInit, OnChanges, OnDestroy, EventEmitter, ElementRef, SimpleChanges, AfterViewInit, TemplateRef, ViewContainerRef } from '@angular/core';
import * as i9 from '@schneideress/ra-common';
import { BaseService, RATranslateService, RAPermissionService, DomService } from '@schneideress/ra-common';
import { IWidgetInfo, IAppConfig, IDashboardInfo, IBulkAction, RaWidgetlockStatus, RADownloadType, WidgetViewState, IconfigChanges } from '@schneideress/widgetframework';
import * as i7 from 'ngx-ui-loader';
import { NgxUiLoaderService } from 'ngx-ui-loader';
import * as i8 from 'angular-notifier';
import { NotifierService } from 'angular-notifier';
import * as i4 from '@angular/common';
import * as i6 from '@angular/common/http';
import * as i10 from '@schneideress/common-controls';

declare class RaDashboardService extends BaseService {
    constructor(injector: Injector);
    private loadedScripts;
    clientId: any;
    loadExternalScript(scriptPath: string, callback: any): void;
    getWidgetsByDashboardArea(widgetInfo: IWidgetInfo, appConfig: IAppConfig): rxjs.Observable<any>;
    updateWidgets(widgetList: Array<IWidgetInfo>, appConfig: IAppConfig): rxjs.Observable<any>;
    getWidgetConfigInfo(widgetInfo: any): rxjs.Observable<never>;
    updateConfig(config: any, widgetInstanceId: number): void;
    /**To add widget to the database */
    addWidget(widgetInfo: any, appConfig: IAppConfig): rxjs.Observable<any>;
    /** To Delete current widget from DOM*/
    deleteWidget(widgetInfo: any, appConfig: IAppConfig): rxjs.Observable<any>;
    /**To Update widgetInfo in database */
    updateWidget(widgetInfo: IWidgetInfo, appConfig: IAppConfig): rxjs.Observable<any>;
    /** To Move or change position if current widget container*/
    moveWidget(widgetInfo: any): void;
    /** To Copy Current widget with same configuration*/
    copyWidget(widgetInfo: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RaDashboardService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RaDashboardService>;
}

declare class GridsterPush {
    fromSouth: string;
    fromNorth: string;
    fromEast: string;
    fromWest: string;
    private pushedItems;
    private pushedItemsTemp;
    private pushedItemsTempPath;
    private pushedItemsPath;
    private gridsterItem;
    private gridster;
    private pushedItemsOrder;
    private tryPattern;
    private iteration;
    constructor(gridsterItem: GridsterItemComponentInterface);
    destroy(): void;
    pushItems(direction: string, disable?: boolean): boolean;
    restoreTempItems(): void;
    restoreItems(): void;
    setPushedItems(): void;
    checkPushBack(): void;
    private push;
    private trySouth;
    private tryNorth;
    private tryEast;
    private tryWest;
    private addToTempPushed;
    private removeFromTempPushed;
    private addToPushed;
    private removeFromPushed;
    private removeFromPushedItem;
    private checkPushedItem;
}

declare class GridsterSwap {
    private swapedItem;
    private gridsterItem;
    private gridster;
    constructor(gridsterItem: GridsterItemComponentInterface);
    destroy(): void;
    swapItems(): void;
    checkSwapBack(): void;
    restoreSwapItem(): void;
    setSwapItem(): void;
    checkSwap(pushedBy: GridsterItemComponentInterface): void;
}

declare class GridsterDraggable {
    private zone;
    gridsterItem: GridsterItemComponentInterface;
    gridster: GridsterComponentInterface;
    lastMouse: {
        clientX: number;
        clientY: number;
    };
    offsetLeft: number;
    offsetTop: number;
    margin: number;
    outerMarginTop: number | null;
    outerMarginRight: number | null;
    outerMarginBottom: number | null;
    outerMarginLeft: number | null;
    diffTop: number;
    diffLeft: number;
    originalClientX: number;
    originalClientY: number;
    top: number;
    left: number;
    height: number;
    width: number;
    positionX: number;
    positionY: number;
    positionXBackup: number;
    positionYBackup: number;
    enabled: boolean;
    mousemove: () => void;
    mouseup: () => void;
    mouseleave: () => void;
    cancelOnBlur: () => void;
    touchmove: () => void;
    touchend: () => void;
    touchcancel: () => void;
    mousedown: () => void;
    touchstart: () => void;
    push: GridsterPush;
    swap: GridsterSwap;
    path: Array<{
        x: number;
        y: number;
    }>;
    collision: GridsterItemComponentInterface | boolean;
    constructor(gridsterItem: GridsterItemComponentInterface, gridster: GridsterComponentInterface, zone: NgZone);
    destroy(): void;
    dragStart(e: MouseEvent): void;
    dragMove: (e: MouseEvent) => void;
    calculateItemPositionFromMousePosition: (e: MouseEvent) => void;
    calculateItemPositionWithScale(e: MouseEvent, scale: number): void;
    calculateItemPositionWithoutScale(e: MouseEvent): void;
    dragStop: (e: MouseEvent) => void;
    cancelDrag: () => void;
    makeDrag: () => void;
    calculateItemPosition(): void;
    toggle(): void;
    dragStartDelay: (e: MouseEvent) => void;
    /**
     * Returns the list of directions for given mouse event
     * @param e Mouse event
     * */
    private getDirections;
}

declare class GridsterPushResize {
    fromSouth: string;
    fromNorth: string;
    fromEast: string;
    fromWest: string;
    private pushedItems;
    private pushedItemsPath;
    private gridsterItem;
    private gridster;
    private tryPattern;
    constructor(gridsterItem: GridsterItemComponentInterface);
    destroy(): void;
    pushItems(direction: string): boolean;
    restoreItems(): void;
    setPushedItems(): void;
    checkPushBack(): void;
    private push;
    private trySouth;
    private tryNorth;
    private tryEast;
    private tryWest;
    private addToPushed;
    private removeFromPushed;
    private checkPushedItem;
}

interface GridsterResizeEventType {
    north: boolean;
    south: boolean;
    west: boolean;
    east: boolean;
}

declare class GridsterResizable {
    private zone;
    gridsterItem: GridsterItemComponentInterface;
    gridster: GridsterComponentInterface;
    lastMouse: {
        clientX: number;
        clientY: number;
    };
    itemBackup: number[];
    resizeEventScrollType: GridsterResizeEventType;
    /**
     * The direction function may reference any of the `GridsterResizable` class methods, that are
     * responsible for gridster resize when the `dragmove` event is being handled. E.g. it may reference
     * the `handleNorth` method when the north handle is pressed and moved by a mouse.
     */
    private directionFunction;
    resizeEnabled: boolean;
    resizableHandles: {
        s: boolean;
        e: boolean;
        n: boolean;
        w: boolean;
        se: boolean;
        ne: boolean;
        sw: boolean;
        nw: boolean;
    };
    mousemove: () => void;
    mouseup: () => void;
    mouseleave: () => void;
    cancelOnBlur: () => void;
    touchmove: () => void;
    touchend: () => void;
    touchcancel: () => void;
    push: GridsterPush;
    pushResize: GridsterPushResize;
    minHeight: number;
    minWidth: number;
    offsetTop: number;
    offsetLeft: number;
    diffTop: number;
    diffLeft: number;
    diffRight: number;
    diffBottom: number;
    margin: number;
    outerMarginTop: number | null;
    outerMarginRight: number | null;
    outerMarginBottom: number | null;
    outerMarginLeft: number | null;
    originalClientX: number;
    originalClientY: number;
    top: number;
    left: number;
    bottom: number;
    right: number;
    width: number;
    height: number;
    newPosition: number;
    constructor(gridsterItem: GridsterItemComponentInterface, gridster: GridsterComponentInterface, zone: NgZone);
    destroy(): void;
    dragStart(e: MouseEvent): void;
    dragMove: (e: MouseEvent) => void;
    dragStop: (e: MouseEvent) => void;
    cancelResize: () => void;
    makeResize: () => void;
    private handleNorth;
    private handleWest;
    private handleSouth;
    private handleEast;
    private handleNorthWest;
    private handleNorthEast;
    private handleSouthWest;
    private handleSouthEast;
    toggle(): void;
    dragStartDelay(e: MouseEvent | TouchEvent): void;
    setItemTop(top: number): void;
    setItemLeft(left: number): void;
    setItemHeight(height: number): void;
    setItemWidth(width: number): void;
}

declare abstract class GridsterItemComponentInterface {
    item: GridsterItem;
    $item: GridsterItem;
    top: number;
    left: number;
    width: number;
    height: number;
    drag: GridsterDraggable;
    resize: GridsterResizable;
    notPlaced: boolean;
    updateOptions: () => void;
    itemChanged: () => void;
    setSize: () => void;
    checkItemChanges: (newValue: GridsterItem, oldValue: GridsterItem) => void;
    canBeDragged: () => boolean;
    canBeResized: () => boolean;
    getResizableHandles: () => {
        s: boolean;
        e: boolean;
        n: boolean;
        w: boolean;
        se: boolean;
        ne: boolean;
        sw: boolean;
        nw: boolean;
    };
    bringToFront: (offset: number) => void;
    sendToBack: (v: number) => void;
    el: HTMLElement;
    gridster: GridsterComponentInterface;
    renderer: Renderer2;
}
interface GridsterItem {
    x: number;
    y: number;
    rows: number;
    cols: number;
    layerIndex?: number;
    initCallback?: (item: GridsterItem, itemComponent: GridsterItemComponentInterface) => void;
    dragEnabled?: boolean;
    resizeEnabled?: boolean;
    resizableHandles?: {
        s?: boolean;
        e?: boolean;
        n?: boolean;
        w?: boolean;
        se?: boolean;
        ne?: boolean;
        sw?: boolean;
        nw?: boolean;
    };
    compactEnabled?: boolean;
    maxItemRows?: number;
    minItemRows?: number;
    maxItemCols?: number;
    minItemCols?: number;
    minItemArea?: number;
    maxItemArea?: number;
    [propName: string]: any;
    curRowHeight?: number;
    widgetHeight?: number;
    widgetInfo?: any;
}

type gridTypes = 'fit' | 'scrollVertical' | 'scrollHorizontal' | 'fixed' | 'verticalFixed' | 'horizontalFixed';
type displayGrids = 'always' | 'onDrag&Resize' | 'none';
type compactTypes = 'none' | 'compactUp' | 'compactLeft' | 'compactUp&Left' | 'compactLeft&Up' | 'compactRight' | 'compactUp&Right' | 'compactRight&Up' | 'compactDown' | 'compactDown&Left' | 'compactLeft&Down' | 'compactDown&Right' | 'compactRight&Down';
type dirTypes = 'ltr' | 'rtl';
interface GridsterConfig {
    gridType?: gridTypes;
    scale?: number;
    fixedColWidth?: number;
    fixedRowHeight?: number;
    keepFixedHeightInMobile?: boolean;
    keepFixedWidthInMobile?: boolean;
    setGridSize?: boolean;
    compactType?: compactTypes;
    mobileBreakpoint?: number;
    allowMultiLayer?: boolean;
    defaultLayerIndex?: number;
    maxLayerIndex?: number;
    baseLayerIndex?: number;
    minCols?: number;
    maxCols?: number;
    minRows?: number;
    maxRows?: number;
    defaultItemCols?: number;
    defaultItemRows?: number;
    maxItemCols?: number;
    maxItemRows?: number;
    minItemCols?: number;
    minItemRows?: number;
    minItemArea?: number;
    maxItemArea?: number;
    addEmptyRowsCount?: number;
    rowHeightRatio?: number;
    margin?: number;
    outerMargin?: boolean;
    outerMarginTop?: number | null;
    outerMarginRight?: number | null;
    outerMarginBottom?: number | null;
    outerMarginLeft?: number | null;
    useTransformPositioning?: boolean;
    scrollSensitivity?: number | null;
    scrollSpeed?: number;
    initCallback?: (gridster: GridsterComponentInterface) => void;
    destroyCallback?: (gridster: GridsterComponentInterface) => void;
    gridSizeChangedCallback?: (gridster: GridsterComponentInterface) => void;
    itemChangeCallback?: (item: GridsterItem, itemComponent: GridsterItemComponentInterface) => void;
    itemResizeCallback?: (item: GridsterItem, itemComponent: GridsterItemComponentInterface) => void;
    itemInitCallback?: (item: GridsterItem, itemComponent: GridsterItemComponentInterface) => void;
    itemRemovedCallback?: (item: GridsterItem, itemComponent: GridsterItemComponentInterface) => void;
    itemValidateCallback?: (item: GridsterItem) => boolean;
    draggable?: Draggable$1;
    resizable?: Resizable$1;
    swap?: boolean;
    swapWhileDragging?: boolean;
    pushItems?: boolean;
    disablePushOnDrag?: boolean;
    disablePushOnResize?: boolean;
    disableAutoPositionOnConflict?: boolean;
    pushDirections?: PushDirections$1;
    pushResizeItems?: boolean;
    displayGrid?: displayGrids;
    disableWindowResize?: boolean;
    disableWarnings?: boolean;
    scrollToNewItems?: boolean;
    disableScrollHorizontal?: boolean;
    disableScrollVertical?: boolean;
    enableBoundaryControl?: boolean;
    enableEmptyCellClick?: boolean;
    enableEmptyCellContextMenu?: boolean;
    enableEmptyCellDrop?: boolean;
    enableEmptyCellDrag?: boolean;
    enableOccupiedCellDrop?: boolean;
    emptyCellClickCallback?: (event: MouseEvent, item: GridsterItem) => void;
    emptyCellContextMenuCallback?: (event: MouseEvent, item: GridsterItem) => void;
    emptyCellDropCallback?: (event: DragEvent, item: GridsterItem) => void;
    emptyCellDragCallback?: (event: MouseEvent, item: GridsterItem) => void;
    emptyCellDragMaxCols?: number;
    emptyCellDragMaxRows?: number;
    ignoreMarginInRow?: boolean;
    dirType?: dirTypes;
    api?: {
        resize?: () => void;
        optionsChanged?: () => void;
        getNextPossiblePosition?: (newItem: GridsterItem) => boolean;
        getFirstPossiblePosition?: (item: GridsterItem) => GridsterItem;
        getLastPossiblePosition?: (item: GridsterItem) => GridsterItem;
        getCurrentRowHeight?: () => number;
        getItemComponent?: (item: GridsterItem) => GridsterItemComponentInterface | undefined;
    };
    [propName: string]: any;
}
interface DragBase$1 {
    enabled?: boolean;
    stop?: (item: GridsterItem, itemComponent: GridsterItemComponentInterface, event: MouseEvent) => Promise<any> | void;
    start?: (item: GridsterItem, itemComponent: GridsterItemComponentInterface, event: MouseEvent) => void;
    delayStart?: number;
}
interface Draggable$1 extends DragBase$1 {
    ignoreContentClass?: string;
    ignoreContent?: boolean;
    dragHandleClass?: string;
    dropOverItems?: boolean;
    dropOverItemsCallback?: (source: GridsterItem, target: GridsterItem, grid?: GridsterComponentInterface) => void;
}
interface Resizable$1 extends DragBase$1 {
    handles?: {
        s: boolean;
        e: boolean;
        n: boolean;
        w: boolean;
        se: boolean;
        ne: boolean;
        sw: boolean;
        nw: boolean;
    };
}
interface PushDirections$1 {
    north: boolean;
    east: boolean;
    south: boolean;
    west: boolean;
}

interface GridsterConfigS {
    gridType: gridTypes;
    scale?: number;
    fixedColWidth: number;
    fixedRowHeight: number;
    keepFixedHeightInMobile: boolean;
    keepFixedWidthInMobile: boolean;
    setGridSize: boolean;
    compactType: compactTypes;
    mobileBreakpoint: number;
    useBodyForBreakpoint: boolean;
    allowMultiLayer: boolean;
    defaultLayerIndex: number;
    maxLayerIndex: number;
    baseLayerIndex: number;
    minCols: number;
    maxCols: number;
    minRows: number;
    maxRows: number;
    defaultItemCols: number;
    defaultItemRows: number;
    maxItemCols: number;
    maxItemRows: number;
    minItemCols: number;
    minItemRows: number;
    minItemArea: number;
    maxItemArea: number;
    addEmptyRowsCount: number;
    rowHeightRatio: number;
    margin: number;
    outerMargin: boolean;
    outerMarginTop: number | null;
    outerMarginRight: number | null;
    outerMarginBottom: number | null;
    outerMarginLeft: number | null;
    useTransformPositioning: boolean;
    scrollSensitivity: number;
    scrollSpeed: number;
    draggable: Draggable;
    resizable: Resizable;
    swap: boolean;
    swapWhileDragging: boolean;
    pushItems: boolean;
    disablePushOnDrag: boolean;
    disablePushOnResize: boolean;
    disableAutoPositionOnConflict: boolean;
    pushDirections: PushDirections;
    pushResizeItems: boolean;
    displayGrid: displayGrids;
    disableWindowResize: boolean;
    disableWarnings: boolean;
    scrollToNewItems: boolean;
    disableScrollHorizontal?: boolean;
    disableScrollVertical?: boolean;
    enableBoundaryControl?: boolean;
    enableEmptyCellClick: boolean;
    enableEmptyCellContextMenu: boolean;
    enableEmptyCellDrop: boolean;
    enableEmptyCellDrag: boolean;
    enableOccupiedCellDrop: boolean;
    emptyCellDragMaxCols: number;
    emptyCellDragMaxRows: number;
    ignoreMarginInRow: boolean;
    dirType: dirTypes;
    api: {
        resize?: () => void;
        optionsChanged?: () => void;
        getNextPossiblePosition: (newItem: GridsterItem) => boolean;
        getFirstPossiblePosition: (item: GridsterItem) => GridsterItem;
        getLastPossiblePosition: (item: GridsterItem) => GridsterItem;
        getItemComponent: (item: GridsterItem) => GridsterItemComponentInterface | undefined;
    };
    [propName: string]: any;
}
interface DragBase {
    enabled: boolean;
    delayStart: number;
    [propName: string]: any;
}
interface Draggable extends DragBase {
    ignoreContentClass: string;
    ignoreContent: boolean;
    dragHandleClass: string;
    dropOverItems: boolean;
    dropOverItemsCallback: (source: GridsterItem, target: GridsterItem, grid?: GridsterComponentInterface) => void;
}
interface Resizable extends DragBase {
    handles: {
        s: boolean;
        e: boolean;
        n: boolean;
        w: boolean;
        se: boolean;
        ne: boolean;
        sw: boolean;
        nw: boolean;
    };
}
interface PushDirections {
    north: boolean;
    east: boolean;
    south: boolean;
    west: boolean;
}

declare class GridsterEmptyCell {
    private gridster;
    initialItem: GridsterItem | null;
    removeEmptyCellClickListenerFn: (() => void) | null;
    removeEmptyCellTouchendListenerFn: (() => void) | null;
    removeEmptyCellContextMenuListenerFn: (() => void) | null;
    removeEmptyCellDropListenerFn: (() => void) | null;
    removeEmptyCellMousedownListenerFn: (() => void) | null;
    removeEmptyCellTouchstartListenerFn: (() => void) | null;
    removeWindowMousemoveListenerFn: () => void;
    removeWindowTouchmoveListenerFn: () => void;
    removeWindowMouseupListenerFn: () => void;
    removeWindowTouchendListenerFn: () => void;
    removeEmptyCellDragoverListenerFn: (() => void) | null;
    removeDocumentDragendListenerFn: (() => void) | null;
    constructor(gridster: GridsterComponentInterface);
    destroy(): void;
    updateOptions(): void;
    emptyCellClickCb: (e: MouseEvent) => void;
    emptyCellContextMenuCb: (e: MouseEvent) => void;
    emptyCellDragDrop: (e: DragEvent) => void;
    emptyCellDragOver: (e: DragEvent) => void;
    emptyCellMouseDown: (e: MouseEvent) => void;
    emptyCellMouseMove: (e: MouseEvent) => void;
    emptyCellMouseUp: (e: MouseEvent) => void;
    getPixelsX(e: MouseEvent, rect: ClientRect): number;
    getPixelsY(e: MouseEvent, rect: ClientRect): number;
    getValidItemFromEvent(e: MouseEvent, oldItem?: GridsterItem | null): GridsterItem | undefined;
}

declare class GridsterCompact {
    private gridster;
    constructor(gridster: GridsterComponentInterface);
    destroy(): void;
    checkCompact(): void;
    checkCompactItem(item: GridsterItem): void;
    private checkCompactMovement;
    private moveTillCollision;
}

interface CommonGridStyle {
    [key: string]: string;
}

declare class GridsterRenderer {
    private gridster;
    /**
     * Caches the last grid column styles.
     * This improves the grid responsiveness by caching and reusing the last style object instead of creating a new one.
     */
    private lastGridColumnStyles;
    /**
     * Caches the last grid column styles.
     * This improves the grid responsiveness by caching and reusing the last style object instead of creating a new one.
     */
    private lastGridRowStyles;
    constructor(gridster: GridsterComponentInterface);
    destroy(): void;
    updateItem(el: Element, item: GridsterItem, renderer: Renderer2): void;
    updateGridster(): void;
    getGridColumnStyle(i: number): CommonGridStyle;
    getGridRowStyle(i: number): CommonGridStyle;
    getLeftPosition(d: number): {
        left: string;
    } | {
        transform: string;
    };
    getTopPosition(d: number): {
        top: string;
    } | {
        transform: string;
    };
    clearCellPosition(renderer: Renderer2, el: Element): void;
    setCellPosition(renderer: Renderer2, el: Element, x: number, y: number): void;
    getLeftMargin(): number;
    getTopMargin(): number;
}

declare abstract class GridsterComponentInterface {
    $options: GridsterConfigS;
    grid: GridsterItemComponentInterface[];
    checkCollision: (item: GridsterItem) => GridsterItemComponentInterface | boolean;
    checkCollisionForSwaping: (item: GridsterItem) => GridsterItemComponentInterface | boolean;
    positionXToPixels: (x: number) => number;
    pixelsToPositionX: (x: number, roundingMethod: (x: number) => number, noLimit?: boolean) => number;
    positionYToPixels: (y: number) => number;
    pixelsToPositionY: (y: number, roundingMethod: (x: number) => number, noLimit?: boolean) => number;
    findItemWithItem: (item: GridsterItem) => GridsterItemComponentInterface | boolean;
    findItemsWithItem: (item: GridsterItem) => GridsterItemComponentInterface[];
    checkGridCollision: (item: GridsterItem) => boolean;
    checkCollisionTwoItems: (item: GridsterItem, item2: GridsterItem) => boolean;
    getItemComponent: (item: GridsterItem) => GridsterItemComponentInterface | undefined;
    el: HTMLElement;
    renderer: Renderer2;
    gridRenderer: GridsterRenderer;
    cdRef: ChangeDetectorRef;
    options: GridsterConfig;
    calculateLayout$: Subject<void>;
    updateGrid: () => void;
    movingItem: GridsterItem | null;
    addItem: (item: GridsterItemComponentInterface) => void;
    removeItem: (item: GridsterItemComponentInterface) => void;
    previewStyle: (drag?: boolean) => void;
    mobile: boolean;
    curWidth: number;
    curHeight: number;
    columns: number;
    rows: number;
    curColWidth: number;
    curRowHeight: number;
    windowResize: (() => void) | null;
    setGridDimensions: () => void;
    dragInProgress: boolean;
    emptyCell: GridsterEmptyCell;
    compact: GridsterCompact;
    zone: NgZone;
    gridRows: Array<number>;
    gridColumns: Array<number>;
}

declare class GridsterComponent implements OnInit, OnChanges, OnDestroy, GridsterComponentInterface {
    renderer: Renderer2;
    cdRef: ChangeDetectorRef;
    zone: NgZone;
    options: GridsterConfig;
    movingItem: GridsterItem | null;
    el: HTMLElement;
    $options: GridsterConfigS;
    mobile: boolean;
    curWidth: number;
    curHeight: number;
    grid: GridsterItemComponentInterface[];
    columns: number;
    rows: number;
    curColWidth: number;
    curRowHeight: number;
    gridColumns: never[];
    gridRows: never[];
    windowResize: (() => void) | null;
    dragInProgress: boolean;
    emptyCell: GridsterEmptyCell;
    compact: GridsterCompact;
    gridRenderer: GridsterRenderer;
    previewStyle$: EventEmitter<GridsterItem | null>;
    calculateLayout$: Subject<void>;
    private resize$;
    private destroy$;
    constructor(el: ElementRef, renderer: Renderer2, cdRef: ChangeDetectorRef, zone: NgZone);
    static checkCollisionTwoItemsForSwaping(item: GridsterItem, item2: GridsterItem): boolean;
    checkCollisionTwoItems(item: GridsterItem, item2: GridsterItem): boolean;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    getCurrentRowHeight(): number;
    private resize;
    setOptions(): void;
    optionsChanged: () => void;
    ngOnDestroy(): void;
    onResize: () => void;
    checkIfToResize(): boolean;
    checkIfMobile(): boolean;
    setGridSize(): void;
    setGridDimensions(): void;
    private calculateLayout;
    updateGrid(): void;
    addItem(itemComponent: GridsterItemComponentInterface): void;
    removeItem(itemComponent: GridsterItemComponentInterface): void;
    checkCollision(item: GridsterItem): GridsterItemComponentInterface | boolean;
    checkGridCollision(item: GridsterItem): boolean;
    findItemWithItem(item: GridsterItem): GridsterItemComponentInterface | boolean;
    findItemsWithItem(item: GridsterItem): Array<GridsterItemComponentInterface>;
    autoPositionItem(itemComponent: GridsterItemComponentInterface): void;
    getNextPossiblePosition: (newItem: GridsterItem, startingFrom?: {
        y?: number;
        x?: number;
    }) => boolean;
    getFirstPossiblePosition: (item: GridsterItem) => GridsterItem;
    getLastPossiblePosition: (item: GridsterItem) => GridsterItem;
    pixelsToPositionX(x: number, roundingMethod: (x: number) => number, noLimit?: boolean): number;
    pixelsToPositionY(y: number, roundingMethod: (x: number) => number, noLimit?: boolean): number;
    positionXToPixels(x: number): number;
    positionYToPixels(y: number): number;
    getItemComponent(item: GridsterItem): GridsterItemComponentInterface | undefined;
    checkCollisionForSwaping(item: GridsterItem): GridsterItemComponentInterface | boolean;
    findItemWithItemForSwapping(item: GridsterItem): GridsterItemComponentInterface | boolean;
    previewStyle(drag?: boolean): void;
    private static getNewArrayLength;
    static ɵfac: i0.ɵɵFactoryDeclaration<GridsterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GridsterComponent, "gridster", never, { "options": { "alias": "options"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class GridsterItemComponent implements OnInit, OnDestroy, OnChanges, GridsterItemComponentInterface {
    renderer: Renderer2;
    private zone;
    item: GridsterItem;
    itemInit: EventEmitter<{
        item: GridsterItem;
        itemComponent: GridsterItemComponentInterface;
    }>;
    itemChange: EventEmitter<{
        item: GridsterItem;
        itemComponent: GridsterItemComponentInterface;
    }>;
    itemResize: EventEmitter<{
        item: GridsterItem;
        itemComponent: GridsterItemComponentInterface;
    }>;
    $item: GridsterItem;
    el: HTMLElement;
    gridster: GridsterComponent;
    top: number;
    left: number;
    width: number;
    height: number;
    drag: GridsterDraggable;
    resize: GridsterResizable;
    notPlaced: boolean;
    init: boolean;
    get zIndex(): number;
    constructor(el: ElementRef, gridster: GridsterComponent, renderer: Renderer2, zone: NgZone);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    updateOptions(): void;
    ngOnDestroy(): void;
    setSize(): void;
    updateItemSize(): void;
    itemChanged(): void;
    checkItemChanges(newValue: GridsterItem, oldValue: GridsterItem): void;
    canBeDragged(): boolean;
    canBeResized(): boolean;
    getResizableHandles(): {
        s: boolean;
        e: boolean;
        n: boolean;
        w: boolean;
        se: boolean;
        ne: boolean;
        sw: boolean;
        nw: boolean;
    };
    bringToFront(offset: number): void;
    sendToBack(offset: number): void;
    private getLayerIndex;
    static ɵfac: i0.ɵɵFactoryDeclaration<GridsterItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GridsterItemComponent, "gridster-item", never, { "item": { "alias": "item"; "required": false; }; }, { "itemInit": "itemInit"; "itemChange": "itemChange"; "itemResize": "itemResize"; }, never, ["*"], true, never>;
}

declare class GridsterModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<GridsterModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<GridsterModule, never, [typeof GridsterComponent, typeof GridsterItemComponent], [typeof GridsterComponent, typeof GridsterItemComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<GridsterModule>;
}

declare class RADashboardEventBus {
    private eventQueue;
    /**
     * To emit an event with the name & data
     */
    publish(eventName: string, data: any): void;
    /**
    * To emit an event with the name, data, key & value
    */
    publishWithKey(eventName: string, data: any, key: string, value: string): void;
    /**
    * To subscribe to an event with the name
    */
    subscribe(eventName: string): Observable<any>;
    /**
    * To subscribe to an event with the name key & value
    */
    subscribeWithKey(eventName: string, key: string, value: string): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<RADashboardEventBus, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RADashboardEventBus>;
}

declare class RADashboardResponsiveService {
    resized: Subject<unknown>;
    maxColsDesktop: number;
    private screenWidthAdjusted;
    private screenWidth;
    private resInfo;
    private currentResInfo;
    constructor();
    private setScreenWidth;
    get IsDesktopView(): boolean;
    get IsMobile(): boolean;
    getGridsterConfig(isWidgetMgmnt: boolean, resize: boolean, canMove: boolean): GridsterConfig;
    /**To map IwidgetInfo object to gridsterItem */
    getGridsterItem(widget: any): GridsterItem;
    private getWidth;
    private getMinItemRows;
    private getMinItemCols;
    private getHeight;
    static ɵfac: i0.ɵɵFactoryDeclaration<RADashboardResponsiveService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RADashboardResponsiveService>;
}

declare class RADashboardArea implements OnInit, OnChanges, OnDestroy {
    private dashboardService;
    private ngZone;
    private ngxService;
    private translateService;
    private notifier;
    private cdr;
    private responsiveService;
    private permissionService;
    widgetList: GridsterItem[];
    options: GridsterConfig;
    gridheight: number;
    gridsterHeight: string;
    gridcellHeight: number;
    userWidgets: any[];
    PAMWidgets: any;
    private conifgAddClick;
    private curatedFilterChange;
    private bulkActionClick;
    private calculateLayout;
    private rearrangeWidgetClick;
    private widgetDeleteEvent;
    private widgetAddEvent;
    private widgetLibraryDoneClick;
    private isWidgetLoaded;
    domResized: boolean;
    showEmptyDashboard: boolean;
    showDownloadOnlyState: boolean;
    isWidgetMgmnt: boolean;
    lastViewType: string;
    emptyDashboardTitle: any;
    emptyDashboardMsg1: any;
    emptyDashboardMsg2: any;
    emptyDashboardButtonText: any;
    emptyDashboardButtonIcon: any;
    DownloadOnlyStateTitle: any;
    DownloadOnlyStateMsg1: any;
    DownloadOnlyStateMsg2: any;
    DownloadOnlyStateButtonText1: any;
    DownloadOnlyStateButtonIcon1: any;
    DownloadOnlyStateButtonText2: any;
    DownloadOnlyStateButtonIcon2: any;
    emptyDashboardButtonAction: any;
    DownloadOnlyStateButtonAction1: any;
    DownloadOnlyStateButtonAction2: any;
    hasGrid: boolean;
    private initialWidgetCount;
    private currentLoadingCount;
    isSiteDetailDashboard: boolean;
    userDashboardId: number;
    areaKey: string;
    downloadDatastreamLimit: any;
    reportDatastreamLimit: any;
    globalFilter: any;
    raDashboardEventBus: RADashboardEventBus;
    widgetHeight: number;
    widgetWidth: number;
    appConfig: IAppConfig;
    dashboardInfo: IDashboardInfo;
    isIndicatorDashboard: boolean;
    templateConfig: any;
    bulkActionData: IBulkAction;
    widgetCount: number;
    hideDashboardBanner: EventEmitter<any>;
    gridWrapper: ElementRef;
    private scrollTrigger;
    gridItem: any;
    constructor(dashboardService: RaDashboardService, ngZone: NgZone, ngxService: NgxUiLoaderService, translateService: RATranslateService, notifier: NotifierService, cdr: ChangeDetectorRef, responsiveService: RADashboardResponsiveService, permissionService: RAPermissionService);
    scroll(): void;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewChecked(): void;
    setEmptyDashboardConfig(): void;
    setDownloadOnlyStateConfig(): void;
    /**To set GridsterConfig */
    initiateGridsterConfig(): void;
    widgetLoaded(widgetElement: any, widget: any): void;
    private loadData;
    changeInitialWidgetCount(): void;
    dataLoaded(widgetInfo: any): void;
    private isElementLoaded;
    private loadWidgetWrappers;
    /** To initiate eventbus subsctiptions */
    inititateEventBusSubscritions(): void;
    /**
     * temp fix- recursive method to iterate over the list of items
     * and add them to gridster in the given order
     * @param widgetList  -list of widgets
     * @param index -index of the current value to be added
     */
    addWidgetListToGridster(widgetList: any, index: number): void;
    ngOnDestroy(): void;
    /**To update position/dimention of all widgets in the area */
    updateWidgets(): boolean;
    /**To update widget dimensions */
    updateWidgetPosition(widgetInstanceId: number): boolean;
    /**To restrict request payload to be of min size (position & size details) */
    formatWidgetDataForPositionDetails(widgetItemList: IWidgetInfo[]): any;
    /** To retrieve widgets based on userDashboardid and area name */
    loadWidgets(userDashboarId: number, areaKey: string): void;
    /**
     * Arranges widgets in a 2-column grid layout for Site Detail dashboard
     * @param widgets - Array of widget objects to be arranged
     * @returns Modified widgets array with updated positions and dimensions. If more widgets exist than maxWidgetCount, only the last N widgets are positioned in the grid.
     *
     * Layout pattern (for last N widgets in 2-column layout):
     * - Widget n-3: x=0, y=0 (top-left)
     * - Widget n-2: x=4, y=0 (top-right)
     * - Widget n-1: x=0, y=2 (second row-left)
     * - Widget n: x=4, y=2 (second row-right)
     *
     * Additional widgets beyond maxWidgetCount are removed from the beginning of the array.
     */
    arrangeWidgetsInTwoColumnGrid(widgets: any): any;
    /** To set Area(Gridster) height dynamically as widgets are added/removed */
    setAreaHeight(): void;
    /** To remove a widget instance from dashboard and to save info in database */
    deleteWidget(widgetInstanceId: any, isalertDisabled?: boolean): void;
    /**To rearrange widgets position in the dashboard, compactLeft&Up,compactLeft,compactUp,etc*/
    rearrangeWidgets(): void;
    /**To add widget instance to the database with the next available position and to make changes in
     * dashboard area.
     */
    addWidget(data: any): void;
    private setPositions;
    /** To add widget to current widget list ,invoked from copy widget window*/
    copyWidget(data: any): void;
    mapObjectListToGridsterItemList(widgetList: Array<IWidgetInfo>): GridsterItem[];
    mapGridsterItemToObject(widgetItem: GridsterItem): IWidgetInfo;
    mapGridsterListToObject(widgetItemList: Array<GridsterItem>): IWidgetInfo[];
    buttonClick(): void;
    buttonActionClick(action: any): void;
    updateAppliedFilters(data: any): void;
    checkPAMWidgets(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RADashboardArea, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RADashboardArea, "ra-dashboard-area", never, { "userDashboardId": { "alias": "user-dashboard-id"; "required": false; }; "areaKey": { "alias": "area-key"; "required": false; }; "downloadDatastreamLimit": { "alias": "download-datastream-limit"; "required": false; }; "reportDatastreamLimit": { "alias": "report-datastream-limit"; "required": false; }; "globalFilter": { "alias": "global-filter"; "required": false; }; "raDashboardEventBus": { "alias": "event-bus"; "required": false; }; "widgetHeight": { "alias": "widget-height"; "required": false; }; "widgetWidth": { "alias": "widget-width"; "required": false; }; "appConfig": { "alias": "app-config"; "required": false; }; "dashboardInfo": { "alias": "dashboard-info"; "required": false; }; "isIndicatorDashboard": { "alias": "isIndicatorDashboard"; "required": false; }; "templateConfig": { "alias": "templateConfig"; "required": false; }; "bulkActionData": { "alias": "bulk_Action_Data"; "required": false; }; "widgetCount": { "alias": "widget-count"; "required": false; }; }, { "hideDashboardBanner": "hideDashboardBanner"; }, never, never, false, never>;
}

declare class LockTooltip implements OnInit {
    private domService;
    element: any;
    title: any;
    data: any;
    footer: any;
    template: any;
    containerLeft: any;
    containerTop: any;
    containerBottom: any;
    constructor(domService: DomService);
    ngOnInit(): void;
    private setPopupPosition;
    removeMe(comp: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LockTooltip, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LockTooltip, "ra-lock-tooltip", never, {}, {}, never, never, false, never>;
}

declare class RAWidgetContainer implements OnInit, OnChanges, AfterViewInit, OnDestroy {
    private dashboardService;
    private ngxService;
    private translateService;
    private ngZone;
    private notifier;
    private renderer;
    private cdr;
    private raPermissionService;
    private domService;
    showPanel: boolean;
    private isWidgetLoaded;
    private widgetElement;
    private configChanged;
    widgetHeight: number;
    lockClass: string;
    lockStatus: RaWidgetlockStatus;
    isDownloadIconVisible: boolean;
    isChartDownloadVisible: boolean;
    isGridDownloadVisible: boolean;
    downloadIconType: RADownloadType;
    enableTitleLine: boolean;
    isGlobalFilterApplied: boolean;
    toolTipValue: string;
    toolTipWidth: string;
    lockDetails: any;
    hideLock: boolean;
    lockTemplateInfo: TemplateRef<any>;
    editToolTipValue: string;
    copyToolTipValue: string;
    moveToolTipValue: string;
    excelToolTipValue: string;
    deleteToolTipValue: string;
    editText: string;
    copyText: string;
    moveText: string;
    excelText: string;
    deleteText: string;
    editToolTipWidth: string;
    copyToolTipWidth: string;
    moveToolTipWidth: string;
    excelToolTipWidth: string;
    deleteToolTipWidth: string;
    widgetSettings: any;
    noPadding: boolean;
    isMouseHover: boolean;
    showSettingsLink: boolean;
    isKpiView: boolean;
    showExcell: boolean;
    hideTitle: boolean;
    inapplicableFilters: any;
    popupInstance: LockTooltip;
    currentComponent: any;
    lockIconTitle: any;
    lockIconFooter: any;
    inapplicableIconTitle: any;
    inapplicableIconFooter: any;
    isCustomElement: any;
    showOnlyDropdown: boolean;
    private trendsReportDownloadRequestSub;
    ctlWidget: ElementRef;
    ctlWidgetModule: ViewContainerRef;
    widgetDropdown: ElementRef;
    searchInput: ElementRef;
    wcWrapper: ElementRef;
    banPopupDiv: ElementRef;
    lockPopupDiv: ElementRef;
    widgetInstanceId: number;
    globalFilter: any;
    dashboardInfo: IDashboardInfo;
    data: any;
    raDashboardEventBus: RADashboardEventBus;
    appConfig: IAppConfig;
    width: number;
    height: number;
    gridCellHeight: number;
    bulkActionData: IBulkAction;
    canLoadData: boolean;
    widgetDeleted: EventEmitter<string>;
    updateAppliedFilters: EventEmitter<any>;
    lockTitle: string;
    dataLoaded: EventEmitter<any>;
    widgetLoaded: EventEmitter<any>;
    isWidgetStateApplicable: boolean;
    isWidgetCanMove: boolean;
    widgetEmptyState: string;
    domResized: boolean;
    lockVisible: boolean;
    lockedFields: any;
    detailPageUrl: string;
    baseUrl: string;
    isWidgetMgmnt: boolean;
    WidgetDisplayName: string;
    enableTitleLineActual: boolean;
    widgetElementHandler: any;
    set setResized(resized: boolean);
    constructor(dashboardService: RaDashboardService, ngxService: NgxUiLoaderService, translateService: RATranslateService, ngZone: NgZone, notifier: NotifierService, renderer: Renderer2, cdr: ChangeDetectorRef, raPermissionService: RAPermissionService, domService: DomService);
    ngOnInit(): void;
    get widgetViewState(): typeof WidgetViewState;
    /** True when Widget_Config has hideEllipses: true (widget shows inline actions instead of ellipsis menu). */
    get hideEllipses(): boolean;
    /** True when the inline Download icon should be shown (hidden when Statistics tab is selected). */
    get showInlineDownloadIcon(): boolean;
    ngOnChanges(changes: SimpleChanges): void;
    invokeWidgetResizedEvent(): void;
    mouseHover(isHover?: boolean): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    /** To Edit current widget configuration*/
    editWidget(): void;
    /** To Delete current widget from DOM*/
    deleteWidget(): void;
    /** To Move or change position if current widget container*/
    moveWidget(): void;
    /** To Copy Current widget with same configuration*/
    copyWidget(): void;
    visitPage(): void;
    getHostUrl(): string;
    configChangeEventHandler(widgetInfo: any): void;
    private generateConfigFilter;
    /**  To load external custom element to the widget container*/
    loadWidget(widgetInfo: any): Promise<void>;
    /**To set Default State for the widget when it is not configured */
    setNotConfiguredState(widgetInfo: IWidgetInfo, forceEnable?: boolean): void;
    /**To configure empty state for the widget  */
    setEmptyState(widgetState: any): void;
    getConfigChanges(configChanged?: boolean): IconfigChanges;
    /** To refresh widget on input config changes */
    refreshWidget(widgetInfo: IWidgetInfo, configChanged?: boolean): Promise<void>;
    mouseOver(event: any): void;
    private setLock;
    setDownloadIcon(): Promise<void>;
    downloadIconClicked(type: string): void;
    /** Trends Report: open download format modal (persistent Download icon click) */
    onTrendReportDownloadClick(): Promise<void>;
    private removeMenu;
    private checkVisitLinkVisiblity;
    /**Show dropdown on gear icon click  */
    showDropDown(e: any): void;
    private addEventListener;
    private getContenxtHtml;
    private getHr;
    private getHtmlForButton;
    private getParsedConfig;
    private applayWidgetSettings;
    private setInapplicableFilters;
    openPopup(title: any, data: any, footer: any, type: any, template?: any): void;
    closePopup(): void;
    getwidgetTitleTranslation(item: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<RAWidgetContainer, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RAWidgetContainer, "ra-widget-container", never, { "widgetInstanceId": { "alias": "widget-instance-id"; "required": false; }; "globalFilter": { "alias": "global-filter"; "required": false; }; "dashboardInfo": { "alias": "dashboard-info"; "required": false; }; "data": { "alias": "data"; "required": false; }; "raDashboardEventBus": { "alias": "event-bus"; "required": false; }; "appConfig": { "alias": "app-config"; "required": false; }; "width": { "alias": "widget-width"; "required": false; }; "height": { "alias": "widget-height"; "required": false; }; "gridCellHeight": { "alias": "grid-cell-height"; "required": false; }; "bulkActionData": { "alias": "bulk-action-data"; "required": false; }; "canLoadData": { "alias": "canLoadData"; "required": false; }; "setResized": { "alias": "dom-resized"; "required": false; }; }, { "widgetDeleted": "widgetDeleted"; "updateAppliedFilters": "updateAppliedFilters"; "dataLoaded": "dataLoaded"; "widgetLoaded": "widgetLoaded"; }, never, never, false, never>;
}

declare class DashboardFrameworkModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DashboardFrameworkModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DashboardFrameworkModule, [typeof RADashboardArea, typeof RAWidgetContainer, typeof LockTooltip], [typeof i4.CommonModule, typeof GridsterModule, typeof i6.HttpClientModule, typeof i7.NgxUiLoaderModule, typeof i8.NotifierModule, typeof i9.RACommonModule, typeof i10.RACommonControlsModule], [typeof RADashboardArea]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DashboardFrameworkModule>;
}

declare enum RAEvent {
    /** widget selection click on widget library */
    WidgetSelected = "widgetSelected",
    /** triggers when user click on the edit link in widget container */
    WidgetEditClicked = "widgetEditClicked",
    /** triggers when user clicks the cancel button on widget configuration window */
    ConfigCancelClick = "configCancelClick",
    /** triggers when user click on the close button on widget configuration window */
    ConfigCloseClick = "configCloseClick",
    /** add button click on widget configuration window */
    ConfigAddClick = "configAddClick",
    /** triggers when a user click on the save button in widget configuration window */
    ConfigChanged = "configChanged",
    /**To rearrange widgets in a dashboard */
    RearrangeClicked = "rearrangeClicked",
    /**dashboard customize button click */
    DashboardCustomizeClick = "dashboardCustomizeClick",
    /**triggers when user clicks on the dashboard change icon in header section */
    DashboardChanged = "dashboardChanged",
    /** triggers when user clicks the close button on library */
    WidgetLibraryCloseBtnClicked = "WidgetLibraryCloseBtnClicked",
    /** triggers when user clicks on view dashboard*/
    LoadDashboard = "LoadDashboard",
    /** triggers when user clicks on copywidget */
    CopyWidget = "CopyWidget",
    /**triggers when user clicks on Move widget */
    MoveWidget = "MoveWidget",
    /**triggers when user raise delete widget event */
    WidgetDelete = "WidgetDelete",
    /** used to add widget to widgetlist when user copies a widget to current dashboard */
    AddWidget = "AddWidget",
    /** done button click on widget library flyout */
    widgetLibraryDoneClick = "widgetLibraryDoneClick",
    /**refresh favorite icon after srtting and resetting favorites */
    favoriteIconRefresh = "favoriteIconRefresh",
    /**to refresh menu content */
    QuickLinkRefresh = "QuickLinkRefresh",
    /**To raise widget added event */
    WidgetAdded = "WidgetAdded",
    /**To update global filter site from map widget selected site */
    UpdateGlobalFilterFromMapWidget = "UpdateGlobalFilterFromMapWidget",
    /**To add widget on empty dashboard */
    AddWidgetEmptyDashboard = "AddWidgetEmptyDashboard",
    /**To raise new widget add click event */
    AddNewWidgetToDashboard = "AddNewWidgetToDashboard",
    HideDashboardBanner = "HideDashboardBanner",
    /**To launch flyout from custom widget library */
    LaunchCustomWidgetFlyout = "LaunchCustomWidgetFlyout",
    /**update applied filter badge for inaplicable filters */
    UpdateAppledFiterForInapplicableFilter = "UpdateAppledFiterForInapplicableFilter",
    /**show inapplicable filter message in global filter flyout */
    ShowInapplicableFilterMessage = "ShowInapplicableFilterMessage",
    /** Bulk Action Clicked */
    BulkActionClick = "BulkActionClick",
    /** Global Filter Clicked */
    /** When user change the curated filter(eg:data streams), system will create/delete widgets */
    CuratedFilterChange = "CuratedFilterChange",
    GlobalFilterClick = "GlobalFilterClick",
    LayoutChange = "LayoutChange",
    /** Event raised when DownloadOnlyState is activated */
    DownloadOnlyState = "DownloadOnlyState",
    /** Event on excel download button clicked*/
    DownloadExcelClick = "DownloadExcelClick",
    /** Event on emission report snapshot button clicked*/
    SnapShotClick = "SnapShotClick",
    /** Event on emission report snapshot selected from list*/
    SnapShotSelected = "SnapShotSelected",
    /** Event to update widget count */
    UpdateWidgetCount = "UpdateWidgetCount",
    /** Trends Report: open download format modal (payload: { widgetInstanceId, isChartDownloadVisible, isGridDownloadVisible }) */
    TrendsReportDownloadModalOpen = "TrendsReportDownloadModalOpen",
    /** Trends Report: execute download for widget (payload: { widgetInstanceId, format }) */
    TrendsReportDownloadRequest = "TrendsReportDownloadRequest"
}
declare enum RAEventKey {
    /** on edit widget click */
    WidgetInstanceId = "widgetInstanceId"
}

declare abstract class RaBaseDashboardTemplate {
    private ngZone;
    userDashboardId: number;
    raDashboardEventBus: RADashboardEventBus;
    appConfig: IAppConfig;
    dashboardInfo: IDashboardInfo;
    isIndicatorDashboard: boolean;
    templateConfig: any;
    dashboardId: number;
    globalFilter: any;
    downloadDatastreamLimit: any;
    reportDatastreamLimit: any;
    bulkActionData: any;
    constructor(ngZone: NgZone);
    initialize: (eventBus: RADashboardEventBus, userDashboardId: number, appConfig: IAppConfig, dashboardInfo: IDashboardInfo, isIndicatorDashboard: boolean, templateConfig?: any) => void;
    abstract init(): void;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RaBaseDashboardTemplate, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RaBaseDashboardTemplate, never, never, { "dashboardId": { "alias": "dashboard-id"; "required": false; }; "globalFilter": { "alias": "global-filter"; "required": false; }; "downloadDatastreamLimit": { "alias": "download-datastream-limit"; "required": false; }; "reportDatastreamLimit": { "alias": "report-datastream-limit"; "required": false; }; "bulkActionData": { "alias": "bulk_Action_Data"; "required": false; }; "initialize": { "alias": "initialize"; "required": false; }; }, {}, never, never, true, never>;
}

declare abstract class RaBaseDashboardFilter {
    abstract getFilterConfig(): any;
    abstract setFilterConfig(filter: string, appConfig: IAppConfig): any;
    abstract clearData(): void;
    abstract isValid(): boolean;
    abstract showHideInapplicableMsg(status: boolean): any;
    abstract showDateRangeControl(isIndicatorDashboard: boolean): any;
    private getAllFilterConfig;
    setInapplicableFilterMsg: (status: boolean) => void;
    isValidEntry: () => boolean;
    clearAllData: () => void;
    setAllFilterConfig: (globalFilter: string, appConfig: IAppConfig) => void;
    showOnlyDateRangeControl: (isIndicatorDashboard: boolean) => void;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RaBaseDashboardFilter, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RaBaseDashboardFilter, never, never, { "getAllFilterConfig": { "alias": "getAllFilterConfig"; "required": false; }; "setInapplicableFilterMsg": { "alias": "setInapplicableFilterMsg"; "required": false; }; "isValidEntry": { "alias": "isValidEntry"; "required": false; }; "clearAllData": { "alias": "clearAllData"; "required": false; }; "setAllFilterConfig": { "alias": "setAllFilterConfig"; "required": false; }; "showOnlyDateRangeControl": { "alias": "showOnlyDateRangeControl"; "required": false; }; }, {}, never, never, true, never>;
}

export { DashboardFrameworkModule, RADashboardArea, RADashboardEventBus, RADashboardResponsiveService, RAEvent, RAEventKey, RAWidgetContainer, RaBaseDashboardFilter, RaBaseDashboardTemplate, RaDashboardService };