@c8y/ngx-components 1021.13.3 → 1021.21.0

package/core/common/inter-app.service.d.ts

@@ -0,0 +1,48 @@
+import { IApplication } from '@c8y/client';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare const SupportedApps: {
+    readonly devicemanagement: "devicemanagement-application-key";
+    readonly cockpit: "cockpit-application-key";
+    readonly administration: "administration-application-key";
+};
+export type SupportedAppKey = (typeof SupportedApps)[keyof typeof SupportedApps];
+/**
+ * Service that provides methods to interact with other applications.
+ * It allows retrieving a specific app by key, checking its availability, verifying if it is not the current application,
+ * determining if a link to another app should be shown, and navigating to it.
+ */
+export declare class InterAppService<T extends string = SupportedAppKey> {
+    private stateService;
+    private alertService;
+    private translateService;
+    /**
+     * Retrieve application by its key as observable.
+     * @param key {SupportedAppKey} - Application key.
+     * @returns Observable of Application
+     */
+    getApp$(key: T): Observable<IApplication | undefined>;
+    /**
+     * Checks if current application is the same as the one that key is provided
+     * @param key {SupportedAppKey} - Application key.
+     * @returns Observable of boolean; true if current app matches provided key.
+     */
+    isCurrentApp$(key: T): Observable<boolean>;
+    /**
+     * Checks if other (other than current) application link should be displayed. It consists of two conditions:
+     * - app that link leads to exists and is available for current user
+     * - app link leads to app that is not current app
+     * @param appKey {SupportedAppKey} - Application key that link leads to.
+     * @returns Observable of boolean; only true when app that link leads to is available and app link leads to app that is not current app
+     */
+    shouldShowAppLink$(appKey: T): Observable<boolean>;
+    /**
+     * Navigates to app by provided app key
+     * @param appKey {SupportedAppKey} - Application key that links leads to.
+     * @param path {string} - Additional path in target application.
+     */
+    navigateToApp(appKey: T, path?: string): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InterAppService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InterAppService<any>>;
+}
+//# sourceMappingURL=inter-app.service.d.ts.map

package/core/common/inter-app.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inter-app.service.d.ts","sourceRoot":"","sources":["../../../core/common/inter-app.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAsC,UAAU,EAAE,MAAM,MAAM,CAAC;;AAMtE,eAAO,MAAM,aAAa;;;;CAIhB,CAAC;AACX,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,OAAO,aAAa,CAAC,CAAC;AAEjF;;;;GAIG;AACH,qBACa,eAAe,CAAC,CAAC,SAAS,MAAM,GAAG,eAAe;IAC7D,OAAO,CAAC,YAAY,CAA2B;IAC/C,OAAO,CAAC,YAAY,CAAwB;IAC5C,OAAO,CAAC,gBAAgB,CAA4B;IAEpD;;;;OAIG;IACH,OAAO,CAAC,GAAG,EAAE,CAAC,GAAG,UAAU,CAAC,YAAY,GAAG,SAAS,CAAC;IAIrD;;;;OAIG;IACH,aAAa,CAAC,GAAG,EAAE,CAAC,GAAG,UAAU,CAAC,OAAO,CAAC;IAI1C;;;;;;OAMG;IACH,kBAAkB,CAAC,MAAM,EAAE,CAAC,GAAG,UAAU,CAAC,OAAO,CAAC;IAYlD;;;;OAIG;IACG,aAAa,CAAC,MAAM,EAAE,CAAC,EAAE,IAAI,CAAC,EAAE,MAAM;yCA/CjC,eAAe;6CAAf,eAAe;CAgE3B"}

package/core/common/interval-based-reload.abstract.d.ts

