@meshmakers/octo-meshboard 3.3.390

package/types/meshmakers-octo-meshboard.d.ts

@@ -0,0 +1,4081 @@
+import { ProcessWidgetSpecificConfig } from '@meshmakers/octo-process-diagrams';
+import * as _angular_core from '@angular/core';
+import { Signal, OnInit, EventEmitter, Type, OnChanges, SimpleChanges, OnDestroy, EnvironmentProviders, InjectionToken } from '@angular/core';
+import { Observable, Subject } from 'rxjs';
+import { EntitySelectDataSource, EntitySelectResult } from '@meshmakers/shared-services';
+import * as i1 from '@meshmakers/shared-ui';
+import { EntitySelectDialogDataSource, ColumnDefinition, DialogFetchOptions, DialogFetchResult, EntitySelectInputComponent, FetchDataOptions, FetchResultTyped, TableColumn as TableColumn$1, HasUnsavedChanges, TimeRangeSelection as TimeRangeSelection$1, TimeRange } from '@meshmakers/shared-ui';
+import * as _meshmakers_octo_services from '@meshmakers/octo-services';
+import { Exact, Scalars, InputMaybe, SearchFilterDto, FieldFilterDto, SortDto, CkTypeSelectorItem, AttributeItem, TenantIdProvider } from '@meshmakers/octo-services';
+export { TENANT_ID_PROVIDER, TenantIdProvider } from '@meshmakers/octo-services';
+import * as Apollo from 'apollo-angular';
+import { ControlValueAccessor } from '@angular/forms';
+import { CkTypeSelectorInputComponent, FieldFilterItem, FilterVariable, PropertyGridItem, PropertyGridConfig, OctoGraphQlDataSource, FieldFilterEditorComponent } from '@meshmakers/octo-ui';
+import * as _meshmakers_octo_meshboard from '@meshmakers/octo-meshboard';
+import * as _progress_kendo_svg_icons from '@progress/kendo-svg-icons';
+import { SVGIcon } from '@progress/kendo-svg-icons';
+
+/**
+ * Mapping from diagram exposed property to runtime data source
+ *
+ * @example
+ * ```typescript
+ * // Map 'level' property to entity attribute
+ * const mapping: DiagramPropertyMapping = {
+ *   propertyId: 'level',
+ *   sourceType: 'attribute',
+ *   sourcePath: 'tankLevel'
+ * };
+ *
+ * // Map 'temperature' property to query column
+ * const mapping2: DiagramPropertyMapping = {
+ *   propertyId: 'temperature',
+ *   sourceType: 'column',
+ *   sourcePath: 'current_temp'
+ * };
+ * ```
+ */
+interface DiagramPropertyMapping {
+    /**
+     * The ID of the exposed property from the diagram's transformProperties
+     */
+    propertyId: string;
+    /**
+     * The source type for the property value
+     * - 'attribute': Value from entity attribute path
+     * - 'column': Value from query result column
+     */
+    sourceType: 'attribute' | 'column';
+    /**
+     * The path to the source value
+     * - For 'attribute': entity attribute path (e.g., 'tankLevel', 'sensors.temperature')
+     * - For 'column': query result column name (e.g., 'avg_temperature')
+     */
+    sourcePath: string;
+    /**
+     * Optional expression for value transformation/normalization.
+     * Uses expr-eval syntax with 'value' as the input variable.
+     *
+     * @example
+     * ```typescript
+     * // Pass through raw value
+     * expression: 'value'
+     *
+     * // Normalize 0-100 to 0-1
+     * expression: 'value / 100'
+     *
+     * // Clamp to range
+     * expression: 'clamp(value, 0, 100)'
+     *
+     * // Linear interpolation
+     * expression: 'lerp(value, 0, 4096, 0, 100)'
+     *
+     * // Boolean threshold
+     * expression: 'value > 50 ? 1 : 0'
+     * ```
+     */
+    expression?: string;
+}
+/**
+ * Data binding mode for Process Widget
+ * - 'none': No data binding (static diagram)
+ * - 'runtimeEntity': Bind to a runtime entity
+ * - 'persistentQuery': Bind to a persistent query
+ */
+type ProcessDataBindingMode = 'none' | 'runtimeEntity' | 'persistentQuery';
+/**
+ * Complete Process Widget configuration for MeshBoard integration
+ *
+ * Extends the base WidgetConfig with process-specific settings.
+ *
+ * @example
+ * ```typescript
+ * const widgetConfig: ProcessWidgetConfig = {
+ *   id: 'widget-1',
+ *   type: 'process',
+ *   title: 'Water Treatment',
+ *   col: 1,
+ *   row: 1,
+ *   colSpan: 4,
+ *   rowSpan: 3,
+ *   dataSource: { type: 'static', data: null },
+ *   processDiagramRtId: '123-456-789',
+ *   fitToBounds: true,
+ *   dataBindingMode: 'runtimeEntity',
+ *   bindingCkTypeId: 'System/Tank',
+ *   bindingRtId: 'tank-001'
+ * };
+ * ```
+ */
+interface ProcessWidgetConfig extends WidgetConfig, ProcessWidgetSpecificConfig {
+    type: 'process';
+    /**
+     * Data binding mode (optional, defaults to 'none')
+     */
+    dataBindingMode?: ProcessDataBindingMode;
+    /**
+     * CK Type ID for runtime entity binding
+     * Required when dataBindingMode is 'runtimeEntity'
+     */
+    bindingCkTypeId?: string;
+    /**
+     * Runtime ID of the entity to bind to
+     * Optional - if not set, query will return all entities of the type
+     */
+    bindingRtId?: string;
+    /**
+     * Runtime ID of the persistent query
+     * Required when dataBindingMode is 'persistentQuery'
+     */
+    bindingQueryRtId?: string;
+    /**
+     * Display name of the persistent query (for UI)
+     */
+    bindingQueryName?: string;
+    /**
+     * Field filters applied to the data binding query
+     * Works with both runtimeEntity and persistentQuery modes
+     */
+    bindingFilters?: WidgetFilterConfig[];
+    /**
+     * Mappings from diagram exposed properties to runtime data sources.
+     * Each mapping connects a diagram's transformProperty to either an
+     * entity attribute path or a query result column.
+     *
+     * @example
+     * ```typescript
+     * propertyMappings: [
+     *   { propertyId: 'level', sourceType: 'attribute', sourcePath: 'tankLevel' },
+     *   { propertyId: 'temp', sourceType: 'column', sourcePath: 'avg_temperature' }
+     * ]
+     * ```
+     */
+    propertyMappings?: DiagramPropertyMapping[];
+}
+
+/**
+ * MeshBoard Widget Models
+ * Defines the interfaces for MeshBoard widgets and their data sources
+ */
+/**
+ * All supported data source types
+ */
+type DataSourceType = 'runtimeEntity' | 'persistentQuery' | 'aggregation' | 'serviceCall' | 'constructionKitQuery' | 'static' | 'repeaterQuery';
+/**
+ * Base interface for all data sources
+ */
+interface WidgetDataSource {
+    type: DataSourceType;
+}
+/**
+ * Data source that fetches a single runtime entity by ID
+ */
+interface RuntimeEntityDataSource extends WidgetDataSource {
+    type: 'runtimeEntity';
+    ckTypeId?: string;
+    rtId?: string;
+    attributePaths?: string[];
+    includeAssociations?: boolean;
+}
+/**
+ * Static data source for demo/testing
+ */
+interface StaticDataSource extends WidgetDataSource {
+    type: 'static';
+    data: unknown;
+}
+/**
+ * Data source that executes a persistent query by its rtId
+ */
+interface PersistentQueryDataSource extends WidgetDataSource {
+    type: 'persistentQuery';
+    /** The rtId of the persistent query to execute */
+    queryRtId: string;
+    /** Display name of the query (for UI) */
+    queryName?: string;
+}
+/**
+ * Aggregation types supported
+ */
+type AggregationType = 'count' | 'sum' | 'avg' | 'min' | 'max';
+/**
+ * Single aggregation query configuration
+ */
+interface AggregationQuery {
+    /** Unique ID to reference this query result */
+    id: string;
+    /** The CK type to aggregate (e.g., 'ConstructionKit/CkType') */
+    ckTypeId: string;
+    /** Type of aggregation to perform */
+    aggregation: AggregationType;
+    /** Attribute to aggregate (required for sum/avg/min/max) */
+    attribute?: string;
+    /** Optional filter expression (deprecated, use filters instead) */
+    filter?: string;
+    /** Field filters for the aggregation query */
+    filters?: WidgetFilterConfig[];
+}
+/**
+ * Data source that performs aggregation queries (count, sum, avg, etc.)
+ */
+interface AggregationDataSource extends WidgetDataSource {
+    type: 'aggregation';
+    queries: AggregationQuery[];
+}
+/**
+ * Service call types for status/health checks
+ */
+type ServiceCallType = 'modelAvailable' | 'healthCheck';
+/**
+ * Data source that calls a service for status information
+ */
+interface ServiceCallDataSource extends WidgetDataSource {
+    type: 'serviceCall';
+    /** Type of service call */
+    callType: ServiceCallType;
+    /** Model name for 'modelAvailable' check */
+    modelName?: string;
+    /** Service type for 'healthCheck' */
+    serviceType?: 'identity' | 'asset-repository' | 'bot' | 'communication-controller' | 'mesh-adapter' | 'custom';
+    /** Custom endpoint URL for custom health checks */
+    customEndpoint?: string;
+}
+/**
+ * Construction Kit query targets
+ */
+type CkQueryTarget = 'models' | 'types' | 'attributes' | 'associationRoles' | 'enums' | 'records';
+/**
+ * Data source that queries Construction Kit data
+ * Supports grouping for chart widgets (e.g., models grouped by state)
+ */
+interface ConstructionKitQueryDataSource extends WidgetDataSource {
+    type: 'constructionKitQuery';
+    /** What to query from Construction Kit */
+    queryTarget: CkQueryTarget;
+    /** Field to group results by (for charts) */
+    groupBy?: string;
+    /** Field to use as value (for aggregations) */
+    valueField?: string;
+    /** Field to use as category/label */
+    categoryField?: string;
+}
+/**
+ * Data source for repeating widgets (Widget Group).
+ * Fetches multiple items and renders a child widget for each.
+ * Supports two modes:
+ * 1. Query Mode: Execute a persistent query and get rows
+ * 2. Entity Mode: Load entities by CK type with optional filters
+ */
+interface RepeaterQueryDataSource extends WidgetDataSource {
+    type: 'repeaterQuery';
+    /** Execute a persistent query by its rtId (Query Mode) */
+    queryRtId?: string;
+    /** Display name of the query (for UI) */
+    queryName?: string;
+    /** Load entities by CK type (Entity Mode) */
+    ckTypeId?: string;
+    /** Filters for Entity Mode */
+    filters?: WidgetFilterConfig[];
+    /** Maximum number of items to render (default: 50) */
+    maxItems?: number;
+}
+type DataSource = RuntimeEntityDataSource | StaticDataSource | PersistentQueryDataSource | AggregationDataSource | ServiceCallDataSource | ConstructionKitQueryDataSource | RepeaterQueryDataSource;
+/**
+ * Supported widget types
+ */
+type WidgetType = 'entityCard' | 'entityWithAssociations' | 'kpi' | 'table' | 'gauge' | 'pieChart' | 'barChart' | 'statsGrid' | 'statusIndicator' | 'serviceHealth' | 'process' | 'widgetGroup' | 'markdown';
+/**
+ * Base widget configuration
+ */
+interface WidgetConfig {
+    /** Local ID used for UI tracking (generated by WidgetFactoryService) */
+    id: string;
+    /** Backend-generated ID (rtId from GraphQL). Only set after persistence. */
+    rtId?: string;
+    type: WidgetType;
+    title: string;
+    dataSource: DataSource;
+    col: number;
+    row: number;
+    colSpan: number;
+    rowSpan: number;
+    /** Whether the widget supports data source configuration dialog */
+    configurable?: boolean;
+}
+/**
+ * Entity Card Widget - displays a single entity like a UML class diagram
+ */
+interface EntityCardWidgetConfig extends WidgetConfig {
+    type: 'entityCard';
+    showHeader?: boolean;
+    showAttributes?: boolean;
+    attributeFilter?: string[];
+    headerColor?: string;
+}
+/**
+ * Entity with Associations Widget - displays entity with its relationships
+ */
+interface EntityWithAssociationsWidgetConfig extends WidgetConfig {
+    type: 'entityWithAssociations';
+    showIncoming?: boolean;
+    showOutgoing?: boolean;
+    maxAssociations?: number;
+    /** List of role IDs to filter (empty = show all) */
+    roleFilter?: string[];
+    /** Display mode: 'expandable' shows groups that can be expanded */
+    displayMode?: 'count' | 'expandable';
+}
+/**
+ * KPI query mode for persistent queries
+ * - 'simpleCount': Use totalCount from simple query
+ * - 'aggregation': Single value from aggregation query (1 row, 1 column)
+ * - 'groupedAggregation': Value for a specific category from grouped aggregation
+ */
+type KpiQueryMode = 'simpleCount' | 'aggregation' | 'groupedAggregation';
+/**
+ * KPI/Statistics Widget - displays a single value with label
+ * Supports both runtime entity data sources and persistent queries
+ */
+interface KpiWidgetConfig extends WidgetConfig {
+    type: 'kpi';
+    /** Attribute path for runtime entity data source */
+    valueAttribute: string;
+    labelAttribute?: string;
+    prefix?: string;
+    suffix?: string;
+    icon?: string;
+    trend?: 'up' | 'down' | 'neutral';
+    /** Query mode when using persistent query data source */
+    queryMode?: KpiQueryMode;
+    /** Value field for aggregation/grouped queries */
+    queryValueField?: string;
+    /** Category field for grouped aggregation queries */
+    queryCategoryField?: string;
+    /** Selected category value for grouped aggregation queries */
+    queryCategoryValue?: string;
+    /** Field filters for data source */
+    filters?: WidgetFilterConfig[];
+}
+/**
+ * Sorting configuration for table widget (JSON-compatible)
+ */
+interface TableSortConfig {
+    attributePath: string;
+    sortOrder: string;
+}
+/**
+ * Filter configuration for widgets (JSON-compatible)
+ * Used by Table, KPI, Gauge, Pie Chart, Bar Chart widgets
+ */
+interface WidgetFilterConfig {
+    attributePath: string;
+    operator: string;
+    comparisonValue: string;
+}
+/**
+ * @deprecated Use WidgetFilterConfig instead
+ */
+type TableFilterConfig = WidgetFilterConfig;
+/**
+ * Table Widget - displays multiple entities in a table
+ * Note: sorting and filters use simplified JSON-compatible types
+ */
+interface TableWidgetConfig extends WidgetConfig {
+    type: 'table';
+    columns: TableColumn[];
+    sorting?: TableSortConfig[];
+    filters?: TableFilterConfig[];
+    pageSize?: number;
+    sortable?: boolean;
+}
+interface TableColumn {
+    field: string;
+    title: string;
+    width?: number;
+}
+/**
+ * Gauge types available
+ */
+type GaugeType = 'arc' | 'circular' | 'linear' | 'radial';
+/**
+ * Color range for gauge thresholds
+ */
+interface GaugeRange {
+    from: number;
+    to: number;
+    color: string;
+}
+/**
+ * Gauge Widget - displays a numeric value as a gauge visualization
+ * Supports Arc, Circular, Linear, and Radial gauge types from Kendo UI
+ * Supports both runtime entity data sources and persistent queries
+ */
+interface GaugeWidgetConfig extends WidgetConfig {
+    type: 'gauge';
+    /** The gauge visualization type */
+    gaugeType: GaugeType;
+    /** Attribute path to read the numeric value from (for runtime entity) */
+    valueAttribute: string;
+    /** Minimum value for the gauge scale */
+    min?: number;
+    /** Maximum value for the gauge scale */
+    max?: number;
+    /** Color ranges for thresholds (e.g., green/yellow/red zones) */
+    ranges?: GaugeRange[];
+    /** Show the value label on the gauge */
+    showLabel?: boolean;
+    /** Optional attribute for dynamic label */
+    labelAttribute?: string;
+    /** Prefix for value display (e.g., '$') */
+    prefix?: string;
+    /** Suffix for value display (e.g., '%', 'units') */
+    suffix?: string;
+    /** Reverse the gauge direction */
+    reverse?: boolean;
+    /** Query mode when using persistent query data source */
+    queryMode?: KpiQueryMode;
+    /** Value field for aggregation/grouped queries */
+    queryValueField?: string;
+    /** Category field for grouped aggregation queries */
+    queryCategoryField?: string;
+    /** Selected category value for grouped aggregation queries */
+    queryCategoryValue?: string;
+    /** Field filters for data source */
+    filters?: WidgetFilterConfig[];
+}
+/**
+ * Pie Chart types available
+ */
+type PieChartType = 'pie' | 'donut';
+/**
+ * Pie Chart Widget - displays data as a pie or donut chart
+ * Works especially well with grouped aggregation queries
+ */
+interface PieChartWidgetConfig extends WidgetConfig {
+    type: 'pieChart';
+    /** The chart visualization type */
+    chartType: PieChartType;
+    /** Field used for category labels (e.g., 'legalEntityType') */
+    categoryField: string;
+    /** Field used for values (e.g., 'meterReading') */
+    valueField: string;
+    /** Show labels on chart segments */
+    showLabels?: boolean;
+    /** Show the chart legend */
+    showLegend?: boolean;
+    /** Position of the legend */
+    legendPosition?: 'top' | 'bottom' | 'left' | 'right';
+    /** Field filters for data source */
+    filters?: WidgetFilterConfig[];
+}
+/**
+ * Bar Chart types available
+ * - column: Vertical bars (standard column chart)
+ * - bar: Horizontal bars
+ * - stackedColumn: Stacked vertical bars
+ * - stackedBar: Stacked horizontal bars
+ * - stackedColumn100: 100% stacked vertical bars
+ * - stackedBar100: 100% stacked horizontal bars
+ */
+type BarChartType = 'column' | 'bar' | 'stackedColumn' | 'stackedBar' | 'stackedColumn100' | 'stackedBar100';
+/**
+ * Series configuration for bar chart
+ * Each series represents a set of values displayed as bars
+ */
+interface BarChartSeries {
+    /** Value field from query results */
+    field: string;
+    /** Display name for legend (defaults to field name) */
+    name?: string;
+    /** Optional custom color for this series */
+    color?: string;
+}
+/**
+ * Bar Chart Widget - displays data as bar or column charts
+ * Supports multiple series for grouped/stacked visualization
+ * Works especially well with grouped aggregation queries
+ *
+ * Two modes are supported:
+ * 1. Static Series Mode: Define series[] with explicit field mappings
+ * 2. Dynamic Series Mode: Use seriesGroupField + valueField to auto-create series from data
+ */
+interface BarChartWidgetConfig extends WidgetConfig {
+    type: 'barChart';
+    /** The chart visualization type */
+    chartType: BarChartType;
+    /** Field used for category labels (X-axis for column, Y-axis for bar) */
+    categoryField: string;
+    /** Series configuration - each series becomes a set of bars (Static Series Mode) */
+    series: BarChartSeries[];
+    /**
+     * Field used to group data into series (Dynamic Series Mode).
+     * When set, unique values of this field become separate series.
+     * Example: 'billingType' with values 'Credit'/'Debit' creates two series.
+     */
+    seriesGroupField?: string;
+    /**
+     * Value field when using seriesGroupField (Dynamic Series Mode).
+     * The numeric field to display for each category/series combination.
+     */
+    valueField?: string;
+    /** Show the chart legend */
+    showLegend?: boolean;
+    /** Position of the legend */
+    legendPosition?: 'top' | 'bottom' | 'left' | 'right';
+    /** Show data labels on bars */
+    showDataLabels?: boolean;
+    /** Field filters for data source */
+    filters?: WidgetFilterConfig[];
+}
+/**
+ * Color options for stat items
+ */
+type StatColor = 'mint' | 'cyan' | 'violet' | 'toffee' | 'lilac' | 'bubblegum' | 'default';
+/**
+ * Single stat item configuration
+ */
+interface StatItem {
+    /** Display label */
+    label: string;
+    /** Reference to aggregation query ID */
+    queryId: string;
+    /** Color variant */
+    color?: StatColor;
+    /** Number format */
+    format?: 'number' | 'percent' | 'currency';
+    /** Prefix for display (e.g., '$') */
+    prefix?: string;
+    /** Suffix for display (e.g., '%') */
+    suffix?: string;
+}
+/**
+ * Stats Grid Widget - displays multiple KPIs in a grid layout
+ * Uses AggregationDataSource for data
+ */
+interface StatsGridWidgetConfig extends WidgetConfig {
+    type: 'statsGrid';
+    /** Stat items to display */
+    stats: StatItem[];
+    /** Number of columns in the grid (default: 3) */
+    columns?: number;
+}
+/**
+ * Status Indicator Widget - displays a boolean status (ENABLED/DISABLED, etc.)
+ * Uses ServiceCallDataSource for data
+ */
+interface StatusIndicatorWidgetConfig extends WidgetConfig {
+    type: 'statusIndicator';
+    /** Label to show when status is true */
+    trueLabel?: string;
+    /** Label to show when status is false */
+    falseLabel?: string;
+    /** Custom true color (CSS color) */
+    trueColor?: string;
+    /** Custom false color (CSS color) */
+    falseColor?: string;
+}
+/**
+ * Service Health Widget - displays health status with pulse animation
+ * Uses ServiceCallDataSource with callType: 'healthCheck'
+ */
+interface ServiceHealthWidgetConfig extends WidgetConfig {
+    type: 'serviceHealth';
+    /** Enable click to navigate to detail page */
+    navigateOnClick?: boolean;
+    /** Route to navigate to (relative to current route) */
+    detailRoute?: string;
+    /** Show pulse animation when healthy */
+    showPulse?: boolean;
+}
+/**
+ * Supported child widget types for Widget Group
+ */
+type GroupChildWidgetType = 'kpi' | 'gauge' | 'entityCard';
+/**
+ * Layout options for Widget Group
+ */
+type WidgetGroupLayout = 'grid' | 'horizontal' | 'vertical';
+/**
+ * Attribute mapping configuration for child widgets.
+ * Maps data item attributes to child widget properties.
+ */
+interface WidgetGroupAttributeMappings {
+    /** Attribute path for the value (KPI/Gauge) */
+    valueAttribute?: string;
+    /** Attribute path for dynamic label */
+    labelAttribute?: string;
+    /** Attribute path for status (StatusIndicator) */
+    statusAttribute?: string;
+}
+/**
+ * Template for child widgets in a Widget Group.
+ * Defines how each data item is rendered as a widget.
+ */
+interface WidgetGroupChildTemplate {
+    /** The widget type to render for each item */
+    widgetType: GroupChildWidgetType;
+    /**
+     * Title template with variable substitution.
+     * Available variables: $rtWellKnownName, $rtId, $ckTypeId, and any attribute with $attributeName
+     */
+    titleTemplate?: string;
+    /** Maps data item attributes to widget properties */
+    attributeMappings: WidgetGroupAttributeMappings;
+    /** Static configuration merged into each child widget */
+    staticConfig?: Partial<KpiWidgetConfig | GaugeWidgetConfig | EntityCardWidgetConfig>;
+}
+/**
+ * Widget Group Widget - renders a widget for each item from a query or entity list.
+ * Acts as a container that executes a query and dynamically creates child widgets.
+ *
+ * Example use case: Query returns 5 machines → 5 KPI widgets show each machine's status.
+ *
+ * Uses RepeaterQueryDataSource for data:
+ * - Query Mode: Execute persistent query, render widget per row
+ * - Entity Mode: Load entities by CK type, render widget per entity
+ */
+interface WidgetGroupConfig extends WidgetConfig {
+    type: 'widgetGroup';
+    /** The data source that provides items to repeat */
+    dataSource: RepeaterQueryDataSource;
+    /** Template defining how each item is rendered as a widget */
+    childTemplate: WidgetGroupChildTemplate;
+    /** Layout mode for child widgets */
+    layout: WidgetGroupLayout;
+    /** Number of columns for grid layout (default: 4) */
+    gridColumns?: number;
+    /** Minimum width for child widgets in pixels (default: 150) */
+    minChildWidth?: number;
+    /** Gap between child widgets in pixels (default: 8) */
+    gap?: number;
+    /** Message to show when no items are returned */
+    emptyMessage?: string;
+}
+/**
+ * Text alignment options for Markdown widget
+ */
+type MarkdownTextAlign = 'left' | 'center' | 'right';
+/**
+ * Markdown Widget - displays formatted markdown content
+ * Uses static data source since content is stored directly in config
+ */
+interface MarkdownWidgetConfig extends WidgetConfig {
+    type: 'markdown';
+    /** The markdown content to display */
+    content: string;
+    /** Whether to resolve MeshBoard variables ($name or ${name}) in content */
+    resolveVariables?: boolean;
+    /** Custom padding (CSS value, default: 16px) */
+    padding?: string;
+    /** Text alignment (default: left) */
+    textAlign?: MarkdownTextAlign;
+}
+
+type AnyWidgetConfig = EntityCardWidgetConfig | EntityWithAssociationsWidgetConfig | KpiWidgetConfig | TableWidgetConfig | GaugeWidgetConfig | PieChartWidgetConfig | BarChartWidgetConfig | StatsGridWidgetConfig | StatusIndicatorWidgetConfig | ServiceHealthWidgetConfig | ProcessWidgetConfig | WidgetGroupConfig | MarkdownWidgetConfig;
+/**
+ * Supported variable types
+ */
+type MeshBoardVariableType = 'string' | 'number' | 'boolean' | 'date' | 'datetime';
+/**
+ * Source of the variable value (extensible for future dynamic variables)
+ */
+type MeshBoardVariableSource = 'static' | 'timeFilter';
+/**
+ * MeshBoard variable definition
+ */
+interface MeshBoardVariable {
+    /** Unique variable name (without $ prefix) */
+    name: string;
+    /** Display label for UI */
+    label?: string;
+    /** Variable description */
+    description?: string;
+    /** Data type */
+    type: MeshBoardVariableType;
+    /** Value source (extensible) */
+    source: MeshBoardVariableSource;
+    /** Current value (as string for serialization) */
+    value: string;
+    /** Default value if no value is set */
+    defaultValue?: string;
+}
+/**
+ * Supported time range types for the time filter
+ */
+type TimeRangeType = 'year' | 'quarter' | 'month' | 'relative' | 'custom';
+/**
+ * Time units for relative time ranges
+ */
+type RelativeTimeUnit = 'hours' | 'days' | 'weeks' | 'months';
+/**
+ * Quarter number (1-4)
+ */
+type Quarter = 1 | 2 | 3 | 4;
+/**
+ * Configuration for the time range picker component
+ */
+interface TimeRangePickerConfig {
+    /** Available range types to show. Defaults to all. */
+    availableTypes?: TimeRangeType[];
+    /** Minimum selectable year. */
+    minYear?: number;
+    /** Maximum selectable year. */
+    maxYear?: number;
+    /** Default relative time value. */
+    defaultRelativeValue?: number;
+    /** Default relative time unit. */
+    defaultRelativeUnit?: RelativeTimeUnit;
+    /** Show time in custom date pickers. */
+    showTime?: boolean;
+}
+/**
+ * The current selection state of the time range picker (for persistence)
+ */
+interface TimeRangeSelection {
+    type: TimeRangeType;
+    year?: number;
+    quarter?: Quarter;
+    month?: number;
+    relativeValue?: number;
+    relativeUnit?: RelativeTimeUnit;
+    customFrom?: string;
+    customTo?: string;
+}
+/**
+ * Time filter configuration for MeshBoard
+ */
+interface MeshBoardTimeFilterConfig {
+    /** Whether the time filter is enabled */
+    enabled: boolean;
+    /** Configuration for the time range picker */
+    pickerConfig?: TimeRangePickerConfig;
+    /** Current selection (for persistence) */
+    selection?: TimeRangeSelection;
+}
+/**
+ * Complete MeshBoard configuration
+ */
+interface MeshBoardConfig {
+    id: string;
+    name: string;
+    description?: string;
+    /** Well-known name for routing (e.g., 'cockpit', 'sales-dashboard') */
+    rtWellKnownName?: string | null;
+    columns: number;
+    rowHeight: number;
+    gap: number;
+    /** MeshBoard-level variables that can be used in widget filters */
+    variables?: MeshBoardVariable[];
+    /** Optional time filter configuration */
+    timeFilter?: MeshBoardTimeFilterConfig;
+    widgets: AnyWidgetConfig[];
+}
+/** @deprecated Use MeshBoardConfig instead */
+type DashboardConfig = MeshBoardConfig;
+interface EntityAttribute {
+    attributeName: string;
+    value: unknown;
+}
+interface EntityAssociation {
+    targetRtId: string;
+    targetCkTypeId: string;
+    originRtId: string;
+    originCkTypeId: string;
+    ckAssociationRoleId: string;
+}
+interface RuntimeEntityData {
+    rtId: string;
+    ckTypeId: string;
+    rtWellKnownName?: string;
+    rtCreationDateTime?: string;
+    rtChangedDateTime?: string;
+    attributes: EntityAttribute[];
+    associations: EntityAssociation[];
+}
+
+/**
+ * Base interface for all dashboard widgets.
+ * Each widget is a self-contained plugin that loads its own data.
+ */
+interface DashboardWidget<TConfig extends AnyWidgetConfig = AnyWidgetConfig, TData = unknown> {
+    /**
+     * The widget configuration containing data source and display options.
+     */
+    config: TConfig;
+    /**
+     * Signal indicating if the widget is currently loading data.
+     */
+    readonly isLoading: Signal<boolean>;
+    /**
+     * Signal containing the loaded data, or null if not loaded yet.
+     */
+    readonly data: Signal<TData | null>;
+    /**
+     * Signal containing any error that occurred during data loading.
+     */
+    readonly error: Signal<string | null>;
+    /**
+     * Triggers a data reload.
+     */
+    refresh(): void;
+}
+/**
+ * Type for widgets that display a single entity.
+ */
+type EntityWidget = DashboardWidget<AnyWidgetConfig, RuntimeEntityData>;
+/**
+ * Type for widgets that display multiple entities.
+ */
+type EntityListWidget = DashboardWidget<AnyWidgetConfig, RuntimeEntityData[]>;
+
+type GetEntitiesByCkTypeQueryVariablesDto = Exact<{
+    ckTypeId: Scalars['String']['input'];
+    rtId?: InputMaybe<Scalars['OctoObjectId']['input']>;
+    after?: InputMaybe<Scalars['String']['input']>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    searchFilter?: InputMaybe<SearchFilterDto>;
+    fieldFilters?: InputMaybe<Array<InputMaybe<FieldFilterDto>> | InputMaybe<FieldFilterDto>>;
+    sort?: InputMaybe<Array<InputMaybe<SortDto>> | InputMaybe<SortDto>>;
+}>;
+type GetEntitiesByCkTypeQueryDto = {
+    __typename?: 'OctoQuery';
+    runtime?: {
+        __typename?: 'RuntimeModelQuery';
+        runtimeEntities?: {
+            __typename?: 'RtEntityGenericDtoConnection';
+            totalCount?: number | null;
+            items?: Array<{
+                __typename?: 'RtEntity';
+                rtId: any;
+                ckTypeId: any;
+                rtWellKnownName?: string | null;
+                rtCreationDateTime?: any | null;
+                rtChangedDateTime?: any | null;
+                attributes?: {
+                    __typename?: 'RtEntityAttributeDtoConnection';
+                    items?: Array<{
+                        __typename?: 'RtEntityAttribute';
+                        attributeName?: string | null;
+                        value?: any | null;
+                    } | null> | null;
+                } | null;
+            } | null> | null;
+        } | null;
+    } | null;
+};
+declare class GetEntitiesByCkTypeDtoGQL extends Apollo.Query<GetEntitiesByCkTypeQueryDto, GetEntitiesByCkTypeQueryVariablesDto> {
+    document: Apollo.TypedDocumentNode<unknown, unknown>;
+    constructor(apollo: Apollo.Apollo);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GetEntitiesByCkTypeDtoGQL, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GetEntitiesByCkTypeDtoGQL>;
+}
+
+/**
+ * Represents a runtime entity for selection in config dialogs
+ */
+interface RuntimeEntityItem$1 {
+    rtId: string;
+    ckTypeId: string;
+    rtWellKnownName?: string;
+    displayName: string;
+}
+/**
+ * Persistent query item for selection in config dialogs
+ */
+interface PersistentQueryItem {
+    rtId: string;
+    name: string;
+    description?: string | null;
+    queryCkTypeId?: string | null;
+}
+/**
+ * Column info derived from query execution
+ */
+interface QueryColumnItem {
+    attributePath: string;
+    attributeValueType: string;
+}
+/**
+ * Category value item for grouped aggregation
+ */
+interface CategoryValueItem {
+    value: string;
+    displayValue: string;
+}
+/**
+ * Data source for entity autocomplete input - filters entities by CK Type
+ */
+declare class RuntimeEntitySelectDataSource$1 implements EntitySelectDataSource<RuntimeEntityItem$1> {
+    private getEntitiesByCkTypeGQL;
+    private ckTypeId;
+    constructor(getEntitiesByCkTypeGQL: GetEntitiesByCkTypeDtoGQL, ckTypeId: string);
+    onFilter(filter: string, take?: number): Promise<EntitySelectResult<RuntimeEntityItem$1>>;
+    onDisplayEntity(entity: RuntimeEntityItem$1): string;
+    getIdEntity(entity: RuntimeEntityItem$1): string;
+}
+/**
+ * Dialog data source for entity selection grid with pagination and search
+ */
+declare class RuntimeEntityDialogDataSource$1 implements EntitySelectDialogDataSource<RuntimeEntityItem$1> {
+    private getEntitiesByCkTypeGQL;
+    private ckTypeId;
+    constructor(getEntitiesByCkTypeGQL: GetEntitiesByCkTypeDtoGQL, ckTypeId: string);
+    getColumns(): ColumnDefinition[];
+    fetchData(options: DialogFetchOptions): Observable<DialogFetchResult<RuntimeEntityItem$1>>;
+    onDisplayEntity(entity: RuntimeEntityItem$1): string;
+    getIdEntity(entity: RuntimeEntityItem$1): string;
+}
+
+/**
+ * Reusable component for selecting a persistent query.
+ * Provides a combobox with filtering and displays query name + description.
+ *
+ * Usage:
+ * ```html
+ * <mm-query-selector
+ *   [(ngModel)]="selectedQuery"
+ *   (querySelected)="onQuerySelected($event)"
+ *   placeholder="Select a Query..."
+ *   hint="Select a query to provide data for this widget.">
+ * </mm-query-selector>
+ * ```
+ */
+declare class QuerySelectorComponent implements OnInit, ControlValueAccessor {
+    private readonly getSystemPersistentQueriesGQL;
+    /** Placeholder text for the combobox */
+    placeholder: string;
+    /** Hint text shown below the combobox */
+    hint?: string;
+    /** Whether the component is disabled */
+    disabled: boolean;
+    /** Whether to load queries automatically on init */
+    autoLoad: boolean;
+    /** Emitted when a query is selected */
+    querySelected: EventEmitter<PersistentQueryItem | null>;
+    /** Emitted when queries are loaded */
+    queriesLoaded: EventEmitter<PersistentQueryItem[]>;
+    queries: PersistentQueryItem[];
+    selectedQuery: PersistentQueryItem | null;
+    isLoading: boolean;
+    private onChange;
+    private onTouched;
+    ngOnInit(): void;
+    /**
+     * Loads persistent queries with optional search text filter
+     */
+    loadQueries(searchText?: string): Promise<void>;
+    /**
+     * Called when the combobox filter changes (user types)
+     */
+    onFilterChange(filter: string): void;
+    /**
+     * Called when a query is selected
+     */
+    onValueChange(query: PersistentQueryItem | null): void;
+    /**
+     * Sets the selected query by rtId (useful for loading existing config)
+     */
+    selectByRtId(rtId: string): Promise<PersistentQueryItem | null>;
+    writeValue(value: PersistentQueryItem | null): void;
+    registerOnChange(fn: (value: PersistentQueryItem | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QuerySelectorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<QuerySelectorComponent, "mm-query-selector", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "autoLoad": { "alias": "autoLoad"; "required": false; }; }, { "querySelected": "querySelected"; "queriesLoaded": "queriesLoaded"; }, never, never, true, never>;
+}
+
+/**
+ * Value object for the runtime entity selector
+ */
+interface RuntimeEntitySelectorValue {
+    ckTypeId: string;
+    rtCkTypeId: string;
+    rtId?: string;
+    displayName?: string;
+}
+/**
+ * Reusable component for selecting a runtime entity.
+ * Combines CK Type selector and Entity selector into a single component.
+ *
+ * Usage:
+ * ```html
+ * <mm-runtime-entity-selector
+ *   [(ngModel)]="selectedEntity"
+ *   (entitySelected)="onEntitySelected($event)"
+ *   ckTypeLabel="Runtime Entities"
+ *   entityLabel="Entity">
+ * </mm-runtime-entity-selector>
+ * ```
+ */
+declare class RuntimeEntitySelectorComponent implements ControlValueAccessor {
+    private readonly getEntitiesByCkTypeGQL;
+    private readonly ckTypeSelectorService;
+    ckTypeSelector: CkTypeSelectorInputComponent;
+    entitySelector?: EntitySelectInputComponent;
+    ckTypeLabel: string;
+    ckTypePlaceholder: string;
+    ckTypeDialogTitle: string;
+    ckTypeHint: string;
+    ckTypeRequired: boolean;
+    entityLabel: string;
+    entityPlaceholder: string;
+    entityDialogTitle: string;
+    entityHint: string;
+    entityRequired: boolean;
+    /** Whether to show the entity selector (set to false if only CK Type selection is needed) */
+    showEntitySelector: boolean;
+    /** Whether the component is disabled */
+    disabled: boolean;
+    /** Emitted when a CK Type is selected */
+    ckTypeSelected: EventEmitter<CkTypeSelectorItem>;
+    /** Emitted when the CK Type is cleared */
+    ckTypeCleared: EventEmitter<void>;
+    /** Emitted when an entity is selected */
+    entitySelected: EventEmitter<RuntimeEntityItem$1>;
+    /** Emitted when the entity is cleared */
+    entityCleared: EventEmitter<void>;
+    /** Emitted when the full value changes */
+    valueChange: EventEmitter<RuntimeEntitySelectorValue | null>;
+    selectedCkType: CkTypeSelectorItem | null;
+    selectedEntity: RuntimeEntityItem$1 | null;
+    entityDataSource?: RuntimeEntitySelectDataSource$1;
+    entityDialogDataSource?: RuntimeEntityDialogDataSource$1;
+    private onChange;
+    private onTouched;
+    /**
+     * Called when a CK Type is selected
+     */
+    onCkTypeSelected(ckType: CkTypeSelectorItem): void;
+    /**
+     * Called when the CK Type is cleared
+     */
+    onCkTypeCleared(): void;
+    /**
+     * Called when an entity is selected
+     */
+    onEntitySelected(entity: RuntimeEntityItem$1): void;
+    /**
+     * Called when the entity is cleared
+     */
+    onEntityCleared(): void;
+    /**
+     * Sets the value by loading CK Type and Entity by their IDs
+     */
+    setValueByIds(ckTypeId: string, rtId?: string): Promise<void>;
+    /**
+     * Loads a CK Type by its rtCkTypeId
+     */
+    private loadCkTypeByRtCkTypeId;
+    /**
+     * Emits the current value
+     */
+    private emitValue;
+    /**
+     * Gets the current value
+     */
+    private getCurrentValue;
+    writeValue(value: RuntimeEntitySelectorValue | null): void;
+    registerOnChange(fn: (value: RuntimeEntitySelectorValue | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RuntimeEntitySelectorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RuntimeEntitySelectorComponent, "mm-runtime-entity-selector", never, { "ckTypeLabel": { "alias": "ckTypeLabel"; "required": false; }; "ckTypePlaceholder": { "alias": "ckTypePlaceholder"; "required": false; }; "ckTypeDialogTitle": { "alias": "ckTypeDialogTitle"; "required": false; }; "ckTypeHint": { "alias": "ckTypeHint"; "required": false; }; "ckTypeRequired": { "alias": "ckTypeRequired"; "required": false; }; "entityLabel": { "alias": "entityLabel"; "required": false; }; "entityPlaceholder": { "alias": "entityPlaceholder"; "required": false; }; "entityDialogTitle": { "alias": "entityDialogTitle"; "required": false; }; "entityHint": { "alias": "entityHint"; "required": false; }; "entityRequired": { "alias": "entityRequired"; "required": false; }; "showEntitySelector": { "alias": "showEntitySelector"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "ckTypeSelected": "ckTypeSelected"; "ckTypeCleared": "ckTypeCleared"; "entitySelected": "entitySelected"; "entityCleared": "entityCleared"; "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * Shared component to display a consistent "widget not configured" message.
+ * Used by all widget types when they are not properly configured.
+ */
+declare class WidgetNotConfiguredComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WidgetNotConfiguredComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WidgetNotConfiguredComponent, "mm-widget-not-configured", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Defines how parent associations should be handled when mapping widget input
+ */
+type ParentAssociationMode = {
+    type: 'create';
+    dashboardRtId: string;
+} | {
+    type: 'keep';
+} | {
+    type: 'move';
+    oldDashboardRtId: string;
+    newDashboardRtId: string;
+};
+interface PersistedMeshBoard {
+    rtId: string;
+    ckTypeId: string;
+    rtWellKnownName?: string | null;
+    name: string;
+    description: string;
+    columns: number;
+    rowHeight: number;
+    gap: number;
+}
+/** @deprecated Use PersistedMeshBoard instead */
+type PersistedDashboard = PersistedMeshBoard;
+interface PersistedWidget {
+    rtId: string;
+    ckTypeId: string;
+    name: string;
+    type: string;
+    col: number;
+    row: number;
+    colSpan: number;
+    rowSpan: number;
+    dataSourceType: string;
+    dataSourceCkTypeId?: string | null;
+    dataSourceRtId?: string | null;
+    config: string;
+}
+/**
+ * Result of updating a dashboard, including created widget mappings
+ */
+interface UpdateDashboardResult {
+    createdWidgets: {
+        localId: string;
+        rtId: string;
+    }[];
+}
+declare class MeshBoardPersistenceService {
+    private readonly getDashboardsGQL;
+    private readonly getDashboardWithWidgetsGQL;
+    private readonly createDashboardGQL;
+    private readonly updateDashboardGQL;
+    private readonly createWidgetGQL;
+    private readonly updateWidgetGQL;
+    private readonly deleteEntitiesGQL;
+    private readonly widgetRegistry;
+    private readonly DASHBOARD_CK_TYPE_ID;
+    private readonly WIDGET_CK_TYPE_ID;
+    /**
+     * Separator used to encode variables in the description field.
+     * Format: <description>\n---MESHBOARD_VARIABLES---\n<json>
+     *
+     * Note: This is a temporary solution until the backend schema is updated
+     * to include a dedicated 'config' field for MeshBoard configuration.
+     */
+    private readonly VARIABLES_SEPARATOR;
+    /**
+     * Fetches all available MeshBoards
+     */
+    getMeshBoards(first?: number): Promise<PersistedMeshBoard[]>;
+    /**
+     * Fetches a MeshBoard with all its widgets
+     */
+    getMeshBoardWithWidgets(rtId: string): Promise<{
+        meshBoard: PersistedMeshBoard;
+        widgets: PersistedWidget[];
+    } | null>;
+    /**
+     * Creates a new MeshBoard with its widgets
+     */
+    createMeshBoard(config: MeshBoardConfig): Promise<string>;
+    /**
+     * Updates an existing MeshBoard and its widgets.
+     * Returns mapping of created widgets (localId -> rtId) for state synchronization.
+     */
+    updateMeshBoard(rtId: string, config: MeshBoardConfig, existingWidgetRtIds?: string[]): Promise<UpdateDashboardResult>;
+    /**
+     * Converts a persisted MeshBoard to MeshBoardConfig
+     */
+    toMeshBoardConfig(meshBoard: PersistedMeshBoard, widgets: PersistedWidget[]): MeshBoardConfig;
+    /**
+     * Converts a persisted widget to AnyWidgetConfig.
+     * Delegates to WidgetRegistryService for widget-specific deserialization (SOLID: Open/Closed Principle).
+     */
+    private toWidgetConfig;
+    /**
+     * Maps widget config to GraphQL input.
+     * Delegates to WidgetRegistryService for widget-specific serialization (SOLID: Open/Closed Principle).
+     */
+    private mapWidgetToInput;
+    /**
+     * Builds parent association array based on the association mode
+     */
+    private buildParentAssociations;
+    /**
+     * Deletes a MeshBoard and all its widgets (via cascade delete)
+     */
+    deleteMeshBoard(rtId: string): Promise<void>;
+    /**
+     * Renames a MeshBoard (updates name and description)
+     */
+    renameMeshBoard(rtId: string, name: string, description: string): Promise<void>;
+    /**
+     * Encodes variables and timeFilter into the description field.
+     * Format: <description>\n---MESHBOARD_VARIABLES---\n<json>
+     *
+     * Note: Only static variables are persisted. TimeFilter variables are derived
+     * from the timeFilter selection when the MeshBoard is loaded.
+     */
+    private encodeVariablesInDescription;
+    /**
+     * Decodes variables and timeFilter from the description field.
+     * Returns the original description, parsed variables, and timeFilter config.
+     *
+     * Handles both legacy format (just variables array) and new format (object with variables and timeFilter).
+     */
+    private decodeVariablesFromDescription;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MeshBoardPersistenceService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MeshBoardPersistenceService>;
+}
+
+/**
+ * Service that manages MeshBoard state and persistence.
+ * Coordinates loading, saving, and switching between MeshBoards.
+ */
+declare class MeshBoardStateService {
+    private readonly ckModelService;
+    private readonly persistenceService;
+    private readonly gridService;
+    private readonly _meshBoardConfig;
+    private readonly _persistedMeshBoardId;
+    /** Stores the rtIds of widgets that exist in the backend */
+    private readonly _existingWidgetRtIds;
+    private readonly _availableMeshBoards;
+    private readonly _isLoading;
+    private readonly _isModelAvailable;
+    readonly meshBoardConfig: _angular_core.Signal<MeshBoardConfig>;
+    readonly persistedMeshBoardId: _angular_core.Signal<string | null>;
+    /** @deprecated Use existingWidgetRtIds instead */
+    readonly existingWidgetIds: _angular_core.Signal<string[]>;
+    readonly existingWidgetRtIds: _angular_core.Signal<string[]>;
+    readonly availableMeshBoards: _angular_core.Signal<PersistedMeshBoard[]>;
+    readonly isLoading: _angular_core.Signal<boolean>;
+    readonly widgets: _angular_core.Signal<AnyWidgetConfig[]>;
+    readonly isModelAvailable: _angular_core.Signal<boolean | null>;
+    /** @deprecated Use meshBoardConfig instead */
+    readonly dashboardConfig: _angular_core.Signal<MeshBoardConfig>;
+    /** @deprecated Use persistedMeshBoardId instead */
+    readonly persistedDashboardId: _angular_core.Signal<string | null>;
+    /** @deprecated Use availableMeshBoards instead */
+    readonly availableDashboards: _angular_core.Signal<PersistedMeshBoard[]>;
+    /**
+     * Creates the default MeshBoard configuration.
+     */
+    private createDefaultConfig;
+    /**
+     * Loads the initial MeshBoard from backend or starts with empty MeshBoard.
+     * Only loads if the required CK model (System.UI) is available.
+     */
+    loadInitialMeshBoard(): Promise<AnyWidgetConfig[]>;
+    /** @deprecated Use loadInitialMeshBoard instead */
+    loadInitialDashboard(): Promise<AnyWidgetConfig[]>;
+    /**
+     * Switches to a different MeshBoard by rtId.
+     * Returns the widgets for data loading.
+     */
+    switchToMeshBoard(rtId: string): Promise<AnyWidgetConfig[]>;
+    /** @deprecated Use switchToMeshBoard instead */
+    switchToDashboard(rtId: string): Promise<AnyWidgetConfig[]>;
+    /**
+     * Switches to a MeshBoard identified by its rtWellKnownName.
+     * Loads initial MeshBoards if not already loaded.
+     * Returns the widgets for data loading, or null if not found.
+     */
+    switchToMeshBoardByWellKnownName(wellKnownName: string): Promise<AnyWidgetConfig[] | null>;
+    /**
+     * Saves the current MeshBoard configuration to the backend.
+     */
+    saveMeshBoard(): Promise<void>;
+    /** @deprecated Use saveMeshBoard instead */
+    saveDashboard(): Promise<void>;
+    /**
+     * Updates the MeshBoard configuration.
+     */
+    updateConfig(updater: (config: MeshBoardConfig) => MeshBoardConfig): void;
+    /**
+     * Sets the MeshBoard configuration directly.
+     */
+    setConfig(config: MeshBoardConfig): void;
+    /**
+     * Gets the current MeshBoard configuration (non-reactive).
+     */
+    getConfig(): MeshBoardConfig;
+    /**
+     * Adds a widget to the MeshBoard.
+     */
+    addWidget(widget: AnyWidgetConfig): void;
+    /**
+     * Removes a widget from the MeshBoard.
+     */
+    removeWidget(widgetId: string): void;
+    /**
+     * Updates a specific widget in the MeshBoard.
+     */
+    updateWidget(widgetId: string, updater: (widget: AnyWidgetConfig) => AnyWidgetConfig): void;
+    /**
+     * Gets a widget by ID.
+     */
+    getWidget(widgetId: string): AnyWidgetConfig | undefined;
+    /**
+     * Updates MeshBoard settings (name, description, columns, variables, timeFilter, etc.).
+     */
+    updateSettings(settings: {
+        name: string;
+        description: string;
+        rtWellKnownName?: string;
+        columns: number;
+        rowHeight: number;
+        gap: number;
+        variables?: MeshBoardVariable[];
+        timeFilter?: MeshBoardTimeFilterConfig;
+    }): void;
+    /**
+     * Gets current settings for the settings dialog.
+     */
+    getCurrentSettings(): {
+        name: string;
+        description: string;
+        rtWellKnownName?: string | null;
+        columns: number;
+        rowHeight: number;
+        gap: number;
+        variables: MeshBoardVariable[];
+        timeFilter?: MeshBoardTimeFilterConfig;
+    };
+    /**
+     * Triggers a refresh of all widgets by creating new config references.
+     * This causes ngOnChanges to fire in each widget, triggering data reload.
+     */
+    triggerRefresh(): void;
+    /**
+     * Refreshes the list of available MeshBoards from the backend.
+     */
+    refreshMeshBoardList(): Promise<void>;
+    /** @deprecated Use refreshMeshBoardList instead */
+    refreshDashboardList(): Promise<void>;
+    /**
+     * Creates a new MeshBoard and switches to it.
+     */
+    createNewMeshBoard(name: string, description: string): Promise<string>;
+    /** @deprecated Use createNewMeshBoard instead */
+    createNewDashboard(name: string, description: string): Promise<string>;
+    /**
+     * Renames the specified MeshBoard.
+     */
+    renameMeshBoard(rtId: string, name: string, description: string): Promise<void>;
+    /** @deprecated Use renameMeshBoard instead */
+    renameDashboard(rtId: string, name: string, description: string): Promise<void>;
+    /**
+     * Deletes a MeshBoard.
+     * If the deleted MeshBoard was the current one, switches to the first available.
+     */
+    deleteMeshBoard(rtId: string): Promise<void>;
+    /** @deprecated Use deleteMeshBoard instead */
+    deleteDashboard(rtId: string): Promise<void>;
+    /**
+     * Gets all variables from the current MeshBoard configuration.
+     */
+    getVariables(): MeshBoardVariable[];
+    /**
+     * Gets a specific variable by name.
+     */
+    getVariable(name: string): MeshBoardVariable | undefined;
+    /**
+     * Updates all variables in the MeshBoard configuration.
+     */
+    updateVariables(variables: MeshBoardVariable[]): void;
+    /**
+     * Sets the value of a single variable.
+     */
+    setVariableValue(name: string, value: string): void;
+    /**
+     * Adds a new variable to the MeshBoard.
+     */
+    addVariable(variable: MeshBoardVariable): void;
+    /**
+     * Removes a variable by name.
+     */
+    removeVariable(name: string): void;
+    /**
+     * Checks if the time filter is enabled.
+     */
+    isTimeFilterEnabled(): boolean;
+    /**
+     * Gets the time filter configuration.
+     */
+    getTimeFilterConfig(): MeshBoardTimeFilterConfig | undefined;
+    /**
+     * Updates the time filter configuration.
+     */
+    updateTimeFilterConfig(config: MeshBoardTimeFilterConfig): void;
+    /**
+     * Updates the time filter selection and sets the predefined variables.
+     */
+    updateTimeFilterSelection(selection: TimeRangeSelection, fromISO: string, toISO: string): void;
+    /**
+     * Sets the time filter variables ($timeRangeFrom, $timeRangeTo).
+     * Removes any existing timeFilter variables and adds the new ones.
+     */
+    setTimeFilterVariables(fromISO: string, toISO: string): void;
+    /**
+     * Clears time filter variables (called when time filter is disabled).
+     */
+    clearTimeFilterVariables(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MeshBoardStateService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MeshBoardStateService>;
+}
+
+/**
+ * Grouped data item for chart visualization
+ */
+interface GroupedDataItem {
+    category: string;
+    value: number;
+}
+/**
+ * Result of a CK query for charts
+ */
+interface CkQueryResult {
+    items: GroupedDataItem[];
+    totalCount: number;
+}
+/**
+ * A single data item from a repeater query.
+ * Used by Widget Group to render child widgets.
+ */
+interface RepeaterDataItem {
+    /** Runtime ID of the entity/row */
+    rtId: string;
+    /** CK Type ID */
+    ckTypeId: string;
+    /** Well-known name of the entity */
+    rtWellKnownName?: string;
+    /** All attributes as a Map for easy access */
+    attributes: Map<string, unknown>;
+}
+declare class MeshBoardDataService {
+    private readonly getDashboardEntityGQL;
+    private readonly getCkModelsWithStateGQL;
+    private readonly getEntitiesByCkTypeGQL;
+    private readonly executeRuntimeQueryGQL;
+    private readonly apollo;
+    private readonly stateService;
+    private readonly variableService;
+    /**
+     * Fetches data based on the data source configuration
+     */
+    fetchData(dataSource: DataSource): Observable<RuntimeEntityData | RuntimeEntityData[] | null>;
+    /**
+     * Fetches a single runtime entity by rtId and ckTypeId
+     */
+    fetchRuntimeEntity(dataSource: RuntimeEntityDataSource): Observable<RuntimeEntityData | null>;
+    /**
+     * Fetches a single entity with associations by rtId and ckTypeId (using generic query)
+     */
+    fetchEntityWithAssociations(rtId: string, ckTypeId: string): Observable<RuntimeEntityData | null>;
+    /**
+     * Maps GraphQL entity response to RuntimeEntityData
+     */
+    private mapToRuntimeEntityData;
+    private readonly CK_COUNTS_QUERY;
+    /**
+     * Fetches aggregation results for multiple queries.
+     * Returns a Map of query ID to aggregated value.
+     *
+     * Supports:
+     * - Construction Kit count queries (ConstructionKit/* types)
+     * - Runtime entity count queries (any CK type)
+     */
+    fetchAggregations(queries: AggregationQuery[]): Promise<Map<string, number>>;
+    /**
+     * Fetches the count of runtime entities for a given CK type.
+     * Optionally applies field filters to narrow down the count.
+     * Resolves MeshBoard variables in filter values.
+     */
+    private fetchRuntimeEntityCount;
+    /**
+     * Fetches all Construction Kit counts in a single query.
+     */
+    private fetchCkCounts;
+    /**
+     * Extracts the count for a specific CK type from the query result.
+     */
+    private getCkCountFromResult;
+    /**
+     * Fetches data from Construction Kit and groups it for chart visualization.
+     * Supports grouping by fields like modelState for pie/bar charts.
+     */
+    fetchCkQueryData(dataSource: ConstructionKitQueryDataSource): Promise<CkQueryResult>;
+    /**
+     * Fetches data for Widget Group repeater.
+     * Supports two modes:
+     * 1. Query Mode: Execute a persistent query and map rows to items
+     * 2. Entity Mode: Load entities by CK type with optional filters
+     *
+     * @param dataSource The repeater query data source configuration
+     * @returns Array of RepeaterDataItem objects for rendering child widgets
+     */
+    fetchRepeaterData(dataSource: RepeaterQueryDataSource): Promise<RepeaterDataItem[]>;
+    /**
+     * Fetches repeater data from a persistent query.
+     * Maps query rows to RepeaterDataItem objects.
+     */
+    private fetchRepeaterFromQuery;
+    /**
+     * Fetches repeater data from entities by CK type.
+     * Maps entities to RepeaterDataItem objects.
+     */
+    private fetchRepeaterFromEntities;
+    /**
+     * Fetches CK models and groups them by a specified field.
+     * Default groupBy is 'modelState'.
+     */
+    private fetchCkModelsGrouped;
+    /**
+     * Groups CK model items by a specified field.
+     */
+    private groupCkModels;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MeshBoardDataService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MeshBoardDataService>;
+}
+/** @deprecated Use MeshBoardDataService instead */
+declare const DashboardDataService: typeof MeshBoardDataService;
+
+/**
+ * Base interface for all widget config dialog results.
+ * Each dialog must return at least the data source info.
+ */
+interface WidgetConfigResult {
+    ckTypeId: string;
+    rtId?: string;
+}
+/**
+ * Base configuration passed to widget factory functions.
+ * Contains common fields that all widgets need.
+ */
+interface BaseWidgetConfig {
+    id: string;
+    title: string;
+    col: number;
+    row: number;
+    colSpan: number;
+    rowSpan: number;
+    configurable?: boolean;
+}
+/**
+ * Persisted widget data from the backend.
+ * Used for deserializing widgets from storage.
+ */
+interface PersistedWidgetData {
+    rtId: string;
+    ckTypeId: string;
+    name: string;
+    type: string;
+    col: number;
+    row: number;
+    colSpan: number;
+    rowSpan: number;
+    dataSourceType: string;
+    dataSourceCkTypeId?: string | null;
+    dataSourceRtId?: string | null;
+    config: string;
+}
+/**
+ * Data structure for widget persistence.
+ * Returned by toPersistedConfig to serialize widget-specific config.
+ */
+interface WidgetPersistenceData {
+    /** Data source type for storage (note: 'persistentQuery' maps to 'systemQuery' in backend) */
+    dataSourceType: DataSourceType;
+    /** CkTypeId for runtimeEntity data sources */
+    dataSourceCkTypeId?: string;
+    /** RtId for runtimeEntity or queryRtId for persistentQuery */
+    dataSourceRtId?: string;
+    /** Widget-specific configuration as JSON-serializable object */
+    config: Record<string, unknown>;
+}
+/**
+ * Interface that config dialog components must implement.
+ * Uses EventEmitters for save/cancelled events.
+ */
+interface WidgetConfigDialog<TResult extends WidgetConfigResult = WidgetConfigResult> {
+    initialCkTypeId?: string;
+    initialRtId?: string;
+    save: Subject<TResult>;
+    cancelled: Subject<void>;
+}
+/**
+ * Function type for applying config result to widget.
+ * Takes the current widget and config result, returns updated widget.
+ */
+type ConfigResultApplier<TWidget extends AnyWidgetConfig = AnyWidgetConfig, TResult extends WidgetConfigResult = WidgetConfigResult> = (widget: TWidget, result: TResult) => TWidget;
+/**
+ * Registration for a widget type including display component, config dialog, and result handler.
+ * This is the central definition for each widget type - all widget-specific logic lives here.
+ */
+interface WidgetRegistration<TWidget extends AnyWidgetConfig = AnyWidgetConfig, TResult extends WidgetConfigResult = WidgetConfigResult> {
+    /** Widget type identifier */
+    type: WidgetType;
+    /** Display name for UI */
+    label: string;
+    /** Component that renders the widget */
+    component: Type<unknown>;
+    /** Config dialog component (optional - some widgets may not be configurable) */
+    configDialogComponent?: Type<WidgetConfigDialog<TResult>>;
+    /** Function to apply config result to widget config */
+    applyConfigResult?: ConfigResultApplier<TWidget, TResult>;
+    /** Default size for the widget */
+    defaultSize: {
+        colSpan: number;
+        rowSpan: number;
+    };
+    /** Function to extract initial config values for dialog */
+    getInitialConfig?: (widget: TWidget) => Record<string, unknown>;
+    /**
+     * Data source types that this widget supports.
+     * Used by config dialogs to show only relevant options.
+     * If not specified, all data source types are assumed to be supported.
+     */
+    supportedDataSources?: DataSourceType[];
+    /**
+     * Creates a new widget with default configuration.
+     * Called when adding a new widget to the dashboard.
+     */
+    createDefaultConfig: (baseConfig: BaseWidgetConfig) => TWidget;
+    /**
+     * Serializes widget configuration for persistence.
+     * Extracts widget-specific data for storage in the backend.
+     */
+    toPersistedConfig: (widget: TWidget) => WidgetPersistenceData;
+    /**
+     * Deserializes persisted data back to widget configuration.
+     * Called when loading a dashboard from the backend.
+     */
+    fromPersistedConfig: (data: PersistedWidgetData, baseConfig: BaseWidgetConfig) => TWidget;
+}
+/**
+ * Result of opening a config dialog
+ */
+interface ConfigDialogResult<TResult extends WidgetConfigResult = WidgetConfigResult> {
+    saved: boolean;
+    result?: TResult;
+}
+/**
+ * Central registry for widget types.
+ * Manages widget components, config dialogs, and their interactions.
+ *
+ * Usage:
+ * 1. Widgets register themselves via registerWidget()
+ * 2. Dashboard uses getRegisteredWidgets() for "Add Widget" dialog
+ * 3. Dashboard uses getWidgetComponent() for rendering
+ * 4. Dashboard uses openConfigDialog() for configuration
+ */
+declare class WidgetRegistryService {
+    private readonly injector;
+    private readonly envInjector;
+    private readonly appRef;
+    private readonly registry;
+    /**
+     * Registers a widget type with its components and handlers.
+     */
+    registerWidget<TWidget extends AnyWidgetConfig = AnyWidgetConfig, TResult extends WidgetConfigResult = WidgetConfigResult>(registration: WidgetRegistration<TWidget, TResult>): void;
+    /**
+     * Gets all registered widget types for the "Add Widget" dialog.
+     */
+    getRegisteredWidgets(): {
+        type: WidgetType;
+        label: string;
+    }[];
+    /**
+     * Gets the display component for a widget type.
+     */
+    getWidgetComponent(type: WidgetType): Type<unknown> | undefined;
+    /**
+     * Gets the default size for a widget type.
+     */
+    getDefaultSize(type: WidgetType): {
+        colSpan: number;
+        rowSpan: number;
+    };
+    /**
+     * Gets the full registration for a widget type.
+     * Used by factory and persistence services to delegate widget-specific logic.
+     */
+    getRegistration(type: WidgetType): WidgetRegistration | undefined;
+    /**
+     * Gets the supported data source types for a widget.
+     * Returns all types if not specified in registration.
+     */
+    getSupportedDataSources(type: WidgetType): DataSourceType[];
+    /**
+     * Creates a new widget with default configuration.
+     * Delegates to the widget's createDefaultConfig function.
+     */
+    createWidget(type: WidgetType, baseConfig: BaseWidgetConfig): AnyWidgetConfig;
+    /**
+     * Serializes a widget for persistence.
+     * Delegates to the widget's toPersistedConfig function.
+     */
+    serializeWidget(widget: AnyWidgetConfig): WidgetPersistenceData;
+    /**
+     * Deserializes persisted data back to a widget configuration.
+     * Delegates to the widget's fromPersistedConfig function.
+     */
+    deserializeWidget(data: PersistedWidgetData): AnyWidgetConfig;
+    /**
+     * Builds base configuration from persisted data.
+     */
+    private buildBaseConfig;
+    /**
+     * Checks if a widget type has a config dialog.
+     */
+    hasConfigDialog(type: WidgetType): boolean;
+    /**
+     * Gets the config dialog component for a widget type.
+     */
+    getConfigDialogComponent(type: WidgetType): Type<WidgetConfigDialog> | undefined;
+    /**
+     * Gets the initial config values for a widget's config dialog.
+     */
+    getInitialConfig(widget: AnyWidgetConfig): Record<string, unknown>;
+    /**
+     * Applies config result to a widget.
+     */
+    applyConfigResult(widget: AnyWidgetConfig, result: WidgetConfigResult): AnyWidgetConfig;
+    /**
+     * Opens a config dialog for a widget and returns an Observable with the result.
+     * The dialog is created dynamically and destroyed after closing.
+     */
+    openConfigDialog(widget: AnyWidgetConfig): Observable<ConfigDialogResult>;
+    /**
+     * Opens a config dialog and waits for result (Promise version).
+     */
+    openConfigDialogAsync(widget: AnyWidgetConfig): Promise<ConfigDialogResult>;
+    /**
+     * Helper to extract ckTypeId from widget.
+     */
+    private getCkTypeId;
+    /**
+     * Helper to extract rtId from widget.
+     */
+    private getRtId;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WidgetRegistryService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<WidgetRegistryService>;
+}
+
+interface WidgetCreationOptions {
+    title: string;
+    type: WidgetType;
+    col?: number;
+    row?: number;
+    colSpan?: number;
+    rowSpan?: number;
+    ckTypeId?: string;
+}
+/**
+ * Service responsible for creating widget configurations.
+ * Delegates to WidgetRegistryService for widget-specific logic (SOLID: Open/Closed Principle).
+ */
+declare class WidgetFactoryService {
+    private readonly registry;
+    /**
+     * Generates a unique widget ID.
+     */
+    generateId(): string;
+    /**
+     * Creates a new widget with default configuration based on type.
+     * Delegates to the widget registration's createDefaultConfig function.
+     */
+    createWidget(options: WidgetCreationOptions): AnyWidgetConfig;
+    /**
+     * Gets the default size for a widget type.
+     * Delegates to WidgetRegistryService.
+     */
+    getDefaultSize(type: WidgetType): {
+        colSpan: number;
+        rowSpan: number;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WidgetFactoryService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<WidgetFactoryService>;
+}
+
+/**
+ * Service that manages edit mode state and snapshot/restore functionality.
+ * Provides a clean abstraction for entering/exiting edit mode with undo capability.
+ */
+declare class EditModeStateService {
+    private readonly _isEditMode;
+    private readonly _isSaving;
+    private snapshot;
+    readonly isEditMode: _angular_core.Signal<boolean>;
+    readonly isSaving: _angular_core.Signal<boolean>;
+    /**
+     * Enters edit mode and creates a snapshot of the provided data.
+     * @param data The data to snapshot for potential restoration
+     */
+    enterEditMode<T>(data: T): void;
+    /**
+     * Toggles edit mode. When entering, creates a snapshot of the provided data.
+     * @param data The data to snapshot when entering edit mode
+     * @returns true if now in edit mode, false if exited
+     */
+    toggleEditMode<T>(data: T): boolean;
+    /**
+     * Cancels edit mode and restores the original data from the snapshot.
+     * @returns The restored data, or null if no snapshot exists
+     */
+    cancelEdit<T>(): T | null;
+    /**
+     * Begins a save operation.
+     */
+    beginSave(): void;
+    /**
+     * Completes a save operation successfully, clearing the snapshot and exiting edit mode.
+     */
+    completeSave(): void;
+    /**
+     * Handles a failed save operation, staying in edit mode.
+     */
+    failSave(): void;
+    /**
+     * Checks if there are unsaved changes (snapshot exists).
+     */
+    hasUnsavedChanges(): boolean;
+    /**
+     * Gets the current snapshot without modifying state.
+     * Useful for comparing current state with original.
+     */
+    getSnapshot<T>(): T | null;
+    /**
+     * Updates the snapshot with new data while staying in edit mode.
+     * Useful when you want to update the "base" state during editing.
+     */
+    updateSnapshot<T>(data: T): void;
+    /**
+     * Resets all state (useful for cleanup).
+     */
+    reset(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EditModeStateService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<EditModeStateService>;
+}
+
+interface GridCell {
+    col: number;
+    row: number;
+}
+interface GridPosition {
+    col: number;
+    row: number;
+}
+/**
+ * Service for MeshBoard grid layout calculations and collision detection.
+ * Handles widget positioning, overlap detection, and finding available positions.
+ */
+declare class MeshBoardGridService {
+    /**
+     * Returns all grid cells occupied by a widget at the given position/size.
+     */
+    getCells(col: number, row: number, colSpan: number, rowSpan: number): GridCell[];
+    /**
+     * Checks if placing a widget at the given position/size would overlap with any other widget.
+     * Uses the model (not DOM) for accurate, predictable collision detection.
+     */
+    wouldCauseOverlap(widgets: AnyWidgetConfig[], widgetId: string, col: number, row: number, colSpan: number, rowSpan: number): boolean;
+    /**
+     * Checks if a widget would extend beyond the grid boundaries.
+     */
+    isOutOfBounds(col: number, colSpan: number, maxColumns: number): boolean;
+    /**
+     * Finds an available position for a widget of the given size.
+     */
+    findAvailablePosition(widgets: AnyWidgetConfig[], colSpan: number, rowSpan: number, maxColumns: number): GridPosition;
+    /**
+     * Resolves overlapping widgets by moving them to non-overlapping positions.
+     * Modifies the widgets array in place.
+     * Returns the list of widgets that were moved.
+     */
+    resolveOverlaps(widgets: AnyWidgetConfig[], maxColumns: number): AnyWidgetConfig[];
+    /**
+     * Gets all widgets that would be outside the grid if columns were reduced.
+     */
+    getWidgetsOutOfBounds(widgets: AnyWidgetConfig[], newColumns: number): AnyWidgetConfig[];
+    /**
+     * Calculates the maximum row used by any widget.
+     */
+    getMaxRow(widgets: AnyWidgetConfig[]): number;
+    /**
+     * Creates a set of all occupied cell keys from the widgets.
+     */
+    private getOccupiedCells;
+    /**
+     * Finds an available position using a pre-computed set of occupied cells.
+     */
+    private findAvailablePositionWithOccupied;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MeshBoardGridService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MeshBoardGridService>;
+}
+/** @deprecated Use MeshBoardGridService instead */
+declare const DashboardGridService: typeof MeshBoardGridService;
+
+declare class EntityCardWidgetComponent implements DashboardWidget<EntityCardWidgetConfig, RuntimeEntityData>, OnInit, OnChanges {
+    private readonly dataService;
+    config: EntityCardWidgetConfig;
+    private readonly _isLoading;
+    private readonly _data;
+    private readonly _error;
+    readonly isLoading: _angular_core.Signal<boolean>;
+    readonly data: _angular_core.Signal<RuntimeEntityData | null>;
+    readonly error: _angular_core.Signal<string | null>;
+    /**
+     * Check if widget is not configured (needs data source setup).
+     * This is a method (not computed) to ensure it re-evaluates when config changes via @Input.
+     */
+    isNotConfigured(): boolean;
+    readonly entityTypeName: _angular_core.Signal<string>;
+    readonly displayName: _angular_core.Signal<string>;
+    readonly filteredAttributes: _angular_core.Signal<_meshmakers_octo_meshboard.EntityAttribute[]>;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    refresh(): void;
+    private loadData;
+    formatValue(value: unknown): string;
+    formatAttributeName(name: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EntityCardWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EntityCardWidgetComponent, "mm-entity-card-widget", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Configuration result from the dialog
+ */
+interface EntityCardConfigResult {
+    ckTypeId: string;
+    rtId: string;
+}
+/**
+ * Configuration dialog for EntityCard and EntityAssociations widgets.
+ * Allows selecting a Runtime Entities type and a specific entity.
+ */
+declare class EntityCardConfigDialogComponent implements OnInit {
+    private readonly getEntitiesByCkTypeGQL;
+    private readonly ckTypeSelectorService;
+    ckTypeSelectorInput?: CkTypeSelectorInputComponent;
+    entitySelectorInput?: EntitySelectInputComponent;
+    initialCkTypeId?: string;
+    initialRtId?: string;
+    save: EventEmitter<EntityCardConfigResult>;
+    cancelled: EventEmitter<void>;
+    selectedCkType: CkTypeSelectorItem | null;
+    selectedEntity: RuntimeEntityItem$1 | null;
+    entityDataSource?: RuntimeEntitySelectDataSource$1;
+    entityDialogDataSource?: RuntimeEntityDialogDataSource$1;
+    isLoadingInitial: boolean;
+    get isValid(): boolean;
+    ngOnInit(): Promise<void>;
+    private loadInitialValues;
+    private loadInitialEntity;
+    onCkTypeSelected(ckType: CkTypeSelectorItem): void;
+    onCkTypeCleared(): void;
+    onEntitySelected(entity: RuntimeEntityItem$1): void;
+    onEntityCleared(): void;
+    onSave(): void;
+    onCancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EntityCardConfigDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EntityCardConfigDialogComponent, "mm-entity-card-config-dialog", never, { "initialCkTypeId": { "alias": "initialCkTypeId"; "required": false; }; "initialRtId": { "alias": "initialRtId"; "required": false; }; }, { "save": "save"; "cancelled": "cancelled"; }, never, never, true, never>;
+}
+
+declare class KpiWidgetComponent implements DashboardWidget<KpiWidgetConfig, RuntimeEntityData>, OnInit, OnChanges {
+    private readonly dataService;
+    private readonly executeRuntimeQueryGQL;
+    private readonly stateService;
+    private readonly variableService;
+    config: KpiWidgetConfig;
+    protected readonly arrowUpIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly arrowDownIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly minusIcon: _progress_kendo_svg_icons.SVGIcon;
+    private readonly _isLoading;
+    private readonly _data;
+    private readonly _error;
+    readonly isLoading: _angular_core.Signal<boolean>;
+    readonly data: _angular_core.Signal<RuntimeEntityData | null>;
+    readonly error: _angular_core.Signal<string | null>;
+    /**
+     * Check if widget is not configured (needs data source setup).
+     * This is a method (not computed) to ensure it re-evaluates when config changes via @Input.
+     */
+    isNotConfigured(): boolean;
+    readonly value: _angular_core.Signal<string>;
+    /**
+     * Gets a system property value from RuntimeEntityData.
+     * System properties are top-level properties like rtId, ckTypeId, rtWellKnownName.
+     */
+    private getSystemPropertyValue;
+    /**
+     * Formats a value for display in the KPI widget.
+     * Numbers are formatted with locale, strings are displayed as-is.
+     */
+    private formatDisplayValue;
+    readonly label: _angular_core.Signal<string>;
+    readonly trendIcon: _angular_core.Signal<_progress_kendo_svg_icons.SVGIcon>;
+    readonly trendClass: _angular_core.Signal<"trend-up" | "trend-down" | "trend-neutral">;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    refresh(): void;
+    private loadData;
+    private loadCountData;
+    private loadPersistentQueryData;
+    private extractAggregationValue;
+    private extractGroupedAggregationValue;
+    private parseNumericValue;
+    /**
+     * Extracts a cell value, preserving strings and converting numbers.
+     * Returns the value as-is if it's a string, or parses it as a number.
+     */
+    private extractCellValue;
+    private sanitizeFieldName;
+    /**
+     * Converts widget filter configuration to GraphQL FieldFilterDto format.
+     * Resolves MeshBoard variables in filter values before conversion.
+     */
+    private convertFiltersToDto;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KpiWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KpiWidgetComponent, "mm-kpi-widget", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Data source type for KPI
+ */
+type KpiDataSourceType = 'runtimeEntity' | 'persistentQuery';
+/**
+ * Configuration result from the KPI dialog
+ */
+interface KpiConfigResult extends WidgetConfigResult {
+    dataSourceType: KpiDataSourceType;
+    ckTypeId: string;
+    rtId?: string;
+    valueAttribute: string;
+    labelAttribute?: string;
+    queryRtId?: string;
+    queryName?: string;
+    queryMode?: KpiQueryMode;
+    queryValueField?: string;
+    queryCategoryField?: string;
+    queryCategoryValue?: string;
+    prefix?: string;
+    suffix?: string;
+    trend?: 'up' | 'down' | 'neutral';
+    filters?: FieldFilterDto[];
+}
+interface TrendOption {
+    value: 'up' | 'down' | 'neutral' | undefined;
+    label: string;
+}
+/**
+ * Configuration dialog for KPI widgets.
+ * Allows selecting data source, value attribute, and display options.
+ */
+declare class KpiConfigDialogComponent implements OnInit {
+    private readonly getEntitiesByCkTypeGQL;
+    private readonly ckTypeSelectorService;
+    private readonly attributeSelectorService;
+    private readonly executeRuntimeQueryGQL;
+    private readonly getCkTypeAvailableQueryColumnsGQL;
+    private readonly meshBoardStateService;
+    ckTypeSelectorInput?: CkTypeSelectorInputComponent;
+    entitySelectorInput?: EntitySelectInputComponent;
+    querySelector?: QuerySelectorComponent;
+    initialCkTypeId?: string;
+    initialRtId?: string;
+    initialValueAttribute?: string;
+    initialLabelAttribute?: string;
+    initialPrefix?: string;
+    initialSuffix?: string;
+    initialTrend?: 'up' | 'down' | 'neutral';
+    initialDataSourceType?: KpiDataSourceType;
+    initialQueryRtId?: string;
+    initialQueryName?: string;
+    initialQueryMode?: KpiQueryMode;
+    initialQueryValueField?: string;
+    initialQueryCategoryField?: string;
+    initialQueryCategoryValue?: string;
+    initialFilters?: WidgetFilterConfig[];
+    save: EventEmitter<KpiConfigResult>;
+    cancelled: EventEmitter<void>;
+    dataSourceType: KpiDataSourceType;
+    selectedCkType: CkTypeSelectorItem | null;
+    selectedEntity: RuntimeEntityItem$1 | null;
+    entityDataSource?: RuntimeEntitySelectDataSource$1;
+    entityDialogDataSource?: RuntimeEntityDialogDataSource$1;
+    isLoadingInitial: boolean;
+    isCountMode: boolean;
+    selectedPersistentQuery: PersistentQueryItem | null;
+    queryColumns: QueryColumnItem[];
+    categoryValues: CategoryValueItem[];
+    queryMode: KpiQueryMode;
+    isLoadingQueryColumns: boolean;
+    isLoadingCategoryValues: boolean;
+    readonly isLoadingAttributes: _angular_core.WritableSignal<boolean>;
+    readonly availableAttributes: _angular_core.WritableSignal<AttributeItem[]>;
+    readonly filteredValueAttributes: _angular_core.WritableSignal<AttributeItem[]>;
+    readonly filteredLabelAttributes: _angular_core.WritableSignal<AttributeItem[]>;
+    filters: FieldFilterItem[];
+    filterAttributes: AttributeItem[];
+    filterVariables: FilterVariable[];
+    form: {
+        valueAttribute: string;
+        labelAttribute: string;
+        prefix: string;
+        suffix: string;
+        trend: "up" | "down" | "neutral" | undefined;
+        queryValueField: string;
+        queryCategoryField: string;
+        queryCategoryValue: string;
+    };
+    trendOptions: TrendOption[];
+    queryModeOptions: {
+        value: KpiQueryMode;
+        label: string;
+    }[];
+    get isValid(): boolean;
+    ngOnInit(): Promise<void>;
+    private loadInitialValues;
+    private loadInitialEntity;
+    setCountMode(countMode: boolean): void;
+    onCkTypeSelected(ckType: CkTypeSelectorItem): void;
+    onCkTypeCleared(): void;
+    private loadAvailableAttributes;
+    onValueAttributeFilter(filter: string): void;
+    onLabelAttributeFilter(filter: string): void;
+    onEntitySelected(entity: RuntimeEntityItem$1): void;
+    onEntityCleared(): void;
+    onSave(): void;
+    onCancel(): void;
+    onDataSourceTypeChange(type: KpiDataSourceType): void;
+    onQuerySelected(query: PersistentQueryItem | null): Promise<void>;
+    onQueryModeChange(mode: KpiQueryMode): Promise<void>;
+    private loadQueryColumnsAndValues;
+    /**
+     * Loads all available filter attributes from the CK type.
+     * Uses getCkTypeAvailableQueryColumns to get all attributes, not just query result columns.
+     */
+    private loadFilterAttributesFromCkType;
+    onCategoryFieldChange(categoryField: string): Promise<void>;
+    private loadCategoryValuesForField;
+    private extractCategoryValues;
+    private sanitizeFieldName;
+    onFiltersChange(updatedFilters: FieldFilterItem[]): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KpiConfigDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KpiConfigDialogComponent, "mm-kpi-config-dialog", never, { "initialCkTypeId": { "alias": "initialCkTypeId"; "required": false; }; "initialRtId": { "alias": "initialRtId"; "required": false; }; "initialValueAttribute": { "alias": "initialValueAttribute"; "required": false; }; "initialLabelAttribute": { "alias": "initialLabelAttribute"; "required": false; }; "initialPrefix": { "alias": "initialPrefix"; "required": false; }; "initialSuffix": { "alias": "initialSuffix"; "required": false; }; "initialTrend": { "alias": "initialTrend"; "required": false; }; "initialDataSourceType": { "alias": "initialDataSourceType"; "required": false; }; "initialQueryRtId": { "alias": "initialQueryRtId"; "required": false; }; "initialQueryName": { "alias": "initialQueryName"; "required": false; }; "initialQueryMode": { "alias": "initialQueryMode"; "required": false; }; "initialQueryValueField": { "alias": "initialQueryValueField"; "required": false; }; "initialQueryCategoryField": { "alias": "initialQueryCategoryField"; "required": false; }; "initialQueryCategoryValue": { "alias": "initialQueryCategoryValue"; "required": false; }; "initialFilters": { "alias": "initialFilters"; "required": false; }; }, { "save": "save"; "cancelled": "cancelled"; }, never, never, true, never>;
+}
+
+interface GroupedAssociation {
+    roleId: string;
+    roleName: string;
+    targetType: string;
+    direction: 'in' | 'out';
+    count: number;
+    associations: EntityAssociation[];
+    isExpanded: boolean;
+}
+interface TargetEntity {
+    rtId: string;
+    ckTypeId: string;
+    displayName: string;
+}
+declare class EntityAssociationsWidgetComponent implements DashboardWidget<EntityWithAssociationsWidgetConfig, RuntimeEntityData>, OnInit, OnChanges {
+    private readonly dataService;
+    config: EntityWithAssociationsWidgetConfig;
+    protected readonly arrowRightIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly arrowLeftIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly linkIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly chevronDownIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly chevronRightIcon: _progress_kendo_svg_icons.SVGIcon;
+    private readonly _isLoading;
+    private readonly _data;
+    private readonly _error;
+    private readonly _expandedGroups;
+    protected showDetailDialog: boolean;
+    protected detailEntityRtId: string;
+    protected detailEntityCkTypeId: string;
+    readonly isLoading: _angular_core.Signal<boolean>;
+    readonly data: _angular_core.Signal<RuntimeEntityData | null>;
+    readonly error: _angular_core.Signal<string | null>;
+    /**
+     * Check if widget is not configured (needs data source setup).
+     * This is a method (not computed) to ensure it re-evaluates when config changes via @Input.
+     */
+    isNotConfigured(): boolean;
+    readonly entityName: _angular_core.Signal<string>;
+    readonly entityRtId: _angular_core.Signal<string>;
+    readonly entityCkTypeId: _angular_core.Signal<string>;
+    readonly displayMode: _angular_core.Signal<"count" | "expandable">;
+    readonly groupedAssociations: _angular_core.Signal<GroupedAssociation[]>;
+    readonly totalAssociations: _angular_core.Signal<number>;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    refresh(): void;
+    protected toggleGroup(group: GroupedAssociation): void;
+    protected isGroupExpanded(group: GroupedAssociation): boolean;
+    protected getTargetEntities(group: GroupedAssociation): TargetEntity[];
+    protected onTargetClick(target: TargetEntity): void;
+    protected onDetailDialogClosed(): void;
+    private loadData;
+    private formatRoleName;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EntityAssociationsWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EntityAssociationsWidgetComponent, "mm-entity-associations-widget", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Represents a runtime entity for selection
+ */
+interface RuntimeEntityItem {
+    rtId: string;
+    ckTypeId: string;
+    rtWellKnownName?: string;
+    displayName: string;
+}
+/**
+ * Represents an association role for selection
+ */
+interface AssociationRoleItem {
+    roleId: string;
+    navigationPropertyName: string;
+    direction: 'in' | 'out';
+    targetCkTypeId: string;
+    multiplicity: string;
+    displayName: string;
+}
+/**
+ * Configuration result from the dialog
+ */
+interface AssociationsConfigResult {
+    ckTypeId: string;
+    rtId: string;
+    showIncoming: boolean;
+    showOutgoing: boolean;
+    roleFilter: string[];
+    displayMode: 'count' | 'expandable';
+}
+/**
+ * Data source for entity autocomplete - filters by ckTypeId
+ */
+declare class RuntimeEntitySelectDataSource implements EntitySelectDataSource<RuntimeEntityItem> {
+    private getEntitiesByCkTypeGQL;
+    private ckTypeId;
+    constructor(getEntitiesByCkTypeGQL: GetEntitiesByCkTypeDtoGQL, ckTypeId: string);
+    onFilter(filter: string, take?: number): Promise<EntitySelectResult<RuntimeEntityItem>>;
+    onDisplayEntity(entity: RuntimeEntityItem): string;
+    getIdEntity(entity: RuntimeEntityItem): string;
+}
+/**
+ * Dialog data source for entity selection grid
+ */
+declare class RuntimeEntityDialogDataSource implements EntitySelectDialogDataSource<RuntimeEntityItem> {
+    private getEntitiesByCkTypeGQL;
+    private ckTypeId;
+    constructor(getEntitiesByCkTypeGQL: GetEntitiesByCkTypeDtoGQL, ckTypeId: string);
+    getColumns(): ColumnDefinition[];
+    fetchData(options: DialogFetchOptions): Observable<DialogFetchResult<RuntimeEntityItem>>;
+    onDisplayEntity(entity: RuntimeEntityItem): string;
+    getIdEntity(entity: RuntimeEntityItem): string;
+}
+/**
+ * Configuration dialog for EntityWithAssociations widget.
+ * Allows selecting a CK Type, runtime entity, direction filters, and role filters.
+ */
+declare class AssociationsConfigDialogComponent implements OnInit {
+    private readonly getEntitiesByCkTypeGQL;
+    private readonly getCkTypeAssociationRolesGQL;
+    private readonly ckTypeSelectorService;
+    initialCkTypeId?: string;
+    initialRtId?: string;
+    initialShowIncoming?: boolean;
+    initialShowOutgoing?: boolean;
+    initialRoleFilter?: string[];
+    initialDisplayMode?: 'count' | 'expandable';
+    save: EventEmitter<AssociationsConfigResult>;
+    cancelled: EventEmitter<void>;
+    selectedCkType: CkTypeSelectorItem | null;
+    selectedEntity: RuntimeEntityItem | null;
+    entityDataSource?: RuntimeEntitySelectDataSource;
+    entityDialogDataSource?: RuntimeEntityDialogDataSource;
+    showIncoming: boolean;
+    showOutgoing: boolean;
+    selectedRoles: AssociationRoleItem[];
+    displayMode: 'count' | 'expandable';
+    isLoadingInitial: boolean;
+    readonly isLoadingRoles: _angular_core.WritableSignal<boolean>;
+    readonly availableRoles: _angular_core.WritableSignal<AssociationRoleItem[]>;
+    readonly filteredRoles: _angular_core.WritableSignal<AssociationRoleItem[]>;
+    private roleFilterText;
+    get isValid(): boolean;
+    ngOnInit(): Promise<void>;
+    private loadInitialValues;
+    private loadInitialEntity;
+    onCkTypeSelected(ckType: CkTypeSelectorItem): Promise<void>;
+    onCkTypeCleared(): void;
+    onEntitySelected(entity: RuntimeEntityItem): void;
+    onEntityCleared(): void;
+    onRoleFilterChange(filter: string): void;
+    private updateFilteredRoles;
+    private loadAssociationRoles;
+    private formatTypeName;
+    onSave(): void;
+    onCancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AssociationsConfigDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AssociationsConfigDialogComponent, "mm-associations-config-dialog", never, { "initialCkTypeId": { "alias": "initialCkTypeId"; "required": false; }; "initialRtId": { "alias": "initialRtId"; "required": false; }; "initialShowIncoming": { "alias": "initialShowIncoming"; "required": false; }; "initialShowOutgoing": { "alias": "initialShowOutgoing"; "required": false; }; "initialRoleFilter": { "alias": "initialRoleFilter"; "required": false; }; "initialDisplayMode": { "alias": "initialDisplayMode"; "required": false; }; }, { "save": "save"; "cancelled": "cancelled"; }, never, never, true, never>;
+}
+
+/**
+ * Dialog component for displaying entity details using property grid.
+ * Shows all attributes of an entity with their names, values, and types.
+ */
+declare class EntityDetailDialogComponent implements OnInit {
+    private readonly getDashboardEntityGQL;
+    rtId: string;
+    ckTypeId: string;
+    closed: EventEmitter<void>;
+    readonly isLoading: _angular_core.WritableSignal<boolean>;
+    readonly error: _angular_core.WritableSignal<string | null>;
+    readonly rtWellKnownName: _angular_core.WritableSignal<string | null>;
+    readonly propertyGridData: _angular_core.WritableSignal<PropertyGridItem[]>;
+    readonly propertyGridConfig: PropertyGridConfig;
+    get dialogTitle(): string;
+    ngOnInit(): Promise<void>;
+    formatCkTypeId(ckTypeId: string): string;
+    private loadEntityDetails;
+    private formatAttributeName;
+    private inferAttributeType;
+    onClose(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EntityDetailDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EntityDetailDialogComponent, "mm-entity-detail-dialog", never, { "rtId": { "alias": "rtId"; "required": false; }; "ckTypeId": { "alias": "ckTypeId"; "required": false; }; }, { "closed": "closed"; }, never, never, true, never>;
+}
+
+/**
+ * Column info derived from a persistent query response
+ */
+interface QueryColumn {
+    attributePath: string;
+    attributeValueType: string;
+}
+/**
+ * DataSource directive for the Table Widget.
+ * Fetches entities based on the widget configuration (ckTypeId, filters, sorting).
+ * Supports both RuntimeEntity and PersistentQuery data sources.
+ */
+declare class TableWidgetDataSourceDirective extends OctoGraphQlDataSource<Record<string, unknown>> {
+    private readonly getEntitiesByCkTypeGQL;
+    private readonly executeRuntimeQueryGQL;
+    private readonly stateService;
+    private readonly variableService;
+    private _config;
+    /** Signal for dynamically derived columns from persistent query */
+    private readonly _queryColumns;
+    /** Exposed signal for reading derived columns */
+    readonly queryColumns: Signal<QueryColumn[]>;
+    /** Derived TableColumn array from persistent query columns */
+    readonly derivedColumns: Signal<TableColumn[]>;
+    /** Event emitted when query columns are loaded from a persistent query */
+    queryColumnsLoaded: EventEmitter<QueryColumn[]>;
+    set config(value: TableWidgetConfig | null);
+    get config(): TableWidgetConfig | null;
+    constructor();
+    fetchData(queryOptions: FetchDataOptions): Observable<FetchResultTyped<Record<string, unknown>> | null>;
+    /**
+     * Recursively flattens attributes into the record using dot notation for nested attributes.
+     * Handles nested CkRecord attributes by extracting their inner attributes.
+     */
+    private flattenAttributes;
+    /**
+     * Fetches data from a persistent query.
+     * Extracts columns from the query response and transforms cells to flat records.
+     */
+    private fetchPersistentQueryData;
+    /**
+     * Converts query columns to TableColumn format for display.
+     */
+    getTableColumnsFromQuery(): TableColumn[];
+    /**
+     * Clears the cached query columns. Call this before fetching new data
+     * when the query configuration changes.
+     */
+    clearQueryColumns(): void;
+    private formatColumnTitle;
+    /**
+     * Sanitizes field names for Kendo Grid compatibility.
+     * Kendo interprets dots as nested object paths, so we replace them with underscores.
+     */
+    private sanitizeFieldName;
+    /**
+     * Converts widget filter configuration to GraphQL FieldFilterDto format.
+     * Resolves MeshBoard variables in filter values before conversion.
+     */
+    private convertFiltersToDto;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableWidgetDataSourceDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TableWidgetDataSourceDirective, "[mmTableWidgetDataSource]", ["mmTableWidgetDataSource"], { "config": { "alias": "config"; "required": false; }; }, { "queryColumnsLoaded": "queryColumnsLoaded"; }, never, never, true, never>;
+}
+
+declare class TableWidgetComponent implements DashboardWidget<TableWidgetConfig, Record<string, unknown>[]>, OnChanges {
+    config: TableWidgetConfig;
+    dataSource?: TableWidgetDataSourceDirective;
+    private readonly _isLoading;
+    private readonly _data;
+    private readonly _error;
+    readonly isLoading: _angular_core.Signal<boolean>;
+    readonly data: _angular_core.Signal<Record<string, unknown>[]>;
+    readonly error: _angular_core.Signal<string | null>;
+    /** Signal to track query columns from data source (for persistent queries) */
+    private readonly _queryColumnsForView;
+    /**
+     * Called when the data source emits queryColumnsLoaded event.
+     * Updates the view columns directly from the emitted columns.
+     */
+    onQueryColumnsLoaded(columns: QueryColumn[]): void;
+    /**
+     * Converts TableWidgetConfig columns to ListViewComponent TableColumn format.
+     * For persistent queries, uses dynamically derived columns from the query response.
+     */
+    readonly listViewColumns: _angular_core.Signal<TableColumn$1[]>;
+    /**
+     * Checks if the widget has a valid configuration.
+     * Supports both runtimeEntity and persistentQuery data sources.
+     */
+    hasValidConfig(): boolean;
+    /**
+     * Checks if columns are ready to be displayed.
+     * For persistent queries, columns are derived from the query response.
+     * Returns true once columns are available.
+     */
+    readonly columnsReady: _angular_core.Signal<boolean>;
+    private formatColumnTitle;
+    ngOnChanges(changes: SimpleChanges): void;
+    refresh(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableWidgetComponent, "mm-table-widget", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Data source type for table widget
+ */
+type TableDataSourceType = 'runtimeEntity' | 'persistentQuery';
+/**
+ * Configuration result from the Table dialog
+ */
+interface TableConfigResult {
+    dataSourceType: TableDataSourceType;
+    ckTypeId: string;
+    columns: TableColumn[];
+    sorting: SortDto[];
+    filters: FieldFilterDto[];
+    queryRtId?: string;
+    queryName?: string;
+    pageSize: number;
+    sortable: boolean;
+}
+/**
+ * Configuration dialog for Table widgets.
+ * Uses the standard dialogs from octo-ui for column, sorting, and filter configuration.
+ */
+declare class TableConfigDialogComponent implements OnInit {
+    private readonly ckTypeSelectorService;
+    private readonly attributeSelectorDialog;
+    private readonly attributeSortSelectorDialog;
+    private readonly notificationService;
+    private readonly getCkTypeAvailableQueryColumnsGQL;
+    private readonly stateService;
+    ckTypeSelectorInput?: CkTypeSelectorInputComponent;
+    filterEditor?: FieldFilterEditorComponent;
+    querySelector?: QuerySelectorComponent;
+    initialDataSourceType?: TableDataSourceType;
+    initialCkTypeId?: string;
+    initialColumns?: TableColumn[];
+    initialSorting?: {
+        attributePath: string;
+        sortOrder: string;
+    }[];
+    initialFilters?: {
+        attributePath: string;
+        operator: string;
+        comparisonValue: string;
+    }[];
+    initialPageSize?: number;
+    initialSortable?: boolean;
+    initialQueryRtId?: string;
+    initialQueryName?: string;
+    save: EventEmitter<TableConfigResult>;
+    cancelled: EventEmitter<void>;
+    protected readonly columnsIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly sortIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly filterIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly searchIcon: _progress_kendo_svg_icons.SVGIcon;
+    dataSourceType: TableDataSourceType;
+    selectedCkType: CkTypeSelectorItem | null;
+    isLoadingInitial: boolean;
+    selectedColumns: string[];
+    sorting: SortDto[];
+    filters: FieldFilterItem[];
+    availableAttributes: AttributeItem[];
+    selectedPersistentQuery: PersistentQueryItem | null;
+    isLoadingQueryColumns: boolean;
+    queryFilterAttributes: AttributeItem[];
+    filterVariables: FilterVariable[];
+    form: {
+        pageSize: number;
+        sortable: boolean;
+    };
+    get isValid(): boolean;
+    ngOnInit(): Promise<void>;
+    private loadInitialValues;
+    private loadAvailableAttributes;
+    onCkTypeSelected(ckType: CkTypeSelectorItem): Promise<void>;
+    onCkTypeCleared(): void;
+    onDataSourceTypeChange(): void;
+    onQuerySelected(query: PersistentQueryItem | null): Promise<void>;
+    /**
+     * Loads all available filter attributes from the CK type.
+     * Uses getCkTypeAvailableQueryColumns instead of query result columns.
+     */
+    private loadFilterAttributesForQuery;
+    openColumnSelector(): Promise<void>;
+    openSortSelector(): Promise<void>;
+    onFiltersChange(filters: FieldFilterItem[]): void;
+    getColumnsSummary(): string;
+    getSortingSummary(): string;
+    onSave(): void;
+    private formatColumnTitle;
+    onCancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableConfigDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableConfigDialogComponent, "mm-table-config-dialog", never, { "initialDataSourceType": { "alias": "initialDataSourceType"; "required": false; }; "initialCkTypeId": { "alias": "initialCkTypeId"; "required": false; }; "initialColumns": { "alias": "initialColumns"; "required": false; }; "initialSorting": { "alias": "initialSorting"; "required": false; }; "initialFilters": { "alias": "initialFilters"; "required": false; }; "initialPageSize": { "alias": "initialPageSize"; "required": false; }; "initialSortable": { "alias": "initialSortable"; "required": false; }; "initialQueryRtId": { "alias": "initialQueryRtId"; "required": false; }; "initialQueryName": { "alias": "initialQueryName"; "required": false; }; }, { "save": "save"; "cancelled": "cancelled"; }, never, never, true, never>;
+}
+
+declare class GaugeWidgetComponent implements DashboardWidget<GaugeWidgetConfig, RuntimeEntityData>, OnInit, OnChanges {
+    pointers: {
+        value: number;
+        color: string;
+    }[];
+    private readonly dataService;
+    private readonly executeRuntimeQueryGQL;
+    private readonly stateService;
+    private readonly variableService;
+    config: GaugeWidgetConfig;
+    private readonly _isLoading;
+    private readonly _data;
+    private readonly _error;
+    readonly isLoading: _angular_core.Signal<boolean>;
+    readonly data: _angular_core.Signal<RuntimeEntityData | null>;
+    readonly error: _angular_core.Signal<string | null>;
+    /**
+     * Check if widget is not configured (needs data source setup).
+     * This is a method (not computed) to ensure it re-evaluates when config changes via @Input.
+     */
+    isNotConfigured(): boolean;
+    readonly numericValue: _angular_core.Signal<number>;
+    readonly formattedValue: _angular_core.Signal<string>;
+    readonly label: _angular_core.Signal<string>;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    refresh(): void;
+    private loadData;
+    private loadPersistentQueryData;
+    private extractAggregationValue;
+    private extractGroupedAggregationValue;
+    private parseNumericValue;
+    private sanitizeFieldName;
+    /**
+     * Converts widget filter configuration to GraphQL FieldFilterDto format.
+     * Resolves MeshBoard variables in filter values before conversion.
+     */
+    private convertFiltersToDto;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaugeWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaugeWidgetComponent, "mm-gauge-widget", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Data source type for Gauge
+ */
+type GaugeDataSourceType = 'runtimeEntity' | 'persistentQuery';
+/**
+ * Configuration result from the Gauge dialog
+ */
+interface GaugeConfigResult extends WidgetConfigResult {
+    dataSourceType: GaugeDataSourceType;
+    ckTypeId: string;
+    rtId?: string;
+    valueAttribute: string;
+    labelAttribute?: string;
+    queryRtId?: string;
+    queryName?: string;
+    queryMode?: KpiQueryMode;
+    queryValueField?: string;
+    queryCategoryField?: string;
+    queryCategoryValue?: string;
+    gaugeType: GaugeType;
+    min?: number;
+    max?: number;
+    ranges?: GaugeRange[];
+    showLabel?: boolean;
+    prefix?: string;
+    suffix?: string;
+    reverse?: boolean;
+    filters?: FieldFilterDto[];
+}
+interface GaugeTypeOption {
+    value: GaugeType;
+    label: string;
+    description: string;
+}
+/**
+ * Configuration dialog for Gauge widgets.
+ * Allows selecting data source, gauge type, value attribute, and display options.
+ */
+declare class GaugeConfigDialogComponent implements OnInit {
+    private readonly getEntitiesByCkTypeGQL;
+    private readonly ckTypeSelectorService;
+    private readonly attributeSelectorService;
+    private readonly executeRuntimeQueryGQL;
+    private readonly getCkTypeAvailableQueryColumnsGQL;
+    private readonly meshBoardStateService;
+    ckTypeSelectorInput?: CkTypeSelectorInputComponent;
+    entitySelectorInput?: EntitySelectInputComponent;
+    querySelector?: QuerySelectorComponent;
+    initialCkTypeId?: string;
+    initialRtId?: string;
+    initialGaugeType?: GaugeType;
+    initialValueAttribute?: string;
+    initialLabelAttribute?: string;
+    initialMin?: number;
+    initialMax?: number;
+    initialRanges?: GaugeRange[];
+    initialShowLabel?: boolean;
+    initialPrefix?: string;
+    initialSuffix?: string;
+    initialReverse?: boolean;
+    initialDataSourceType?: GaugeDataSourceType;
+    initialQueryRtId?: string;
+    initialQueryName?: string;
+    initialQueryMode?: KpiQueryMode;
+    initialQueryValueField?: string;
+    initialQueryCategoryField?: string;
+    initialQueryCategoryValue?: string;
+    initialFilters?: WidgetFilterConfig[];
+    save: EventEmitter<GaugeConfigResult>;
+    cancelled: EventEmitter<void>;
+    dataSourceType: GaugeDataSourceType;
+    selectedCkType: CkTypeSelectorItem | null;
+    selectedEntity: RuntimeEntityItem$1 | null;
+    entityDataSource?: RuntimeEntitySelectDataSource$1;
+    entityDialogDataSource?: RuntimeEntityDialogDataSource$1;
+    isLoadingInitial: boolean;
+    selectedPersistentQuery: PersistentQueryItem | null;
+    queryColumns: QueryColumnItem[];
+    categoryValues: CategoryValueItem[];
+    queryMode: KpiQueryMode;
+    isLoadingQueryColumns: boolean;
+    isLoadingCategoryValues: boolean;
+    readonly isLoadingAttributes: _angular_core.WritableSignal<boolean>;
+    readonly availableAttributes: _angular_core.WritableSignal<AttributeItem[]>;
+    readonly filteredValueAttributes: _angular_core.WritableSignal<AttributeItem[]>;
+    readonly filteredLabelAttributes: _angular_core.WritableSignal<AttributeItem[]>;
+    filters: FieldFilterItem[];
+    filterAttributes: AttributeItem[];
+    filterVariables: FilterVariable[];
+    form: {
+        gaugeType: GaugeType;
+        valueAttribute: string;
+        labelAttribute: string;
+        min: number | null;
+        max: number | null;
+        ranges: GaugeRange[];
+        showLabel: boolean;
+        prefix: string;
+        suffix: string;
+        reverse: boolean;
+        queryValueField: string;
+        queryCategoryField: string;
+        queryCategoryValue: string;
+    };
+    gaugeTypeOptions: GaugeTypeOption[];
+    queryModeOptions: {
+        value: KpiQueryMode;
+        label: string;
+    }[];
+    get isValid(): boolean;
+    ngOnInit(): Promise<void>;
+    private loadInitialValues;
+    private loadInitialEntity;
+    onCkTypeSelected(ckType: CkTypeSelectorItem): void;
+    onCkTypeCleared(): void;
+    private loadAvailableAttributes;
+    onValueAttributeFilter(filter: string): void;
+    onLabelAttributeFilter(filter: string): void;
+    onEntitySelected(entity: RuntimeEntityItem$1): void;
+    onEntityCleared(): void;
+    addRange(): void;
+    removeRange(index: number): void;
+    onSave(): void;
+    onCancel(): void;
+    onDataSourceTypeChange(type: GaugeDataSourceType): void;
+    onQuerySelected(query: PersistentQueryItem | null): Promise<void>;
+    onQueryModeChange(mode: KpiQueryMode): Promise<void>;
+    private loadQueryColumnsAndValues;
+    /**
+     * Loads all available filter attributes from the CK type.
+     * Uses getCkTypeAvailableQueryColumns to get all attributes, not just query result columns.
+     */
+    private loadFilterAttributesFromCkType;
+    onCategoryFieldChange(categoryField: string): Promise<void>;
+    private loadCategoryValuesForField;
+    private extractCategoryValues;
+    private sanitizeFieldName;
+    onFiltersChange(updatedFilters: FieldFilterItem[]): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaugeConfigDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaugeConfigDialogComponent, "mm-gauge-config-dialog", never, { "initialCkTypeId": { "alias": "initialCkTypeId"; "required": false; }; "initialRtId": { "alias": "initialRtId"; "required": false; }; "initialGaugeType": { "alias": "initialGaugeType"; "required": false; }; "initialValueAttribute": { "alias": "initialValueAttribute"; "required": false; }; "initialLabelAttribute": { "alias": "initialLabelAttribute"; "required": false; }; "initialMin": { "alias": "initialMin"; "required": false; }; "initialMax": { "alias": "initialMax"; "required": false; }; "initialRanges": { "alias": "initialRanges"; "required": false; }; "initialShowLabel": { "alias": "initialShowLabel"; "required": false; }; "initialPrefix": { "alias": "initialPrefix"; "required": false; }; "initialSuffix": { "alias": "initialSuffix"; "required": false; }; "initialReverse": { "alias": "initialReverse"; "required": false; }; "initialDataSourceType": { "alias": "initialDataSourceType"; "required": false; }; "initialQueryRtId": { "alias": "initialQueryRtId"; "required": false; }; "initialQueryName": { "alias": "initialQueryName"; "required": false; }; "initialQueryMode": { "alias": "initialQueryMode"; "required": false; }; "initialQueryValueField": { "alias": "initialQueryValueField"; "required": false; }; "initialQueryCategoryField": { "alias": "initialQueryCategoryField"; "required": false; }; "initialQueryCategoryValue": { "alias": "initialQueryCategoryValue"; "required": false; }; "initialFilters": { "alias": "initialFilters"; "required": false; }; }, { "save": "save"; "cancelled": "cancelled"; }, never, never, true, never>;
+}
+
+/**
+ * Data item for the pie chart
+ */
+interface ChartDataItem {
+    category: string;
+    value: number;
+}
+declare class PieChartWidgetComponent implements DashboardWidget<PieChartWidgetConfig, ChartDataItem[]>, OnInit, OnChanges {
+    private readonly executeRuntimeQueryGQL;
+    private readonly dataService;
+    private readonly stateService;
+    private readonly variableService;
+    config: PieChartWidgetConfig;
+    private readonly _isLoading;
+    private readonly _chartData;
+    private readonly _error;
+    readonly isLoading: _angular_core.Signal<boolean>;
+    readonly chartData: _angular_core.Signal<ChartDataItem[]>;
+    readonly error: _angular_core.Signal<string | null>;
+    readonly data: _angular_core.Signal<ChartDataItem[]>;
+    /**
+     * Check if widget is not configured (needs data source setup).
+     * This is a method (not computed) to ensure it re-evaluates when config changes via @Input.
+     */
+    isNotConfigured(): boolean;
+    readonly labelSettings: _angular_core.Signal<{
+        visible: boolean;
+        content: (e: {
+            category: string;
+            value: number;
+        }) => string;
+    }>;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    refresh(): void;
+    hasValidConfig(): boolean;
+    formatValue(value: number): string;
+    private loadData;
+    /**
+     * Loads data from Construction Kit query data source.
+     */
+    private loadCkQueryData;
+    /**
+     * Loads data from persistent query data source.
+     * Note: isNotConfigured() check in loadData() ensures queryRtId is set.
+     */
+    private loadPersistentQueryData;
+    /**
+     * Sanitizes field names for comparison.
+     * Replaces dots with underscores (same as table widget).
+     */
+    private sanitizeFieldName;
+    /**
+     * Converts widget filter configuration to GraphQL FieldFilterDto format.
+     * Resolves MeshBoard variables in filter values before conversion.
+     */
+    private convertFiltersToDto;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PieChartWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PieChartWidgetComponent, "mm-pie-chart-widget", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Configuration result from the Pie Chart dialog
+ */
+interface PieChartConfigResult extends WidgetConfigResult {
+    dataSourceType: DataSourceType;
+    queryRtId?: string;
+    queryName?: string;
+    categoryField: string;
+    valueField: string;
+    ckQueryTarget?: CkQueryTarget;
+    ckGroupBy?: string;
+    chartType: PieChartType;
+    showLabels: boolean;
+    showLegend: boolean;
+    legendPosition: 'top' | 'bottom' | 'left' | 'right';
+    filters?: FieldFilterDto[];
+}
+/**
+ * Configuration dialog for Pie Chart widgets.
+ */
+declare class PieChartConfigDialogComponent implements OnInit {
+    private readonly executeRuntimeQueryGQL;
+    private readonly getCkTypeAvailableQueryColumnsGQL;
+    private readonly stateService;
+    querySelector?: QuerySelectorComponent;
+    initialDataSourceType?: DataSourceType;
+    initialQueryRtId?: string;
+    initialQueryName?: string;
+    initialChartType?: PieChartType;
+    initialCategoryField?: string;
+    initialValueField?: string;
+    initialShowLabels?: boolean;
+    initialShowLegend?: boolean;
+    initialLegendPosition?: 'top' | 'bottom' | 'left' | 'right';
+    initialCkQueryTarget?: CkQueryTarget;
+    initialCkGroupBy?: string;
+    initialFilters?: WidgetFilterConfig[];
+    save: EventEmitter<PieChartConfigResult>;
+    cancelled: EventEmitter<void>;
+    protected readonly searchIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly chartPieIcon: _progress_kendo_svg_icons.SVGIcon;
+    isLoadingInitial: boolean;
+    isLoadingColumns: boolean;
+    dataSourceTypes: {
+        value: string;
+        label: string;
+    }[];
+    ckQueryTargets: {
+        value: string;
+        label: string;
+    }[];
+    ckGroupByOptions: {
+        value: string;
+        label: string;
+    }[];
+    selectedPersistentQuery: PersistentQueryItem | null;
+    queryColumns: QueryColumnItem[];
+    filters: FieldFilterItem[];
+    filterAttributes: AttributeItem[];
+    filterVariables: FilterVariable[];
+    legendPositions: {
+        value: string;
+        label: string;
+    }[];
+    form: {
+        dataSourceType: DataSourceType;
+        chartType: PieChartType;
+        categoryField: string;
+        valueField: string;
+        showLabels: boolean;
+        showLegend: boolean;
+        legendPosition: "top" | "bottom" | "left" | "right";
+        ckQueryTarget: CkQueryTarget;
+        ckGroupBy: string;
+    };
+    get isValid(): boolean;
+    ngOnInit(): Promise<void>;
+    onDataSourceTypeChange(dataSourceType: DataSourceType): void;
+    onCkQueryTargetChange(target: CkQueryTarget): void;
+    private updateCkGroupByOptions;
+    onQuerySelected(query: PersistentQueryItem | null): Promise<void>;
+    private loadQueryColumns;
+    /**
+     * Loads all available filter attributes from the CK type.
+     * Uses getCkTypeAvailableQueryColumns to get all attributes, not just query result columns.
+     */
+    private loadFilterAttributes;
+    private sanitizeFieldName;
+    onFiltersChange(updatedFilters: FieldFilterItem[]): void;
+    onSave(): void;
+    onCancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PieChartConfigDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PieChartConfigDialogComponent, "mm-pie-chart-config-dialog", never, { "initialDataSourceType": { "alias": "initialDataSourceType"; "required": false; }; "initialQueryRtId": { "alias": "initialQueryRtId"; "required": false; }; "initialQueryName": { "alias": "initialQueryName"; "required": false; }; "initialChartType": { "alias": "initialChartType"; "required": false; }; "initialCategoryField": { "alias": "initialCategoryField"; "required": false; }; "initialValueField": { "alias": "initialValueField"; "required": false; }; "initialShowLabels": { "alias": "initialShowLabels"; "required": false; }; "initialShowLegend": { "alias": "initialShowLegend"; "required": false; }; "initialLegendPosition": { "alias": "initialLegendPosition"; "required": false; }; "initialCkQueryTarget": { "alias": "initialCkQueryTarget"; "required": false; }; "initialCkGroupBy": { "alias": "initialCkGroupBy"; "required": false; }; "initialFilters": { "alias": "initialFilters"; "required": false; }; }, { "save": "save"; "cancelled": "cancelled"; }, never, never, true, never>;
+}
+
+/**
+ * Series data for the bar chart
+ */
+interface SeriesData {
+    name: string;
+    data: number[];
+    color?: string;
+}
+declare class BarChartWidgetComponent implements DashboardWidget<BarChartWidgetConfig, SeriesData[]>, OnInit, OnChanges {
+    private readonly executeRuntimeQueryGQL;
+    private readonly stateService;
+    private readonly variableService;
+    config: BarChartWidgetConfig;
+    private readonly _isLoading;
+    private readonly _categories;
+    private readonly _seriesData;
+    private readonly _error;
+    readonly isLoading: _angular_core.Signal<boolean>;
+    readonly categories: _angular_core.Signal<string[]>;
+    readonly seriesData: _angular_core.Signal<SeriesData[]>;
+    readonly error: _angular_core.Signal<string | null>;
+    readonly data: _angular_core.Signal<SeriesData[]>;
+    /**
+     * Check if widget is not configured (needs data source setup).
+     * This is a method (not computed) to ensure it re-evaluates when config changes via @Input.
+     */
+    isNotConfigured(): boolean;
+    readonly kendoChartType: _angular_core.Signal<"column" | "bar">;
+    readonly stackConfig: _angular_core.Signal<string | boolean>;
+    readonly labelRotation: _angular_core.Signal<0 | -45>;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    refresh(): void;
+    hasValidConfig(): boolean;
+    /**
+     * Checks if using dynamic series mode (seriesGroupField + valueField)
+     */
+    private isDynamicSeriesMode;
+    formatValue(value: number): string;
+    private loadData;
+    /**
+     * Processes data in Static Series Mode.
+     * Each series in config.series corresponds to a separate numeric field.
+     */
+    private processStaticSeriesData;
+    /**
+     * Processes data in Dynamic Series Mode.
+     * Series are created dynamically from unique values of seriesGroupField.
+     * Each row represents a combination of category + series group + value.
+     *
+     * Example data structure:
+     * - Row 1: { legalEntityType: 'Company', billingType: 'Credit', quantity: 261721 }
+     * - Row 2: { legalEntityType: 'Company', billingType: 'Debit', quantity: 65263 }
+     * - ...
+     *
+     * Results in:
+     * - Categories: ['Company', 'LegalPerson', 'LocalAuthority', 'NaturalPerson']
+     * - Series 'Credit': [261721, 70343, 23140, 189794]
+     * - Series 'Debit': [65263, 60153, 159636, 108225]
+     */
+    private processDynamicSeriesData;
+    /**
+     * Sanitizes field names for comparison.
+     * Replaces dots with underscores (same as table widget).
+     */
+    private sanitizeFieldName;
+    /**
+     * Converts widget filter configuration to GraphQL FieldFilterDto format.
+     * Resolves MeshBoard variables in filter values before conversion.
+     */
+    private convertFiltersToDto;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BarChartWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BarChartWidgetComponent, "mm-bar-chart-widget", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Series configuration mode
+ */
+type SeriesMode = 'static' | 'dynamic';
+/**
+ * Configuration result from the Bar Chart dialog
+ */
+interface BarChartConfigResult extends WidgetConfigResult {
+    queryRtId: string;
+    queryName?: string;
+    chartType: BarChartType;
+    categoryField: string;
+    series: BarChartSeries[];
+    /** Series Group Field for dynamic series mode */
+    seriesGroupField?: string;
+    /** Value Field for dynamic series mode */
+    valueField?: string;
+    showLegend: boolean;
+    legendPosition: 'top' | 'bottom' | 'left' | 'right';
+    showDataLabels: boolean;
+    filters?: FieldFilterDto[];
+}
+/**
+ * Configuration dialog for Bar Chart widgets.
+ * Supports column, bar, stacked, and 100% stacked chart types.
+ */
+declare class BarChartConfigDialogComponent implements OnInit {
+    private readonly executeRuntimeQueryGQL;
+    private readonly getCkTypeAvailableQueryColumnsGQL;
+    private readonly stateService;
+    querySelector?: QuerySelectorComponent;
+    initialQueryRtId?: string;
+    initialQueryName?: string;
+    initialChartType?: BarChartType;
+    initialCategoryField?: string;
+    initialSeries?: BarChartSeries[];
+    initialSeriesGroupField?: string;
+    initialValueField?: string;
+    initialShowLegend?: boolean;
+    initialLegendPosition?: 'top' | 'bottom' | 'left' | 'right';
+    initialShowDataLabels?: boolean;
+    initialFilters?: WidgetFilterConfig[];
+    save: EventEmitter<BarChartConfigResult>;
+    cancelled: EventEmitter<void>;
+    isLoadingInitial: boolean;
+    isLoadingColumns: boolean;
+    selectedPersistentQuery: PersistentQueryItem | null;
+    queryColumns: QueryColumnItem[];
+    numericColumns: QueryColumnItem[];
+    filters: FieldFilterItem[];
+    filterAttributes: AttributeItem[];
+    filterVariables: FilterVariable[];
+    seriesMode: SeriesMode;
+    selectedSeriesFields: string[];
+    seriesGroupField: string;
+    valueField: string;
+    nonNumericColumns: QueryColumnItem[];
+    seriesModeOptions: {
+        value: string;
+        label: string;
+    }[];
+    legendPositions: {
+        value: string;
+        label: string;
+    }[];
+    form: {
+        chartType: BarChartType;
+        categoryField: string;
+        showLegend: boolean;
+        legendPosition: "top" | "bottom" | "left" | "right";
+        showDataLabels: boolean;
+    };
+    get isValid(): boolean;
+    ngOnInit(): Promise<void>;
+    onQuerySelected(query: PersistentQueryItem | null): Promise<void>;
+    private loadQueryColumns;
+    /**
+     * Loads all available filter attributes from the CK type.
+     * Uses getCkTypeAvailableQueryColumns to get all attributes, not just query result columns.
+     */
+    private loadFilterAttributes;
+    private sanitizeFieldName;
+    onSeriesFieldsChange(fields: string[]): void;
+    onFiltersChange(updatedFilters: FieldFilterItem[]): void;
+    onSave(): void;
+    onCancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BarChartConfigDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BarChartConfigDialogComponent, "mm-bar-chart-config-dialog", never, { "initialQueryRtId": { "alias": "initialQueryRtId"; "required": false; }; "initialQueryName": { "alias": "initialQueryName"; "required": false; }; "initialChartType": { "alias": "initialChartType"; "required": false; }; "initialCategoryField": { "alias": "initialCategoryField"; "required": false; }; "initialSeries": { "alias": "initialSeries"; "required": false; }; "initialSeriesGroupField": { "alias": "initialSeriesGroupField"; "required": false; }; "initialValueField": { "alias": "initialValueField"; "required": false; }; "initialShowLegend": { "alias": "initialShowLegend"; "required": false; }; "initialLegendPosition": { "alias": "initialLegendPosition"; "required": false; }; "initialShowDataLabels": { "alias": "initialShowDataLabels"; "required": false; }; "initialFilters": { "alias": "initialFilters"; "required": false; }; }, { "save": "save"; "cancelled": "cancelled"; }, never, never, true, never>;
+}
+
+interface StatValue {
+    label: string;
+    value: number | null;
+    color: string;
+    prefix?: string;
+    suffix?: string;
+    isLoading: boolean;
+}
+declare class StatsGridWidgetComponent implements OnInit, OnChanges {
+    private readonly dataService;
+    config: StatsGridWidgetConfig;
+    private readonly _isLoading;
+    private readonly _error;
+    private readonly _statValues;
+    readonly isLoading: _angular_core.Signal<boolean>;
+    readonly error: _angular_core.Signal<string | null>;
+    readonly statValues: _angular_core.Signal<StatValue[]>;
+    /**
+     * Check if widget is not configured (needs stats configuration).
+     * This is a method (not computed) to ensure it re-evaluates when config changes via @Input.
+     */
+    isNotConfigured(): boolean;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    refresh(): void;
+    private loadData;
+    private getColorClass;
+    formatValue(stat: StatValue): string;
+    get gridColumns(): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StatsGridWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StatsGridWidgetComponent, "mm-stats-grid-widget", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface StatsGridConfigResult extends WidgetConfigResult {
+    ckTypeId: string;
+    stats: StatItem[];
+    queries: AggregationQuery[];
+    columns: number;
+}
+interface ColorOption {
+    value: StatColor;
+    label: string;
+    color: string;
+}
+interface CkTypeOption {
+    value: string;
+    label: string;
+}
+interface EditableStat {
+    id: string;
+    label: string;
+    ckTypeId: string;
+    aggregation: AggregationType;
+    color: StatColor;
+    prefix?: string;
+    suffix?: string;
+}
+declare class StatsGridConfigDialogComponent implements OnInit {
+    initialStats?: StatItem[];
+    initialQueries?: AggregationQuery[];
+    initialColumns?: number;
+    save: EventEmitter<StatsGridConfigResult>;
+    cancelled: EventEmitter<void>;
+    colorOptions: ColorOption[];
+    ckTypeOptions: CkTypeOption[];
+    filteredCkTypeOptions: CkTypeOption[];
+    aggregationOptions: AggregationType[];
+    form: {
+        columns: number;
+        stats: EditableStat[];
+    };
+    private nextId;
+    get isValid(): boolean;
+    ngOnInit(): void;
+    onCkTypeFilter(filter: string): void;
+    addStat(): void;
+    removeStat(index: number): void;
+    onSave(): void;
+    onCancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StatsGridConfigDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StatsGridConfigDialogComponent, "mm-stats-grid-config-dialog", never, { "initialStats": { "alias": "initialStats"; "required": false; }; "initialQueries": { "alias": "initialQueries"; "required": false; }; "initialColumns": { "alias": "initialColumns"; "required": false; }; }, { "save": "save"; "cancelled": "cancelled"; }, never, never, true, never>;
+}
+
+declare class StatusIndicatorWidgetComponent implements OnInit, OnChanges {
+    private readonly ckModelService;
+    config: StatusIndicatorWidgetConfig;
+    private readonly _isLoading;
+    private readonly _error;
+    private readonly _status;
+    readonly isLoading: _angular_core.Signal<boolean>;
+    readonly error: _angular_core.Signal<string | null>;
+    readonly status: _angular_core.Signal<boolean | null>;
+    /**
+     * Check if widget is not configured (needs service call setup).
+     * This is a method (not computed) to ensure it re-evaluates when config changes via @Input.
+     */
+    isNotConfigured(): boolean;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    refresh(): void;
+    private loadStatus;
+    private checkModelAvailable;
+    get statusLabel(): string;
+    get statusColor(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StatusIndicatorWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StatusIndicatorWidgetComponent, "mm-status-indicator-widget", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface StatusIndicatorConfigResult extends WidgetConfigResult {
+    ckTypeId: string;
+    callType: ServiceCallDataSource['callType'];
+    modelName?: string;
+    serviceType?: ServiceCallDataSource['serviceType'];
+    trueLabel?: string;
+    falseLabel?: string;
+    trueColor?: string;
+    falseColor?: string;
+}
+interface CallTypeOption {
+    value: ServiceCallDataSource['callType'];
+    label: string;
+}
+interface ServiceTypeOption$1 {
+    value: ServiceCallDataSource['serviceType'];
+    label: string;
+}
+declare class StatusIndicatorConfigDialogComponent implements OnInit {
+    initialCallType?: ServiceCallDataSource['callType'];
+    initialModelName?: string;
+    initialServiceType?: ServiceCallDataSource['serviceType'];
+    initialTrueLabel?: string;
+    initialFalseLabel?: string;
+    initialTrueColor?: string;
+    initialFalseColor?: string;
+    save: EventEmitter<StatusIndicatorConfigResult>;
+    cancelled: EventEmitter<void>;
+    callTypeOptions: CallTypeOption[];
+    serviceTypeOptions: ServiceTypeOption$1[];
+    form: {
+        callType: ServiceCallDataSource["callType"];
+        modelName: string;
+        serviceType: ServiceCallDataSource["serviceType"];
+        trueLabel: string;
+        falseLabel: string;
+        trueColor: string;
+        falseColor: string;
+    };
+    get isValid(): boolean;
+    ngOnInit(): void;
+    onCallTypeChange(callType: ServiceCallDataSource['callType']): void;
+    onSave(): void;
+    onCancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StatusIndicatorConfigDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StatusIndicatorConfigDialogComponent, "mm-status-indicator-config-dialog", never, { "initialCallType": { "alias": "initialCallType"; "required": false; }; "initialModelName": { "alias": "initialModelName"; "required": false; }; "initialServiceType": { "alias": "initialServiceType"; "required": false; }; "initialTrueLabel": { "alias": "initialTrueLabel"; "required": false; }; "initialFalseLabel": { "alias": "initialFalseLabel"; "required": false; }; "initialTrueColor": { "alias": "initialTrueColor"; "required": false; }; "initialFalseColor": { "alias": "initialFalseColor"; "required": false; }; }, { "save": "save"; "cancelled": "cancelled"; }, never, never, true, never>;
+}
+
+type HealthStatus = 'healthy' | 'unhealthy' | 'unknown' | 'loading';
+declare class ServiceHealthWidgetComponent implements OnInit, OnChanges, OnDestroy {
+    private readonly healthService;
+    private readonly router;
+    config: ServiceHealthWidgetConfig;
+    private readonly _healthStatus;
+    private readonly _error;
+    private readonly _lastChecked;
+    readonly healthStatus: _angular_core.Signal<HealthStatus>;
+    readonly error: _angular_core.Signal<string | null>;
+    readonly lastChecked: _angular_core.Signal<Date | null>;
+    /**
+     * Check if widget is not configured (needs service call setup).
+     * This is a method (not computed) to ensure it re-evaluates when config changes via @Input.
+     */
+    isNotConfigured(): boolean;
+    private refreshSubscription?;
+    private readonly REFRESH_INTERVAL;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    refresh(): void;
+    onClick(): void;
+    private startAutoRefresh;
+    private stopAutoRefresh;
+    private checkHealth;
+    private performHealthCheck;
+    get serviceName(): string;
+    get statusLabel(): string;
+    get showPulse(): boolean;
+    get isClickable(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ServiceHealthWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ServiceHealthWidgetComponent, "mm-service-health-widget", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface ServiceHealthConfigResult extends WidgetConfigResult {
+    ckTypeId: string;
+    serviceType: ServiceCallDataSource['serviceType'];
+    customEndpoint?: string;
+    showPulse: boolean;
+    navigateOnClick: boolean;
+    detailRoute?: string;
+}
+interface ServiceTypeOption {
+    value: ServiceCallDataSource['serviceType'];
+    label: string;
+}
+declare class ServiceHealthConfigDialogComponent implements OnInit {
+    initialServiceType?: ServiceCallDataSource['serviceType'];
+    initialCustomEndpoint?: string;
+    initialShowPulse?: boolean;
+    initialNavigateOnClick?: boolean;
+    initialDetailRoute?: string;
+    save: EventEmitter<ServiceHealthConfigResult>;
+    cancelled: EventEmitter<void>;
+    serviceTypeOptions: ServiceTypeOption[];
+    form: {
+        serviceType: ServiceCallDataSource["serviceType"];
+        customEndpoint: string;
+        showPulse: boolean;
+        navigateOnClick: boolean;
+        detailRoute: string;
+    };
+    get isValid(): boolean;
+    ngOnInit(): void;
+    onServiceTypeChange(serviceType: ServiceCallDataSource['serviceType']): void;
+    onSave(): void;
+    onCancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ServiceHealthConfigDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ServiceHealthConfigDialogComponent, "mm-service-health-config-dialog", never, { "initialServiceType": { "alias": "initialServiceType"; "required": false; }; "initialCustomEndpoint": { "alias": "initialCustomEndpoint"; "required": false; }; "initialShowPulse": { "alias": "initialShowPulse"; "required": false; }; "initialNavigateOnClick": { "alias": "initialNavigateOnClick"; "required": false; }; "initialDetailRoute": { "alias": "initialDetailRoute"; "required": false; }; }, { "save": "save"; "cancelled": "cancelled"; }, never, never, true, never>;
+}
+
+/**
+ * Widget Group Component
+ *
+ * Renders a collection of child widgets based on data from a repeater query.
+ * Acts as a container that executes a query and dynamically creates child widgets
+ * for each row/entity returned.
+ *
+ * Example use case: Query returns 5 machines → 5 KPI widgets show each machine's status.
+ */
+declare class WidgetGroupComponent implements DashboardWidget<WidgetGroupConfig, RepeaterDataItem[]>, OnInit, OnChanges {
+    private readonly dataService;
+    private readonly variableService;
+    private readonly stateService;
+    config: WidgetGroupConfig;
+    private readonly _isLoading;
+    private readonly _data;
+    private readonly _error;
+    readonly isLoading: _angular_core.Signal<boolean>;
+    readonly data: _angular_core.Signal<RepeaterDataItem[] | null>;
+    readonly error: _angular_core.Signal<string | null>;
+    /**
+     * Computed: Check if widget is not configured (needs data source setup).
+     */
+    readonly isNotConfigured: _angular_core.Signal<boolean>;
+    /**
+     * Computed: Generate child widget configs from data items
+     */
+    readonly childConfigs: _angular_core.Signal<AnyWidgetConfig[]>;
+    /**
+     * Computed: CSS grid template columns based on layout configuration
+     */
+    readonly gridTemplateColumns: _angular_core.Signal<string>;
+    /**
+     * Computed: Layout CSS class
+     */
+    readonly layoutClass: _angular_core.Signal<string>;
+    /**
+     * Computed: Gap style
+     */
+    readonly gapStyle: _angular_core.Signal<string>;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    refresh(): void;
+    private loadData;
+    /**
+     * Creates a child widget configuration from a data item.
+     * Applies the template configuration and maps attributes.
+     */
+    private createChildConfig;
+    /**
+     * Creates a KPI widget config for a child widget.
+     */
+    private createKpiChildConfig;
+    /**
+     * Creates a Gauge widget config for a child widget.
+     */
+    private createGaugeChildConfig;
+    /**
+     * Creates an Entity Card widget config for a child widget.
+     */
+    private createEntityCardChildConfig;
+    /**
+     * Converts a RepeaterDataItem to RuntimeEntityData format.
+     */
+    private convertToRuntimeEntityData;
+    /**
+     * Resolves a template string with variable substitution.
+     * Supports $rtWellKnownName, $rtId, $ckTypeId, and $attributeName syntax.
+     */
+    private resolveTemplate;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WidgetGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WidgetGroupComponent, "mm-widget-group", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Data source type selection
+ */
+type WidgetGroupDataSourceMode = 'persistentQuery' | 'ckType';
+/**
+ * Configuration result from the Widget Group dialog
+ */
+interface WidgetGroupConfigResult extends WidgetConfigResult {
+    /** Required by WidgetConfigResult - empty string for query mode, actual type for ckType mode */
+    ckTypeId: string;
+    dataSourceMode: WidgetGroupDataSourceMode;
+    queryRtId?: string;
+    queryName?: string;
+    filters?: FieldFilterDto[];
+    maxItems?: number;
+    childTemplate: WidgetGroupChildTemplate;
+    layout: WidgetGroupLayout;
+    gridColumns?: number;
+    minChildWidth?: number;
+    gap?: number;
+    emptyMessage?: string;
+}
+/**
+ * Configuration dialog for Widget Group widgets.
+ * Allows configuring data source, child widget template, and layout options.
+ */
+declare class WidgetGroupConfigDialogComponent implements OnInit {
+    private readonly ckTypeSelectorService;
+    private readonly attributeSelectorService;
+    private readonly executeRuntimeQueryGQL;
+    private readonly getCkTypeAvailableQueryColumnsGQL;
+    private readonly meshBoardStateService;
+    querySelector?: QuerySelectorComponent;
+    initialDataSourceMode?: WidgetGroupDataSourceMode;
+    initialQueryRtId?: string;
+    initialQueryName?: string;
+    initialCkTypeId?: string;
+    initialFilters?: WidgetFilterConfig[];
+    initialMaxItems?: number;
+    initialChildTemplate?: WidgetGroupChildTemplate;
+    initialLayout?: WidgetGroupLayout;
+    initialGridColumns?: number;
+    initialMinChildWidth?: number;
+    initialGap?: number;
+    initialEmptyMessage?: string;
+    save: EventEmitter<WidgetGroupConfigResult>;
+    cancelled: EventEmitter<void>;
+    dataSourceMode: WidgetGroupDataSourceMode;
+    selectedPersistentQuery: PersistentQueryItem | null;
+    selectedCkType: CkTypeSelectorItem | null;
+    availableColumns: QueryColumnItem[];
+    isLoadingColumns: boolean;
+    private columnFilter;
+    filters: FieldFilterItem[];
+    filterAttributes: AttributeItem[];
+    filterVariables: FilterVariable[];
+    isLoadingInitial: boolean;
+    form: {
+        maxItems: number;
+        childWidgetType: GroupChildWidgetType;
+        titleTemplate: string;
+        valueAttribute: string;
+        prefix: string;
+        suffix: string;
+        gaugeType: GaugeType;
+        gaugeMin: number;
+        gaugeMax: number;
+        layout: WidgetGroupLayout;
+        gridColumns: number;
+        minChildWidth: number;
+        gap: number;
+        emptyMessage: string;
+    };
+    childWidgetTypeOptions: {
+        value: GroupChildWidgetType;
+        label: string;
+    }[];
+    gaugeTypeOptions: {
+        value: GaugeType;
+        label: string;
+    }[];
+    /**
+     * Computed: Filtered columns based on search
+     */
+    filteredColumns: _angular_core.WritableSignal<QueryColumnItem[]>;
+    get isValid(): boolean;
+    ngOnInit(): Promise<void>;
+    onDataSourceModeChange(mode: WidgetGroupDataSourceMode): void;
+    onQuerySelected(query: PersistentQueryItem | null): Promise<void>;
+    private loadQueryColumns;
+    private loadInitialCkTypeValues;
+    onCkTypeSelected(ckType: CkTypeSelectorItem): void;
+    onCkTypeCleared(): void;
+    private loadCkTypeAttributes;
+    onColumnFilter(filter: string): void;
+    onFiltersChange(updatedFilters: FieldFilterItem[]): void;
+    onSave(): void;
+    private buildStaticConfig;
+    onCancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WidgetGroupConfigDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WidgetGroupConfigDialogComponent, "mm-widget-group-config-dialog", never, { "initialDataSourceMode": { "alias": "initialDataSourceMode"; "required": false; }; "initialQueryRtId": { "alias": "initialQueryRtId"; "required": false; }; "initialQueryName": { "alias": "initialQueryName"; "required": false; }; "initialCkTypeId": { "alias": "initialCkTypeId"; "required": false; }; "initialFilters": { "alias": "initialFilters"; "required": false; }; "initialMaxItems": { "alias": "initialMaxItems"; "required": false; }; "initialChildTemplate": { "alias": "initialChildTemplate"; "required": false; }; "initialLayout": { "alias": "initialLayout"; "required": false; }; "initialGridColumns": { "alias": "initialGridColumns"; "required": false; }; "initialMinChildWidth": { "alias": "initialMinChildWidth"; "required": false; }; "initialGap": { "alias": "initialGap"; "required": false; }; "initialEmptyMessage": { "alias": "initialEmptyMessage"; "required": false; }; }, { "save": "save"; "cancelled": "cancelled"; }, never, never, true, never>;
+}
+
+declare class MarkdownWidgetComponent implements DashboardWidget<MarkdownWidgetConfig, string>, OnInit, OnChanges {
+    private readonly stateService;
+    private readonly variableService;
+    config: MarkdownWidgetConfig;
+    private readonly _isLoading;
+    private readonly _data;
+    private readonly _error;
+    readonly isLoading: _angular_core.Signal<boolean>;
+    readonly data: _angular_core.Signal<string | null>;
+    readonly error: _angular_core.Signal<string | null>;
+    /**
+     * Check if widget has content configured.
+     * This is a method (not computed) to ensure it re-evaluates when config changes via @Input.
+     */
+    isNotConfigured(): boolean;
+    /**
+     * Resolved markdown content with variables interpolated.
+     */
+    readonly resolvedContent: _angular_core.Signal<string>;
+    /**
+     * Style object for custom padding and alignment.
+     */
+    readonly containerStyle: _angular_core.Signal<{
+        padding: string;
+        textAlign: _meshmakers_octo_meshboard.MarkdownTextAlign;
+    }>;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    refresh(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MarkdownWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MarkdownWidgetComponent, "mm-markdown-widget", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Result from the Markdown config dialog.
+ */
+interface MarkdownConfigResult extends WidgetConfigResult {
+    content: string;
+    resolveVariables: boolean;
+    padding?: string;
+    textAlign?: MarkdownTextAlign;
+}
+declare class MarkdownConfigDialogComponent implements OnInit {
+    initialContent?: string;
+    initialResolveVariables?: boolean;
+    initialPadding?: string;
+    initialTextAlign?: MarkdownTextAlign;
+    save: Subject<MarkdownConfigResult>;
+    cancelled: Subject<void>;
+    readonly showPreview: _angular_core.WritableSignal<boolean>;
+    content: string;
+    resolveVariables: boolean;
+    padding: string;
+    textAlign: MarkdownTextAlign;
+    ngOnInit(): void;
+    onSave(): void;
+    onCancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MarkdownConfigDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MarkdownConfigDialogComponent, "mm-markdown-config-dialog", never, { "initialContent": { "alias": "initialContent"; "required": false; }; "initialResolveVariables": { "alias": "initialResolveVariables"; "required": false; }; "initialPadding": { "alias": "initialPadding"; "required": false; }; "initialTextAlign": { "alias": "initialTextAlign"; "required": false; }; }, { "save": "save"; "cancelled": "cancelled"; }, never, never, true, never>;
+}
+
+/**
+ * Process Widget Registration
+ *
+ * This file is separate from default-widget-registrations.ts to enable
+ * lazy loading of the ProcessWidget and its dependencies (octo-process-diagrams).
+ *
+ * Usage:
+ * - Import and call registerProcessWidget() only in routes/components that need it
+ * - Or use provideProcessWidget() in app config for eager loading
+ */
+
+/**
+ * Registers the Process Widget with the widget registry.
+ *
+ * Call this function to enable Process Diagram widgets in MeshBoard.
+ * This is kept separate to allow lazy loading of the octo-process-diagrams dependency.
+ *
+ * @example
+ * ```typescript
+ * // In a lazy-loaded route or component
+ * const registry = inject(WidgetRegistryService);
+ * registerProcessWidget(registry);
+ * ```
+ */
+declare function registerProcessWidget(registry: WidgetRegistryService): void;
+/**
+ * Provides the Process Widget registration as an environment provider.
+ *
+ * Use this if you want to eagerly register the Process Widget at app startup.
+ * For lazy loading, use registerProcessWidget() directly in the component/route instead.
+ *
+ * @example
+ * ```typescript
+ * // In app.config.ts (eager loading)
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideMeshBoard(),
+ *     provideProcessWidget() // Optional: only if you need ProcessWidget
+ *   ]
+ * };
+ * ```
+ */
+declare function provideProcessWidget(): EnvironmentProviders;
+
+/**
+ * Registers all built-in widget types with the registry.
+ * Called during app initialization.
+ */
+declare function registerDefaultWidgets(registry: WidgetRegistryService): void;
+/**
+ * Provides the widget registry with all built-in widgets registered.
+ * Add this to your app's providers array.
+ *
+ * Usage:
+ * ```typescript
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideDefaultWidgets()
+ *   ]
+ * });
+ * ```
+ */
+declare function provideDefaultWidgets(): EnvironmentProviders;
+
+/**
+ * Configuration options for MeshBoard
+ */
+interface MeshBoardOptions {
+    /** Whether to include default widgets (default: true) */
+    includeDefaultWidgets?: boolean;
+    /** Default grid columns (default: 6) */
+    defaultColumns?: number;
+    /** Default row height in pixels (default: 200) */
+    defaultRowHeight?: number;
+    /** Default gap between widgets in pixels (default: 16) */
+    defaultGap?: number;
+}
+/**
+ * Injection token for MeshBoard options
+ */
+declare const MESHBOARD_OPTIONS: InjectionToken<MeshBoardOptions>;
+
+/**
+ * @deprecated Use TENANT_ID_PROVIDER from @meshmakers/octo-services instead
+ */
+declare const MESHBOARD_TENANT_ID_PROVIDER: InjectionToken<_meshmakers_octo_services.TenantIdProvider>;
+/**
+ * Main provider function for the MeshBoard library.
+ * This is the recommended way to configure MeshBoard in your application.
+ *
+ * Usage:
+ * ```typescript
+ * // app.config.ts
+ * import { provideMeshBoard } from '@meshmakers/octo-meshboard';
+ *
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideMeshBoard(),
+ *     // or with options:
+ *     provideMeshBoard({ defaultColumns: 4 })
+ *   ]
+ * };
+ * ```
+ */
+declare function provideMeshBoard(options?: MeshBoardOptions): EnvironmentProviders;
+/**
+ * Provider function for registering custom widgets.
+ * Use this to add your own widget types to MeshBoard.
+ *
+ * Usage:
+ * ```typescript
+ * // app.config.ts
+ * import { provideMeshBoard, provideWidgetRegistrations } from '@meshmakers/octo-meshboard';
+ * import { MyCustomWidget, MyCustomConfigDialog } from './widgets/my-custom-widget';
+ *
+ * const customWidgets: WidgetRegistration<any, any>[] = [
+ *   {
+ *     type: 'myCustom',
+ *     label: 'My Custom Widget',
+ *     component: MyCustomWidget,
+ *     configDialogComponent: MyCustomConfigDialog,
+ *     defaultSize: { colSpan: 2, rowSpan: 1 },
+ *     supportedDataSources: ['runtimeEntity'],
+ *     // ... other registration options
+ *   }
+ * ];
+ *
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideMeshBoard(),
+ *     provideWidgetRegistrations(customWidgets)
+ *   ]
+ * };
+ * ```
+ */
+declare function provideWidgetRegistrations(registrations: WidgetRegistration<any, any>[]): EnvironmentProviders;
+
+interface WidgetPositionUpdate {
+    id: string;
+    title: string;
+    col: number;
+    row: number;
+    colSpan: number;
+    rowSpan: number;
+}
+declare class EditWidgetDialogComponent implements OnInit {
+    widget: AnyWidgetConfig;
+    widgets: AnyWidgetConfig[];
+    maxColumns: number;
+    gridService: MeshBoardGridService;
+    save: EventEmitter<WidgetPositionUpdate>;
+    cancelled: EventEmitter<void>;
+    form: WidgetPositionUpdate;
+    error: string;
+    ngOnInit(): void;
+    onSave(): void;
+    onCancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EditWidgetDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EditWidgetDialogComponent, "mm-edit-widget-dialog", never, { "widget": { "alias": "widget"; "required": false; }; "widgets": { "alias": "widgets"; "required": false; }; "maxColumns": { "alias": "maxColumns"; "required": false; }; "gridService": { "alias": "gridService"; "required": false; }; }, { "save": "save"; "cancelled": "cancelled"; }, never, never, true, never>;
+}
+
+/**
+ * Main container component that displays a MeshBoard with widgets in a grid layout.
+ * Provides toolbar for settings, adding widgets, saving, and refreshing.
+ */
+declare class MeshBoardViewComponent implements OnInit, OnDestroy, HasUnsavedChanges {
+    private readonly stateService;
+    private readonly editModeService;
+    private readonly widgetFactory;
+    private readonly widgetRegistry;
+    private readonly dataService;
+    private readonly dialogService;
+    private readonly viewContainerRef;
+    private readonly router;
+    private readonly route;
+    protected readonly gridService: MeshBoardGridService;
+    private readonly tenantIdProvider;
+    private lastNavigatedRtId;
+    protected readonly gearIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly plusIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly saveIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly arrowRotateCwIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly pencilIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly xIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly linkIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly trashIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly gridLayoutIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected showEditWidgetDialog: boolean;
+    protected editingWidget: AnyWidgetConfig | null;
+    private configDialogRef;
+    protected readonly config: _angular_core.Signal<MeshBoardConfig>;
+    protected readonly isEditMode: _angular_core.Signal<boolean>;
+    protected readonly isSaving: _angular_core.Signal<boolean>;
+    protected readonly isLoading: _angular_core.Signal<boolean>;
+    protected readonly isModelAvailable: _angular_core.Signal<boolean | null>;
+    private readonly _isInitialized;
+    protected readonly isInitialized: _angular_core.Signal<boolean>;
+    private readonly _notFoundError;
+    protected readonly notFoundError: _angular_core.Signal<string | null>;
+    protected readonly meshBoardPageLink: _angular_core.Signal<string>;
+    protected readonly hasWidgets: _angular_core.Signal<boolean>;
+    protected readonly canSave: _angular_core.Signal<boolean>;
+    protected readonly isTimeFilterEnabled: _angular_core.Signal<boolean>;
+    protected readonly timeFilterConfig: _angular_core.Signal<_meshmakers_octo_meshboard.MeshBoardTimeFilterConfig | undefined>;
+    protected readonly initialTimeSelection: _angular_core.Signal<TimeRangeSelection$1 | undefined>;
+    constructor();
+    /**
+     * Updates the URL to include the current MeshBoard rtId.
+     */
+    private updateUrlWithRtId;
+    ngOnInit(): Promise<void>;
+    /**
+     * Loads a specific MeshBoard by its rtId.
+     */
+    private loadMeshBoardById;
+    ngOnDestroy(): void;
+    /**
+     * Preloads data for all widgets to improve initial rendering performance.
+     */
+    private preloadWidgetData;
+    /**
+     * Initializes time filter variables based on the stored selection.
+     * Called after loading a MeshBoard to ensure time filter variables are set.
+     */
+    private initializeTimeFilterVariables;
+    /**
+     * Gets the component type for a widget based on its type.
+     */
+    getWidgetComponentType(type: WidgetType): Type<unknown> | undefined;
+    /**
+     * Toggles edit mode.
+     */
+    toggleEditMode(): void;
+    /**
+     * Cancels edit mode and restores original state.
+     */
+    cancelEdit(): void;
+    /**
+     * Opens the settings dialog.
+     */
+    openSettings(): Promise<void>;
+    /**
+     * Opens the add widget dialog.
+     */
+    openAddWidget(): Promise<void>;
+    /**
+     * Opens the MeshBoard manager dialog.
+     */
+    openManager(): Promise<void>;
+    /**
+     * Adds a widget to the MeshBoard.
+     */
+    private addWidget;
+    /**
+     * Finds a free position in the grid for a new widget.
+     */
+    private findFreePosition;
+    /**
+     * Checks if a position is occupied by existing widgets.
+     */
+    private isPositionOccupied;
+    /**
+     * Saves the MeshBoard.
+     */
+    save(): Promise<void>;
+    /**
+     * Refreshes all widget data.
+     */
+    refresh(): void;
+    /**
+     * Handles time range change from the time range picker.
+     * Triggers a refresh of all widgets to apply the new filter.
+     */
+    onTimeRangeChange(_range: TimeRange): void;
+    /**
+     * Handles time selection change from the time range picker.
+     * Updates the time filter variables and persists the selection.
+     */
+    onTimeSelectionChange(sharedSelection: TimeRangeSelection$1): void;
+    /**
+     * Compares two TimeRangeSelection objects for equality.
+     */
+    private isSelectionEqual;
+    /**
+     * Removes a widget from the MeshBoard.
+     */
+    removeWidget(widgetId: string): void;
+    /**
+     * Opens the configuration dialog for a widget.
+     * Creates the dialog component dynamically using ViewContainerRef to avoid
+     * double-wrapping with DialogService (config dialogs have their own kendo-dialog).
+     */
+    openWidgetConfig(widget: AnyWidgetConfig): void;
+    /**
+     * Closes the configuration dialog if open.
+     */
+    private closeConfigDialog;
+    /**
+     * Handles TileLayout reorder events.
+     */
+    onReorder(event: {
+        newIndex: number;
+        oldIndex: number;
+    }): void;
+    /**
+     * Handles TileLayout resize events.
+     */
+    onResize(event: any): void;
+    /**
+     * Track by function for widget rendering.
+     */
+    trackByWidgetId(_index: number, widget: AnyWidgetConfig): string;
+    /**
+     * Checks if a widget is unconfigured (needs data source setup).
+     */
+    isWidgetUnconfigured(widget: AnyWidgetConfig): boolean;
+    /**
+     * Checks if a widget type supports configuration.
+     */
+    supportsConfiguration(widget: AnyWidgetConfig): boolean;
+    /**
+     * Opens the edit widget dialog for position/size editing.
+     */
+    openEditWidgetDialog(widget: AnyWidgetConfig): void;
+    /**
+     * Handles save from the edit widget dialog.
+     */
+    onEditWidgetSave(update: WidgetPositionUpdate): void;
+    /**
+     * Closes the edit widget dialog.
+     */
+    closeEditWidgetDialog(): void;
+    /**
+     * Checks if there are unsaved changes in the MeshBoard.
+     * Returns true if in edit mode with a snapshot (indicating changes).
+     */
+    hasUnsavedChanges(): boolean;
+    /**
+     * Saves the MeshBoard and returns true if successful.
+     * This is called by the UnsavedChangesGuard when the user chooses to save.
+     */
+    saveChanges(): Promise<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MeshBoardViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MeshBoardViewComponent, "mm-meshboard-view", never, {}, {}, never, never, true, [{ directive: typeof i1.UnsavedChangesDirective; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Result returned when the dialog is closed with save action.
+ */
+declare class MeshBoardSettingsResult {
+    name: string;
+    description: string;
+    columns: number;
+    rowHeight: number;
+    gap: number;
+    variables: MeshBoardVariable[];
+    timeFilter?: MeshBoardTimeFilterConfig | undefined;
+    rtWellKnownName?: string | undefined;
+    constructor(name: string, description: string, columns: number, rowHeight: number, gap: number, variables: MeshBoardVariable[], timeFilter?: MeshBoardTimeFilterConfig | undefined, rtWellKnownName?: string | undefined);
+}
+/**
+ * Dialog for editing MeshBoard settings.
+ * Allows configuration of name, description, columns, rowHeight, and gap.
+ */
+declare class MeshBoardSettingsDialogComponent {
+    private readonly dialogRef;
+    name: string;
+    description: string;
+    rtWellKnownName: string;
+    columns: number;
+    rowHeight: number;
+    gap: number;
+    variables: MeshBoardVariable[];
+    timeFilterEnabled: boolean;
+    get isValid(): boolean;
+    /**
+     * Sets the initial values for the form fields.
+     */
+    setInitialValues(settings: {
+        name: string;
+        description: string;
+        rtWellKnownName?: string | null;
+        columns: number;
+        rowHeight: number;
+        gap: number;
+        variables?: MeshBoardVariable[];
+        timeFilter?: MeshBoardTimeFilterConfig;
+    }): void;
+    /**
+     * Saves the settings and closes the dialog.
+     */
+    save(): void;
+    /**
+     * Cancels and closes the dialog.
+     */
+    cancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MeshBoardSettingsDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MeshBoardSettingsDialogComponent, "mm-meshboard-settings-dialog", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Widget type info for display in the dialog.
+ */
+interface WidgetTypeInfo {
+    type: WidgetType;
+    label: string;
+    description: string;
+    icon: SVGIcon;
+}
+/**
+ * Dialog for selecting a widget type to add to the MeshBoard.
+ */
+declare class AddWidgetDialogComponent implements OnInit {
+    private readonly dialogRef;
+    private readonly widgetRegistry;
+    protected readonly checkCircleIcon: SVGIcon;
+    protected readonly widgetTypes: _angular_core.WritableSignal<WidgetTypeInfo[]>;
+    protected readonly selectedType: _angular_core.WritableSignal<WidgetType | null>;
+    ngOnInit(): void;
+    /**
+     * Gets the icon for a widget type.
+     */
+    private getWidgetIcon;
+    /**
+     * Gets the description for a widget type.
+     */
+    private getWidgetDescription;
+    /**
+     * Selects a widget type.
+     */
+    selectType(type: WidgetType): void;
+    /**
+     * Checks if a widget type is selected.
+     */
+    isSelected(type: WidgetType): boolean;
+    /**
+     * Adds the selected widget and closes the dialog.
+     */
+    add(): void;
+    /**
+     * Cancels and closes the dialog.
+     */
+    cancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AddWidgetDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AddWidgetDialogComponent, "mm-add-widget-dialog", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Dialog for managing multiple MeshBoards.
+ * Provides actions to switch, create, rename, and delete MeshBoards.
+ */
+declare class MeshBoardManagerDialogComponent implements OnInit {
+    private readonly dialogRef;
+    private readonly stateService;
+    private readonly dialogService;
+    private readonly assetRepoService;
+    private readonly jobManagementService;
+    private readonly importStrategyDialogService;
+    private readonly injectedTenantIdProvider;
+    externalTenantIdProvider: TenantIdProvider | null;
+    private readonly DASHBOARD_CK_TYPE_ID;
+    private readonly VARIABLES_SEPARATOR;
+    /**
+     * Gets the tenant ID provider from either external property or DI.
+     */
+    private get tenantIdProvider();
+    protected readonly plusIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly trashIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly pencilIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly checkIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly xIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly gridLayoutIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly downloadIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly uploadIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly isExporting: _angular_core.WritableSignal<boolean>;
+    protected readonly isImporting: _angular_core.WritableSignal<boolean>;
+    protected readonly meshBoards: _angular_core.Signal<PersistedMeshBoard[]>;
+    protected readonly currentMeshBoardId: _angular_core.Signal<string | null>;
+    protected readonly isLoading: _angular_core.WritableSignal<boolean>;
+    protected readonly editingId: _angular_core.WritableSignal<string | null>;
+    protected readonly editingName: _angular_core.WritableSignal<string>;
+    protected readonly editingDescription: _angular_core.WritableSignal<string>;
+    protected readonly isCreating: _angular_core.WritableSignal<boolean>;
+    protected readonly newName: _angular_core.WritableSignal<string>;
+    protected readonly newDescription: _angular_core.WritableSignal<string>;
+    protected readonly hasMeshBoards: _angular_core.Signal<boolean>;
+    ngOnInit(): Promise<void>;
+    /**
+     * Refreshes the list of MeshBoards.
+     */
+    private refresh;
+    /**
+     * Checks if a MeshBoard is the currently active one.
+     */
+    isActive(meshBoard: PersistedMeshBoard): boolean;
+    /**
+     * Gets the display description for a MeshBoard.
+     * Strips the encoded variables/timeFilter JSON from the raw description.
+     */
+    getDisplayDescription(meshBoard: PersistedMeshBoard): string;
+    /**
+     * Checks if a MeshBoard is being edited.
+     */
+    isEditing(meshBoard: PersistedMeshBoard): boolean;
+    /**
+     * Switches to a different MeshBoard.
+     */
+    switchTo(meshBoard: PersistedMeshBoard): Promise<void>;
+    /**
+     * Starts editing a MeshBoard.
+     */
+    startEdit(meshBoard: PersistedMeshBoard): void;
+    /**
+     * Cancels editing a MeshBoard.
+     */
+    cancelEdit(): void;
+    /**
+     * Saves the edited MeshBoard.
+     */
+    saveEdit(): Promise<void>;
+    /**
+     * Deletes a MeshBoard after confirmation.
+     */
+    delete(meshBoard: PersistedMeshBoard): Promise<void>;
+    /**
+     * Shows a confirmation dialog before deleting.
+     */
+    private confirmDelete;
+    /**
+     * Starts creating a new MeshBoard.
+     */
+    startCreate(): void;
+    /**
+     * Cancels creating a new MeshBoard.
+     */
+    cancelCreate(): void;
+    /**
+     * Creates a new MeshBoard.
+     */
+    create(): Promise<void>;
+    /**
+     * Closes the dialog.
+     */
+    close(): void;
+    /**
+     * Checks if export is available (requires tenant provider).
+     */
+    get canExport(): boolean;
+    /**
+     * Exports a MeshBoard as a deep graph.
+     */
+    exportMeshBoard(meshBoard: PersistedMeshBoard, event: Event): Promise<void>;
+    /**
+     * Triggers the file input for importing a MeshBoard.
+     */
+    triggerImport(): void;
+    /**
+     * Imports a MeshBoard from a ZIP file.
+     */
+    importMeshBoard(file: File): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MeshBoardManagerDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MeshBoardManagerDialogComponent, "mm-meshboard-manager-dialog", never, {}, {}, never, never, true, never>;
+}
+
+export { AddWidgetDialogComponent, AssociationsConfigDialogComponent, BarChartConfigDialogComponent, BarChartWidgetComponent, DashboardDataService, DashboardGridService, EditModeStateService, EditWidgetDialogComponent, EntityAssociationsWidgetComponent, EntityCardConfigDialogComponent, EntityCardWidgetComponent, EntityDetailDialogComponent, GaugeConfigDialogComponent, GaugeWidgetComponent, KpiConfigDialogComponent, KpiWidgetComponent, MESHBOARD_OPTIONS, MESHBOARD_TENANT_ID_PROVIDER, MarkdownConfigDialogComponent, MarkdownWidgetComponent, MeshBoardDataService, MeshBoardGridService, MeshBoardManagerDialogComponent, MeshBoardPersistenceService, MeshBoardSettingsDialogComponent, MeshBoardSettingsResult, MeshBoardStateService, MeshBoardViewComponent, PieChartConfigDialogComponent, PieChartWidgetComponent, QuerySelectorComponent, RuntimeEntityDialogDataSource$1 as RuntimeEntityDialogDataSource, RuntimeEntitySelectDataSource$1 as RuntimeEntitySelectDataSource, RuntimeEntitySelectorComponent, ServiceHealthConfigDialogComponent, ServiceHealthWidgetComponent, StatsGridConfigDialogComponent, StatsGridWidgetComponent, StatusIndicatorConfigDialogComponent, StatusIndicatorWidgetComponent, TableConfigDialogComponent, TableWidgetComponent, TableWidgetDataSourceDirective, WidgetFactoryService, WidgetGroupComponent, WidgetGroupConfigDialogComponent, WidgetNotConfiguredComponent, WidgetRegistryService, provideDefaultWidgets, provideMeshBoard, provideProcessWidget, provideWidgetRegistrations, registerDefaultWidgets, registerProcessWidget };
+export type { AggregationDataSource, AggregationQuery, AggregationType, AnyWidgetConfig, AssociationsConfigResult, BarChartConfigResult, BarChartSeries, BarChartType, BarChartWidgetConfig, BaseWidgetConfig, CategoryValueItem, CkQueryResult, CkQueryTarget, ConfigDialogResult, ConfigResultApplier, ConstructionKitQueryDataSource, DashboardConfig, DashboardWidget, DataSource, DataSourceType, DiagramPropertyMapping, EntityAssociation, EntityAttribute, EntityCardConfigResult, EntityCardWidgetConfig, EntityListWidget, EntityWidget, EntityWithAssociationsWidgetConfig, GaugeConfigResult, GaugeRange, GaugeType, GaugeWidgetConfig, GridCell, GridPosition, GroupChildWidgetType, GroupedDataItem, KpiConfigResult, KpiDataSourceType, KpiQueryMode, KpiWidgetConfig, MarkdownConfigResult, MarkdownTextAlign, MarkdownWidgetConfig, MeshBoardConfig, MeshBoardOptions, MeshBoardTimeFilterConfig, MeshBoardVariable, MeshBoardVariableSource, MeshBoardVariableType, ParentAssociationMode, PersistedDashboard, PersistedMeshBoard, PersistedWidget, PersistedWidgetData, PersistentQueryDataSource, PersistentQueryItem, PieChartConfigResult, PieChartType, PieChartWidgetConfig, ProcessWidgetConfig, Quarter, QueryColumn, QueryColumnItem, RelativeTimeUnit, RepeaterDataItem, RepeaterQueryDataSource, RuntimeEntityData, RuntimeEntityDataSource, RuntimeEntityItem$1 as RuntimeEntityItem, RuntimeEntitySelectorValue, ServiceCallDataSource, ServiceCallType, ServiceHealthConfigResult, ServiceHealthWidgetConfig, StatColor, StatItem, StaticDataSource, StatsGridConfigResult, StatsGridWidgetConfig, StatusIndicatorConfigResult, StatusIndicatorWidgetConfig, TableColumn, TableConfigResult, TableFilterConfig, TableSortConfig, TableWidgetConfig, TimeRangePickerConfig, TimeRangeSelection, TimeRangeType, UpdateDashboardResult, WidgetConfig, WidgetConfigDialog, WidgetConfigResult, WidgetCreationOptions, WidgetDataSource, WidgetFilterConfig, WidgetGroupAttributeMappings, WidgetGroupChildTemplate, WidgetGroupConfig, WidgetGroupConfigResult, WidgetGroupLayout, WidgetPersistenceData, WidgetPositionUpdate, WidgetRegistration, WidgetType };