@praxisui/charts 1.0.0-beta.68

package/index.d.ts

@@ -0,0 +1,639 @@
+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 * as _praxisui_charts from '@praxisui/charts';
+import { EChartsCoreOption } from 'echarts';
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+
+type PraxisChartAxisType = 'category' | 'value' | 'time';
+type PraxisChartAxisPosition = 'top' | 'bottom' | 'left' | 'right';
+interface PraxisChartAxisLabelConfig {
+    visible?: boolean;
+    rotate?: number;
+    format?: string;
+}
+interface PraxisChartAxisConfig {
+    field?: string;
+    label?: string;
+    type?: PraxisChartAxisType;
+    position?: PraxisChartAxisPosition;
+    min?: number;
+    max?: number;
+    labels?: PraxisChartAxisLabelConfig;
+}
+
+type PraxisChartPrimitive = string | number | boolean | Date | null | undefined;
+type PraxisChartDataRow = Record<string, PraxisChartPrimitive>;
+interface PraxisChartQueryMetricConfig {
+    field?: string;
+    aggregation?: 'sum' | 'count' | 'avg' | 'min' | 'max';
+    alias?: string;
+}
+type PraxisChartStatsOperation = 'group-by' | 'timeseries' | 'distribution';
+type PraxisChartStatsDistributionMode = 'terms' | 'histogram';
+type PraxisChartStatsOrderBy = 'key-asc' | 'key-desc' | 'value-asc' | 'value-desc';
+type PraxisChartStatsGranularity = 'hour' | 'day' | 'week' | 'month' | 'quarter' | 'year';
+type PraxisChartStatsMetricOperation = 'COUNT' | 'SUM' | 'AVG' | 'MIN' | 'MAX';
+interface PraxisChartStatsMetricRequest {
+    operation: PraxisChartStatsMetricOperation;
+    field?: string;
+}
+interface PraxisChartGroupByStatsRequest {
+    filter: Record<string, unknown>;
+    field: string;
+    metric: PraxisChartStatsMetricRequest;
+    limit?: number;
+    orderBy?: 'KEY_ASC' | 'KEY_DESC' | 'VALUE_ASC' | 'VALUE_DESC';
+}
+interface PraxisChartTimeSeriesStatsRequest {
+    filter: Record<string, unknown>;
+    field: string;
+    granularity: Uppercase<PraxisChartStatsGranularity>;
+    metric: PraxisChartStatsMetricRequest;
+    from?: string;
+    to?: string;
+    fillGaps?: boolean;
+}
+interface PraxisChartDistributionStatsRequest {
+    filter: Record<string, unknown>;
+    field: string;
+    mode: 'TERMS' | 'HISTOGRAM';
+    metric: PraxisChartStatsMetricRequest;
+    bucketSize?: number;
+    bucketCount?: number;
+    limit?: number;
+    orderBy?: 'KEY_ASC' | 'KEY_DESC' | 'VALUE_ASC' | 'VALUE_DESC';
+}
+type PraxisChartStatsRequest = PraxisChartGroupByStatsRequest | PraxisChartTimeSeriesStatsRequest | PraxisChartDistributionStatsRequest;
+interface PraxisChartQueryConfig {
+    sourceKind?: 'praxis.stats';
+    statsOperation?: PraxisChartStatsOperation;
+    granularity?: PraxisChartStatsGranularity;
+    fillGaps?: boolean;
+    distributionMode?: PraxisChartStatsDistributionMode;
+    bucketSize?: number;
+    bucketCount?: number;
+    statsOrderBy?: PraxisChartStatsOrderBy;
+    statsPath?: string;
+    statsRequest?: PraxisChartStatsRequest;
+    dimensions?: string[];
+    metrics?: PraxisChartQueryMetricConfig[];
+    filters?: Record<string, unknown>;
+    sort?: string[];
+    limit?: number;
+}
+interface PraxisChartLocalDataSource {
+    kind: 'local';
+    items?: PraxisChartDataRow[];
+}
+interface PraxisChartRemoteDataSource {
+    kind: 'remote';
+    resourcePath: string;
+    schemaId?: string;
+    query?: PraxisChartQueryConfig;
+}
+type PraxisChartDataSource = PraxisChartLocalDataSource | PraxisChartRemoteDataSource;
+
+type PraxisChartLoadState = 'idle' | 'loading' | 'ready' | 'empty' | 'error';
+interface PraxisChartInteractionConfig {
+    pointClick?: boolean;
+    selection?: boolean;
+    drillDown?: boolean;
+}
+interface PraxisChartPointEvent {
+    chartId?: string;
+    seriesId?: string;
+    seriesName?: string;
+    category?: string;
+    value?: unknown;
+    data?: unknown;
+}
+interface PraxisChartQueryRequestEvent {
+    chartId?: string;
+    dataSource: Extract<PraxisChartDataSource, {
+        kind: 'remote';
+    }>;
+    query?: PraxisChartQueryConfig;
+}
+
+type PraxisChartType = 'bar' | 'line' | 'pie' | 'donut' | 'area' | 'stacked-bar';
+type PraxisChartAggregation = 'sum' | 'count' | 'avg' | 'min' | 'max';
+interface PraxisChartMetricConfig {
+    field?: string;
+    aggregation?: PraxisChartAggregation;
+    label?: string;
+}
+interface PraxisChartSeriesLabelConfig {
+    visible?: boolean;
+    format?: string;
+}
+interface PraxisChartSeriesConfig {
+    id: string;
+    name?: string;
+    type?: PraxisChartType;
+    categoryField?: string;
+    metric?: PraxisChartMetricConfig;
+    color?: string;
+    smooth?: boolean;
+    stackId?: string;
+    labels?: PraxisChartSeriesLabelConfig;
+}
+
+interface PraxisChartLegendConfig {
+    visible?: boolean;
+    position?: 'top' | 'bottom' | 'left' | 'right';
+}
+interface PraxisChartTooltipConfig {
+    enabled?: boolean;
+    trigger?: 'item' | 'axis';
+}
+interface PraxisChartThemeConfig {
+    palette?: string[];
+    backgroundColor?: string;
+    textColor?: string;
+    borderRadius?: number;
+    legend?: PraxisChartLegendConfig;
+    tooltip?: PraxisChartTooltipConfig;
+}
+
+interface PraxisChartEmptyStateConfig {
+    title?: PraxisTextValue;
+    description?: PraxisTextValue;
+    icon?: string;
+}
+interface PraxisChartErrorStateConfig {
+    title?: PraxisTextValue;
+    description?: PraxisTextValue;
+    technicalDetails?: string;
+}
+interface PraxisChartStateConfig {
+    loading?: boolean;
+    loadingLabel?: PraxisTextValue;
+    error?: PraxisChartErrorStateConfig | null;
+}
+interface PraxisChartConfig {
+    id?: string;
+    type: PraxisChartType;
+    title?: PraxisTextValue;
+    subtitle?: PraxisTextValue;
+    height?: number | string;
+    axes?: {
+        x?: PraxisChartAxisConfig;
+        y?: PraxisChartAxisConfig;
+    };
+    series: PraxisChartSeriesConfig[];
+    dataSource?: PraxisChartDataSource;
+    interactions?: PraxisChartInteractionConfig;
+    theme?: PraxisChartThemeConfig;
+    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 PraxisXUiChartPreset = 'kpi-trend' | 'comparison' | 'distribution' | 'ranking' | 'composition' | 'hierarchical-drill-down';
+type PraxisXUiChartTextValue = string | {
+    key: string;
+    fallback?: string;
+};
+type PraxisXUiChartSourceKind = 'praxis.stats' | 'derived';
+type PraxisXUiChartStatsOperation = 'group-by' | 'timeseries' | 'distribution';
+type PraxisXUiChartStatsDistributionMode = 'terms' | 'histogram';
+type PraxisXUiChartStatsOrderBy = 'key-asc' | 'key-desc' | 'value-asc' | 'value-desc';
+type PraxisXUiChartAggregation = 'sum' | 'avg' | 'min' | 'max' | 'count' | 'distinct-count';
+interface PraxisXUiChartFilter {
+    field: string;
+    operator: 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'between' | 'in' | 'contains';
+    value?: unknown;
+    values?: unknown[];
+}
+interface PraxisXUiChartSort {
+    field: string;
+    direction: 'asc' | 'desc';
+}
+interface PraxisXUiChartDimension {
+    field: string;
+    label?: PraxisXUiChartTextValue;
+    role?: 'category' | 'series' | 'segment' | 'time';
+    format?: string;
+}
+interface PraxisXUiChartMetric {
+    field: string;
+    label?: PraxisXUiChartTextValue;
+    aggregation?: PraxisXUiChartAggregation;
+    format?: string;
+}
+interface PraxisXUiChartAggregationConfig {
+    field: string;
+    operation: PraxisXUiChartAggregation;
+    as?: string;
+}
+interface PraxisXUiChartStatsSourceOptions {
+    granularity?: 'hour' | 'day' | 'week' | 'month' | 'quarter' | 'year';
+    fillGaps?: boolean;
+    mode?: PraxisXUiChartStatsDistributionMode;
+    bucketSize?: number;
+    bucketCount?: number;
+    orderBy?: PraxisXUiChartStatsOrderBy;
+    limit?: number;
+}
+interface PraxisXUiChartRefresh {
+    strategy?: 'manual' | 'interval' | 'on-context-change';
+    intervalMs?: number;
+    freshnessMs?: number;
+    cacheKey?: string;
+}
+interface PraxisXUiChartSource {
+    kind: PraxisXUiChartSourceKind;
+    resource?: string;
+    operation?: PraxisXUiChartStatsOperation;
+    options?: PraxisXUiChartStatsSourceOptions;
+    refresh?: PraxisXUiChartRefresh;
+}
+interface PraxisXUiChartToggleableFeature {
+    enabled: boolean;
+}
+interface PraxisXUiChartTheme {
+    palette?: string | string[];
+    variant?: 'default' | 'compact' | 'executive';
+}
+interface PraxisXUiChartStateDescriptor {
+    title?: PraxisXUiChartTextValue;
+    description?: PraxisXUiChartTextValue;
+}
+interface PraxisXUiChartState {
+    empty?: PraxisXUiChartStateDescriptor;
+    loading?: PraxisXUiChartStateDescriptor;
+    error?: PraxisXUiChartStateDescriptor;
+}
+interface PraxisXUiChartEventAction {
+    action: 'filter-widget' | 'open-detail' | 'navigate' | 'update-context' | 'emit';
+    target?: string;
+    mapping?: Record<string, string>;
+}
+interface PraxisXUiChartEvents {
+    pointClick?: PraxisXUiChartEventAction;
+    selectionChange?: PraxisXUiChartEventAction;
+    drillDown?: PraxisXUiChartEventAction;
+    crossFilter?: PraxisXUiChartEventAction;
+}
+interface PraxisXUiChartContract {
+    version: string;
+    kind: PraxisXUiChartKind;
+    preset?: PraxisXUiChartPreset;
+    chartId?: string;
+    title?: PraxisXUiChartTextValue;
+    subtitle?: PraxisXUiChartTextValue;
+    height?: number | string;
+    source: PraxisXUiChartSource;
+    dimensions?: PraxisXUiChartDimension[];
+    metrics?: PraxisXUiChartMetric[];
+    aggregations?: PraxisXUiChartAggregationConfig[];
+    groupBy?: string[];
+    sort?: PraxisXUiChartSort[];
+    filters?: PraxisXUiChartFilter[];
+    limit?: number;
+    legend?: boolean | PraxisXUiChartToggleableFeature;
+    labels?: boolean | PraxisXUiChartToggleableFeature;
+    tooltip?: boolean | PraxisXUiChartToggleableFeature;
+    theme?: PraxisXUiChartTheme;
+    state?: PraxisXUiChartState;
+    events?: PraxisXUiChartEvents;
+}
+interface PraxisXUiChartRuntimeHints {
+    preferredLoadState?: Extract<PraxisChartLoadState, 'idle' | 'loading' | 'ready' | 'empty' | 'error'>;
+}
+
+interface PraxisChartWidgetSchema {
+    kind?: 'x-ui.chart';
+    componentId?: 'praxis-chart' | 'chart';
+    key?: string;
+    className?: string;
+    chart?: PraxisXUiChartContract;
+    data?: PraxisChartDataRow[];
+    outputs?: WidgetDefinition['outputs'];
+    bindingOrder?: string[];
+    shell?: WidgetShellConfig;
+    layout?: GridItemLayout;
+}
+interface PraxisChartWidgetResolution {
+    componentId: 'praxis-chart';
+    key: string;
+    definition: WidgetDefinition;
+    shell?: WidgetShellConfig;
+    className?: string;
+    layout?: GridItemLayout;
+}
+type PraxisChartWidgetLike = PraxisXUiChartContract | PraxisChartWidgetSchema;
+type PraxisChartWidgetInstance = WidgetInstance;
+type PraxisChartGridWidgetInstance = GridWidgetInstance;
+
+interface PraxisChartSchemaMeta {
+    schemaId: string;
+    schemaHash?: string;
+    resourcePath?: string;
+    operation?: 'get' | 'post';
+    schemaType?: 'response' | 'request';
+    source?: 'mock' | 'backend';
+}
+interface PraxisChartBackendWidgetPayload {
+    kind?: 'x-ui.chart';
+    key?: string;
+    className?: string;
+    layout?: GridItemLayout;
+    shell?: WidgetShellConfig;
+    outputs?: PraxisChartWidgetSchema['outputs'];
+    bindingOrder?: string[];
+    chart?: PraxisXUiChartContract;
+    runtime?: {
+        preferredLoadState?: Extract<PraxisChartLoadState, 'idle' | 'loading' | 'ready' | 'empty' | 'error'>;
+    };
+}
+interface PraxisChartBackendPayload {
+    schemaMeta: PraxisChartSchemaMeta;
+    widget: PraxisChartBackendWidgetPayload;
+    data?: PraxisChartDataRow[];
+}
+
+interface PraxisChartEngineRenderPayload {
+    config: PraxisChartConfig;
+    data: PraxisChartDataRow[];
+    onPointClick?: (event: PraxisChartPointEvent) => void;
+}
+interface PraxisChartEngineAdapter {
+    render(host: HTMLElement, payload: PraxisChartEngineRenderPayload): void;
+    resize(): void;
+    destroy(): void;
+}
+
+declare const PRAXIS_CHART_ENGINE: InjectionToken<PraxisChartEngineAdapter>;
+
+declare function providePraxisCharts(): Provider[];
+
+declare class PraxisChartCanonicalContractMapperService {
+    toPraxisChartConfig(contract: PraxisXUiChartContract): PraxisChartConfig;
+    private assertSupportedContract;
+    private buildAxes;
+    private buildSeries;
+    private buildDataSource;
+    private buildQuery;
+    private buildInteractions;
+    private buildTheme;
+    private mapTextValue;
+    private toLabel;
+    private resolveToggle;
+    private mapAggregation;
+    private toQueryFilterMap;
+    private buildStatsPath;
+    private buildStatsRequest;
+    private resolveStatsField;
+    private buildStatsMetricRequest;
+    private mapStatsOrderBy;
+    private mapStatsOrderByToBackend;
+    private mapStatsGranularityToBackend;
+    private mapDistributionModeToBackend;
+    private mapStatsMetricOperation;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PraxisChartCanonicalContractMapperService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PraxisChartCanonicalContractMapperService>;
+}
+
+interface PraxisChartCartesianSeries {
+    id: string;
+    name: string;
+    type: 'bar' | 'line';
+    stack?: string;
+    smooth?: boolean;
+    area?: boolean;
+    color?: string;
+    labelsVisible?: boolean;
+    points: Array<number | null>;
+}
+interface PraxisChartPieSlice {
+    id: string;
+    name: string;
+    value: number;
+    color?: string;
+}
+interface PraxisChartTransformedData {
+    mode: 'cartesian' | 'pie';
+    categories: string[];
+    series: PraxisChartCartesianSeries[];
+    slices: PraxisChartPieSlice[];
+    hasData: boolean;
+}
+declare class PraxisChartDataTransformerService {
+    transform(config: PraxisChartConfig, rows: PraxisChartDataRow[]): PraxisChartTransformedData;
+    private transformCartesian;
+    private transformPie;
+    private buildCartesianSeries;
+    private aggregate;
+    private extractMetricValue;
+    private normalizeCategory;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PraxisChartDataTransformerService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PraxisChartDataTransformerService>;
+}
+
+declare class PraxisChartOptionBuilderService {
+    private readonly transformer;
+    constructor(transformer: PraxisChartDataTransformerService);
+    build(config: PraxisChartConfig, rows: PraxisChartDataRow[]): EChartsCoreOption;
+    private resolveText;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PraxisChartOptionBuilderService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PraxisChartOptionBuilderService>;
+}
+
+declare class PraxisChartMetadataRegistrationService {
+    private readonly registry;
+    private registered;
+    constructor(registry: ComponentMetadataRegistry);
+    ensureRegistered(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PraxisChartMetadataRegistrationService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PraxisChartMetadataRegistrationService>;
+}
+
+declare class PraxisChartSchemaMapperService {
+    private readonly metadataRegistration;
+    private readonly canonicalContractMapper;
+    constructor(metadataRegistration: PraxisChartMetadataRegistrationService, canonicalContractMapper: PraxisChartCanonicalContractMapperService);
+    resolve(input: PraxisChartWidgetLike, defaults?: {
+        key?: string;
+        layout?: GridItemLayout;
+    }): 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;
+    private toConfig;
+    private toOutputs;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PraxisChartSchemaMapperService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PraxisChartSchemaMapperService>;
+}
+
+declare class PraxisChartBackendPayloadAdapterService {
+    private readonly chartSchemaMapper;
+    private readonly canonicalContractMapper;
+    constructor(chartSchemaMapper: PraxisChartSchemaMapperService, canonicalContractMapper: PraxisChartCanonicalContractMapperService);
+    toChartConfig(payload: PraxisChartBackendPayload): PraxisChartConfig;
+    toWidgetInstance(payload: PraxisChartBackendPayload): WidgetInstance;
+    toGridWidgetInstance(payload: PraxisChartBackendPayload): GridWidgetInstance;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PraxisChartBackendPayloadAdapterService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PraxisChartBackendPayloadAdapterService>;
+}
+
+declare class PraxisChartStatsApiService {
+    private readonly http;
+    private readonly apiUrl;
+    constructor(http: HttpClient, apiUrl: ApiUrlConfig);
+    execute(event: PraxisChartQueryRequestEvent, config: PraxisChartConfig): Observable<PraxisChartDataRow[]>;
+    private toChartRows;
+    private resolveBucketCategory;
+    private resolveMetricValue;
+    private resolveCategoryField;
+    private resolveMetricField;
+    private buildStatsUrl;
+    private buildDefaultApiBase;
+    private normalizePath;
+    private stripLeadingApiSegment;
+    private shouldStripLeadingApiSegment;
+    private handleHttpError;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PraxisChartStatsApiService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<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_DRILLDOWN_DATA_BY_MONTH: Record<string, PraxisChartDataRow[]>;
+
+declare function buildPraxisChartMockWidgetPage(adapter: PraxisChartBackendPayloadAdapterService): WidgetPageDefinition;
+declare function buildPraxisChartMockGridPage(adapter: PraxisChartBackendPayloadAdapterService): GridPageDefinition;
+declare function buildPraxisChartInteractiveWidgetPage(adapter: PraxisChartBackendPayloadAdapterService): WidgetPageDefinition;
+declare function buildPraxisChartInteractiveGridPage(adapter: PraxisChartBackendPayloadAdapterService): GridPageDefinition;
+
+type ShowcaseLayoutMode = 'widget' | 'grid';
+type ShowcasePayloadMode = 'group-by' | 'timeseries' | 'distribution';
+type ShowcaseScenarioMode = 'baseline' | 'interactive' | 'empty' | 'loading' | 'error';
+declare class PraxisChartCompositionShowcaseComponent {
+    protected readonly layoutMode: _angular_core.WritableSignal<ShowcaseLayoutMode>;
+    protected readonly payloadMode: _angular_core.WritableSignal<ShowcasePayloadMode>;
+    protected readonly scenarioMode: _angular_core.WritableSignal<ShowcaseScenarioMode>;
+    protected readonly runtimeContext: {
+        tenantId: string;
+        locale: string;
+        environment: string;
+    };
+    private readonly backendPayloadAdapter;
+    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 selectedPayloadJson: _angular_core.Signal<string>;
+    private readonly selectedPayload;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PraxisChartCompositionShowcaseComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PraxisChartCompositionShowcaseComponent, "praxis-chart-composition-showcase", never, {}, {}, never, never, true, never>;
+}
+
+declare const PRAXIS_CHART_COMPONENT_METADATA: ComponentDocMeta;
+declare function providePraxisChartsMetadata(): Provider;
+
+declare const PRAXIS_CHART_DRILLDOWN_PANEL_METADATA: ComponentDocMeta;
+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 };

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@praxisui/charts",
+  "version": "1.0.0-beta.68",
+  "description": "Metadata-driven charts library for Praxis UI Angular with engine adapters and Apache ECharts as the initial renderer.",
+  "peerDependencies": {
+    "@angular/common": "^20.0.0",
+    "@angular/core": "^20.0.0",
+    "@praxisui/core": "^1.0.0-beta.68"
+  },
+  "dependencies": {
+    "echarts": "^6.0.0",
+    "tslib": "^2.3.0"
+  },
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/codexrodrigues/praxis-ui-angular"
+  },
+  "homepage": "https://praxisui.dev",
+  "bugs": {
+    "url": "https://github.com/codexrodrigues/praxis-ui-angular/issues"
+  },
+  "keywords": [
+    "angular",
+    "praxisui",
+    "charts",
+    "analytics",
+    "echarts",
+    "metadata"
+  ],
+  "sideEffects": false,
+  "module": "fesm2022/praxisui-charts.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./fesm2022/praxisui-charts.mjs"
+    }
+  }
+}