@praxisui/charts 3.0.0-beta.0 → 3.0.0-beta.10

package/index.d.ts

@@ -1,11 +1,11 @@
 import * as _angular_core from '@angular/core';
 import { InjectionToken, Provider } from '@angular/core';
 import * as _praxisui_core from '@praxisui/core';
-import { PraxisTextValue, WidgetDefinition, WidgetShellConfig, GridItemLayout, WidgetInstance, GridWidgetInstance, ComponentMetadataRegistry, ApiUrlConfig, WidgetPageDefinition, GridPageDefinition, ComponentDocMeta } from '@praxisui/core';
+import { PraxisTextValue, WidgetDefinition, WidgetShellConfig, WidgetInstance, ComponentMetadataRegistry, ApiUrlConfig, WidgetPageDefinition, SettingsValueProvider, PraxisI18nDictionary, PraxisI18nConfig, PraxisI18nMessageDescriptor, ComponentDocMeta } from '@praxisui/core';
 import * as _praxisui_charts from '@praxisui/charts';
 import { EChartsCoreOption } from 'echarts';
 import { HttpClient } from '@angular/common/http';
-import { Observable } from 'rxjs';
+import { Observable, BehaviorSubject } from 'rxjs';
 
 type PraxisChartAxisType = 'category' | 'value' | 'time';
 type PraxisChartAxisPosition = 'top' | 'bottom' | 'left' | 'right';
@@ -39,11 +39,13 @@ type PraxisChartStatsMetricOperation = 'COUNT' | 'SUM' | 'AVG' | 'MIN' | 'MAX';
 interface PraxisChartStatsMetricRequest {
     operation: PraxisChartStatsMetricOperation;
     field?: string;
+    alias?: string;
 }
 interface PraxisChartGroupByStatsRequest {
     filter: Record<string, unknown>;
     field: string;
     metric: PraxisChartStatsMetricRequest;
+    metrics?: PraxisChartStatsMetricRequest[];
     limit?: number;
     orderBy?: 'KEY_ASC' | 'KEY_DESC' | 'VALUE_ASC' | 'VALUE_DESC';
 }
