import * as _angular_core from '@angular/core';
import { Injector, OnInit, AfterViewInit, OnDestroy, Signal, ChangeDetectorRef, ElementRef } from '@angular/core';
import * as _acorex_platform_layout_widget_core from '@acorex/platform/layout/widget-core';
import { AXPWidgetNode, AXPWidgetRendererDirective, AXPLayoutBaseWidgetComponent, AXPWidgetConfig, AXPValueWidgetComponent, AXPWidgetCategory } from '@acorex/platform/layout/widget-core';
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/components';
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 AXMDashboardEntityModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMDashboardEntityModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXMDashboardEntityModule, never, never, never>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXMDashboardEntityModule>;
}

declare class AXMDashboardManagementModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMDashboardManagementModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXMDashboardManagementModule, never, [typeof _acorex_platform_layout_widget_core.AXPWidgetCoreModule, typeof AXMDashboardEntityModule], 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[];
    userId?: string;
    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) => boolean>;
        isWidgetLocked: _angular_core.Signal<(widget: _acorex_modules_dashboard_management.AXMDashboardWidgetData) => boolean>;
        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_widget_core.AXPWidgetNode) => Promise<void>;
        handleValueChanged: (widgetNode: _acorex_platform_layout_widget_core.AXPWidgetNode, data: unknown) => Promise<void>;
        handleOptionsChanged: (widgetNode: _acorex_platform_layout_widget_core.AXPWidgetNode, data: unknown) => Promise<void>;
        setIsAdmin: (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>;
        isPrinting: _angular_core.Signal<boolean>;
        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;
        isPrinting: boolean;
    }>;
    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>;
}

/**
 * Dashboard Signal Store: manages dashboards, widgets and permissions.
 */
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) => boolean>;
    isWidgetLocked: _angular_core.Signal<(widget: AXMDashboardWidgetData) => boolean>;
    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;
    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;
    private readonly layoutBuilder;
    private readonly roleService;
    private readonly sessionService;
    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 AXPLayoutBaseWidgetComponent implements AfterViewInit, OnDestroy {
    private readonly regionalService;
    private readonly elementRef;
    private userTimezone;
    private containerWidth;
    private containerHeight;
    private resizeObserver;
    constructor();
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private setupResizeObserver;
    private loadUserTimezone;
    timezone: _angular_core.Signal<AXPTimeZone | null>;
    others: _angular_core.Signal<AXPTimeZone[]>;
    isHorizontal: _angular_core.Signal<boolean>;
    hasEnoughSpaceForHorizontal: _angular_core.Signal<boolean>;
    codeFontSize: _angular_core.Signal<number>;
    abbrFontSize: _angular_core.Signal<number>;
    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/widget-core' {
    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/widget-core' {
    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/widget-core' {
    interface AXPWidgetTypesMap {
        clockCalendar: 'clock-calendar';
    }
}

interface AXPShortcutItem {
    name: string;
    title: string;
    description?: string;
    icon: string;
    command: AXPExecuteCommand;
}
declare class AXPDashboardShortcutWidgetViewComponent extends AXPLayoutBaseWidgetComponent {
    private popupService;
    private workflow;
    private searchConfig;
    protected item: _angular_core.Signal<AXPShortcutItem>;
    protected color: _angular_core.Signal<string>;
    ngOnInit(): void;
    protected executeCommand(): Promise<void>;
    protected setCommand(): Promise<void>;
    private get __style();
    private get __class();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPDashboardShortcutWidgetViewComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPDashboardShortcutWidgetViewComponent, "ng-component", never, {}, {}, never, never, true, never>;
}

declare const AXPDashboardShortcutWidget: AXPWidgetConfig;

/**
 * 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/widget-core' {
    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/widget-core' {
    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/widget-core' {
    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 typeValue: _angular_core.WritableSignal<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/widget-core' {
    interface AXPWidgetTypesMap {
        stickyNote: 'sticky-note';
    }
}

/**
 * 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/widget-core' {
    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/widget-core' {
    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/widget-core' {
    interface AXPWidgetTypesMap {
        weather: 'weather';
    }
}

export { AXMAddDashboardPopup, AXMAdvancedWeatherViewComponent, AXMAnalogClockComponent, AXMClockWidgetViewComponent, AXMConfigurationPopup, AXMDashboardEntityModule, AXMDashboardHomeComponent, AXMDashboardManagementModule, AXMDashboardPopupService, AXMDashboardService, AXMDashboardServiceImpl, AXMDashboardStore, AXMDashboardWidgetWrapperComponent, AXMMinimalWeatherViewComponent, AXPAdvancedWeatherWidget, AXPAnalogClockWidget, AXPBarChartWidget, AXPBarChartWidgetViewComponent, AXPClockCalendarWidget, AXPClockCalendarWidgetViewComponent, AXPDashboardShortcutWidget, AXPDashboardShortcutWidgetViewComponent, AXPDonutChartWidget, AXPDonutChartWidgetViewComponent, AXPGaugeChartWidget, AXPGaugeChartWidgetViewComponent, AXPHomeDashboardSetting, AXPLineChartWidget, AXPLineChartWidgetViewComponent, AXPMinimalWeatherWidget, AXPStickyNoteWidget, AXPStickyNoteWidgetViewComponent, 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, AXPShortcutItem, AXPTimezoneOption, AXPWeatherCondition, AXPWeatherConditionDisplay, AXPWeatherData, AXPWeatherForecastDay, AXPWeatherHour, AXPWeatherLocation, AXPWeatherRequestOptions };
