@schneideress/dashboardframework 17.0.47 → 20.0.0

package/index.d.ts

@@ -1,5 +1,1255 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@schneideress/dashboardframework" />
-export * from './public-api';
+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;
+    hasGird: boolean;
+    private initialWidgetCount;
+    private currentLoadingCount;
+    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;
+    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;
+    /** 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; }; }, { "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;
+    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;
+    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;
+    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"
+}
+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 };