@univerjs-pro/engine-chart 1.0.0-beta.0 → 1.0.0-beta.2

package/lib/types/facade/f-univer.d.ts

@@ -0,0 +1,51 @@
+import type { IEchartTheme } from '@univerjs-pro/engine-chart';
+import { FUniver } from '@univerjs/core/facade';
+/** @ignore */
+export interface IFUniverChartMixin {
+    /**
+     * Registers a Chart theme in this Univer runtime.
+     *
+     * The theme is shared by Sheet, Slide, Document, and Board Charts. Use the
+     * same `name` with a Chart builder's `setTheme()` method to apply it.
+     * Registering the same name again replaces the previous theme.
+     *
+     * @param {string} name The stable name used by Chart builders.
+     * @param {IEchartTheme} theme The complete Chart theme definition.
+     * @returns {void}
+     * @example
+     * ```ts
+     * import { UniverTheme1 } from '@univerjs-pro/engine-chart';
+     *
+     * univerAPI.registerTheme('brand', {
+     *   ...UniverTheme1,
+     *   themeName: 'brand',
+     *   theme: {
+     *     ...UniverTheme1.theme,
+     *     color: ['#1677ff', '#52c41a', '#faad14'],
+     *   },
+     * });
+     *
+     * const fWorkbook = univerAPI.getActiveWorkbook();
+     * if (!fWorkbook) throw new Error('No active workbook.');
+     * const fWorksheet = fWorkbook.getSheetByName('Sheet1');
+     * if (!fWorksheet) throw new Error('Worksheet not found.');
+     *
+     * const chartInfo = fWorksheet
+     *   .newChart(univerAPI.Enum.ChartTypeString.Column)
+     *   .setSource('A1:D8')
+     *   .setTheme('brand')
+     *   .build();
+     *
+     * await fWorksheet.insertChart(chartInfo);
+     * ```
+     */
+    registerTheme(name: string, theme: IEchartTheme): void;
+}
+/** @ignore */
+export declare class FUniverChartMixin extends FUniver implements IFUniverChartMixin {
+    registerTheme(name: string, theme: IEchartTheme): void;
+}
+declare module '@univerjs/core/facade' {
+    interface FUniver extends IFUniverChartMixin {
+    }
+}

package/lib/types/facade/index.d.ts

@@ -1,5 +1,7 @@
 import './register-builders';
 import './f-enum';
+import './f-univer';
+export type { IChartLiveAdapter } from '../chart-builder/chart-live-adapter';
 export { FAreaChartBuilder } from './builders/f-area-chart-builder';
 export { FBoxplotChartBuilder } from './builders/f-boxplot-chart-builder';
 export { FBubbleChartBuilder } from './builders/f-bubble-chart-builder';
@@ -20,16 +22,12 @@ export { FSunburstChartBuilder } from './builders/f-sunburst-chart-builder';
 export { FTreemapChartBuilder } from './builders/f-treemap-chart-builder';
 export { FWaterfallChartBuilder } from './builders/f-waterfall-chart-builder';
 export { FWordCloudChartBuilder } from './builders/f-word-cloud-chart-builder';
-export { getChartBuilderConstructor } from './chart-builder-registry';
-export type { IChartBuilderTypeMap } from './chart-builder-type-map';
-export type { HostAnyChartBuilder, HostChartBuilderOf, HostComposedChartBuilder, IHostChartBuilderTypes } from './chart-host-builder-types';
+export type { FAnyChartBuilder, IChartBuilderTypeMap } from './chart-builder-type-map';
+export type { HostComposedChartBuilder } from './chart-host-builder-types';
+export type { FChartInfoBuilder, IChartBuilderExtensionContext } from './create-chart-builder';
+export { createChartBuilder } from './create-chart-builder';
 export { FAxisChartBuilder } from './f-axis-chart-builder';
 export { FCartesianChartBuilder } from './f-cartesian-chart-builder';
-export { FChartBase } from './f-chart-base';
+export { FChart } from './f-chart';
 export { FChartBuilderBase } from './f-chart-builder-base';
-export { FChartsBase } from './f-charts-base';
-export type { IChartBuilderHostTypes } from './f-charts-base';
-export { getChartBuilderPendingConfig } from './internal/chart-builder-facade-context';
 export { CHART_FACADE_RANDOM_ID_LENGTH } from './internal/constants';
-export { HostBuilderComposer } from './internal/host-builder-composer';
-export type { EngineChartBuilderConstructor } from './internal/host-builder-composer';

package/lib/types/facade/internal/category-fields.d.ts

@@ -0,0 +1,3 @@
+import type { ChartPendingConfig } from '@univerjs-pro/engine-chart';
+export declare function createSetCategoryFieldsConfig(indexes: readonly number[]): ChartPendingConfig;
+export declare function createClearCategoryFieldsConfig(): ChartPendingConfig;

package/lib/types/facade/internal/chart-builder-facade-context.d.ts

