mdt-charts 1.29.0 → 1.30.0

package/lib/model/modelInstance/titleConfigReader.js

@@ -1,40 +1,33 @@
 import { ModelHelper } from "../helpers/modelHelper";
 export class TitleConfigReader {
-	constructor(config, dataGetter, defaultCssUnitReader) {
-		this.config = config;
-		this.dataGetter = dataGetter;
-		this.defaultCssUnitReader = defaultCssUnitReader;
-	}
-	static create(config, modelInstance) {
-		return new TitleConfigReader(
-			config,
-			() => modelInstance.dataModel.repository.getRawRows(),
-			() => ModelHelper.getFontSizeCssValue("--chart-title-font-size", 16)
-		);
-	}
-	getTextContent() {
-		return this.getResolvedTitle();
-	}
-	getFontSize() {
-		var _a;
-		return typeof this.config === "object"
-			? (_a = this.config.fontSize) !== null && _a !== void 0
-				? _a
-				: this.defaultCssUnitReader()
-			: this.defaultCssUnitReader();
-	}
-	getResolvedTitle() {
-		switch (typeof this.config) {
-			case "string":
-				return this.config;
-			case "function":
-				return this.config({ data: this.dataGetter() });
-			case "object":
-				return typeof this.config.text === "function"
-					? this.config.text({ data: this.dataGetter() })
-					: this.config.text;
-			default:
-				return "";
-		}
-	}
+    constructor(config, dataGetter, defaultCssUnitReader) {
+        this.config = config;
+        this.dataGetter = dataGetter;
+        this.defaultCssUnitReader = defaultCssUnitReader;
+    }
+    static create(config, modelInstance) {
+        return new TitleConfigReader(config, () => modelInstance.dataModel.repository.getRawRows(), () => ModelHelper.getFontSizeCssValue("--chart-title-font-size", 16));
+    }
+    getTextContent() {
+        return this.getResolvedTitle();
+    }
+    getFontSize() {
+        var _a;
+        return typeof this.config === "object"
+            ? (_a = this.config.fontSize) !== null && _a !== void 0 ? _a : this.defaultCssUnitReader() : this.defaultCssUnitReader();
+    }
+    getResolvedTitle() {
+        switch (typeof this.config) {
+            case "string":
+                return this.config;
+            case "function":
+                return this.config({ data: this.dataGetter() });
+            case "object":
+                return typeof this.config.text === "function"
+                    ? this.config.text({ data: this.dataGetter() })
+                    : this.config.text;
+            default:
+                return "";
+        }
+    }
 }

package/lib/model/notations/polar/donut/donutAggregatorService.d.ts

@@ -2,15 +2,12 @@ import { MdtChartsDataRow, MdtChartsDonutAggregator } from "../../../../config/c
 import { DonutAggregatorContent } from "../../../model";
 export declare const AGGREGATOR_DEFAULT_TITLE = "\u0421\u0443\u043C\u043C\u0430";
 export interface AggregatorServiceDataOptions {
-	rows: MdtChartsDataRow[];
-	valueFieldName: string;
+    rows: MdtChartsDataRow[];
+    valueFieldName: string;
 }
 export declare class DonutAggregatorService {
-	getContent(
-		aggregatorOptions: MdtChartsDonutAggregator,
-		dataOptions: AggregatorServiceDataOptions
-	): DonutAggregatorContent;
-	private doesValueExist;
-	private generateDefaultContent;
-	private getDefaultValue;
+    getContent(aggregatorOptions: MdtChartsDonutAggregator, dataOptions: AggregatorServiceDataOptions): DonutAggregatorContent;
+    private doesValueExist;
+    private generateDefaultContent;
+    private getDefaultValue;
 }

package/lib/model/notations/polar/donut/donutAggregatorService.js