@@ -52,6 +54,7 @@ interface PraxisChartTimeSeriesStatsRequest {
     field: string;
     granularity: Uppercase<PraxisChartStatsGranularity>;
     metric: PraxisChartStatsMetricRequest;
+    metrics?: PraxisChartStatsMetricRequest[];
     from?: string;
     to?: string;
     fillGaps?: boolean;
@@ -96,6 +99,16 @@ interface PraxisChartRemoteDataSource {
 }
 type PraxisChartDataSource = PraxisChartLocalDataSource | PraxisChartRemoteDataSource;
 
+interface PraxisChartQueryContext {
+    filters?: Record<string, unknown> | null;
+    sort?: string[] | null;
+    limit?: number | null;
+    page?: {
+        index?: number | null;
+        size?: number | null;
+    } | null;
+    meta?: Record<string, unknown> | null;
+}
 type PraxisChartLoadState = 'idle' | 'loading' | 'ready' | 'empty' | 'error';
 interface PraxisChartInteractionConfig {
     pointClick?: boolean;
@@ -116,9 +129,10 @@ interface PraxisChartQueryRequestEvent {
         kind: 'remote';
     }>;
     query?: PraxisChartQueryConfig;
+    queryContext?: PraxisChartQueryContext | null;
 }
 
-type PraxisChartType = 'bar' | 'line' | 'pie' | 'donut' | 'area' | 'stacked-bar';
+type PraxisChartType = 'bar' | 'combo' | 'horizontal-bar' | 'line' | 'pie' | 'donut' | 'area' | 'stacked-bar' | 'stacked-area' | 'scatter';
 type PraxisChartAggregation = 'sum' | 'count' | 'avg' | 'min' | 'max';
 interface PraxisChartMetricConfig {
     field?: string;
@@ -133,6 +147,7 @@ interface PraxisChartSeriesConfig {
     id: string;
     name?: string;
     type?: PraxisChartType;
+    axis?: 'primary' | 'secondary';
     categoryField?: string;
     metric?: PraxisChartMetricConfig;
     color?: string;
@@ -158,6 +173,11 @@ interface PraxisChartThemeConfig {
     tooltip?: PraxisChartTooltipConfig;
 }
 
+type PraxisChartMotionPreset = 'subtle' | 'standard' | 'expressive';
+interface PraxisChartMotionConfig {
+    enabled?: boolean;
+    preset?: PraxisChartMotionPreset;
+}
 interface PraxisChartEmptyStateConfig {
     title?: PraxisTextValue;
     description?: PraxisTextValue;
@@ -176,107 +196,26 @@ interface PraxisChartStateConfig {
 interface PraxisChartConfig {
     id?: string;
     type: PraxisChartType;
+    orientation?: 'vertical' | 'horizontal';
     title?: PraxisTextValue;
     subtitle?: PraxisTextValue;
     height?: number | string;
     axes?: {
         x?: PraxisChartAxisConfig;
         y?: PraxisChartAxisConfig;
+        ySecondary?: PraxisChartAxisConfig;
     };
     series: PraxisChartSeriesConfig[];
     dataSource?: PraxisChartDataSource;
     interactions?: PraxisChartInteractionConfig;
     theme?: PraxisChartThemeConfig;
+    motion?: PraxisChartMotionConfig;
     emptyState?: PraxisChartEmptyStateConfig;
     state?: PraxisChartStateConfig;
     preferredLoadState?: Extract<PraxisChartLoadState, 'idle' | 'loading' | 'ready' | 'empty' | 'error'>;
 }
 
-declare class PraxisChartComponent {
-    readonly config: _angular_core.InputSignal<PraxisChartConfig>;
-    readonly data: _angular_core.InputSignal<PraxisChartDataRow[] | null>;
-    readonly pointClick: _angular_core.OutputEmitterRef<PraxisChartPointEvent>;
-    readonly queryRequest: _angular_core.OutputEmitterRef<PraxisChartQueryRequestEvent>;
-    readonly loadStateChange: _angular_core.OutputEmitterRef<PraxisChartLoadState>;
-    private readonly chartHost;
-    private readonly engine;
-    private readonly transformer;
-    private readonly statsApi;
-    private readonly i18n;
-    private readonly destroyRef;
-    private readonly resizeObserver;
-    private readonly currentLoadState;
-    private readonly remoteResolvedData;
-    private readonly remoteRuntimeState;
-    private readonly remoteTechnicalError;
-    private previousRemoteSignature;
-    readonly resolvedData: _angular_core.Signal<PraxisChartDataRow[]>;
-    readonly resolvedHeight: _angular_core.Signal<string>;
-    readonly renderConfig: _angular_core.Signal<PraxisChartConfig>;
-    readonly loadingLabel: _angular_core.Signal<string>;
-    readonly emptyTitle: _angular_core.Signal<string>;
-    readonly emptyDescription: _angular_core.Signal<string>;
-    readonly errorTitle: _angular_core.Signal<string>;
-    readonly errorDescription: _angular_core.Signal<string>;
-    readonly loadState: _angular_core.Signal<PraxisChartLoadState>;
-    constructor();
-    private ensureResizeObserver;
-    private buildRemoteSignature;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PraxisChartComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PraxisChartComponent, "praxis-chart", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; }, { "pointClick": "pointClick"; "queryRequest": "queryRequest"; "loadStateChange": "loadStateChange"; }, never, never, true, never>;
-}
-
-declare class PraxisChartDrilldownPanelComponent {
-    readonly title: _angular_core.InputSignal<string>;
-    readonly selection: _angular_core.InputSignal<PraxisChartPointEvent | null>;
-    readonly activeCategory: _angular_core.Signal<string | null>;
-    readonly detailData: _angular_core.Signal<_praxisui_charts.PraxisChartDataRow[]>;
-    readonly detailChartConfig: _angular_core.Signal<{
-        id: string;
-        type: "donut";
-        title: {
-            text: string;
-        };
-        subtitle: {
-            text: string;
-        };
-        height: number;
-        series: {
-            id: string;
-            categoryField: string;
-            metric: {
-                field: string;
-                aggregation: "sum";
-            };
-            labels: {
-                visible: boolean;
-            };
-        }[];
-        emptyState: {
-            title: {
-                text: string;
-            };
-            description: {
-                text: string;
-            };
-        };
-        theme: {
-            palette: string[];
-        };
-    }>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PraxisChartDrilldownPanelComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PraxisChartDrilldownPanelComponent, "praxis-chart-drilldown-panel", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
-declare class PraxisChartStateProbeComponent {
-    readonly title: _angular_core.InputSignal<string>;
-    readonly value: _angular_core.InputSignal<unknown>;
-    readonly serializedValue: _angular_core.Signal<string>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PraxisChartStateProbeComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PraxisChartStateProbeComponent, "praxis-chart-state-probe", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
-type PraxisXUiChartKind = 'bar' | 'line' | 'pie' | 'donut' | 'area' | 'stacked-bar';
+type PraxisXUiChartKind = 'bar' | 'combo' | 'horizontal-bar' | 'line' | 'pie' | 'donut' | 'area' | 'stacked-bar' | 'stacked-area' | 'scatter';
 type PraxisXUiChartPreset = 'kpi-trend' | 'comparison' | 'distribution' | 'ranking' | 'composition' | 'hierarchical-drill-down';
 type PraxisXUiChartTextValue = string | {
     key: string;
@@ -300,13 +239,16 @@ interface PraxisXUiChartSort {
 interface PraxisXUiChartDimension {
     field: string;
     label?: PraxisXUiChartTextValue;
-    role?: 'category' | 'series' | 'segment' | 'time';
+    role?: 'category' | 'series' | 'segment' | 'time' | 'value';
     format?: string;
 }
 interface PraxisXUiChartMetric {
     field: string;
     label?: PraxisXUiChartTextValue;
     aggregation?: PraxisXUiChartAggregation;
+    seriesKind?: 'bar' | 'line' | 'area';
+    axis?: 'primary' | 'secondary';
+    color?: string;
     format?: string;
 }
 interface PraxisXUiChartAggregationConfig {
@@ -343,6 +285,11 @@ interface PraxisXUiChartTheme {
     palette?: string | string[];
     variant?: 'default' | 'compact' | 'executive';
 }
+type PraxisXUiChartMotionPreset = 'subtle' | 'standard' | 'expressive';
+interface PraxisXUiChartMotion {
+    enabled?: boolean;
+    preset?: PraxisXUiChartMotionPreset;
+}
 interface PraxisXUiChartStateDescriptor {
     title?: PraxisXUiChartTextValue;
     description?: PraxisXUiChartTextValue;
@@ -368,6 +315,7 @@ interface PraxisXUiChartContract {
     kind: PraxisXUiChartKind;
     preset?: PraxisXUiChartPreset;
     chartId?: string;
+    orientation?: 'vertical' | 'horizontal';
     title?: PraxisXUiChartTextValue;
     subtitle?: PraxisXUiChartTextValue;
     height?: number | string;
@@ -385,11 +333,159 @@ interface PraxisXUiChartContract {
     theme?: PraxisXUiChartTheme;
     state?: PraxisXUiChartState;
     events?: PraxisXUiChartEvents;
+    motion?: PraxisXUiChartMotion;
 }
 interface PraxisXUiChartRuntimeHints {
     preferredLoadState?: Extract<PraxisChartLoadState, 'idle' | 'loading' | 'ready' | 'empty' | 'error'>;
 }
 
+interface ChartEditorResourceOption {
+    id: string;
+    label: string;
+    path: string;
+    description?: string;
+}
+interface ChartEditorFieldOption {
+    field: string;
+    label?: string;
+    type?: 'string' | 'number' | 'date' | 'boolean' | 'enum';
+    aggregable?: boolean;
+    filterable?: boolean;
+    roles?: Array<'dimension' | 'metric' | 'time'>;
+}
+interface ChartEditorTargetOption {
+    id: string;
+    label: string;
+    kind?: 'widget' | 'route' | 'panel' | 'event';
+}
+
+type PraxisDataQueryContextBridge = {
+    filters?: Record<string, unknown> | null;
+    sort?: string[] | null;
+    limit?: number | null;
+    page?: {
+        index?: number | null;
+        size?: number | null;
+    } | null;
+    meta?: Record<string, unknown> | null;
+};
+declare class PraxisChartComponent {
+    readonly config: _angular_core.InputSignal<PraxisChartConfig>;
+    readonly data: _angular_core.InputSignal<PraxisChartDataRow[] | null>;
+    readonly chartDocument: _angular_core.InputSignal<PraxisXUiChartContract | null>;
+    readonly filterCriteria: _angular_core.InputSignal<Record<string, unknown> | null>;
+    readonly queryContext: _angular_core.InputSignal<PraxisDataQueryContextBridge | null>;
+    readonly enableCustomization: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly availableResources: _angular_core.InputSignal<readonly ChartEditorResourceOption[]>;
+    readonly availableFields: _angular_core.InputSignal<readonly ChartEditorFieldOption[]>;
+    readonly availableTargets: _angular_core.InputSignal<readonly ChartEditorTargetOption[]>;
+    readonly pointClick: _angular_core.OutputEmitterRef<PraxisChartPointEvent>;
+    readonly queryRequest: _angular_core.OutputEmitterRef<PraxisChartQueryRequestEvent>;
+    readonly loadStateChange: _angular_core.OutputEmitterRef<PraxisChartLoadState>;
+    readonly chartDocumentApplied: _angular_core.OutputEmitterRef<PraxisXUiChartContract>;
+    readonly chartDocumentSaved: _angular_core.OutputEmitterRef<PraxisXUiChartContract>;
+    private readonly chartHost;
+    private readonly hostElement;
+    private readonly engine;
+    private readonly transformer;
+    private readonly canonicalMapper;
+    private readonly statsApi;
+    private readonly i18n;
+    private readonly settingsPanel;
+    private readonly destroyRef;
+    private readonly resizeObserver;
+    private readonly shellObserver;
+    private readonly currentLoadState;
+    private readonly remoteResolvedData;
+    private readonly remoteRuntimeState;
+    private readonly remoteTechnicalError;
+    private readonly runtimeChartDocument;
+    private readonly mappedRuntimeConfig;
+    private readonly chartDocumentMappingError;
+    private readonly fillContainerHeight;
+    private previousRemoteSignature;
+    private previousDocumentSignature;
+    private editorSessionSubscriptions;
+    readonly effectiveConfig: _angular_core.Signal<PraxisChartConfig>;
+    readonly resolvedData: _angular_core.Signal<PraxisChartDataRow[]>;
+    readonly resolvedHeight: _angular_core.Signal<string>;
+    readonly renderConfig: _angular_core.Signal<PraxisChartConfig>;
+    readonly loadingLabel: _angular_core.Signal<string>;
+    readonly emptyTitle: _angular_core.Signal<string>;
+    readonly emptyDescription: _angular_core.Signal<string>;
+    readonly errorTitle: _angular_core.Signal<string>;
+    readonly errorDescription: _angular_core.Signal<string>;
+    readonly editChartLabel: _angular_core.Signal<string>;
+    readonly loadState: _angular_core.Signal<PraxisChartLoadState>;
+    constructor();
+    canOpenConfigEditor(): boolean;
+    openConfigEditor(): Promise<void>;
+    private ensureResizeObserver;
+    private buildRemoteSignature;
+    private clearEditorSessionSubscriptions;
+    private observeShellSizingContext;
+    private scheduleResizeAfterShellModeChange;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PraxisChartComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PraxisChartComponent, "praxis-chart", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "chartDocument": { "alias": "chartDocument"; "required": false; "isSignal": true; }; "filterCriteria": { "alias": "filterCriteria"; "required": false; "isSignal": true; }; "queryContext": { "alias": "queryContext"; "required": false; "isSignal": true; }; "enableCustomization": { "alias": "enableCustomization"; "required": false; "isSignal": true; }; "availableResources": { "alias": "availableResources"; "required": false; "isSignal": true; }; "availableFields": { "alias": "availableFields"; "required": false; "isSignal": true; }; "availableTargets": { "alias": "availableTargets"; "required": false; "isSignal": true; }; }, { "pointClick": "pointClick"; "queryRequest": "queryRequest"; "loadStateChange": "loadStateChange"; "chartDocumentApplied": "chartDocumentApplied"; "chartDocumentSaved": "chartDocumentSaved"; }, never, never, true, never>;
+}
+
+declare class PraxisChartDrilldownPanelComponent {
+    readonly title: _angular_core.InputSignal<string>;
+    readonly selection: _angular_core.InputSignal<PraxisChartPointEvent | null>;
+    readonly activeCategory: _angular_core.Signal<string | null>;
+    readonly detailData: _angular_core.Signal<_praxisui_charts.PraxisChartDataRow[]>;
+    readonly detailChartConfig: _angular_core.Signal<{
+        id: string;
+        type: "donut";
+        title: {
+            text: string;
+        };
+        subtitle: {
+            text: string;
+        };
+        height: number;
+        series: {
+            id: string;
+            categoryField: string;
+            metric: {
+                field: string;
+                aggregation: "sum";
+            };
+            labels: {
+                visible: boolean;
+            };
+        }[];
+        emptyState: {
+            title: {
+                text: string;
+            };
+            description: {
+                text: string;
+            };
+        };
+        theme: {
+            palette: string[];
+        };
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PraxisChartDrilldownPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PraxisChartDrilldownPanelComponent, "praxis-chart-drilldown-panel", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class PraxisChartStateProbeComponent {
+    readonly title: _angular_core.InputSignal<string>;
+    readonly value: _angular_core.InputSignal<unknown>;
+    readonly serializedValue: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PraxisChartStateProbeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PraxisChartStateProbeComponent, "praxis-chart-state-probe", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface PraxisChartCanvasItem {
+    col: number;
+    row: number;
+    colSpan: number;
+    rowSpan: number;
+    zIndex?: number;
+}
 interface PraxisChartWidgetSchema {
     kind?: 'x-ui.chart';
     componentId?: 'praxis-chart' | 'chart';
@@ -400,7 +496,7 @@ interface PraxisChartWidgetSchema {
     outputs?: WidgetDefinition['outputs'];
     bindingOrder?: string[];
     shell?: WidgetShellConfig;
-    layout?: GridItemLayout;
+    canvasItem?: PraxisChartCanvasItem;
 }
 interface PraxisChartWidgetResolution {
     componentId: 'praxis-chart';
@@ -408,11 +504,10 @@ interface PraxisChartWidgetResolution {
     definition: WidgetDefinition;
     shell?: WidgetShellConfig;
     className?: string;
-    layout?: GridItemLayout;
+    canvasItem?: PraxisChartCanvasItem;
 }
 type PraxisChartWidgetLike = PraxisXUiChartContract | PraxisChartWidgetSchema;
 type PraxisChartWidgetInstance = WidgetInstance;
-type PraxisChartGridWidgetInstance = GridWidgetInstance;
 
 interface PraxisChartSchemaMeta {
     schemaId: string;
@@ -426,7 +521,7 @@ interface PraxisChartBackendWidgetPayload {
     kind?: 'x-ui.chart';
     key?: string;
     className?: string;
-    layout?: GridItemLayout;
+    canvasItem?: PraxisChartCanvasItem;
     shell?: WidgetShellConfig;
     outputs?: PraxisChartWidgetSchema['outputs'];
     bindingOrder?: string[];
@@ -456,15 +551,57 @@ declare const PRAXIS_CHART_ENGINE: InjectionToken<PraxisChartEngineAdapter>;
 
 declare function providePraxisCharts(): Provider[];
 
+declare class ChartContractNormalizerService {
+    normalize(input: PraxisXUiChartContract): PraxisXUiChartContract;
+    private normalizeMotion;
+    private normalizeKindSpecificFields;
+    private normalizeOperationSpecificFields;
+    private normalizeSourceSpecificFields;
+    private isDistribution;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChartContractNormalizerService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ChartContractNormalizerService>;
+}
+
+type ChartContractIssueSeverity = 'error' | 'warning';
+interface ChartContractValidationIssue {
+    severity: ChartContractIssueSeverity;
+    code: string;
+    field: string;
+    message: string;
+}
+interface ChartContractValidationResult {
+    valid: boolean;
+    issues: ChartContractValidationIssue[];
+}
+
+declare class ChartContractValidationService {
+    validate(document: PraxisXUiChartContract): ChartContractValidationResult;
+    private validateSource;
+    private validateTheme;
+    private validateMetrics;
+    private validateKinds;
+    private validateEvents;
+    private validateEventAction;
+    private error;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChartContractValidationService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ChartContractValidationService>;
+}
+
 declare class PraxisChartCanonicalContractMapperService {
+    private readonly normalizer;
+    private readonly validator;
+    constructor(normalizer?: ChartContractNormalizerService, validator?: ChartContractValidationService);
     toPraxisChartConfig(contract: PraxisXUiChartContract): PraxisChartConfig;
-    private assertSupportedContract;
     private buildAxes;
     private buildSeries;
     private buildDataSource;
     private buildQuery;
     private buildInteractions;
     private buildTheme;
+    private buildMotion;
+    private resolveOrientation;
+    private resolveSeriesType;
+    private shouldSmoothSeries;
     private mapTextValue;
     private toLabel;
     private resolveToggle;
@@ -474,6 +611,7 @@ declare class PraxisChartCanonicalContractMapperService {
     private buildStatsRequest;
     private resolveStatsField;
     private buildStatsMetricRequest;
+    private buildStatsMetricRequests;
     private mapStatsOrderBy;
     private mapStatsOrderByToBackend;
     private mapStatsGranularityToBackend;
@@ -486,13 +624,14 @@ declare class PraxisChartCanonicalContractMapperService {
 interface PraxisChartCartesianSeries {
     id: string;
     name: string;
-    type: 'bar' | 'line';
+    type: 'bar' | 'line' | 'scatter';
+    axis?: 'primary' | 'secondary';
     stack?: string;
     smooth?: boolean;
     area?: boolean;
     color?: string;
     labelsVisible?: boolean;
-    points: Array<number | null>;
+    points: Array<number | null | [number | string, number | null]>;
 }
 interface PraxisChartPieSlice {
     id: string;
@@ -501,7 +640,7 @@ interface PraxisChartPieSlice {
     color?: string;
 }
 interface PraxisChartTransformedData {
-    mode: 'cartesian' | 'pie';
+    mode: 'cartesian' | 'pie' | 'scatter';
     categories: string[];
     series: PraxisChartCartesianSeries[];
     slices: PraxisChartPieSlice[];
@@ -512,9 +651,13 @@ declare class PraxisChartDataTransformerService {
     private transformCartesian;
     private transformPie;
     private buildCartesianSeries;
+    private resolveCartesianSeriesType;
+    private isAreaLikeSeries;
+    private transformScatter;
     private aggregate;
     private extractMetricValue;
     private normalizeCategory;
+    private extractScatterXValue;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<PraxisChartDataTransformerService, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<PraxisChartDataTransformerService>;
 }
@@ -524,6 +667,8 @@ declare class PraxisChartOptionBuilderService {
     constructor(transformer: PraxisChartDataTransformerService);
     build(config: PraxisChartConfig, rows: PraxisChartDataRow[]): EChartsCoreOption;
     private resolveText;
+    private buildGrid;
+    private buildCartesianYAxis;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<PraxisChartOptionBuilderService, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<PraxisChartOptionBuilderService>;
 }
@@ -543,16 +688,12 @@ declare class PraxisChartSchemaMapperService {
     constructor(metadataRegistration: PraxisChartMetadataRegistrationService, canonicalContractMapper: PraxisChartCanonicalContractMapperService);
     resolve(input: PraxisChartWidgetLike, defaults?: {
         key?: string;
-        layout?: GridItemLayout;
+        canvasItem?: PraxisChartCanvasItem;
     }): PraxisChartWidgetResolution;
     toWidgetDefinition(input: PraxisChartWidgetLike): WidgetDefinition;
     toWidgetInstance(input: PraxisChartWidgetLike, defaults?: {
         key?: string;
     }): WidgetInstance;
-    toGridWidgetInstance(input: PraxisChartWidgetLike, defaults: {
-        key?: string;
-        layout: GridItemLayout;
-    }): GridWidgetInstance;
     private normalize;
     private isWidgetSchema;
     private isCanonicalChartContract;
@@ -568,7 +709,7 @@ declare class PraxisChartBackendPayloadAdapterService {
     constructor(chartSchemaMapper: PraxisChartSchemaMapperService, canonicalContractMapper: PraxisChartCanonicalContractMapperService);
     toChartConfig(payload: PraxisChartBackendPayload): PraxisChartConfig;
     toWidgetInstance(payload: PraxisChartBackendPayload): WidgetInstance;
-    toGridWidgetInstance(payload: PraxisChartBackendPayload): GridWidgetInstance;
+    toCanvasItem(payload: PraxisChartBackendPayload, fallback?: PraxisChartCanvasItem): PraxisChartCanvasItem;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<PraxisChartBackendPayloadAdapterService, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<PraxisChartBackendPayloadAdapterService>;
 }
@@ -582,7 +723,8 @@ declare class PraxisChartStatsApiService {
     private resolveBucketCategory;
     private resolveMetricValue;
     private resolveCategoryField;
-    private resolveMetricField;
+    private resolveMetricBindings;
+    private projectMetricValues;
     private buildStatsUrl;
     private buildDefaultApiBase;
     private normalizePath;
@@ -596,35 +738,299 @@ declare class PraxisChartStatsApiService {
 declare const PRAXIS_CHART_BACKEND_MOCK_BAR: PraxisChartBackendPayload;
 declare const PRAXIS_CHART_BACKEND_MOCK_TIMESERIES: PraxisChartBackendPayload;
 declare const PRAXIS_CHART_BACKEND_MOCK_DONUT: PraxisChartBackendPayload;
+declare const PRAXIS_CHART_BACKEND_MOCK_HORIZONTAL_BAR: PraxisChartBackendPayload;
+declare const PRAXIS_CHART_BACKEND_MOCK_STACKED_AREA: PraxisChartBackendPayload;
+declare const PRAXIS_CHART_BACKEND_MOCK_MULTI_METRIC_BAR: PraxisChartBackendPayload;
+declare const PRAXIS_CHART_BACKEND_MOCK_SCATTER: PraxisChartBackendPayload;
+declare const PRAXIS_CHART_BACKEND_MOCK_COMBO: PraxisChartBackendPayload;
 
 declare const PRAXIS_CHART_DRILLDOWN_DATA_BY_MONTH: Record<string, PraxisChartDataRow[]>;
 
+type CanvasWidgetPageDefinition = WidgetPageDefinition & {
+    canvas?: {
+        mode: 'grid';
+        columns: number;
+        rowUnit?: string;
+        gap?: string;
+        items: Record<string, PraxisChartCanvasItem>;
+    };
+};
 declare function buildPraxisChartMockWidgetPage(adapter: PraxisChartBackendPayloadAdapterService): WidgetPageDefinition;
-declare function buildPraxisChartMockGridPage(adapter: PraxisChartBackendPayloadAdapterService): GridPageDefinition;
+declare function buildPraxisChartMockCanvasPage(adapter: PraxisChartBackendPayloadAdapterService): CanvasWidgetPageDefinition;
 declare function buildPraxisChartInteractiveWidgetPage(adapter: PraxisChartBackendPayloadAdapterService): WidgetPageDefinition;
-declare function buildPraxisChartInteractiveGridPage(adapter: PraxisChartBackendPayloadAdapterService): GridPageDefinition;
+declare function buildPraxisChartInteractiveCanvasPage(adapter: PraxisChartBackendPayloadAdapterService): CanvasWidgetPageDefinition;
 
-type ShowcaseLayoutMode = 'widget' | 'grid';
-type ShowcasePayloadMode = 'group-by' | 'timeseries' | 'distribution';
+type ShowcaseLayoutMode = 'widget' | 'canvas';
+type ShowcasePayloadMode = 'group-by' | 'timeseries' | 'distribution' | 'horizontal-bar' | 'stacked-area' | 'multi-metric-bar' | 'scatter' | 'combo';
 type ShowcaseScenarioMode = 'baseline' | 'interactive' | 'empty' | 'loading' | 'error';
 declare class PraxisChartCompositionShowcaseComponent {
+    readonly enableCustomization: _angular_core.InputSignalWithTransform<boolean, unknown>;
     protected readonly layoutMode: _angular_core.WritableSignal<ShowcaseLayoutMode>;
     protected readonly payloadMode: _angular_core.WritableSignal<ShowcasePayloadMode>;
     protected readonly scenarioMode: _angular_core.WritableSignal<ShowcaseScenarioMode>;
-    protected readonly runtimeContext: {
+    private readonly backendPayloadAdapter;
+    protected readonly runtimeContext: _angular_core.Signal<{
         tenantId: string;
         locale: string;
         environment: string;
-    };
-    private readonly backendPayloadAdapter;
+        enableCustomization: boolean;
+    }>;
     protected readonly widgetPage: _angular_core.Signal<_praxisui_core.WidgetPageDefinition>;
-    protected readonly gridPage: _angular_core.Signal<_praxisui_core.GridPageDefinition>;
-    protected readonly payloadTitle: _angular_core.Signal<"Envelope timeseries" | "Envelope distribution" | "Envelope group-by">;
+    protected readonly canvasPage: _angular_core.Signal<(_praxisui_core.WidgetPageDefinition & {
+        canvas?: {
+            mode: "grid";
+            columns: number;
+            rowUnit?: string;
+            gap?: string;
+            items: Record<string, _praxisui_charts.PraxisChartCanvasItem>;
+        };
+    }) | {
+        widgets: _praxisui_core.WidgetInstance[];
+        canvas: {
+            items: {
+                [x: string]: _praxisui_charts.PraxisChartCanvasItem;
+            };
+            mode: "grid";
+            columns: number;
+            rowUnit?: string;
+            gap?: string;
+            autoRows?: "fixed" | "content";
+            collisionPolicy?: _praxisui_core.WidgetPageCanvasCollisionPolicy;
+        };
+        connections?: _praxisui_core.WidgetConnection[];
+        composition?: _praxisui_core.WidgetPageCompositionDefinition;
+        state?: _praxisui_core.WidgetPageStateInput;
+        context?: Record<string, any>;
+        layout?: _praxisui_core.WidgetPageLayout;
+        layoutPreset?: string;
+        layoutPresetOptions?: Record<string, any>;
+        grouping?: _praxisui_core.WidgetPageGroupingDefinition[];
+        slotAssignments?: _praxisui_core.WidgetPageSlotAssignments;
+        deviceLayouts?: _praxisui_core.WidgetPageDeviceLayouts;
+        themePreset?: string;
+    }>;
+    protected readonly resolvedPage: _angular_core.Signal<_praxisui_core.WidgetPageDefinition | {
+        widgets: _praxisui_core.WidgetInstance[];
+        canvas: {
+            items: {
+                [x: string]: _praxisui_charts.PraxisChartCanvasItem;
+            };
+            mode: "grid";
+            columns: number;
+            rowUnit?: string;
+            gap?: string;
+            autoRows?: "fixed" | "content";
+            collisionPolicy?: _praxisui_core.WidgetPageCanvasCollisionPolicy;
+        };
+        connections?: _praxisui_core.WidgetConnection[];
+        composition?: _praxisui_core.WidgetPageCompositionDefinition;
+        state?: _praxisui_core.WidgetPageStateInput;
+        context?: Record<string, any>;
+        layout?: _praxisui_core.WidgetPageLayout;
+        layoutPreset?: string;
+        layoutPresetOptions?: Record<string, any>;
+        grouping?: _praxisui_core.WidgetPageGroupingDefinition[];
+        slotAssignments?: _praxisui_core.WidgetPageSlotAssignments;
+        deviceLayouts?: _praxisui_core.WidgetPageDeviceLayouts;
+        themePreset?: string;
+    }>;
+    protected readonly payloadTitle: _angular_core.Signal<"Envelope timeseries" | "Envelope distribution" | "Envelope horizontal-bar" | "Envelope stacked-area" | "Envelope multi-metric bar" | "Envelope scatter" | "Envelope combo" | "Envelope group-by">;
     protected readonly selectedPayloadJson: _angular_core.Signal<string>;
     private readonly selectedPayload;
+    private buildScenarioCanvasPage;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<PraxisChartCompositionShowcaseComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PraxisChartCompositionShowcaseComponent, "praxis-chart-composition-showcase", never, {}, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PraxisChartCompositionShowcaseComponent, "praxis-chart-composition-showcase", never, { "enableCustomization": { "alias": "enableCustomization"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface ChartEditorPreviewPayload {
+    config: PraxisChartConfig;
+    data: PraxisChartDataRow[];
+}
+declare class ChartEditorPreviewMapperService {
+    private readonly mapper;
+    constructor(mapper: PraxisChartCanonicalContractMapperService);
+    build(document: PraxisXUiChartContract): ChartEditorPreviewPayload;
+    private buildRows;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChartEditorPreviewMapperService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ChartEditorPreviewMapperService>;
+}
+
+interface ChartConfigEditorApplyEvent {
+    document: PraxisXUiChartContract;
+    issues: ChartContractValidationIssue[];
+    dirty: boolean;
+}
+interface ChartConfigEditorSaveEvent {
+    document: PraxisXUiChartContract;
+    issues: ChartContractValidationIssue[];
+    dirty: boolean;
+}
+interface ChartConfigEditorResetEvent {
+    document: PraxisXUiChartContract;
+}
+
+type ChartEditorSection = 'general' | 'data' | 'analytics' | 'appearance' | 'motion' | 'events' | 'preview';
+type ChartFeatureKey = 'legend' | 'labels' | 'tooltip';
+type ChartStateKey = 'empty' | 'loading' | 'error';
+type ChartEventKey = 'pointClick' | 'drillDown';
+declare class PraxisChartConfigEditor implements SettingsValueProvider {
+    readonly documentInput: _angular_core.InputSignal<PraxisXUiChartContract | null>;
+    readonly modeInput: _angular_core.InputSignal<"create" | "edit">;
+    readonly readonlyInput: _angular_core.InputSignal<boolean>;
+    readonly availableResourcesInput: _angular_core.InputSignal<ChartEditorResourceOption[]>;
+    readonly availableFieldsInput: _angular_core.InputSignal<ChartEditorFieldOption[]>;
+    readonly availableTargetsInput: _angular_core.InputSignal<ChartEditorTargetOption[]>;
+    readonly apply: _angular_core.OutputEmitterRef<ChartConfigEditorApplyEvent>;
+    readonly save: _angular_core.OutputEmitterRef<ChartConfigEditorSaveEvent>;
+    readonly resetChange: _angular_core.OutputEmitterRef<ChartConfigEditorResetEvent>;
+    readonly documentChange: _angular_core.OutputEmitterRef<PraxisXUiChartContract>;
+    readonly isDirty$: BehaviorSubject<boolean>;
+    readonly isValid$: BehaviorSubject<boolean>;
+    readonly isBusy$: BehaviorSubject<boolean>;
+    readonly sections: Array<{
+        id: ChartEditorSection;
+        labelKey: string;
+        fallback: string;
+    }>;
+    readonly chartKinds: PraxisXUiChartKind[];
+    readonly sourceKinds: readonly ["praxis.stats", "derived"];
+    readonly operations: PraxisXUiChartStatsOperation[];
+    readonly timeGranularities: readonly ["hour", "day", "week", "month", "quarter", "year"];
+    readonly distributionModes: PraxisXUiChartStatsDistributionMode[];
+    readonly dimensionRoles: NonNullable<PraxisXUiChartDimension['role']>[];
+    readonly metricAggregations: PraxisXUiChartAggregation[];
+    readonly metricAxes: Array<NonNullable<PraxisXUiChartMetric['axis']>>;
+    readonly metricSeriesKinds: Array<NonNullable<PraxisXUiChartMetric['seriesKind']>>;
+    readonly motionPresets: readonly ["subtle", "standard", "expressive"];
+    readonly eventActionOptions: PraxisXUiChartEventAction['action'][];
+    readonly activeSection: _angular_core.WritableSignal<ChartEditorSection>;
+    private readonly injectedData;
+    private readonly defaults;
+    private readonly normalizer;
+    private readonly validator;
+    private readonly previewMapper;
+    private readonly i18n;
+    private readonly currentDocument;
+    private readonly initialDocument;
+    private lastExternalSignature;
+    readonly normalizedDocument: _angular_core.Signal<PraxisXUiChartContract>;
+    readonly validation: _angular_core.Signal<ChartContractValidationResult>;
+    readonly issues: _angular_core.Signal<ChartContractValidationIssue[]>;
+    readonly availableResources: _angular_core.Signal<ChartEditorResourceOption[]>;
+    readonly availableFields: _angular_core.Signal<ChartEditorFieldOption[]>;
+    readonly availableTargets: _angular_core.Signal<ChartEditorTargetOption[]>;
+    readonly preview: _angular_core.Signal<ChartEditorPreviewPayload | null>;
+    constructor();
+    getSettingsValue(): PraxisXUiChartContract;
+    onSave(): PraxisXUiChartContract;
+    reset(): void;
+    applyChanges(): ChartConfigEditorApplyEvent;
+    saveChanges(): ChartConfigEditorSaveEvent;
+    setSection(section: ChartEditorSection): void;
+    setChartId(value: string): void;
+    setKind(value: PraxisXUiChartKind): void;
+    setTitle(value: string): void;
+    setSubtitle(value: string): void;
+    setHeight(value: string): void;
+    setSourceKind(value: 'praxis.stats' | 'derived'): void;
+    setResource(value: string): void;
+    setOperation(value: PraxisXUiChartStatsOperation): void;
+    setGranularity(value: typeof this.timeGranularities[number]): void;
+    setFillGaps(value: boolean): void;
+    setDistributionMode(value: PraxisXUiChartStatsDistributionMode): void;
+    setBucketSize(value: string): void;
+    setBucketCount(value: string): void;
+    addDimension(): void;
+    removeDimension(index: number): void;
+    setDimensionField(index: number, field: string): void;
+    setDimensionRole(index: number, role: NonNullable<PraxisXUiChartDimension['role']>): void;
+    addMetric(): void;
+    removeMetric(index: number): void;
+    setMetricField(index: number, field: string): void;
+    setMetricLabel(index: number, label: string): void;
+    setMetricAggregation(index: number, aggregation: PraxisXUiChartAggregation): void;
+    setMetricAxis(index: number, axis: NonNullable<PraxisXUiChartMetric['axis']>): void;
+    setMetricSeriesKind(index: number, seriesKind: NonNullable<PraxisXUiChartMetric['seriesKind']>): void;
+    setMotionEnabled(enabled: boolean): void;
+    setMotionPreset(preset: 'subtle' | 'standard' | 'expressive'): void;
+    setFeatureEnabled(feature: ChartFeatureKey, enabled: boolean): void;
+    setPalette(value: string): void;
+    setStateTitle(stateKey: ChartStateKey, value: string): void;
+    setStateDescription(stateKey: ChartStateKey, value: string): void;
+    setEventAction(eventKey: ChartEventKey, action: PraxisXUiChartEventAction['action'] | ''): void;
+    setEventTarget(eventKey: ChartEventKey, target: string): void;
+    setEventMapping(eventKey: ChartEventKey, value: string): void;
+    isReadonly(): boolean;
+    titleValue(): string;
+    subtitleValue(): string;
+    resourceValue(): string;
+    resourceOptions(): ChartEditorResourceOption[];
+    granularityValue(): typeof this.timeGranularities[number];
+    fillGapsValue(): boolean;
+    distributionModeValue(): PraxisXUiChartStatsDistributionMode;
+    bucketSizeValue(): string;
+    bucketCountValue(): string;
+    heightValue(): string;
+    featureEnabled(feature: ChartFeatureKey): boolean;
+    paletteValue(): string;
+    stateTitle(stateKey: ChartStateKey): string;
+    stateDescription(stateKey: ChartStateKey): string;
+    eventAction(eventKey: ChartEventKey): PraxisXUiChartEventAction['action'] | '';
+    eventTarget(eventKey: ChartEventKey): string;
+    targetOptions(): ChartEditorTargetOption[];
+    eventMappingText(eventKey: ChartEventKey): string;
+    dimensions(): PraxisXUiChartDimension[];
+    metrics(): PraxisXUiChartMetric[];
+    fieldOptions(role: 'dimension' | 'metric'): ChartEditorFieldOption[];
+    showMetricAxisControls(): boolean;
+    showMetricSeriesKindControls(): boolean;
+    showTimeseriesControls(): boolean;
+    showDistributionControls(): boolean;
+    showComboPanel(): boolean;
+    showPieDonutPanel(): boolean;
+    showScatterPanel(): boolean;
+    issueTrackBy(_: number, issue: ChartContractValidationIssue): string;
+    t(key: string, fallback: string): string;
+    doc(): PraxisXUiChartContract;
+    private patchStateDescriptor;
+    private patchEvent;
+    private parseMappingText;
+    private createApplyPayload;
+    private createSavePayload;
+    private patchDocument;
+    private refreshState;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PraxisChartConfigEditor, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PraxisChartConfigEditor, "praxis-chart-config-editor", never, { "documentInput": { "alias": "document"; "required": false; "isSignal": true; }; "modeInput": { "alias": "mode"; "required": false; "isSignal": true; }; "readonlyInput": { "alias": "readonly"; "required": false; "isSignal": true; }; "availableResourcesInput": { "alias": "availableResources"; "required": false; "isSignal": true; }; "availableFieldsInput": { "alias": "availableFields"; "required": false; "isSignal": true; }; "availableTargetsInput": { "alias": "availableTargets"; "required": false; "isSignal": true; }; }, { "apply": "apply"; "save": "save"; "resetChange": "resetChange"; "documentChange": "documentChange"; }, never, never, true, never>;
+}
+
+interface PraxisChartConfigEditorData {
+    chartDocument?: PraxisXUiChartContract;
+    document?: PraxisXUiChartContract;
+    chartKey?: string;
+    mode?: 'create' | 'edit';
+    availableResources?: ChartEditorResourceOption[];
+    availableFields?: ChartEditorFieldOption[];
+    availableTargets?: ChartEditorTargetOption[];
+    hostContext?: Record<string, unknown>;
+    readonly?: boolean;
+}
+
+declare class ChartEditorDefaultsService {
+    create(): PraxisXUiChartContract;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChartEditorDefaultsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ChartEditorDefaultsService>;
+}
+
+type PraxisChartsText = PraxisTextValue;
+interface PraxisChartsI18nOptions {
+    locale?: string;
+    fallbackLocale?: string;
+    dictionaries?: Record<string, PraxisI18nDictionary>;
 }
+declare const PRAXIS_CHARTS_I18N: InjectionToken<Record<string, never>>;
+declare function createPraxisChartsI18nConfig(options?: PraxisChartsI18nOptions): Partial<PraxisI18nConfig>;
+declare function providePraxisChartsI18n(options?: PraxisChartsI18nOptions): Provider[];
+declare function resolvePraxisChartsText(value: PraxisChartsText | null | undefined, fallback?: string): PraxisI18nMessageDescriptor;
 
 declare const PRAXIS_CHART_COMPONENT_METADATA: ComponentDocMeta;
 declare function providePraxisChartsMetadata(): Provider;
@@ -635,5 +1041,5 @@ declare function providePraxisChartDrilldownPanelMetadata(): Provider;
 declare const PRAXIS_CHART_STATE_PROBE_COMPONENT_METADATA: ComponentDocMeta;
 declare function providePraxisChartStateProbeMetadata(): Provider;
 
-export { PRAXIS_CHART_BACKEND_MOCK_BAR, PRAXIS_CHART_BACKEND_MOCK_DONUT, PRAXIS_CHART_BACKEND_MOCK_TIMESERIES, PRAXIS_CHART_COMPONENT_METADATA, PRAXIS_CHART_DRILLDOWN_DATA_BY_MONTH, PRAXIS_CHART_DRILLDOWN_PANEL_METADATA, PRAXIS_CHART_ENGINE, PRAXIS_CHART_STATE_PROBE_COMPONENT_METADATA, PraxisChartBackendPayloadAdapterService, PraxisChartCanonicalContractMapperService, PraxisChartComponent, PraxisChartCompositionShowcaseComponent, PraxisChartDataTransformerService, PraxisChartDrilldownPanelComponent, PraxisChartOptionBuilderService, PraxisChartSchemaMapperService, PraxisChartStateProbeComponent, PraxisChartStatsApiService, buildPraxisChartInteractiveGridPage, buildPraxisChartInteractiveWidgetPage, buildPraxisChartMockGridPage, buildPraxisChartMockWidgetPage, providePraxisChartDrilldownPanelMetadata, providePraxisChartStateProbeMetadata, providePraxisCharts, providePraxisChartsMetadata };
-export type { PraxisChartAggregation, PraxisChartAxisConfig, PraxisChartAxisLabelConfig, PraxisChartAxisPosition, PraxisChartAxisType, PraxisChartBackendPayload, PraxisChartBackendWidgetPayload, PraxisChartCartesianSeries, PraxisChartConfig, PraxisChartDataRow, PraxisChartDataSource, PraxisChartDistributionStatsRequest, PraxisChartEmptyStateConfig, PraxisChartEngineAdapter, PraxisChartEngineRenderPayload, PraxisChartErrorStateConfig, PraxisChartGridWidgetInstance, PraxisChartGroupByStatsRequest, PraxisChartInteractionConfig, PraxisChartLegendConfig, PraxisChartLoadState, PraxisChartLocalDataSource, PraxisChartMetricConfig, PraxisChartPieSlice, PraxisChartPointEvent, PraxisChartPrimitive, PraxisChartQueryConfig, PraxisChartQueryMetricConfig, PraxisChartQueryRequestEvent, PraxisChartRemoteDataSource, PraxisChartSchemaMeta, PraxisChartSeriesConfig, PraxisChartSeriesLabelConfig, PraxisChartStateConfig, PraxisChartStatsDistributionMode, PraxisChartStatsGranularity, PraxisChartStatsMetricOperation, PraxisChartStatsMetricRequest, PraxisChartStatsOperation, PraxisChartStatsOrderBy, PraxisChartStatsRequest, PraxisChartThemeConfig, PraxisChartTimeSeriesStatsRequest, PraxisChartTooltipConfig, PraxisChartTransformedData, PraxisChartType, PraxisChartWidgetInstance, PraxisChartWidgetLike, PraxisChartWidgetResolution, PraxisChartWidgetSchema, PraxisXUiChartAggregation, PraxisXUiChartAggregationConfig, PraxisXUiChartContract, PraxisXUiChartDimension, PraxisXUiChartEventAction, PraxisXUiChartEvents, PraxisXUiChartFilter, PraxisXUiChartKind, PraxisXUiChartMetric, PraxisXUiChartPreset, PraxisXUiChartRefresh, PraxisXUiChartRuntimeHints, PraxisXUiChartSort, PraxisXUiChartSource, PraxisXUiChartSourceKind, PraxisXUiChartState, PraxisXUiChartStateDescriptor, PraxisXUiChartStatsDistributionMode, PraxisXUiChartStatsOperation, PraxisXUiChartStatsOrderBy, PraxisXUiChartStatsSourceOptions, PraxisXUiChartTextValue, PraxisXUiChartTheme, PraxisXUiChartToggleableFeature };
+export { ChartContractNormalizerService, ChartContractValidationService, ChartEditorDefaultsService, ChartEditorPreviewMapperService, PRAXIS_CHARTS_I18N, PRAXIS_CHART_BACKEND_MOCK_BAR, PRAXIS_CHART_BACKEND_MOCK_COMBO, PRAXIS_CHART_BACKEND_MOCK_DONUT, PRAXIS_CHART_BACKEND_MOCK_HORIZONTAL_BAR, PRAXIS_CHART_BACKEND_MOCK_MULTI_METRIC_BAR, PRAXIS_CHART_BACKEND_MOCK_SCATTER, PRAXIS_CHART_BACKEND_MOCK_STACKED_AREA, PRAXIS_CHART_BACKEND_MOCK_TIMESERIES, PRAXIS_CHART_COMPONENT_METADATA, PRAXIS_CHART_DRILLDOWN_DATA_BY_MONTH, PRAXIS_CHART_DRILLDOWN_PANEL_METADATA, PRAXIS_CHART_ENGINE, PRAXIS_CHART_STATE_PROBE_COMPONENT_METADATA, PraxisChartBackendPayloadAdapterService, PraxisChartCanonicalContractMapperService, PraxisChartComponent, PraxisChartCompositionShowcaseComponent, PraxisChartConfigEditor, PraxisChartDataTransformerService, PraxisChartDrilldownPanelComponent, PraxisChartOptionBuilderService, PraxisChartSchemaMapperService, PraxisChartStateProbeComponent, PraxisChartStatsApiService, buildPraxisChartInteractiveCanvasPage, buildPraxisChartInteractiveWidgetPage, buildPraxisChartMockCanvasPage, buildPraxisChartMockWidgetPage, createPraxisChartsI18nConfig, providePraxisChartDrilldownPanelMetadata, providePraxisChartStateProbeMetadata, providePraxisCharts, providePraxisChartsI18n, providePraxisChartsMetadata, resolvePraxisChartsText };
+export type { ChartConfigEditorApplyEvent, ChartConfigEditorResetEvent, ChartConfigEditorSaveEvent, ChartContractIssueSeverity, ChartContractValidationIssue, ChartContractValidationResult, ChartEditorFieldOption, ChartEditorPreviewPayload, ChartEditorResourceOption, ChartEditorTargetOption, PraxisChartAggregation, PraxisChartAxisConfig, PraxisChartAxisLabelConfig, PraxisChartAxisPosition, PraxisChartAxisType, PraxisChartBackendPayload, PraxisChartBackendWidgetPayload, PraxisChartCanvasItem, PraxisChartCartesianSeries, PraxisChartConfig, PraxisChartConfigEditorData, PraxisChartDataRow, PraxisChartDataSource, PraxisChartDistributionStatsRequest, PraxisChartEmptyStateConfig, PraxisChartEngineAdapter, PraxisChartEngineRenderPayload, PraxisChartErrorStateConfig, PraxisChartGroupByStatsRequest, PraxisChartInteractionConfig, PraxisChartLegendConfig, PraxisChartLoadState, PraxisChartLocalDataSource, PraxisChartMetricConfig, PraxisChartMotionConfig, PraxisChartMotionPreset, PraxisChartPieSlice, PraxisChartPointEvent, PraxisChartPrimitive, PraxisChartQueryConfig, PraxisChartQueryContext, PraxisChartQueryMetricConfig, PraxisChartQueryRequestEvent, PraxisChartRemoteDataSource, PraxisChartSchemaMeta, PraxisChartSeriesConfig, PraxisChartSeriesLabelConfig, PraxisChartStateConfig, PraxisChartStatsDistributionMode, PraxisChartStatsGranularity, PraxisChartStatsMetricOperation, PraxisChartStatsMetricRequest, PraxisChartStatsOperation, PraxisChartStatsOrderBy, PraxisChartStatsRequest, PraxisChartThemeConfig, PraxisChartTimeSeriesStatsRequest, PraxisChartTooltipConfig, PraxisChartTransformedData, PraxisChartType, PraxisChartWidgetInstance, PraxisChartWidgetLike, PraxisChartWidgetResolution, PraxisChartWidgetSchema, PraxisChartsI18nOptions, PraxisChartsText, PraxisXUiChartAggregation, PraxisXUiChartAggregationConfig, PraxisXUiChartContract, PraxisXUiChartDimension, PraxisXUiChartEventAction, PraxisXUiChartEvents, PraxisXUiChartFilter, PraxisXUiChartKind, PraxisXUiChartMetric, PraxisXUiChartMotion, PraxisXUiChartMotionPreset, PraxisXUiChartPreset, PraxisXUiChartRefresh, PraxisXUiChartRuntimeHints, PraxisXUiChartSort, PraxisXUiChartSource, PraxisXUiChartSourceKind, PraxisXUiChartState, PraxisXUiChartStateDescriptor, PraxisXUiChartStatsDistributionMode, PraxisXUiChartStatsOperation, PraxisXUiChartStatsOrderBy, PraxisXUiChartStatsSourceOptions, PraxisXUiChartTextValue, PraxisXUiChartTheme, PraxisXUiChartToggleableFeature };