@@ -1,12 +1,13 @@
-import type { ChartBuilder } from '@univerjs-pro/engine-chart';
-export type ChartFacadeBuilderConstructor<TFacade = unknown> = new (context: IChartBuilderFacadeContext) => TFacade;
-/** Facade-owned wrapping context for one shared chart builder instance. */
-export interface IChartBuilderFacadeContext<TBuilder extends ChartBuilder = ChartBuilder> {
+import type { ChartBuilder, ChartTypeString, IChartCreateConfig, IChartInfo } from '@univerjs-pro/engine-chart';
+import type { IChartBuilderTypeMap } from '../chart-builder-type-map';
+export interface IChartBuilderFacadeContext<TBuilder extends ChartBuilder = ChartBuilder, TSource = never[], TDataSource = TSource, TInfo extends IChartInfo<TDataSource> = IChartInfo<TDataSource>> {
     readonly builder: TBuilder;
-    wrap<TFacade>(Constructor: ChartFacadeBuilderConstructor<TFacade>): TFacade;
+    readonly info: Partial<TInfo>;
+    readonly normalizeSource: (source: TSource) => TDataSource;
+    readonly createConfig: (builder: TBuilder) => IChartCreateConfig;
+    readonly requireSource: boolean;
 }
-export declare const ChartBuilderFacadeContextAccess: unique symbol;
-export interface IChartBuilderFacadeContextAccess {
-    readonly [ChartBuilderFacadeContextAccess]: IChartBuilderFacadeContext;
-}
-export declare function wrapChartBuilder<TFacade>(builder: ChartBuilder, Constructor: ChartFacadeBuilderConstructor<TFacade>): TFacade;
+export type ChartFacadeBuilderConstructor<TFacade, TSource, TDataSource, TInfo extends IChartInfo<TDataSource>> = new (context: IChartBuilderFacadeContext<ChartBuilder, TSource, TDataSource, TInfo>) => TFacade;
+export declare function wrapChartBuilder<TFacade, TSource = never[], TDataSource = TSource, TInfo extends IChartInfo<TDataSource> = IChartInfo<TDataSource>>(builder: ChartBuilder, Constructor: ChartFacadeBuilderConstructor<TFacade, TSource, TDataSource, TInfo>, context?: Omit<IChartBuilderFacadeContext<ChartBuilder, TSource, TDataSource, TInfo>, 'builder'>): TFacade;
+/** Wraps a core Builder with the concrete Facade selected by its fixed type. */
+export declare function wrapTypedChartBuilder<T extends ChartTypeString, TSource = never[], TDataSource = TSource, TInfo extends IChartInfo<TDataSource> = IChartInfo<TDataSource>>(builder: ChartBuilder, type: T, context?: Omit<IChartBuilderFacadeContext<ChartBuilder, TSource, TDataSource, TInfo>, 'builder'>): IChartBuilderTypeMap<TSource, TDataSource, TInfo>[T];

package/lib/types/index.d.ts

@@ -3,8 +3,9 @@ export type { IChartBuilderAdapter, } from './chart-builder/chart-builder-adapte
 export type { ChartColor, ChartLinearGradientInput, IChartGradientPoint, IChartGradientStop, IChartLinearGradient, } from './chart-builder/chart-color';
 export { CHART_LINEAR_GRADIENT_TYPE, chartLinearGradient, } from './chart-builder/chart-color';
 export type { ChartDescription, } from './chart-builder/chart-description';
+export type { IChartLiveAdapter } from './chart-builder/chart-live-adapter';
 export { createChartStarterRows } from './chart-builder/chart-starter-data';
-export type { ChartLegendSpec, ChartSeriesSelector, ChartSubtitleSpec, ChartTitleSpec, IChartAggregationSpec, IChartAppearanceSpec, IChartAreaSpec, IChartAxesSpec, IChartAxisBindingDescription, IChartAxisLabelSpec, IChartAxisPointerSpec, IChartAxisSpec, IChartBarSpec, IChartBubbleMappingSpec, IChartBubbleSpec, IChartDescription, IChartFontSpec, IChartFunnelSpec, IChartGaugeTicksPatch, IChartHeatmapLabelSpec, IChartHeatmapSpec, IChartLegendOptions, IChartLineSeriesPatch, IChartMappingSpec, IChartMarkLineLabelSpec, IChartMarkLineSpec, IChartParetoBarLabelStyleSpec, IChartParetoBarStyleSpec, IChartParetoBorderStyleSpec, IChartParetoLineLabelStyleSpec, IChartParetoLineStyleSpec, IChartParetoPointStyleSpec, IChartParetoSpec, IChartPieAggregateSpec, IChartPieCompositeSpec, IChartPieConnectorSpec, IChartPieLabelSpec, IChartPieSecondaryPlotSpec, IChartPieSpec, IChartPlotAreaSpec, IChartRadarSpec, IChartRelationForceSpec, IChartRelationSpec, IChartScatterMappingSpec, IChartSeriesBorderSpec, IChartSeriesDataPointStyleSpec, IChartSeriesDescription, IChartSeriesLabelSpec, IChartSeriesPatch, IChartSeriesPointSpec, IChartSeriesStyleSpec, IChartSliceStyleSpec, IChartSolidSeriesPatch, IChartSolidSeriesStyleSpec, IChartSubtitleOptions, IChartSymbolDataPointStyleSpec, IChartTitleOptions, IChartTrendlineSpec, IChartWaterfallConnectorStyleSpec, IChartWaterfallPointRoleSpec, IChartWaterfallSpec, IChartWordCloudDescription, IChartWordCloudSpec, PieSecondarySplitSpec, } from './chart-builder/chart-types';
+export type { ChartLegendSpec, ChartSeriesSelector, ChartSubtitleSpec, ChartTitleSpec, IChartAggregationSpec, IChartAppearanceSpec, IChartAreaSpec, IChartAxesSpec, IChartAxisBindingDescription, IChartAxisLabelSpec, IChartAxisPointerSpec, IChartAxisSpec, IChartBarSpec, IChartBubbleMappingSpec, IChartBubbleSpec, IChartDescription, IChartFontSpec, IChartFunnelSpec, IChartGaugeTicksPatch, IChartHeatmapLabelSpec, IChartHeatmapSpec, IChartInfo, IChartLegendOptions, IChartLineSeriesPatch, IChartMappingSpec, IChartMarkLineLabelSpec, IChartMarkLineSpec, IChartParetoBarLabelStyleSpec, IChartParetoBarStyleSpec, IChartParetoBorderStyleSpec, IChartParetoLineLabelStyleSpec, IChartParetoLineStyleSpec, IChartParetoPointStyleSpec, IChartParetoSpec, IChartPieAggregateSpec, IChartPieCompositeSpec, IChartPieConnectorSpec, IChartPieLabelSpec, IChartPieSecondaryPlotSpec, IChartPieSpec, IChartPlotAreaSpec, IChartPosition, IChartRadarSpec, IChartRelationForceSpec, IChartRelationSpec, IChartScatterMappingSpec, IChartSeriesBorderSpec, IChartSeriesDataPointStyleSpec, IChartSeriesDescription, IChartSeriesLabelSpec, IChartSeriesPatch, IChartSeriesPointSpec, IChartSeriesStyleSpec, IChartSize, IChartSliceStyleSpec, IChartSolidSeriesPatch, IChartSolidSeriesStyleSpec, IChartSubtitleOptions, IChartSymbolDataPointStyleSpec, IChartTitleOptions, IChartTrendlineSpec, IChartWaterfallConnectorStyleSpec, IChartWaterfallPointRoleSpec, IChartWaterfallSpec, IChartWordCloudDescription, IChartWordCloudSpec, PieSecondarySplitSpec, } from './chart-builder/chart-types';
 export { AREA_CHART_TYPES, AXIS_CHART_TYPES, CARTESIAN_CHART_TYPES, ChartAxisTickPosition, ChartSeriesTypeString, ChartTypeString, ChartVisualMapType, ChartWaterfallStyleTarget, ChartWordCloudShapeSource, DEFAULT_CHART_TYPE, PieCompositeMarkRole, PieSecondaryPlotType, PieSecondarySplitType, } from './chart-builder/chart-types';
 export type { ChartPendingConfig, IChartCreateConfig, } from './chart-builder/chart-types';
 export { ChartAggregationTarget, } from './chart-builder/configuration/aggregation';
@@ -21,7 +22,7 @@ export { clearBar, setBar, } from './chart-builder/configuration/bar';
 export { clearDojiStyle, clearFallingStyle, clearRisingStyle, resetCandleWidth, setCandleWidth, setDojiStyle, setFallingStyle, setRisingStyle, } from './chart-builder/configuration/candlestick';
 export type { ChartPublicSeriesSelector, } from './chart-builder/configuration/cartesian-series';
 export { ChartAllSeriesStyleTarget, ChartSeriesClearTarget, } from './chart-builder/configuration/cartesian-series';
-export { clearAllSeriesStyle, clearSeries, setAllSeriesStyle, setSeries, } from './chart-builder/configuration/cartesian-series';
+export { clearAllSeriesOverrides, clearAllSeriesStyle, clearSeries, setAllSeriesStyle, setSeries, } from './chart-builder/configuration/cartesian-series';
 export type { IChartConfigOperation, } from './chart-builder/configuration/chart-config-operation';
 export { resetChordEmphasis, resetChordLabel, resetChordLayout, resetChordNode, resetChordRibbon, setChordEmphasis, setChordLabel, setChordLayout, setChordMapping, setChordNode, setChordRibbon, } from './chart-builder/configuration/chord';
 export { ChartSeriesAxis, } from './chart-builder/configuration/combination';
@@ -51,33 +52,41 @@ export { clearTrendlines, removeTrendline, setTrendline, } from './chart-builder
 export type { ChartTrendlineSelector, ChartTrendlineValue, } from './chart-builder/configuration/trendline';
 export { clearWaterfallConnector, clearWaterfallStyle, resetUseSubtotal, resetWaterfallStackType, setUseSubtotal, setWaterfallConnector, setWaterfallPointRoles, setWaterfallStackType, setWaterfallStyle, } from './chart-builder/configuration/waterfall';
 export { clearMaskImage, resetWordCloudRepeat, resetWordCloudShape, setMaskImage, setWordCloudRepeat, setWordCloudShape, } from './chart-builder/configuration/word-cloud';
-export { toChartModelConfig, toCompleteChartModelConfig, } from './chart-builder/conversion/chart-config-converter';
+export type { IResolvedChartModelConfigUpdate, } from './chart-builder/conversion/chart-config-converter';
+export { resolveChartModelConfigUpdate, toChartModelConfig, toChartModelConfigReplacement, } from './chart-builder/conversion/chart-config-converter';
 export { canonicalizeChartContext, } from './chart-builder/conversion/chart-context-patch';
+export { toChartCreateConfig, toChartCreateConfigSnapshot } from './chart-builder/conversion/chart-create-config';
 export { chartBitsToType, chartTypeToBits, getChartStackType, withChartStackType, } from './chart-builder/conversion/chart-type-converter';
 export { describeChartModel, projectChartModelDescription, resolveChartDescriptionMetadata, } from './chart-builder/conversion/describe-chart-model';
 export { resolveChartModelData, } from './chart-builder/conversion/resolve-chart-model-data';
-export { DetachedChartBuilderAdapter, DetachedInlineChartBuilderAdapter, } from './chart-builder/detached-chart-builder-adapter';
-export type { IInlineChartBuilderAdapter, IInlineChartHostPatch, } from './chart-builder/internal/host-builder-runtime';
-export { InlineChartBuilder, resolveInlineChartDataSet, } from './chart-builder/internal/host-builder-runtime';
+export { DetachedChartBuilderAdapter, } from './chart-builder/detached-chart-builder-adapter';
+export type { IChartHostConfigAdapter, IChartHostPatch, } from './chart-builder/internal/chart-host-config-adapter';
+export { resolveChartDataSetFromValues, } from './chart-builder/internal/chart-host-config-adapter';
 export type { IChartDataAggregation, IChartTopNSpec } from './chart-data-aggregation';
 export type { IUniverChartConfig } from './config/config';
 export { AreaLineStyle, AxisAlignEnum, AxisValueType, BarShape, CategoryType, ChartAttributeBits, ChartAxisDimension, ChartBorderDashType, ChartCandlestickState, ChartChordFocusMode, ChartChordLabelPosition, ChartChordRibbonColorMode, ChartGaugeMode, ChartGaugePointerShape, ChartHistogramBinKind, ChartMarkLineLabelPosition, ChartSemanticAxis, ChartSourceDataTypeEnum, ChartSunburstLabelPosition, ChartTrendlineType, ChartTypeBits, ChartWaterfallPointRole, DataOrientation, HistogramBinningMode, InvalidValueType, IRuntimeAxisPosition, IRuntimeAxisPriority, LabelAlignEnum, LabelContentType, LegendPositionEnum, LinePointShape, ParetoSeriesIndex, ParetoSeriesPart, PieLabelPosition, RadarShape, RelationChartLayoutEnum, SelectModeEnum, SeriesLabelPosition, StackType, TextAlign, TextVerticalAlign, TitlePositionEnum, TreemapParentLabelLayout, WaterfallSeriesTypeEnum, WaterfallStackTypeEnum, WordCloudShapeEnum, } from './enum';
-export { generateChartContext } from './models/chart-context/resolve-chart-context';
+export { generateChartContext, reconcileChartContext } from './models/chart-context/resolve-chart-context';
 export { MAX_HISTOGRAM_BIN_COUNT } from './models/chart-data/internal/histogram-bins';
 export { PIE_CONNECTOR_COLOR_DEFAULT, PIE_CONNECTOR_DASH_TYPE_DEFAULT, PIE_CONNECTOR_OPACITY_DEFAULT, PIE_CONNECTOR_VISIBLE_DEFAULT, PIE_CONNECTOR_WIDTH_DEFAULT, PIE_PERCENTAGE_SPLIT_LESS_THAN_DEFAULT, PIE_POSITION_SPLIT_COUNT_DEFAULT, PIE_POSITION_SPLIT_COUNT_MIN, PIE_SECONDARY_GAP_WIDTH_DEFAULT, PIE_SECONDARY_GAP_WIDTH_MAX, PIE_SECONDARY_GAP_WIDTH_MIN, PIE_SECONDARY_SIZE_DEFAULT, PIE_SECONDARY_SIZE_MAX, PIE_SECONDARY_SIZE_MIN, PIE_VALUE_SPLIT_LESS_THAN_DEFAULT, } from './models/chart-data/pie-composite/pie-composite-spec';
 export { CHART_HOST_DEFAULT_BORDER_COLOR, CHART_HOST_DEFAULT_BORDER_RADIUS, CHART_HOST_DEFAULT_BORDER_WIDTH, composeChartHostFrameImage, getChartHostFrameContentRect, resolveChartHostFrameBorder, resolveChartHostFrameStyle, resolveDefaultChartHostFrameStyle, shouldComposeChartHostFrame, } from './models/chart-host/chart-host-style';
 export type { IResolveChartHostFrameStyleInput, IResolveDefaultChartHostFrameStyleInput, } from './models/chart-host/chart-host-style';
+export { chartConfigInterpreter } from './models/chart-host/config/chart-config-interpreter';
+export type { IChartConfigUpdate } from './models/chart-host/config/chart-config-interpreter';
 export { chartImageSourceToDataUrl, DataUrlImageChartHost, ImageChartHost, } from './models/chart-host/image-chart-host';
 export { OffscreenChartHost } from './models/chart-host/offscreen-chart-host';
+export { ChartDataSourceResolver, ChartDataSourceRuntimeStatus, IChartDataSourceResolver, } from './models/chart-host/resource/chart-data-source-resolver';
+export type { IChartDataSourceHandle, IChartDataSourceProvider, IChartDataSourceResolveResult, IChartDataSourceRuntimeState, } from './models/chart-host/resource/chart-data-source-resolver';
+export { CHART_RESOURCE_VERSION, ChartResourceRepository, isInlineChartDataSource, isReferencedChartDataSource, } from './models/chart-host/resource/chart-resource-repository';
+export type { IChartDataSourceInput, IChartResource, IChartResourceContext, IChartResourceDataSource, IChartResourceSnapshot, IChartResourceState, ICreateChartDataSourceOptions, ICreateChartSnapshotOptions, IInlineChartDataSource, IReferencedChartDataSource, IUpdateChartSnapshotPatch, } from './models/chart-host/resource/chart-resource-repository';
 export { serializeChartResource } from './models/chart-host/resource/chart-resource-serializer';
-export { buildInlineChartTableDataSet, parseInlineChartTable, } from './models/chart-host/resource/inline-chart-table';
-export type { InlineChartCellValue } from './models/chart-host/resource/inline-chart-table';
-export { STATIC_CHART_RESOURCE_VERSION, StaticChartResourceRepository, } from './models/chart-host/resource/static-chart-resource-repository';
-export type { ICreateStaticChartDataSourceOptions, ICreateStaticChartSnapshotOptions, IStaticChartContext, IStaticChartInlineDataSource, IStaticChartResource, IStaticChartSnapshot, IStaticChartState, IUpdateStaticChartSnapshotPatch, } from './models/chart-host/resource/static-chart-resource-repository';
-export { StaticChartModelStore } from './models/chart-host/static/static-chart-model-store';
-export type { IStaticChartModelRuntime } from './models/chart-host/static/static-chart-model-store';
-export { createStaticChartRuntime, refreshStaticChartRuntime, } from './models/chart-host/static/static-chart-runtime';
-export type { ICreateStaticChartRuntimeOptions, IStaticChartRuntime, IStaticChartRuntimeConfig, } from './models/chart-host/static/static-chart-runtime';
+export { buildChartDataSetFromValues, parseInlineChartTable, } from './models/chart-host/resource/inline-chart-table';
+export type { ChartDataSourceValue } from './models/chart-host/resource/inline-chart-table';
+export { RESOURCE_REF_CHART_DATA_SOURCE_KIND, ResourceRefChartDataSourceAdapter, } from './models/chart-host/resource/resource-ref-chart-data-source.adapter';
+export type { IResourceRefChartDataSourceInput, IResourceRefChartDataSourceReference, } from './models/chart-host/resource/resource-ref-chart-data-source.adapter';
+export { ChartModelStore } from './models/chart-host/static/chart-model-store';
+export type { IChartModelRuntime } from './models/chart-host/static/chart-model-store';
+export { createChartRuntime, refreshChartRuntime, } from './models/chart-host/static/chart-runtime';
+export type { IChartRuntime, IChartRuntimeConfig, ICreateChartRuntimeOptions, } from './models/chart-host/static/chart-runtime';
 export type { IChartModelInit } from './models/chart-model/chart-model';
 export { ChartModel } from './models/chart-model/chart-model';
 export { echartToChartModelInit, isChartModelInit } from './models/chart-model/echart-to-chart-model-init';
@@ -118,9 +127,11 @@ export { toChartDataItem } from './source/chart-data-item';
 export { ChartDataSource } from './source/chart-source';
 export { StaticChartSource } from './source/static-chart-source';
 export type { IChartCandlestickMappingSpec, IChartCandlestickSpec, IChartCandlestickStateStyleSpec, IChartChordEmphasisSpec, IChartChordLabelSpec, IChartChordLayoutSpec, IChartChordMappingSpec, IChartChordNodeStyleSpec, IChartChordRibbonStyleSpec, IChartChordSpec, IChartGaugeAnchorSpec, IChartGaugeAnglesSpec, IChartGaugeAxisLabelSpec, IChartGaugeAxisLineSpec, IChartGaugeAxisTickSpec, IChartGaugeDetailSpec, IChartGaugeFontSpec, IChartGaugePointerSpec, IChartGaugeProgressSpec, IChartGaugeRangeSpec, IChartGaugeScaleSpec, IChartGaugeSpec, IChartGaugeSplitLineSpec, IChartGaugeTitleSpec, IChartHistogramBinningSpec, IChartHistogramDataSpec, IChartHistogramSpec, IChartHistogramStyleSpec, IChartSunburstCenterLabelSpec, IChartSunburstLabelSpec, IChartSunburstSpec, IChartTreemapLabelSpec, IChartTreemapSpec, IChartValueLabelSpec, } from './types';
-export { ChartHostRenderMode, ChartImageSourceType } from './types';
-export type { ChartDataSourceValues, ChartDirection, ChartElementEventHandler, ChartElementEventType, ChartElementKind, ChartImageSource, ChartRenderRuntimeContext, ChartRuntimeStyle, ChartStyle, DeepNullish, DeepPartial, DimensionDefinitionLoose, IAllSeriesStyle, IAxisOptions, IBarStyle, IChartBubbleStyle, IChartCandlestickData, IChartCandlestickPoint, IChartChordData, IChartChordLink, IChartChordNode, IChartConfig, IChartContext, IChartData, IChartDataCategory, IChartDataSeries, IChartDataSource, IChartElementBounds, IChartElementEvent, IChartElementHit, IChartElementOverlay, IChartGaugeData, IChartGaugeItem, IChartHistogramBin, IChartHistogramData, IChartHost, IChartHostBorderStyle, IChartHostLease, IChartHostRect, IChartHostStyle, IChartInstance, IChartPlotArea, IChartRenderAsImageOptions, IChartRenderInput, IChartRenderInstance, IChartRenderInstanceCreateContext, IChartRenderInstanceSpecInput, IChartRenderInstanceStyleInput, IChartRenderModel, IChartRenderModelImageExportInput, IChartRenderModelImageExportOptions, IChartRenderModelImageExportResult, IChartSnapshot, IChartStyle, IChartSunburstData, IChartSunburstNode, IChartTreemapData, IChartTreemapNode, IDimensionDefinition, IDomChartHost, IGridLineStyle, IImageChartHost, ILabelStyle, ILegendStyle, IPieLabelStyle, IPointStyle, IRelationForceOptions, IRuntimeAxis, ISeriesLabelStyle, ISeriesStyle, ITrendLine, IUniverDataSet, OptionDataValue, RightYAxisOptions, } from './types';
+export { ChartHostRenderMode, ChartImageExportFormat, ChartImageSourceType } from './types';
+export type { ChartDataSourceValues, ChartDirection, ChartElementEventHandler, ChartElementEventType, ChartElementKind, ChartImageSource, ChartRenderRuntimeContext, ChartRuntimeStyle, ChartStyle, DeepNullish, DeepPartial, DimensionDefinitionLoose, IAllSeriesStyle, IAxisOptions, IBarStyle, IChartBubbleStyle, IChartCandlestickData, IChartCandlestickPoint, IChartChordData, IChartChordLink, IChartChordNode, IChartConfig, IChartContext, IChartData, IChartDataCategory, IChartDataCategoryLevel, IChartDataCategorySegment, IChartDataSeries, IChartDataSource, IChartElementBounds, IChartElementEvent, IChartElementHit, IChartElementOverlay, IChartGaugeData, IChartGaugeItem, IChartHistogramBin, IChartHistogramData, IChartHost, IChartHostBorderStyle, IChartHostLease, IChartHostRect, IChartHostStyle, IChartInstance, IChartPlotArea, IChartRenderAsImageOptions, IChartRenderInput, IChartRenderInstance, IChartRenderInstanceCreateContext, IChartRenderInstanceSpecInput, IChartRenderInstanceStyleInput, IChartRenderModel, IChartRenderModelImageExportInput, IChartRenderModelImageExportOptions, IChartRenderModelImageExportResult, IChartSnapshot, IChartStyle, IChartSunburstData, IChartSunburstNode, IChartTreemapData, IChartTreemapNode, IDimensionDefinition, IDomChartHost, IGridLineStyle, IImageChartHost, ILabelStyle, ILegendStyle, IPieLabelStyle, IPointStyle, IRelationForceOptions, IRuntimeAxis, ISeriesLabelStyle, ISeriesStyle, ITrendLine, IUniverDataSet, IUniverDataSetCategorySpan, OptionDataValue, RightYAxisOptions, } from './types';
 export { chartBitsUtils, chartTypeCanUseTrendLine, mergeChartConfig, } from './util';
+export { omitUndefinedFields, } from './utils/compact';
+export { DEFAULT_CHART_DEVICE_PIXEL_RATIO } from './utils/device-pixel-ratio';
 export { echarts } from './utils/echarts';
 export { WordCloudMaskImageOptions, WordCloudResourceConfig } from './word-cloud-resource/word-cloud-resource-config';
 export { WORD_CLOUD_DEFAULT_OPTION, WORD_CLOUD_SERIES_TYPE } from './wordcloud-chart/adapters/echarts/echarts-options';

package/lib/types/models/chart-context/chart-field-selection.d.ts

@@ -12,7 +12,7 @@ export declare function countChartFieldTypes(field: Array<OptionDataValue | unde
     strings: number;
     total: number;
 };
-export declare function classifyChartFields(dataSet: Pick<IUniverDataSet, 'source' | 'sourceType'>): IChartFieldSelection;
+export declare function classifyChartFields(dataSet: Pick<IUniverDataSet, 'source' | 'sourceType' | 'categorySpans'>): IChartFieldSelection;
 export declare function resolveChartFieldSelectionContext(dataSet: IUniverDataSet, context: IChartContext, initializeSelection?: boolean): IChartContext;
 /** The single compatibility boundary for the historical scalar snapshot field. */
 export declare function normalizeChartSnapshotContext(context: IChartSnapshotContext): IChartContext;

package/lib/types/models/chart-context/resolve-chart-context.d.ts

@@ -1,2 +1,5 @@
+import type { ChartTypeBits } from '../../enum';
 import type { IChartContext, IUniverDataSet } from '../../types';
 export declare function generateChartContext(dataSet: IUniverDataSet, context?: IChartContext, initializeSelection?: boolean): IChartContext;
+/** Preserves a usable field selection and re-infers it when the latest data shape invalidates it. */
+export declare function reconcileChartContext(dataSet: IUniverDataSet, context: IChartContext, chartType: ChartTypeBits): IChartContext;

package/lib/types/models/chart-data/chart-field-consumption-validator.d.ts

@@ -1,7 +1,7 @@
+import type { ChartTypeBits } from '../../enum';
 import type { IUniverDataSet } from '../../types';
 import type { IChartFieldDiagnostic } from '../common/chart-field-diagnostic';
 import type { IChartFieldConsumption } from './chart-field-consumption';
-import type { ChartTypeBits } from '../../enum';
 export type ChartFieldValidationResult = {
     valid: true;
 } | {

package/lib/types/models/chart-data/internal/category-series-aggregation.d.ts

@@ -1,10 +1,9 @@
 import type { IChartDataAggregation } from '../../../chart-data-aggregation';
 import type { IUniverDataSet } from '../../../types';
-import type { IChartFieldConsumption } from '../chart-field-consumption';
 /**
  * Projects category/value rows while preserving source-field indexes.
  *
  * This runs after field-consumption validation, so callers continue to own chart-specific
  * mapping rules and this module owns only ordinary category/value aggregation and ranking.
  */
-export declare function projectCategorySeriesData(dataSet: IUniverDataSet, fieldConsumption: IChartFieldConsumption, dataAggregation: IChartDataAggregation | undefined): IUniverDataSet;
+export declare function projectCategorySeriesData(dataSet: IUniverDataSet, categoryIndexes: readonly number[], seriesIndexes: readonly number[], dataAggregation: IChartDataAggregation | undefined): IUniverDataSet;

package/lib/types/models/chart-data/internal/data-set-category-spans.d.ts

@@ -0,0 +1,7 @@
+import type { IUniverDataSet, IUniverDataSetCategorySpan } from '../../../types';
+export interface IDataSetCategorySpanLookup {
+    get(fieldIndex: number, itemIndex: number): IUniverDataSetCategorySpan | undefined;
+}
+export declare function createDataSetCategorySpanLookup(dataSet: IUniverDataSet, fieldIndexes: readonly number[], itemCount: number): IDataSetCategorySpanLookup;
+export declare function getDataSetCategorySpan(dataSet: IUniverDataSet, fieldIndex: number, itemIndex: number): IUniverDataSetCategorySpan | undefined;
+export declare function getEffectiveCategoryLabel(dataSet: IUniverDataSet, fieldIndex: number, itemIndex: number, categorySpanLookup?: IDataSetCategorySpanLookup): string;

package/lib/types/models/chart-data/internal/multi-level-category-axis.d.ts

@@ -0,0 +1,10 @@
+import type { IChartDataCategory, IUniverDataSet } from '../../../types';
+import type { IChartLocaleTexts } from '../../common/chart-locale-texts';
+interface INormalizeMultiLevelCategoryAxisInput {
+    dataSet: IUniverDataSet;
+    categoryIndexes: number[];
+    headers?: string[];
+    localeTexts: IChartLocaleTexts;
+}
+export declare function normalizeMultiLevelCategoryAxis(input: INormalizeMultiLevelCategoryAxisInput): IChartDataCategory | undefined;
+export {};

package/lib/types/models/chart-host/config/chart-config-interpreter.d.ts

@@ -0,0 +1,13 @@
+import type { IChartDataAggregation } from '../../../chart-data-aggregation';
+import type { ChartStyle, IChartContext } from '../../../types';
+import type { IChartResourceSnapshot } from '../resource/chart-resource-repository';
+export interface IChartConfigUpdate {
+    chartType?: IChartResourceSnapshot['chartType'];
+    style?: ChartStyle;
+    context?: IChartContext;
+    dataAggregation?: Partial<IChartDataAggregation>;
+    patch?: Partial<Omit<IChartResourceSnapshot, 'id'>>;
+}
+export declare const chartConfigInterpreter: {
+    apply(previous: IChartResourceSnapshot, update: IChartConfigUpdate, replaceConfig: boolean): IChartResourceSnapshot | null;
+};

package/lib/types/models/chart-host/resource/chart-data-source-resolver.d.ts

@@ -0,0 +1,58 @@
+import type { IDisposable } from '@univerjs/core';
+import type { Observable } from 'rxjs';
+import type { ChartDataSourceValue } from './inline-chart-table';
+import type { IResourceRefChartDataSourceReference } from './resource-ref-chart-data-source.adapter';
+import { Disposable } from '@univerjs/core';
+export declare enum ChartDataSourceRuntimeStatus {
+    LOADING = "loading",
+    READY = "ready",
+    UNAVAILABLE = "unavailable",
+    REFRESH_ERROR = "refresh-error"
+}
+export interface IChartDataSourceResolveResult {
+    values: ReadonlyArray<ReadonlyArray<ChartDataSourceValue>>;
+}
+export interface IChartDataSourceProvider {
+    readonly kind: IResourceRefChartDataSourceReference['kind'];
+    getCacheKey(source: Readonly<IResourceRefChartDataSourceReference>): string;
+    resolve(source: Readonly<IResourceRefChartDataSourceReference>, options: {
+        signal: AbortSignal;
+    }): Promise<IChartDataSourceResolveResult>;
+}
+export interface IChartDataSourceRuntimeState {
+    status: ChartDataSourceRuntimeStatus;
+    values?: ReadonlyArray<ReadonlyArray<ChartDataSourceValue>>;
+    error?: unknown;
+}
+export interface IChartDataSourceHandle extends IDisposable {
+    readonly state$: Observable<IChartDataSourceRuntimeState>;
+    refresh(): Promise<void>;
+}
+export interface IChartDataSourceResolver {
+    registerProvider(provider: IChartDataSourceProvider): IDisposable;
+    acquire(source: Readonly<IResourceRefChartDataSourceReference>): IChartDataSourceHandle;
+}
+export declare const IChartDataSourceResolver: import("@wendellhu/redi").IdentifierDecorator<IChartDataSourceResolver>;
+export declare class ChartDataSourceResolver extends Disposable implements IChartDataSourceResolver {
+    private readonly _providers;
+    private readonly _entries;
+    private readonly _handles;
+    private _isDisposed;
+    registerProvider(provider: IChartDataSourceProvider): IDisposable;
+    acquire(source: Readonly<IResourceRefChartDataSourceReference>): IChartDataSourceHandle;
+    dispose(): void;
+    private _getOrCreateEntry;
+    private _attachHandle;
+    private _detachHandle;
+    private _releaseHandle;
+    private _refreshHandle;
+    private _startResolve;
+    private _resolveEntry;
+    private _isCurrentGeneration;
+    private _clearPending;
+    private _publishEntry;
+    private _invalidateProviderEntry;
+    private _cancelEntry;
+    private _snapshotState;
+    private _unavailableState;
+}

package/lib/types/models/chart-host/resource/chart-resource-repository.d.ts

@@ -0,0 +1,111 @@
+import type { Observable } from 'rxjs';
+import type { IChartDataAggregation } from '../../../chart-data-aggregation';
+import type { ChartTypeBits } from '../../../enum';
+import type { ChartStyle, IChartContext } from '../../../types';
+import type { ChartDataSourceValue } from './inline-chart-table';
+import type { IResourceRefChartDataSourceReference } from './resource-ref-chart-data-source.adapter';
+import { Disposable } from '@univerjs/core';
+export declare const CHART_RESOURCE_VERSION = 2;
+export interface IInlineChartDataSource<TCell extends ChartDataSourceValue = ChartDataSourceValue> {
+    id: string;
+    name?: string;
+    values: TCell[][];
+}
+export interface IReferencedChartDataSource {
+    id: string;
+    name?: string;
+    source: IResourceRefChartDataSourceReference;
+}
+export type IChartResourceDataSource = IInlineChartDataSource | IReferencedChartDataSource;
+export type IChartDataSourceInput = {
+    values: ChartDataSourceValue[][];
+    source?: never;
+} | {
+    source: IResourceRefChartDataSourceReference;
+    values?: never;
+};
+interface IChartDataSourceCandidate {
+    values?: ChartDataSourceValue[][];
+    source?: IResourceRefChartDataSourceReference;
+}
+export declare function isInlineChartDataSource<T extends IChartDataSourceCandidate>(dataSource: T | null | undefined): dataSource is T & {
+    values: ChartDataSourceValue[][];
+    source?: never;
+};
+export declare function isReferencedChartDataSource<T extends IChartDataSourceCandidate>(dataSource: T | null | undefined): dataSource is T & {
+    source: IResourceRefChartDataSourceReference;
+    values?: never;
+};
+export interface IChartResourceContext {
+    orient?: 'row' | 'column';
+    chartContext?: Partial<IChartContext>;
+}
+export interface IChartResourceState {
+    legendSelected?: Record<string, boolean>;
+    activePage?: number;
+    relationNodePositions?: Record<string, {
+        x: number;
+        y: number;
+    }>;
+}
+export interface IChartResourceSnapshot<TContext = IChartResourceContext, TState = IChartResourceState> {
+    id: string;
+    dataSourceId: string;
+    chartType: ChartTypeBits;
+    style?: ChartStyle;
+    context?: TContext;
+    state?: TState;
+    dataAggregation?: IChartDataAggregation;
+}
+export interface IChartResource<TDataSource extends IChartResourceDataSource = IChartResourceDataSource, TChart extends IChartResourceSnapshot<unknown, unknown> = IChartResourceSnapshot> {
+    version: typeof CHART_RESOURCE_VERSION;
+    dataSources: Record<string, TDataSource>;
+    charts: Record<string, TChart>;
+}
+export type ICreateChartDataSourceOptions<TDataSource extends IChartResourceDataSource = IChartResourceDataSource> = TDataSource extends IChartResourceDataSource ? Omit<TDataSource, 'id'> & {
+    id?: string;
+} : never;
+export type ICreateChartSnapshotOptions<TChart extends IChartResourceSnapshot<unknown, unknown>> = Omit<TChart, 'id'> & {
+    id?: string;
+};
+export type IUpdateChartSnapshotPatch<TChart extends IChartResourceSnapshot<unknown, unknown>> = Partial<Omit<TChart, 'id'>>;
+interface IChartDataSourceRemovedEvent {
+    unitId: string;
+    dataSourceId: string;
+}
+export declare class ChartResourceRepository<TDataSource extends IChartResourceDataSource = IChartResourceDataSource, TChart extends IChartResourceSnapshot<unknown, unknown> = IChartResourceSnapshot, TResource extends IChartResource<TDataSource, TChart> = IChartResource<TDataSource, TChart>> extends Disposable {
+    private readonly _resources;
+    private readonly _dataSourceRemoved$;
+    readonly dataSourceRemoved$: Observable<IChartDataSourceRemovedEvent>;
+    ensureUnitResource(unitId: string): TResource;
+    loadUnit(unitId: string, resource: unknown): TResource;
+    unloadUnit(unitId: string): void;
+    serializeUnit(unitId: string): string;
+    getResource(unitId: string): TResource;
+    getDataSource(unitId: string, dataSourceId: string): TDataSource | undefined;
+    getChart(unitId: string, chartId: string): TChart | undefined;
+    createDataSource(unitId: string, options: ICreateChartDataSourceOptions<TDataSource>): TDataSource;
+    setDataSource(unitId: string, dataSource: TDataSource): TDataSource;
+    updateDataSource(unitId: string, dataSourceId: string, values: ChartDataSourceValue[][], patch?: Partial<Pick<TDataSource, 'name'>>): TDataSource | undefined;
+    removeDataSource(unitId: string, dataSourceId: string): boolean;
+    createChart(unitId: string, options: ICreateChartSnapshotOptions<TChart>): TChart;
+    setChart(unitId: string, chart: TChart): TChart;
+    updateChart(unitId: string, chartId: string, patch: IUpdateChartSnapshotPatch<TChart>): TChart | undefined;
+    removeChart(unitId: string, chartId: string, options?: {
+        cleanupDataSource?: boolean;
+    }): TChart | undefined;
+    getChartIdsByDataSource(unitId: string, dataSourceId: string): string[];
+    getDataSourceSharingCount(unitId: string, dataSourceId: string): number;
+    isDataSourceShared(unitId: string, dataSourceId: string): boolean;
+    duplicateDataSourceForChart(unitId: string, chartId: string, duplicateDataSourceId?: string): TDataSource | undefined;
+    cleanupOrphanedResources(unitId: string): void;
+    dispose(): void;
+    private _decodeResource;
+    private _decodeDataSource;
+    private _cloneDataSource;
+    private _isResourceEnvelope;
+    private _isValues;
+    private _normalizeReference;
+    private _invalidDataSource;
+}
+export {};

package/lib/types/models/chart-host/resource/chart-resource-serializer.d.ts

@@ -1,10 +1,11 @@
 import type { ChartStyle } from '../../../types';
 interface IChartResourceSnapshot {
     style?: ChartStyle;
+    context?: unknown;
 }
 interface IChartResourceEnvelope<TChart extends IChartResourceSnapshot> {
     charts: Record<string, TChart>;
 }
-/** Serializes a host chart resource while omitting non-canonical empty chart palettes. */
+/** Serializes a host chart resource with authored-only persisted chart styles. */
 export declare function serializeChartResource<TChart extends IChartResourceSnapshot, TResource extends IChartResourceEnvelope<TChart>>(resource: TResource): string;
 export {};

package/lib/types/models/chart-host/resource/inline-chart-table.d.ts

@@ -1,4 +1,5 @@
+import type { CellValue } from '@univerjs/core';
 import type { IUniverDataSet } from '../../../types';
-export type InlineChartCellValue = string | number | boolean | null;
-export declare function parseInlineChartTable(text: string): InlineChartCellValue[][];
-export declare function buildInlineChartTableDataSet(values: readonly (readonly InlineChartCellValue[])[]): IUniverDataSet;
+export type ChartDataSourceValue = CellValue | null;
+export declare function parseInlineChartTable(text: string): ChartDataSourceValue[][];
+export declare function buildChartDataSetFromValues(values: readonly (readonly ChartDataSourceValue[])[]): IUniverDataSet;

package/lib/types/models/chart-host/resource/persisted-chart-style.d.ts

@@ -0,0 +1,3 @@
+import type { ChartStyle } from '../../../types';
+/** Projects authored style at the persistence boundary while accepting historical runtime fields. */
+export declare function projectPersistedChartStyle(style: ChartStyle | undefined): ChartStyle | undefined;

package/lib/types/models/chart-host/resource/resource-ref-chart-data-source.adapter.d.ts

@@ -0,0 +1,22 @@
+import type { IResourceRef } from '@univerjs-pro/embed';
+export declare const RESOURCE_REF_CHART_DATA_SOURCE_KIND = "resource-ref";
+export interface IResourceRefChartDataSourceReference {
+    readonly kind: typeof RESOURCE_REF_CHART_DATA_SOURCE_KIND;
+    readonly ref: IResourceRef;
+}
+export interface IResourceRefChartDataSourceInput extends Omit<IResourceRef, 'file'> {
+    readonly file?: IResourceRef['file'];
+}
+interface ICompatibleResourceRefChartDataSourceReference {
+    readonly kind: typeof RESOURCE_REF_CHART_DATA_SOURCE_KIND;
+    readonly ref: IResourceRefChartDataSourceInput;
+}
+export declare class ResourceRefChartDataSourceAdapter {
+    static toReference(ref: IResourceRefChartDataSourceInput): IResourceRefChartDataSourceReference;
+    static isReference(reference: unknown): reference is Readonly<IResourceRefChartDataSourceReference>;
+    static assertReference(reference: unknown): asserts reference is Readonly<ICompatibleResourceRefChartDataSourceReference>;
+    static fromReference(reference: Readonly<ICompatibleResourceRefChartDataSourceReference>): IResourceRef;
+    private static _normalizeInput;
+    private static _isCompatibleReference;
+}
+export {};

package/lib/types/models/chart-host/resource/resource-ref-chart-data-source.provider.d.ts

@@ -0,0 +1,12 @@
+import type { IChartDataSourceProvider, IChartDataSourceResolveResult } from './chart-data-source-resolver';
+import type { IResourceRefChartDataSourceReference } from './resource-ref-chart-data-source.adapter';
+import { Injector } from '@univerjs/core';
+export declare class ResourceRefChartDataSourceProvider implements IChartDataSourceProvider {
+    private readonly _injector;
+    readonly kind = "resource-ref";
+    constructor(_injector: Injector);
+    getCacheKey(source: IResourceRefChartDataSourceReference): string;
+    resolve(source: IResourceRefChartDataSourceReference, options: {
+        signal: AbortSignal;
+    }): Promise<IChartDataSourceResolveResult>;
+}

package/lib/types/models/chart-host/static/chart-model-store.d.ts

@@ -0,0 +1,56 @@
+import type { Injector } from '@univerjs/core';
+import type { Observable } from 'rxjs';
+import type { IChartContext, IUniverDataSet } from '../../../types';
+import type { ChartModel } from '../../chart-model/chart-model';
+import type { IChartDataSourceResolver, IChartDataSourceRuntimeState } from '../resource/chart-data-source-resolver';
+import type { ChartResourceRepository, IChartResource, IChartResourceContext, IChartResourceDataSource, IChartResourceSnapshot } from '../resource/chart-resource-repository';
+import type { ChartDataSourceValue } from '../resource/inline-chart-table';
+import type { IChartRuntime } from './chart-runtime';
+import { Disposable } from '@univerjs/core';
+export interface IChartModelRuntime extends IChartRuntime {
+    unitId: string;
+    chartId: string;
+    dataSourceId: string;
+}
+export declare class ChartModelStore<TDataSource extends IChartResourceDataSource, TChart extends IChartResourceSnapshot<IChartResourceContext, unknown>, TResource extends IChartResource<TDataSource, TChart>, TRuntime extends IChartModelRuntime = IChartModelRuntime> extends Disposable {
+    private readonly _resourceRepository;
+    private readonly _injector;
+    private readonly _buildDataSet;
+    private readonly _dataSourceResolver;
+    private readonly _activeRuntimeModel$;
+    readonly activeRuntimeModel$: Observable<TRuntime | null>;
+    get activeRuntimeModel(): TRuntime | null;
+    private readonly _activeChartModel$;
+    readonly activeChartModel$: Observable<ChartModel<import("../../..").IChartDataSource> | null>;
+    get activeChartModel(): ChartModel | null;
+    private readonly _runtimeModels;
+    private readonly _dataSourceBindings;
+    private readonly _chartModelAdded$;
+    readonly chartModelAdded$: Observable<TRuntime>;
+    private readonly _chartModelRemoved$;
+    readonly chartModelRemoved$: Observable<TRuntime>;
+    constructor(_resourceRepository: ChartResourceRepository<TDataSource, TChart, TResource>, _injector: Injector, _buildDataSet: (values: ReadonlyArray<ReadonlyArray<ChartDataSourceValue>>) => IUniverDataSet, _dataSourceResolver: IChartDataSourceResolver);
+    ensureChartModel(unitId: string, chartId: string): TRuntime | undefined;
+    getChartModel(unitId: string, chartId: string): TRuntime | undefined;
+    getDataSourceRuntimeState$(unitId: string, chartId: string): Observable<IChartDataSourceRuntimeState> | undefined;
+    getDataSourceRuntimeState(unitId: string, chartId: string): IChartDataSourceRuntimeState | undefined;
+    refreshChartDataSource(unitId: string, chartId: string): Promise<void>;
+    setActiveChartRuntime(runtime: TRuntime | null): void;
+    setActiveChartModel(chartModel: ChartModel | null): void;
+    setActiveChartById(unitId: string, chartId: string): TRuntime | null;
+    generateChartModelContext(unitId: string, chartId: string): IChartContext | undefined;
+    refreshChartModel(unitId: string, chartId: string): TRuntime | undefined;
+    refreshChartsByDataSource(unitId: string, dataSourceId: string): TRuntime[];
+    removeChartModel(unitId: string, chartId: string): boolean;
+    removeUnit(unitId: string): void;
+    dispose(): void;
+    protected _createStoredRuntime(runtime: IChartModelRuntime): TRuntime;
+    protected _beforeRuntimeRefresh(_runtime: TRuntime): void;
+    private _bindDataSource;
+    private _releaseBindingsByDataSource;
+    private _releaseHandle;
+    private _disposeBinding;
+    private _disposeUnitBindings;
+    private _disposeRuntime;
+    private _getOrCreateUnitMap;
+}