@@ -1,43 +1,40 @@
 export const AGGREGATOR_DEFAULT_TITLE = "Сумма";
 export class DonutAggregatorService {
-	getContent(aggregatorOptions, dataOptions) {
-		if (
-			!(aggregatorOptions === null || aggregatorOptions === void 0 ? void 0 : aggregatorOptions.content) ||
-			!dataOptions.rows
-		)
-			return this.generateDefaultContent(dataOptions);
-		const content = aggregatorOptions.content({ data: dataOptions.rows });
-		if (!content || (!this.doesValueExist(content.value) && !content.title))
-			return this.generateDefaultContent(dataOptions);
-		if (this.doesValueExist(content.value) && content.title) {
-			return {
-				title: content.title,
-				value: content.value
-			};
-		}
-		if (!content.title && this.doesValueExist(content.value))
-			return {
-				value: content.value,
-				title: AGGREGATOR_DEFAULT_TITLE
-			};
-		if (!this.doesValueExist(content.value) && content.title) {
-			return {
-				value: this.getDefaultValue(dataOptions),
-				title: content.title
-			};
-		}
-	}
-	doesValueExist(content) {
-		return content != null;
-	}
-	generateDefaultContent(dataOptions) {
-		return {
-			title: AGGREGATOR_DEFAULT_TITLE,
-			value: dataOptions.rows ? this.getDefaultValue(dataOptions) : 0
-		};
-	}
-	getDefaultValue(dataOptions) {
-		const totalSumOfValues = dataOptions.rows.reduce((acc, row) => acc + row[dataOptions.valueFieldName], 0);
-		return totalSumOfValues;
-	}
+    getContent(aggregatorOptions, dataOptions) {
+        if (!(aggregatorOptions === null || aggregatorOptions === void 0 ? void 0 : aggregatorOptions.content) || !dataOptions.rows)
+            return this.generateDefaultContent(dataOptions);
+        const content = aggregatorOptions.content({ data: dataOptions.rows });
+        if (!content || (!this.doesValueExist(content.value) && !content.title))
+            return this.generateDefaultContent(dataOptions);
+        if (this.doesValueExist(content.value) && content.title) {
+            return {
+                title: content.title,
+                value: content.value
+            };
+        }
+        if (!content.title && this.doesValueExist(content.value))
+            return {
+                value: content.value,
+                title: AGGREGATOR_DEFAULT_TITLE
+            };
+        if (!this.doesValueExist(content.value) && content.title) {
+            return {
+                value: this.getDefaultValue(dataOptions),
+                title: content.title
+            };
+        }
+    }
+    doesValueExist(content) {
+        return content != null;
+    }
+    generateDefaultContent(dataOptions) {
+        return {
+            title: AGGREGATOR_DEFAULT_TITLE,
+            value: dataOptions.rows ? this.getDefaultValue(dataOptions) : 0
+        };
+    }
+    getDefaultValue(dataOptions) {
+        const totalSumOfValues = dataOptions.rows.reduce((acc, row) => acc + row[dataOptions.valueFieldName], 0);
+        return totalSumOfValues;
+    }
 }

package/lib/model/notations/polar/donut/donutModel.d.ts

@@ -2,13 +2,9 @@ import { MdtChartsDataRow, PolarChart } from "../../../../config/config";
 import { DonutOptionsCanvas } from "../../../../designer/designerConfig";
 import { DonutChartSettings } from "../../../model";
 export declare class DonutModel {
-	private thicknessService;
-	private aggregatorService;
-	getSettings(
-		settingsFromConfig: DonutOptionsCanvas,
-		chartOptions: PolarChart,
-		rawDataRows: MdtChartsDataRow[]
-	): DonutChartSettings;
-	private getThicknessOptions;
-	private getAggregatorOptions;
+    private thicknessService;
+    private aggregatorService;
+    getSettings(settingsFromConfig: DonutOptionsCanvas, chartOptions: PolarChart, rawDataRows: MdtChartsDataRow[]): DonutChartSettings;
+    private getThicknessOptions;
+    private getAggregatorOptions;
 }

package/lib/model/notations/polar/donut/donutModel.js

