@masterteam/dashboard-builder 0.0.1

package/types/masterteam-dashboard-builder.d.ts

@@ -0,0 +1,4616 @@
+import * as _masterteam_dashboard_builder from '@masterteam/dashboard-builder';
+import * as _angular_core from '@angular/core';
+import { OnInit, OnDestroy, AfterViewInit, OnChanges, SimpleChanges, TemplateRef, PipeTransform } from '@angular/core';
+import { GridsterItem, GridsterConfig } from 'angular-gridster2';
+import { ContextMenu } from 'primeng/contextmenu';
+import { MenuItem } from 'primeng/api';
+import * as _angular_forms from '@angular/forms';
+import { ControlValueAccessor, FormGroup, FormArray, ValidationErrors } from '@angular/forms';
+import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+import { ColumnDef, TableAction } from '@masterteam/components/table';
+import { ModalService } from '@masterteam/components/modal';
+import { ModalRef } from '@masterteam/components/dialog';
+import { MTMenuItem } from '@masterteam/components/menu';
+
+/**
+ * Localized name with English and Arabic
+ */
+interface LocalizedName {
+    en: string;
+    ar: string;
+    [key: string]: string | undefined;
+}
+/**
+ * Report type enum
+ */
+type ReportType = 'Dashboard' | 'Excel';
+/**
+ * Request for modules tree from gateway
+ */
+interface ModulesTreeRequest {
+    services: string[];
+    includeValues?: boolean;
+}
+/**
+ * Module value item from tree response
+ */
+interface ModuleValue {
+    id: number;
+    name: string;
+    value: string;
+    selector: string;
+}
+/**
+ * Module item from tree response
+ */
+interface ModuleItem {
+    id: string;
+    name: string;
+    description?: string;
+    version?: string;
+    values: ModuleValue[];
+}
+/**
+ * Service item from tree response
+ */
+interface ServiceItem {
+    serviceName: string;
+    modules: ModuleItem[];
+}
+/**
+ * Modules tree response
+ */
+interface ModulesTreeResponse {
+    services: ServiceItem[];
+}
+/**
+ * Grouped module option for select dropdown
+ */
+interface GroupedModuleOption {
+    /** Group label (module type name like "Levels", "Log") */
+    label: string;
+    /** Module type id */
+    moduleTypeId: string;
+    /** Items in this group */
+    items: ModuleSelectOption[];
+}
+/**
+ * Module option for select dropdown
+ */
+interface ModuleSelectOption {
+    /** Module id (number) */
+    id: number;
+    /** Display name */
+    name: string;
+    /** Selector format "ModuleType:Id" */
+    selector: string;
+    /** Parent module type id */
+    moduleTypeId: string;
+}
+/**
+ * Request item for bulk properties lookup
+ */
+interface BulkPropertyRequestItem {
+    serviceName: string;
+    selector: string;
+}
+/**
+ * Request for bulk properties lookup from gateway
+ */
+interface BulkPropertiesRequest {
+    items: BulkPropertyRequestItem[];
+}
+/**
+ * Response item from bulk properties lookup
+ */
+interface BulkPropertiesResponseItem {
+    serviceName: string;
+    selector: string;
+    /** Display name for the specific selector (e.g., "Projects" for "Level:7") */
+    selectorName?: string;
+    properties: PropertyItem$1[];
+}
+/**
+ * Response wrapper from bulk properties lookup
+ * API returns { data: { items: [...] } }
+ */
+interface BulkPropertiesResponse {
+    items: BulkPropertiesResponseItem[];
+}
+/**
+ * Property item from module properties response
+ */
+interface PropertyItem$1 {
+    id: number;
+    name: string;
+    hasName: boolean;
+    key: string;
+    hasKey: boolean;
+    normalizedKey: string;
+    hasNormalizedKey: boolean;
+    configuration: string;
+    hasConfiguration: boolean;
+    viewType: string;
+    hasViewType: boolean;
+    isTranslatable: boolean;
+}
+/**
+ * Property items response (lookup/status values)
+ */
+interface PropertyItemsResponse {
+    propertyKey: string;
+    viewType: string;
+    language: string;
+    items: PropertyItemOption[];
+}
+/**
+ * Property item option for filters
+ */
+interface PropertyItemOption {
+    key: string;
+    name: string;
+}
+/**
+ * Response from /metadata/{service}/modules/{moduleId}/properties
+ */
+interface PropertiesResponse {
+    properties: PropertyItem$1[];
+}
+/**
+ * Report URL configuration for dashboard exports
+ */
+interface ReportUrl {
+    url: string;
+    name: LocalizedName;
+    responseType?: string;
+}
+/**
+ * Dashboard-specific configuration
+ */
+interface ReportDashboardConfig {
+    ignoreQueryFilter?: boolean;
+    filters?: Record<string, any>;
+    versionNumber?: number;
+    extraInfo?: Record<string, any>;
+    reportUrls?: ReportUrl[];
+}
+/**
+ * Excel sheet configuration
+ */
+interface ExcelSheet {
+    name: string;
+    chartDataQuery?: {
+        dashboardId?: number;
+        [key: string]: any;
+    };
+}
+/**
+ * Excel-specific configuration
+ */
+interface ReportExcelConfig {
+    excel: ExcelSheet[];
+}
+/**
+ * Chart link configuration (per-chart config in link)
+ */
+interface ChartLinkConfiguration {
+    series?: string[];
+    [key: string]: any;
+}
+/**
+ * Report chart link - links a chart component to a report
+ */
+interface ReportChartLink {
+    id?: number;
+    reportId: number;
+    chartComponentId?: string;
+    configration: ChartLinkConfiguration;
+    order?: number;
+}
+/**
+ * Report model - base record for dashboard and excel
+ */
+interface Report {
+    id?: number;
+    name: LocalizedName;
+    type: ReportType;
+    icon?: string;
+    url?: string;
+    showInMenu?: boolean;
+    isActive?: boolean;
+    createdAt?: string;
+    dashboardConfig?: ReportDashboardConfig;
+    excelConfig?: ReportExcelConfig;
+    chartLinks?: ReportChartLink[];
+}
+/**
+ * Style configuration for dashboard items
+ */
+interface StyleConfig {
+    'background-color'?: string;
+    color?: string;
+    'justify-content'?: 'start' | 'center' | 'end';
+    'font-size-title'?: number;
+    'font-size-value'?: number;
+    [key: string]: any;
+}
+/**
+ * Display configuration
+ */
+interface DisplayConfig {
+    StyleConfig: StyleConfig;
+    dimensions?: {
+        cols?: number;
+        rows?: number;
+        [key: string]: any;
+    };
+    [key: string]: any;
+}
+/**
+ * Service configuration for chart data
+ */
+interface ServiceConfig {
+    dashboardId: string;
+    chartType?: string;
+    query?: {
+        extraProperties?: any[];
+        properties?: any[];
+        [key: string]: any;
+    };
+    [key: string]: any;
+}
+/**
+ * Action configuration
+ */
+interface ActionConfig {
+    type: string;
+    actionType: string;
+    id?: string;
+    config?: Record<string, any>;
+}
+/**
+ * Client configuration for UI
+ */
+interface ClientConfig {
+    title?: LocalizedName;
+    componentName?: string;
+    functionName?: string;
+    subType?: string;
+    requestType?: string;
+    displayConfig?: DisplayConfig;
+    configAsType?: {
+        icon?: string;
+        breadcrumb?: any[];
+        [key: string]: any;
+    };
+    actions?: ActionConfig[];
+    filter?: {
+        configs?: any[];
+        [key: string]: any;
+    };
+    pieConfigOverried?: any;
+    barConfigOverride?: any;
+    stackBarConfigOverride?: any;
+    [key: string]: any;
+}
+/**
+ * Chart/Item configuration
+ */
+interface ItemConfig {
+    serviceConfig: ServiceConfig;
+    clientConfig: ClientConfig;
+}
+/**
+ * Dashboard chart item extending GridsterItem
+ */
+interface DashboardChartItem extends GridsterItem {
+    /** Link record ID from server */
+    id?: number;
+    /** Chart component GUID from server */
+    chartComponentId?: string;
+    config: ItemConfig;
+    chartTypeId?: string;
+    loading?: boolean;
+    quickManage?: boolean;
+    group?: string;
+    orderInGroup?: number;
+    selectedGroupIndex?: number;
+}
+/**
+ * Dashboard dialog item
+ */
+interface DashboardDialogItem {
+    id?: number;
+    name?: string;
+    config: ItemConfig;
+    chartTypeId?: string;
+    loading?: boolean;
+}
+/**
+ * Dashboard page configuration
+ * Alias for Report with Dashboard type - used for backwards compatibility
+ */
+type DashboardPage = Report;
+/**
+ * Request payload for linking a chart to a report
+ */
+interface LinkChartRequest {
+    reportId: number;
+    chartComponentId?: string;
+    configration: ChartLinkConfiguration;
+}
+/**
+ * Request payload for bulk linking charts to a report
+ */
+interface BulkLinkChartRequest {
+    reportId: number;
+    chartComponentId?: string;
+    configration: ChartLinkConfiguration;
+}
+/**
+ * Response item from bulk link operation
+ */
+interface BulkLinkChartResponse {
+    id: number;
+    chartComponentId: string;
+    configration: string;
+    order: number;
+}
+/**
+ * Request payload for unlinking a chart from a report
+ */
+interface UnlinkChartRequest {
+    reportId: number;
+    chartComponentId: string;
+}
+/**
+ * Chart actions context for pipes
+ */
+interface ChartActionsContext {
+    deleteItem: (item: DashboardChartItem) => void;
+    removeGroup: (item: DashboardChartItem) => void;
+    editItem: (item: DashboardChartItem, parentItem?: DashboardChartItem) => void;
+    addDialogForChart: (item: DashboardChartItem) => void;
+    editOnDialogForChart: (item: DashboardChartItem) => void;
+    deleteDialogFromChart: (item: DashboardChartItem) => void;
+}
+/**
+ * Quick manage item types
+ */
+type QuickManageType = 'default' | 'pie' | 'bar' | 'stackBar' | 'snapshotBar' | null;
+/**
+ * Module type for data sources
+ */
+interface ModuleType {
+    id: string;
+    name: string;
+    version?: string;
+    description?: string;
+}
+/**
+ * Chart data response structure
+ */
+interface ChartData {
+    labels?: string[];
+    values?: number[];
+    data?: any[];
+    rows?: any[];
+    columns?: any[];
+    total?: number;
+    [key: string]: any;
+}
+/**
+ * HTTP methods for custom API
+ */
+declare enum HTTPMethod {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    DELETE = "DELETE",
+    PATCH = "PATCH"
+}
+/**
+ * Custom API configuration
+ */
+interface CustomApi {
+    customApiUrl: string;
+    method: HTTPMethod;
+    headers?: Record<string, string>;
+    params?: Record<string, any>;
+}
+
+/**
+ * Chart Type Configuration
+ */
+interface ChartTypeConfig {
+    id: string;
+    name: string;
+    icon: string;
+    serviceType: string;
+    componentName: string;
+    functionName: string;
+    requestType?: string;
+    category: 'chart' | 'card' | 'table' | 'special' | 'layout';
+    /** Products this chart type is available for (pplus, splus, report) */
+    products?: ('pplus' | 'splus' | 'report')[];
+    hideInList?: boolean;
+    /** Whether this type requires manage-item configuration (false = add directly) */
+    hasManageItem: boolean;
+    /** Default size when added to grid */
+    defaultSize?: {
+        cols: number;
+        rows: number;
+    };
+}
+/**
+ * Module Type from API
+ */
+interface IModuleType {
+    id: string;
+    name: string;
+    version?: string;
+    description?: string;
+}
+/**
+ * Module with properties
+ */
+interface IModule {
+    moduleDisplay: string;
+    moduleId: number | string;
+    moduleName: string;
+    selectionId?: number;
+}
+/**
+ * Property definition from API
+ * Maps to PropertyItem from dashboard.model.ts
+ */
+interface IProperty {
+    id: number;
+    name: string;
+    hasName?: boolean;
+    key: string;
+    hasKey?: boolean;
+    normalizedKey: string;
+    hasNormalizedKey?: boolean;
+    configuration?: string;
+    hasConfiguration?: boolean;
+    viewType: string;
+    hasViewType?: boolean;
+    isTranslatable: boolean;
+    /** @deprecated Use PropertyItem.isCalculated when available */
+    isCalculated?: boolean;
+    /** @deprecated Use sorting on client side */
+    order?: number;
+    description?: string;
+}
+/**
+ * Property with grouping info
+ */
+interface IPropertyWithGroup extends IProperty {
+    groupingBy: string;
+}
+/**
+ * Selection filter
+ */
+interface SelectionFilter {
+    propertyKey: string | null;
+    propertyValue: any;
+    operation: 'Equals' | 'NotEquals' | 'OneOf' | 'Between' | 'Contains' | 'GreaterThan' | 'LessThan' | null;
+    logical: 'And' | 'Or' | null;
+    operationLevel?: number | null;
+    propertyData?: any;
+}
+/**
+ * Selection configuration
+ */
+interface ISelection {
+    id: number;
+    service?: string | null;
+    /** Module selector in format "ModuleType:Id" (e.g., "Level:7") */
+    selector: string | null;
+    /** Display name of the selected module (e.g., "Project" for "Level:7") */
+    selectorName?: string | null;
+    filters: SelectionFilter[];
+}
+/**
+ * Source link configuration for joins
+ */
+interface SourceLink {
+    source1SelectionId: number | null;
+    source2SelectionId: number | null;
+    source1PropertyKey: string | null;
+    source2PropertyKey: string | null;
+    source1Properties?: IProperty[];
+    source2Properties?: IProperty[];
+    isLeftJoin?: boolean;
+    isFilterLinkage?: boolean;
+    sourceLinkId?: number | null;
+}
+/**
+ * Available chart types - matching old groupedCharts implementation
+ */
+declare const CHART_TYPES: ChartTypeConfig[];
+/**
+ * Manage Item Service
+ *
+ * Handles state and operations for the manage-item drawer
+ */
+declare class ManageItemService {
+    private dashboardService;
+    private fb;
+    readonly chart: _angular_core.WritableSignal<DashboardChartItem | null>;
+    readonly selectedType: _angular_core.WritableSignal<ChartTypeConfig | null>;
+    readonly chartTypes: _angular_core.WritableSignal<ChartTypeConfig[]>;
+    readonly moduleTypes: _angular_core.WritableSignal<IModuleType[]>;
+    readonly modulesProperties: _angular_core.WritableSignal<{
+        moduleName: string;
+        moduleDisplay: string;
+        properties: IProperty[];
+    }[]>;
+    readonly propertiesFlat: _angular_core.WritableSignal<IPropertyWithGroup[]>;
+    readonly isEdit: _angular_core.WritableSignal<boolean>;
+    readonly dirty: _angular_core.WritableSignal<boolean>;
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    readonly configSignal: _angular_core.WritableSignal<ItemConfig | null>;
+    readonly chartTypesFiltered: _angular_core.Signal<ChartTypeConfig[]>;
+    readonly chartTypesByCategory: _angular_core.Signal<{
+        card: ChartTypeConfig[];
+        chart: ChartTypeConfig[];
+        table: ChartTypeConfig[];
+        special: ChartTypeConfig[];
+        layout: ChartTypeConfig[];
+    }>;
+    readonly chartForm: _angular_forms.FormGroup<{
+        id: _angular_forms.FormControl<number | null>;
+        name: _angular_forms.FormControl<string | null>;
+        dashboardId: _angular_forms.FormControl<string | null>;
+        chartTypeId: _angular_forms.FormControl<string | null>;
+        configuration: _angular_forms.FormGroup<{
+            clientConfig: _angular_forms.FormControl<ClientConfig | null>;
+            serviceConfig: _angular_forms.FormControl<ServiceConfig | null>;
+        }>;
+    }>;
+    /**
+     * Reset all state
+     */
+    resetState(): void;
+    /**
+     * Initialize with existing chart (edit mode) or empty (new mode)
+     */
+    init(chartData?: DashboardChartItem): void;
+    /**
+     * Set chart data for editing
+     */
+    setChart(chartData: DashboardChartItem): void;
+    /**
+     * Select a chart type
+     */
+    selectType(type: ChartTypeConfig): void;
+    /**
+     * Mark form as dirty
+     */
+    markDirty(): void;
+    /**
+     * Get configuration value (returns signal value for reactivity)
+     */
+    getConfig(): ItemConfig | null;
+    /**
+     * Update service config
+     */
+    updateServiceConfig(partial: Partial<ServiceConfig>): void;
+    /**
+     * Update client config
+     */
+    updateClientConfig(partial: Partial<ClientConfig>): void;
+    /**
+     * Load module types from API
+     */
+    loadModuleTypes(): void;
+    /**
+     * Load properties for selected modules
+     */
+    loadPropertiesForModules(modules: {
+        moduleType: string;
+        moduleDisplay?: string;
+    }[]): void;
+    /**
+     * Get final chart data for saving
+     */
+    getFinalChartData(): {
+        configuration: ItemConfig;
+        chartTypeId: string;
+    } | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ManageItemService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ManageItemService>;
+}
+
+/**
+ * Dashboard Builder Component
+ *
+ * Main component for building and managing dashboard layouts.
+ * Features:
+ * - Gridster-based drag & drop layout
+ * - Chart management (add, edit, delete)
+ * - Group support
+ * - Multi-select and copy/paste
+ * - Chart settings drawer (pie, bar, stack bar controls)
+ */
+declare class DashboardBuilder implements OnInit, OnDestroy {
+    private cdr;
+    private dashboardService;
+    private storeService;
+    private transloco;
+    private modalService;
+    /** Whether to wrap content in mt-page component */
+    readonly isPage: _angular_core.InputSignal<boolean>;
+    /** Page title when isPage is true */
+    readonly pageTitle: _angular_core.InputSignal<string>;
+    /** Show back button in page header */
+    readonly backButton: _angular_core.InputSignal<boolean>;
+    /** Dashboard/Page ID to load */
+    readonly pageId: _angular_core.InputSignal<string | number | null>;
+    /** Read-only mode */
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    /** Emit when page config changes */
+    readonly pageChange: _angular_core.OutputEmitterRef<_masterteam_dashboard_builder.Report>;
+    /** Emit when charts change */
+    readonly chartsChange: _angular_core.OutputEmitterRef<DashboardChartItem[]>;
+    /** Emit when save is complete */
+    readonly onSave: _angular_core.OutputEmitterRef<void>;
+    /** Emit when back button is clicked */
+    readonly onBack: _angular_core.OutputEmitterRef<void>;
+    /** Emit when requesting to add new chart (opens external chart editor) */
+    readonly onAddChart: _angular_core.OutputEmitterRef<{
+        x: number;
+        y: number;
+    }>;
+    /** Emit when requesting to edit chart */
+    readonly onEditChart: _angular_core.OutputEmitterRef<{
+        chart: DashboardChartItem;
+        isDialog?: boolean;
+    }>;
+    readonly contextMenu: _angular_core.Signal<ContextMenu | undefined>;
+    readonly gridsterContainer: _angular_core.Signal<any>;
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    readonly saving: _angular_core.WritableSignal<boolean>;
+    readonly pageConfig: _angular_core.WritableSignal<_masterteam_dashboard_builder.Report | null>;
+    readonly charts: _angular_core.WritableSignal<DashboardChartItem[]>;
+    readonly dialogs: _angular_core.WritableSignal<DashboardDialogItem[]>;
+    readonly filtersConfig: _angular_core.WritableSignal<any[]>;
+    readonly selectedCharts: _angular_core.WritableSignal<string[]>;
+    readonly contextPos: _angular_core.WritableSignal<{
+        x: number;
+        y: number;
+    }>;
+    readonly stopActionsOnCards: _angular_core.WritableSignal<boolean>;
+    readonly pendingWidgetType: _angular_core.WritableSignal<ChartTypeConfig | null>;
+    /** Reference to widget palette drawer */
+    private widgetPaletteRef;
+    /** Reference to chart settings drawer */
+    private chartSettingsRef;
+    readonly languageCode: _angular_core.Signal<string>;
+    readonly direction: _angular_core.Signal<"rtl" | "ltr">;
+    readonly chartActionsContext: ChartActionsContext;
+    readonly options: GridsterConfig;
+    private subscription;
+    private isDragging;
+    private scrollInterval;
+    private dragStartY;
+    readonly menuItems: _angular_core.Signal<MenuItem[]>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private setupEventListeners;
+    private removeEventListeners;
+    private loadPageIfNeeded;
+    loadPage(id: string | number): void;
+    saveDash(): void;
+    addOrEditPage(page?: DashboardPage): void;
+    deleteReport(): void;
+    onItemResize(item: GridsterItem, itemComponent: any): void;
+    onItemChange(item: GridsterItem, _itemComponent: any): void;
+    onContextMenu(event: MouseEvent, item: GridsterItem): void;
+    /** Handle dragover on gridster - must call preventDefault to allow drop */
+    onGridDragOver(event: DragEvent): void;
+    /** Handle drop on gridster - just prevent default, actual handling in onDrop */
+    onGridDrop(event: DragEvent): void;
+    /** Handle drop on empty cell from widget palette */
+    onDrop(event: DragEvent, item: GridsterItem): void;
+    onKeyDown(event: KeyboardEvent): void;
+    onSelect(chart: DashboardChartItem, event: MouseEvent): void;
+    pasteSelectedCharts(): void;
+    private pasteItemInChart;
+    addItem(): void;
+    editItem(chart: DashboardChartItem, parentItem?: DashboardChartItem): void;
+    deleteItem(chart: DashboardChartItem): void;
+    private removeChartLocally;
+    newChart(value: any): void;
+    editChart(value: any): void;
+    createGroup(): void;
+    removeGroup(groupItem: DashboardChartItem): void;
+    addHeader(): void;
+    addTopbar(): void;
+    /** Open widget palette drawer */
+    toggleWidgetPalette(): void;
+    /** Close widget palette drawer */
+    closeWidgetPalette(): void;
+    /** Add widget based on type configuration */
+    addWidgetByType(widgetType: ChartTypeConfig): void;
+    /** Add layout widget directly (header, topbar, group) */
+    private addLayoutWidget;
+    /** Open manage-item drawer for a specific widget type */
+    private openManageItemForType;
+    /** Create new chart with specified size */
+    private newChartWithSize;
+    openBreadcrumb(item: DashboardChartItem): void;
+    openManageFilter(): void;
+    addDialogForChart(chart: DashboardChartItem): void;
+    editOnDialogForChart(chart: DashboardChartItem): void;
+    deleteDialogFromChart(chart: DashboardChartItem): void;
+    /** Open chart settings drawer for item configuration */
+    openQuickManage(event: Event, item: DashboardChartItem): void;
+    /** Handle apply from chart settings drawer */
+    onQuickManageApply(updatedItem: DashboardChartItem): void;
+    stopAndActiveActions(): void;
+    reRenderItem(item: DashboardChartItem): void;
+    isSelected(chart: DashboardChartItem): boolean;
+    showQuickManageButton(chart: DashboardChartItem): boolean;
+    private handleDragOver;
+    private handleDrop;
+    private handleDragEnd;
+    private startAutoScroll;
+    private stopAutoScroll;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DashboardBuilder, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DashboardBuilder, "mt-dashboard-builder", never, { "isPage": { "alias": "isPage"; "required": false; "isSignal": true; }; "pageTitle": { "alias": "pageTitle"; "required": false; "isSignal": true; }; "backButton": { "alias": "backButton"; "required": false; "isSignal": true; }; "pageId": { "alias": "pageId"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, { "pageChange": "pageChange"; "chartsChange": "chartsChange"; "onSave": "onSave"; "onBack": "onBack"; "onAddChart": "onAddChart"; "onEditChart": "onEditChart"; }, never, never, true, never>;
+}
+
+/**
+ * Dashboard Viewer Component
+ *
+ * A read-only component for viewing and displaying dashboard layouts.
+ * Similar to pageBuilder-gridster but without editing capabilities.
+ *
+ * Features:
+ * - Gridster-based layout display (read-only)
+ * - Chart/widget rendering
+ * - Group support with tab switching
+ * - Filter sidebar integration
+ * - Dialog rendering
+ */
+declare class DashboardViewer implements OnInit, OnDestroy {
+    private cdr;
+    private dashboardService;
+    private storeService;
+    /** Whether to wrap content in mt-page component */
+    readonly isPage: _angular_core.InputSignal<boolean>;
+    /** Page title when isPage is true */
+    readonly pageTitle: _angular_core.InputSignal<string>;
+    /** Show back button in page header */
+    readonly backButton: _angular_core.InputSignal<boolean>;
+    /** Dashboard/Page ID to load */
+    readonly pageId: _angular_core.InputSignal<string | number | null>;
+    /** Pre-loaded charts (optional - if provided, skips API call) */
+    readonly chartsData: _angular_core.InputSignal<DashboardChartItem[]>;
+    /** Pre-loaded dialogs (optional) */
+    readonly dialogsData: _angular_core.InputSignal<DashboardDialogItem[]>;
+    /** Pre-loaded filters (optional) */
+    readonly filtersData: _angular_core.InputSignal<any[]>;
+    /** Show filters sidebar */
+    readonly showFilters: _angular_core.InputSignal<boolean>;
+    /** Emit when page is loaded */
+    readonly pageLoaded: _angular_core.OutputEmitterRef<_masterteam_dashboard_builder.Report>;
+    /** Emit when back button is clicked */
+    readonly onBack: _angular_core.OutputEmitterRef<void>;
+    /** Emit when chart is clicked (for drill-down, etc.) */
+    readonly chartClick: _angular_core.OutputEmitterRef<{
+        chart: DashboardChartItem;
+        event: Event;
+    }>;
+    readonly gridsterContainer: _angular_core.Signal<any>;
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    readonly pageConfig: _angular_core.WritableSignal<_masterteam_dashboard_builder.Report | null>;
+    readonly charts: _angular_core.WritableSignal<DashboardChartItem[]>;
+    readonly dialogs: _angular_core.WritableSignal<DashboardDialogItem[]>;
+    readonly filters: _angular_core.WritableSignal<any[]>;
+    readonly languageCode: _angular_core.Signal<string>;
+    readonly direction: _angular_core.Signal<"rtl" | "ltr">;
+    readonly options: GridsterConfig;
+    private subscription;
+    private chartsDataEffect;
+    private dialogsDataEffect;
+    private filtersDataEffect;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private setupSubscriptions;
+    private loadPageIfNeeded;
+    loadPage(id: string | number): void;
+    reloadPage(): void;
+    /**
+     * Get the title for a group item
+     */
+    getGroupTitle(item: DashboardChartItem): string;
+    /**
+     * Get children of a group
+     */
+    getGroupChildren(item: DashboardChartItem): DashboardChartItem[];
+    /**
+     * Select a child in a group
+     */
+    selectGroupChild(item: DashboardChartItem, index: number): void;
+    /**
+     * Check if item is a group
+     */
+    isGroup(item: DashboardChartItem): boolean;
+    /**
+     * Check if item is a header
+     */
+    isHeader(item: DashboardChartItem): boolean;
+    /**
+     * Check if item is a topbar
+     */
+    isTopbar(item: DashboardChartItem): boolean;
+    /**
+     * Check if item should be shown (not grouped or is a group itself)
+     */
+    shouldShowItem(item: DashboardChartItem): boolean;
+    /**
+     * Get item title
+     */
+    getItemTitle(item: DashboardChartItem): string;
+    /**
+     * Get style config
+     */
+    getStyleConfig(item: DashboardChartItem): Record<string, any>;
+    /**
+     * Get icon from configAsType
+     */
+    getItemIcon(item: DashboardChartItem): string | null;
+    /**
+     * Get breadcrumb items for topbar
+     */
+    getBreadcrumb(item: DashboardChartItem): any[];
+    /**
+     * Get chart type
+     */
+    getChartType(item: DashboardChartItem): string;
+    /**
+     * Handle chart click
+     */
+    onChartClick(chart: DashboardChartItem, event: Event): void;
+    /**
+     * Track function for ngFor
+     */
+    trackByDashboardId(_index: number, item: DashboardChartItem): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DashboardViewer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DashboardViewer, "mt-dashboard-viewer", never, { "isPage": { "alias": "isPage"; "required": false; "isSignal": true; }; "pageTitle": { "alias": "pageTitle"; "required": false; "isSignal": true; }; "backButton": { "alias": "backButton"; "required": false; "isSignal": true; }; "pageId": { "alias": "pageId"; "required": false; "isSignal": true; }; "chartsData": { "alias": "chartsData"; "required": false; "isSignal": true; }; "dialogsData": { "alias": "dialogsData"; "required": false; "isSignal": true; }; "filtersData": { "alias": "filtersData"; "required": false; "isSignal": true; }; "showFilters": { "alias": "showFilters"; "required": false; "isSignal": true; }; }, { "pageLoaded": "pageLoaded"; "onBack": "onBack"; "chartClick": "chartClick"; }, never, never, true, never>;
+}
+
+/**
+ * Chart Models
+ *
+ * Type definitions for chart data, configuration, and responses.
+ */
+
+/**
+ * Store interface for each dashboard item
+ */
+interface DashboardItemStore {
+    /** Initial configuration (immutable) */
+    initConfigurationItem?: ItemConfig;
+    /** Current configuration (may be modified) */
+    ConfigurationItem?: ItemConfig;
+    /** Raw data response from API */
+    DataResponse?: any;
+    /** Processed/transformed data for rendering */
+    DataHandled?: ChartDataHandled;
+    /** Flag to trigger data fetch */
+    GetData?: boolean;
+    /** Action being handled */
+    handleAction?: HandleAction;
+    /** Filter activation state */
+    filterActivated?: any;
+    /** Loading state for the item */
+    isLoading?: boolean;
+    /** Error state for the item */
+    error?: string | null;
+    /** Whether the item has an error */
+    hasError?: boolean;
+    /** Extra filter from parent context */
+    extraFilter?: Record<string, any>;
+    /** Stop actions flag */
+    stopActions?: boolean;
+    /** Query params for current context */
+    queryParams?: Record<string, any>;
+    /** Pre-query params to merge */
+    preQueryParams?: Record<string, any>;
+    /** Dialog visibility state */
+    showDialog?: boolean;
+    /** Dialog configuration */
+    dialogConfig?: any;
+    /** Dialog data */
+    dialogData?: any;
+}
+/**
+ * Action types for dashboard items
+ */
+interface HandleAction {
+    id: number | string;
+    type: 'openDialog' | 'closeDialog' | 'navigate' | 'filter' | 'refresh';
+    data: any;
+}
+/**
+ * Processed chart data structure
+ */
+interface ChartDataHandled {
+    /** ECharts options (for chart types) */
+    chartOptions?: any;
+    /** No data flag */
+    noData?: boolean;
+    /** Table columns */
+    columns?: TableColumn$1[];
+    /** Table data rows */
+    rows?: any[];
+    /** Statistic cards data */
+    cards?: StatisticCardData[];
+    /** Calendar/timeline options */
+    calendarOptions?: any;
+    /** Labels for display */
+    labels?: ChartLabel[];
+    /** Raw values */
+    values?: any[];
+    /** Any additional data */
+    [key: string]: any;
+}
+/**
+ * Table column definition
+ */
+interface TableColumn$1 {
+    /** Column key (field name) */
+    key: string;
+    /** Display label */
+    label: string;
+    /** Alias for key */
+    field?: string;
+    /** Alias for label */
+    header?: string;
+    headerAr?: string;
+    sortable?: boolean;
+    filterable?: boolean;
+    width?: string;
+    align?: 'left' | 'center' | 'right';
+    type?: 'text' | 'number' | 'date' | 'status' | 'currency' | 'percentage';
+    format?: string;
+    hidden?: boolean;
+}
+/**
+ * Statistic card data
+ */
+interface StatisticCardData {
+    id?: string | number;
+    title: {
+        en?: string;
+        ar?: string;
+    } | string;
+    value: number | string;
+    icon?: string;
+    color?: string;
+    trend?: {
+        direction: 'up' | 'down' | 'neutral';
+        value: number;
+        label?: string;
+    };
+    suffix?: string;
+    prefix?: string;
+    description?: string;
+    actions?: any[];
+    /** Subtitle text */
+    subTitle?: {
+        en?: string;
+        ar?: string;
+    } | string;
+    /** Card width */
+    width?: string;
+    /** Whether the card is clickable */
+    isClickable?: boolean;
+}
+/**
+ * Chart label for legends
+ */
+interface ChartLabel {
+    key: string;
+    label: string;
+    color?: string;
+    icon?: string;
+}
+/**
+ * Request types for data fetching
+ */
+type RequestType = 'level' | 'levellog' | 'log' | 'custom' | 'snapShot' | 'levelCards' | 'timelineProjectDependencies' | 'customSplus' | 'phaseGate';
+/**
+ * Chart type to component mapping
+ */
+type ComponentType = 'chart' | 'map' | 'BackgroundTextChart' | 'chartCustomWithCardInfo' | 'listOfcharts' | 'listOfCardsStatistic' | 'cardsStatistic' | 'header' | 'footer' | 'label' | 'listOfLevelCards' | 'dialog' | 'table' | 'phaseGateTable' | 'topbar' | 'timeline' | 'timelineProjectDependencies' | 'lastHistoryLevelCard' | 'entityPreview' | 'clusterStackedChart' | 'listComponentSplusCard' | 'splitterChart' | 'repeater' | 'levelCardsWithStatic' | 'phaseGateStepperCard' | 'Group';
+/**
+ * EChart series data item
+ */
+interface EChartSeriesItem {
+    value: number;
+    name: string;
+    key?: string;
+    itemStyle?: {
+        color?: string;
+        borderColor?: string;
+        borderWidth?: number;
+    };
+    extraValues?: Record<string, any>;
+    groupValues?: Record<string, any>;
+}
+/**
+ * Bar chart data structure
+ */
+interface BarChartData {
+    noData: boolean;
+    chartOptions: {
+        xAxis: any;
+        yAxis: any;
+        series: any[];
+        tooltip?: any;
+        legend?: any;
+        grid?: any;
+        dataZoom?: any[];
+    };
+}
+/**
+ * Pie/Donut chart data structure
+ */
+interface PieChartData {
+    noData: boolean;
+    chartOptions: {
+        series: any[];
+        tooltip?: any;
+        legend?: any;
+    };
+}
+/**
+ * Table view data structure
+ */
+interface TableViewData {
+    columns: TableColumn$1[];
+    rows: any[];
+    data?: any[];
+    total?: number;
+    totalRecords?: number;
+    groupBy?: string;
+    isGrouped?: boolean;
+}
+/**
+ * Timeline/Gantt data item
+ */
+interface TimelineItem {
+    id?: string | number;
+    title: string;
+    startDate: string | Date;
+    endDate: string | Date;
+    color?: string;
+    type?: string;
+    progress?: number;
+    dependencies?: string[];
+    extraValues?: Record<string, any>;
+}
+/**
+ * Timeline/Gantt data structure
+ */
+interface TimelineData {
+    items: TimelineItem[];
+    calendarOptions?: any;
+    labels?: ChartLabel[];
+    events?: any[];
+    startDate?: string | Date;
+    endDate?: string | Date;
+}
+/**
+ * Breadcrumb item for topbar
+ */
+interface BreadcrumbItem {
+    label: {
+        en?: string;
+        ar?: string;
+    } | string;
+    routerLink?: string;
+    icon?: string;
+    queryParams?: Record<string, any>;
+}
+/**
+ * Filter configuration
+ */
+interface FilterConfig {
+    show: boolean;
+    propertyKey?: string;
+    options?: FilterOption[];
+    defaultValue?: any;
+    type?: 'select' | 'multiselect' | 'multiSelect' | 'date' | 'daterange' | 'text';
+    placeholder?: Record<string, string>;
+}
+/**
+ * Filter option
+ */
+interface FilterOption {
+    label: string;
+    value: any;
+    icon?: string;
+    color?: string;
+}
+/**
+ * Action click event
+ */
+interface ChartActionEvent {
+    type: 'click' | 'dblclick' | 'hover' | 'clickOnHeader';
+    data?: any;
+    event?: Event;
+    dataIndex?: number;
+    seriesIndex?: number;
+    name?: string;
+    value?: any;
+}
+
+declare class DashboardItem implements OnInit, OnDestroy {
+    private readonly storeService;
+    private readonly itemStoreService;
+    private readonly chartDataService;
+    private readonly actionService;
+    private readonly transloco;
+    private subscription;
+    private readonly destroy$;
+    /** Chart configuration */
+    readonly config: _angular_core.InputSignal<ItemConfig | null>;
+    /** Chart type identifier */
+    readonly chartTypeId: _angular_core.InputSignal<string | number | undefined>;
+    /** Read-only mode */
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    /** Whether this item is inside a group */
+    readonly inGroup: _angular_core.InputSignal<boolean>;
+    /** Whether this item is rendered inside a dialog */
+    readonly isDialog: _angular_core.InputSignal<boolean>;
+    /** Query params passed from parent (e.g., dialog) */
+    readonly queryParams: _angular_core.InputSignal<Record<string, any>>;
+    /** Emitted when an action is triggered (useful for dialog communication) */
+    readonly actionTriggered: _angular_core.OutputEmitterRef<any>;
+    /** Dashboard ID - derived from config or chartTypeId */
+    readonly dashboardId: _angular_core.Signal<string | null>;
+    /** Component name */
+    readonly componentName: _angular_core.Signal<ComponentType>;
+    /** Request type */
+    readonly requestType: _angular_core.Signal<RequestType | undefined>;
+    /** Function name for data handling */
+    readonly functionName: _angular_core.Signal<string | undefined>;
+    /** Custom API configuration */
+    readonly customApi: _angular_core.Signal<CustomApi | undefined>;
+    /** Language code for title display */
+    readonly languageCode: _angular_core.Signal<string>;
+    /** Chart type from service config */
+    readonly chartType: _angular_core.Signal<string | undefined>;
+    /** Loading state - SINGLE SOURCE OF TRUTH */
+    readonly isLoading: _angular_core.WritableSignal<boolean>;
+    /** Has error */
+    readonly hasError: _angular_core.WritableSignal<boolean>;
+    /** Error message */
+    readonly errorMessage: _angular_core.WritableSignal<string | null>;
+    /** Configuration from store */
+    readonly configurationItem: _angular_core.WritableSignal<ItemConfig | null>;
+    /** Statistic data for cardsStatistic type */
+    readonly statisticData: _angular_core.WritableSignal<any>;
+    /** Track if component has been initialized */
+    private initialized;
+    /** Track current dashboardId to detect changes */
+    private currentDashboardId;
+    constructor();
+    ngOnInit(): void;
+    /**
+     * Setup subscriptions and fetch data for a specific dashboardId
+     */
+    private setupForDashboardId;
+    ngOnDestroy(): void;
+    /**
+     * Initialize store with configuration
+     */
+    private initializeStore;
+    /**
+     * Main getData method - delegates to ChartDataService for all request types
+     */
+    getData(): void;
+    /**
+     * Refresh data
+     */
+    refresh(): void;
+    /**
+     * Trigger data fetch via store
+     */
+    triggerDataFetch(): void;
+    /**
+     * Handle actions from child components (charts, tables, etc.)
+     * This is the main entry point for action handling.
+     */
+    doActions(eventData: any, eventType: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DashboardItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DashboardItem, "mt-dashboard-item", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "chartTypeId": { "alias": "chartTypeId"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "inGroup": { "alias": "inGroup"; "required": false; "isSignal": true; }; "isDialog": { "alias": "isDialog"; "required": false; "isSignal": true; }; "queryParams": { "alias": "queryParams"; "required": false; "isSignal": true; }; }, { "actionTriggered": "actionTriggered"; }, never, never, true, never>;
+}
+
+interface HeaderCardConfig$1 {
+    showHeader?: boolean;
+    isHeaderHidden?: boolean;
+    headerClickable?: boolean;
+    icon?: string;
+    iconColor?: string;
+    titleColor?: string;
+}
+interface CardBorderStyleConfig {
+    'border-width'?: number;
+    'border-top-show'?: boolean;
+    'border-top-color'?: string;
+    'border-right-show'?: boolean;
+    'border-right-color'?: string;
+    'border-bottom-show'?: boolean;
+    'border-bottom-color'?: string;
+    'border-left-show'?: boolean;
+    'border-left-color'?: string;
+    'background-color'?: string;
+    'box-shadow'?: string;
+    'border-radius'?: number;
+}
+interface CardStyleConfig$1 {
+    backgroundColor?: string;
+    borderRadius?: number;
+    shadows?: Array<{
+        x: number;
+        y: number;
+        blur: number;
+        spread: number;
+        color: string;
+    }>;
+}
+declare class CardContentComponent {
+    /** Card title */
+    readonly title: _angular_core.InputSignal<string>;
+    /** Whether card is inside a group */
+    readonly inGroup: _angular_core.InputSignal<boolean>;
+    /** Header configuration */
+    readonly headerConfig: _angular_core.InputSignal<HeaderCardConfig$1 | null>;
+    /** Style configuration (border styling) */
+    readonly styleConfig: _angular_core.InputSignal<CardBorderStyleConfig | null>;
+    /** Card style configuration (background, shadows, border radius) */
+    readonly cardStyleConfig: _angular_core.InputSignal<CardStyleConfig$1 | null>;
+    /** Whether to show header */
+    readonly showHeaderInput: _angular_core.InputSignal<boolean>;
+    /** Whether header is clickable */
+    readonly headerClickableInput: _angular_core.InputSignal<boolean>;
+    /** No top end content flag */
+    readonly isNoTopEnd: _angular_core.InputSignal<boolean>;
+    /** Whether this card contains a chart (disables horizontal scroll) */
+    readonly isChart: _angular_core.InputSignal<boolean>;
+    /** Header click event */
+    readonly headerClick: _angular_core.OutputEmitterRef<void>;
+    /** Computed show header */
+    readonly showHeader: _angular_core.Signal<boolean>;
+    /** Computed header clickable */
+    readonly headerClickable: _angular_core.Signal<boolean>;
+    /** Computed card styles from StyleConfig and cardStyleConfig */
+    readonly cardStyles: _angular_core.Signal<Record<string, string>>;
+    /** Computed border radius style */
+    readonly borderRadiusStyle: _angular_core.Signal<string>;
+    onHeaderClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardContentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CardContentComponent, "db-card-content", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "inGroup": { "alias": "inGroup"; "required": false; "isSignal": true; }; "headerConfig": { "alias": "headerConfig"; "required": false; "isSignal": true; }; "styleConfig": { "alias": "styleConfig"; "required": false; "isSignal": true; }; "cardStyleConfig": { "alias": "cardStyleConfig"; "required": false; "isSignal": true; }; "showHeaderInput": { "alias": "showHeader"; "required": false; "isSignal": true; }; "headerClickableInput": { "alias": "headerClickable"; "required": false; "isSignal": true; }; "isNoTopEnd": { "alias": "isNoTopEnd"; "required": false; "isSignal": true; }; "isChart": { "alias": "isChart"; "required": false; "isSignal": true; }; }, { "headerClick": "headerClick"; }, never, ["[topEnd]", "[body]", "[footer]"], true, never>;
+}
+
+declare class CardFilterComponent implements OnInit {
+    private readonly storeService;
+    private readonly transloco;
+    /** Filter configuration */
+    readonly config: _angular_core.InputSignal<FilterConfig | null>;
+    /** Dashboard ID */
+    readonly dashboardId: _angular_core.InputSignal<string | number | undefined>;
+    /** Filter change event */
+    readonly filterChange: _angular_core.OutputEmitterRef<any>;
+    /** Selected value (single select) */
+    selectedValue: any;
+    /** Selected values (multi select) */
+    selectedValues: any[];
+    /** Date range */
+    startDate: string;
+    endDate: string;
+    /** Language code */
+    readonly langCode: _angular_core.Signal<string>;
+    /** Filter type */
+    readonly filterType: _angular_core.Signal<"date" | "text" | "select" | "multiselect" | "multiSelect" | "daterange">;
+    /** Filter options */
+    readonly options: _angular_core.Signal<FilterOption[]>;
+    /** Placeholder text */
+    readonly placeholder: _angular_core.Signal<string>;
+    ngOnInit(): void;
+    onFilterChange(value: any): void;
+    onMultiFilterChange(values: any[]): void;
+    onDateChange(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardFilterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CardFilterComponent, "db-card-filter", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "dashboardId": { "alias": "dashboardId"; "required": false; "isSignal": true; }; }, { "filterChange": "filterChange"; }, never, never, true, never>;
+}
+
+declare class ChartCardComponent implements OnInit, OnDestroy {
+    private readonly storeService;
+    private readonly actionService;
+    private readonly transloco;
+    private readonly subscription;
+    /** Dashboard ID for this card */
+    readonly dashboardId: _angular_core.InputSignal<string | number>;
+    /** Whether card is inside a group */
+    readonly inGroup: _angular_core.InputSignal<boolean>;
+    /** Config mode flag */
+    readonly isConfigMode: _angular_core.InputSignal<boolean>;
+    /** Action event output */
+    readonly onAction: _angular_core.OutputEmitterRef<{
+        type: string;
+        data: any;
+    }>;
+    /** Configuration item */
+    readonly configurationItem: _angular_core.WritableSignal<ItemConfig | null>;
+    /** Handled chart data */
+    readonly dataHandled: _angular_core.WritableSignal<ChartDataHandled | null>;
+    /** Card title */
+    readonly title: _angular_core.Signal<string>;
+    /** Show filter flag */
+    readonly showFilter: _angular_core.Signal<any>;
+    /** Show top end section (filter or extra filters) */
+    readonly showTopEnd: _angular_core.Signal<any>;
+    /** Filter configuration */
+    readonly filterConfig: _angular_core.Signal<{
+        [key: string]: any;
+        configs?: any[];
+    } | undefined>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onChartClick(event: any): void;
+    onHeaderClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChartCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChartCardComponent, "db-chart-card", never, { "dashboardId": { "alias": "dashboardId"; "required": true; "isSignal": true; }; "inGroup": { "alias": "inGroup"; "required": false; "isSignal": true; }; "isConfigMode": { "alias": "isConfigMode"; "required": false; "isSignal": true; }; }, { "onAction": "onAction"; }, never, never, true, never>;
+}
+
+type EChartsType = any;
+declare class EChartComponent implements OnInit, AfterViewInit, OnChanges, OnDestroy {
+    private readonly elementRef;
+    private readonly ngZone;
+    private readonly platformId;
+    private chart;
+    private resizeObserver;
+    private echarts;
+    /** Dashboard ID */
+    readonly dashboardId: _angular_core.InputSignal<string | number>;
+    /** Chart configuration/data - can be ECharts option directly or wrapped format */
+    readonly chartConfig: _angular_core.InputSignal<any>;
+    /** Item configuration */
+    readonly configurationItem: _angular_core.InputSignal<ItemConfig | null>;
+    /** Chart height */
+    readonly height: _angular_core.InputSignal<string>;
+    /** Whether this chart is in a group */
+    readonly inGroup: _angular_core.InputSignal<boolean>;
+    /** Whether header is hidden */
+    readonly headerHidden: _angular_core.InputSignal<boolean>;
+    /** Chart click event */
+    readonly chartClick: _angular_core.OutputEmitterRef<{
+        data: any;
+        event: any;
+    }>;
+    /** Chart ready flag */
+    readonly isReady: _angular_core.WritableSignal<boolean>;
+    /** Legend items for custom legend */
+    readonly legendItems: _angular_core.WritableSignal<{
+        name: string;
+        color: string;
+        disabled: boolean;
+    }[]>;
+    /** Language code */
+    readonly languageCode: _angular_core.WritableSignal<string>;
+    /**
+     * Extract ECharts options from chartConfig
+     * Handles both direct format and wrapped format for backwards compatibility
+     */
+    readonly chartOptions: _angular_core.Signal<any>;
+    /** Chart width from config */
+    readonly chartWidth: _angular_core.Signal<any>;
+    /** Has scroll class */
+    readonly hasScrollClass: _angular_core.Signal<boolean>;
+    /** Container class */
+    readonly containerClass: _angular_core.Signal<"scroll-wrapper" | "chart-wrapper">;
+    /** Chart class */
+    readonly chartClass: _angular_core.Signal<"chart" | "chart-scroll">;
+    /** Show custom legend */
+    readonly showCustomLegend: _angular_core.Signal<any>;
+    constructor();
+    ngOnInit(): Promise<void>;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    /**
+     * Process legends for custom legend display
+     */
+    private processLegends;
+    /**
+     * Toggle legend item visibility
+     */
+    toggleLegendItem(item: {
+        name: string;
+        disabled: boolean;
+    }): void;
+    /**
+     * Dynamically load ECharts
+     */
+    private loadECharts;
+    /**
+     * Initialize chart
+     */
+    private initChart;
+    /**
+     * Update chart with new options
+     */
+    private updateChart;
+    /**
+     * Setup resize observer
+     */
+    private setupResizeObserver;
+    /**
+     * Resize chart
+     */
+    resize(): void;
+    /**
+     * Destroy chart
+     */
+    private destroyChart;
+    /**
+     * Destroy resize observer
+     */
+    private destroyResizeObserver;
+    /**
+     * Get chart instance
+     */
+    getChartInstance(): EChartsType | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EChartComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EChartComponent, "db-echart", never, { "dashboardId": { "alias": "dashboardId"; "required": false; "isSignal": true; }; "chartConfig": { "alias": "chartConfig"; "required": false; "isSignal": true; }; "configurationItem": { "alias": "configurationItem"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "inGroup": { "alias": "inGroup"; "required": false; "isSignal": true; }; "headerHidden": { "alias": "headerHidden"; "required": false; "isSignal": true; }; }, { "chartClick": "chartClick"; }, never, never, true, never>;
+}
+
+interface EntityData {
+    key?: string;
+    normalizedKey?: string;
+    label?: string;
+    value?: any;
+    viewType?: string;
+    settings?: any;
+    showInfoUser?: boolean;
+    displayAreas?: any[];
+}
+declare class EntityInfoComponent {
+    /** Entity data to display */
+    readonly data: _angular_core.InputSignal<EntityData | null>;
+    /** Display type: 'entity' shows label, 'inTable' shows value only */
+    readonly displayType: _angular_core.InputSignal<"entity" | "inTable">;
+    /** Extra configuration */
+    readonly extraInfoData: _angular_core.InputSignal<any>;
+    /** Whether to limit words with ellipsis */
+    readonly limitWords: _angular_core.InputSignal<boolean>;
+    /** Custom CSS class */
+    readonly customClass: _angular_core.InputSignal<string>;
+    /** Computed viewType in lowercase */
+    readonly viewTypeLower: _angular_core.Signal<string>;
+    readonly textValue: _angular_core.Signal<any>;
+    readonly numericValue: _angular_core.Signal<number | null>;
+    readonly dateDisplayValue: _angular_core.Signal<any>;
+    readonly currencyDisplayValue: _angular_core.Signal<any>;
+    readonly timeDisplayValue: _angular_core.Signal<any>;
+    readonly lookupName: _angular_core.Signal<any>;
+    readonly lookupColor: _angular_core.Signal<any>;
+    readonly checkboxValue: _angular_core.Signal<boolean>;
+    readonly statusName: _angular_core.Signal<any>;
+    readonly statusColor: _angular_core.Signal<any>;
+    readonly percentageValue: _angular_core.Signal<number | null>;
+    readonly percentageColor: _angular_core.Signal<any>;
+    readonly sliderValue: _angular_core.Signal<number>;
+    readonly userData: _angular_core.Signal<any>;
+    readonly userName: _angular_core.Signal<any>;
+    readonly userInitials: _angular_core.Signal<string>;
+    readonly multiselectValues: _angular_core.Signal<any[]>;
+    readonly multiUserValues: _angular_core.Signal<any[]>;
+    readonly dynamicListValues: _angular_core.Signal<any[]>;
+    readonly locationDisplayValue: _angular_core.Signal<any>;
+    /** Get initials from name */
+    getInitials(name: string): string;
+    /** Format currency value */
+    private formatCurrency;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EntityInfoComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EntityInfoComponent, "mt-entity-info", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "displayType": { "alias": "displayType"; "required": false; "isSignal": true; }; "extraInfoData": { "alias": "extraInfoData"; "required": false; "isSignal": true; }; "limitWords": { "alias": "limitWords"; "required": false; "isSignal": true; }; "customClass": { "alias": "customClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface PropertyItem {
+    key: string;
+    normalizedKey?: string;
+    label?: string;
+    value: any;
+    viewType?: string;
+    settings?: any;
+}
+interface PropertyConfig {
+    width?: string;
+    border?: string[];
+    hidden?: boolean;
+    colorAsProperty?: string;
+}
+interface ProcessedProperty {
+    propInfo: PropertyItem;
+    config: PropertyConfig;
+}
+declare class EntityPreviewCardComponent implements OnInit, OnDestroy {
+    private readonly storeService;
+    private readonly transloco;
+    private readonly subscription;
+    /** Dashboard ID for this card */
+    readonly dashboardId: _angular_core.InputSignal<string | number>;
+    /** Configuration item from store */
+    readonly configurationItem: _angular_core.WritableSignal<ItemConfig | null>;
+    /** Processed properties to display */
+    readonly props: _angular_core.WritableSignal<ProcessedProperty[]>;
+    /** Card title */
+    readonly title: _angular_core.Signal<string>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Subscribe to store updates for this dashboard ID
+     */
+    private subscribeToStore;
+    /**
+     * Get current language code
+     */
+    private getLanguageCode;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EntityPreviewCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EntityPreviewCardComponent, "mt-entity-preview-card", never, { "dashboardId": { "alias": "dashboardId"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface StatusItem {
+    label: string;
+    color: string;
+    shape?: 'circle' | 'square';
+}
+declare class HeaderCardComponent implements OnInit, OnDestroy {
+    private readonly storeService;
+    private readonly transloco;
+    private readonly subscription;
+    /** Dashboard ID */
+    readonly dashboardId: _angular_core.InputSignal<string | number>;
+    /** Action event output */
+    readonly onAction: _angular_core.OutputEmitterRef<{
+        type: string;
+        data: any;
+    }>;
+    /** Configuration item */
+    readonly configurationItem: _angular_core.WritableSignal<ItemConfig | null>;
+    /** Data handled (for dynamic text replacement) */
+    readonly dataHandled: _angular_core.WritableSignal<any>;
+    /** Language code */
+    readonly langCode: _angular_core.Signal<string>;
+    /** StyleConfig from displayConfig */
+    readonly styleConfig: _angular_core.Signal<_masterteam_dashboard_builder.StyleConfig>;
+    /** Card style config */
+    readonly cardStyleConfig: _angular_core.Signal<any>;
+    /** Cols from dimensions */
+    readonly cols: _angular_core.Signal<number>;
+    /** Is full width (cols == 36) */
+    readonly isFullWidth: _angular_core.Signal<boolean>;
+    /** Title with dynamic text replacement */
+    readonly title: _angular_core.Signal<string>;
+    /** Icon name */
+    readonly icon: _angular_core.Signal<string>;
+    /** Logo configuration */
+    readonly logo: _angular_core.Signal<any>;
+    /** Logo URL */
+    readonly logoUrl: _angular_core.Signal<string | null>;
+    /** Icon color */
+    readonly iconColor: _angular_core.Signal<any>;
+    /** Icon background color */
+    readonly iconBgColor: _angular_core.Signal<any>;
+    /** Font size for title */
+    readonly fontSizeTitle: _angular_core.Signal<string>;
+    /** Container styles from StyleConfig */
+    readonly containerStyles: _angular_core.Signal<any>;
+    /** Card styles */
+    readonly cardStyles: _angular_core.Signal<any>;
+    /** Status indicators */
+    readonly statuses: _angular_core.WritableSignal<StatusItem[]>;
+    /** Is clickable */
+    readonly isClickable: _angular_core.Signal<boolean>;
+    /** Show arrow */
+    readonly showArrow: _angular_core.Signal<any>;
+    ngOnInit(): void;
+    private processStatuses;
+    ngOnDestroy(): void;
+    onTitleClick(): void;
+    onArrowClick(): void;
+    onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HeaderCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HeaderCardComponent, "db-header-card", never, { "dashboardId": { "alias": "dashboardId"; "required": true; "isSignal": true; }; }, { "onAction": "onAction"; }, never, never, true, never>;
+}
+
+interface LevelCardData$1 {
+    id: number;
+    name: string;
+    currentPhase?: string;
+    props: PropertyData[];
+    status?: PropertyData;
+    [key: string]: any;
+}
+interface PropertyData {
+    key: string;
+    normalizedKey: string;
+    viewType: string;
+    value: any;
+    displayAreas?: {
+        key: string;
+        order: number;
+    }[];
+    displayArea?: {
+        key: string;
+        order: number;
+    }[];
+}
+declare class LevelCardListComponent implements OnInit, OnDestroy {
+    private readonly storeService;
+    private readonly transloco;
+    private readonly subscription;
+    /** Dashboard ID */
+    readonly dashboardId: _angular_core.InputSignal<string | number>;
+    /** Whether inside a group */
+    readonly inGroup: _angular_core.InputSignal<boolean>;
+    /** Properties to hide */
+    readonly hideProperties: _angular_core.InputSignal<string[]>;
+    /** Action event output */
+    readonly onAction: _angular_core.OutputEmitterRef<{
+        type: string;
+        data: any;
+    }>;
+    /** Configuration item */
+    readonly configurationItem: _angular_core.WritableSignal<ItemConfig | null>;
+    /** Card data from handler */
+    readonly cardData: _angular_core.WritableSignal<any[][]>;
+    /** Currently selected tab index */
+    readonly tabSelected: _angular_core.WritableSignal<number>;
+    /** Language code */
+    readonly langCode: _angular_core.Signal<string>;
+    /** Gallery mode flag */
+    readonly galleryMode: _angular_core.Signal<boolean>;
+    /** Tabs from config */
+    readonly tabs: _angular_core.Signal<{
+        ar: string | undefined;
+        en: string | undefined;
+    }[]>;
+    /** Current tab data */
+    readonly currentTabData: _angular_core.Signal<any[]>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Get properties for card body (displayArea: levelCard_body)
+     */
+    getBodyProps(card: LevelCardData$1): PropertyData[];
+    /**
+     * Get attachments for gallery mode
+     */
+    getAttachments(card: LevelCardData$1): any[];
+    /**
+     * Check if card has any counters
+     */
+    hasCounters(card: any): boolean;
+    /**
+     * Handle card click
+     */
+    onCardClick(card: LevelCardData$1): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LevelCardListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LevelCardListComponent, "mt-level-card-list", never, { "dashboardId": { "alias": "dashboardId"; "required": true; "isSignal": true; }; "inGroup": { "alias": "inGroup"; "required": false; "isSignal": true; }; "hideProperties": { "alias": "hideProperties"; "required": false; "isSignal": true; }; }, { "onAction": "onAction"; }, never, never, true, never>;
+}
+
+declare class ListStatisticCardComponent implements OnInit, OnDestroy {
+    private readonly storeService;
+    private readonly subscription;
+    /** Dashboard ID */
+    readonly dashboardId: _angular_core.InputSignal<string | number>;
+    /** Configuration item - matches OLD: ConfigurationItem */
+    readonly configurationItem: _angular_core.WritableSignal<ItemConfig | null>;
+    /** Handled data - matches OLD: DataHandled - receives direct format from handler */
+    readonly dataHandled: _angular_core.WritableSignal<any>;
+    /** Style configuration - matches OLD: StyleConfig */
+    readonly styleConfig: _angular_core.Signal<_masterteam_dashboard_builder.StyleConfig | undefined>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * DoActions - matches OLD exactly
+     * OLD: DoActions(event: any, type: string)
+     */
+    doActions(event: any, type: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListStatisticCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ListStatisticCardComponent, "db-list-statistic-card", never, { "dashboardId": { "alias": "dashboardId"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface SkeletonConfig {
+    width: string;
+    height: string;
+}
+declare class SkeletonCardComponent implements OnInit, OnDestroy {
+    private readonly storeService;
+    private readonly subscription;
+    /** Dashboard ID */
+    readonly dashboardId: _angular_core.InputSignal<string | number>;
+    /** Configuration item */
+    readonly configurationItem: _angular_core.WritableSignal<ItemConfig | null>;
+    /** Skeletons configuration */
+    readonly skeletons: _angular_core.Signal<SkeletonConfig[]>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private getSkeletonsForComponent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkeletonCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkeletonCardComponent, "db-skeleton-card", never, { "dashboardId": { "alias": "dashboardId"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class StatisticCardComponent implements OnInit {
+    /** Card config (same as old component) */
+    readonly config: _angular_core.InputSignal<any>;
+    /** Style config from parent */
+    readonly styleConfig: _angular_core.InputSignal<any>;
+    /** Configuration item from parent */
+    readonly configurationItem: _angular_core.InputSignal<ItemConfig | null>;
+    /** Click event - emits the config */
+    readonly cardClick: _angular_core.OutputEmitterRef<any>;
+    /** Path for images */
+    pathImages: string;
+    /** Language code */
+    readonly languageCode: _angular_core.Signal<string>;
+    readonly isArabic: _angular_core.Signal<boolean>;
+    /** Show card info icon */
+    readonly showCardInfo: _angular_core.Signal<any>;
+    /** Card info tooltip content */
+    readonly cardInfoTooltip: _angular_core.Signal<any>;
+    /** Tooltip value */
+    readonly tooltipValue: _angular_core.Signal<any>;
+    /** Font size for value */
+    readonly fontSizeValue: _angular_core.Signal<string | undefined>;
+    /** Font size for title */
+    readonly fontSizeTitle: _angular_core.Signal<string | undefined>;
+    /** Card styles */
+    readonly cardStyles: _angular_core.Signal<Record<string, any>>;
+    /** Border top style */
+    readonly borderTopStyle: _angular_core.Signal<{
+        'border-top'?: undefined;
+    } | {
+        'border-top': string;
+    }>;
+    /** Icon styles */
+    readonly iconStyles: _angular_core.Signal<{
+        'background-color': any;
+        color: any;
+    }>;
+    ngOnInit(): void;
+    onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StatisticCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StatisticCardComponent, "mt-statistic-card", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "styleConfig": { "alias": "styleConfig"; "required": false; "isSignal": true; }; "configurationItem": { "alias": "configurationItem"; "required": false; "isSignal": true; }; }, { "cardClick": "cardClick"; }, never, never, true, never>;
+}
+
+interface TableColumn {
+    key: string;
+    keyPure?: string;
+    label: string;
+    viewType?: string;
+    columnType?: 'entity' | 'actions' | 'template' | 'drag';
+    hideColumn?: boolean;
+    width?: string;
+    isSort?: boolean;
+    isAsc?: boolean;
+}
+interface TableStyleConfig {
+    thTextColor?: string;
+    thBackgroundColor?: string;
+    thFontBold?: boolean;
+    thFontSize?: number;
+    tdTextColor?: string;
+    tdFontBold?: boolean;
+    tdFontSize?: number;
+    groupTextColor?: string;
+    groupBackgroundColor?: string;
+    hiddenColumns?: string[];
+    hideTableSubheader?: boolean;
+    hideIndex?: boolean;
+}
+declare class TableCardComponent implements OnInit, OnDestroy {
+    private readonly storeService;
+    private readonly transloco;
+    private readonly subscription;
+    /** Dashboard ID */
+    readonly dashboardId: _angular_core.InputSignal<string | number>;
+    /** Whether card is in a group */
+    readonly inGroup: _angular_core.InputSignal<boolean>;
+    /** Action event output */
+    readonly onAction: _angular_core.OutputEmitterRef<{
+        type: string;
+        data: any;
+    }>;
+    /** Configuration item */
+    readonly configurationItem: _angular_core.WritableSignal<ItemConfig | null>;
+    /** Raw data from handler */
+    readonly rawData: _angular_core.WritableSignal<any>;
+    /** Loading state */
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    /** Columns */
+    readonly columns: _angular_core.WritableSignal<TableColumn[]>;
+    /** Labels for status display */
+    readonly labels: _angular_core.WritableSignal<any[]>;
+    /** Processed table rows */
+    readonly tableRows: _angular_core.WritableSignal<any[]>;
+    /** Grouped data */
+    readonly groupedData: _angular_core.WritableSignal<any[]>;
+    /** Title */
+    readonly title: _angular_core.Signal<string>;
+    /** Table style config */
+    readonly tableStyleConfig: _angular_core.Signal<TableStyleConfig | null>;
+    /** Whether to show index column */
+    readonly showIndex: _angular_core.Signal<boolean>;
+    /** Whether table is grouped */
+    readonly isGrouped: _angular_core.Signal<boolean>;
+    /** Has data */
+    readonly hasData: _angular_core.Signal<boolean>;
+    /** Visible columns (not hidden) */
+    readonly visibleColumns: _angular_core.Signal<TableColumn[]>;
+    /** Total columns (for colspan) */
+    readonly totalColumns: _angular_core.Signal<number>;
+    /** Row clickable */
+    readonly isRowClickable: _angular_core.Signal<boolean | undefined>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Build table columns and rows from raw data
+     * Matches old buildTable logic in table-card.component.ts
+     */
+    private buildTable;
+    /**
+     * Build flat (non-grouped) table
+     */
+    private buildFlatTable;
+    /**
+     * Build grouped table
+     */
+    private buildGroupedTable;
+    /**
+     * Get cell data for entity-info component
+     * Returns the full entity data object { viewType, value, label }
+     */
+    getCellData(row: any, column: TableColumn): any;
+    /**
+     * Sort column
+     */
+    onSort(column: TableColumn): void;
+    /**
+     * Get sortable value from row
+     */
+    private getSortValue;
+    /**
+     * Handle row click
+     */
+    onRowClick(row: any): void;
+    /**
+     * Handle header click
+     */
+    onHeaderClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableCardComponent, "db-table-card", never, { "dashboardId": { "alias": "dashboardId"; "required": true; "isSignal": true; }; "inGroup": { "alias": "inGroup"; "required": false; "isSignal": true; }; }, { "onAction": "onAction"; }, never, never, true, never>;
+}
+
+declare class DashboardItemStoreService {
+    /** Store for all dashboard items, keyed by dashboardId */
+    private itemsStore;
+    /** Subject for broadcasting store updates */
+    private storeUpdates$;
+    /** Localization data */
+    private localization;
+    /** Current action data per dashboard item */
+    private actionData;
+    /**
+     * Initialize or update store for a dashboard item
+     */
+    updateStoreForItem(dashboardId: string | number, data: Partial<DashboardItemStore>): void;
+    /**
+     * Get current store for a dashboard item
+     */
+    getStoreForItem(dashboardId: string | number): DashboardItemStore | undefined;
+    /**
+     * Get current store for a dashboard item (alias for getStoreForItem)
+     */
+    getStore(dashboardId: string | number): DashboardItemStore | undefined;
+    /**
+     * Get specific property from item store
+     */
+    getItemProperty<K extends keyof DashboardItemStore>(dashboardId: string | number, key: K): DashboardItemStore[K] | undefined;
+    /**
+     * Select specific property from item store as Observable
+     */
+    selectItemProperty$<K extends keyof DashboardItemStore>(dashboardId: string | number, key: K): Observable<DashboardItemStore[K] | undefined>;
+    /**
+     * Clear store for a specific item
+     */
+    clearItemStore(dashboardId: string | number): void;
+    /**
+     * Clear all stores
+     */
+    clearAllStores(): void;
+    /**
+     * Get configuration item for a dashboard
+     */
+    getConfigurationItem(dashboardId: string | number): ItemConfig | undefined;
+    /**
+     * Update configuration item
+     */
+    updateConfigurationItem(dashboardId: string | number, config: ItemConfig): void;
+    /**
+     * Get handled data for a dashboard item
+     */
+    getDataHandled(dashboardId: string | number): any;
+    /**
+     * Trigger data fetch for an item
+     */
+    triggerDataFetch(dashboardId: string | number): void;
+    /**
+     * Handle action type
+     */
+    handleActionsType(type: string, configurationItem: Partial<ItemConfig> | any, data: any): void;
+    /**
+     * Get data for current action
+     */
+    getDataForCurrentAction(dashboardId: string | number): any;
+    /**
+     * Get extra filter for current action context
+     */
+    getExtraFilterForCurrentAction(dashboardId: string | number): Record<string, any>;
+    /**
+     * Set extra filter for an item
+     */
+    setExtraFilter(dashboardId: string | number, filter: Record<string, any>): void;
+    /**
+     * Set query params for an item
+     */
+    setQueryParams(dashboardId: string | number, params: Record<string, any>): void;
+    /**
+     * Get query params for an item
+     */
+    getQueryParams(dashboardId: string | number): Record<string, any>;
+    /**
+     * Set pre-query params (params that should be merged before request)
+     */
+    setPreQueryParams(dashboardId: string | number, params: Record<string, any>): void;
+    /**
+     * Get items that have filters applied (for batch refresh)
+     */
+    getItemsWithFilters(): Array<{
+        id: string | number;
+        filters: Record<string, any>;
+    }>;
+    /**
+     * Trigger data fetch for all items that have filters
+     */
+    refreshItemsWithFilters(): void;
+    /**
+     * Stop actions for an item (prevent action handling)
+     */
+    stopActions(dashboardId: string | number, stop?: boolean): void;
+    /**
+     * Set localization data
+     */
+    setLocalization(data: Record<string, any>): void;
+    /**
+     * Get localization data
+     */
+    getLocalization(): Record<string, any>;
+    /**
+     * Get localized value
+     */
+    getLocalizedValue(key: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DashboardItemStoreService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DashboardItemStoreService>;
+}
+
+declare class ChartDataService {
+    private readonly http;
+    private readonly transloco;
+    private readonly itemStore;
+    private urlPrefix;
+    private apiVersion;
+    private readonly handlers;
+    private readonly passthroughFunctions;
+    constructor();
+    /**
+     * Initialize URL configuration from localStorage (same as old implementation)
+     */
+    private initUrlConfig;
+    private createPassthroughResult;
+    /**
+     * Main entry point - fetch and process chart data
+     */
+    fetchChartData(config: ItemConfig, filters?: Record<string, any>): Observable<ChartDataHandled | null>;
+    /**
+     * Build HTTP request based on request type
+     */
+    private buildRequest;
+    /**
+     * Merge service config filters with runtime filters
+     */
+    private mergeFilters;
+    /**
+     * Build HttpParams from filters
+     */
+    private buildHttpParams;
+    /**
+     * Fetch level data
+     */
+    private fetchLevelData;
+    /**
+     * Fetch level log data
+     */
+    private fetchLevelLogData;
+    /**
+     * Fetch log data
+     */
+    private fetchLogData;
+    /**
+     * Fetch custom data (uses POST like old implementation)
+     * URL: ${urlPrefix}dashboards/${apiVersion}chart?name=${chartName}
+     */
+    private fetchCustomData;
+    /**
+     * Build request body for custom chart requests
+     */
+    private buildCustomRequestBody;
+    /**
+     * Fetch snapshot data
+     * URL: ${urlPrefix}dashboards/${apiVersion}GetSnapShotInfo/${levelId?/}${timeFrame}?year=${year}
+     */
+    private fetchSnapshotData;
+    /**
+     * Fetch level cards data
+     * URL: ${urlPrefix}Dashboards/${apiVersion}GetCards/${selector}
+     */
+    private fetchLevelCardsData;
+    /**
+     * Fetch timeline dependencies
+     * URL: ${urlPrefix}dashboards/${apiVersion}ProjectsDependancies
+     */
+    private fetchTimelineDependencies;
+    /**
+     * Fetch custom S+ data
+     */
+    private fetchCustomSplusData;
+    /**
+     * Fetch phase gate data
+     * URL: ${urlPrefix}api/Levels/${levelId}/PhaseGates
+     */
+    private fetchPhaseGateData;
+    /**
+     * Fetch data from custom API (customApi.customApiUrl)
+     */
+    private fetchCustomApiData;
+    /**
+     * Process chart data using appropriate handler method
+     * DYNAMIC pattern: Find handler that has the functionName method and call it
+     */
+    processChartData(data: any, config: ItemConfig): ChartDataHandled;
+    /**
+     * Get language code
+     */
+    getLanguageCode(): string;
+    /**
+     * Trigger refresh for a specific item
+     */
+    refreshItem(dashboardId: string | number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChartDataService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ChartDataService>;
+}
+
+declare class BarChartHandler {
+    /**
+     * handleBarChart - matches functionName from CHART_TYPES
+     * Returns ECharts option directly (exactly like old BarChartService.handleBarChart)
+     */
+    handleBarChart(dataResponse: any, config: ItemConfig): any;
+    /**
+     * Format X axis value
+     */
+    private formatXAxis;
+    /**
+     * Apply bar override configurations
+     */
+    private applyBarOverrides;
+    /**
+     * Build grouped bar chart
+     */
+    private buildGroupedBarChart;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BarChartHandler, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<BarChartHandler>;
+}
+
+declare class PieChartHandler {
+    /**
+     * handleDonutChart - matches functionName from CHART_TYPES
+     * Returns ECharts option directly (exactly like old DountChartService.handleDonutChart)
+     */
+    handleDonutChart(dataResponse: any, config: ItemConfig): any;
+    /**
+     * Normalize chart data - aggregate duplicate labels
+     * Exactly matches old DountChartService.normalizeChartData
+     */
+    normalizeChartData(data: any): {
+        labels: any[];
+        values: any[];
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PieChartHandler, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PieChartHandler>;
+}
+
+declare class StackBarChartHandler {
+    /**
+     * Helper method to convert legend position based on language
+     */
+    private getLegendPositionX;
+    /**
+     * handleStackBarChart - matches functionName from CHART_TYPES
+     */
+    handleStackBarChart(dataResponse: any, config: ItemConfig): any;
+    private buildSingleDefaultOption;
+    private buildGroupedStackedOption;
+    private removeDuplicatedKeys;
+    private findStackInfo;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StackBarChartHandler, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<StackBarChartHandler>;
+}
+/**
+ * Centralized x-axis formatting utilities
+ */
+declare const axisFormatters: Record<string, {
+    formatValue: (dateValue: string, formatConfig: any) => string;
+    preprocessData?: (stacks: any[], formatConfig: any) => any;
+    findCategoryData?: (processedStacks: any[], xAxisKey: string, xAxisLabels: Map<string, string>) => any;
+}>;
+declare function groupDatesByYearAndMonth(data: any[], valueAggregator?: (values: number[]) => number): any[];
+
+declare class GaugeChartHandler {
+    /**
+     * handleGaugeChart - matches functionName from CHART_TYPES
+     * Returns ECharts config directly (exactly like old GaugeChartService)
+     */
+    handleGaugeChart(dataResponse: any, config: ItemConfig): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaugeChartHandler, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GaugeChartHandler>;
+}
+
+declare class TableViewHandler {
+    /**
+     * handleTableView - matches functionName from CHART_TYPES
+     * Returns data directly (not wrapped in { type, data, config })
+     */
+    handleTableView(dataResponse: any, config: ItemConfig): any;
+    /**
+     * Handle projects by execution period (special case)
+     * Returns eCharts bar chart config directly (like old HandleProjectsByExecutionPeriod)
+     */
+    private handleProjectsByExecutionPeriod;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableViewHandler, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TableViewHandler>;
+}
+
+declare class OverviewCardHandler {
+    /**
+     * handleOverviewCard - matches functionName from CHART_TYPES
+     * Returns EXACT same format as old OverviewCardService
+     */
+    handleOverviewCard(data: any, config: ItemConfig): any;
+    /**
+     * Handle special case values (same as old)
+     */
+    private handleSpecialCase;
+    /**
+     * Get current week of year (same as old)
+     */
+    private getCurrentWeekOfYear;
+    /**
+     * handleProperties - for entityPreview component
+     * Returns dataResponse directly - the component handles transformation
+     * (same as old PropertiesService.handleProperties)
+     */
+    handleProperties(dataResponse: any, config: ItemConfig): any;
+    /**
+     * handleHeader - for header component
+     * Extracts title from first value (same as old PropertiesService.handleHeader)
+     */
+    handleHeader(data: any, config: ItemConfig): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverviewCardHandler, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<OverviewCardHandler>;
+}
+
+declare class TimelineHandler {
+    /**
+     * handleTimeline - Single level timeline
+     * Matches old TimelineService.handleTimeline exactly
+     */
+    handleTimeline(data: any, config: ItemConfig): any;
+    /**
+     * handleTimelineV2MultiLevel - matches functionName from CHART_TYPES
+     * Returns timeline data directly (not wrapped) like old TimelineService.
+     * Format: { calendarOptions: {...}, ...data }
+     */
+    handleTimelineV2MultiLevel(dataResponse: any, config: ItemConfig): any;
+    /**
+     * Helper to handle value cases (name or value directly)
+     */
+    private handleCasesForValue;
+    /**
+     * Helper function to find parent resource recursively
+     */
+    private findParentResource;
+    /**
+     * Handle multi-level timeline (alias for handleTimelineV2MultiLevel)
+     * Used for hierarchical timeline views.
+     * Returns data directly like handleTimelineV2MultiLevel.
+     */
+    handleMultiLevel(dataResponse: any, config: ItemConfig): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimelineHandler, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TimelineHandler>;
+}
+
+declare class LineChartHandler {
+    /**
+     * handleLineChart - matches functionName from CHART_TYPES
+     * Returns ECharts config directly with noData, width, divClass properties
+     */
+    handleLineChart(dataResponse: any, config: ItemConfig): any;
+    /**
+     * Build ECharts configuration
+     */
+    private buildChartOption;
+    /**
+     * Get default color for series index
+     */
+    private getDefaultColor;
+    /**
+     * Convert hex to rgba
+     */
+    private hexToRgba;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LineChartHandler, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<LineChartHandler>;
+}
+
+declare class SnapshotHandler {
+    /**
+     * handleSnapShot - matches functionName from CHART_TYPES
+     * Returns ECharts option directly (same as old SnapShotService)
+     */
+    handleSnapShot(data: any, config: ItemConfig): any;
+    /**
+     * Handle snapshot line chart (default)
+     * Returns ECharts option directly
+     */
+    handleSnapShotLineChart(data: any, config: ItemConfig): any;
+    /**
+     * Handle snapshot line bar chart
+     * Returns ECharts option directly
+     */
+    handleSnapShotLineBarChart(data: any, config: ItemConfig): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SnapshotHandler, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SnapshotHandler>;
+}
+
+declare class ComparisonChartHandler {
+    /**
+     * Main handler for comparison charts
+     * Returns ECharts config directly with noData, width, divClass properties
+     * (matches old ComparisonChartService.handleComparisonChart format)
+     */
+    handle(dataResponse: any, config: ItemConfig): any;
+    /**
+     * Year over Year comparison handler
+     * Returns ECharts config directly with noData, width, divClass properties
+     */
+    handleYearOverYear(dataResponse: any, config: ItemConfig): any;
+    /**
+     * Planned vs Actual comparison
+     * Returns ECharts config directly with noData, width, divClass properties
+     */
+    handlePlannedVsActual(dataResponse: any, config: ItemConfig): any;
+    /**
+     * Parse generic comparison data
+     */
+    private parseComparisonData;
+    /**
+     * Parse Year over Year data
+     */
+    private parseYoYData;
+    /**
+     * Parse Planned vs Actual data
+     */
+    private parsePlannedActualData;
+    /**
+     * Build comparison bar chart
+     */
+    private buildComparisonChart;
+    /**
+     * Build Year over Year chart
+     */
+    private buildYoYChart;
+    /**
+     * Build Planned vs Actual chart with variance indicators
+     */
+    private buildPlannedActualChart;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ComparisonChartHandler, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ComparisonChartHandler>;
+}
+
+declare class SplitterChartHandler {
+    /**
+     * handleSplitterChart - matches functionName from CHART_TYPES
+     * Returns data directly in the format:
+     * {
+     *   negative: { labels: string[], groupedValue: number },
+     *   positive: { labels: string[], groupedValue: number }
+     * }
+     */
+    handleSplitterChart(dataResponse: any, config: ItemConfig): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SplitterChartHandler, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SplitterChartHandler>;
+}
+
+interface LevelCardData {
+    id: string | number;
+    name: string;
+    level?: {
+        id: number;
+        name: string;
+        order: number;
+    };
+    status?: {
+        name: string;
+        color: string;
+    };
+    properties: LevelCardProperty[];
+    extraData?: Record<string, any>;
+    show?: boolean;
+}
+interface LevelCardProperty {
+    key: string;
+    normalizedKey: string;
+    label: string;
+    value: any;
+    displayValue?: string;
+    viewType?: string;
+    color?: string;
+    icon?: string;
+}
+declare class LevelCardHandler {
+    /**
+     * handlelevelCards - matches functionName from CHART_TYPES
+     * Returns data directly like old LevelCardService:
+     * result?.map(data => data?.details?.map(...).sort(...))
+     */
+    handlelevelCards(result: any, config: ItemConfig): any;
+    /**
+     * handlelevelCardsWithFilter - matches functionName from CHART_TYPES
+     * Returns data directly like old LevelCardService:
+     * [[{ data: levelProps }]]
+     */
+    handlelevelCardsWithFilter(result: any, config: ItemConfig): any;
+    /**
+     * Handle grouped level cards (multiple selections)
+     * Returns data directly
+     */
+    handleGrouped(dataResponse: any[], config: ItemConfig): any;
+    /**
+     * Parse level cards from details array (standard API response)
+     */
+    private parseLevelCards;
+    /**
+     * Parse level cards with filter (values array format)
+     */
+    private parseLevelCardsWithFilter;
+    /**
+     * Parse a single card detail
+     */
+    private parseCardDetail;
+    /**
+     * Get display value from property
+     */
+    private getDisplayValue;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LevelCardHandler, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<LevelCardHandler>;
+}
+
+declare class MapChartHandler {
+    private mapCity;
+    /**
+     * handleMapChart - for ECharts geo map
+     * Returns ECharts option directly
+     */
+    handleMapChart(dataResponse: any, config: ItemConfig): any;
+    /**
+     * handleLeafletMap - matches functionName from CHART_TYPES
+     * Returns data directly as array of grouped records
+     */
+    handleLeafletMap(dataResponse: any, config: ItemConfig): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MapChartHandler, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MapChartHandler>;
+}
+
+declare class RingGaugeChartHandler {
+    private colorByPropMap;
+    /**
+     * handleRingGaugeChart - matches functionName from CHART_TYPES
+     * Returns ECharts option directly (same as old RingGaugeChartService)
+     */
+    handleRingGaugeChart(dataResponse: any, config: ItemConfig): any;
+    /**
+     * Helper method to return empty chart options
+     */
+    private getEmptyChartOptions;
+    /**
+     * Helper method to extract numeric value from various value types
+     */
+    private extractNumericValue;
+    /**
+     * Build color by property map
+     */
+    private buildColorByPropertyMap;
+    /**
+     * Add legend graphics to options
+     */
+    private addLegendGraphics;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RingGaugeChartHandler, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<RingGaugeChartHandler>;
+}
+
+declare class SPlusChartHandler {
+    private generalService;
+    /**
+     * Handle S+ Gauge Chart - returns ECharts option directly
+     * Matches old SplusChartsService.handleGaugeChartSplus return format
+     */
+    handleGaugeChartSplus(data: any, config: ItemConfig): any;
+    /**
+     * Handle S+ Component Cards Chart - returns transformed array directly
+     * Matches old SplusChartsService.handleComponentsCardsChart return format
+     */
+    handleComponentsCardsChart(data: any, _config: ItemConfig): any;
+    /**
+     * Handle S+ progress chart
+     */
+    handleProgress(dataResponse: any, config: ItemConfig): ChartDataHandled;
+    /**
+     * Handle S+ KPIs display
+     */
+    handleKPIs(dataResponse: any, config: ItemConfig): ChartDataHandled;
+    /**
+     * Handle S+ weighted progress
+     */
+    handleWeightedProgress(dataResponse: any, config: ItemConfig): ChartDataHandled;
+    /**
+     * Handle S+ milestone timeline
+     */
+    handleMilestones(dataResponse: any, config: ItemConfig): ChartDataHandled;
+    /**
+     * Parse progress data
+     */
+    private parseProgressData;
+    /**
+     * Parse KPI data
+     */
+    private parseKPIData;
+    /**
+     * Parse milestone data
+     */
+    private parseMilestoneData;
+    /**
+     * Build progress bar chart
+     */
+    private buildProgressChart;
+    /**
+     * Build weighted progress chart with summary gauge
+     */
+    private buildWeightedProgressChart;
+    /**
+     * Handle S+ gauge chart (handleGaugeChartSplus)
+     */
+    handleGauge(dataResponse: any, config: ItemConfig): ChartDataHandled;
+    /**
+     * Handle S+ component cards (handleComponentsCardsChart)
+     */
+    handleComponentCards(dataResponse: any, config: ItemConfig): ChartDataHandled;
+    /**
+     * Get color based on status
+     */
+    private getStatusColor;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SPlusChartHandler, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SPlusChartHandler>;
+}
+
+interface PhaseGateStep {
+    id: string | number;
+    name: string;
+    order: number;
+    status: 'completed' | 'current' | 'upcoming' | 'skipped';
+    date?: string;
+    completedDate?: string;
+    color?: string;
+    icon?: string;
+    properties?: PhaseGateProperty[];
+}
+interface PhaseGateProperty {
+    key: string;
+    label: string;
+    value: any;
+    displayValue?: string;
+    viewType?: string;
+}
+declare class PhaseGateStepperHandler {
+    /**
+     * handlePhaseGateStepperCard - matches functionName from CHART_TYPES
+     * Returns data directly matching old PhaseGateStepperService format
+     */
+    handlePhaseGateStepperCard(data: any, _configurationItem: any): any;
+    /**
+     * Handle phase gate for table display
+     */
+    handleTable(dataResponse: any, config: ItemConfig): ChartDataHandled;
+    /**
+     * Parse phase gate data from API response
+     */
+    private parsePhaseGateData;
+    /**
+     * Determine step status
+     */
+    private determineStepStatus;
+    /**
+     * Get color based on status
+     */
+    private getStatusColor;
+    /**
+     * Parse step properties
+     */
+    private parseStepProperties;
+    /**
+     * Get display value from property
+     */
+    private getDisplayValue;
+    /**
+     * Build table columns from steps
+     */
+    private buildTableColumns;
+    /**
+     * Build table rows from steps
+     */
+    private buildTableRows;
+    /**
+     * Get localized status label
+     */
+    private getStatusLabel;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PhaseGateStepperHandler, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PhaseGateStepperHandler>;
+}
+
+/**
+ * Formatters
+ *
+ * Number, currency, and date formatting utilities.
+ */
+/**
+ * Get current language code from localStorage
+ */
+declare function getLanguageCode(): string;
+/**
+ * Format large numbers with suffixes (K, M, B, T)
+ */
+declare function formatCurrency(value: number | string | null | undefined, config?: {
+    type?: 'currency';
+    showCurrency?: boolean;
+    handleLang?: boolean;
+    decimals?: number;
+}): string;
+/**
+ * Format percentage value
+ */
+declare function formatPercentage(value: number | string | null | undefined, decimals?: number): string;
+/**
+ * Format number with locale
+ */
+declare function formatNumber(value: number | string | null | undefined, options?: Intl.NumberFormatOptions): string;
+/**
+ * Format date
+ */
+declare function formatDate(value: string | Date | null | undefined, format?: 'short' | 'medium' | 'long' | 'full'): string;
+/**
+ * Formatter for ECharts axis labels
+ */
+declare function createAxisFormatter(config?: {
+    maxLength?: number;
+    handleLang?: boolean;
+}): (value: string | number) => string;
+/**
+ * Formatter for ECharts tooltip values
+ */
+declare function createTooltipFormatter(config?: {
+    type?: 'currency' | 'percentage' | 'number';
+}): (value: number) => string;
+/**
+ * Format words with underscores for display
+ * @param text - Text to format
+ * @param maxLength - Optional max length to truncate to
+ */
+declare function formatWordsUnderBar(text: string, maxLength?: number): string;
+
+/**
+ * Chart Helpers
+ *
+ * Utility functions for chart data manipulation.
+ */
+
+/**
+ * General configuration for charts (matches old generalConfigration)
+ */
+declare const generalConfiguration: {
+    fontConfig: {
+        fontFamily: string;
+        fontSizeConfig: {
+            label: number;
+            legend: number;
+            category: number;
+            tooltip: number;
+        };
+    };
+    generalFilter: {
+        show: boolean;
+    };
+};
+/**
+ * Format value based on config format (matches old Formater function)
+ */
+declare function formatValue(value: any, configFormat: any): any;
+/**
+ * Add commas to number for display (same as old)
+ */
+declare function addCommasToNumber(num: string | number): string;
+/**
+ * Convert all object keys to lowercase
+ */
+declare function switchAllKeysToLower<T extends Record<string, any>>(obj: T | null | undefined): Record<string, any>;
+/**
+ * Alias for switchAllKeysToLower (matches old generalFuctions naming)
+ */
+declare const switchAllKeysSmall: typeof switchAllKeysToLower;
+/**
+ * Get nested data from object using dot notation path
+ */
+declare function getNestedData(key: string, item: any): any;
+/**
+ * Dynamic text replacement with placeholders
+ * Replaces {{key}} patterns with values from the data object
+ */
+declare function dynamicTextReplace(text: string | null | undefined, data: Record<string, any> | null | undefined): string;
+/**
+ * Dynamic reorder array based on order config
+ * Supports both object syntax and individual parameters
+ * Compatible with old format: { order: string[], operation?: string }
+ */
+declare function dynamicReorder<T>(arrayOrConfig: T[] | {
+    array: T[];
+    orderConfig?: {
+        order?: string[];
+        operation?: string;
+    } | Record<string, number>;
+    path?: string;
+}, orderConfig?: {
+    order?: string[];
+    operation?: string;
+} | Record<string, number>, path?: string): T[];
+/**
+ * Sort chart data based on value
+ * Returns { sortedData, sortedXAxis } like old implementation
+ */
+declare function sortChartData<T extends {
+    value?: number;
+}>(data: T[], xAxisData?: string[], config?: {
+    key?: string;
+    direction?: 'asc' | 'desc';
+    type?: 'string' | 'number' | 'date';
+    enable?: boolean;
+}): {
+    sortedData: T[];
+    sortedXAxis: string[];
+} | null;
+/**
+ * Sort table view data
+ */
+declare function sortDataTableView(data: any[], sortConfig: {
+    key: string;
+    direction: 'asc' | 'desc';
+}): any[];
+/**
+ * Get localized title from object
+ */
+declare function getLocalizedTitle(titleObj: {
+    en?: string;
+    ar?: string;
+} | string | null | undefined): string;
+/**
+ * Check if running on mobile platform
+ */
+declare function isMobilePlatform(): boolean;
+/**
+ * Get color from indexed color conditions
+ * Matches old getColorFromConditions behavior
+ */
+declare function getColorFromConditions(conditions: any[] | undefined, index: number, value: any): string | undefined;
+
+declare function handleFiltersForCustom(configItem: any, params: any, extraFilters?: any): any;
+declare function handleFilterForCard(filters: any, params: any): any;
+declare function handleFilterForSnapshot(levelId: any, params: any): string;
+
+/**
+ * Event emitted when a dashboard action is triggered
+ */
+interface DashboardListEvent {
+    type: 'view' | 'edit' | 'create' | 'delete' | 'manage';
+    dashboard?: DashboardPage;
+    id?: string | number;
+}
+declare class DashboardList implements OnDestroy {
+    private dashboardService;
+    private modalService;
+    private transloco;
+    private modalRef;
+    readonly nameTpl: _angular_core.Signal<TemplateRef<any> | undefined>;
+    /** Whether to wrap content in mt-page component */
+    readonly isPage: _angular_core.InputSignal<boolean>;
+    /** Page title when isPage is true */
+    readonly pageTitle: _angular_core.InputSignal<string>;
+    /** Base route for navigation (default: current route) */
+    readonly baseRoute: _angular_core.InputSignal<string>;
+    /** Whether to show the create button */
+    readonly showCreateButton: _angular_core.InputSignal<boolean>;
+    /** Whether to show the view action */
+    readonly showViewButton: _angular_core.InputSignal<boolean>;
+    /** Whether to show the edit action */
+    readonly showEditButton: _angular_core.InputSignal<boolean>;
+    /** Emitted when a dashboard action is triggered */
+    readonly dashboardAction: _angular_core.OutputEmitterRef<DashboardListEvent>;
+    /** Emitted when a new dashboard is created */
+    readonly dashboardCreated: _angular_core.OutputEmitterRef<_masterteam_dashboard_builder.Report>;
+    /** Dashboards resource using rxResource */
+    readonly dashboards: _angular_core.ResourceRef<_masterteam_dashboard_builder.ApiResponse<_masterteam_dashboard_builder.Report[]> | undefined>;
+    /** Current language code */
+    readonly langCode: _angular_core.Signal<string>;
+    /** Loading state */
+    readonly isLoading: _angular_core.Signal<boolean>;
+    /** Dashboard list */
+    readonly dashboardList: _angular_core.Signal<_masterteam_dashboard_builder.Report[]>;
+    /** Table columns */
+    readonly tableColumns: _angular_core.Signal<ColumnDef[]>;
+    /** Table row actions */
+    readonly rowActions: _angular_core.Signal<TableAction[]>;
+    /** Deleting row IDs for loading state */
+    readonly deletingRowIds: _angular_core.WritableSignal<(string | number)[]>;
+    ngOnDestroy(): void;
+    /**
+     * Get localized dashboard name
+     */
+    getDashboardName(dashboard: DashboardPage): string;
+    /**
+     * Handle view action - emits event only
+     */
+    onView(dashboard: DashboardPage): void;
+    /**
+     * Handle edit action - opens dialog for editing
+     */
+    onEdit(dashboard: DashboardPage): void;
+    /**
+     * Handle manage action - emits event for navigation
+     */
+    onManage(dashboard: DashboardPage): void;
+    /**
+     * Open create dashboard modal
+     */
+    openCreateModal(): void;
+    /**
+     * Refresh the dashboard list
+     */
+    refresh(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DashboardList, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DashboardList, "mt-dashboard-list", never, { "isPage": { "alias": "isPage"; "required": false; "isSignal": true; }; "pageTitle": { "alias": "pageTitle"; "required": false; "isSignal": true; }; "baseRoute": { "alias": "baseRoute"; "required": false; "isSignal": true; }; "showCreateButton": { "alias": "showCreateButton"; "required": false; "isSignal": true; }; "showViewButton": { "alias": "showViewButton"; "required": false; "isSignal": true; }; "showEditButton": { "alias": "showEditButton"; "required": false; "isSignal": true; }; }, { "dashboardAction": "dashboardAction"; "dashboardCreated": "dashboardCreated"; }, never, never, true, never>;
+}
+
+interface ApiResponse<T> {
+    data: T;
+    status?: number;
+    message?: string;
+}
+/**
+ * Dashboard Builder Service
+ *
+ * Handles all API calls for dashboard management including:
+ * - Reports CRUD (Dashboard/Excel)
+ * - Chart linking/unlinking
+ * - Metadata from gateway (modules, properties, values)
+ */
+declare class DashboardBuilderService {
+    private http;
+    /** Subject for processing items */
+    private processOnItem;
+    readonly processOnItem$: Observable<{
+        actionType: string;
+        value: any;
+    }>;
+    /** Filters signal for reactive state */
+    readonly filters: _angular_core.WritableSignal<any[]>;
+    /** Chart for selected dialog */
+    readonly chartForSelectedDialog: _angular_core.WritableSignal<any>;
+    /**
+     * Selector to Name mapping (e.g., "Level:7" -> "Project")
+     * Built from tree data, used to resolve selectorName for properties
+     */
+    readonly selectorNameMap: _angular_core.WritableSignal<Map<string, string>>;
+    /**
+     * Tree data cache for building selector name map
+     */
+    readonly treeData: _angular_core.WritableSignal<ServiceItem[]>;
+    /**
+     * Fixed selections that cannot be removed or edited in SelectionConfiguration.
+     * These selections are always shown and are read-only.
+     */
+    readonly fixedSelections: _angular_core.WritableSignal<ISelection[]>;
+    /** API configuration */
+    private urlPrefix;
+    /** HTTP context for gateway requests */
+    private gatewayContext;
+    constructor();
+    private loadConfig;
+    /**
+     * Emit process action
+     */
+    doProcessOnItem(actionType: string, value: any): void;
+    /**
+     * Build selector name map from tree data
+     * Maps selector (e.g., "Level:7") to name (e.g., "Project")
+     * @param services Tree data services array
+     */
+    buildSelectorNameMap(services: ServiceItem[]): void;
+    /**
+     * Set fixed selections that cannot be removed or edited
+     * @param selections Array of ISelection to be fixed/locked
+     */
+    setFixedSelections(selections: ISelection[]): void;
+    /**
+     * Clear all fixed selections
+     */
+    clearFixedSelections(): void;
+    /**
+     * Add a single fixed selection
+     * @param selection Selection to add as fixed
+     */
+    addFixedSelection(selection: ISelection): void;
+    /**
+     * Remove a single fixed selection by ID
+     * @param selectionId ID of the selection to remove
+     */
+    removeFixedSelection(selectionId: number): void;
+    /**
+     * Resolve selector name from selector
+     * @param selector Full selector (e.g., "Level:7")
+     * @returns Name (e.g., "Project") or null if not found
+     */
+    resolveSelectorName(selector: string | null | undefined): string | null;
+    /**
+     * Enrich bulk properties response with selectorName from tree data
+     * @param items Bulk properties response items
+     * @returns Enriched items with selectorName
+     */
+    enrichPropertiesWithSelectorName(items: BulkPropertiesResponseItem[]): BulkPropertiesResponseItem[];
+    /**
+     * Get all reports
+     * @param type Optional filter by type: 'Dashboard' | 'Excel'
+     */
+    getReports(type?: 'Dashboard' | 'Excel'): Observable<ApiResponse<Report[]>>;
+    /**
+     * Get report by ID
+     */
+    getReportById(id: string | number): Observable<ApiResponse<Report>>;
+    /**
+     * Create a new report
+     */
+    createReport(report: Partial<Report>): Observable<ApiResponse<Report>>;
+    /**
+     * Update an existing report
+     */
+    updateReport(report: Partial<Report>, id: string | number): Observable<ApiResponse<Report>>;
+    /**
+     * Delete a report
+     */
+    deleteReport(id: string | number): Observable<ApiResponse<void>>;
+    /**
+     * Link a chart to a report (creates or updates link)
+     */
+    linkChart(request: LinkChartRequest): Observable<ApiResponse<void>>;
+    /**
+     * Bulk link charts to a report (creates or updates links)
+     * @param requests Array of link requests
+     * @returns Array of link responses with id and chartComponentId
+     */
+    linkChartsBulk(requests: BulkLinkChartRequest[]): Observable<ApiResponse<BulkLinkChartResponse[]>>;
+    /**
+     * Update chart link configuration
+     */
+    updateChartLink(request: LinkChartRequest): Observable<ApiResponse<void>>;
+    /**
+     * Unlink a chart from a report
+     */
+    unlinkChart(request: UnlinkChartRequest): Observable<ApiResponse<void>>;
+    /**
+     * Get all available services from gateway
+     */
+    getMetadataServices(): Observable<ApiResponse<any[]>>;
+    /**
+     * Get modules tree with all services, modules, and values in a single call
+     * This returns the complete tree structure for efficient caching
+     */
+    getModulesTree(): Observable<ApiResponse<ModulesTreeResponse>>;
+    /**
+     * Get modules for a specific service
+     * @param serviceName The service name (e.g., 'pplus')
+     */
+    getModules(serviceName: string): Observable<ApiResponse<ModuleType[]>>;
+    /**
+     * Get properties for a specific module
+     * @param serviceName The service name (e.g., 'pplus')
+     * @param moduleId Module type name or 'ModuleType:Id' format (e.g., 'Level:12')
+     * @returns Properties array extracted from nested response
+     */
+    getModuleProperties(serviceName: string, moduleId: string): Observable<ApiResponse<PropertyItem$1[]>>;
+    /**
+     * Get values for a specific module
+     * @param serviceName The service name (e.g., 'pplus')
+     * @param moduleId Module type name (e.g., 'Level')
+     */
+    getModuleValues(serviceName: string, moduleId: string): Observable<ApiResponse<any[]>>;
+    /**
+     * Get authorization rules for a service
+     * @param serviceName The service name
+     */
+    getAuthorization(serviceName: string): Observable<ApiResponse<any>>;
+    /**
+     * Get public endpoints for a service
+     * @param serviceName The service name
+     */
+    getPublicEndpoints(serviceName: string): Observable<ApiResponse<any[]>>;
+    /**
+     * Get property items for lookup/status properties
+     * GET /api/dashboards/builder/property-items/{propertyKey}?language=en
+     */
+    getPropertyItems(propertyKey: string, language?: string): Observable<ApiResponse<PropertyItemsResponse>>;
+    /**
+     * Bulk properties lookup - single request for multiple modules
+     * POST /metadata/modules/properties
+     * @param items Array of { serviceName, moduleId } items
+     * @returns Properties grouped by module (extracted from data.items)
+     */
+    getBulkProperties(items: BulkPropertyRequestItem[]): Observable<ApiResponse<BulkPropertiesResponseItem[]>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DashboardBuilderService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DashboardBuilderService>;
+}
+
+/**
+ * Store Service
+ *
+ * Simple reactive store for dashboard builder state management
+ */
+declare class DashboardStoreService {
+    /** Query parameters */
+    private queryParamsSignal;
+    readonly queryParams: _angular_core.Signal<Record<string, any>>;
+    /** Stop actions on cards flag */
+    private stopActionsSignal;
+    readonly stopActions: _angular_core.Signal<boolean>;
+    /** Dynamic key-value store */
+    private dynamicStore;
+    /** Language code */
+    readonly languageCode: _angular_core.WritableSignal<string>;
+    /** Direction */
+    readonly direction: _angular_core.WritableSignal<"rtl" | "ltr">;
+    /** Reload current page subject */
+    private reloadCurrentPageSubject;
+    readonly reloadCurrentPage$: rxjs.Observable<void>;
+    /**
+     * Trigger reload of current page
+     */
+    triggerReloadCurrentPage(): void;
+    /**
+     * Update query parameters
+     */
+    updateQueryParams(params: Record<string, any>): void;
+    /**
+     * Update stop actions flag
+     */
+    updateStopActions(value: boolean): void;
+    /**
+     * Update dynamic key in store
+     */
+    updateDynamicKey(key: string, value: any): void;
+    /**
+     * Get dynamic key from store
+     */
+    getDynamicKey<T = any>(key: string): T | undefined;
+    /**
+     * Get computed value from dynamic store
+     */
+    selectDynamicKey<T = any>(key: string): _angular_core.Signal<T | undefined>;
+    /**
+     * Get query params as a plain object
+     */
+    getQueryParams(): Record<string, any>;
+    /**
+     * Get extra filters for a specific dashboard action
+     */
+    getExtraFilterForCurrentAction(dashboardId: string): Record<string, any>;
+    /**
+     * Reset store to initial state
+     */
+    reset(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DashboardStoreService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DashboardStoreService>;
+}
+
+/**
+ * Manage Pages Component
+ *
+ * Dialog component for creating and editing dashboard reports
+ */
+declare class ManagePages implements OnInit {
+    private dashboardService;
+    readonly modal: ModalService;
+    private ref;
+    /** Input: Report to edit (if editing) */
+    readonly dataEdit: _angular_core.InputSignal<Report | null>;
+    /** Report form data */
+    readonly report: _angular_core.WritableSignal<{
+        id?: number;
+        name: LocalizedName;
+        type: "Dashboard" | "Excel";
+        showInMenu: boolean;
+        isActive: boolean;
+        icon: string;
+        url: string;
+        dashboardConfig: ReportDashboardConfig;
+    }>;
+    /** Saving state */
+    readonly saving: _angular_core.WritableSignal<boolean>;
+    ngOnInit(): void;
+    saveReport(): void;
+    close(): void;
+    private clear;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ManagePages, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ManagePages, "mt-manage-pages", never, { "dataEdit": { "alias": "dataEdit"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Manage Breadcrumb Component
+ *
+ * Dialog component for configuring breadcrumb navigation
+ */
+declare class ManageBreadcrumb implements OnInit {
+    readonly modal: ModalService;
+    private ref;
+    /** Input: Initial breadcrumb data */
+    readonly data: _angular_core.InputSignal<any[]>;
+    /** Breadcrumb configuration */
+    readonly breadcrumb: _angular_core.WritableSignal<any[]>;
+    ngOnInit(): void;
+    save(): void;
+    close(): void;
+    addItem(): void;
+    removeItem(index: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ManageBreadcrumb, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ManageBreadcrumb, "mt-manage-breadcrumb", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Filter Field Models
+ *
+ * Defines the structure for dynamic filter fields configuration
+ * used in dashboard page filtering.
+ */
+/** Localized text with English and Arabic translations */
+interface LocalizedText {
+    en: string;
+    ar: string;
+}
+/** Filter field types supported by the system */
+type FilterFieldType = 'dropdownTVService' | 'lookup' | 'status' | 'phaseGate' | 'user' | 'date' | 'section' | 'separator' | 'year' | 'month' | 'quarter' | 'checkbox' | 'schemaSettings' | 'schemaSettingsLeafs';
+/** Selection item for dropdown configuration */
+interface FilterSelectionItem {
+    id: number;
+    moduleType?: string;
+    moduleId?: number;
+    filters?: any[];
+    modules?: any[];
+    properties?: any[];
+}
+/** Filter field configuration details */
+interface FilterFieldConfiguration {
+    payload?: {
+        dashboardId: number;
+        selection: FilterSelectionItem[];
+        chartType: string;
+        query: {
+            selectedProperties: string[];
+        };
+    };
+    lookupId?: number;
+    schemaLevelId?: number;
+    logId?: number;
+    isRequird?: boolean;
+    isMultiple?: boolean;
+    checked?: boolean;
+    minYear?: number;
+    maxYear?: number;
+}
+/** Filter field definition */
+interface FilterField {
+    key?: string;
+    name?: LocalizedText;
+    type: FilterFieldType;
+    configuration?: FilterFieldConfiguration;
+}
+/** Filter field type option for dropdown */
+interface FilterFieldTypeOption {
+    value: FilterFieldType;
+    label: string;
+    products: string[];
+}
+
+/**
+ * Manage Filter On Page Component
+ *
+ * Dialog component for configuring page filters.
+ * Opened from dashboard-builder via openManageFilter() method.
+ *
+ * Flow:
+ * 1. Receives initial filters via `data` input
+ * 2. User configures filters using DynamicFiltersConfig
+ * 3. On save, closes with updated filters
+ * 4. Dashboard-builder saves filters to pageConfig
+ */
+declare class ManageFilterOnPage implements OnInit {
+    readonly modal: ModalService;
+    private ref;
+    /** Input: Initial filters data */
+    readonly data: _angular_core.InputSignal<FilterField[]>;
+    /** Input: Available lookups for dropdown */
+    readonly lookups: _angular_core.InputSignal<any[]>;
+    /** Input: Available level schemas */
+    readonly levelsSchema: _angular_core.InputSignal<any[]>;
+    /** Filters configuration */
+    readonly filtersConfig: _angular_core.WritableSignal<FilterField[]>;
+    /** Level logs for status filter */
+    readonly levelLogs: _angular_core.WritableSignal<any[]>;
+    ngOnInit(): void;
+    /** Handle filter configuration changes */
+    onFiltersChange(filters: FilterField[]): void;
+    /** Load level logs for a specific schema level (placeholder for API call) */
+    onLoadLevelLogs(schemaLevelId: number): void;
+    /** Save and close the dialog */
+    save(): void;
+    /** Cancel and close the dialog */
+    close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ManageFilterOnPage, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ManageFilterOnPage, "mt-manage-filter-on-page", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "lookups": { "alias": "lookups"; "required": false; "isSignal": true; }; "levelsSchema": { "alias": "levelsSchema"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DynamicFiltersConfig implements ControlValueAccessor {
+    /** Available lookups from parent context */
+    readonly lookups: _angular_core.InputSignal<any[]>;
+    /** Available level schemas from parent context */
+    readonly levelsSchema: _angular_core.InputSignal<any[]>;
+    /** Available level logs from parent context */
+    readonly levelLogs: _angular_core.InputSignal<any[]>;
+    /** Product type to filter available field types */
+    readonly productType: _angular_core.InputSignal<string>;
+    /** Emit when level logs need to be loaded for a specific schema level */
+    readonly loadLevelLogs: _angular_core.OutputEmitterRef<number>;
+    /** Filter fields data */
+    readonly filterFields: _angular_core.WritableSignal<FilterField[]>;
+    /** Paste configuration state */
+    readonly showPasteArea: _angular_core.WritableSignal<boolean>;
+    readonly pasteContent: _angular_core.WritableSignal<string>;
+    readonly pasteError: _angular_core.WritableSignal<string>;
+    /** Disabled state */
+    readonly disabled: _angular_core.WritableSignal<boolean>;
+    /** Available field types filtered by product */
+    readonly availableFieldTypes: _angular_core.Signal<FilterFieldTypeOption[]>;
+    private onChange;
+    private onTouched;
+    writeValue(value: FilterField[]): void;
+    registerOnChange(fn: (value: FilterField[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    /** Add a new filter field */
+    addFilterField(): void;
+    /** Remove a filter field by index */
+    removeFilterField(index: number): void;
+    /** Update a filter field property */
+    updateField(index: number, key: keyof FilterField, value: any): void;
+    /** Update filter field name */
+    updateFieldName(index: number, lang: 'en' | 'ar', value: string): void;
+    /** Update filter field configuration */
+    updateFieldConfig(index: number, key: string, value: any): void;
+    /** Handle field type change */
+    onFieldTypeChange(index: number, type: FilterFieldType): void;
+    /** Handle schema level change for status/phaseGate */
+    onSchemaLevelChange(index: number, schemaLevelId: number): void;
+    /** Copy current configuration to clipboard */
+    copyConfiguration(): void;
+    /** Toggle paste area visibility */
+    togglePasteArea(): void;
+    /** Apply pasted configuration */
+    applyPastedConfiguration(): void;
+    /** Track by function for ngFor */
+    trackByIndex(index: number): number;
+    /** Notify parent of changes */
+    private notifyChange;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DynamicFiltersConfig, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DynamicFiltersConfig, "mt-dynamic-filters-config", never, { "lookups": { "alias": "lookups"; "required": false; "isSignal": true; }; "levelsSchema": { "alias": "levelsSchema"; "required": false; "isSignal": true; }; "levelLogs": { "alias": "levelLogs"; "required": false; "isSignal": true; }; "productType": { "alias": "productType"; "required": false; "isSignal": true; }; }, { "loadLevelLogs": "loadLevelLogs"; }, never, never, true, never>;
+}
+
+declare class ChartSettingsDrawer {
+    private dialogRef;
+    private drawerConfig;
+    readonly modal: ModalService;
+    /** The chart item signal - reactive for proper change detection */
+    readonly item: _angular_core.WritableSignal<DashboardChartItem | null>;
+    constructor();
+    /** Determine the type of manage UI to show */
+    readonly manageType: _angular_core.Signal<QuickManageType>;
+    /** Default config (full config for DefaultControlUi) */
+    readonly defaultConfig: _angular_core.Signal<{}>;
+    /** Pie chart config - note: typo "Overried" matches old implementation */
+    readonly pieConfig: _angular_core.Signal<any>;
+    /** Bar chart config */
+    readonly barConfig: _angular_core.Signal<any>;
+    /** Stack bar chart config */
+    readonly stackBarConfig: _angular_core.Signal<any>;
+    /** Snapshot bar chart config */
+    readonly snapshotBarConfig: _angular_core.Signal<any>;
+    /** Update default config */
+    onDefaultConfigChange(config: any): void;
+    /** Update pie chart config - note: typo "Overried" matches old implementation */
+    onPieConfigChange(config: any): void;
+    /** Update bar chart config */
+    onBarConfigChange(config: any): void;
+    /** Update stack bar chart config */
+    onStackBarConfigChange(config: any): void;
+    /** Update snapshot bar chart config */
+    onSnapshotBarConfigChange(config: any): void;
+    /** Apply changes and close drawer */
+    apply(): void;
+    /** Close without changes */
+    close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChartSettingsDrawer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChartSettingsDrawer, "mt-chart-settings-drawer", never, {}, {}, never, never, true, never>;
+}
+
+interface DefaultControlConfig {
+    title: string;
+    titleFontSize: number;
+    titleColor: string;
+    showSubtitle: boolean;
+    subtitle: string;
+    subtitleFontSize: number;
+    subtitleColor: string;
+    backgroundColor: string;
+    borderColor: string;
+    borderRadius: number;
+    padding: number;
+}
+declare class DefaultControlUi implements ControlValueAccessor {
+    readonly config: _angular_core.WritableSignal<DefaultControlConfig>;
+    readonly fontSizeOptions: {
+        label: string;
+        value: number;
+    }[];
+    private onChange;
+    private onTouched;
+    writeValue(value: DefaultControlConfig): void;
+    registerOnChange(fn: (value: DefaultControlConfig) => void): void;
+    registerOnTouched(fn: () => void): void;
+    updateConfig(partial: Partial<DefaultControlConfig>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DefaultControlUi, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DefaultControlUi, "mt-default-control-ui", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Pie Chart Configuration - Matches old implementation exactly
+ */
+interface PieControlConfig {
+    radius?: number;
+    thickness?: number;
+    padAngle?: number;
+    borderRadius?: number;
+    centerX?: number;
+    centerY?: number;
+    startAngle?: number;
+    endAngle?: number;
+    roseType?: boolean | 'radius' | 'area';
+    useEnhancedLegend?: boolean;
+    legendPosition?: 'left' | 'right' | 'top' | 'bottom';
+    legendVerticalAlign?: 'top' | 'middle' | 'bottom';
+    legendOrientation?: 'horizontal' | 'vertical';
+    legendType?: 'scroll' | 'plain';
+    legendFontSize?: number;
+    legendFontColor?: string;
+    legendIcon?: string;
+    labelFontSize?: number;
+    totalValueFontSize?: number;
+    labelFontColor?: string;
+    labelFormatter?: string;
+    tooltipTrigger?: 'item' | 'axis' | 'none';
+    labelPosition?: string;
+    showLabelLine?: boolean;
+    explode?: number;
+    animation?: boolean;
+    animationDuration?: number;
+    tooltipBackgroundColor?: string;
+    tooltipBorderColor?: string;
+    tooltipBorderWidth?: number;
+}
+declare class PieControlUi implements ControlValueAccessor {
+    readonly config: _angular_core.WritableSignal<PieControlConfig>;
+    readonly roseTypeOptions: ({
+        label: string;
+        value: boolean;
+    } | {
+        label: string;
+        value: string;
+    })[];
+    readonly labelPositionOptions: {
+        label: string;
+        value: string;
+    }[];
+    readonly legendPositionOptions: {
+        label: string;
+        value: string;
+    }[];
+    readonly legendVerticalAlignOptions: {
+        label: string;
+        value: string;
+    }[];
+    readonly legendOrientationOptions: {
+        label: string;
+        value: string;
+    }[];
+    readonly legendTypeOptions: {
+        label: string;
+        value: string;
+    }[];
+    readonly legendIconOptions: {
+        label: string;
+        value: string;
+    }[];
+    readonly labelFormatterOptions: {
+        label: string;
+        value: string;
+    }[];
+    readonly tooltipTriggerOptions: {
+        label: string;
+        value: string;
+    }[];
+    readonly fontSizeOptions: {
+        label: string;
+        value: number;
+    }[];
+    private onChange;
+    private onTouched;
+    writeValue(value: PieControlConfig): void;
+    registerOnChange(fn: (value: PieControlConfig) => void): void;
+    registerOnTouched(fn: () => void): void;
+    updateConfig(partial: Partial<PieControlConfig>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PieControlUi, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PieControlUi, "mt-pie-control-ui", never, {}, {}, never, never, true, never>;
+}
+
+interface BarControlConfig {
+    barWidth?: number;
+    barGap?: number;
+    barCategoryGap?: number;
+    barType?: 'bar' | 'line';
+    xAxisShow?: boolean;
+    yAxisShow?: boolean;
+    yAxisFormat?: string;
+    showCurrency?: boolean;
+    xAxisFontSize?: number;
+    yAxisFontSize?: number;
+    xAxisFontColor?: string;
+    yAxisFontColor?: string;
+    xAxisLineColor?: string;
+    yAxisLineColor?: string;
+    gridTop?: number;
+    gridBottom?: number;
+    gridLeft?: number;
+    gridRight?: number;
+    labelShow?: boolean;
+    labelPosition?: 'top' | 'left' | 'right' | 'bottom' | 'inside';
+    labelFontSize?: number;
+    labelFontColor?: string;
+    labelFormatter?: string;
+    tooltipShow?: boolean;
+    tooltipTrigger?: 'item' | 'axis' | 'none';
+    tooltipBackgroundColor?: string;
+    tooltipBorderColor?: string;
+    tooltipBorderWidth?: number;
+    borderRadius?: boolean;
+    showValueOnlyInTooltip?: boolean;
+    maxCharsPerLine?: number;
+    isGrouped?: boolean;
+}
+declare class BarControlUi implements ControlValueAccessor {
+    readonly config: _angular_core.WritableSignal<BarControlConfig>;
+    readonly barTypeOptions: {
+        label: string;
+        value: string;
+    }[];
+    readonly yAxisFormatOptions: {
+        label: string;
+        value: string;
+    }[];
+    readonly labelPositionOptions: {
+        label: string;
+        value: string;
+    }[];
+    readonly tooltipTriggerOptions: {
+        label: string;
+        value: string;
+    }[];
+    readonly labelFormatterOptions: {
+        label: string;
+        value: string;
+    }[];
+    readonly fontSizeOptions: {
+        label: string;
+        value: number;
+    }[];
+    private onChange;
+    private onTouched;
+    writeValue(value: BarControlConfig): void;
+    registerOnChange(fn: (value: BarControlConfig) => void): void;
+    registerOnTouched(fn: () => void): void;
+    updateConfig(partial: Partial<BarControlConfig>): void;
+    onYAxisFormatChange(value: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BarControlUi, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BarControlUi, "mt-bar-control-ui", never, {}, {}, never, never, true, never>;
+}
+
+interface StackBarControlConfig {
+    barWidth?: number;
+    hasLines?: boolean;
+    barType?: 'bar' | 'line';
+    xAxisLabelRotate?: number;
+    xAxisFontSize?: number;
+    yAxisShow?: boolean;
+    yAxisFormat?: {
+        type: string;
+        [key: string]: any;
+    };
+    legendPositionY?: 'top' | 'bottom';
+    legendPositionX?: 'start' | 'center' | 'end';
+    legendFontSize?: number;
+    legendFontColor?: string;
+    showLabel?: boolean;
+    labelFontSize?: number;
+    labelFontColor?: string;
+    tooltipBackgroundColor?: string;
+    tooltipBorderColor?: string;
+    tooltipBorderWidth?: number;
+    gridLeft?: string | number;
+    gridRight?: string | number;
+    gridTop?: string | number;
+    gridBottom?: string | number;
+    isStacked?: boolean;
+    borderRadius?: string | number;
+}
+declare class StackBarControlUi implements ControlValueAccessor {
+    readonly config: _angular_core.WritableSignal<StackBarControlConfig>;
+    readonly legendPositionYOptions: {
+        label: string;
+        value: string;
+    }[];
+    readonly legendPositionXOptions: {
+        label: string;
+        value: string;
+    }[];
+    readonly barTypeOptions: {
+        label: string;
+        value: string;
+    }[];
+    readonly yAxisFormatOptions: ({
+        label: string;
+        value: null;
+    } | {
+        label: string;
+        value: string;
+    })[];
+    readonly fontSizeOptions: {
+        label: string;
+        value: number;
+    }[];
+    private onChange;
+    private onTouched;
+    writeValue(value: StackBarControlConfig): void;
+    registerOnChange(fn: (value: StackBarControlConfig) => void): void;
+    registerOnTouched(fn: () => void): void;
+    updateConfig(partial: Partial<StackBarControlConfig>): void;
+    onYAxisFormatChange(formatType: string | null): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StackBarControlUi, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StackBarControlUi, "mt-stack-bar-control-ui", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Manage Item Component (Drawer)
+ *
+ * Main drawer component for configuring chart/widget items.
+ * Uses tabs to organize different configuration sections.
+ * Provides ManageItemService for state sharing between child components.
+ */
+declare class ManageItem implements OnInit {
+    private _dashboardService;
+    private _manageItemService;
+    private _dialogConfig;
+    readonly modal: ModalService;
+    ref: ModalRef<any> | null;
+    /** Input data from drawer - supports both input() and dialog data */
+    readonly data: _angular_core.InputSignal<{
+        chart?: DashboardChartItem;
+        isDialog?: boolean;
+        isNew?: boolean;
+        chartType?: ChartTypeConfig;
+        defaultSize?: {
+            cols: number;
+            rows: number;
+        };
+    } | null>;
+    /** Whether chart type is pre-selected (hides type selection) */
+    readonly hasPreselectedType: _angular_core.Signal<boolean>;
+    /** Tab options with translation keys */
+    readonly tabOptions: _angular_core.WritableSignal<{
+        label: string;
+        value: string;
+        icon: string;
+    }[]>;
+    /** Active tab */
+    readonly activeTab: _angular_core.WritableSignal<string>;
+    /** Chart configuration being edited - from service */
+    readonly config: _angular_core.Signal<ItemConfig | null>;
+    /** Chart type ID - from service */
+    readonly chartTypeId: _angular_core.Signal<string>;
+    /** Selected chart type info */
+    readonly selectedChartType: _angular_core.WritableSignal<ChartTypeConfig | null>;
+    /** Is this a dialog item */
+    readonly isDialog: _angular_core.Signal<any>;
+    /** Is this a new item */
+    readonly isNew: _angular_core.Signal<any>;
+    /** Saving state */
+    readonly saving: _angular_core.WritableSignal<boolean>;
+    /** Validation state */
+    readonly isValid: _angular_core.Signal<boolean>;
+    /** Initialize from dialog data effect */
+    private _initEffect;
+    ngOnInit(): void;
+    save(): void;
+    cancel(): void;
+    /** Update config from child components */
+    onConfigUpdate(partialConfig: Partial<ItemConfig>): void;
+    /** Update service config */
+    onServiceConfigUpdate(partialConfig: Partial<ItemConfig['serviceConfig']>): void;
+    /** Update client config */
+    onClientConfigUpdate(partialConfig: Partial<ItemConfig['clientConfig']>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ManageItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ManageItem, "mt-manage-item", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * General Settings Component
+ *
+ * Handles general chart configuration:
+ * - Chart type selection (visual grid)
+ * - Title (English & Arabic)
+ * - Component name
+ */
+declare class GeneralSettings {
+    private transloco;
+    /** Current configuration */
+    readonly config: _angular_core.InputSignal<ItemConfig | null>;
+    /** Is dialog item (hides chart type selection) */
+    readonly isDialog: _angular_core.InputSignal<boolean>;
+    /** Whether chart type is pre-selected (hides chart type selection) */
+    readonly hasPreselectedType: _angular_core.InputSignal<boolean>;
+    /** Emit config changes */
+    readonly configChange: _angular_core.OutputEmitterRef<Partial<ItemConfig>>;
+    /** Emit chart type selection */
+    readonly chartTypeChange: _angular_core.OutputEmitterRef<ChartTypeConfig>;
+    /** All available chart types */
+    readonly chartTypes: _angular_core.WritableSignal<ChartTypeConfig[]>;
+    /** Chart types filtered (not hidden) */
+    readonly chartTypesFiltered: _angular_core.Signal<ChartTypeConfig[]>;
+    /** Grouped chart types by category */
+    readonly chartTypesByCategory: _angular_core.Signal<{
+        card: ChartTypeConfig[];
+        chart: ChartTypeConfig[];
+        table: ChartTypeConfig[];
+        special: ChartTypeConfig[];
+        layout: ChartTypeConfig[];
+    }>;
+    /** Currently selected chart type */
+    readonly selectedChartType: _angular_core.Signal<ChartTypeConfig | null | undefined>;
+    /**
+     * Select a chart type
+     */
+    selectChartType(type: ChartTypeConfig): void;
+    /**
+     * Check if a chart type is selected
+     */
+    isTypeSelected(type: ChartTypeConfig): boolean;
+    /**
+     * Update title field
+     */
+    updateTitle(lang: 'en' | 'ar', value: string): void;
+    /**
+     * Update component name
+     */
+    updateComponentName(value: string): void;
+    /**
+     * Get category label
+     */
+    getCategoryLabel(category: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GeneralSettings, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GeneralSettings, "mt-general-settings", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "isDialog": { "alias": "isDialog"; "required": false; "isSignal": true; }; "hasPreselectedType": { "alias": "hasPreselectedType"; "required": false; "isSignal": true; }; }, { "configChange": "configChange"; "chartTypeChange": "chartTypeChange"; }, never, never, true, never>;
+}
+
+/**
+ * Selection module info for linking - includes properties for each selection
+ */
+interface SelectionModule {
+    selectionId: number;
+    selector: string;
+    moduleType: string;
+    moduleTypeName: string;
+    moduleName: string;
+    properties: IProperty[];
+}
+
+/**
+ * Chart Query Series
+ */
+interface ChartQuerySeries {
+    key: string;
+    color: string;
+    valueProperty: string | null;
+    aggregateFunction: string;
+    groupByProperties: string[];
+    autoStack: boolean;
+    stackProperties: string[];
+    autoStackByProperty: string | null;
+    filters: ChartQuerySeriesFilter[];
+    extraProperties: string[];
+    formula?: string;
+    showAdvancedSettings?: boolean;
+    barType?: 'bar' | 'line' | 'lineAccumulated';
+}
+/**
+ * Chart Query Series Filter
+ */
+interface ChartQuerySeriesFilter {
+    propertyKey: string | null;
+    value: any;
+    operator: string;
+}
+/**
+ * Chart Query Configuration
+ */
+interface ChartQuery {
+    categoryProperty: string;
+    series: ChartQuerySeries[];
+}
+
+/** Properties grouped by module for select with [group]="true" */
+interface PropertyGroup {
+    label: string;
+    items: IProperty[];
+}
+/**
+ * Aggregation Property Configuration
+ */
+interface AggregationProperty {
+    propertyKey: string | null;
+    aggregateFunction: string;
+    alias?: string;
+}
+/**
+ * Table Query Configuration Value
+ */
+interface TableQueryValue {
+    selectedProperties: string[];
+    AggregationProperties: AggregationProperty[];
+    lookupProperty: string;
+    PivotProperties: string[];
+}
+/**
+ * Table Query Component
+ *
+ * Handles query configuration for table/dialog chart types.
+ * Implements ControlValueAccessor for form integration.
+ */
+declare class TableQuery implements ControlValueAccessor {
+    private fb;
+    /** Available properties (flat) */
+    readonly propertiesFlat: _angular_core.InputSignal<IProperty[]>;
+    /** Properties grouped by module for grouped select */
+    readonly propertiesGrouped: _angular_core.InputSignal<PropertyGroup[]>;
+    /** Whether to use grouped select (when multiple modules) */
+    readonly useGroupedSelect: _angular_core.Signal<boolean>;
+    /** Options config for multi-select */
+    readonly optionsConfig: _angular_core.Signal<{
+        optionValue: string;
+        optionLabel: string;
+        items: IProperty[];
+    }>;
+    /** Aggregate function options */
+    readonly aggregateFunctions: {
+        value: string;
+        label: string;
+    }[];
+    /** Main form */
+    readonly queryForm: FormGroup<{
+        selectedProperties: _angular_forms.FormControl<string[] | null>;
+        AggregationProperties: FormArray<FormGroup<any>>;
+        lookupProperty: _angular_forms.FormControl<string | null>;
+        PivotProperties: _angular_forms.FormControl<string[] | null>;
+    }>;
+    /** Disabled state */
+    disabled: boolean;
+    /** ControlValueAccessor callbacks */
+    private onChange;
+    private onTouched;
+    constructor();
+    writeValue(value: TableQueryValue): void;
+    registerOnChange(fn: (value: TableQueryValue) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    validate(): ValidationErrors | null;
+    get aggregationArray(): FormArray;
+    createAggregationFormGroup(agg?: Partial<AggregationProperty>): FormGroup;
+    addAggregation(): void;
+    removeAggregation(index: number): void;
+    trackByIndex(index: number): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableQuery, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableQuery, "mt-table-query", never, { "propertiesFlat": { "alias": "propertiesFlat"; "required": false; "isSignal": true; }; "propertiesGrouped": { "alias": "propertiesGrouped"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Module properties response */
+interface ModuleProperties {
+    /** Module type (e.g., "Level") */
+    moduleName: string;
+    /** Display name for the specific selector (e.g., "Projects" for "Level:7") */
+    selectorName: string | null;
+    /** Full selector (e.g., "Level:7") */
+    selector: string;
+    moduleId?: number;
+    properties: IProperty[];
+}
+/**
+ * Query component type based on chart type and component name
+ */
+type QueryComponentType = 'general' | 'table' | 'timeline' | 'timelineMultiLevel' | 'map' | 'splitter' | 'properties' | 'snapshot' | 'phaseGate' | 'repeater' | 'none';
+/**
+ * Data Source Settings Component
+ *
+ * Comprehensive data source configuration:
+ * - Module/Data source selection via SelectionConfiguration
+ * - Source links for multiple selections via SourceLinkConfiguration
+ * - Query configuration based on chart type (GeneralQuery, TableQuery, etc.)
+ */
+declare class DataSourceSettings {
+    private dashboardService;
+    /** Current configuration */
+    readonly config: _angular_core.InputSignal<ItemConfig | null>;
+    /** Selected chart type */
+    readonly chartType: _angular_core.InputSignal<ChartTypeConfig | null>;
+    /** Emit service config changes */
+    readonly serviceConfigChange: _angular_core.OutputEmitterRef<Partial<ServiceConfig>>;
+    /** Properties grouped by module */
+    readonly modulesProperties: _angular_core.WritableSignal<ModuleProperties[]>;
+    /** Flattened properties list with grouping info */
+    readonly propertiesFlat: _angular_core.Signal<IPropertyWithGroup[]>;
+    /**
+     * Properties grouped for select field with [group]="true"
+     * Structure: [{ label: 'Projects', items: [{ name, key }, ...] }, ...]
+     * Uses selectorName for display (e.g., "Projects" instead of "Level")
+     */
+    readonly propertiesGrouped: _angular_core.Signal<{
+        label: string;
+        items: IProperty[];
+    }[]>;
+    /**
+     * Selection modules for source link configuration
+     * Built from selections with their loaded module info
+     */
+    readonly selectionModules: _angular_core.Signal<SelectionModule[]>;
+    /** Query component type based on chart type and component name */
+    readonly queryComponentType: _angular_core.Signal<QueryComponentType>;
+    /** Loading states */
+    readonly loadingProperties: _angular_core.WritableSignal<boolean>;
+    /** Tab state: 'selection' or 'customApi' */
+    readonly activeTab: _angular_core.WritableSignal<"selection" | "customApi">;
+    /** Tab options for display */
+    readonly tabOptions: {
+        id: string;
+        label: string;
+    }[];
+    /** Custom API configuration */
+    readonly customApi: _angular_core.WritableSignal<CustomApi | null>;
+    /** Internal selections state */
+    readonly selections: _angular_core.WritableSignal<ISelection[]>;
+    readonly sourceLinks: _angular_core.WritableSignal<SourceLink[]>;
+    readonly query: _angular_core.WritableSignal<any>;
+    readonly isNormalized: _angular_core.WritableSignal<boolean>;
+    readonly groupByMultiple: _angular_core.WritableSignal<string[]>;
+    /** Repeater dashboard selection */
+    readonly repeaterDashboardId: _angular_core.WritableSignal<number | null>;
+    readonly availableDashboards: _angular_core.WritableSignal<{
+        id: number;
+        name: string;
+    }[]>;
+    /** Show source links when multiple selections exist */
+    readonly showSourceLinks: _angular_core.Signal<boolean>;
+    /** Hide selection config for layout, snapshot, phaseGate types (they don't need data source selection) */
+    readonly hideSelectionConfig: _angular_core.Signal<boolean>;
+    /** Show groupByMultiple for table queries (non-report mode) */
+    readonly showGroupByMultiple: _angular_core.Signal<boolean>;
+    /**
+     * Derived signal: Extract module keys from selections for change detection
+     * Only changes when actual selectors change, not on every selection update
+     */
+    private readonly moduleKeysSignature;
+    /** Track last loaded module signature to prevent duplicate requests */
+    private lastLoadedSignature;
+    constructor();
+    /**
+     * Load properties for all selections using bulk API
+     * Single POST request to /metadata/modules/properties
+     * Enriches response with selectorName from tree data
+     */
+    loadPropertiesForSelections(selections: ISelection[]): void;
+    /**
+     * Handle selection changes
+     */
+    onSelectionsChange(selections: ISelection[]): void;
+    /**
+     * Handle module change - update selections, effect handles property loading
+     */
+    onModuleChange(event: {
+        selectionId: number;
+        selector: string;
+        selectorName?: string | null;
+    }): void;
+    /**
+     * Extract module type from selector (e.g., "Level:7" -> "Level")
+     */
+    private extractModuleTypeFromSelector;
+    /**
+     * Handle source links change
+     */
+    onSourceLinksChange(links: SourceLink[]): void;
+    /**
+     * Handle query change (general query)
+     */
+    onQueryChange(query: ChartQuery): void;
+    /**
+     * Handle table query change
+     */
+    onTableQueryChange(query: TableQuery): void;
+    /**
+     * Handle timeline query change
+     */
+    onTimelineQueryChange(query: any): void;
+    /**
+     * Handle map query change
+     */
+    onMapQueryChange(query: any): void;
+    /**
+     * Handle splitter query change
+     */
+    onSplitterQueryChange(query: any): void;
+    /**
+     * Handle properties query change
+     */
+    onPropertiesQueryChange(query: any): void;
+    /**
+     * Handle snapshot query change
+     */
+    onSnapshotQueryChange(query: any): void;
+    /**
+     * Handle groupByMultiple change
+     */
+    onGroupByMultipleChange(values: string[]): void;
+    /**
+     * Handle repeater dashboard selection
+     */
+    onRepeaterDashboardChange(dashboardId: number): void;
+    /**
+     * Handle isNormalized change
+     */
+    onIsNormalizedChange(value: boolean): void;
+    /**
+     * Handle tab change
+     */
+    onTabChange(tabId: string): void;
+    /**
+     * Handle custom API change
+     */
+    onCustomApiChange(customApi: CustomApi | null): void;
+    /**
+     * Get chart type id for query component
+     */
+    getChartTypeId(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DataSourceSettings, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DataSourceSettings, "mt-data-source-settings", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "chartType": { "alias": "chartType"; "required": false; "isSignal": true; }; }, { "serviceConfigChange": "serviceConfigChange"; }, never, never, true, never>;
+}
+
+/** Shadow configuration */
+interface ShadowConfig {
+    x: number;
+    y: number;
+    blur: number;
+    spread: number;
+    color: string;
+}
+/** Override label configuration */
+interface OverrideLabel {
+    en: string;
+    ar: string;
+}
+/** Card style configuration */
+interface CardStyleConfig {
+    borderRadius?: number;
+    backgroundColor?: string;
+    shadows?: ShadowConfig[];
+}
+/** Header card configuration */
+interface HeaderCardConfig {
+    isHeaderCentered?: boolean;
+    isHeaderHidden?: boolean;
+    headerColor?: string;
+    headerFontSize?: number;
+}
+/** Label center configuration */
+interface LabelCenterConfig {
+    hide?: boolean;
+    text?: {
+        en?: string;
+        ar?: string;
+    };
+}
+/** Sort data bars configuration */
+interface SortDataBarsConfig {
+    enable?: boolean;
+    sortBy?: string;
+    order?: 'asc' | 'desc' | string;
+    direction?: 'asc' | 'desc' | string;
+}
+/** Card info configuration */
+interface CardInfoConfig {
+    show?: boolean;
+    value?: any;
+    type?: string;
+}
+/** Format configuration */
+interface FormatConfig {
+    type?: string | null;
+    showCurrency?: boolean;
+    handleLang?: boolean;
+    customText?: string | null;
+    customDateFormat?: string | null;
+    showCurrencyTooltip?: boolean;
+    hideSuffixes?: boolean;
+}
+/** Table format configuration */
+interface TableFormatConfig {
+    thTextColor?: string | null;
+    thBackgroundColor?: string | null;
+    tdTextColor?: string | null;
+    groupBackgroundColor?: string | null;
+    groupTextColor?: string | null;
+    thFontBold?: boolean;
+    tdFontBold?: boolean;
+    thFontSize?: number | null;
+    tdFontSize?: number | null;
+    hideTableSubheader?: boolean;
+    disableCurrencyFormat?: boolean;
+    showPercentageAsProgressBar?: boolean;
+    showPercentageStatus?: boolean;
+    hiddenColumns?: string[];
+    sortConfig?: {
+        column: string;
+        direction: 'asc' | 'desc';
+    };
+}
+/** Color condition configuration */
+interface ColorCondition {
+    color: string;
+    type: 'equal' | 'greaterThan' | 'greaterThanOrEqual' | 'lessThan' | 'lessThanOrEqual' | 'between';
+    value1?: number;
+    value2?: number;
+    labelEn?: string;
+    labelAr?: string;
+}
+/** Color conditions by bar index */
+interface ColorConditionsByIndex {
+    [key: number]: ColorCondition[];
+}
+/** Ring gauge configuration */
+interface RingGaugeConfig {
+    centerProperty?: string;
+    statusProperty?: string;
+    hiddenProperties?: string[];
+}
+/** Order configuration */
+interface OrderConfig {
+    order?: string[];
+    operation?: string;
+    orderBy?: string;
+}
+/** Card list configuration */
+interface CardListConfig {
+    hideProperties?: string[];
+}
+/** Property translation entry */
+interface PropertyTranslation {
+    ar: string;
+    en: string;
+}
+/** Property translations map */
+interface PropertyTranslationsMap {
+    [key: string]: PropertyTranslation;
+}
+/** Property color entry */
+interface PropertyColorEntry {
+    selectedKey: string;
+}
+/** Property colors map */
+interface PropertyColorsMap {
+    [key: string]: PropertyColorEntry;
+}
+/** Props config as index item */
+interface PropsConfigAsIndexItem {
+    width?: string;
+    colorAsProperty?: string;
+    hidden?: boolean;
+    border?: string[];
+}
+/** Format X-Axis configuration */
+interface FormatXAxisConfig {
+    type?: string | null;
+    shortFormate?: boolean;
+}
+/** Extra column from lookup configuration */
+interface ExtraColumnFromLookupConfig {
+    extraCoulmnFromLookup?: boolean;
+    lookupId?: number | null;
+    groupedBy?: string | null;
+    propKey?: string | null;
+}
+/** Timeline header colors config (single) */
+interface TimelineHeaderSingleConfig {
+    bgColor?: string;
+    color?: string;
+}
+/**
+ * Display Settings Component
+ *
+ * Comprehensive visual/display configuration with chart-type-aware field visibility.
+ * Shows only relevant settings based on the selected chart type.
+ */
+declare class DisplaySettings {
+    /** Current configuration */
+    readonly config: _angular_core.InputSignal<ItemConfig | null>;
+    /** Selected chart type */
+    readonly chartType: _angular_core.InputSignal<ChartTypeConfig | null>;
+    /** Available properties (for property-based configs) */
+    readonly availableProperties: _angular_core.InputSignal<any[]>;
+    /** Selected properties from query */
+    readonly selectedProperties: _angular_core.InputSignal<string[]>;
+    /** Available lookups for extra column from lookup */
+    readonly lookups: _angular_core.InputSignal<any[]>;
+    /** Emit client config changes */
+    readonly clientConfigChange: _angular_core.OutputEmitterRef<Partial<ClientConfig>>;
+    /** Color condition expansion state */
+    readonly colorConditionExpanded: _angular_core.WritableSignal<Record<number, boolean>>;
+    /** Property translations paste state */
+    readonly showPropertyTranslationsPaste: _angular_core.WritableSignal<boolean>;
+    readonly propertyTranslationsPasteText: _angular_core.WritableSignal<string>;
+    readonly propertyTranslationsPasteError: _angular_core.WritableSignal<string>;
+    /** Property colors paste state */
+    readonly showPropertyColorsPaste: _angular_core.WritableSignal<boolean>;
+    readonly propertyColorsPasteText: _angular_core.WritableSignal<string>;
+    readonly propertyColorsPasteError: _angular_core.WritableSignal<string>;
+    /**
+     * Chart type to fields mapping
+     * Each chart type maps to comma-separated list of visible fields
+     */
+    private readonly chartTypeFieldsMap;
+    /** Computed fields to show based on chart type */
+    readonly fieldsToShow: _angular_core.Signal<string>;
+    /** Check if a field should be shown */
+    shouldShowField(fieldName: string): boolean;
+    /** Position options */
+    readonly positionOptions: {
+        label: string;
+        value: string;
+    }[];
+    /** Legend position options */
+    readonly legendPositionOptions: {
+        label: string;
+        value: string;
+    }[];
+    /** Legend icon type options */
+    readonly legendIconOptions: {
+        label: string;
+        value: string;
+    }[];
+    /** Label position options */
+    readonly labelPositionOptions: {
+        label: string;
+        value: string;
+    }[];
+    /** Map options */
+    readonly mapOptions: {
+        label: string;
+        value: string;
+    }[];
+    /** Order type options */
+    readonly orderTypeOptions: {
+        label: string;
+        value: string;
+    }[];
+    /** Order operation options */
+    readonly orderOperationOptions: {
+        label: string;
+        value: string;
+    }[];
+    /** Border options for props config */
+    readonly borderOptions: {
+        label: string;
+        value: string;
+    }[];
+    /** Color condition type options */
+    readonly colorConditionTypeOptions: {
+        label: string;
+        value: string;
+    }[];
+    /** Format type options */
+    readonly formatTypeOptions: ({
+        label: string;
+        value: null;
+    } | {
+        label: string;
+        value: string;
+    })[];
+    /** Format X-Axis type options */
+    readonly formatXAxisTypeOptions: ({
+        label: string;
+        value: null;
+    } | {
+        label: string;
+        value: string;
+    })[];
+    /** Default color palette */
+    readonly defaultColorPalette: string[];
+    /** Current style config */
+    readonly styleConfig: _angular_core.Signal<StyleConfig>;
+    /** Current config as type */
+    readonly configAsType: _angular_core.Signal<{
+        [key: string]: any;
+        icon?: string;
+        breadcrumb?: any[];
+    }>;
+    /** Current card info */
+    readonly cardInfo: _angular_core.Signal<CardInfoConfig>;
+    /** Current header card config */
+    readonly headerCardConfig: _angular_core.Signal<HeaderCardConfig>;
+    /** Current card style config */
+    readonly cardStyleConfig: _angular_core.Signal<CardStyleConfig>;
+    /** Current label config */
+    readonly labelConfig: _angular_core.Signal<{
+        show?: boolean;
+        showTotalInTop?: boolean;
+        position?: string;
+    }>;
+    /** Current legend config */
+    readonly legendConfig: _angular_core.Signal<{
+        show?: boolean;
+        position?: string;
+        iconType?: string;
+    }>;
+    /** Current label center config */
+    readonly labelCenterConfig: _angular_core.Signal<LabelCenterConfig>;
+    /** Current sort data bars config */
+    readonly sortDataBarsConfig: _angular_core.Signal<SortDataBarsConfig>;
+    /** Current override labels */
+    readonly overrideLabels: _angular_core.Signal<OverrideLabel[]>;
+    /** Current default colors */
+    readonly defaultColors: _angular_core.Signal<string[]>;
+    /** Current order config */
+    readonly orderConfig: _angular_core.Signal<any>;
+    /** Current format config */
+    readonly formatConfig: _angular_core.Signal<FormatConfig>;
+    /** Current table format config */
+    readonly tableFormatConfig: _angular_core.Signal<TableFormatConfig>;
+    /** Current color by condition */
+    readonly colorByCondition: _angular_core.Signal<ColorConditionsByIndex>;
+    /** Current ring gauge config */
+    readonly ringGaugeConfig: _angular_core.Signal<RingGaugeConfig>;
+    /** Current card list config */
+    readonly cardListConfig: _angular_core.Signal<CardListConfig>;
+    /** Props config as index */
+    readonly propsConfigAsIndex: _angular_core.Signal<PropsConfigAsIndexItem[]>;
+    /** Property translations map */
+    readonly propertyTranslations: _angular_core.Signal<PropertyTranslationsMap>;
+    /** Property colors map */
+    readonly propertyColors: _angular_core.Signal<PropertyColorsMap>;
+    /** Format X-Axis config */
+    readonly formatXAxisConfig: _angular_core.Signal<FormatXAxisConfig>;
+    /** Table columns config (extra column from lookup) */
+    readonly tableColumnsConfig: _angular_core.Signal<ExtraColumnFromLookupConfig>;
+    /** Timeline header colors config (single object for old format) */
+    readonly timelineHeaderColorsSingle: _angular_core.Signal<TimelineHeaderSingleConfig>;
+    /** Toggle association */
+    readonly toggleAssociation: _angular_core.Signal<boolean>;
+    /** Selected properties resolved from input or config */
+    readonly resolvedSelectedProperties: _angular_core.Signal<any[]>;
+    /** Available properties resolved from input or selected properties */
+    readonly resolvedAvailableProperties: _angular_core.Signal<any[]>;
+    /** Available properties as options */
+    readonly propertyOptions: _angular_core.Signal<{
+        label: any;
+        value: any;
+    }[]>;
+    /** Available translation options (exclude used) */
+    readonly availableTranslationOptions: _angular_core.Signal<{
+        label: any;
+        value: any;
+    }[]>;
+    /** Available color options (exclude used) */
+    readonly availableColorOptions: _angular_core.Signal<{
+        label: any;
+        value: any;
+    }[]>;
+    /** All property options (full list) */
+    readonly allPropertyKeyOptions: _angular_core.Signal<{
+        label: any;
+        value: any;
+    }[]>;
+    /** Ring gauge hidden properties options */
+    readonly ringGaugeHiddenOptions: _angular_core.Signal<{
+        label: any;
+        value: any;
+    }[]>;
+    /** Update style config property */
+    updateStyleConfig(key: keyof StyleConfig | string, value: any): void;
+    /** Update configAsType property */
+    updateConfigAsType(key: string, value: any): void;
+    /** Update nested configAsType property */
+    updateNestedConfigAsType(parentKey: string, key: string, value: any): void;
+    /** Update header card config */
+    updateHeaderCardConfig(key: keyof HeaderCardConfig, value: any): void;
+    /** Update legend settings */
+    updateLegend(key: string, value: unknown): void;
+    /** Update label settings */
+    updateLabel(key: string, value: unknown): void;
+    /** Update label center config */
+    updateLabelCenterConfig(key: string, value: any): void;
+    /** Update label center text */
+    updateLabelCenterText(lang: 'en' | 'ar', value: string): void;
+    /** Update card style config */
+    updateCardStyleConfig(key: keyof CardStyleConfig, value: any): void;
+    /** Update sort data bars config */
+    updateSortDataBarsConfig(key: string, value: any): void;
+    /** Update card info config */
+    updateCardInfoConfig(key: string, value: any): void;
+    /** Update border top visibility */
+    updateBorderTopShow(show: boolean): void;
+    /** Update border top color */
+    updateBorderTopColor(color: string): void;
+    /** Update map type */
+    updateMapType(value: string): void;
+    /** Add a new shadow */
+    addShadow(): void;
+    /** Remove a shadow */
+    removeShadow(index: number): void;
+    /** Update a shadow property */
+    updateShadow(index: number, key: keyof ShadowConfig, value: any): void;
+    /** Add override label */
+    addOverrideLabel(): void;
+    /** Remove override label */
+    removeOverrideLabel(index: number): void;
+    /** Update override label */
+    updateOverrideLabel(index: number, lang: 'en' | 'ar', value: string): void;
+    /** Add a default color */
+    addDefaultColor(color: string): void;
+    /** Remove a default color */
+    removeDefaultColor(index: number): void;
+    /** Update a default color */
+    updateDefaultColor(index: number, color: string): void;
+    trackByIndex(index: number): number;
+    /** Update format config */
+    updateFormatConfig(key: keyof FormatConfig, value: any): void;
+    /** Update table format config */
+    updateTableFormatConfig(key: keyof TableFormatConfig, value: any): void;
+    /** Update table format sort config */
+    updateTableFormatSortConfig(key: 'column' | 'direction', value: string): void;
+    /** Reset table format to default */
+    resetTableFormat(): void;
+    /** Get color condition indexes */
+    getColorConditionIndexes(): number[];
+    /** Check if a bar index is expanded */
+    isColorConditionExpanded(index: number): boolean;
+    /** Toggle bar index expansion */
+    toggleColorConditionExpanded(index: number): void;
+    /** Add bar index for color conditions */
+    addColorConditionIndex(): void;
+    /** Remove bar index */
+    removeColorConditionIndex(index: number): void;
+    /** Add condition to bar index */
+    addColorCondition(index: number): void;
+    /** Remove condition from bar index */
+    removeColorCondition(index: number, conditionIndex: number): void;
+    /** Update color condition */
+    updateColorCondition(index: number, conditionIndex: number, key: keyof ColorCondition, value: any): void;
+    /** Update ring gauge config */
+    updateRingGaugeConfig(key: keyof RingGaugeConfig, value: any): void;
+    /** Update card list hide properties */
+    updateCardListHideProperties(properties: string[]): void;
+    /** Add props config item */
+    addPropsConfigItem(): void;
+    /** Remove props config item */
+    removePropsConfigItem(index: number): void;
+    /** Update props config item */
+    updatePropsConfigItem(index: number, key: keyof PropsConfigAsIndexItem, value: any): void;
+    /** Update order config field */
+    updateOrderConfig(key: keyof OrderConfig, value: any): void;
+    /** Add order item */
+    addOrderItem(): void;
+    /** Remove order item */
+    removeOrderItem(index: number): void;
+    /** Update order item */
+    updateOrderItem(index: number, value: string): void;
+    /** Move order item up */
+    moveOrderItemUp(index: number): void;
+    /** Move order item down */
+    moveOrderItemDown(index: number): void;
+    /** Get property translation keys */
+    getPropertyTranslationKeys(): string[];
+    /** Add property translation */
+    addPropertyTranslation(propertyKey: string): void;
+    /** Remove property translation */
+    removePropertyTranslation(propertyKey: string): void;
+    /** Update property translation */
+    updatePropertyTranslation(propertyKey: string, lang: 'ar' | 'en', value: string): void;
+    /** Get property color keys */
+    getPropertyColorKeys(): string[];
+    /** Add property color */
+    addPropertyColor(propertyKey: string): void;
+    /** Copy property translations */
+    copyPropertyTranslations(): void;
+    /** Toggle property translations paste area */
+    togglePropertyTranslationsPaste(): void;
+    /** Apply pasted property translations */
+    applyPropertyTranslationsPaste(): void;
+    /** Remove property color */
+    removePropertyColor(propertyKey: string): void;
+    /** Update property color */
+    updatePropertyColor(propertyKey: string, selectedKey: string): void;
+    /** Copy property colors */
+    copyPropertyColors(): void;
+    /** Toggle property colors paste area */
+    togglePropertyColorsPaste(): void;
+    /** Apply pasted property colors */
+    applyPropertyColorsPaste(): void;
+    /** Update format X-Axis config */
+    updateFormatXAxisConfig(key: keyof FormatXAxisConfig, value: any): void;
+    /** Update table columns config */
+    updateTableColumnsConfig(key: keyof ExtraColumnFromLookupConfig, value: any): void;
+    /** Update timeline header colors (single config) */
+    updateTimelineHeaderColorSingle(key: 'bgColor' | 'color', value: string): void;
+    /** Update toggle association */
+    updateToggleAssociation(value: boolean): void;
+    /** Selected property for adding translations */
+    readonly selectedPropertyForTranslation: _angular_core.WritableSignal<string>;
+    /** Selected property for adding colors */
+    readonly selectedPropertyForColor: _angular_core.WritableSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DisplaySettings, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DisplaySettings, "mt-display-settings", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "chartType": { "alias": "chartType"; "required": false; "isSignal": true; }; "availableProperties": { "alias": "availableProperties"; "required": false; "isSignal": true; }; "selectedProperties": { "alias": "selectedProperties"; "required": false; "isSignal": true; }; "lookups": { "alias": "lookups"; "required": false; "isSignal": true; }; }, { "clientConfigChange": "clientConfigChange"; }, never, never, true, never>;
+}
+
+/** Action type option */
+interface ActionTypeOption {
+    readonly label: string;
+    readonly value: string;
+    readonly icon: string;
+}
+/** Trigger option */
+interface TriggerOption {
+    readonly label: string;
+    readonly value: string;
+    readonly icon: string;
+}
+/** Dynamic/Static key pair */
+interface KeyPair {
+    propertyKey: string;
+    propertyValue: string;
+}
+/**
+ * Actions Settings Component
+ *
+ * Handles chart action configuration:
+ * - Click actions (open dialog, navigate, custom function)
+ * - Trigger types (click, double-click, hover)
+ * - Action configuration
+ */
+declare class ActionsSettings {
+    /** Current configuration */
+    readonly config: _angular_core.InputSignal<ItemConfig | null>;
+    /** Emit client config changes */
+    readonly clientConfigChange: _angular_core.OutputEmitterRef<Partial<ClientConfig>>;
+    /** Action type options - using valid icons from icons.json */
+    readonly actionTypeOptions: readonly ActionTypeOption[];
+    /** Trigger type options - using valid icons from icons.json */
+    readonly triggerOptions: readonly TriggerOption[];
+    /** Current actions list */
+    readonly actions: _angular_core.Signal<ActionConfig[]>;
+    /**
+     * Get current actions array safely
+     */
+    private getCurrentActions;
+    /**
+     * Emit updated actions
+     */
+    private emitActions;
+    /**
+     * Get action at index safely
+     */
+    private getActionAt;
+    /**
+     * Add a new action
+     */
+    addAction(): void;
+    /**
+     * Remove an action
+     */
+    removeAction(index: number): void;
+    /**
+     * Duplicate an action
+     */
+    duplicateAction(index: number): void;
+    /**
+     * Update an action property
+     */
+    updateAction<K extends keyof ActionConfig>(index: number, key: K, value: ActionConfig[K]): void;
+    /**
+     * Update action config object
+     */
+    updateActionConfig(index: number, configKey: string, value: unknown): void;
+    /**
+     * Move action up in the list
+     */
+    moveActionUp(index: number): void;
+    /**
+     * Move action down in the list
+     */
+    moveActionDown(index: number): void;
+    /**
+     * Get action type label
+     */
+    getActionTypeLabel(actionType: string): string;
+    /**
+     * Get trigger type label
+     */
+    getTriggerLabel(trigger: string): string;
+    /**
+     * Add a dynamic key to action
+     */
+    addDynamicKey(actionIndex: number): void;
+    /**
+     * Remove a dynamic key from action
+     */
+    removeDynamicKey(actionIndex: number, keyIndex: number): void;
+    /**
+     * Update a dynamic key
+     */
+    updateDynamicKey(actionIndex: number, keyIndex: number, field: keyof KeyPair, value: string): void;
+    /**
+     * Add a static key to action
+     */
+    addStaticKey(actionIndex: number): void;
+    /**
+     * Remove a static key from action
+     */
+    removeStaticKey(actionIndex: number, keyIndex: number): void;
+    /**
+     * Update a static key
+     */
+    updateStaticKey(actionIndex: number, keyIndex: number, field: keyof KeyPair, value: string): void;
+    /**
+     * Track by action id for ngFor
+     */
+    trackByActionId(_index: number, action: ActionConfig): string;
+    /**
+     * Track by index helper
+     */
+    trackByIndex(index: number): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ActionsSettings, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ActionsSettings, "mt-actions-settings", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; }, { "clientConfigChange": "clientConfigChange"; }, never, never, true, never>;
+}
+
+/**
+ * Chart Viewer Component
+ *
+ * Simple preview component that wraps dashboard-item.
+ * Used in manage-item to show live preview of the chart being configured.
+ */
+declare class ChartViewer {
+    /** Chart configuration */
+    readonly config: _angular_core.InputSignal<ItemConfig | null>;
+    /** Chart type ID */
+    readonly chartTypeId: _angular_core.InputSignal<string>;
+    /** Loading state for refresh */
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    /** Refresh the preview */
+    refresh(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChartViewer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChartViewer, "mt-chart-viewer", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "chartTypeId": { "alias": "chartTypeId"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Filter items by group ID
+ *
+ * Returns items that belong to a specific group, sorted by orderInGroup
+ */
+declare class FilterByGroupPipe implements PipeTransform {
+    transform(items: DashboardChartItem[], groupId?: string): DashboardChartItem[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FilterByGroupPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<FilterByGroupPipe, "filterByGroup", true>;
+}
+
+/**
+ * Get dialog actions for a chart
+ *
+ * Returns menu items for dialog management (add, edit, delete)
+ * Used in the "Advanced" popover menu
+ */
+declare class GetChartActionsPipe implements PipeTransform {
+    private transloco;
+    transform(chart: DashboardChartItem, context: ChartActionsContext): MTMenuItem[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GetChartActionsPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<GetChartActionsPipe, "getChartActions", true>;
+}
+
+/**
+ * Deep clone an object
+ */
+declare function cloneDeep<T>(obj: T): T;
+
+export { ActionsSettings, BarChartHandler, BarControlUi, CHART_TYPES, CardContentComponent, CardFilterComponent, ChartCardComponent, ChartDataService, ChartSettingsDrawer, ChartViewer, ComparisonChartHandler, DashboardBuilder, DashboardBuilderService, DashboardItem, DashboardItemStoreService, DashboardList, DashboardStoreService, DashboardViewer, DataSourceSettings, DefaultControlUi, DisplaySettings, DynamicFiltersConfig, EChartComponent, EntityInfoComponent, EntityPreviewCardComponent, FilterByGroupPipe, GaugeChartHandler, GeneralSettings, GetChartActionsPipe, HTTPMethod, HeaderCardComponent, LevelCardHandler, LevelCardListComponent, LineChartHandler, ListStatisticCardComponent, ManageBreadcrumb, ManageFilterOnPage, ManageItem, ManageItemService, ManagePages, MapChartHandler, OverviewCardHandler, PhaseGateStepperHandler, PieChartHandler, PieControlUi, RingGaugeChartHandler, SPlusChartHandler, SkeletonCardComponent, SnapshotHandler, SplitterChartHandler, StackBarChartHandler, StackBarControlUi, StatisticCardComponent, TableCardComponent, TableViewHandler, TimelineHandler, addCommasToNumber, axisFormatters, cloneDeep, createAxisFormatter, createTooltipFormatter, dynamicReorder, dynamicTextReplace, formatCurrency, formatDate, formatNumber, formatPercentage, formatValue, formatWordsUnderBar, generalConfiguration, getColorFromConditions, getLanguageCode, getLocalizedTitle, getNestedData, groupDatesByYearAndMonth, handleFilterForCard, handleFilterForSnapshot, handleFiltersForCustom, isMobilePlatform, sortChartData, sortDataTableView, switchAllKeysSmall, switchAllKeysToLower };
+export type { ActionConfig, ApiResponse, BarChartData, BreadcrumbItem, BulkLinkChartRequest, BulkLinkChartResponse, BulkPropertiesRequest, BulkPropertiesResponse, BulkPropertiesResponseItem, BulkPropertyRequestItem, CardBorderStyleConfig, CardStyleConfig$1 as CardStyleConfig, ChartActionEvent, ChartActionsContext, ChartData, ChartDataHandled, ChartLabel, ChartLinkConfiguration, ChartTypeConfig, ClientConfig, ComponentType, CustomApi, DashboardChartItem, DashboardDialogItem, DashboardItemStore, DashboardListEvent, DashboardPage, DisplayConfig, EChartSeriesItem, ExcelSheet, FilterConfig, FilterOption, GroupedModuleOption, HandleAction, HeaderCardConfig$1 as HeaderCardConfig, IModule, IModuleType, IProperty, IPropertyWithGroup, ISelection, ItemConfig, LevelCardData, LevelCardProperty, LinkChartRequest, LocalizedName, ModuleItem, ModuleSelectOption, ModuleType, ModuleValue, ModulesTreeRequest, ModulesTreeResponse, PhaseGateProperty, PhaseGateStep, PieChartData, PropertiesResponse, PropertyItem$1 as PropertyItem, PropertyItemOption, PropertyItemsResponse, QuickManageType, Report, ReportChartLink, ReportDashboardConfig, ReportExcelConfig, ReportType, ReportUrl, RequestType, SelectionFilter, ServiceConfig, ServiceItem, SourceLink, StatisticCardData, StyleConfig, TableColumn$1 as TableColumn, TableViewData, TimelineData, TimelineItem, UnlinkChartRequest };