@@ -0,0 +1,120 @@
+import { EventEmitter, Injector, Signal } from '@angular/core';
+import { CountdownIntervalComponent } from '../countdown-interval';
+/**
+ * Abstract class representing an interval reload functionality.
+ * This class provides methods and properties for managing an interval-based reload mechanism.
+ */
+export declare abstract class IntervalBasedReload {
+    abstract countdownIntervalComponent: CountdownIntervalComponent;
+    /**
+     * Indicates whether auto-refresh is enabled for the datapoints reload component that is set in widget config.
+     */
+    isAutoRefreshEnabled: boolean;
+    /**
+     * Current isLoading state. Based on it next countdown cycle is being started.
+     */
+    abstract isLoading: Signal<boolean>;
+    /**
+     * Indicates whether the alarm list is being scrolled or not.
+     */
+    abstract isScrolling: boolean;
+    /**
+     * Current refresh interval set in a widget config.
+     */
+    abstract refreshInterval: number;
+    /**
+     * Indicates that a countdown cycle has ended.
+     */
+    abstract onCountdownEnded: EventEmitter<void>;
+    /**
+     * Indicates the current state of an interval refresh toggle button.
+     */
+    abstract isIntervalRefreshToggleOn: boolean;
+    abstract toggleCountdownButtonTooltipText: string;
+    /**
+     * Indicates whether the countdown has been manually disabled by the user.
+     */
+    protected abstract manuallyDisabledCountdown: boolean;
+    /**
+     * Controls the visibility of the countdown timer component in the current component's UI.
+     */
+    protected abstract hideCountdown: boolean;
+    /**
+     * Stops the countdown and triggers a refresh action.
+     * This function is responsible for halting the countdown interval component's operation.
+     * After stopping the countdown, it emits an `onCountdownEnded` event.
+     * This event is used to inform external components that the countdown has ended,
+     * typically prompting them to reload or refresh their data.
+     */
+    autoRefreshList(): void;
+    /**
+     * Manages the countdown timer's visibility and state in response to user scrolling.
+     *
+     * This method toggles the countdown timer based on the user's scrolling behavior. It uses
+     * the `disableCountdown` and `enableCountdown` methods for handling the countdown state.
+     *
+     * - If the user is scrolling down while the countdown is visible (`isScrolling` is true and
+     *   `hideCountdown` is false), `disableCountdown` is called to stop and hide the countdown,
+     *   and `isIntervalRefreshToggleOn` is set to false.
+     *
+     * - If the user has stopped scrolling, the countdown subscription is closed, and the countdown
+     *   is hidden (`!isScrolling`, `countdownSubscription?.closed`, `hideCountdown`), `enableCountdown`
+     *   is called to show and restart the countdown, and `isIntervalRefreshToggleOn` is set to true.
+     */
+    handleScrolling(): void;
+    abstract reload(): void;
+    /**
+     * Wrapper method where it's name better describes a context where it was called.
+     */
+    abstract countdownEnded(): void;
+    /**
+     * Handles the toggle state of the countdown on button click.
+     *
+     * This method is triggered by a mouse event, typically a click on the countdown toggle button.
+     * It toggles `isIntervalRefreshToggleOn` to reflect the current state of the countdown timer.
+     *
+     * - If `isIntervalRefreshToggleOn` is set to false, indicating that the countdown should be stopped,
+     *   `disableCountdown` is called, and `manuallyDisabledCountdown` is set to true.
+     *
+     * - If `isIntervalRefreshToggleOn` is true and the countdown subscription is closed, indicating that
+     *   the countdown can be started, `enableCountdown` is called, and `manuallyDisabledCountdown`
+     *   is set to false.
+     *
+     * @param $event - The MouseEvent that triggered this method.
+     */
+    onToggleCountdownButtonState($event: MouseEvent): void;
+    /**
+     * This function listens for changes in the `isLoading` observable, filtering out any truthy values.
+     * Once a falsy value is detected (indicating that loading has finished), it attempts to start the countdown.
+     *
+     * IMPORTANT: If the widget's configuration (refreshInterval, check template) is not set prior to executing countdownIntervalComponent?.start,
+     * the countdown interval will not start!
+     *
+     * @param injector - The injector used to provide necessary dependencies
+     *                   within the `runInInjectionContext`.
+     */
+    startCountdown(injector: Injector): void;
+    /**
+     * Enables and starts the countdown timer.
+     *
+     * This method makes the countdown visible (`hideCountdown` is set to false) and then
+     * starts the countdown process. It ensures the countdown timer is updated immediately
+     * by triggering change detection with `cdRef.detectChanges()` before starting the countdown.
+     * This method encapsulates the logic required to initiate the countdown timer.
+     */
+    abstract enableCountdown(): void;
+    /**
+     * Disables and hides the countdown timer.
+     *
+     * This method stops the ongoing countdown process by
+     * stopping the `countdownIntervalComponent` if it exists. It then hides the countdown timer
+     * by setting `hideCountdown` to true. This method encapsulates the logic required to halt and
+     * conceal the countdown timer.
+     */
+    disableCountdown(): void;
+    /**
+     * Updates the countdown button tooltip text based on the state of the interval refresh toggle state.
+     */
+    protected abstract updateCountdownButtonTooltipText(): void;
+}
+//# sourceMappingURL=interval-based-reload.abstract.d.ts.map

package/core/common/interval-based-reload.abstract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interval-based-reload.abstract.d.ts","sourceRoot":"","sources":["../../../core/common/interval-based-reload.abstract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,EAAiC,MAAM,eAAe,CAAC;AAC9F,OAAO,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAC;AAEnE;;;GAGG;AACH,8BAAsB,mBAAmB;IACvC,QAAQ,CAAC,0BAA0B,EAAE,0BAA0B,CAAC;IAChE;;OAEG;IACH,oBAAoB,EAAE,OAAO,CAAC;IAC9B;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;IACpC;;OAEG;IACH,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B;;OAEG;IACH,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC;;OAEG;IACH,QAAQ,CAAC,gBAAgB,EAAE,YAAY,CAAC,IAAI,CAAC,CAAC;IAC9C;;OAEG;IACH,QAAQ,CAAC,yBAAyB,EAAE,OAAO,CAAC;IAE5C,QAAQ,CAAC,gCAAgC,EAAE,MAAM,CAAC;IAClD;;OAEG;IACH,SAAS,CAAC,QAAQ,CAAC,yBAAyB,EAAE,OAAO,CAAC;IACtD;;OAEG;IACH,SAAS,CAAC,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAE1C;;;;;;OAMG;IACH,eAAe,IAAI,IAAI;IAOvB;;;;;;;;;;;;;OAaG;IACH,eAAe,IAAI,IAAI;IAmBvB,QAAQ,CAAC,MAAM,IAAI,IAAI;IACvB;;OAEG;IACH,QAAQ,CAAC,cAAc,IAAI,IAAI;IAC/B;;;;;;;;;;;;;;OAcG;IACH,4BAA4B,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAiBtD;;;;;;;;;OASG;IACH,cAAc,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAUxC;;;;;;;OAOG;IACH,QAAQ,CAAC,eAAe,IAAI,IAAI;IAEhC;;;;;;;OAOG;IACH,gBAAgB,IAAI,IAAI;IAKxB;;OAEG;IACH,SAAS,CAAC,QAAQ,CAAC,gCAAgC,IAAI,IAAI;CAC5D"}

package/core/dashboard/dashboard.module.d.ts

@@ -7,26 +7,32 @@ import * as i5 from "./widgets-dashboard.component";
 import * as i6 from "./wiget-time-context/widget-time-context.component";
 import * as i7 from "./wiget-time-context/realtime-control/realtime-control.component";
 import * as i8 from "./wiget-time-context/aggregation-picker/aggregation-picker.component";