@@ -1,32 +1,32 @@
 import { DonutAggregatorService } from "./donutAggregatorService";
 import { DonutThicknessService } from "./donutThicknessService";
 export class DonutModel {
-	constructor() {
-		this.thicknessService = new DonutThicknessService();
-		this.aggregatorService = new DonutAggregatorService();
-	}
-	getSettings(settingsFromConfig, chartOptions, rawDataRows) {
-		return {
-			padAngle: settingsFromConfig.padAngle,
-			thickness: this.getThicknessOptions(settingsFromConfig.thickness),
-			aggregator: this.getAggregatorOptions(settingsFromConfig, chartOptions, rawDataRows)
-		};
-	}
-	getThicknessOptions(settingsFromConfig) {
-		return {
-			unit: this.thicknessService.getUnit(settingsFromConfig),
-			max: this.thicknessService.valueToNumber(settingsFromConfig.max),
-			min: this.thicknessService.valueToNumber(settingsFromConfig.min),
-			value: this.thicknessService.valueToNumber(settingsFromConfig.value)
-		};
-	}
-	getAggregatorOptions(settingsFromConfig, chartOptions, rawDataRows) {
-		return {
-			margin: settingsFromConfig.aggregatorPad,
-			content: this.aggregatorService.getContent(chartOptions.aggregator, {
-				rows: rawDataRows,
-				valueFieldName: chartOptions.data.valueField.name
-			})
-		};
-	}
+    constructor() {
+        this.thicknessService = new DonutThicknessService();
+        this.aggregatorService = new DonutAggregatorService();
+    }
+    getSettings(settingsFromConfig, chartOptions, rawDataRows) {
+        return {
+            padAngle: settingsFromConfig.padAngle,
+            thickness: this.getThicknessOptions(settingsFromConfig.thickness),
+            aggregator: this.getAggregatorOptions(settingsFromConfig, chartOptions, rawDataRows)
+        };
+    }
+    getThicknessOptions(settingsFromConfig) {
+        return {
+            unit: this.thicknessService.getUnit(settingsFromConfig),
+            max: this.thicknessService.valueToNumber(settingsFromConfig.max),
+            min: this.thicknessService.valueToNumber(settingsFromConfig.min),
+            value: this.thicknessService.valueToNumber(settingsFromConfig.value)
+        };
+    }
+    getAggregatorOptions(settingsFromConfig, chartOptions, rawDataRows) {
+        return {
+            margin: settingsFromConfig.aggregatorPad,
+            content: this.aggregatorService.getContent(chartOptions.aggregator, {
+                rows: rawDataRows,
+                valueFieldName: chartOptions.data.valueField.name
+            })
+        };
+    }
 }

package/lib/model/notations/polar/donut/donutThicknessService.d.ts

@@ -1,7 +1,7 @@
 import { MdtChartsDonutThicknessOptions } from "../../../../designer/designerConfig";
 import { DonutThicknessUnit } from "../../../model";
 export declare class DonutThicknessService {
-	private defaultUnit;
-	getUnit(settingsFromConfig: MdtChartsDonutThicknessOptions): DonutThicknessUnit;
-	valueToNumber(value: string | number): number;
+    private defaultUnit;
+    getUnit(settingsFromConfig: MdtChartsDonutThicknessOptions): DonutThicknessUnit;
+    valueToNumber(value: string | number): number;
 }

package/lib/model/notations/polar/donut/donutThicknessService.js

@@ -1,16 +1,18 @@
 import { getPxPercentUnitByValue } from "../../../helpers/unitsFromConfigReader";
 export class DonutThicknessService {
-	constructor() {
-		this.defaultUnit = "px";
-	}
-	getUnit(settingsFromConfig) {
-		if (settingsFromConfig.value) return getPxPercentUnitByValue(settingsFromConfig.value);
-		const minUnit = getPxPercentUnitByValue(settingsFromConfig.min);
-		const maxUnit = getPxPercentUnitByValue(settingsFromConfig.max);
-		return minUnit === maxUnit ? minUnit : this.defaultUnit;
-	}
-	valueToNumber(value) {
-		if (typeof value === "number") return value;
-		return parseInt(value);
-	}
+    constructor() {
+        this.defaultUnit = "px";
+    }
+    getUnit(settingsFromConfig) {
+        if (settingsFromConfig.value)
+            return getPxPercentUnitByValue(settingsFromConfig.value);
+        const minUnit = getPxPercentUnitByValue(settingsFromConfig.min);
+        const maxUnit = getPxPercentUnitByValue(settingsFromConfig.max);
+        return minUnit === maxUnit ? minUnit : this.defaultUnit;
+    }
+    valueToNumber(value) {
+        if (typeof value === "number")
+            return value;
+        return parseInt(value);
+    }
 }

package/lib/model/notations/polar/polarModel.d.ts

