@acorex/modules 19.4.15 → 20.0.0-next.0

package/dashboard-management/index.d.ts

@@ -1,5 +1,1142 @@
-export * from './lib/const';
-export * from './lib/dashboard-management.module';
-export * from './lib/entities';
-export * from './lib/features/home-dashboard';
-export * from './lib/features/shared/widgets';
+import * as _angular_core from '@angular/core';
+import { Injector, OnInit, OnDestroy, Signal, ChangeDetectorRef, ElementRef } from '@angular/core';
+import * as _acorex_platform_layout_builder from '@acorex/platform/layout/builder';
+import { AXPWidgetNode, AXPWidgetRendererDirective, AXPLayoutWidgetComponent, AXPWidgetConfig, AXPValueWidgetComponent, AXPWidgetCategory } from '@acorex/platform/layout/builder';
+import { AXPEntity, AXPTimeZone } from '@acorex/platform/common';
+import { AXPEntityModel, AXMEntityCrudServiceImpl } from '@acorex/platform/layout/entity';
+import * as _acorex_components_grid_layout_builder from '@acorex/components/grid-layout-builder';
+import { AXGridLayoutNode, AXGridLayoutOptions, AXGridLayoutEvent } from '@acorex/components/grid-layout-builder';
+import * as _acorex_platform_themes_shared from '@acorex/platform/themes/shared';
+import * as _ngrx_signals from '@ngrx/signals';
+import * as _acorex_modules_dashboard_management from '@acorex/modules/dashboard-management';
+import { ActivatedRoute, Router } from '@angular/router';
+import { AXDialogService } from '@acorex/components/dialog';
+import { AXPPageLayoutBaseComponent } from '@acorex/platform/layout/views';
+import { AXPopupService } from '@acorex/components/popup';
+import { AXPActionMenuItem, AXPExecuteCommand } from '@acorex/platform/core';
+import { AXBasePageComponent } from '@acorex/components/page';
+import { AXPWidgetPropertiesChangedEvent } from '@acorex/platform/layout/designer';
+import { AXButtonItemComponent } from '@acorex/components/button';
+import { AXItemClickEvent, AXEvent, AXValueChangedEvent } from '@acorex/cdk/common';
+import { AXBarChartData, AXBarChartOption } from '@acorex/charts/bar-chart';
+import { AXDonutChartData, AXDonutChartOption } from '@acorex/charts/donut-chart';
+import { AXGaugeChartOption } from '@acorex/charts/gauge-chart';
+import { AXLineChartData, AXLineChartOption, AXLineChartPointClickEvent } from '@acorex/charts/line-chart';
+import { Observable } from 'rxjs';
+
+declare const RootConfig: {
+    config: {
+        i18n: string;
+    };
+    module: {
+        module: string;
+        name: string;
+        title: string;
+        icon: string;
+    };
+    entities: {
+        dashboard: {
+            name: string;
+            title: string;
+            titlePlural: string;
+            icon: string;
+        };
+    };
+};
+
+declare class AXMDashboardManagementModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMDashboardManagementModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXMDashboardManagementModule, never, [typeof _acorex_platform_layout_builder.AXPLayoutBuilderModule], never>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXMDashboardManagementModule>;
+}
+
+declare function dashboardFactory(injector: Injector): Promise<AXPEntity | null>;
+
+interface AXMDashboardLayout {
+    id: string;
+    title: string;
+    description?: string;
+    widgets: AXMDashboardWidgetData[];
+    createdAt?: Date;
+    updatedAt?: Date;
+    createdBy?: string;
+    updatedBy?: string;
+    roleIds?: string[];
+    isDeleted?: boolean;
+    locked?: boolean;
+    scope: 'U' | 'T';
+}
+type AXMDashboardWidgetData = {
+    config: AXGridLayoutNode;
+    node?: AXPWidgetNode;
+};
+
+interface AXMCommonDashboardEntityModel extends AXPEntityModel<string> {
+    name: string;
+    title: string;
+    description: string;
+    widgets: AXMDashboardWidgetData[];
+    roleIds?: string[];
+    isDeleted?: boolean;
+    locked?: boolean;
+    scope: 'U' | 'T';
+}
+
+declare abstract class AXMDashboardService extends AXMEntityCrudServiceImpl<string, AXMCommonDashboardEntityModel> {
+}
+declare class AXMDashboardServiceImpl extends AXMDashboardService {
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMDashboardServiceImpl, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMDashboardServiceImpl>;
+}
+
+declare class AXMDashboardHomeComponent extends AXPPageLayoutBaseComponent implements OnInit {
+    #private;
+    protected readonly rootConfig: {
+        config: {
+            i18n: string;
+        };
+        module: {
+            module: string;
+            name: string;
+            title: string;
+            icon: string;
+        };
+        entities: {
+            dashboard: {
+                name: string;
+                title: string;
+                titlePlural: string;
+                icon: string;
+            };
+        };
+    };
+    protected readonly activatedRoute: ActivatedRoute;
+    protected readonly dialogService: AXDialogService;
+    protected readonly popupService: AXPopupService;
+    protected readonly router: Router;
+    protected readonly store: {
+        dashboards: _angular_core.Signal<_acorex_modules_dashboard_management.AXMDashboardLayout[]>;
+        allDashboards: _angular_core.Signal<_acorex_modules_dashboard_management.AXMDashboardLayout[]>;
+        currentDashboardId: _angular_core.Signal<string | null>;
+        isAdmin: _angular_core.Signal<boolean>;
+        dashboardsOption: _ngrx_signals.DeepSignal<_acorex_components_grid_layout_builder.AXGridLayoutOptions>;
+        isLoading: _angular_core.Signal<boolean>;
+        selectedDashboard: _angular_core.Signal<_acorex_modules_dashboard_management.AXMDashboardLayout | null>;
+        isUserAdmin: _angular_core.Signal<boolean>;
+        availableDashboards: _angular_core.Signal<_acorex_modules_dashboard_management.AXMDashboardLayout[]>;
+        currentLayoutOptions: _angular_core.Signal<_acorex_components_grid_layout_builder.AXGridLayoutOptions>;
+        canConfigureWidget: _angular_core.Signal<(widget: _acorex_modules_dashboard_management.AXMDashboardWidgetData) => any>;
+        isWidgetLocked: _angular_core.Signal<(widget: _acorex_modules_dashboard_management.AXMDashboardWidgetData) => any>;
+        setCurrentDashboard: (dashboardId: string) => void;
+        addDashboard: () => Promise<void>;
+        editDashboard: () => Promise<void>;
+        addWidget: () => Promise<void>;
+        removeDashboard: (id: string) => Promise<void>;
+        removeWidget: (dashboardId: string, widgetId: string) => Promise<void>;
+        handleConfigChange: (dashboard: _acorex_modules_dashboard_management.AXMDashboardLayout) => Promise<void>;
+        onGridChange: (event: _acorex_components_grid_layout_builder.AXGridLayoutEvent) => Promise<void>;
+        handlePopupConfiguration: (widgetNode: _acorex_platform_layout_builder.AXPWidgetNode) => Promise<void>;
+        handleValueChanged: (widgetNode: _acorex_platform_layout_builder.AXPWidgetNode, data: unknown) => Promise<void>;
+        handleOptionsChanged: (widgetNode: _acorex_platform_layout_builder.AXPWidgetNode, data: unknown) => Promise<void>;
+        setIsAdmin: (isAdmin: boolean) => void;
+        filterDashboardsByScope: (isAdmin: boolean) => void;
+        toggleLockDashboard: () => Promise<void>;
+        isDashboardLocked: () => boolean;
+    } & _ngrx_signals.StateSource<{
+        dashboards: _acorex_modules_dashboard_management.AXMDashboardLayout[];
+        allDashboards: _acorex_modules_dashboard_management.AXMDashboardLayout[];
+        currentDashboardId: string | null;
+        isAdmin: boolean;
+        dashboardsOption: _acorex_components_grid_layout_builder.AXGridLayoutOptions;
+        isLoading: boolean;
+    }>;
+    protected readonly themeService: {
+        currentMode: _angular_core.Signal<_acorex_platform_themes_shared.AXPThemeMode>;
+        currentPalette: _angular_core.Signal<string>;
+        systemThemeMode: _angular_core.Signal<_acorex_platform_themes_shared.AXPThemeMode>;
+        font: _ngrx_signals.DeepSignal<{
+            family: string;
+            size: string;
+        }>;
+        screenSize: _angular_core.Signal<_acorex_platform_themes_shared.AXPScreenSize>;
+        deviceType: _angular_core.Signal<_acorex_platform_themes_shared.AXPDeviceType>;
+        isTouchDevice: _angular_core.Signal<boolean>;
+        overlayLoading: _angular_core.Signal<boolean>;
+        navigationLoading: _angular_core.Signal<boolean>;
+        overlayLoadingTaskCount: _angular_core.Signal<number>;
+        navigationLoadingTaskCount: _angular_core.Signal<number>;
+        sideMenuState: _angular_core.Signal<_acorex_platform_themes_shared.AXPSideMenuState>;
+        sideMenuWidth: _angular_core.Signal<number>;
+        menuOrientation: _angular_core.Signal<_acorex_platform_themes_shared.AXPMenuOrientation>;
+        isDarkMode: _angular_core.Signal<boolean>;
+        isLightMode: _angular_core.Signal<boolean>;
+        isSystemMode: _angular_core.Signal<boolean>;
+        isSideMenuOpen: _angular_core.Signal<boolean>;
+        isSideMenuOverlay: _angular_core.Signal<boolean>;
+        isSmall: _angular_core.Signal<boolean>;
+        isMedium: _angular_core.Signal<boolean>;
+        isLarge: _angular_core.Signal<boolean>;
+        isMobileDevice: _angular_core.Signal<boolean>;
+        isTabletDevice: _angular_core.Signal<boolean>;
+        isDesktopDevice: _angular_core.Signal<boolean>;
+        isTouchScreen: _angular_core.Signal<boolean>;
+        isOverlayLoading: _angular_core.Signal<boolean>;
+        isNavigationLoading: _angular_core.Signal<boolean>;
+        isMenuHorizontal: _angular_core.Signal<boolean>;
+        changeThemeMode: (theme: _acorex_platform_themes_shared.AXPThemeMode) => void;
+        openSideMenu: () => void;
+        closeSideMenu: () => void;
+        setSideMenuWidth: (width: number) => void;
+        toggleSideMenu: () => void;
+        setNavigationLoading: (value: boolean, delay?: number) => void;
+        setOverlayLoading: (value: boolean, delay?: number) => void;
+        loadSettings: () => Promise<void>;
+    } & _ngrx_signals.StateSource<{
+        currentMode: _acorex_platform_themes_shared.AXPThemeMode;
+        currentPalette: string;
+        systemThemeMode: _acorex_platform_themes_shared.AXPThemeMode;
+        font: {
+            family: string;
+            size: string;
+        };
+        screenSize: _acorex_platform_themes_shared.AXPScreenSize;
+        deviceType: _acorex_platform_themes_shared.AXPDeviceType;
+        isTouchDevice: boolean;
+        overlayLoading: boolean;
+        navigationLoading: boolean;
+        overlayLoadingTaskCount: number;
+        navigationLoadingTaskCount: number;
+        sideMenuState: _acorex_platform_themes_shared.AXPSideMenuState;
+        sideMenuWidth: number;
+        menuOrientation: _acorex_platform_themes_shared.AXPMenuOrientation;
+    }>;
+    protected readonly context: _angular_core.WritableSignal<{}>;
+    private dashboardsLoaded;
+    ngOnInit(): Promise<void>;
+    private applyDashboardFiltering;
+    protected confirmWidgetDelete(dashboardId: string, widgetId: string): Promise<void>;
+    getPageTitle(): string;
+    getPageDescription(): Promise<string>;
+    protected getTitleActions(): AXPActionMenuItem[] | Promise<AXPActionMenuItem[]>;
+    getPrimaryMenuItems(): Promise<AXPActionMenuItem[]>;
+    getSecondaryMenuItems(): Promise<AXPActionMenuItem[]>;
+    execute(command: AXPExecuteCommand): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMDashboardHomeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMDashboardHomeComponent, "axm-dashboard-home", never, {}, {}, never, never, true, never>;
+}
+
+declare const AXMDashboardStore: _angular_core.Type<{
+    dashboards: _angular_core.Signal<AXMDashboardLayout[]>;
+    allDashboards: _angular_core.Signal<AXMDashboardLayout[]>;
+    currentDashboardId: _angular_core.Signal<string | null>;
+    isAdmin: _angular_core.Signal<boolean>;
+    dashboardsOption: _ngrx_signals.DeepSignal<AXGridLayoutOptions>;
+    isLoading: _angular_core.Signal<boolean>;
+    selectedDashboard: _angular_core.Signal<AXMDashboardLayout | null>;
+    isUserAdmin: _angular_core.Signal<boolean>;
+    availableDashboards: _angular_core.Signal<AXMDashboardLayout[]>;
+    currentLayoutOptions: _angular_core.Signal<AXGridLayoutOptions>;
+    canConfigureWidget: _angular_core.Signal<(widget: AXMDashboardWidgetData) => any>;
+    isWidgetLocked: _angular_core.Signal<(widget: AXMDashboardWidgetData) => any>;
+    setCurrentDashboard: (dashboardId: string) => void;
+    addDashboard: () => Promise<void>;
+    editDashboard: () => Promise<void>;
+    addWidget: () => Promise<void>;
+    removeDashboard: (id: string) => Promise<void>;
+    removeWidget: (dashboardId: string, widgetId: string) => Promise<void>;
+    handleConfigChange: (dashboard: AXMDashboardLayout) => Promise<void>;
+    onGridChange: (event: AXGridLayoutEvent) => Promise<void>;
+    handlePopupConfiguration: (widgetNode: AXPWidgetNode) => Promise<void>;
+    handleValueChanged: (widgetNode: AXPWidgetNode, data: unknown) => Promise<void>;
+    handleOptionsChanged: (widgetNode: AXPWidgetNode, data: unknown) => Promise<void>;
+    setIsAdmin: (isAdmin: boolean) => void;
+    filterDashboardsByScope: (isAdmin: boolean) => void;
+    toggleLockDashboard: () => Promise<void>;
+    isDashboardLocked: () => boolean;
+} & _ngrx_signals.StateSource<{
+    dashboards: AXMDashboardLayout[];
+    allDashboards: AXMDashboardLayout[];
+    currentDashboardId: string | null;
+    isAdmin: boolean;
+    dashboardsOption: AXGridLayoutOptions;
+    isLoading: boolean;
+}>>;
+
+declare class AXMAddDashboardPopup extends AXBasePageComponent implements OnInit {
+    protected readonly scope: string;
+    private readonly data;
+    private readonly roleService;
+    private readonly sessionService;
+    protected title: _angular_core.ModelSignal<string>;
+    protected description: _angular_core.ModelSignal<string>;
+    protected selectedRoleIds: _angular_core.ModelSignal<string[]>;
+    protected isDisabled: _angular_core.ModelSignal<boolean>;
+    protected isLocked: _angular_core.ModelSignal<boolean>;
+    protected isAdmin: _angular_core.ModelSignal<boolean>;
+    protected roles: any[];
+    protected get isValid(): boolean;
+    ngOnInit(): Promise<void>;
+    protected handleClose(isCanceled?: boolean): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMAddDashboardPopup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMAddDashboardPopup, "ng-component", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "selectedRoleIds": { "alias": "selectedRoleIds"; "required": false; "isSignal": true; }; "isDisabled": { "alias": "isDisabled"; "required": false; "isSignal": true; }; "isLocked": { "alias": "isLocked"; "required": false; "isSignal": true; }; "isAdmin": { "alias": "isAdmin"; "required": false; "isSignal": true; }; }, { "title": "titleChange"; "description": "descriptionChange"; "selectedRoleIds": "selectedRoleIdsChange"; "isDisabled": "isDisabledChange"; "isLocked": "isLockedChange"; "isAdmin": "isAdminChange"; }, never, never, true, never>;
+}
+
+declare class AXMConfigurationPopup extends AXBasePageComponent implements OnInit {
+    widget: AXPWidgetNode;
+    protected readonly widgetData: _angular_core.WritableSignal<AXPWidgetNode | null>;
+    ngOnInit(): void;
+    protected handleClose(isCanceled?: boolean): Promise<void>;
+    protected handlePropertyChange(event: AXPWidgetPropertiesChangedEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMConfigurationPopup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMConfigurationPopup, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare class AXMDashboardPopupService {
+    private readonly popupService;
+    private readonly translateService;
+    generateDashboardLayout(data: Partial<AXMDashboardLayout>, isAdmin: boolean): Promise<AXMDashboardLayout | void>;
+    handlePopupConfiguration(widget: AXPWidgetNode): Promise<AXPWidgetNode | void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMDashboardPopupService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMDashboardPopupService>;
+}
+
+declare enum AXPHomeDashboardSetting {
+    CurrentDashboard = "home:dashboard:current-dashboard"
+}
+
+declare class AXMDashboardWidgetWrapperComponent {
+    #private;
+    title: _angular_core.InputSignal<string | null>;
+    onDelete: _angular_core.OutputEmitterRef<void>;
+    onConfiguration: _angular_core.OutputEmitterRef<void>;
+    onValueChanged: _angular_core.OutputEmitterRef<unknown>;
+    onOptionsChanged: _angular_core.OutputEmitterRef<unknown>;
+    widget: _angular_core.Signal<AXPWidgetRendererDirective | undefined>;
+    hasConfiguration: _angular_core.InputSignal<boolean>;
+    isLocked: _angular_core.InputSignal<boolean>;
+    isDropdownOpen: _angular_core.WritableSignal<boolean>;
+    handleOnItemClick(event: AXItemClickEvent<AXButtonItemComponent>): void;
+    log(event: AXEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMDashboardWidgetWrapperComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMDashboardWidgetWrapperComponent, "axm-dashboard-widget-wrapper", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "hasConfiguration": { "alias": "hasConfiguration"; "required": false; "isSignal": true; }; "isLocked": { "alias": "isLocked"; "required": false; "isSignal": true; }; }, { "onDelete": "onDelete"; "onConfiguration": "onConfiguration"; "onValueChanged": "onValueChanged"; "onOptionsChanged": "onOptionsChanged"; }, ["widget"], ["*"], true, never>;
+}
+
+declare class AXMClockWidgetViewComponent extends AXPLayoutWidgetComponent {
+    private readonly regionalService;
+    private userTimezone;
+    constructor();
+    private loadUserTimezone;
+    timezone: _angular_core.Signal<AXPTimeZone | null>;
+    others: _angular_core.Signal<AXPTimeZone[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMClockWidgetViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMClockWidgetViewComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare const AXPAnalogClockWidget: AXPWidgetConfig;
+declare module '@acorex/platform/layout/builder' {
+    interface AXPWidgetTypesMap {
+        analogClock: 'analog-clock';
+    }
+}
+
+interface AXMClockMark {
+    transform?: string;
+    top?: string;
+    left?: string;
+    value?: number;
+}
+declare class AXMAnalogClockComponent implements OnInit, OnDestroy {
+    timezone: _angular_core.InputSignal<string | undefined>;
+    classes: _angular_core.InputSignal<string | undefined>;
+    showNumbers: _angular_core.InputSignal<boolean>;
+    private readonly currentTime;
+    private readonly timeParts;
+    constructor();
+    readonly hourHandTransform: _angular_core.Signal<string>;
+    readonly minuteHandTransform: _angular_core.Signal<string>;
+    readonly secondHandTransform: _angular_core.Signal<string>;
+    hourLines: AXMClockMark[];
+    hourNumbers: AXMClockMark[];
+    dots: AXMClockMark[];
+    private timerId?;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private createClockMarks;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMAnalogClockComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMAnalogClockComponent, "axm-analog-clock", never, { "timezone": { "alias": "timezone"; "required": false; "isSignal": true; }; "classes": { "alias": "classes"; "required": false; "isSignal": true; }; "showNumbers": { "alias": "showNumbers"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Bar Chart Widget Component
+ * Renders data as vertical bars with interactive hover effects and animations
+ */
+declare class AXPBarChartWidgetViewComponent extends AXPValueWidgetComponent {
+    barChartData: Signal<AXBarChartData[]>;
+    barChartOptions: Signal<AXBarChartOption & {
+        title: string;
+    }>;
+    constructor();
+    handleBarClick(event: any): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPBarChartWidgetViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPBarChartWidgetViewComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare const AXPBarChartWidget: AXPWidgetConfig;
+declare module '@acorex/platform/layout/builder' {
+    interface AXPWidgetTypesMap {
+        barChart: 'bar-chart';
+    }
+}
+
+declare const AXP_WIDGETS_CHART_CATEGORY: AXPWidgetCategory;
+declare const AXP_WIDGETS_UTILITY_CATEGORY: AXPWidgetCategory;
+
+/**
+ * ACoreX Clock Calendar Widget Types
+ * Contains all types and interfaces for the Clock Calendar widget
+ */
+/**
+ * Clock layout display options
+ */
+type AXPClockLayout = 'both' | 'digital' | 'analog';
+/**
+ * Clock timezone options
+ */
+interface AXPTimezoneOption {
+    id: string;
+    title: string;
+}
+/**
+ * Date format options
+ */
+interface AXPDateFormatOption {
+    id: string;
+    title: string;
+}
+/**
+ * Hour number definition for the analog clock
+ */
+interface AXPHourNumber {
+    number: number;
+    angle: number;
+}
+/**
+ * Widget options for configuring the clock-calendar
+ */
+interface AXPClockCalendarOptions {
+    displayLayout?: AXPClockLayout;
+    showDate?: boolean;
+    showDayOfWeek?: boolean;
+    use24Hour?: boolean;
+    showSeconds?: boolean;
+    showHourMarkers?: boolean;
+    dateFormat?: string;
+    timezone?: string;
+}
+/**
+ * Common timezone options for the widget configuration
+ */
+declare const AXP_TIMEZONE_OPTIONS: AXPTimezoneOption[];
+/**
+ * Common date format options for the widget configuration
+ */
+declare const AXP_DATE_FORMAT_OPTIONS: AXPDateFormatOption[];
+
+declare class AXPClockCalendarWidgetViewComponent extends AXPValueWidgetComponent implements OnInit, OnDestroy {
+    private readonly cdr;
+    protected currentTime: Date;
+    protected currentDate: Date;
+    private clockSubscription;
+    protected readonly clockHours: number[];
+    protected readonly clockHourNumbers: AXPHourNumber[];
+    protected hourRotation: number;
+    protected minuteRotation: number;
+    protected secondRotation: number;
+    protected readonly displayLayout: Signal<string>;
+    protected readonly showDigitalClock: Signal<boolean>;
+    protected readonly showAnalogClock: Signal<boolean>;
+    protected readonly showDate: Signal<boolean>;
+    protected readonly showDayOfWeek: Signal<boolean>;
+    protected readonly use24Hour: Signal<boolean>;
+    protected readonly showSeconds: Signal<boolean>;
+    protected readonly dateFormat: Signal<string>;
+    protected readonly timezone: Signal<string>;
+    protected readonly displayTimezone: Signal<string>;
+    protected readonly timeFormat: Signal<string>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private startClockTimer;
+    private stopClockTimer;
+    private updateTime;
+    private getAdjustedTime;
+    private updateClockHandsRotation;
+    protected initializeWidget(): void;
+    protected updateWidget(): void;
+    protected destroyWidget(): void;
+    protected getDayOfWeek(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPClockCalendarWidgetViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPClockCalendarWidgetViewComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare const AXPClockCalendarWidget: AXPWidgetConfig;
+declare module '@acorex/platform/layout/builder' {
+    interface AXPWidgetTypesMap {
+        clockCalendar: 'clock-calendar';
+    }
+}
+
+/**
+ * Donut Chart Widget Component
+ * Displays data in a circular donut chart with interactive segments
+ */
+declare class AXPDonutChartWidgetViewComponent extends AXPValueWidgetComponent {
+    donutChartData: Signal<AXDonutChartData[]>;
+    donutChartOptions: Signal<AXDonutChartOption & {
+        title: string;
+    }>;
+    constructor();
+    handleDonutChartSegmentClick(event: any): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPDonutChartWidgetViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPDonutChartWidgetViewComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare const AXPDonutChartWidget: AXPWidgetConfig;
+declare module '@acorex/platform/layout/builder' {
+    interface AXPWidgetTypesMap {
+        donutChart: 'donut-chart';
+    }
+}
+
+/**
+ * Gauge Chart Widget Component
+ * Renders a semi-circular gauge chart with animated needle and thresholds
+ */
+declare class AXPGaugeChartWidgetViewComponent extends AXPValueWidgetComponent {
+    gaugeChartValue: Signal<number>;
+    gaugeChartOptions: Signal<AXGaugeChartOption & {
+        title: string;
+    }>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPGaugeChartWidgetViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPGaugeChartWidgetViewComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare const AXPGaugeChartWidget: AXPWidgetConfig;
+declare module '@acorex/platform/layout/builder' {
+    interface AXPWidgetTypesMap {
+        gaugeChart: 'gauge-chart';
+    }
+}
+
+/**
+ * Line Chart Widget Component
+ * Renders data as lines with interactive hover effects and animations
+ */
+declare class AXPLineChartWidgetViewComponent extends AXPValueWidgetComponent {
+    lineChartData: Signal<AXLineChartData[]>;
+    lineChartOptions: Signal<AXLineChartOption & {
+        title: string;
+    }>;
+    constructor();
+    handleLineChartPointClick(event: AXLineChartPointClickEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPLineChartWidgetViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPLineChartWidgetViewComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare const AXPLineChartWidget: AXPWidgetConfig;
+declare module '@acorex/platform/layout/builder' {
+    interface AXPWidgetTypesMap {
+        lineChart: 'line-chart';
+    }
+}
+
+declare class AXPStickyNoteWidgetViewComponent extends AXPValueWidgetComponent<string> implements OnInit {
+    protected isEditing: _angular_core.WritableSignal<boolean>;
+    private wysiwyg;
+    protected value: _angular_core.Signal<string>;
+    protected date: _angular_core.Signal<any>;
+    protected bgColor: _angular_core.Signal<any>;
+    protected color: _angular_core.WritableSignal<string>;
+    private el;
+    protected colorPresets: string[];
+    handleClickOutside(event: MouseEvent): void;
+    protected activateEdit(): void;
+    protected saveChanges(): void;
+    protected setColor(color: string): void;
+    protected valueChange(event: AXValueChangedEvent<any>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPStickyNoteWidgetViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPStickyNoteWidgetViewComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare const AXPStickyNoteWidget: AXPWidgetConfig;
+declare module '@acorex/platform/layout/builder' {
+    interface AXPWidgetTypesMap {
+        stickyNote: 'sticky-note';
+    }
+}
+
+/**
+ * Task List Data structure
+ */
+interface AXPTaskData {
+    id: string;
+    title: string;
+    completed: boolean;
+    priority?: 'low' | 'medium' | 'high';
+    dueDate?: Date | string;
+    category?: string;
+    assignedTo?: {
+        id: string;
+        name: string;
+        image?: string;
+    };
+    createdAt: Date | string;
+}
+/**
+ * Task List Widget Value
+ */
+interface AXPTaskListValue {
+    data: AXPTaskData[];
+}
+/**
+ * Task List Widget Options
+ */
+interface AXPTaskListOptions {
+    maxItems?: number;
+    showDate?: boolean;
+    showAssignee?: boolean;
+    showCategory?: boolean;
+    showPriority?: boolean;
+    groupByCategory?: boolean;
+    groupByPriority?: boolean;
+    allowMarkComplete?: boolean;
+}
+
+/**
+ * Task List Widget Component
+ * Displays a list of tasks with checkboxes and filtering options
+ */
+declare class AXPTaskListWidgetViewComponent extends AXPValueWidgetComponent<AXPTaskListValue> {
+    taskClick: _angular_core.OutputEmitterRef<AXPTaskData>;
+    taskCompleted: _angular_core.OutputEmitterRef<AXPTaskData>;
+    private readonly cdr;
+    private readonly datePipe;
+    protected readonly maxItems: _angular_core.Signal<any>;
+    protected readonly showDate: _angular_core.Signal<any>;
+    protected readonly showAssignee: _angular_core.Signal<any>;
+    protected readonly showPriority: _angular_core.Signal<any>;
+    protected readonly allowMarkComplete: _angular_core.Signal<any>;
+    protected readonly showCategories: _angular_core.Signal<any>;
+    protected readonly taskItems: _angular_core.Signal<AXPTaskData[]>;
+    protected getPendingTaskCount(): number;
+    protected getCompletedTaskCount(): number;
+    protected hasCategories(): boolean;
+    protected getCategories(): string[];
+    protected getTasksByCategory(category: string): AXPTaskData[];
+    protected getCategoryTaskCount(category: string): number;
+    protected onTaskClick(task: AXPTaskData): void;
+    protected onTaskCompletionChange(task: AXPTaskData, isCompleted: boolean): void;
+    protected formatDueDate(date: Date | string | undefined): string;
+    protected getPriorityColor(priority: string | undefined): string;
+    private getFilteredTasks;
+    protected getDaysDifference(date: Date): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPTaskListWidgetViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPTaskListWidgetViewComponent, "ng-component", never, {}, { "taskClick": "taskClick"; "taskCompleted": "taskCompleted"; }, never, never, true, never>;
+}
+
+declare const AXPTaskListWidget: AXPWidgetConfig;
+declare module '@acorex/platform/layout/builder' {
+    interface AXPWidgetTypesMap {
+        taskList: 'task-list';
+    }
+}
+
+/**
+ * Weather location information
+ */
+interface AXPWeatherLocation {
+    /** City name */
+    city: string;
+    /** Country name */
+    country: string;
+    /** Formatted location display name */
+    displayName: string;
+}
+/**
+ * Weather current condition information
+ */
+interface AXPWeatherCondition {
+    /** Condition text */
+    condition: string;
+    /** Condition code */
+    conditionCode: number;
+    /** Icon URL */
+    iconUrl: string;
+    /** Temperature in Celsius */
+    tempC: number;
+    /** Temperature in Fahrenheit */
+    tempF: number;
+    /** Feels like temperature in Celsius */
+    feelsLikeC: number;
+    /** Feels like temperature in Fahrenheit */
+    feelsLikeF: number;
+    /** Humidity percentage */
+    humidity: number;
+    /** Wind speed in km/h */
+    windKph: number;
+    /** Wind speed in mph */
+    windMph: number;
+    /** Wind direction */
+    windDirection: string;
+    /** UV index */
+    uv: number;
+    /** Last updated timestamp */
+    lastUpdated: string;
+}
+/**
+ * Weather forecast data for a single day
+ */
+interface AXPWeatherForecastDay {
+    /** Date string */
+    date: string;
+    /** Day name (e.g., "Mon", "Tue") */
+    day: string;
+    /** Weather condition code */
+    condition: string;
+    /** Weather icon URL */
+    iconUrl: string;
+    /** Max temperature in Celsius */
+    maxTempC: number;
+    /** Max temperature in Fahrenheit */
+    maxTempF: number;
+    /** Min temperature in Celsius */
+    minTempC: number;
+    /** Min temperature in Fahrenheit */
+    minTempF: number;
+    /** Hourly forecast data */
+    hour: AXPWeatherHour[];
+}
+/**
+ * Weather hourly forecast data
+ */
+interface AXPWeatherHour {
+    /** Time string */
+    time: string;
+    /** Weather condition code */
+    condition: string;
+    /** Weather icon URL */
+    iconUrl: string;
+    /** Hourly temperature in Celsius */
+    tempC: number;
+    /** Hourly temperature in Fahrenheit */
+    tempF: number;
+}
+/**
+ * Complete weather data response
+ */
+interface AXPWeatherData {
+    /** Location information */
+    location: AXPWeatherLocation;
+    /** Current weather data */
+    current: AXPWeatherCondition;
+    /** Forecast data */
+    forecast: AXPWeatherForecastDay[];
+}
+/**
+ * Weather API request options
+ */
+interface AXPWeatherRequestOptions {
+    /** Temperature unit */
+    tempUnit?: string;
+    /** Location query */
+    location?: string;
+    /** Use mock data */
+    useMockData?: boolean;
+}
+/**
+ * Weather UI condition display info
+ */
+interface AXPWeatherConditionDisplay {
+    /** Condition unique ID */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Icon class (Font Awesome) */
+    icon: string;
+    /** SVG icon name */
+    svgIcon: string;
+    /** Associated color */
+    color: string;
+}
+/**
+ * Abstract Weather API Service
+ * Base class that defines the interface and common functionality
+ * for weather data providers
+ */
+declare abstract class AXPWeatherApiAbstract {
+    /** Weather condition definitions mapping */
+    protected weatherConditions: Record<string, AXPWeatherConditionDisplay>;
+    /** Day of week mapping */
+    protected readonly dayNames: string[];
+    /**
+     * Get weather condition info by ID
+     * @param id Condition ID
+     * @returns Weather condition info or default if not found
+     */
+    getCondition(id: string): AXPWeatherConditionDisplay;
+    /**
+     * Get current weather data for given location
+     * @param options Weather request options
+     * @returns Observable with weather data
+     */
+    abstract getWeather(options: AXPWeatherRequestOptions): Observable<AXPWeatherData>;
+    /**
+     * Get weather forecast for a location
+     * @param options Weather request options with days
+     * @returns Observable of weather data with forecast
+     */
+    abstract getForecast(options: AXPWeatherRequestOptions & {
+        days?: number;
+    }): Observable<AXPWeatherData>;
+    /**
+     * Parse location string into city and display components
+     * @param location Location query string
+     * @returns Parsed location parts
+     */
+    protected parseLocation(location: string): {
+        city: string;
+        country: string;
+        display: string;
+    };
+    /**
+     * Format location name for display
+     * @param locationParts Parsed location parts
+     * @returns Formatted location name
+     */
+    protected formatLocationName(locationParts: {
+        city: string;
+        country: string;
+        display: string;
+    }): string;
+    /**
+     * Map API condition text to our internal condition IDs
+     * @param conditionText Condition text from API
+     * @returns Internal condition ID
+     */
+    protected mapApiConditionToId(conditionText: string): string;
+    /**
+     * Generate random integer between min and max (inclusive)
+     * Helper method for implementations
+     * @param min Minimum value
+     * @param max Maximum value
+     * @returns Random integer
+     */
+    protected getRandomInt(min: number, max: number): number;
+    /**
+     * Set the API key for the weather service
+     * This is only used by the real API implementation,
+     * but is defined in the abstract class for consistency
+     * @param key The API key
+     */
+    abstract setApiKey(key: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPWeatherApiAbstract, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPWeatherApiAbstract>;
+}
+
+/**
+ * Mock Weather API Service
+ * Provides simulated weather data for development and testing
+ */
+declare class AXPWeatherApiMockService extends AXPWeatherApiAbstract {
+    private readonly mockDelay;
+    /**
+     * Get current weather data for given location
+     * @param options Weather request options
+     * @returns Observable with weather data
+     */
+    getWeather(options: AXPWeatherRequestOptions): Observable<AXPWeatherData>;
+    /**
+     * Get weather forecast for a location
+     * @param options Weather request options with days
+     * @returns Observable of weather data with forecast
+     */
+    getForecast(options: AXPWeatherRequestOptions & {
+        days?: number;
+    }): Observable<AXPWeatherData>;
+    /**
+     * Get mock weather data for demo/development
+     * @param location Location query
+     * @param options Request options
+     * @returns Observable of mock weather data
+     */
+    private getMockWeatherData;
+    /**
+     * Get mock forecast data for demo/development
+     * @param location Location query
+     * @param days Number of forecast days
+     * @param options Request options
+     * @returns Observable of mock weather data with forecast
+     */
+    private getMockForecast;
+    /**
+     * Set the API key for the weather service
+     * No-op in the mock implementation
+     * @param key The API key
+     */
+    setApiKey(key: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPWeatherApiMockService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPWeatherApiMockService>;
+}
+
+/**
+ * Real Weather API Service
+ * Fetches actual weather data from a weather API service
+ */
+declare class AXPWeatherApiService extends AXPWeatherApiAbstract {
+    private readonly http;
+    private readonly baseApiUrl;
+    private apiKeyToken;
+    /**
+     * Set the API key for the weather service
+     * @param key The API key
+     */
+    setApiKey(key: string): void;
+    /**
+     * Get current weather data for given location
+     * @param options Weather request options
+     * @returns Observable with weather data
+     */
+    getWeather(options: AXPWeatherRequestOptions): Observable<AXPWeatherData>;
+    /**
+     * Get weather forecast for a location
+     * @param options Weather request options with days
+     * @returns Observable of weather data with forecast
+     */
+    getForecast(options: AXPWeatherRequestOptions & {
+        days?: number;
+    }): Observable<AXPWeatherData>;
+    /**
+     * Transform API response to our internal data model
+     * @param apiData Raw API response
+     * @param displayName Formatted location name
+     * @returns Normalized weather data
+     */
+    private transformApiResponse;
+    /**
+     * Transform forecast API response to our internal data model
+     * @param apiData Raw API response with forecast
+     * @param displayName Formatted location name
+     * @param days Number of forecast days
+     * @returns Normalized weather data with forecast
+     */
+    private transformForecastResponse;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPWeatherApiService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPWeatherApiService>;
+}
+
+declare class AXMAdvancedWeatherViewComponent extends AXPValueWidgetComponent {
+    private weatherService;
+    protected weatherData: _angular_core.WritableSignal<AXPWeatherData | null>;
+    protected isLoading: _angular_core.WritableSignal<boolean>;
+    protected hasError: _angular_core.WritableSignal<boolean>;
+    protected errorMessage: _angular_core.WritableSignal<string>;
+    protected city: _angular_core.Signal<any>;
+    protected temperatureUnit: _angular_core.Signal<any>;
+    protected forecastDays: _angular_core.Signal<any>;
+    protected forecastHours: _angular_core.Signal<any>;
+    private iconCache;
+    constructor();
+    protected loadWeatherData(): void;
+    private handleError;
+    protected getConditionIcon(conditionId: string): string;
+    protected getConditionName(conditionId: string): string;
+    protected getCurrentTemperature(): number;
+    protected getMaxTemp(): number;
+    protected getMinTemp(): number;
+    protected getForecastDayTemp(day: any): number;
+    protected parseDate(dateStr: string): Date;
+    protected getDayName(date: Date): string;
+    protected displayedForecast: _angular_core.Signal<_acorex_modules_dashboard_management.AXPWeatherForecastDay[]>;
+    protected displayedHourlyForecast: _angular_core.Signal<AXPWeatherHour[]>;
+    protected getHourLabel(timeStr: string): string;
+    protected getHourTemp(hour: AXPWeatherHour): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMAdvancedWeatherViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMAdvancedWeatherViewComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Weather Widget Configuration
+ * Provides customization options for displaying weather data and forecast
+ */
+declare const AXPAdvancedWeatherWidget: AXPWidgetConfig;
+/**
+ * Type declaration to register the weather widget type
+ */
+declare module '@acorex/platform/layout/builder' {
+    interface AXPWidgetTypesMap {
+        advancedWeather: 'advanced-weather';
+    }
+}
+
+declare class AXMMinimalWeatherViewComponent extends AXPValueWidgetComponent {
+    private weatherService;
+    protected weatherData: _angular_core.WritableSignal<AXPWeatherData | null>;
+    protected isLoading: _angular_core.WritableSignal<boolean>;
+    protected hasError: _angular_core.WritableSignal<boolean>;
+    protected errorMessage: _angular_core.WritableSignal<string>;
+    protected city: _angular_core.Signal<any>;
+    protected temperatureUnit: _angular_core.Signal<any>;
+    private iconCache;
+    constructor();
+    protected loadWeatherData(): void;
+    private handleError;
+    protected getConditionIcon(): string;
+    protected getCurrentTemperature(): number;
+    protected getMaxTemp(): number;
+    protected getMinTemp(): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMMinimalWeatherViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMMinimalWeatherViewComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Weather Widget Configuration
+ * Provides customization options for displaying weather data and forecast
+ */
+declare const AXPMinimalWeatherWidget: AXPWidgetConfig;
+/**
+ * Type declaration to register the weather widget type
+ */
+declare module '@acorex/platform/layout/builder' {
+    interface AXPWidgetTypesMap {
+        minimalWeather: 'minimal-weather';
+    }
+}
+
+/**
+ * Weather Widget Component
+ * Displays current weather conditions and optional forecast data
+ * for a specified location with customizable display options.
+ */
+declare class AXPWeatherWidgetViewComponent extends AXPValueWidgetComponent {
+    protected cdr: ChangeDetectorRef;
+    protected containerEl: _angular_core.Signal<ElementRef<HTMLDivElement>>;
+    private weatherService;
+    protected weatherData: _angular_core.WritableSignal<AXPWeatherData | null>;
+    protected isLoading: _angular_core.WritableSignal<boolean>;
+    protected hasError: _angular_core.WritableSignal<boolean>;
+    protected errorMessage: _angular_core.WritableSignal<string>;
+    protected isForecastLoading: _angular_core.WritableSignal<boolean>;
+    private refreshSubscription;
+    protected city: _angular_core.Signal<any>;
+    protected temperatureUnit: _angular_core.Signal<any>;
+    protected windSpeedUnit: _angular_core.Signal<any>;
+    protected showCurrentCondition: _angular_core.Signal<boolean>;
+    protected showTemperature: _angular_core.Signal<boolean>;
+    protected showHumidity: _angular_core.Signal<boolean>;
+    protected showWind: _angular_core.Signal<boolean>;
+    protected showForecast: _angular_core.Signal<boolean>;
+    protected forecastDays: _angular_core.Signal<any>;
+    protected autoRefresh: _angular_core.Signal<boolean>;
+    protected refreshInterval: _angular_core.Signal<any>;
+    private optionsEffect;
+    private valueEffect;
+    protected displayedForecast: _angular_core.Signal<_acorex_modules_dashboard_management.AXPWeatherForecastDay[]>;
+    /**
+     * Component constructor
+     * @param cdr ChangeDetectorRef for triggering view updates
+     */
+    constructor(cdr: ChangeDetectorRef);
+    /**
+     * Component cleanup on destroy
+     */
+    ngOnDestroy(): void;
+    /**
+     * Loads weather data from the API
+     * Sets loading state and handles errors
+     */
+    private loadWeatherData;
+    /**
+     * Sets up the auto-refresh timer based on configuration
+     */
+    private setupRefreshTimer;
+    /**
+     * Clears the refresh timer subscription
+     */
+    private clearRefreshTimer;
+    /**
+     * Manually refreshes the weather data
+     */
+    protected refreshWeather(): void;
+    /**
+     * Gets the current temperature based on selected unit
+     */
+    protected getCurrentTemperature(): number;
+    /**
+     * Gets the feels like temperature based on selected unit
+     */
+    protected getFeelsLikeTemperature(): number;
+    /**
+     * Gets the humidity percentage
+     */
+    protected getHumidity(): number;
+    /**
+     * Gets the wind speed based on selected unit
+     */
+    protected getWindSpeed(): number;
+    /**
+     * Gets the current weather condition
+     */
+    protected getCurrentCondition(): string;
+    /**
+     * Gets the formatted last updated time
+     */
+    protected getLastUpdated(): string;
+    /**
+     * Gets the appropriate icon class for a weather condition
+     * @param conditionId The ID of the weather condition
+     * @returns The Font Awesome icon class string
+     */
+    protected getConditionIcon(conditionId: string): string;
+    /**
+     * Gets the display name for a weather condition
+     * @param conditionId The ID of the weather condition
+     * @returns The translated display name
+     */
+    protected getConditionName(conditionId: string): string;
+    /**
+     * Gets the color for a weather condition
+     * @param conditionId Weather condition ID
+     * @returns CSS color value
+     */
+    protected getConditionColor(conditionId: string): string;
+    /**
+     * Cleans up chart resources
+     * Required by AXPChartBaseComponent
+     */
+    protected cleanupChart(): void;
+    private handleError;
+    protected getTemperatureUnit(): string;
+    protected getWindSpeedUnit(): string;
+    protected getDayName(date: Date): string;
+    protected parseDate(dateStr: string): Date;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPWeatherWidgetViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPWeatherWidgetViewComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Weather Widget Configuration
+ * Provides customization options for displaying weather data and forecast
+ */
+declare const AXPWeatherWidget: AXPWidgetConfig;
+/**
+ * Type declaration to register the weather widget type
+ */
+declare module '@acorex/platform/layout/builder' {
+    interface AXPWidgetTypesMap {
+        weather: 'weather';
+    }
+}
+
+export { AXMAddDashboardPopup, AXMAdvancedWeatherViewComponent, AXMAnalogClockComponent, AXMClockWidgetViewComponent, AXMConfigurationPopup, AXMDashboardHomeComponent, AXMDashboardManagementModule, AXMDashboardPopupService, AXMDashboardService, AXMDashboardServiceImpl, AXMDashboardStore, AXMDashboardWidgetWrapperComponent, AXMMinimalWeatherViewComponent, AXPAdvancedWeatherWidget, AXPAnalogClockWidget, AXPBarChartWidget, AXPBarChartWidgetViewComponent, AXPClockCalendarWidget, AXPClockCalendarWidgetViewComponent, AXPDonutChartWidget, AXPDonutChartWidgetViewComponent, AXPGaugeChartWidget, AXPGaugeChartWidgetViewComponent, AXPHomeDashboardSetting, AXPLineChartWidget, AXPLineChartWidgetViewComponent, AXPMinimalWeatherWidget, AXPStickyNoteWidget, AXPStickyNoteWidgetViewComponent, AXPTaskListWidget, AXPTaskListWidgetViewComponent, AXPWeatherApiAbstract, AXPWeatherApiMockService, AXPWeatherApiService, AXPWeatherWidget, AXPWeatherWidgetViewComponent, AXP_DATE_FORMAT_OPTIONS, AXP_TIMEZONE_OPTIONS, AXP_WIDGETS_CHART_CATEGORY, AXP_WIDGETS_UTILITY_CATEGORY, RootConfig, dashboardFactory };
+export type { AXMCommonDashboardEntityModel, AXMDashboardLayout, AXMDashboardWidgetData, AXPClockCalendarOptions, AXPClockLayout, AXPDateFormatOption, AXPHourNumber, AXPTaskData, AXPTaskListOptions, AXPTaskListValue, AXPTimezoneOption, AXPWeatherCondition, AXPWeatherConditionDisplay, AXPWeatherData, AXPWeatherForecastDay, AXPWeatherHour, AXPWeatherLocation, AXPWeatherRequestOptions };