-import * as i9 from "./wiget-time-context/widget-time-context-icon-bar/widget-time-context-icon-bar.component";
-import * as i10 from "../common/common.module";
-import * as i11 from "../action-bar/action-bar.module";
-import * as i12 from "../dynamic-component/dynamic-component.module";
-import * as i13 from "@angular/cdk/drag-drop";
-import * as i14 from "ngx-bootstrap/dropdown";
-import * as i15 from "ngx-bootstrap/tooltip";
-import * as i16 from "../header/header.module";
-import * as i17 from "../docs/docs.module";
-import * as i18 from "../breadcrumb/breadcrumb.module";
-import * as i19 from "../forms/forms.module";
-import * as i20 from "ngx-bootstrap/datepicker";
-import * as i21 from "../dynamic-forms/dynamic-forms.module";
-import * as i22 from "../help/help.module";
-import * as i23 from "../date-time-picker/date-time-picker.module";
-import * as i24 from "@c8y/ngx-components/interval-picker";
-import * as i25 from "ngx-bootstrap/popover";
+import * as i9 from "./widget-auto-refresh-context/widget-auto-refresh-context.component";
+import * as i10 from "./widget-auto-refresh-context/widget-auto-refresh-context-icon-bar.component";
+import * as i11 from "./widget-auto-refresh-context/auto-refresh-control.component";
+import * as i12 from "./widget-auto-refresh-context/auto-refresh-select-control.component";
+import * as i13 from "./wiget-time-context/widget-time-context-icon-bar/widget-time-context-icon-bar.component";
+import * as i14 from "../common/common.module";
+import * as i15 from "../action-bar/action-bar.module";
+import * as i16 from "../dynamic-component/dynamic-component.module";
+import * as i17 from "@angular/cdk/drag-drop";
+import * as i18 from "ngx-bootstrap/dropdown";
+import * as i19 from "ngx-bootstrap/tooltip";
+import * as i20 from "../header/header.module";
+import * as i21 from "../docs/docs.module";
+import * as i22 from "../breadcrumb/breadcrumb.module";
+import * as i23 from "../forms/forms.module";
+import * as i24 from "ngx-bootstrap/datepicker";
+import * as i25 from "../dynamic-forms/dynamic-forms.module";
+import * as i26 from "../help/help.module";
+import * as i27 from "../date-time-picker/date-time-picker.module";
+import * as i28 from "../countdown-interval/countdown-interval.module";
+import * as i29 from "@ngx-translate/core";
+import * as i30 from "@c8y/ngx-components/interval-picker";
+import * as i31 from "ngx-bootstrap/popover";
 export declare class DashboardModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<DashboardModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<DashboardModule, [typeof i1.DashboardChildComponent, typeof i2.DashboardComponent, typeof i3.DashboardChildTitleComponent, typeof i4.DashboardChildActionComponent, typeof i5.WidgetsDashboardComponent, typeof i6.WidgetTimeContextComponent, typeof i7.RealtimeControlComponent, typeof i8.AggregationPickerComponent, typeof i9.WidgetTimeContextIconBar], [typeof i10.CommonModule, typeof i11.ActionBarModule, typeof i12.DynamicComponentModule, typeof i13.DragDropModule, typeof i14.BsDropdownModule, typeof i15.TooltipModule, typeof i16.HeaderModule, typeof i17.DocsModule, typeof i18.BreadcrumbModule, typeof i19.FormsModule, typeof i20.BsDatepickerModule, typeof i21.DynamicFormsModule, typeof i22.HelpModule, typeof i23.DateTimePickerModule, typeof i24.IntervalPickerComponent, typeof i25.PopoverModule], [typeof i2.DashboardComponent, typeof i1.DashboardChildComponent, typeof i3.DashboardChildTitleComponent, typeof i4.DashboardChildActionComponent, typeof i5.WidgetsDashboardComponent, typeof i6.WidgetTimeContextComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DashboardModule, [typeof i1.DashboardChildComponent, typeof i2.DashboardComponent, typeof i3.DashboardChildTitleComponent, typeof i4.DashboardChildActionComponent, typeof i5.WidgetsDashboardComponent, typeof i6.WidgetTimeContextComponent, typeof i7.RealtimeControlComponent, typeof i8.AggregationPickerComponent, typeof i9.WidgetAutoRefreshContextComponent, typeof i10.WidgetAutoRefreshContextIconBarComponent, typeof i11.AutoRefreshControlComponent, typeof i12.AutoRefreshSelectControlComponent, typeof i13.WidgetTimeContextIconBar], [typeof i14.CommonModule, typeof i15.ActionBarModule, typeof i16.DynamicComponentModule, typeof i17.DragDropModule, typeof i18.BsDropdownModule, typeof i19.TooltipModule, typeof i20.HeaderModule, typeof i21.DocsModule, typeof i22.BreadcrumbModule, typeof i23.FormsModule, typeof i24.BsDatepickerModule, typeof i25.DynamicFormsModule, typeof i26.HelpModule, typeof i27.DateTimePickerModule, typeof i28.CountdownIntervalModule, typeof i29.TranslateModule, typeof i30.IntervalPickerComponent, typeof i31.PopoverModule], [typeof i2.DashboardComponent, typeof i1.DashboardChildComponent, typeof i3.DashboardChildTitleComponent, typeof i4.DashboardChildActionComponent, typeof i5.WidgetsDashboardComponent, typeof i6.WidgetTimeContextComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<DashboardModule>;
 }
 //# sourceMappingURL=dashboard.module.d.ts.map

package/core/dashboard/dashboard.module.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dashboard.module.d.ts","sourceRoot":"","sources":["../../../core/dashboard/dashboard.module.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,qBAuCa,eAAe;yCAAf,eAAe;0CAAf,eAAe;0CAAf,eAAe;CAAG"}
+{"version":3,"file":"dashboard.module.d.ts","sourceRoot":"","sources":["../../../core/dashboard/dashboard.module.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,qBA6Ca,eAAe;yCAAf,eAAe;0CAAf,eAAe;0CAAf,eAAe;CAAG"}

package/core/dashboard/index.d.ts

@@ -9,4 +9,7 @@ export * from './dashboard-child-change';
 export * from './dashboard-child-title.component';
 export * from './wiget-time-context/widget-time-context.component';
 export * from './wiget-time-context/widget-time-context.model';
+export * from './widget-auto-refresh-context/widget-auto-refresh-context.model';
+export * from './widget-auto-refresh-context/widget-global-auto-refresh.service';
+export * from './widget-auto-refresh-context/global-refresh-loading.operator';
 //# sourceMappingURL=index.d.ts.map

package/core/dashboard/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../core/dashboard/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oCAAoC,CAAC;AACnD,cAAc,0BAA0B,CAAC;AACzC,cAAc,mCAAmC,CAAC;AAClD,cAAc,oDAAoD,CAAC;AACnE,cAAc,gDAAgD,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../core/dashboard/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oCAAoC,CAAC;AACnD,cAAc,0BAA0B,CAAC;AACzC,cAAc,mCAAmC,CAAC;AAClD,cAAc,oDAAoD,CAAC;AACnE,cAAc,gDAAgD,CAAC;AAC/D,cAAc,iEAAiE,CAAC;AAChF,cAAc,kEAAkE,CAAC;AACjF,cAAc,+DAA+D,CAAC"}

package/core/dashboard/widget-auto-refresh-context/auto-refresh-control.component.d.ts

@@ -0,0 +1,31 @@
+import { AfterViewInit, EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { BehaviorSubject } from 'rxjs';
+import { CountdownIntervalComponent } from '../../countdown-interval';
+import * as i0 from "@angular/core";
+export declare class AutoRefreshControlComponent implements OnInit, AfterViewInit, OnDestroy, ControlValueAccessor {
+    readonly DISABLE_AUTO_REFRESH: "Disable auto refresh";
+    readonly ENABLE_AUTO_REFRESH: "Enable auto refresh";
+    readonly DEFAULT_INTERVAL_VALUE = 30000;
+    countdownIntervalComponent: CountdownIntervalComponent;
+    loading: EventEmitter<boolean>;
+    showIntervalRefresh$: BehaviorSubject<boolean>;
+    autoRefreshSeconds$: BehaviorSubject<number>;
+    private readonly widgetGlobalAutoRefresh;
+    private destroy$;
+    onChange: (value: boolean) => void;
+    onTouched: () => void;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    toggleIntervalRefresh(): void;
+    registerOnChange(fn: any): void;
+    writeValue(showIntervalRefresh: boolean): void;
+    registerOnTouched(fn: any): void;
+    private subscribeOnCountdownChangeState;
+    private setUpOnCountdownEndedListener;
+    private handleCountdownEnded;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AutoRefreshControlComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AutoRefreshControlComponent, "c8y-auto-refresh-control", never, {}, { "loading": "loading"; }, never, never, false, never>;
+}
+//# sourceMappingURL=auto-refresh-control.component.d.ts.map

package/core/dashboard/widget-auto-refresh-context/auto-refresh-control.component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-refresh-control.component.d.ts","sourceRoot":"","sources":["../../../../core/dashboard/widget-auto-refresh-context/auto-refresh-control.component.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EAEb,YAAY,EAGZ,SAAS,EACT,MAAM,EAGP,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,oBAAoB,EAAqB,MAAM,gBAAgB,CAAC;AACzE,OAAO,EAAE,eAAe,EAAW,MAAM,MAAM,CAAC;AAEhD,OAAO,EAAE,0BAA0B,EAAE,MAAM,0BAA0B,CAAC;;AAKtE,qBAWa,2BACX,YAAW,MAAM,EAAE,aAAa,EAAE,SAAS,EAAE,oBAAoB;IAEjE,QAAQ,CAAC,oBAAoB,yBAAmC;IAChE,QAAQ,CAAC,mBAAmB,wBAAkC;IAC9D,QAAQ,CAAC,sBAAsB,SAA0B;IAGzD,0BAA0B,EAAE,0BAA0B,CAAC;IAGvD,OAAO,wBAA+B;IAEtC,oBAAoB,EAAE,eAAe,CAAC,OAAO,CAAC,CAAC;IAC/C,mBAAmB,EAAE,eAAe,CAAC,MAAM,CAAC,CAAC;IAC7C,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAA0C;IAElF,OAAO,CAAC,QAAQ,CAAgC;IAChD,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IAGnC,SAAS,aAAY;IAErB,QAAQ,IAAI,IAAI;IAIhB,eAAe;IAOf,WAAW;IAKX,qBAAqB;IAQrB,gBAAgB,CAAC,EAAE,EAAE,GAAG,GAAG,IAAI;IAI/B,UAAU,CAAC,mBAAmB,EAAE,OAAO,GAAG,IAAI;IAO9C,iBAAiB,CAAC,EAAE,EAAE,GAAG,GAAG,IAAI;IAIhC,OAAO,CAAC,+BAA+B;IAsBvC,OAAO,CAAC,6BAA6B;IAUrC,OAAO,CAAC,oBAAoB;yCA9FjB,2BAA2B;2CAA3B,2BAA2B;CAiGvC"}

package/core/dashboard/widget-auto-refresh-context/auto-refresh-select-control.component.d.ts

@@ -0,0 +1,17 @@
+import { ControlValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class AutoRefreshSelectControlComponent implements ControlValueAccessor {
+    readonly DEFAULT_INTERVAL_VALUES: number[];
+    readonly START_INTERVAL_VALUE = 30000;
+    readonly SECONDS_UNTIL_REFRESH: "{{ seconds }} s`until refresh`";
+    autoRefreshSeconds: number;
+    onChange: (value: number) => void;
+    onTouched: () => void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    writeValue(autoRefreshSeconds: number): void;
+    onIntervalChange(autoRefreshSeconds: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AutoRefreshSelectControlComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AutoRefreshSelectControlComponent, "c8y-auto-refresh-select-control", never, {}, {}, never, never, false, never>;
+}
+//# sourceMappingURL=auto-refresh-select-control.component.d.ts.map

package/core/dashboard/widget-auto-refresh-context/auto-refresh-select-control.component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-refresh-select-control.component.d.ts","sourceRoot":"","sources":["../../../../core/dashboard/widget-auto-refresh-context/auto-refresh-select-control.component.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,oBAAoB,EAAqB,MAAM,gBAAgB,CAAC;;AAMzE,qBAWa,iCAAkC,YAAW,oBAAoB;IAC5E,QAAQ,CAAC,uBAAuB,WAA2B;IAC3D,QAAQ,CAAC,oBAAoB,SAA0B;IAEvD,QAAQ,CAAC,qBAAqB,mCAA6C;IAE3E,kBAAkB,EAAE,MAAM,CAAC;IAE3B,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAGlC,SAAS,aAAY;IAErB,gBAAgB,CAAC,EAAE,EAAE,GAAG,GAAG,IAAI;IAI/B,iBAAiB,CAAC,EAAE,EAAE,GAAG,GAAG,IAAI;IAIhC,UAAU,CAAC,kBAAkB,EAAE,MAAM,GAAG,IAAI;IAI5C,gBAAgB,CAAC,kBAAkB,EAAE,MAAM,GAAG,IAAI;yCAzBvC,iCAAiC;2CAAjC,iCAAiC;CA6B7C"}

package/core/dashboard/widget-auto-refresh-context/global-refresh-loading.operator.d.ts

@@ -0,0 +1,4 @@
+import { MonoTypeOperatorFunction } from 'rxjs';
+import { WidgetGlobalAutoRefreshService } from './widget-global-auto-refresh.service';
+export declare function globalAutoRefreshLoading(globalRefreshService: WidgetGlobalAutoRefreshService): MonoTypeOperatorFunction<boolean>;
+//# sourceMappingURL=global-refresh-loading.operator.d.ts.map

package/core/dashboard/widget-auto-refresh-context/global-refresh-loading.operator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"global-refresh-loading.operator.d.ts","sourceRoot":"","sources":["../../../../core/dashboard/widget-auto-refresh-context/global-refresh-loading.operator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAc,MAAM,MAAM,CAAC;AAE5D,OAAO,EAAE,8BAA8B,EAAE,MAAM,sCAAsC,CAAC;AAEtF,wBAAgB,wBAAwB,CACtC,oBAAoB,EAAE,8BAA8B,GACnD,wBAAwB,CAAC,OAAO,CAAC,CAUnC"}

package/core/dashboard/widget-auto-refresh-context/index.d.ts

@@ -0,0 +1,8 @@
+export * from './widget-auto-refresh-context.component';
+export * from './auto-refresh-control.component';
+export * from './auto-refresh-select-control.component';
+export * from './widget-auto-refresh-context.model';
+export * from './widget-global-auto-refresh.service';
+export * from './widget-auto-refresh-context-icon-bar.component';
+export * from './global-refresh-loading.operator';
+//# sourceMappingURL=index.d.ts.map

package/core/dashboard/widget-auto-refresh-context/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../core/dashboard/widget-auto-refresh-context/index.ts"],"names":[],"mappings":"AAAA,cAAc,yCAAyC,CAAC;AACxD,cAAc,kCAAkC,CAAC;AACjD,cAAc,yCAAyC,CAAC;AACxD,cAAc,qCAAqC,CAAC;AACpD,cAAc,sCAAsC,CAAC;AACrD,cAAc,kDAAkD,CAAC;AACjE,cAAc,mCAAmC,CAAC"}

package/core/dashboard/widget-auto-refresh-context/widget-auto-refresh-context-icon-bar.component.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+export declare class WidgetAutoRefreshContextIconBarComponent {
+    globalAutoRefreshTooltip: "This widget is in sync with the dashboard auto refresh context.";
+    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetAutoRefreshContextIconBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WidgetAutoRefreshContextIconBarComponent, "c8y-widget-auto-refresh-context-icon-bar", never, {}, {}, never, never, false, never>;
+}
+//# sourceMappingURL=widget-auto-refresh-context-icon-bar.component.d.ts.map

package/core/dashboard/widget-auto-refresh-context/widget-auto-refresh-context-icon-bar.component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"widget-auto-refresh-context-icon-bar.component.d.ts","sourceRoot":"","sources":["../../../../core/dashboard/widget-auto-refresh-context/widget-auto-refresh-context-icon-bar.component.ts"],"names":[],"mappings":";AAGA,qBAIa,wCAAwC;IACnD,wBAAwB,oEAEtB;yCAHS,wCAAwC;2CAAxC,wCAAwC;CAIpD"}

package/core/dashboard/widget-auto-refresh-context/widget-auto-refresh-context.component.d.ts

@@ -0,0 +1,29 @@
+import { AfterViewInit, OnDestroy, OnInit } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class WidgetAutoRefreshContextComponent implements OnInit, OnDestroy, AfterViewInit {
+    form: ReturnType<WidgetAutoRefreshContextComponent['createForm']>;
+    editMode$: BehaviorSubject<boolean>;
+    globalRefreshWidgetLoading: boolean;
+    readonly ACTION_BAR_GROUP_ID = "globalrefreshcontext";
+    readonly ACTION_BAR_PRIORITY = 5;
+    private destroy$;
+    private readonly fb;
+    private readonly widgetGlobalAutoRefresh;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    onRefresh(): void;
+    private createForm;
+    private subscribeOnAutoRefreshSecondsChange;
+    private subscribeOnAutoRefreshChange;
+    private initializeWidgetSubscriptions;
+    private setAutoRefreshQueryParam;
+    private subscribeOnQueryParamChange;
+    private subscribeOnRouterEvents;
+    private onContextDestroy;
+    private listenOnDashboardSaveOperation;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetAutoRefreshContextComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WidgetAutoRefreshContextComponent, "c8y-widget-auto-refresh-context", never, { "editMode$": { "alias": "editMode$"; "required": false; }; }, {}, never, never, false, never>;
+}
+//# sourceMappingURL=widget-auto-refresh-context.component.d.ts.map

package/core/dashboard/widget-auto-refresh-context/widget-auto-refresh-context.component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"widget-auto-refresh-context.component.d.ts","sourceRoot":"","sources":["../../../../core/dashboard/widget-auto-refresh-context/widget-auto-refresh-context.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAA4B,SAAS,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAG3F,OAAO,EAAE,eAAe,EAAW,MAAM,MAAM,CAAC;;AAOhD,qBAIa,iCAAkC,YAAW,MAAM,EAAE,SAAS,EAAE,aAAa;IACxF,IAAI,EAAE,UAAU,CAAC,iCAAiC,CAAC,YAAY,CAAC,CAAC,CAAC;IAGlE,SAAS,EAAE,eAAe,CAAC,OAAO,CAAC,CAAC;IAEpC,0BAA0B,UAAQ;IAClC,QAAQ,CAAC,mBAAmB,0BAA0B;IACtD,QAAQ,CAAC,mBAAmB,KAAK;IAEjC,OAAO,CAAC,QAAQ,CAAgC;IAEhD,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAuB;IAC1C,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAA0C;IAElF,QAAQ;IAUR,eAAe;IAiBf,WAAW;IAIX,SAAS;IAIT,OAAO,CAAC,UAAU;IAQlB,OAAO,CAAC,mCAAmC;IAY3C,OAAO,CAAC,4BAA4B;IAapC,OAAO,CAAC,6BAA6B;IAMrC,OAAO,CAAC,wBAAwB;IAahC,OAAO,CAAC,2BAA2B;IAsBnC,OAAO,CAAC,uBAAuB;IAO/B,OAAO,CAAC,gBAAgB;IAYxB,OAAO,CAAC,8BAA8B;yCA/I3B,iCAAiC;2CAAjC,iCAAiC;CAuJ7C"}

package/core/dashboard/widget-auto-refresh-context/widget-auto-refresh-context.model.d.ts

@@ -0,0 +1,15 @@
+export declare const DEFAULT_INTERVAL_VALUE = 30000;
+export declare const DEFAULT_INTERVAL_VALUES: number[];
+export declare const DEFAULT_INTERVAL_STATE = true;
+export declare const GLOBAL_CONTEXT_AUTO_REFRESH = "globalContextAutoRefresh";
+export type GlobalAutoRefreshQueryParam = {
+    [GLOBAL_CONTEXT_AUTO_REFRESH]: boolean;
+};
+export interface GlobalAutoRefreshWidgetConfig {
+    /**
+     * Indicates if instance of widget is bound to global auto refresh context. It can be only used with widgets which
+     * dynamic component definition contains displaySettings allowing to use it with global auto refresh context.
+     */
+    widgetInstanceGlobalAutoRefreshContext?: boolean;
+}
+//# sourceMappingURL=widget-auto-refresh-context.model.d.ts.map

package/core/dashboard/widget-auto-refresh-context/widget-auto-refresh-context.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"widget-auto-refresh-context.model.d.ts","sourceRoot":"","sources":["../../../../core/dashboard/widget-auto-refresh-context/widget-auto-refresh-context.model.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB,QAAS,CAAC;AAC7C,eAAO,MAAM,uBAAuB,UAA0C,CAAC;AAC/E,eAAO,MAAM,sBAAsB,OAAO,CAAC;AAE3C,eAAO,MAAM,2BAA2B,6BAA6B,CAAC;AACtE,MAAM,MAAM,2BAA2B,GAAG;IACxC,CAAC,2BAA2B,CAAC,EAAE,OAAO,CAAC;CACxC,CAAC;AAEF,MAAM,WAAW,6BAA6B;IAC5C;;;OAGG;IACH,sCAAsC,CAAC,EAAE,OAAO,CAAC;CAClD"}

package/core/dashboard/widget-auto-refresh-context/widget-global-auto-refresh.service.d.ts

@@ -0,0 +1,169 @@
+import { BehaviorSubject, MonoTypeOperatorFunction, Observable, Subject } from 'rxjs';
+import { GlobalAutoRefreshQueryParam } from './widget-auto-refresh-context.model';
+import { Event } from '@angular/router';
+import * as i0 from "@angular/core";
+export declare class WidgetGlobalAutoRefreshService {
+    /**
+     * A BehaviorSubject that tracks the number of loading operations in progress.
+     * Initialized with a count of 0.
+     */
+    private loadingCount$;
+    /**
+     * An Observable that emits a boolean indicating whether any widgets with global refresh option are currently loading.
+     * The value is true if the loading count is non-zero, and false if the loading count is zero.
+     * Uses distinctUntilChanged() to emit only when the boolean value changes.
+     */
+    private isLoadingWidgets$;
+    /**
+     * Object containing behavior subjects for managing auto-refresh settings.
+     */
+    autoRefreshSettings: {
+        /**
+         * BehaviorSubject that emits the current state of auto-refresh button.
+         * Defaults to DEFAULT_INTERVAL_STATE.
+         */
+        isEnabled$: BehaviorSubject<boolean>;
+        /**
+         * BehaviorSubject that emits the current auto-refresh interval value.
+         * Defaults to DEFAULT_INTERVAL_VALUE.
+         */
+        refreshInterval$: BehaviorSubject<number>;
+        /**
+         * BehaviorSubject that emits whether auto-refresh has been manually disabled by the user.
+         * Defaults to false.
+         */
+        userDisabledManually$: BehaviorSubject<boolean>;
+    };
+    /**
+     * Object containing subjects for managing countdown actions.
+     */
+    countdownActions: {
+        /**
+         * Subject used to stop the countdown.
+         */
+        stop$: Subject<void>;
+        /**
+         * Subject used to reset the countdown.
+         */
+        reset$: Subject<void>;
+        /**
+         * Subject that emits when the countdown has ended.
+         */
+        countdownEnded$: Subject<void>;
+    };
+    /**
+     * Subject that emits when a dashboard save operation is triggered.
+     */
+    onDashboardSave$: Subject<void>;
+    /**
+     * A signal representing the number of widgets with the global auto-refresh option enabled.
+     */
+    globalRefreshWidgetsCount: import("@angular/core").WritableSignal<number>;
+    /**
+     * Tracks the navigation state.
+     *
+     * The signal returns a boolean indicating whether a navigation operation is currently in progress.
+     * It initializes with a default value of `false` and can be toggled to `true` during navigation events from `handleNavigationInProgress$`.
+     */
+    private navigationInProgress;
+    private readonly router;
+    private readonly activatedRoute;
+    /**
+     * Increments the loading count by 1.
+     */
+    incrementLoading(): void;
+    /**
+     * Decrements the loading count by 1.
+     */
+    decrementLoading(): void;
+    /**
+     * Retrieves an observable that emits the value of a Global Auto Refresh query parameter
+     * whenever it changes. The query parameter being tracked is determined by
+     * `GlobalAutoRefreshName.GLOBAL_CONTEXT_AUTO_REFRESH`.
+     *
+     * @returns An observable that emits the parsed value of the `GLOBAL_CONTEXT_AUTO_REFRESH` query parameter.
+     */
+    getQueryParamChangeValue$(): Observable<boolean | null>;
+    /**
+     * Monitors router navigation events and updates the navigation progress state.
+     *
+     * @returns An Observable that emits router events of types NavigationStart, NavigationEnd,
+     *          NavigationCancel, and NavigationError.
+     */
+    handleNavigationInProgress$(): Observable<Event>;
+    /**
+     * Sets the global auto-refresh query parameter in the current route.
+     *
+     * @param queryParams - An object representing the query parameters to set for the global auto-refresh option.
+     *                      The existing query parameters will be merged with these.
+     */
+    setAutoRefreshQueryParam(queryParams: GlobalAutoRefreshQueryParam): Promise<void>;
+    /**
+     * Handles changes to the edit mode and updates the isEnabled$ variable.
+     *
+     * - If auto-refresh was manually disabled by the user (`userDisabledManually$` is `true`), auto-refresh will remain disabled regardless of the edit mode state.
+     * - If auto-refresh was not manually disabled, it will be disabled when entering edit mode and enabled when exiting edit mode.
+     *
+     * @param editMode - A boolean indicating the current state of edit mode (`true` if edit mode is active, `false` otherwise).
+     */
+    onEditModeChange(editMode: boolean): void;
+    /**
+     * Returns an Observable that triggers the countdown reset action when loading completes.
+     *
+     * This method creates an Observable that:
+     * - Skips a specified number of initial emissions from `isLoadingWidgets$` based on the `skipInitialBehaviorSubjectEmission$` method.
+     * - Filters out emissions where the loading state is true.
+     * - On emission where the loading state is false, it triggers a countdown reset action.
+     *
+     */
+    resetCountdownOnLoadingComplete$(): MonoTypeOperatorFunction<any>;
+    /**
+     * Resets the service's settings and parameters to their default values.
+     */
+    resetServiceToDefaults(): void;
+    /**
+     * Resets the countdown timer by emitting a reset action after a short delay.
+     */
+    resetCountdown(): void;
+    /**
+     * Initializes the auto-refresh countdown logic based on the widget loading state and edit mode.
+     *
+     * This method returns an observable that monitors the widget loading state and triggers specific actions
+     * related to the countdown process. It performs the following steps:
+     *
+     * 1. Skips the initial loading state emitted by `isLoadingWidgets$`.
+     * 2. Stops the countdown if the widgets are currently loading.
+     * 3. Filters out cases where widgets are loading or the application is in edit mode.
+     * 4. Resets the countdown when widgets are not loading and the application is not in edit mode.
+     *
+     * @param editMode$ - A `BehaviorSubject` representing whether the application is currently in edit mode.
+     *
+     * @returns An `Observable<boolean>` that emits the loading state of the widgets after the initialization steps.
+     */
+    initializeAutoRefreshCountdownLoading$(editMode$: BehaviorSubject<boolean>): Observable<boolean>;
+    /**
+     * Parses a string representation of global auto-refresh parameter into a boolean or null.
+     *
+     * Converts the provided `globalAutoRefresh` string into a boolean value or null based on its content:
+     * - Returns `true` if `globalAutoRefresh` is 'true'.
+     * - Returns `false` if `globalAutoRefresh` is 'false'.
+     * - Returns `null` if `globalAutoRefresh` is neither 'true' nor 'false'.
+     *
+     * @param globalAutoRefresh - The string representation of the global auto-refresh parameter.
+     *
+     * @returns A boolean value corresponding to the parsed global auto-refresh state, or null if the input is not 'true' or 'false'.
+     */
+    private parseGlobalAutoRefreshParam;
+    /**
+     * Resets the loading count to zero.
+     */
+    private resetLoadingToZero;
+    /**
+     * Clears the global auto-refresh query parameter by navigating to the current route with the parameter set to null.
+     *
+     */
+    private clearQueryParam;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetGlobalAutoRefreshService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WidgetGlobalAutoRefreshService>;
+}
+//# sourceMappingURL=widget-global-auto-refresh.service.d.ts.map

package/core/dashboard/widget-auto-refresh-context/widget-global-auto-refresh.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"widget-global-auto-refresh.service.d.ts","sourceRoot":"","sources":["../../../../core/dashboard/widget-auto-refresh-context/widget-global-auto-refresh.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,wBAAwB,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAEtF,OAAO,EAIL,2BAA2B,EAC5B,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EAEL,KAAK,EAMN,MAAM,iBAAiB,CAAC;;AAEzB,qBACa,8BAA8B;IACzC;;;OAGG;IACH,OAAO,CAAC,aAAa,CAAkC;IAEvD;;;;OAIG;IACH,OAAO,CAAC,iBAAiB,CAGvB;IAEF;;OAEG;IACH,mBAAmB;QACjB;;;WAGG;;QAEH;;;WAGG;;QAEH;;;WAGG;;MAEH;IAEF;;OAEG;IACH,gBAAgB;QACd;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;MAEH;IAEF;;OAEG;IACH,gBAAgB,gBAAuB;IAEvC;;OAEG;IACH,yBAAyB,iDAAa;IAEtC;;;;;OAKG;IACH,OAAO,CAAC,oBAAoB,CAAiB;IAE7C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkB;IACzC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA0B;IAEzD;;OAEG;IACH,gBAAgB,IAAI,IAAI;IAIxB;;OAEG;IACH,gBAAgB,IAAI,IAAI;IAIxB;;;;;;OAMG;IACH,yBAAyB,IAAI,UAAU,CAAC,OAAO,GAAG,IAAI,CAAC;IAOvD;;;;;OAKG;IACH,2BAA2B,IAAI,UAAU,CAAC,KAAK,CAAC;IAahD;;;;;OAKG;IACG,wBAAwB,CAAC,WAAW,EAAE,2BAA2B,GAAG,OAAO,CAAC,IAAI,CAAC;IAcvF;;;;;;;OAOG;IACH,gBAAgB,CAAC,QAAQ,EAAE,OAAO,GAAG,IAAI;IAQzC;;;;;;;;OAQG;IACH,gCAAgC,IAAI,wBAAwB,CAAC,GAAG,CAAC;IAUjE;;OAEG;IACH,sBAAsB,IAAI,IAAI;IAa9B;;OAEG;IACH,cAAc,IAAI,IAAI;IAItB;;;;;;;;;;;;;;OAcG;IACH,sCAAsC,CAAC,SAAS,EAAE,eAAe,CAAC,OAAO,CAAC,GAAG,UAAU,CAAC,OAAO,CAAC;IAShG;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,2BAA2B;IAInC;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAI1B;;;OAGG;IACH,OAAO,CAAC,eAAe;yCA7PZ,8BAA8B;6CAA9B,8BAA8B;CAwQ1C"}

package/core/dashboard/widgets-dashboard.component.d.ts

@@ -4,17 +4,19 @@ import { BreadcrumbItem } from '../breadcrumb/breadcrumb.model';
 import { DashboardComponent } from './dashboard.component';
 import { DashboardChange, DashboardSettings, Widget, WidgetChange, DashboardCopyPermission } from './dashboard.model';
 import { DynamicComponentService } from '../dynamic-component/dynamic-component.service';
-import { Observable } from 'rxjs';
+import { BehaviorSubject, Observable } from 'rxjs';
 import { DashboardChildComponent } from './dashboard-child.component';
 import { TranslateService } from '@ngx-translate/core';
 import { RevertChangeType } from './widget-change-event.model';
 import { ModalService } from '../modal';
+import { WidgetGlobalAutoRefreshService } from './widget-auto-refresh-context';
 import * as i0 from "@angular/core";
 export declare class WidgetsDashboardComponent {
     private dynamic;
     private translateService;
     private route;
     private modal;
+    private widgetGlobalAutoRefresh;
     set widgets(value: Widget[]);
     get widgets(): Widget[];
     context: any;
@@ -48,16 +50,17 @@ export declare class WidgetsDashboardComponent {
     resolvedWidgets$: Observable<Widget[]>;
     isLoadingWidgets$: Observable<boolean>;
     copyDisabledPopoverMsg: string;
-    editMode: boolean;
     widgetInFullscreenMode: boolean;
     inFullScreen$: Observable<boolean>;
+    editMode$: BehaviorSubject<boolean>;
     readonly copyDashboardLabel: "Copy dashboard";
     readonly undoMessage: "Undo: \"{{ changeToUndo }}\"";
     readonly redoMessage: "Redo: \"{{ changeToRedo }}\"";
+    readonly ACTION_BAR_EDIT_WIDGETS_PRIORITY = 10;
     private _widgets;
     private isLoading$;
     private isExecutingResolvers$;
-    constructor(dynamic: DynamicComponentService, translateService: TranslateService, route: ActivatedRoute, modal: ModalService);
+    constructor(dynamic: DynamicComponentService, translateService: TranslateService, route: ActivatedRoute, modal: ModalService, widgetGlobalAutoRefresh: WidgetGlobalAutoRefreshService);
     ngOnChanges({ isCopyDisabled }: SimpleChanges): void;
     canDeactivate(omitConfirm?: boolean): Promise<boolean>;
     toggleFullscreen(hasWidget?: boolean): void;