@@ -5,22 +5,11 @@ import { CanvasModel } from "../../modelInstance/canvasModel/canvasModel";
 import { ModelInstance } from "../../modelInstance/modelInstance";
 export declare const MIN_DONUT_BLOCK_SIZE = 120;
 export declare class PolarModel {
-	private static donutModel;
-	static getOptions(
-		options: MdtChartsPolarOptions,
-		designerConfig: DesignerConfig,
-		modelInstance: ModelInstance
-	): PolarOptionsModel;
-	static getLegendPositionByBlockSize(canvasModel: CanvasModel): "bottom" | "right";
-	static doesChartBlockHasEnoughWidthForContainsLegend(
-		chartBlockWidth: number,
-		legendWidth: number,
-		legendCoordinate: LegendCoordinate
-	): boolean;
-	static doesChartBlockHasEnoughHeightForContainsLegend(
-		chartBlockHeight: number,
-		legendCoordinate: LegendCoordinate
-	): boolean;
-	private static getDonutSettings;
-	private static getChartsModel;
+    private static donutModel;
+    static getOptions(options: MdtChartsPolarOptions, designerConfig: DesignerConfig, modelInstance: ModelInstance): PolarOptionsModel;
+    static getLegendPositionByBlockSize(canvasModel: CanvasModel): "bottom" | "right";
+    static doesChartBlockHasEnoughWidthForContainsLegend(chartBlockWidth: number, legendWidth: number, legendCoordinate: LegendCoordinate): boolean;
+    static doesChartBlockHasEnoughHeightForContainsLegend(chartBlockHeight: number, legendCoordinate: LegendCoordinate): boolean;
+    private static getDonutSettings;
+    private static getChartsModel;
 }

package/lib/model/notations/polar/polarModel.js

@@ -1,86 +1,79 @@
 import { ChartStyleModelService } from "../../chartStyleModel/chartStyleModel";
 import { DonutModel } from "./donut/donutModel";
 import { TitleConfigReader } from "../../modelInstance/titleConfigReader";
