@masterteam/dashboard-builder 0.0.27 → 0.0.29

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

@@ -1,19 +1,19 @@
 import * as _masterteam_dashboard_builder from '@masterteam/dashboard-builder';
 import * as _angular_core from '@angular/core';
-import { OnInit, OnDestroy, AfterViewInit, OnChanges, SimpleChanges, TemplateRef, PipeTransform } from '@angular/core';
+import { OnInit, OnDestroy, ElementRef, AfterViewInit, OnChanges, SimpleChanges, TemplateRef, PipeTransform } from '@angular/core';
 import { GridsterItem, GridsterConfig } from 'angular-gridster2';
 import { ContextMenu } from 'primeng/contextmenu';
 import { MenuItem } from 'primeng/api';
+import { MTMenuItem } from '@masterteam/components/menu';
 import * as _angular_forms from '@angular/forms';
 import { ControlValueAccessor, FormGroup, FormArray, ValidationErrors } from '@angular/forms';
-import { EntityData as EntityData$1 } from '@masterteam/components/entities';
 import { MTIcon } from '@masterteam/icons';
+import { EntityData as EntityData$1 } from '@masterteam/components/entities';
 import * as rxjs from 'rxjs';
 import { Observable } from 'rxjs';
 import { ColumnDef, TableAction } from '@masterteam/components/table';
 import { ModalService } from '@masterteam/components/modal';
 import { ModalRef } from '@masterteam/components/dialog';