+import { createRecordOverflowModel } from "../../featuresModel/recordOverflowModel/recordOverflowModel";
 export const MIN_DONUT_BLOCK_SIZE = 120;
 export class PolarModel {
-	static getOptions(options, designerConfig, modelInstance) {
-		const titleConfig = TitleConfigReader.create(options.title, modelInstance);
-		return {
-			type: options.type,
-			selectable: !!options.selectable,
-			title: {
-				textContent: titleConfig.getTextContent(),
-				fontSize: titleConfig.getFontSize()
-			},
-			data: Object.assign({}, options.data),
-			charts: this.getChartsModel(
-				options.chart,
-				modelInstance.dataModel.repository.getScopedRows().length,
-				designerConfig.chartStyle
-			),
-			legend: modelInstance.canvasModel.legendCanvas.getModel(),
-			tooltip: options.tooltip,
-			chartCanvas: this.getDonutSettings(
-				designerConfig.canvas.chartOptions.donut,
-				options.chart,
-				modelInstance.dataModel.repository.getRawRows()
-			),
-			defs: { gradients: [] }
-		};
-	}
-	//TODO: type for returned value
-	static getLegendPositionByBlockSize(canvasModel) {
-		const widthCoefficientWhenLegendShouldInBottom = 1.5;
-		const avgLegendWidth = 100;
-		const blockWidth = canvasModel.getBlockSize().width;
-		const blockHeight = canvasModel.getBlockSize().height;
-		return canvasModel.getChartBlockWidth() < MIN_DONUT_BLOCK_SIZE + avgLegendWidth &&
-			blockWidth * widthCoefficientWhenLegendShouldInBottom < blockHeight
-			? "bottom"
-			: "right";
-	}
-	static doesChartBlockHasEnoughWidthForContainsLegend(chartBlockWidth, legendWidth, legendCoordinate) {
-		const rightLegendMargin = legendCoordinate.right.margin;
-		return chartBlockWidth - legendWidth - rightLegendMargin.left - rightLegendMargin.right >= MIN_DONUT_BLOCK_SIZE;
-	}
-	static doesChartBlockHasEnoughHeightForContainsLegend(chartBlockHeight, legendCoordinate) {
-		const minHeightForLegend = 30;
-		const bottomLegendMargin = legendCoordinate.bottom.margin;
-		const heightForLegend =
-			chartBlockHeight - bottomLegendMargin.bottom - bottomLegendMargin.top - MIN_DONUT_BLOCK_SIZE;
-		return heightForLegend >= minHeightForLegend;
-	}
-	static getDonutSettings(settings, chartOptions, dataRows) {
-		return this.donutModel.getSettings(settings, chartOptions, dataRows);
-	}
-	static getChartsModel(chart, dataLength, chartStyleConfig) {
-		const chartsModel = [];
-		chartsModel.push({
-			type: chart.type,
-			data: Object.assign({}, chart.data),
-			tooltip: { show: true },
-			cssClasses: ChartStyleModelService.getCssClasses(0),
-			style: ChartStyleModelService.getChartStyle(dataLength, chartStyleConfig),
-			legend: {
-				markerShape: "default",
-				barViewOptions: {
-					hatch: { on: false },
-					borderRadius: {
-						topLeft: 0,
-						topRight: 0,
-						bottomLeft: 0,
-						bottomRight: 0
-					},
-					width: 0
-				},
-				lineViewOptions: {
-					dashedStyles: { on: false, dashSize: 0, gapSize: 0 },
-					strokeWidth: 0,
-					length: 0
-				}
-			}
-		});
-		return chartsModel;
-	}
+    static getOptions(options, designerConfig, modelInstance) {
+        const titleConfig = TitleConfigReader.create(options.title, modelInstance);
+        return {
+            type: options.type,
+            selectable: !!options.selectable,
+            title: {
+                textContent: titleConfig.getTextContent(),
+                fontSize: titleConfig.getFontSize()
+            },
+            data: Object.assign({}, options.data),
+            charts: this.getChartsModel(options.chart, modelInstance.dataModel.repository.getScopedRows().length, designerConfig.chartStyle),
+            legend: modelInstance.canvasModel.legendCanvas.getModel(),
+            tooltip: options.tooltip,
+            chartCanvas: this.getDonutSettings(designerConfig.canvas.chartOptions.donut, options.chart, modelInstance.dataModel.repository.getRawRows()),
+            defs: { gradients: [] },
+            recordOverflowAlert: createRecordOverflowModel(modelInstance.dataModel.getScope().hidedRecordsAmount, {
+                one: "категория",
+                twoToFour: "категории",
+                tenToTwenty: "категорий",
+                other: "категорий"
+            }, options.recordOverflowAlert)
+        };
+    }
+    //TODO: type for returned value
+    static getLegendPositionByBlockSize(canvasModel) {
+        const widthCoefficientWhenLegendShouldInBottom = 1.5;
+        const avgLegendWidth = 100;
+        const blockWidth = canvasModel.getBlockSize().width;
+        const blockHeight = canvasModel.getBlockSize().height;
+        return canvasModel.getChartBlockWidth() < MIN_DONUT_BLOCK_SIZE + avgLegendWidth &&
+            blockWidth * widthCoefficientWhenLegendShouldInBottom < blockHeight
+            ? "bottom"
+            : "right";
+    }
+    static doesChartBlockHasEnoughWidthForContainsLegend(chartBlockWidth, legendWidth, legendCoordinate) {
+        const rightLegendMargin = legendCoordinate.right.margin;
+        return chartBlockWidth - legendWidth - rightLegendMargin.left - rightLegendMargin.right >= MIN_DONUT_BLOCK_SIZE;
+    }
+    static doesChartBlockHasEnoughHeightForContainsLegend(chartBlockHeight, legendCoordinate) {
+        const minHeightForLegend = 30;
+        const bottomLegendMargin = legendCoordinate.bottom.margin;
+        const heightForLegend = chartBlockHeight - bottomLegendMargin.bottom - bottomLegendMargin.top - MIN_DONUT_BLOCK_SIZE;
+        return heightForLegend >= minHeightForLegend;
+    }
+    static getDonutSettings(settings, chartOptions, dataRows) {
+        return this.donutModel.getSettings(settings, chartOptions, dataRows);
+    }
+    static getChartsModel(chart, dataLength, chartStyleConfig) {
+        const chartsModel = [];
+        chartsModel.push({
+            type: chart.type,
+            data: Object.assign({}, chart.data),
+            tooltip: { show: true },
+            cssClasses: ChartStyleModelService.getCssClasses(0),
+            style: ChartStyleModelService.getChartStyle(dataLength, chartStyleConfig),
+            legend: {
+                markerShape: "default",
+                barViewOptions: {
+                    hatch: { on: false },
+                    borderRadius: { topLeft: 0, topRight: 0, bottomLeft: 0, bottomRight: 0 },
+                    width: 0
+                },
+                lineViewOptions: {
+                    dashedStyles: { on: false, dashSize: 0, gapSize: 0 },
+                    strokeWidth: 0,
+                    length: 0
+                }
+            }
+        });
+        return chartsModel;
+    }
 }
 PolarModel.donutModel = new DonutModel();

package/lib/model/notations/twoDimensional/styles.d.ts

@@ -1,51 +1,14 @@
-import {
-	AreaChartViewOptions,
-	BarBorderRadius,
-	ChartLegendModel,
-	ChartStyle,
-	GradientId,
-	LineLikeChartDashOptions,
-	LineLikeChartShapeOptions,
-	Orient,
-	TwoDimensionalBarLikeChartViewModel,
-	TwoDimensionalChartLegendLineModel
-} from "../../model";
-import {
-	ChartOrientation,
-	MdtChartsLineLikeChartDashedStyles,
-	MdtChartsTwoDimensionalChart,
-	TwoDimensionalChartType
-} from "../../../config/config";
+import { AreaChartViewOptions, BarBorderRadius, ChartLegendModel, ChartStyle, GradientId, LineLikeChartDashOptions, LineLikeChartShapeOptions, Orient, TwoDimensionalBarLikeChartViewModel, TwoDimensionalChartLegendLineModel } from "../../model";
+import { ChartOrientation, MdtChartsLineLikeChartDashedStyles, MdtChartsTwoDimensionalChart, TwoDimensionalChartType } from "../../../config/config";
 import { MdtChartsLineLikeChartShape } from "../../../designer/designerConfig";
 export declare const LINE_CHART_DEFAULT_WIDTH = 2;
-export declare function parseShape(
-	chartOrientation: ChartOrientation,
-	configOptions?: MdtChartsLineLikeChartShape
-): LineLikeChartShapeOptions;
+export declare function parseShape(chartOrientation: ChartOrientation, configOptions?: MdtChartsLineLikeChartShape): LineLikeChartShapeOptions;
 export declare function parseDashStyles(configOptions?: MdtChartsLineLikeChartDashedStyles): LineLikeChartDashOptions;
-export declare function getBarViewOptions(
-	chart: MdtChartsTwoDimensionalChart,
-	keyAxisOrient: Orient,
-	barIndexes: number[]
-): TwoDimensionalBarLikeChartViewModel;
-export declare function calculateBarIndexes(
-	allCharts: Pick<MdtChartsTwoDimensionalChart, "isSegmented" | "data" | "type">[],
-	currentChart: Pick<MdtChartsTwoDimensionalChart, "isSegmented" | "data" | "type">,
-	currentChartIndex: number
-): number[];
-export declare function getSegmentedRadiusValues(
-	segmentsLength: number,
-	segmentIndex: number,
-	keyAxisOrient: Orient,
-	defaultRadius: number
-): BarBorderRadius;
+export declare function getBarViewOptions(chart: MdtChartsTwoDimensionalChart, keyAxisOrient: Orient, barIndexes: number[]): TwoDimensionalBarLikeChartViewModel;
+export declare function calculateBarIndexes(allCharts: Pick<MdtChartsTwoDimensionalChart, "isSegmented" | "data" | "type">[], currentChart: Pick<MdtChartsTwoDimensionalChart, "isSegmented" | "data" | "type">, currentChartIndex: number): number[];
+export declare function getSegmentedRadiusValues(segmentsLength: number, segmentIndex: number, keyAxisOrient: Orient, defaultRadius: number): BarBorderRadius;
 export declare function getLegendMarkerOptions(chart: MdtChartsTwoDimensionalChart): ChartLegendModel;
 export declare function getLineViewOptions(chart: MdtChartsTwoDimensionalChart): TwoDimensionalChartLegendLineModel;
 export declare function getWidthOfLegendMarkerByType(chartType: TwoDimensionalChartType): number;
-export declare function getAreaViewOptions(
-	chart: MdtChartsTwoDimensionalChart,
-	chartIndex: number,
-	style: ChartStyle,
-	chartBlockId: number
-): AreaChartViewOptions;
+export declare function getAreaViewOptions(chart: MdtChartsTwoDimensionalChart, chartIndex: number, style: ChartStyle, chartBlockId: number): AreaChartViewOptions;
 export declare function getGradientId(chartIndex: number, subIndex: number, chartBlockId: number): GradientId;