-import { MTMenuItem } from '@masterteam/components/menu';
 
 /**
  * Localized name with English and Arabic
@@ -475,6 +475,1378 @@ interface CustomApi {
     params?: Record<string, any>;
 }
 
+/**
+ * Action emitted from the kebab menu. The host (`dashboard-builder`)
+ * routes each id to a single concrete owner (ManageItem, ChartSettingsDrawer,
+ * ChartFilterDrawer, inline title input, or destructive action).
+ */
+type ItemCardMenuAction = {
+    type: 'configure-datasource';
+} | {
+    type: 'style';
+} | {
+    type: 'filters';
+} | {
+    type: 'edit-title';
+} | {
+    type: 'duplicate';
+} | {
+    type: 'delete';
+} | {
+    type: 'dialog-open';
+} | {
+    type: 'dialog-edit';
+} | {
+    type: 'dialog-remove';
+};
+declare class ItemCardMenuComponent {
+    private readonly transloco;
+    /** Whether to allow duplicate (excluded for layout/group widgets). */
+    readonly allowDuplicate: _angular_core.InputSignal<boolean>;
+    /** Whether the chart has a linked dialog already. */
+    readonly hasLinkedDialog: _angular_core.InputSignal<boolean>;
+    /** Whether the chart supports adding a linked dialog. */
+    readonly canLinkDialog: _angular_core.InputSignal<boolean>;
+    /** Action emitter — host wires each id to a single concrete owner. */
+    readonly action: _angular_core.OutputEmitterRef<ItemCardMenuAction>;
+    /**
+     * Build the menu model. Six primary entries plus optional dialog entries
+     * when the chart has (or supports) a linked dialog. Each menu item carries
+     * a stable `id` so `onItemSelect` can route deterministically.
+     */
+    readonly items: _angular_core.Signal<MTMenuItem[]>;
+    onItemSelect(item: MTMenuItem): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ItemCardMenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ItemCardMenuComponent, "mt-item-card-menu", never, { "allowDuplicate": { "alias": "allowDuplicate"; "required": false; "isSignal": true; }; "hasLinkedDialog": { "alias": "hasLinkedDialog"; "required": false; "isSignal": true; }; "canLinkDialog": { "alias": "canLinkDialog"; "required": false; "isSignal": true; }; }, { "action": "action"; }, never, never, true, never>;
+}
+
+/**
+ * Chart Capability Registry — types
+ *
+ * One manifest entry per active chart/widget. Every other layer
+ * (chart picker, data-source settings, query/display UI, save/load
+ * pipeline, runtime expansion) reads from the manifest instead of
+ * branching on serviceType / componentName / functionName.
+ */
+/** Backend ChartType enum names that the host BE accepts in execution payloads. */
+type BackendChartType = 'BarChart' | 'PropertiesBarChar' | 'DonutChart' | 'TableChart' | 'SplitterChart' | 'BarStackChart' | 'TimeLine' | 'OverviewCard' | 'TableView' | 'PercentagePieChart' | 'Properties' | 'FormulaBarChart' | 'ComparisonChart' | 'BarV2Chart' | 'PieV2Chart' | 'StackBarV2Chart' | 'CardViewV2Chart' | 'GaugeChart' | 'LineChart' | 'SplitChart' | 'GaugeComponentChart' | 'PropertyCardView';
+type RequestType$1 = 'level' | 'levellog' | 'log' | 'custom' | 'snapShot' | 'levelCards' | 'timelineProjectDependencies' | 'customSplus' | 'phaseGate';
+type QueryEditorKind = 'none' | 'general' | 'table' | 'properties' | 'timeline' | 'timelineMultiLevel' | 'map' | 'splitter' | 'snapshot' | 'phaseGate' | 'repeater';
+type RendererKey = 'chart' | 'map' | 'table' | 'phaseGateTable' | 'timeline' | 'listStatistic' | 'levelCards' | 'properties' | 'entityPreview' | 'performanceCard' | 'performanceGaugeCard' | 'splitter' | 'phaseGateStepper' | 'header' | 'topbar' | 'repeater' | 'group' | 'raw';
+type Product = 'pplus' | 'splus' | 'report';
+/** Generic display schema field key. Open string to allow registry-specific extensions. */
+type DisplayField = string;
+/** Generic query schema field key. */
+type QueryField = 'valueProperty' | 'aggregateFunction' | 'groupByProperties' | 'autoStack' | 'stackProperties' | 'autoStackByProperty' | 'categoryProperty' | 'color' | 'formula' | 'filters' | 'extraProperties' | 'showAdvancedSettings' | 'barType';
+interface QuerySchema {
+    /** Visible chart-specific fields (subset of QueryField, in chosen order). */
+    fields: QueryField[];
+    /** Required fields before save. */
+    required: QueryField[];
+}
+interface DisplaySchema {
+    /** Visible display-config fields. */
+    fields: DisplayField[];
+}
+interface ChartCapabilityLegacyAliases {
+    /** Old chart ids that should resolve to this manifest entry. */
+    ids?: string[];
+    /** Legacy serviceType strings (e.g., `splitChart`). */
+    serviceTypes?: string[];
+    /** Legacy componentName strings (e.g., `listOfLevelCards`). */
+    componentNames?: string[];
+    /** Legacy functionName strings (e.g., `handleTableChart`). */
+    functionNames?: string[];
+}
+interface ChartCapability {
+    /** Stable chart id used by the palette and saved dashboards. */
+    id: string;
+    /** Human-readable label. */
+    name: string;
+    /** Icon key from the new FE icon system. */
+    icon: string;
+    /** Group in the chart palette. */
+    category: 'chart' | 'card' | 'table' | 'special' | 'layout';
+    /** Products this widget is exposed in. */
+    products: Product[];
+    /** Hide from picker but allow legacy edit. */
+    hideInList?: boolean;
+    /** Whether the chart needs the manage-item drawer. */
+    hasManageItem: boolean;
+    /** Default grid size when added. */
+    defaultSize?: {
+        cols: number;
+        rows: number;
+    };
+    /** Stored serviceConfig.chartType (FE-side). May differ from backend enum. */
+    serviceType: string;
+    /** Stored clientConfig.componentName. */
+    componentName: string;
+    /** Stored clientConfig.functionName. */
+    functionName: string;
+    /** Stored clientConfig.requestType. */
+    requestType?: RequestType$1;
+    /** Backend ChartType enum that this widget should be sent as during execution. */
+    backendChartType?: BackendChartType;
+    /** Renderer key for the dashboard-item switch. */
+    renderer: RendererKey;
+    /** Capability flags driving UX visibility. */
+    selection: {
+        /** Whether the selection block is shown. */
+        visible: boolean;
+        /** Whether multiple selections are allowed. */
+        allowMultiple: boolean;
+    };
+    supportsSourceLinks: boolean;
+    supportsCustomApi: boolean;
+    supportsGroupByMultiple: boolean;
+    supportsRepeater?: boolean;
+    /** Query editor and schema. */
+    query: {
+        editor: QueryEditorKind;
+        schema?: QuerySchema;
+    };
+    /** Display schema. */
+    display: DisplaySchema;
+    /** Legacy aliases honored by the legacy adapter when resolving manifests. */
+    legacyAliases?: ChartCapabilityLegacyAliases;
+}
+/** Minimum shape needed to resolve a manifest from a saved config. */
+interface ConfigLookupShape {
+    serviceConfig?: {
+        chartType?: string | null;
+        [k: string]: unknown;
+    };
+    clientConfig?: {
+        componentName?: string | null;
+        functionName?: string | null;
+        [k: string]: unknown;
+    };
+    /** When known, provided directly by the chart picker. */
+    chartTypeId?: string | null;
+}
+
+/**
+ * Chart Capability Registry — manifest data.
+ *
+ * Each entry is the single source of truth for a chart/widget. Consumers:
+ *  - widget-palette / chart picker
+ *  - manage-item DataSourceSettings
+ *  - GeneralQuery / TableQuery / etc. visibility rules
+ *  - DisplaySettings
+ *  - chart-data.service request handler resolution
+ *  - dashboard-item renderer key
+ *  - save / load / request normalization
+ */
+
+declare const CHART_CAPABILITIES: ChartCapability[];
+/** Lookup by stable id. */
+declare function getCapabilityById(id: string | null | undefined): ChartCapability | null;
+/**
+ * Resolve a manifest entry from a saved config.
+ *
+ * Resolution order:
+ *  1. chartTypeId (palette / saved field)
+ *  2. (serviceType + componentName + functionName) exact key
+ *  3. legacyAliases.ids
+ *  4. legacyAliases.componentNames + serviceType match
+ *  5. legacyAliases.serviceTypes + componentName match
+ *  6. legacyAliases.functionNames
+ */
+declare function resolveCapability(input: {
+    chartTypeId?: string | null;
+    serviceType?: string | null;
+    componentName?: string | null;
+    functionName?: string | null;
+}): ChartCapability | null;
+
+/**
+ * Chart Type Aliases — single source of truth for backend-safe chart type mapping.
+ *
+ * BE enum (DashboardBuilder.Shared.ChartType) accepts:
+ *   BarV2Chart, PieV2Chart, StackBarV2Chart, CardViewV2Chart, GaugeChart,
+ *   LineChart, SplitChart, PropertyCardView, TableView, Properties, ...
+ *
+ * Old/new FE may store legacy values such as `LineV2Chart`, `splitChart`,
+ * `SplitterChart`, `snapShot`, `phaseGate`, `levelCards`. Special types are
+ * never sent to BE chart execution — they go to legacy host endpoints.
+ */
+
+/**
+ * Maps any FE chart type / alias string to a backend-safe ChartType,
+ * or returns null when the value is not a backend execution chart type
+ * (legacy special types: snapShot, phaseGate, levelCards, header, topbar).
+ */
+declare function toBackendChartType(raw: string | null | undefined): BackendChartType | null;
+/**
+ * Returns the backend-safe chart type or, when there is no mapping,
+ * preserves the original FE value so that legacy/special endpoints still receive it.
+ */
+declare function normalizeChartTypeForRequest(raw: string | null | undefined): string;
+
+interface AnyConfig {
+    serviceConfig?: Record<string, any> | undefined;
+    clientConfig?: Record<string, any> | undefined;
+    /** Optional grid metadata that the report link DTO expects to keep. */
+    [k: string]: any;
+}
+/** Normalize a single filter operation (BE expects `Equals`, never `Equal`). */
+declare function normalizeFilterOperation(op: unknown): unknown;
+/** Normalize an array of filters in place (returns a new array). */
+declare function normalizeFilters(filters: any[] | undefined): any[] | undefined;
+/**
+ * Build a backend-safe selector from legacy moduleType / moduleId pair.
+ */
+declare function selectorFromLegacy(moduleType: string | null | undefined, moduleId: string | number | null | undefined): string | null;
+/**
+ * Extract numeric/string id from `Type:Id` selector. Used by legacy
+ * host endpoints (`GetCards/{moduleId}`, `Levels/{levelId}/PhaseGates`)
+ * which never accepted a selector.
+ */
+declare function moduleIdFromSelector(selector: string | null | undefined): string | null;
+/**
+ * Map an FE source-link entry to the backend SourceLink DTO shape.
+ *
+ * BE: { id, sourceLinkId?, sourceLinkId2?, sourceId1, sourceId2,
+ *       source1LinkProperty, source2LinkProperty, isFilterLinkage, isLeftJoin }
+ */
+declare function toBackendSourceLink(link: any, fallbackId: number): any;
+/**
+ * Normalize a config that may be old (moduleType/moduleId, fuctionName,
+ * root repeaterDashboardId) into canonical new shape, without losing data.
+ *
+ * Pure: returns a new object.
+ */
+declare function normalizeOnLoad(config: AnyConfig | null | undefined): AnyConfig;
+/**
+ * Normalize before a chart link / report save.
+ *
+ * Strips runtime/UI-only fields and converts to canonical names.
+ */
+declare function normalizeBeforeSave(config: AnyConfig | null | undefined): AnyConfig;
+/**
+ * Normalize before a chart execution request.
+ *
+ * - Maps chart type to BE-safe enum (LineV2Chart→LineChart, etc).
+ * - Returns a new ServiceConfig-like payload that filter handling can be
+ *   layered on top of.
+ *
+ * The actual filter substitution happens in handleFiltersForCustom, which
+ * stays a single function and is consistent across services.
+ */
+declare function normalizeBeforeRequest(serviceConfig: Record<string, any> | null | undefined): Record<string, any>;
+
+/**
+ * Config Domain Registry (Pass 3).
+ *
+ * The dashboard-builder configuration is split into separate **domains** so
+ * the contextual popover can render compact, focused controls without leaking
+ * cross-domain concerns. The persisted shape (`ItemConfig.serviceConfig` /
+ * `ItemConfig.clientConfig`) is **unchanged** — domains are thin facets that
+ * read and write to specific paths.
+ *
+ * Each domain is keyed by a `ConfigDomainKey` so the popover, validators, and
+ * presets can address them uniformly.
+ *
+ * IMPORTANT: This module is **persistence-neutral**. It does not introduce new
+ * BE shapes or new save/load paths. Adapters in `./adapters.*.ts` convert
+ * between persisted ItemConfig and small UI view-models per domain.
+ */
+
+/** Stable identifier for a configuration domain shown in the contextual popover. */
+type ConfigDomainKey = 'title' | 'datasource' | 'fields' | 'filters' | 'style' | 'layout' | 'labelLegendFormat' | 'behavior' | 'advanced';
+/** Top-level tab a domain belongs to in the popover. */
+type PopoverTab = 'data' | 'filters' | 'style' | 'behavior' | 'advanced';
+interface ConfigDomainSpec {
+    key: ConfigDomainKey;
+    /** Human label key (transloco). Falls back to en string. */
+    labelKey: string;
+    /** Default English label. */
+    label: string;
+    /** Icon (mt icon name) shown next to the domain in the popover. */
+    icon: string;
+    /** Tab in the popover this domain belongs to. */
+    tab: PopoverTab;
+    /** Whether this domain is shown in the SIMPLE mode by default. */
+    simple: boolean;
+    /** Whether this domain is shown in ADVANCED mode (drawer). */
+    advanced: boolean;
+}
+/**
+ * The canonical list of configuration domains. Order is the order of
+ * appearance in the popover.
+ */
+declare const CONFIG_DOMAINS: readonly ConfigDomainSpec[];
+/** Domains supported by a chart capability (manifest-driven). */
+interface ChartDomainSupport {
+    domains: ConfigDomainKey[];
+}
+/**
+ * Determine which domains apply to a given chart capability.
+ *
+ * Layout widgets (header/topbar/group) only support title + style + advanced.
+ * Special endpoint widgets (snapshot/phaseGate/repeater) skip filters where
+ * filters are not honored. Everything else gets the full domain set.
+ *
+ * Pure: never mutates the capability.
+ */
+declare function domainsForCapability(cap: ChartCapability | null | undefined): ChartDomainSupport;
+/** Find a domain spec by key. */
+declare function findDomain(key: ConfigDomainKey): ConfigDomainSpec | undefined;
+/** All popover tabs. */
+declare const POPOVER_TABS: readonly PopoverTab[];
+interface PopoverTabSpec {
+    key: PopoverTab;
+    label: string;
+    icon: string;
+}
+declare const POPOVER_TAB_SPECS: readonly PopoverTabSpec[];
+
+/**
+ * Pass 3 Config Models.
+ *
+ * Three layered views over the same persisted ItemConfig:
+ *  - PersistedItemConfig — what BE accepts and what we save (= existing
+ *    `ItemConfig`). Unchanged shape so old dashboards keep loading.
+ *  - UiItemConfig — domain-bounded view-models the popover/contextual
+ *    components consume. Friendly fields, validated, no leaked BE keys.
+ *  - RuntimeItemConfig — what the renderer reads at runtime. Includes
+ *    transient flags (loading, __substituted, etc.) that are NEVER persisted.
+ *
+ * Adapters (see `./adapters.*.ts`) translate between layers in both directions.
+ * If you ever feel the urge to persist a UI/runtime field, instead extend
+ * `PersistedItemConfig` deliberately and add a normalizer entry — DO NOT mutate
+ * runtime state into the persisted view.
+ */
+
+/** Backend-compatible config (alias for the existing ItemConfig). */
+type PersistedItemConfig = ItemConfig;
+/** Friendly title view-model. */
+interface TitleUi {
+    title: string;
+    /** Subtitle (optional, lives under clientConfig.subtitle). */
+    subtitle: string;
+    showSubtitle: boolean;
+    icon: string;
+    iconColor: string;
+    iconBackgroundColor: string;
+    /** Hold the localized payload to round-trip both languages safely. */
+    localizedTitle?: LocalizedName;
+    localizedSubtitle?: LocalizedName;
+}
+/** Compact data-source view-model (fields specific to the chart's manifest). */
+interface DatasourceUi {
+    /** Top-level chart enum (BarV2Chart, etc.) — read-only in popover. */
+    chartType: string;
+    /** Number of selections configured. */
+    selectionCount: number;
+    /** Whether the chart uses a custom API rather than module selection. */
+    hasCustomApi: boolean;
+    /** Function name (read-only summary). */
+    functionName?: string;
+    /** Whether at least one selection has a `selector`. */
+    hasValidSelection: boolean;
+}
+/** Single field assignment (value/group/category). */
+interface FieldAssignment {
+    role: 'value' | 'groupBy' | 'category' | 'property' | 'extra';
+    propertyKey: string;
+    propertyLabel?: string;
+}
+/** Friendly field assignments derived from `serviceConfig.query`. */
+interface FieldsUi {
+    value?: FieldAssignment;
+    groupBy: FieldAssignment[];
+    category?: FieldAssignment;
+    properties: FieldAssignment[];
+    extras: FieldAssignment[];
+    formula?: string;
+}
+/** Operator that the BE accepts. */
+type FilterOperator = 'Equals' | 'NotEquals' | 'OneOf' | 'Between' | 'Contains' | 'GreaterThan' | 'LessThan' | 'IsNull' | 'IsNotNull';
+/** Where the filter is enforced. */
+type FilterScope = 'chart' | 'page' | 'source' | 'repeater';
+/** Where the filter originated in the persisted shape. */
+type FilterSource = 'static' | 'dynamic' | 'selection' | 'page' | 'repeater';
+interface FilterChip {
+    /** Stable id within the UI session. */
+    id: string;
+    scope: FilterScope;
+    source: FilterSource;
+    propertyKey: string;
+    propertyLabel?: string;
+    operator: FilterOperator;
+    value: unknown;
+    /** Dynamic key if scoped to a page placeholder. */
+    dynamicKey?: string;
+    /** Optional metadata (selectionId, etc.). */
+    meta?: Record<string, unknown>;
+    /** UI on/off toggle. Persisted. */
+    active: boolean;
+}
+interface FiltersUi {
+    chips: FilterChip[];
+    /** Whether this chart honors page-wide filters (`!ignoreQueryFilter`). */
+    honorsPageFilters: boolean;
+}
+interface StyleUi {
+    /** Title color override (clientConfig.displayConfig.StyleConfig.color). */
+    titleColor: string;
+    /** Title font size. */
+    titleFontSize: number;
+    /** Card background color. */
+    backgroundColor: string;
+    /** Card border color. */
+    borderColor: string;
+    /** Subtitle color. */
+    subtitleColor: string;
+    /** Subtitle font size. */
+    subtitleFontSize: number;
+    /** Default palette for series colors. */
+    paletteColors: string[];
+}
+interface LayoutUi {
+    borderRadius: number;
+    padding: number;
+    shadow: 'none' | 'soft' | 'medium' | 'strong';
+    density: 'compact' | 'comfortable' | 'presentation';
+}
+interface LabelLegendFormatUi {
+    legendShow: boolean;
+    legendPosition: 'top' | 'right' | 'bottom' | 'left';
+    legendIconType: 'circle' | 'rect' | 'roundRect' | 'triangle' | 'diamond';
+    labelShow: boolean;
+    labelPosition: 'inside' | 'outside' | 'top';
+    formatType: 'number' | 'currency' | 'percentage';
+    formatCurrencyCode?: string;
+    formatDecimals?: number;
+}
+interface BehaviorUi {
+    filtersBarVisible: boolean;
+    cardActions: number;
+    /** Whether the per-card refresh button is shown (driven by filterConfig.show). */
+    showRefreshButton: boolean;
+}
+interface UiItemConfig {
+    title: TitleUi;
+    datasource: DatasourceUi;
+    fields: FieldsUi;
+    filters: FiltersUi;
+    style: StyleUi;
+    layout: LayoutUi;
+    labelLegendFormat: LabelLegendFormatUi;
+    behavior: BehaviorUi;
+}
+/**
+ * Runtime-only state on a chart item. Never persisted.
+ *
+ * Builder/viewer track these in component signals or item-store; they are
+ * documented here so engineers can reason about which state is volatile.
+ */
+interface RuntimeItemConfig {
+    /** True while a request is in flight. */
+    loading: boolean;
+    /** True when the most recent request failed. */
+    hasError: boolean;
+    /** Last error message. */
+    errorMessage?: string;
+    /** True when the chart has no datasource and is showing the Configure CTA. */
+    needsConfiguration: boolean;
+    /** Repeater clone marker (set by repeater-runtime). */
+    substituted?: boolean;
+}
+/** A complete view assembly used by the contextual popover. */
+interface ConfigViewAssembly {
+    ui: UiItemConfig;
+    persisted: PersistedItemConfig;
+    runtime: RuntimeItemConfig;
+}
+
+declare function titleToUi(persisted: PersistedItemConfig): TitleUi;
+declare function applyTitleToPersisted(persisted: PersistedItemConfig, patch: Partial<TitleUi>, activeLang?: string): PersistedItemConfig;
+declare function datasourceToUi(persisted: PersistedItemConfig): {
+    chartType: string;
+    selectionCount: any;
+    hasCustomApi: boolean;
+    functionName: string | undefined;
+    hasValidSelection: any;
+};
+declare function fieldsToUi(persisted: PersistedItemConfig): FieldsUi;
+declare function filtersToUi(persisted: PersistedItemConfig): FiltersUi;
+declare function styleToUi(persisted: PersistedItemConfig): StyleUi;
+declare function applyStyleToPersisted(persisted: PersistedItemConfig, patch: Partial<StyleUi>): PersistedItemConfig;
+declare function layoutToUi(persisted: PersistedItemConfig): LayoutUi;
+declare function applyLayoutToPersisted(persisted: PersistedItemConfig, patch: Partial<LayoutUi>): PersistedItemConfig;
+declare function labelLegendFormatToUi(persisted: PersistedItemConfig): LabelLegendFormatUi;
+declare function applyLabelLegendFormatToPersisted(persisted: PersistedItemConfig, patch: Partial<LabelLegendFormatUi>): PersistedItemConfig;
+declare function behaviorToUi(persisted: PersistedItemConfig): BehaviorUi;
+declare function applyBehaviorToPersisted(persisted: PersistedItemConfig, patch: Partial<BehaviorUi>): PersistedItemConfig;
+/**
+ * Apply chip edits back to the persisted shape. Replaces the chart-local
+ * staticFilters block in full (chips of source 'static') and updates dynamic
+ * filter active/operator hints. Selection-source chips are read-only here —
+ * those flow through DataSourceSettings advanced.
+ */
+declare function applyFilterChipsToPersisted(persisted: PersistedItemConfig, chips: FilterChip[]): PersistedItemConfig;
+declare function persistedToUi(persisted: PersistedItemConfig): UiItemConfig;
+declare function buildAssembly(persisted: PersistedItemConfig, runtime: RuntimeItemConfig): ConfigViewAssembly;
+
+/**
+ * Pass 3 Config Presets.
+ *
+ * Sensible defaults per chart capability for the contextual popover. These
+ * are *defaults* the popover applies when the user picks a preset; they
+ * never overwrite previously saved values silently.
+ *
+ * Presets are persisted using the same paths the manual controls use, so
+ * applying a preset is functionally equivalent to a user-made config.
+ */
+
+type StylePresetKey = 'compact' | 'standard' | 'presentation' | 'kpi-card' | 'table-dense' | 'table-comfortable';
+interface StylePreset {
+    key: StylePresetKey;
+    label: string;
+    description: string;
+    layout: Partial<LayoutUi>;
+    style: Partial<StyleUi>;
+    labelLegendFormat: Partial<LabelLegendFormatUi>;
+}
+declare const STYLE_PRESETS: readonly StylePreset[];
+/**
+ * Recommend the relevant presets for a chart capability — table presets only
+ * for tables, KPI presets only for cards. The popover surfaces this list.
+ */
+declare function presetsForCapability(cap: ChartCapability | null | undefined): readonly StylePreset[];
+declare function findPreset(key: StylePresetKey): StylePreset | undefined;
+
+/**
+ * Pass 3 Config Validators.
+ *
+ * Domain-aware validation for the contextual popover and Save flow. Each
+ * validator returns a flat array of `ValidationIssue` so the popover can
+ * surface them next to the right control.
+ *
+ * Validators are read-only — they never mutate the input. They DO honor
+ * the manifest schema (`capability.query.schema.required`) so a chart can
+ * declare which fields must be present before save is allowed.
+ */
+
+type ValidationSeverity = 'error' | 'warning' | 'info';
+interface ValidationIssue {
+    domain: ConfigDomainKey;
+    severity: ValidationSeverity;
+    /** Stable code for tests / i18n. */
+    code: string;
+    /** Human message. */
+    message: string;
+    /** Optional dotted path to the persisted field for focusing. */
+    path?: string;
+}
+interface ValidateOptions {
+    capability?: ChartCapability | null;
+    filterChips?: FilterChip[];
+}
+declare function validate(persisted: PersistedItemConfig, options?: ValidateOptions): ValidationIssue[];
+declare function hasBlockingIssues(issues: ValidationIssue[]): boolean;
+declare function groupIssuesByDomain(issues: ValidationIssue[]): Record<ConfigDomainKey, ValidationIssue[]>;
+
+/**
+ * Pass 3 Advanced Config Bridge.
+ *
+ * Centralized JSON merge helpers used by the Advanced tab in the contextual
+ * popover and by the existing `chart-settings-drawer` Advanced JSON editor.
+ *
+ * Responsibilities:
+ *  - Parse a JSON draft, return either a typed value or a friendly error.
+ *  - Deep-merge a parsed object into the existing clientConfig (keeping
+ *    nested keys intact unless explicitly overridden).
+ *  - Never persist invalid JSON; never accept a top-level array or scalar.
+ */
+type ParseResult = {
+    ok: true;
+    value: Record<string, unknown>;
+} | {
+    ok: false;
+    error: string;
+};
+declare function parseAdvancedJson(draft: string): ParseResult;
+/**
+ * Deep-merge `source` into `target`. Arrays and primitives in source REPLACE
+ * the target value; nested plain objects are merged recursively.
+ *
+ * Pure: returns a new object.
+ */
+declare function deepMerge(target: Record<string, any> | null | undefined, source: Record<string, any> | null | undefined): Record<string, any>;
+/** Convert a typed value to a pretty-printed JSON string for editor use. */
+declare function formatForEditor(value: unknown): string;
+
+/**
+ * Pass 4 — Control Schema Types
+ *
+ * Schema-driven control generator. Every supported chart/item type declares a
+ * `ControlSchema` (or inherits one) describing the controls it exposes in the
+ * contextual popover. A single generic renderer (`SchemaControlRendererComponent`)
+ * walks the schema, reads from `PersistedItemConfig` via the field's `path`,
+ * and emits patches that the host applies through the existing adapters.
+ *
+ * Why schema instead of one component per chart:
+ *  - 27+ existing chart/item types share most of their controls.
+ *  - One renderer keeps UX consistent and avoids component sprawl.
+ *  - Adding a control to a chart is a one-line registry change.
+ *  - Coverage is verifiable from data.
+ *
+ * The schema does NOT replace the persisted shape. The generic renderer reads
+ * and writes the same paths the renderer-handler consumes, so a control added
+ * to the schema affects rendering through the existing pipeline.
+ */
+
+/** Canonical control field types the generic renderer can render. */
+type ControlFieldType = 'text' | 'multilineText' | 'number' | 'boolean' | 'color' | 'select' | 'multiselect' | 'iconPicker' | 'palette' | 'json' | 'numberRange' | 'cssDimension';
+/** Where the control lives in the popover. */
+type ControlSectionScope = 'simple' | 'advanced';
+/** Domain bucket — used by the popover to group controls and validation. */
+type ControlDomain = 'title' | 'header' | 'style' | 'layout' | 'labelLegendFormat' | 'behavior' | 'chart' | 'table' | 'card' | 'gauge' | 'timeline' | 'map' | 'entity' | 'levelCards' | 'splitter' | 'snapshot' | 'phaseGate' | 'repeater' | 'advanced';
+/** A select option. Static list (or capability-derived if dynamic). */
+interface ControlOption {
+    label: string;
+    value: string | number | boolean;
+    /** Optional icon name. */
+    icon?: string;
+    /** Optional tooltip / description. */
+    hint?: string;
+}
+/** Predicate signature for visibleWhen. */
+type ControlVisiblePredicate = (cfg: PersistedItemConfig, cap: ChartCapability | null) => boolean;
+/**
+ * One controllable field in the schema.
+ *
+ * `path` is a dotted accessor over `PersistedItemConfig` — e.g.
+ * `clientConfig.displayConfig.StyleConfig.color` or `serviceConfig.query.valueProperty`.
+ * Read/write helpers in `control-schema.access.ts` use it to translate between
+ * the schema and the persisted shape so renderers continue to consume the
+ * same paths.
+ */
+interface ControlField {
+    /** Stable id for tests, telemetry, validation routing. */
+    key: string;
+    /** Human label (English fallback). */
+    label: string;
+    /** Optional helper text shown under the control. */
+    description?: string;
+    /** Renderer kind. */
+    type: ControlFieldType;
+    /** Persisted dotted path (read/write target). */
+    path: string;
+    /**
+     * Default value applied when the field is missing on the persisted shape.
+     * The default is *only* read for display — it is never silently written.
+     */
+    default?: unknown;
+    /** Min/max for numeric inputs. */
+    min?: number;
+    max?: number;
+    /** Step for numeric inputs. */
+    step?: number;
+    /** Static options for select/multiselect. */
+    options?: ControlOption[];
+    /**
+     * Dynamic options provider — receives the capability and the persisted
+     * config and returns options derived from the dashboard model (e.g. the
+     * list of selected properties for a value-field picker).
+     */
+    optionsFrom?: (cfg: PersistedItemConfig, cap: ChartCapability | null) => ControlOption[];
+    /** Whether the control is shown only in advanced mode. */
+    scope?: ControlSectionScope;
+    /** Whether the control is required for save. */
+    required?: boolean;
+    /** Hide the control unless the predicate returns true. */
+    visibleWhen?: ControlVisiblePredicate;
+    /** Optional placeholder text. */
+    placeholder?: string;
+}
+/** A logical group of fields in the popover. */
+interface ControlSection {
+    /** Stable id for the section. */
+    key: string;
+    /** Human label (English fallback). */
+    label: string;
+    /** Icon (mt icon) shown in the section header. */
+    icon: string;
+    /** Domain grouping (used by validators and the popover). */
+    domain: ControlDomain;
+    /** Default scope — fields can override per-field. */
+    scope: ControlSectionScope;
+    /** Optional helper paragraph at the top of the section. */
+    description?: string;
+    /** Hide the section unless the predicate returns true. */
+    visibleWhen?: ControlVisiblePredicate;
+    /** Fields in display order. */
+    fields: ControlField[];
+}
+/**
+ * Complete schema for a chart/item type.
+ *
+ * - `id` matches a `ChartCapability.id`.
+ * - `extends` lets a chart inherit common sections.
+ * - `sections` are merged with parent — duplicate `key`s in the child override
+ *   the parent (NOT a shallow merge of fields; each section is replaced atomically).
+ */
+interface ControlSchema {
+    /** Capability id this schema belongs to. */
+    id: string;
+    /** Short name for documentation/coverage matrices. */
+    name: string;
+    /** Optional parent schema id (for inheritance). */
+    extends?: string;
+    /** Section list. */
+    sections: ControlSection[];
+}
+/**
+ * What the renderer emits when a field changes — the host translates this
+ * patch into a persisted config patch via `applyControlPatchToPersisted`.
+ */
+interface ControlPatch {
+    /** Field path (matches the `ControlField.path`). */
+    path: string;
+    /** New value (any JSON-serializable). */
+    value: unknown;
+}
+/** Convenience: a flat (non-grouped) control list — used by coverage checks. */
+interface FlattenedControl {
+    sectionKey: string;
+    sectionLabel: string;
+    domain: ControlDomain;
+    scope: ControlSectionScope;
+    field: ControlField;
+}
+
+/**
+ * Pass 4 - Control Schema Access Helpers
+ *
+ * Pure read/write helpers for the schema-driven control system.
+ *
+ * - readByPath reads a value out of a PersistedItemConfig using a dotted
+ *   path (e.g. clientConfig.displayConfig.StyleConfig.color).
+ * - applyControlPatchToPersisted returns a deep-cloned copy of the config
+ *   with the value at path set, creating intermediate objects as needed.
+ *
+ * No third-party dependencies - keeps the bundle small and deterministic.
+ */
+
+declare function readByPath(cfg: PersistedItemConfig | null | undefined, path: string): unknown;
+declare function setByPath(cfg: PersistedItemConfig, path: string, value: unknown): PersistedItemConfig;
+declare function applyControlPatchToPersisted(cfg: PersistedItemConfig, patch: ControlPatch): PersistedItemConfig;
+declare function applyControlPatchesToPersisted(cfg: PersistedItemConfig, patches: ControlPatch[]): PersistedItemConfig;
+
+/**
+ * Pass 4 - Control Schema Registry
+ *
+ * One ControlSchema per supported chart/item type. Sections are grouped by
+ * domain so the popover can render compact, focused control surfaces.
+ *
+ * Many charts share common controls (title, header, card style, label/legend,
+ * format, palette). Those live in COMMON_SECTION_FACTORIES and are composed
+ * into per-chart schemas, then per-chart schemas add chart-specific sections
+ * (bar settings, pie label center, ring gauge config, table format, etc.).
+ *
+ * IMPORTANT: paths point to the same persisted locations the renderer-handlers
+ * already consume. Adding a control here makes the value editable end-to-end
+ * without changing the renderer or the persistence pipeline.
+ */
+
+declare function getControlSchema(capabilityId: string | null | undefined): ControlSchema;
+declare function listControlSchemaIds(): string[];
+declare function listControlSchemas(): ControlSchema[];
+declare function getFallbackControlSchema(): ControlSchema;
+declare function flattenSchema(schema: ControlSchema): {
+    sectionKey: string;
+    sectionLabel: string;
+    fieldKey: string;
+    fieldPath: string;
+    fieldLabel: string;
+    type: ControlField["type"];
+}[];
+
+/**
+ * Pass 4 - Display field visibility helper.
+ *
+ * The legacy `DisplaySettings` component used to own a giant in-component map
+ * (`chartTypeFieldsMap`) that listed which display-config fields appear for
+ * each chart type. Adding a chart meant editing the map by hand.
+ *
+ * This helper derives the same visibility set from the manifest
+ * (`ChartCapability.display.fields`) so:
+ *  - DisplaySettings does not need to know about every chart type.
+ *  - Adding a chart in the manifest automatically gives it the right fields.
+ *  - The popover and the legacy drawer share one source of truth.
+ *
+ * Backwards compatibility is preserved by merging the manifest's field set
+ * with the legacy map for charts that still have a hand-curated entry there;
+ * a chart with both is the union (manifest wins on additions).
+ */
+
+interface DisplayFieldQuery {
+    capabilityId?: string | null;
+    serviceType?: string | null;
+    componentName?: string | null;
+}
+/**
+ * Resolve the visible display-fields list for a chart. Manifest is the
+ * primary source - the legacy hand-curated map only kicks in when the
+ * manifest entry doesn't supply any fields, AND it gets unioned with the
+ * manifest list otherwise so we never lose hand-tuned entries.
+ */
+declare function resolveDisplayFields(cap: ChartCapability | null | undefined, query?: DisplayFieldQuery): string[];
+/**
+ * For a given DisplayFieldQuery, expand the resolved field list into a quick
+ * predicate function. Used by DisplaySettings so it can skip the giant
+ * `shouldShowField` switch and ask the helper instead.
+ */
+declare function buildDisplayFieldPredicate(cap: ChartCapability | null | undefined, query?: DisplayFieldQuery): (field: string) => boolean;
+
+/**
+ * Pass 5 — Renderer-Control Binding Metadata.
+ *
+ * One canonical metadata record per chart-type+control combination. The schema
+ * registry, runtime adapters, the renderer-handlers (via `BINDING_LEGACY_READ`)
+ * and the verification script all consult these records so that:
+ *
+ *   1. The path a control writes to is the path the renderer reads from.
+ *   2. Old persisted configs still load (legacy read paths are resolved by
+ *      the runtime helper `readBoundValue` so the renderer can prefer a
+ *      legacy field if the canonical field is missing — the inverse of how
+ *      a fresh popover write would propagate).
+ *   3. Coverage and binding mismatches can be verified statically without
+ *      booting the app.
+ *
+ * Each binding records:
+ *   - `chartId`               : capability id (e.g. `chart-line-chart`).
+ *   - `controlId`             : matches the schema field key.
+ *   - `domain`                : same domain bucket the schema section uses.
+ *   - `uiPath`                : UI-friendly read path used by the popover.
+ *   - `persistedPath`         : path written by the schema renderer + adapters.
+ *   - `runtimePath`           : path the runtime adapter exposes (often the
+ *                               same as persistedPath).
+ *   - `rendererReadPaths`     : paths the renderer/handler actually consumes
+ *                               at render time. The first item is the canonical
+ *                               renderer path; later items are accepted legacy
+ *                               aliases.
+ *   - `legacyPersistPaths`    : extra persisted paths that previous passes
+ *                               wrote to. Migrations and fallbacks consult
+ *                               these so old configs keep working.
+ *   - `valueAdapter`          : optional runtime transform (e.g. mapping a
+ *                               'horizontal'/'vertical' string to a boolean).
+ *   - `simpleOrAdvanced`      : popover scope (`simple` | `advanced`).
+ *   - `notes`                 : freeform notes that surface in audit reports.
+ *
+ * The `valueAdapter` is intentionally simple — it never reaches into the rest
+ * of the config — so JSON-only fields and complex nested transforms remain
+ * inside the renderer. This keeps binding metadata declarative.
+ */
+type BindingScope = 'simple' | 'advanced';
+interface ControlBindingValueAdapter {
+    /** Transform a UI value into the persisted shape (one-way). */
+    toPersisted?: (uiValue: unknown) => unknown;
+    /** Transform a persisted/runtime value into the UI display value. */
+    fromPersisted?: (persistedValue: unknown) => unknown;
+}
+interface ControlBinding {
+    /** Capability id this binding belongs to. */
+    chartId: string;
+    /** Stable id matching a `ControlField.key` in the schema. */
+    controlId: string;
+    /** Domain bucket — mirrors the schema section domain. */
+    domain: string;
+    /** UI display label (same as schema label). */
+    label: string;
+    /** UI read path (popover-side). */
+    uiPath: string;
+    /** Persisted path the schema/popover writes to. */
+    persistedPath: string;
+    /** Runtime adapter exposes this path. Usually identical to persistedPath. */
+    runtimePath: string;
+    /**
+     * Renderer read paths in priority order. The first entry is the canonical
+     * path the renderer prefers when present. Later entries are legacy paths the
+     * renderer also accepts (so old configs still work).
+     */
+    rendererReadPaths: string[];
+    /**
+     * Persisted paths that earlier passes wrote to. Migrations and adapters
+     * consult these so a previously persisted value still loads as-if written
+     * to the canonical persistedPath.
+     */
+    legacyPersistPaths?: string[];
+    /** Optional runtime transform between UI and persisted shapes. */
+    valueAdapter?: ControlBindingValueAdapter;
+    /** Default popover scope. */
+    simpleOrAdvanced: BindingScope;
+    /** Freeform documentation lines. */
+    notes?: string[];
+}
+/** Index by `${chartId}::${controlId}`. */
+type ControlBindingIndex = Map<string, ControlBinding>;
+declare function bindingKey(chartId: string, controlId: string): string;
+
+/**
+ * Pass 5 — Canonical control binding registry.
+ *
+ * Single source of truth for "which control writes where, and which renderer
+ * path actually consumes the value". Each binding declares:
+ *
+ *   - the persisted path the schema/popover writes to,
+ *   - the path the runtime exposes,
+ *   - one or more renderer read paths (first is canonical; the rest are
+ *     accepted legacy aliases for old configs),
+ *   - any legacy persist paths earlier passes wrote to (so migrations and
+ *     fallbacks still work).
+ *
+ * The schema registry, runtime helpers, and the verification script all
+ * consult these records so:
+ *
+ *   1. Adding a control without a binding is a verification failure.
+ *   2. Schema and renderer cannot drift in opposite directions silently.
+ *   3. Old persisted configs keep working because legacy paths remain in the
+ *      renderer's accepted list.
+ *
+ * Bindings here are intentionally chart-specific. Common shared controls
+ * (title, palette, density) declare one binding per consuming chart so the
+ * verification script catches drift even when the same logical control is
+ * shared.
+ */
+
+declare function getBinding(chartId: string, controlId: string): ControlBinding | undefined;
+declare function listBindings(): ControlBinding[];
+declare function listBindingsForChart(chartId: string): ControlBinding[];
+/**
+ * Resolve a renderer-bound value at runtime.
+ *
+ * The renderer receives a `clientConfig`/`serviceConfig` pair and asks for the
+ * value at a logical control id. This function consults the binding's
+ * `rendererReadPaths` in order, returning the first defined value. If none of
+ * the bound paths produces a value, the default is returned. Old configs that
+ * persisted to a legacy path therefore still resolve to a usable runtime
+ * value without the renderer needing chart-specific fallbacks scattered
+ * everywhere.
+ */
+declare function readBoundValue(chartId: string, controlId: string, cfg: {
+    serviceConfig?: any;
+    clientConfig?: any;
+} | null | undefined, fallback?: unknown): unknown;
+
+/**
+ * Pass-6 item guidance model.
+ *
+ * Eight discrete states that a chart card can be in. Each state declares a
+ * primary action (translated), an optional secondary action, an icon, and a
+ * severity so the chrome (chart-card / dashboard-item) renders one
+ * consistent surface instead of scattering ad-hoc conditionals across
+ * templates.
+ */
+
+type ItemGuidanceState = 'unconfigured' | 'missingDatasource' | 'missingFields' | 'invalidFilters' | 'readyToPreview' | 'noData' | 'dataError' | 'configured';
+type ItemGuidanceSeverity = 'info' | 'warn' | 'error' | 'success';
+interface ItemGuidanceAction {
+    /**
+     * Stable identifier that the chrome dispatches to its host. Hosts map
+     * the id to a router action (open guided wizard on a specific step,
+     * open kebab menu, open legacy editor, retry, etc.).
+     */
+    id: 'open-guided' | 'open-guided-source' | 'open-guided-fields' | 'open-guided-filters' | 'open-guided-preview' | 'open-guided-advanced' | 'open-legacy-editor' | 'edit-title' | 'open-more' | 'retry' | 'refresh';
+    /** Translation key for the label. */
+    labelKey: string;
+    /** Optional MT icon. */
+    icon?: MTIcon;
+    /** Optional translation key for the tooltip / aria-label. */
+    tooltipKey?: string;
+}
+interface ItemGuidanceDescriptor {
+    /** State id. */
+    state: ItemGuidanceState;
+    /** Severity (drives chip color). */
+    severity: ItemGuidanceSeverity;
+    /** MT icon for the surface. */
+    icon: MTIcon;
+    /** Translation key for the title heading. */
+    titleKey: string;
+    /** Translation key for the description / hint. */
+    descriptionKey: string;
+    /** Primary CTA. */
+    primaryAction: ItemGuidanceAction;
+    /** Optional secondary CTA. */
+    secondaryAction?: ItemGuidanceAction;
+    /** Whether to render the center primary CTA card. */
+    showCenterCta: boolean;
+    /** Whether the inline title editor should be visible (builder mode). */
+    showTitleEdit: boolean;
+    /** Whether the top-end "More actions" kebab should be visible (builder). */
+    showTopEndMenu: boolean;
+}
+
+/**
+ * Pass-6 item guidance registry.
+ *
+ * Static descriptor table for each `ItemGuidanceState`. The registry is the
+ * single source of truth for "what should the user see in this state?".
+ * Templates query this registry instead of hard-coding strings/icons.
+ */
+
+declare const ITEM_GUIDANCE_REGISTRY: Record<ItemGuidanceState, ItemGuidanceDescriptor>;
+declare function describeGuidance(state: ItemGuidanceState): ItemGuidanceDescriptor;
+
+interface GuidanceInput {
+    /** Persisted config (from store) — null while initial load is in flight. */
+    config: ItemConfig | null;
+    /** Whether the chart is currently loading data from the backend. */
+    isLoading: boolean;
+    /** Whether the last request failed. */
+    hasError: boolean;
+    /** Whether handler returned non-empty data. */
+    hasData: boolean;
+    /** Whether the host is in builder mode (CTA + chrome show). */
+    builderMode: boolean;
+}
+declare class ItemGuidanceService {
+    /**
+     * Resolve a single guidance state from the persisted config + runtime
+     * flags. Falls back to `'configured'` when nothing else applies.
+     *
+     * Note: returns `null` when the host is not in builder mode and the chart
+     * has data — viewer mode does not show guidance overlays.
+     */
+    resolveState(input: GuidanceInput): ItemGuidanceState | null;
+    /**
+     * Whether the guidance state is a "needs user intervention" state. Useful
+     * for the chrome to decide whether the center CTA card should obscure the
+     * underlying chart skeleton.
+     */
+    isInterventionState(state: ItemGuidanceState | null): boolean;
+    private resolveCapability;
+    private isLayoutOrSpecial;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ItemGuidanceService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ItemGuidanceService>;
+}
+
+declare class ChartFilterDrawer {
+    private readonly dialogRef;
+    private readonly drawerConfig;
+    readonly workingItem: _angular_core.WritableSignal<DashboardChartItem | null>;
+    readonly workingChips: _angular_core.WritableSignal<FilterChip[]>;
+    /** Track that we have changes so cancel-without-apply discards them. */
+    private dirty;
+    /** Computed accessor to the persisted item config for the filter builder. */
+    readonly persisted: _angular_core.Signal<_masterteam_dashboard_builder.ItemConfig | null>;
+    constructor();
+    onChipsChange(next: FilterChip[]): void;
+    apply(): void;
+    cancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChartFilterDrawer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChartFilterDrawer, "mt-chart-filter-drawer", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * The action triggered by the toolbar. The host (dashboard-builder /
+ * dashboard-item) is responsible for opening the appropriate surface.
+ */
+type ItemContextAction = {
+    type: 'open-popover';
+    tab: PopoverTab;
+} | {
+    type: 'edit-title';
+} | {
+    type: 'duplicate';
+} | {
+    type: 'remove';
+} | {
+    type: 'open-advanced-editor';
+};
+declare class ItemContextToolbarComponent {
+    /** Whether to render the compact (single-button) variant. */
+    readonly compact: _angular_core.InputSignal<boolean>;
+    /** Whether duplicate is allowed (false for layout/group widgets). */
+    readonly allowDuplicate: _angular_core.InputSignal<boolean>;
+    /** Action emitter — host wires this to popover/dialog/edit handlers. */
+    readonly action: _angular_core.OutputEmitterRef<ItemContextAction>;
+    readonly allActions: _angular_core.Signal<({
+        id: string;
+        labelEn: string;
+        icon: string;
+        actionPayload: {
+            type: "open-popover";
+            tab: PopoverTab;
+        };
+    } | {
+        id: string;
+        labelEn: string;
+        icon: string;
+        actionPayload: {
+            type: "duplicate";
+            tab?: undefined;
+        };
+    } | {
+        id: string;
+        labelEn: string;
+        icon: string;
+        actionPayload: {
+            type: "open-advanced-editor";
+            tab?: undefined;
+        };
+    } | {
+        id: string;
+        labelEn: string;
+        icon: string;
+        actionPayload: {
+            type: "remove";
+            tab?: undefined;
+        };
+    })[]>;
+    emitAction(action: ItemContextAction): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ItemContextToolbarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ItemContextToolbarComponent, "mt-item-context-toolbar", never, { "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "allowDuplicate": { "alias": "allowDuplicate"; "required": false; "isSignal": true; }; }, { "action": "action"; }, never, never, true, never>;
+}
+
+interface ItemConfigPopoverData {
+    item: DashboardChartItem;
+    /** Initial tab - defaults to 'data'. */
+    defaultTab?: PopoverTab;
+}
+type ItemConfigPopoverResult = {
+    type: 'apply';
+    item: DashboardChartItem;
+} | {
+    type: 'cancel';
+} | {
+    type: 'open-advanced-editor';
+    tab: 'general' | 'dataSource' | 'actions';
+} | {
+    type: 'open-chart-settings-drawer';
+    item: DashboardChartItem;
+};
+declare class ItemConfigPopoverComponent {
+    private readonly dialogRef;
+    private readonly dialogConfig;
+    /** Working item - deep-cloned so cancel does not mutate canvas state. */
+    readonly item: _angular_core.WritableSignal<DashboardChartItem | null>;
+    /** Tabs (constant). */
+    readonly tabs: _angular_core.WritableSignal<{
+        value: PopoverTab;
+        key: PopoverTab;
+        label: string;
+        icon: string;
+    }[]>;
+    /** Active tab. */
+    readonly activeTab: _angular_core.WritableSignal<PopoverTab>;
+    /**
+     * Style/Behavior/Advanced controls scope. Simple shows the most-common
+     * controls; advanced reveals every field from the chart's control schema.
+     */
+    readonly controlScope: _angular_core.WritableSignal<ControlSectionScope>;
+    /** Capability for this item. */
+    readonly capability: _angular_core.Signal<_masterteam_dashboard_builder.ChartCapability | null>;
+    /** Control schema for this chart capability. */
+    readonly schema: _angular_core.Signal<ControlSchema>;
+    /** Available presets for the capability. */
+    readonly presets: _angular_core.Signal<readonly StylePreset[]>;
+    /** UI snapshot for read paths. */
+    readonly ui: _angular_core.Signal<_masterteam_dashboard_builder.UiItemConfig | null>;
+    /** Filter chips (UI representation). */
+    readonly chips: _angular_core.Signal<FilterChip[]>;
+    /** Persisted config for the schema renderer. */
+    readonly persistedConfig: _angular_core.Signal<ItemConfig | null>;
+    /** Validation issues. */
+    readonly issues: _angular_core.Signal<_masterteam_dashboard_builder.ValidationIssue[]>;
+    readonly issuesByDomain: _angular_core.Signal<Record<_masterteam_dashboard_builder.ConfigDomainKey, _masterteam_dashboard_builder.ValidationIssue[]>>;
+    readonly hasErrors: _angular_core.Signal<boolean>;
+    /** Advanced JSON draft. */
+    readonly advancedJsonDraft: _angular_core.WritableSignal<string>;
+    readonly advancedJsonError: _angular_core.WritableSignal<string>;
+    private advancedJsonInitialized;
+    constructor();
+    /** Selected style preset key (computed from the current layout). */
+    readonly selectedPresetKey: _angular_core.Signal<StylePresetKey | null>;
+    onTitleChange(title: string): void;
+    onStylePatch(patch: Partial<StyleUi>): void;
+    onLayoutPatch(patch: Partial<LayoutUi>): void;
+    /**
+     * Apply a preset across all declared domains. Pass 4 fix: the previous
+     * implementation only applied layout + style; presets that declared
+     * `labelLegendFormat` overrides were silently dropped. This now applies
+     * every domain the preset declares so the renderer receives the same
+     * values the preset shape promises.
+     */
+    onApplyPreset(preset: StylePreset): void;
+    onChipsChange(chips: FilterChip[]): void;
+    onServiceConfigPatch(partial: Partial<ServiceConfig>): void;
+    onShowFiltersBarChange(show: boolean): void;
+    onSchemaPatch(patch: ControlPatch): void;
+    toggleControlScope(): void;
+    initAdvancedJsonIfNeeded(): void;
+    onAdvancedJsonChange(value: string): void;
+    applyAdvancedJson(): void;
+    apply(): void;
+    cancel(): void;
+    openAdvancedEditor(tab?: 'general' | 'dataSource' | 'actions'): void;
+    /**
+     * Hand-off to the chart-settings-drawer (legacy bar/pie/stack drawer for
+     * power users). Pre-applies the in-popover edits so the drawer opens on
+     * the latest state.
+     */
+    openChartSettingsDrawer(): void;
+    private patchPersisted;
+    private cloneItem;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ItemConfigPopoverComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ItemConfigPopoverComponent, "mt-item-config-popover", never, {}, {}, never, never, true, never>;
+}
+
+/** Five steps. The host can request a default. */
+type GuidedStep = 'source' | 'fields' | 'filters' | 'preview' | 'advanced';
+interface GuidedConfigDialogData {
+    item: DashboardChartItem;
+    /** Initial step — defaults to 'source' for new charts. */
+    defaultStep?: GuidedStep;
+    /** Optional popover-tab compat (the kebab still emits PopoverTab values). */
+    defaultTab?: PopoverTab;
+}
+type GuidedConfigDialogResult = {
+    type: 'apply';
+    item: DashboardChartItem;
+} | {
+    type: 'cancel';
+} | {
+    type: 'open-advanced-editor';
+};
+declare class GuidedConfigDialogComponent {
+    private readonly dialogRef;
+    private readonly dialogConfig;
+    private readonly transloco;
+    private readonly guidance;
+    /** Working copy — deep-cloned so cancel does not mutate canvas state. */
+    readonly item: _angular_core.WritableSignal<DashboardChartItem | null>;
+    /** Current step. */
+    readonly activeStep: _angular_core.WritableSignal<GuidedStep>;
+    /** Step order. */
+    private readonly STEPS;
+    readonly stepOptions: _angular_core.Signal<{
+        label: string;
+        value: string;
+        icon: string;
+    }[]>;
+    readonly progressPercent: _angular_core.Signal<number>;
+    readonly isLastStep: _angular_core.Signal<boolean>;
+    readonly canGoBack: _angular_core.Signal<boolean>;
+    /** Capability for this item. */
+    readonly capability: _angular_core.Signal<_masterteam_dashboard_builder.ChartCapability | null>;
+    /** Control schema for the current chart capability. */
+    readonly schema: _angular_core.Signal<ControlSchema>;
+    /** Persisted config snapshot. */
+    readonly persistedConfig: _angular_core.Signal<ItemConfig | null>;
+    /** UI snapshot. */
+    readonly ui: _angular_core.Signal<_masterteam_dashboard_builder.UiItemConfig | null>;
+    /** Filter chips (UI representation). */
+    readonly chips: _angular_core.Signal<FilterChip[]>;
+    /** Validation issues. */
+    readonly issues: _angular_core.Signal<_masterteam_dashboard_builder.ValidationIssue[]>;
+    readonly issuesByDomain: _angular_core.Signal<Record<_masterteam_dashboard_builder.ConfigDomainKey, _masterteam_dashboard_builder.ValidationIssue[]>>;
+    readonly hasErrors: _angular_core.Signal<boolean>;
+    /** Resolved guidance state for the chip in the header. */
+    readonly state: _angular_core.Signal<ItemGuidanceState | null>;
+    readonly stateDescriptor: _angular_core.Signal<_masterteam_dashboard_builder.ItemGuidanceDescriptor>;
+    /** Summary chips for Step 4. */
+    readonly summaryChips: _angular_core.Signal<{
+        id: string;
+        label: string;
+        icon: "dev.database-01" | "layout.list" | "general.filter-funnel-01" | "alert.alert-circle" | "general.check-circle";
+        tone: "ok" | "missing";
+    }[]>;
+    /** Advanced JSON draft. */
+    readonly advancedJsonDraft: _angular_core.WritableSignal<string>;
+    readonly advancedJsonError: _angular_core.WritableSignal<string>;
+    private advancedJsonInitialized;
+    constructor();
+    onTitleChange(title: string): void;
+    onChipsChange(chips: FilterChip[]): void;
+    onServiceConfigPatch(partial: Partial<ServiceConfig>): void;
+    onSchemaPatch(patch: ControlPatch): void;
+    initAdvancedJsonIfNeeded(): void;
+    onAdvancedJsonChange(value: string): void;
+    applyAdvancedJson(): void;
+    goNext(): void;
+    goBack(): void;
+    apply(): void;
+    cancel(): void;
+    openAdvancedEditor(): void;
+    private patchPersisted;
+    private cloneItem;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GuidedConfigDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GuidedConfigDialogComponent, "mt-guided-config-dialog", never, {}, {}, never, never, true, never>;
+}
+
+declare class FilterChipsBarComponent {
+    readonly chips: _angular_core.InputSignal<FilterChip[]>;
+    readonly chipsChange: _angular_core.OutputEmitterRef<FilterChip[]>;
+    readonly editingChipId: _angular_core.WritableSignal<string | null>;
+    readonly showReadonly: _angular_core.WritableSignal<boolean>;
+    readonly visibleChips: _angular_core.Signal<FilterChip[]>;
+    readonly hiddenCount: _angular_core.Signal<number>;
+    scopeLabel(chip: FilterChip): string;
+    operatorLabel(chip: FilterChip): string;
+    formatValue(chip: FilterChip): string;
+    editableScope(source: FilterChip['source']): boolean;
+    toggle(chip: FilterChip): void;
+    remove(chip: FilterChip): void;
+    beginEdit(chip: FilterChip): void;
+    updateValue(chip: FilterChip, value: string): void;
+    commitEdit(): void;
+    cancelEdit(): void;
+    addStaticChip(): void;
+    toggleShowReadonly(): void;
+    private emit;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FilterChipsBarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FilterChipsBarComponent, "mt-filter-chips-bar", never, { "chips": { "alias": "chips"; "required": true; "isSignal": true; }; }, { "chipsChange": "chipsChange"; }, never, never, true, never>;
+}
+
+interface FieldOption {
+    key: string;
+    label: string;
+    source: 'query' | 'selectedProperties' | 'extraProperties' | 'manual';
+    viewType?: string;
+}
+declare class FilterBuilderComponent {
+    readonly chips: _angular_core.InputSignal<FilterChip[]>;
+    readonly persisted: _angular_core.InputSignal<ItemConfig | null>;
+    readonly chipsChange: _angular_core.OutputEmitterRef<FilterChip[]>;
+    readonly showReadOnly: _angular_core.WritableSignal<boolean>;
+    readonly OPERATOR_OPTIONS: {
+        value: FilterOperator;
+        label: string;
+        group: "common" | "string" | "number" | "list" | "null";
+    }[];
+    readonly editableChips: _angular_core.Signal<FilterChip[]>;
+    readonly readOnlyChips: _angular_core.Signal<FilterChip[]>;
+    readonly readOnlyCount: _angular_core.Signal<number>;
+    readonly fieldOptions: _angular_core.Signal<FieldOption[]>;
+    isKnownField(key: string): boolean;
+    scopeLabel(chip: FilterChip): string;
+    operatorReadonlyLabel(op: FilterOperator): string;
+    formatReadonlyValue(chip: FilterChip): string;
+    formatList(value: unknown): string;
+    getBetween(chip: FilterChip, idx: 0 | 1): string | number;
+    valueKind(chip: FilterChip): 'list' | 'between' | 'boolean' | 'number' | 'text';
+    toggleActive(chip: FilterChip): void;
+    remove(chip: FilterChip): void;
+    setField(chip: FilterChip, propertyKey: string): void;
+    setOperator(chip: FilterChip, raw: string): void;
+    setValue(chip: FilterChip, value: unknown): void;
+    setNumber(chip: FilterChip, raw: unknown): void;
+    setListValue(chip: FilterChip, raw: string): void;
+    setBetween(chip: FilterChip, idx: 0 | 1, raw: unknown): void;
+    addStaticFilter(): void;
+    toggleShowReadOnly(): void;
+    private emit;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FilterBuilderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FilterBuilderComponent, "mt-filter-builder", never, { "chips": { "alias": "chips"; "required": true; "isSignal": true; }; "persisted": { "alias": "persisted"; "required": false; "isSignal": true; }; }, { "chipsChange": "chipsChange"; }, never, never, true, never>;
+}
+
 /**
  * Chart Type Configuration
  */
@@ -569,7 +1941,10 @@ interface SourceLink {
     sourceLinkId?: number | null;
 }
 /**
- * Available chart types - matching old groupedCharts implementation
+ * Available chart types — derived from the chart capability registry.
+ *
+ * The registry (`CHART_CAPABILITIES`) is the single source of truth.
+ * Adding a new chart means adding a manifest entry, not editing this array.
  */
 declare const CHART_TYPES: ChartTypeConfig[];
 /**
@@ -666,6 +2041,54 @@ declare class ManageItemService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<ManageItemService>;
 }
 
+declare class DatasourcePanelComponent {
+    readonly item: _angular_core.InputSignal<DashboardChartItem | null>;
+    readonly serviceConfigChange: _angular_core.OutputEmitterRef<Partial<ServiceConfig>>;
+    readonly openAdvanced: _angular_core.OutputEmitterRef<void>;
+    readonly config: _angular_core.Signal<ItemConfig | null>;
+    readonly chartTypeConfig: _angular_core.Signal<ChartTypeConfig | null>;
+    readonly summary: _angular_core.Signal<{
+        chartType: string;
+        sourceStatus: string;
+        sourceIcon: string;
+        sourceLabel: string;
+        fieldsStatus: "missing" | "ok";
+        fieldsIcon: string;
+        fieldsLabel: string;
+        missing: string[];
+    }>;
+    onServiceConfigChange(patch: Partial<ServiceConfig>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DatasourcePanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DatasourcePanelComponent, "mt-datasource-panel", never, { "item": { "alias": "item"; "required": true; "isSignal": true; }; }, { "serviceConfigChange": "serviceConfigChange"; "openAdvanced": "openAdvanced"; }, never, never, true, never>;
+}
+
+declare class SchemaControlRendererComponent {
+    readonly schema: _angular_core.InputSignal<ControlSchema>;
+    readonly persisted: _angular_core.InputSignal<_masterteam_dashboard_builder.ItemConfig | null>;
+    readonly capability: _angular_core.InputSignal<ChartCapability | null>;
+    readonly scope: _angular_core.InputSignal<ControlSectionScope>;
+    readonly patch: _angular_core.OutputEmitterRef<ControlPatch>;
+    readonly jsonError: _angular_core.Signal<Record<string, string>>;
+    readonly visibleSections: _angular_core.Signal<ControlSection[]>;
+    visibleFields(section: ControlSection): ControlField[];
+    readValue(field: ControlField): unknown;
+    readString(field: ControlField): string;
+    readBoolean(field: ControlField): boolean;
+    readJson(field: ControlField): string;
+    readPalette(field: ControlField): string;
+    optionsFor(field: ControlField): _masterteam_dashboard_builder.ControlOption[];
+    multiselectChecked(field: ControlField, value: unknown): boolean;
+    emit(field: ControlField, value: unknown): void;
+    emitNumber(field: ControlField, raw: unknown): void;
+    emitMultiselect(field: ControlField, optionValue: unknown, checked: boolean): void;
+    emitPalette(field: ControlField, raw: string): void;
+    emitJson(field: ControlField, raw: string): void;
+    private emitShadowPreset;
+    private fieldShouldRender;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SchemaControlRendererComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SchemaControlRendererComponent, "mt-schema-control-renderer", never, { "schema": { "alias": "schema"; "required": true; "isSignal": true; }; "persisted": { "alias": "persisted"; "required": true; "isSignal": true; }; "capability": { "alias": "capability"; "required": false; "isSignal": true; }; "scope": { "alias": "scope"; "required": false; "isSignal": true; }; }, { "patch": "patch"; }, never, never, true, never>;
+}
+
 /**
  * Dashboard Builder Component
  *
@@ -780,7 +2203,59 @@ declare class DashboardBuilder implements OnInit, OnDestroy {
     pasteSelectedCharts(): void;
     private pasteItemInChart;
     addItem(): void;
-    editItem(chart: DashboardChartItem, parentItem?: DashboardChartItem): void;
+    /**
+     * Pass 7 — primary data-config entry point. The center "Configure
+     * datasource" CTA on an unconfigured chart and the kebab's "Configure
+     * datasource" entry both route here. ManageItem (the full advanced
+     * editor) is the **only** datasource flow.
+     */
+    configureChart(chart: DashboardChartItem): void;
+    /**
+     * Pass 7 — open the dedicated chart filter drawer. Sole owner of
+     * chart-level filter editing (replaces the duplicated filter editing
+     * surfaces inside the deactivated popover/wizard).
+     */
+    openItemFilterDrawer(chart: DashboardChartItem): void;
+    /**
+     * Apply a partial chart-config update produced by one of the dedicated
+     * drawers (filters, style, manage-item). Updates the chart in place,
+     * re-renders it, and emits to the host.
+     */
+    private applyChartConfigUpdate;
+    /**
+     * Pass 7 — sole card-menu action handler. The kebab emits a single
+     * `ItemCardMenuAction` and the host routes each id to one obvious owner:
+     *
+     *   - configure-datasource → ManageItem (advanced editor)
+     *   - style                → ChartSettingsDrawer
+     *   - filters              → ChartFilterDrawer
+     *   - edit-title           → focuses the inline title input on the card
+     *   - duplicate / delete   → host helpers
+     *   - dialog-*             → linked-dialog actions (only present when
+     *                            the chart is configured to open a dialog)
+     *
+     * No surface duplicates another. There is no other code path that opens
+     * a separate popover/wizard.
+     */
+    onItemCardMenuAction(chart: DashboardChartItem, action: ItemCardMenuAction): void;
+    /**
+     * Pass 7 — focus the inline title input for the given chart. Both the
+     * unconfigured chart surface (`dashboard-item.html` overlay) and the
+     * configured chart heading (`card-content.component.html`) carry
+     * `data-dashboard-action="edit-title"`; the gridster-item carries the
+     * matching `data-chart-id`. The kebab's "Edit title" entry routes here
+     * without opening any other surface.
+     */
+    private requestEditTitle;
+    /** Whether the chart has a linked dialog (Manage menu shows dialog entries). */
+    hasLinkedDialog(chart: DashboardChartItem): boolean;
+    /** Whether the chart can have a linked dialog added (chart cards that aren't dialogs themselves). */
+    canLinkDialog(chart: DashboardChartItem): boolean;
+    /** Duplicate a chart on the canvas. */
+    duplicateChart(chart: DashboardChartItem): void;
+    /** Whether the kebab menu should appear on this chart card. */
+    showContextToolbar(chart: DashboardChartItem): boolean;
+    editItem(chart: DashboardChartItem, parentItem?: DashboardChartItem, defaultTab?: 'general' | 'dataSource' | 'actions'): void;
     deleteItem(chart: DashboardChartItem): void;
     private removeChartLocally;
     newChart(value: any): void;
@@ -793,11 +2268,29 @@ declare class DashboardBuilder implements OnInit, OnDestroy {
     toggleWidgetPalette(): void;
     /** Close widget palette drawer */
     closeWidgetPalette(): void;
-    /** Add widget based on type configuration */
+    /**
+     * Pass 7 — add widget based on type configuration.
+     *
+     * Layout widgets (header/topbar/group) land on the canvas directly because
+     * they don't have a datasource. For chart-type widgets we restore the
+     * old, simpler behavior: open `ManageItem` (the advanced editor) first
+     * and only place a chart on the canvas after the user saves. Cancel
+     * never lands a half-configured chart.
+     */
     addWidgetByType(widgetType: ChartTypeConfig): void;
+    /**
+     * Pass-2: persist an inline title edit committed from the chart card.
+     * Updates `clientConfig.title.{en,ar}` for the matched chart.
+     */
+    onChartTitleEdited(chart: DashboardChartItem, newTitle: string): void;
     /** Add layout widget directly (header, topbar, group) */
     private addLayoutWidget;
-    /** Open manage-item drawer for a specific widget type */
+    /**
+     * Open the ManageItem advanced editor with the widget type pre-selected.
+     * The chart only lands on the canvas if the user clicks Save — Cancel
+     * leaves the canvas untouched (Pass 7 reset of the Pass-2 "drop empty
+     * card on canvas" pattern that produced unconfigured cards).
+     */
     private openManageItemForType;
     /** Create new chart with specified size */
     private newChartWithSize;
@@ -851,7 +2344,9 @@ declare class DashboardViewer implements OnInit, OnDestroy {
     private dashboardService;
     private storeService;
     private itemStoreService;
+    private limitedHttp;
     private route;
+    private get repeaterUrlConfig();
     /** Whether to wrap content in mt-page component */
     readonly isPage: _angular_core.InputSignal<boolean>;
     /** Page title when isPage is true */
@@ -1270,6 +2765,7 @@ declare class DashboardItem implements OnInit, OnDestroy {
     private readonly chartDataService;
     private readonly actionService;
     private readonly transloco;
+    private readonly guidance;
     private subscription;
     private readonly destroy$;
     /** Chart configuration */
@@ -1290,8 +2786,24 @@ declare class DashboardItem implements OnInit, OnDestroy {
     readonly extraFilters: _angular_core.InputSignal<Record<string, any>>;
     /** Skip global route/query filters for this item */
     readonly ignoreQueryFilter: _angular_core.InputSignal<boolean>;
+    /**
+     * Whether the host is rendering in builder mode (not viewer). Enables
+     * the inline title edit + Configure datasource CTA on the chart card.
+     */
+    readonly builderMode: _angular_core.InputSignal<boolean>;
     /** Emitted when an action is triggered (useful for dialog communication) */
     readonly actionTriggered: _angular_core.OutputEmitterRef<any>;
+    /**
+     * Emitted when the empty card asks the host to open the manage-item drawer
+     * for this widget. Host (dashboard-builder) should open manage-item with
+     * `chart` set to this item.
+     */
+    readonly configureRequested: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Emitted when the user inline-edits the chart title. Host (dashboard-builder)
+     * should persist the new title into clientConfig.title.{en,ar}.
+     */
+    readonly titleEdited: _angular_core.OutputEmitterRef<string>;
     /** Dashboard ID - derived from config or chartTypeId */
     readonly dashboardId: _angular_core.Signal<string | null>;
     /** Component name */
@@ -1306,6 +2818,39 @@ declare class DashboardItem implements OnInit, OnDestroy {
     readonly languageCode: _angular_core.Signal<string>;
     /** Chart type from service config */
     readonly chartType: _angular_core.Signal<string | undefined>;
+    /** Whether the inline title input should be shown in the needs-config overlay. */
+    readonly titleEditableEnabled: _angular_core.Signal<boolean>;
+    /** Current title in active language (or English / Arabic fallback). */
+    readonly currentTitle: _angular_core.Signal<string>;
+    /**
+     * Whether the chart needs configuration to render (no selection, no
+     * customApi, and not a layout/special-endpoint widget). Displayed at the
+     * host level so every renderer (chart, table, statistic, properties,
+     * entity-preview, etc.) benefits from a single, consistent CTA.
+     */
+    readonly needsConfiguration: _angular_core.Signal<boolean>;
+    /**
+     * Pass-6 guidance state. Surfaces the right title/hint/CTA for the
+     * user's current situation (unconfigured, missingDatasource, missingFields,
+     * invalidFilters, noData, dataError, configured).
+     */
+    readonly guidanceState: _angular_core.Signal<ItemGuidanceState>;
+    /** Stable string fed to `data-dashboard-ux-state` for verification. */
+    readonly guidanceUxState: _angular_core.Signal<string>;
+    /** Translated heading shown above the center CTA. */
+    readonly guidanceTitle: _angular_core.Signal<string>;
+    /** Translated hint shown below the heading. */
+    readonly guidanceHint: _angular_core.Signal<string>;
+    /** Icon for the center surface. */
+    readonly guidanceIcon: _angular_core.Signal<string>;
+    /** Translated label for the primary CTA. */
+    readonly guidancePrimaryLabel: _angular_core.Signal<string>;
+    /** Icon for the primary CTA. */
+    readonly guidancePrimaryIcon: _angular_core.Signal<string>;
+    /** Translated label for the secondary CTA, or empty string. */
+    readonly guidanceSecondaryLabel: _angular_core.Signal<string>;
+    /** Icon for the secondary CTA. */
+    readonly guidanceSecondaryIcon: _angular_core.Signal<string>;
     /** Loading state - SINGLE SOURCE OF TRUTH */
     readonly isLoading: _angular_core.WritableSignal<boolean>;
     /** Has error */
@@ -1347,12 +2892,30 @@ declare class DashboardItem implements OnInit, OnDestroy {
      * Handle actions from child components (charts, tables, etc.)
      * This is the main entry point for action handling.
      */
+    /**
+     * Handle the Configure datasource CTA on an empty chart card.
+     * Forwarded to the host so the manage-item drawer can be opened on the
+     * Data Source tab for this widget.
+     */
+    onConfigureRequested(): void;
+    /**
+     * Pass-6: handle the secondary CTA. Currently routed to the same
+     * `configureRequested` event so the host can open the legacy advanced
+     * editor or refresh, depending on the guidance state's secondary action.
+     */
+    onSecondaryRequested(): void;
+    /**
+     * Handle inline title edit committed by the chart card. Forwarded to host
+     * to persist into clientConfig.title.{en,ar}. We also patch the local
+     * store so the change shows immediately.
+     */
+    onTitleChange(newTitle: string): void;
     doActions(eventData: any, eventType: string): void;
     private buildRequestFilters;
     private buildParentFilter;
     private mergeRequestFilters;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<DashboardItem, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DashboardItem, "mt-dashboard-item", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "chartTypeId": { "alias": "chartTypeId"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "pageName": { "alias": "pageName"; "required": false; "isSignal": true; }; "inGroup": { "alias": "inGroup"; "required": false; "isSignal": true; }; "isDialog": { "alias": "isDialog"; "required": false; "isSignal": true; }; "queryParams": { "alias": "queryParams"; "required": false; "isSignal": true; }; "extraFilters": { "alias": "extraFilters"; "required": false; "isSignal": true; }; "ignoreQueryFilter": { "alias": "ignoreQueryFilter"; "required": false; "isSignal": true; }; }, { "actionTriggered": "actionTriggered"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DashboardItem, "mt-dashboard-item", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "chartTypeId": { "alias": "chartTypeId"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "pageName": { "alias": "pageName"; "required": false; "isSignal": true; }; "inGroup": { "alias": "inGroup"; "required": false; "isSignal": true; }; "isDialog": { "alias": "isDialog"; "required": false; "isSignal": true; }; "queryParams": { "alias": "queryParams"; "required": false; "isSignal": true; }; "extraFilters": { "alias": "extraFilters"; "required": false; "isSignal": true; }; "ignoreQueryFilter": { "alias": "ignoreQueryFilter"; "required": false; "isSignal": true; }; "builderMode": { "alias": "builderMode"; "required": false; "isSignal": true; }; }, { "actionTriggered": "actionTriggered"; "configureRequested": "configureRequested"; "titleEdited": "titleEdited"; }, never, never, true, never>;
 }
 
 interface HeaderCardConfig$1 {
@@ -1406,6 +2969,13 @@ declare class CardContentComponent {
     readonly styleConfig: _angular_core.InputSignal<CardBorderStyleConfig | null>;
     /** Card style configuration (background, shadows, border radius) */
     readonly cardStyleConfig: _angular_core.InputSignal<CardStyleConfig$1 | null>;
+    /**
+     * Pass-3: density preset hint (`compact` | `comfortable` | `presentation`).
+     * Read from `clientConfig.configAsType.density` and applied as a
+     * `data-density` attribute that CSS can target. Old configs without this
+     * key fall back to `comfortable` via the absence-of-attribute baseline.
+     */
+    readonly density: _angular_core.InputSignal<string | null>;
     /** Whether to show header */
     readonly showHeader: _angular_core.InputSignal<boolean>;
     /** Whether header is clickable */
@@ -1416,6 +2986,20 @@ declare class CardContentComponent {
     readonly isChart: _angular_core.InputSignal<boolean>;
     /** Header click event */
     readonly headerClick: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Whether the title is click-to-edit (builder mode only). Falsy by
+     * default so view-mode cards keep their existing behavior.
+     */
+    readonly titleEditable: _angular_core.InputSignal<boolean>;
+    /** Emitted when the user commits an edited title (Enter / blur). */
+    readonly titleChange: _angular_core.OutputEmitterRef<string>;
+    /** Internal: whether the title input is currently being edited. */
+    readonly editingTitle: _angular_core.WritableSignal<boolean>;
+    /** Internal: draft text while editing. */
+    readonly titleDraft: _angular_core.WritableSignal<string>;
+    /** Reference to the inline title input (if visible). */
+    readonly titleInputRef: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    constructor();
     /** Computed show header */
     readonly showHeaderState: _angular_core.Signal<boolean>;
     /** Computed header clickable */
@@ -1427,8 +3011,20 @@ declare class CardContentComponent {
     /** Computed border radius style */
     readonly borderRadiusStyle: _angular_core.Signal<string>;
     onHeaderClick(): void;
+    /**
+     * Begin inline title editing. Only triggered when `titleEditable` is true.
+     * The title text is replaced by an `<input>` until Enter/blur (commit) or
+     * Escape (cancel).
+     */
+    onStartEditTitle(event: Event): void;
+    /** Commit the in-progress title edit. */
+    onCommitTitle(): void;
+    /** Cancel the in-progress title edit. */
+    onCancelTitle(): void;
+    /** Track input changes during edit. */
+    onTitleInput(value: string): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardContentComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CardContentComponent, "mt-card-content", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "inGroup": { "alias": "inGroup"; "required": false; "isSignal": true; }; "headerConfig": { "alias": "headerConfig"; "required": false; "isSignal": true; }; "styleConfig": { "alias": "styleConfig"; "required": false; "isSignal": true; }; "cardStyleConfig": { "alias": "cardStyleConfig"; "required": false; "isSignal": true; }; "showHeader": { "alias": "showHeader"; "required": false; "isSignal": true; }; "headerClickable": { "alias": "headerClickable"; "required": false; "isSignal": true; }; "isNoTopEnd": { "alias": "isNoTopEnd"; "required": false; "isSignal": true; }; "isChart": { "alias": "isChart"; "required": false; "isSignal": true; }; }, { "headerClick": "headerClick"; }, never, ["[topEnd]", "[body]", "[footer]"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CardContentComponent, "mt-card-content", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "inGroup": { "alias": "inGroup"; "required": false; "isSignal": true; }; "headerConfig": { "alias": "headerConfig"; "required": false; "isSignal": true; }; "styleConfig": { "alias": "styleConfig"; "required": false; "isSignal": true; }; "cardStyleConfig": { "alias": "cardStyleConfig"; "required": false; "isSignal": true; }; "density": { "alias": "density"; "required": false; "isSignal": true; }; "showHeader": { "alias": "showHeader"; "required": false; "isSignal": true; }; "headerClickable": { "alias": "headerClickable"; "required": false; "isSignal": true; }; "isNoTopEnd": { "alias": "isNoTopEnd"; "required": false; "isSignal": true; }; "isChart": { "alias": "isChart"; "required": false; "isSignal": true; }; "titleEditable": { "alias": "titleEditable"; "required": false; "isSignal": true; }; }, { "headerClick": "headerClick"; "titleChange": "titleChange"; }, never, ["[topEnd]", "[body]", "[footer]"], true, never>;
 }
 
 declare class CardFilterComponent implements OnInit {
@@ -1663,6 +3259,16 @@ declare class CardInfoComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<CardInfoComponent, "mt-card-info", never, { "cardInfo": { "alias": "cardInfo"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+/**
+ * Inline view-mode the body should render with.
+ *
+ *  - 'echart'           — handler returned ECharts options.
+ *  - 'splitter'         — handler returned `{ positive, negative }`.
+ *  - 'timeline'         — handler returned `{ calendarOptions, ... }`.
+ *  - 'phaseGateStepper' — handler returned `{ steps, currentIndex }`.
+ *  - 'raw'              — fallback to ECharts (we still try to render).
+ */
+type CardViewMode = 'echart' | 'splitter' | 'timeline' | 'phaseGateStepper' | 'raw';
 declare class ChartCardComponent implements OnInit, OnDestroy {
     private readonly storeService;
     private readonly actionService;
@@ -1672,13 +3278,19 @@ declare class ChartCardComponent implements OnInit, OnDestroy {
     readonly dashboardId: _angular_core.InputSignal<string | number>;
     /** Whether card is inside a group */
     readonly inGroup: _angular_core.InputSignal<boolean>;
-    /** Config mode flag */
+    /** Config mode flag (drawer preview) */
     readonly isConfigMode: _angular_core.InputSignal<boolean>;
+    /** Whether title is click-to-edit (builder mode only). */
+    readonly titleEditable: _angular_core.InputSignal<boolean>;
     /** Action event output */
     readonly onAction: _angular_core.OutputEmitterRef<{
         type: string;
         data: any;
     }>;
+    /** Emitted when the empty card "Configure datasource" CTA is clicked. */
+    readonly onConfigure: _angular_core.OutputEmitterRef<void>;
+    /** Emitted when title is edited inline. */
+    readonly onTitleChange: _angular_core.OutputEmitterRef<string>;
     /** Configuration item */
     readonly configurationItem: _angular_core.WritableSignal<ItemConfig | null>;
     /** Handled chart data */
@@ -1704,12 +3316,41 @@ declare class ChartCardComponent implements OnInit, OnDestroy {
     readonly showStaticFilters: _angular_core.Signal<boolean | undefined>;
     /** Show dynamic filters */
     readonly showDynamicFilters: _angular_core.Signal<boolean>;
+    /**
+     * The visual mode the body should use, derived from componentName.
+     * Falls back to 'echart' when not a special widget.
+     */
+    readonly componentViewMode: _angular_core.Signal<CardViewMode>;
+    /**
+     * Whether the chart needs configuration (no selection, no customApi, and
+     * not a layout/special-endpoint widget).
+     */
+    readonly needsConfiguration: _angular_core.Signal<boolean>;
+    /** Whether the user can act on the Configure CTA (builder mode). */
+    readonly canConfigure: _angular_core.Signal<boolean>;
+    readonly hasSplitterData: _angular_core.Signal<boolean>;
+    readonly splitterOrientation: _angular_core.Signal<"vertical" | "horizontal">;
+    readonly splitterGap: _angular_core.Signal<number>;
+    readonly hasTimelineData: _angular_core.Signal<boolean>;
+    readonly timelineEvents: _angular_core.Signal<any[]>;
+    readonly timelineResources: _angular_core.Signal<any[]>;
+    readonly timelineLabels: _angular_core.Signal<any[]>;
+    readonly timelineEventsLimited: _angular_core.Signal<any[]>;
+    readonly timelineEventsTruncated: _angular_core.Signal<boolean>;
+    readonly hasPhaseGateData: _angular_core.Signal<boolean>;
+    readonly phaseGateSteps: _angular_core.Signal<any[]>;
+    readonly phaseGateCurrentIndex: _angular_core.Signal<number>;
+    readonly phaseGateShowLabels: _angular_core.Signal<boolean>;
+    readonly phaseGateCompact: _angular_core.Signal<boolean>;
     ngOnInit(): void;
     ngOnDestroy(): void;
     onChartClick(event: any): void;
     onHeaderClick(): void;
+    onConfigureClick(event: Event): void;
+    /** Format an ISO date for inline timeline display. */
+    formatDate(value: any): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChartCardComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChartCardComponent, "mt-chart-card", never, { "dashboardId": { "alias": "dashboardId"; "required": true; "isSignal": true; }; "inGroup": { "alias": "inGroup"; "required": false; "isSignal": true; }; "isConfigMode": { "alias": "isConfigMode"; "required": false; "isSignal": true; }; }, { "onAction": "onAction"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChartCardComponent, "mt-chart-card", never, { "dashboardId": { "alias": "dashboardId"; "required": true; "isSignal": true; }; "inGroup": { "alias": "inGroup"; "required": false; "isSignal": true; }; "isConfigMode": { "alias": "isConfigMode"; "required": false; "isSignal": true; }; "titleEditable": { "alias": "titleEditable"; "required": false; "isSignal": true; }; }, { "onAction": "onAction"; "onConfigure": "onConfigure"; "onTitleChange": "onTitleChange"; }, never, never, true, never>;
 }
 
 type EChartsType = any;
@@ -2577,6 +4218,10 @@ declare class TableViewHandler {
      * Returns data directly (not wrapped in { type, data, config })
      */
     handleTableView(dataResponse: any, config: ItemConfig): any;
+    /**
+     * Legacy alias used by some old saved configs.
+     */
+    handleTableChart(dataResponse: any, config: ItemConfig): any;
     /**
      * Handle projects by execution period (special case)
      * Returns eCharts bar chart config directly (like old HandleProjectsByExecutionPeriod)
@@ -2839,6 +4484,25 @@ declare class RingGaugeChartHandler {
      * Returns ECharts option directly (same as old RingGaugeChartService)
      */
     handleRingGaugeChart(dataResponse: any, config: ItemConfig): any;
+    /**
+     * handleRingGaugeChartWithFormula
+     *
+     * Wraps the BarV2Chart formula response (series-based) into the same
+     * `{ values: [object] }` shape that handleRingGaugeChart consumes, then
+     * delegates rendering. Old FE method name is preserved so legacy configs
+     * continue to resolve.
+     *
+     * Old configs sometimes used numeric/index-based property keys; we map
+     * them to the named ring-gauge keys when configAsType.ringGaugeConfig is
+     * available and otherwise fall back to whatever the response provides.
+     */
+    handleRingGaugeChartWithFormula(dataResponse: any, config: ItemConfig): any;
+    /**
+     * Convert BarV2Chart formula response into the ring-gauge `{ values: [obj] }`
+     * shape expected by handleRingGaugeChart. Tolerant of multiple legacy
+     * shapes.
+     */
+    private adaptFormulaResponseToRingGauge;
     /**
      * Helper method to return empty chart options
      */
@@ -2867,6 +4531,19 @@ declare class SPlusChartHandler {
      * Matches old SplusChartsService.handleGaugeChartSplus return format
      */
     handleGaugeChartSplus(data: any, config: ItemConfig): any;
+    /**
+     * handlePerformanceGaugeCardSplus
+     *
+     * Old SplusChartsService method. Extracts the current numeric value from
+     * the chart response, resolves the configured component statuses, sorts
+     * them, and chooses the active status based on the value's range. The
+     * shape returned is what the `performanceGaugeCard` renderer consumes:
+     *   { performance: number, status: any, statuses: any[] }
+     *
+     * Compatible with old configs that stored componentId either as a numeric
+     * id, `{type}_{id}` format inside selection.moduleId, or via selector.
+     */
+    handlePerformanceGaugeCardSplus(data: any, config: ItemConfig): any;
     /**
      * Handle S+ Component Cards Chart - returns transformed array directly
      * Matches old SplusChartsService.handleComponentsCardsChart return format
@@ -2946,7 +4623,12 @@ declare class PhaseGateStepperHandler {
     private readonly storeService;
     /**
      * handlePhaseGateStepperCard - matches functionName from CHART_TYPES
-     * Returns data directly matching old PhaseGateStepperService format
+     * Returns data directly matching old PhaseGateStepperService format.
+     *
+     * Tolerates BE responses that arrive as: an array, an object with `phases`,
+     * an object with `phaseGates`, or an object with `data`. Always returns
+     * `{ phases, checkList, currentIndex, noData }` so the chart-card
+     * phase-gate view-mode can render safely without further branching.
      */
     handlePhaseGateStepperCard(data: any, _configurationItem: any): any;
     /**
@@ -3408,9 +5090,22 @@ declare class DashboardBuilderService {
      */
     linkChart(request: LinkChartRequest): Observable<ApiResponse<void>>;
     /**
-     * Bulk link charts to a report (creates or updates links)
-     * @param requests Array of link requests
-     * @returns Array of link responses with id and chartComponentId
+     * Bulk link charts to a report.
+     *
+     * Backend contract (Docs/DASHBOARD_BUILDER_API.md and ReportService.cs)
+     * does not expose a `/charts/link/bulk` route. Old FE and the documented
+     * surface only ship `POST /reports/charts/link` (single create-or-update).
+     *
+     * Strategy:
+     *   1. Issue one POST per request to the documented single-link endpoint.
+     *   2. Aggregate the responses into the same response shape consumers
+     *      expect (`BulkLinkChartResponse[]`), preserving order.
+     *   3. Surface partial failures as null entries so the caller can still
+     *      patch the successful charts back to the grid (mirrors old behavior
+     *      where save was non-fatal per chart).
+     *
+     * If a host backend ever exposes a real bulk route, swap the inner call
+     * for a single POST and keep the same outer signature.
      */
     linkChartsBulk(requests: BulkLinkChartRequest[]): Observable<ApiResponse<BulkLinkChartResponse[]>>;
     /**
@@ -3628,8 +5323,13 @@ declare class ManageFilterOnPage implements OnInit {
     ngOnInit(): void;
     /** Handle filter configuration changes */
     onFiltersChange(filters: FilterField[]): void;
-    /** Load level logs for a specific schema level (placeholder for API call) */
-    onLoadLevelLogs(schemaLevelId: number): void;
+    /**
+     * Hook for hosts that want to feed level-log values into the filter
+     * dialog. The host listens to `(loadLevelLogs)` (when consumers wire it)
+     * and pushes into `levelLogs`. Left intentionally unbound here so the
+     * library does not depend on a specific level-logs endpoint shape.
+     */
+    onLoadLevelLogs(_schemaLevelId: number): void;
     /** Save and close the dialog */
     save(): void;
     /** Cancel and close the dialog */
@@ -3730,6 +5430,7 @@ declare class DefaultControlUi implements ControlValueAccessor {
 
 declare class ChartSettingsDrawer {
     private dialogRef;
+    private transloco;
     private drawerConfig;
     readonly modal: ModalService;
     /** The chart item signal - reactive for proper change detection */
@@ -3747,12 +5448,44 @@ declare class ChartSettingsDrawer {
         value: string;
         icon: string;
     }[]>;
+    /**
+     * Pass-2: JSON draft for the Advanced Override tab. Initialized lazily
+     * from the current clientConfig and held as a string so users can edit
+     * freely. We validate before applying.
+     */
+    readonly advancedJsonDraft: _angular_core.WritableSignal<string>;
+    /** Last known parse error (empty when JSON is currently valid). */
+    readonly advancedJsonError: _angular_core.WritableSignal<string>;
+    /** Whether the JSON draft has been initialized. */
+    private advancedJsonInitialized;
+    /** Initialize draft from current item if not yet seeded. */
+    initAdvancedJsonIfNeeded(): void;
+    /** Track edits to the JSON draft. */
+    onAdvancedJsonChange(value: string): void;
+    /**
+     * Validate and DEEP-merge the Advanced JSON into the current
+     * clientConfig. Never persists invalid JSON. Nested objects are merged
+     * key-by-key so a partial patch like `{ configAsType: { icon: 'x' } }`
+     * does not wipe out other `configAsType` keys. Arrays and primitives in
+     * the draft replace the existing values.
+     */
+    applyAdvancedJson(): void;
     /** Resolve ChartTypeConfig from CHART_TYPES based on item config */
     readonly resolvedChartType: _angular_core.Signal<ChartTypeConfig | null>;
     /** ItemConfig computed for DisplaySettings input */
     readonly itemConfig: _angular_core.Signal<ItemConfig | null>;
     /** Determine the type of manage UI to show */
     readonly manageType: _angular_core.Signal<QuickManageType>;
+    /**
+     * Pass-4: capability + control schema used by the schema-driven default
+     * branch. Resolved from the working item via the manifest, with the same
+     * legacy-alias resolution the rest of the popover/drawer uses.
+     */
+    readonly capability: _angular_core.Signal<_masterteam_dashboard_builder.ChartCapability | null>;
+    /** Schema for the current chart type (or fallback). */
+    readonly schemaForItem: _angular_core.Signal<_masterteam_dashboard_builder.ControlSchema>;
+    /** Apply a single schema-driven control patch to the working item. */
+    onSchemaPatch(patch: ControlPatch): void;
     /** Default control config mapped from item config */
     readonly defaultControlConfig: _angular_core.Signal<DefaultControlConfig>;
     /** Pie chart config - note: typo "Overried" matches old implementation */
@@ -3976,8 +5709,14 @@ declare class DisplaySettings {
      * Each chart type maps to comma-separated list of visible fields
      */
     private readonly chartTypeFieldsMap;
-    /** Computed fields to show based on chart type */
-    readonly fieldsToShow: _angular_core.Signal<string>;
+    /**
+     * Pass-4: visible field list is now derived from the manifest's
+     * `display.fields` via `buildDisplayFieldPredicate` (with the legacy
+     * hand-curated map preserved as a union fallback). Adding a chart in the
+     * manifest now automatically gives it the correct field surface — the
+     * giant in-component map no longer needs editing per chart type.
+     */
+    private readonly fieldPredicate;
     /** Check if a field should be shown */
     shouldShowField(fieldName: string): boolean;
     shouldShowPropertiesViewSettings(): boolean;
@@ -4510,6 +6249,7 @@ declare class ManageItem implements OnInit {
     private _dialogConfig;
     readonly modal: ModalService;
     ref: ModalRef<any> | null;
+    private transloco;
     /** Input data from drawer - supports both input() and dialog data */
     readonly data: _angular_core.InputSignal<{
         chart?: DashboardChartItem;
@@ -4522,11 +6262,17 @@ declare class ManageItem implements OnInit {
         };
         services?: readonly string[] | null;
         informativeContext?: DashboardInformativeContext | null;
+        /**
+         * Pass-2: which tab to open the drawer on. Configure CTA on the empty
+         * chart card sends `dataSource` so the user lands directly on the
+         * datasource flow rather than on General.
+         */
+        defaultTab?: "general" | "dataSource" | "actions";
     } | null>;
     /** Whether chart type is pre-selected (hides type selection) */
     readonly hasPreselectedType: _angular_core.Signal<boolean>;
     /** Tab options with translation keys */
-    readonly tabOptions: _angular_core.WritableSignal<{
+    readonly tabOptions: _angular_core.Signal<{
         label: string;
         value: string;
         icon: string;
@@ -4766,6 +6512,7 @@ type QueryComponentType = 'general' | 'table' | 'timeline' | 'timelineMultiLevel
  */
 declare class DataSourceSettings {
     private dashboardService;
+    private transloco;
     /** Current configuration */
     readonly config: _angular_core.InputSignal<ItemConfig | null>;
     /** Selected chart type */
@@ -4792,21 +6539,40 @@ declare class DataSourceSettings {
      * Built from selections with their loaded module info
      */
     readonly selectionModules: _angular_core.Signal<SelectionModule[]>;
-    /** Query component type based on chart type and component name */
+    /**
+     * Query component type — driven by the chart capability registry.
+     *
+     * Resolution order:
+     *  1. Manifest by chart id (most precise).
+     *  2. Manifest by (serviceType, componentName, functionName) tuple,
+     *     including legacy aliases.
+     *  3. Default to 'general' (matches old FE behavior for unknown charts).
+     */
     readonly queryComponentType: _angular_core.Signal<QueryComponentType>;
     /** Loading states */
     readonly loadingProperties: _angular_core.WritableSignal<boolean>;
+    /**
+     * Pass-2: progressive-disclosure mode. `simple` shows only required fields
+     * + the most-common fields per chart type. `advanced` reveals every field
+     * (including custom API, source links, and per-property advanced options).
+     * No fields are removed in either mode — only their visibility is gated.
+     */
+    readonly disclosureMode: _angular_core.WritableSignal<"advanced" | "simple">;
+    /** Whether the user is in advanced mode. */
+    readonly isAdvanced: _angular_core.Signal<boolean>;
+    /** Toggle simple/advanced. */
+    onDisclosureToggle(advanced: boolean): void;
     /** Tab state: 'selection' or 'customApi' */
     readonly activeTab: _angular_core.WritableSignal<"selection" | "customApi">;
     /** Selection mode inside the selection tab */
-    readonly selectionMode: _angular_core.WritableSignal<"context" | "advanced">;
+    readonly selectionMode: _angular_core.WritableSignal<"advanced" | "context">;
     readonly contextTargetSelector: _angular_core.WritableSignal<string | null>;
     readonly contextTargetApplyToken: _angular_core.WritableSignal<number>;
     /** Tab options for display */
-    readonly tabOptions: {
+    readonly tabOptions: _angular_core.Signal<{
         id: string;
         label: string;
-    }[];
+    }[]>;
     /** Custom API configuration */
     readonly customApi: _angular_core.WritableSignal<CustomApi | null>;
     /** Internal selections state */
@@ -4836,6 +6602,13 @@ declare class DataSourceSettings {
     private readonly moduleKeysSignature;
     /** Track last loaded module signature to prevent duplicate requests */
     private lastLoadedSignature;
+    /**
+     * Pass-2 guard: track whether we've already initialized the activeTab from
+     * a saved config. The Custom API ↔ Selection auto-switch should only run
+     * on the first config load, not on every subsequent edit; otherwise the
+     * user gets yanked off the Custom API tab when editing a sibling field.
+     */
+    private tabInitializedFromConfig;
     constructor();
     /**
      * Load properties for all selections using bulk API
@@ -4904,9 +6677,59 @@ declare class DataSourceSettings {
      */
     onGroupByMultipleChange(values: string[]): void;
     /**
-     * Handle repeater dashboard selection
+     * Handle repeater dashboard selection.
+     *
+     * Canonical persisted shape: `serviceConfig.query = { dashboardRepeated, selectedProperties }`.
+     * The legacy root `repeaterDashboardId` is no longer written.
+     */
+    onRepeaterDashboardChange(dashboardId: number | null): void;
+    /**
+     * Selected properties for repeater (also used for timeline multi-level
+     * extra columns and phaseGate input fallback).
+     */
+    onRepeaterSelectedPropertiesChange(values: string[]): void;
+    /**
+     * Phase Gate query: a single levelId field (static or dynamic placeholder).
+     */
+    onPhaseGateLevelIdChange(value: string): void;
+    /**
+     * Timeline Multi-Level: list of per-level configurations + extra
+     * selected properties. Auto-fills selectedProperties.
+     */
+    onTimelineMultiLevelChange(query: any): void;
+    /**
+     * Add an empty timeline-multi-level entry.
+     */
+    addTimelineLevel(): void;
+    /**
+     * Remove a level by index.
+     */
+    removeTimelineLevel(index: number): void;
+    /**
+     * Update a single field on a single level.
+     */
+    updateTimelineLevelField(index: number, field: string, value: any): void;
+    /**
+     * Reads the current repeater query — convenience accessor for the template.
+     */
+    readonly repeaterSelectedProperties: _angular_core.Signal<string[]>;
+    /**
+     * Reads the phaseGate levelId — convenience accessor for the template.
+     */
+    readonly phaseGateLevelId: _angular_core.Signal<string>;
+    /**
+     * Reads the current timeline-multi-level query for the template.
+     */
+    readonly timelineLevels: _angular_core.Signal<any[]>;
+    readonly timeFrameOptions: {
+        value: string;
+        label: string;
+    }[];
+    /**
+     * Loads available dashboards for the repeater dropdown by hitting the
+     * configured reports list. Uses Dashboard type only.
      */
-    onRepeaterDashboardChange(dashboardId: number): void;
+    private loadAvailableDashboardsForRepeater;
     /**
      * Handle isNormalized change
      */
@@ -5096,5 +6919,5 @@ declare class GetChartActionsPipe implements PipeTransform {
  */
 declare function cloneDeep<T>(obj: T): T;
 
-export { ActionsSettings, BarChartHandler, BarControlUi, CHART_TYPES, CardContentComponent, CardFilterComponent, CardInfoComponent, ChartCardComponent, ChartDataService, ChartSettingsDrawer, ChartViewer, ComparisonChartHandler, DashboardBuilder, DashboardBuilderService, DashboardItem, DashboardItemStoreService, DashboardList, DashboardStoreService, DashboardViewer, DataSourceSettings, DefaultControlUi, DisplaySettings, DynamicFiltersComponent, DynamicFiltersConfig, EChartComponent, PropertiesCardComponent as EntitiesPreviewCardComponent, EntityInfoComponent, EntityPreviewCardComponent, FilterByGroupPipe, GaugeChartHandler, GeneralSettings, GetChartActionsPipe, HTTPMethod, HeaderCardComponent, LevelCardHandler, LineChartHandler, ListStatisticCardComponent, ManageBreadcrumb, ManageFilterOnPage, ManageItem, ManageItemService, ManagePages, MapChartHandler, OverviewCardHandler, PhaseGateStepperHandler, PieChartHandler, PieControlUi, PropertiesCardComponent, RingGaugeChartHandler, SPlusChartHandler, SkeletonCardComponent, SnapshotHandler, SplitterChartHandler, StackBarChartHandler, StackBarControlUi, StaticFiltersComponent, StatisticCardComponent, TableCardComponent, TableViewHandler, TimelineHandler, TopbarCardComponent, addCommasToNumber, axisFormatters, cloneDeep, createAxisFormatter, createTooltipFormatter, dynamicReorder, dynamicTextReplace, formatCurrency, formatDate, formatNumber, formatPercentage, formatValue, formatWordsUnderBar, formatXAxis, generalConfiguration, getColorFromConditions, getLocalizedTitle, getNestedData, groupDatesByYearAndMonth, handleFilterForCard, handleFilterForSnapshot, handleFiltersForCustom, isMobilePlatform, sortChartData, sortDataTableView, switchAllKeysSmall, switchAllKeysToLower };
-export type { ActionConfig, ApiResponse, BarChartData, BreadcrumbItem, BulkLinkChartRequest, BulkLinkChartResponse, BulkPropertiesRequest, BulkPropertiesResponse, BulkPropertiesResponseItem, BulkPropertiesResponseItemDto, BulkPropertyRequestItem, CardBorderStyleConfig, CardInfoConfig$1 as CardInfoConfig, CardStyleConfig$1 as CardStyleConfig, CatalogPropertyDto, ChartActionEvent, ChartActionsContext, ChartData, ChartDataHandled, ChartLabel, ChartLinkConfiguration, ChartTypeConfig, ClientConfig, ComponentType, CustomApi, DashboardBuilderData, DashboardChartItem, DashboardChartTemplate, DashboardDialogItem, DashboardInformativeContext, DashboardItemStore, DashboardListEvent, DashboardPage, DashboardTargetOption, DashboardTargetPathStep, DashboardTargetTemplateFilter, DashboardTargetTemplateSelection, DashboardTargetTemplateSourceLink, DashboardTargetsContextInfo, DashboardTargetsResponse, DisplayConfig, EChartSeriesItem, ExcelSheet, FilterConfig, FilterOption, FormatXAxisConfig$1 as FormatXAxisConfig, GroupedModuleOption, HandleAction, HeaderCardConfig$1 as HeaderCardConfig, IModule, IModuleType, IProperty, IPropertyWithGroup, ISelection, ItemConfig, LevelCardData, LevelCardProperty, LinkChartRequest, LocalizedName, ModuleItem, ModuleSelectOption, ModuleType, ModuleValue, ModulesTreeRequest, ModulesTreeResponse, PhaseGateProperty, PhaseGateStep, PieChartData, PropertiesResponse, PropertyItem, PropertyItemOption, PropertyItemsResponse, QuickManageType, Report, ReportChartLink, ReportDashboardConfig, ReportExcelConfig, ReportType, ReportUrl, RequestType, SelectionFilter, ServiceConfig, ServiceItem, SourceLink, StaticFilterConfig, StaticFilterItem, StatisticCardData, StyleConfig, TableColumn$1 as TableColumn, TableViewData, TimelineData, TimelineItem, UnlinkChartRequest };
+export { ActionsSettings, BarChartHandler, BarControlUi, CHART_CAPABILITIES, CHART_TYPES, CONFIG_DOMAINS, CardContentComponent, CardFilterComponent, CardInfoComponent, ChartCardComponent, ChartDataService, ChartFilterDrawer, ChartSettingsDrawer, ChartViewer, ComparisonChartHandler, DashboardBuilder, DashboardBuilderService, DashboardItem, DashboardItemStoreService, DashboardList, DashboardStoreService, DashboardViewer, DataSourceSettings, DatasourcePanelComponent, DefaultControlUi, DisplaySettings, DynamicFiltersComponent, DynamicFiltersConfig, EChartComponent, PropertiesCardComponent as EntitiesPreviewCardComponent, EntityInfoComponent, EntityPreviewCardComponent, FilterBuilderComponent, FilterByGroupPipe, FilterChipsBarComponent, GaugeChartHandler, GeneralSettings, GetChartActionsPipe, GuidedConfigDialogComponent, HTTPMethod, HeaderCardComponent, ITEM_GUIDANCE_REGISTRY, ItemCardMenuComponent, ItemConfigPopoverComponent, ItemContextToolbarComponent, ItemGuidanceService, LevelCardHandler, LineChartHandler, ListStatisticCardComponent, ManageBreadcrumb, ManageFilterOnPage, ManageItem, ManageItemService, ManagePages, MapChartHandler, OverviewCardHandler, POPOVER_TABS, POPOVER_TAB_SPECS, PhaseGateStepperHandler, PieChartHandler, PieControlUi, PropertiesCardComponent, RingGaugeChartHandler, SPlusChartHandler, STYLE_PRESETS, SchemaControlRendererComponent, SkeletonCardComponent, SnapshotHandler, SplitterChartHandler, StackBarChartHandler, StackBarControlUi, StaticFiltersComponent, StatisticCardComponent, TableCardComponent, TableViewHandler, TimelineHandler, TopbarCardComponent, addCommasToNumber, applyBehaviorToPersisted, applyControlPatchToPersisted, applyControlPatchesToPersisted, applyFilterChipsToPersisted, applyLabelLegendFormatToPersisted, applyLayoutToPersisted, applyStyleToPersisted, applyTitleToPersisted, axisFormatters, behaviorToUi, bindingKey, buildAssembly, buildDisplayFieldPredicate, cloneDeep, createAxisFormatter, createTooltipFormatter, datasourceToUi, deepMerge, describeGuidance, domainsForCapability, dynamicReorder, dynamicTextReplace, fieldsToUi, filtersToUi, findDomain, findPreset, flattenSchema, formatCurrency, formatDate, formatForEditor, formatNumber, formatPercentage, formatValue, formatWordsUnderBar, formatXAxis, generalConfiguration, getBinding, getCapabilityById, getColorFromConditions, getControlSchema, getFallbackControlSchema, getLocalizedTitle, getNestedData, groupDatesByYearAndMonth, groupIssuesByDomain, handleFilterForCard, handleFilterForSnapshot, handleFiltersForCustom, hasBlockingIssues, isMobilePlatform, labelLegendFormatToUi, layoutToUi, listBindings, listBindingsForChart, listControlSchemaIds, listControlSchemas, moduleIdFromSelector, normalizeBeforeRequest, normalizeBeforeSave, normalizeChartTypeForRequest, normalizeFilterOperation, normalizeFilters, normalizeOnLoad, parseAdvancedJson, persistedToUi, presetsForCapability, readBoundValue, readByPath, resolveCapability, resolveDisplayFields, selectorFromLegacy, setByPath, sortChartData, sortDataTableView, styleToUi, switchAllKeysSmall, switchAllKeysToLower, titleToUi, toBackendChartType, toBackendSourceLink, validate };
+export type { ActionConfig, ApiResponse, BackendChartType, BarChartData, BehaviorUi, BindingScope, BreadcrumbItem, BulkLinkChartRequest, BulkLinkChartResponse, BulkPropertiesRequest, BulkPropertiesResponse, BulkPropertiesResponseItem, BulkPropertiesResponseItemDto, BulkPropertyRequestItem, CardBorderStyleConfig, CardInfoConfig$1 as CardInfoConfig, CardStyleConfig$1 as CardStyleConfig, CatalogPropertyDto, ChartActionEvent, ChartActionsContext, ChartCapability, ChartCapabilityLegacyAliases, RequestType$1 as ChartCapabilityRequestType, ChartData, ChartDataHandled, ChartDomainSupport, ChartLabel, ChartLinkConfiguration, ChartTypeConfig, ClientConfig, ComponentType, ConfigDomainKey, ConfigDomainSpec, ConfigLookupShape, ConfigViewAssembly, ControlBinding, ControlBindingIndex, ControlBindingValueAdapter, ControlDomain, ControlField, ControlFieldType, ControlOption, ControlPatch, ControlSchema, ControlSection, ControlSectionScope, ControlVisiblePredicate, CustomApi, DashboardBuilderData, DashboardChartItem, DashboardChartTemplate, DashboardDialogItem, DashboardInformativeContext, DashboardItemStore, DashboardListEvent, DashboardPage, DashboardTargetOption, DashboardTargetPathStep, DashboardTargetTemplateFilter, DashboardTargetTemplateSelection, DashboardTargetTemplateSourceLink, DashboardTargetsContextInfo, DashboardTargetsResponse, DatasourceUi, DisplayConfig, DisplayField, DisplayFieldQuery, DisplaySchema, EChartSeriesItem, ExcelSheet, FieldAssignment, FieldsUi, FilterChip, FilterConfig, FilterOperator, FilterOption, FilterScope, FilterSource, FiltersUi, FlattenedControl, FormatXAxisConfig$1 as FormatXAxisConfig, GroupedModuleOption, GuidanceInput, GuidedConfigDialogData, GuidedConfigDialogResult, GuidedStep, HandleAction, HeaderCardConfig$1 as HeaderCardConfig, IModule, IModuleType, IProperty, IPropertyWithGroup, ISelection, ItemCardMenuAction, ItemConfig, ItemConfigPopoverData, ItemConfigPopoverResult, ItemContextAction, ItemGuidanceAction, ItemGuidanceDescriptor, ItemGuidanceSeverity, ItemGuidanceState, LabelLegendFormatUi, LayoutUi, LevelCardData, LevelCardProperty, LinkChartRequest, LocalizedName, ModuleItem, ModuleSelectOption, ModuleType, ModuleValue, ModulesTreeRequest, ModulesTreeResponse, ParseResult, PersistedItemConfig, PhaseGateProperty, PhaseGateStep, PieChartData, PopoverTab, PopoverTabSpec, Product, PropertiesResponse, PropertyItem, PropertyItemOption, PropertyItemsResponse, QueryEditorKind, QueryField, QuerySchema, QuickManageType, RendererKey, Report, ReportChartLink, ReportDashboardConfig, ReportExcelConfig, ReportType, ReportUrl, RequestType, RuntimeItemConfig, SelectionFilter, ServiceConfig, ServiceItem, SourceLink, StaticFilterConfig, StaticFilterItem, StatisticCardData, StyleConfig, StylePreset, StylePresetKey, StyleUi, TableColumn$1 as TableColumn, TableViewData, TimelineData, TimelineItem, TitleUi, UiItemConfig, UnlinkChartRequest, ValidateOptions, ValidationIssue, ValidationSeverity };