mdt-charts 1.28.2 → 1.29.0

package/lib/model/dataManagerModel/dataManagerModel.d.ts

@@ -3,32 +3,42 @@ import { DesignerConfig } from "../../designer/designerConfig";
 import { LegendBlockModel } from "../model";
 import { ModelInstance } from "../modelInstance/modelInstance";
 export interface DataLegendParams {
-    amount: number;
-    size: {
-        width: number;
-        height: number;
-    };
+	amount: number;
+	size: {
+		width: number;
+		height: number;
+	};
 }
 export declare class DataManagerModel {
-    private static service;
-    private static polarMarginCalculator;
-    static getPreparedData(data: MdtChartsDataSource, allowableKeys: string[], config: MdtChartsConfig): MdtChartsDataSource;
-    static initDataScope(config: MdtChartsConfig, data: MdtChartsDataSource, designerConfig: DesignerConfig, legendBlock: LegendBlockModel, modelInstance: ModelInstance): void;
-    private static initScopedData;
-    static getDataValuesByKeyField(data: MdtChartsDataSource, dataSourceName: string, keyFieldName: string): string[];
-    private static initDataScopeFor2D;
-    private static initDataScopeForPolar;
-    private static getLegendDataParams;
-    private static getMaximumPossibleScope;
-    private static limitAllowableKeys;
-    /**
-     * Выводит количество элементов (преимущественно баров) в одной группе. Группа - один ключ
-     * @param configOptions
-     * @param chartsLength
-     */
-    private static getElementsInGroupAmount;
-    private static getBarLikeChartsInGroupAmount;
-    private static getScopedData;
-    private static getScopedChartData;
-    private static getDataLimitByItemSize;
+	private static service;
+	private static polarMarginCalculator;
+	static getPreparedData(
+		data: MdtChartsDataSource,
+		allowableKeys: string[],
+		config: MdtChartsConfig
+	): MdtChartsDataSource;
+	static initDataScope(
+		config: MdtChartsConfig,
+		data: MdtChartsDataSource,
+		designerConfig: DesignerConfig,
+		legendBlock: LegendBlockModel,
+		modelInstance: ModelInstance
+	): void;
+	private static initScopedData;
+	static getDataValuesByKeyField(data: MdtChartsDataSource, dataSourceName: string, keyFieldName: string): string[];
+	private static initDataScopeFor2D;
+	private static initDataScopeForPolar;
+	private static getLegendDataParams;
+	private static getMaximumPossibleScope;
+	private static limitAllowableKeys;
+	/**
+	 * Выводит количество элементов (преимущественно баров) в одной группе. Группа - один ключ
+	 * @param configOptions
+	 * @param chartsLength
+	 */
+	private static getElementsInGroupAmount;
+	private static getBarLikeChartsInGroupAmount;
+	private static getScopedData;
+	private static getScopedChartData;
+	private static getDataLimitByItemSize;
 }

package/lib/model/dataManagerModel/dataManagerModel.js

@@ -6,134 +6,185 @@ import { DataManagerModelService } from "./dataManagerModelService";
 import { LegendPolarMarginCalculator } from "../featuresModel/legendModel/polarMarginCalculator";
 import { styledElementValues } from "../modelBuilder";
 export class DataManagerModel {
-    static getPreparedData(data, allowableKeys, config) {
-        const scopedData = this.getScopedData(data, allowableKeys, config.options.data);
-        return scopedData;
-    }
-    static initDataScope(config, data, designerConfig, legendBlock, modelInstance) {
-        if (config.options.type === "2d") {
-            this.initDataScopeFor2D(config.options, modelInstance, data, designerConfig);
-        }
-        else if (config.options.type === "polar") {
-            this.initDataScopeForPolar(config.options, modelInstance, data, legendBlock, designerConfig.canvas.legendBlock);
-        }
-        this.initScopedData(data, modelInstance, config);
-    }
-    static initScopedData(data, modelInstance, config) {
-        const preparedData = DataManagerModel.getPreparedData(data, modelInstance.dataModel.getAllowableKeys(), config);
-        modelInstance.dataModel.repository.initScopedFullSource(preparedData);
-    }
-    static getDataValuesByKeyField(data, dataSourceName, keyFieldName) {
-        return data[dataSourceName].map((dataRow) => dataRow[keyFieldName]);
-    }
-    static initDataScopeFor2D(configOptions, modelInstance, data, designerConfig) {
-        modelInstance.dataModel.initMaxRecordsAmount(configOptions.data.maxRecordsAmount);
-        const axisLength = AxisModel.getAxisLength(configOptions.orientation, modelInstance.canvasModel);
-        const uniqueKeys = ModelHelper.getUniqueValues(data[configOptions.data.dataSource].map((d) => d[configOptions.data.keyField.name]));
-        const dataLength = uniqueKeys.length;
-        const limit = this.getDataLimitByItemSize(this.getElementsInGroupAmount(configOptions), dataLength, axisLength, designerConfig.canvas.chartOptions.bar);
-        const allowableKeys = uniqueKeys.slice(0, limit);
-        const hidedRecordsAmount = dataLength - allowableKeys.length;
-        modelInstance.dataModel.initScope(this.limitAllowableKeys(allowableKeys, hidedRecordsAmount, modelInstance.dataModel));
-    }
-    static initDataScopeForPolar(configOptions, modelInstance, data, legendBlock, legendCanvas) {
-        modelInstance.dataModel.initMaxRecordsAmount(configOptions.data.maxRecordsAmount);
-        const canvasModel = modelInstance.canvasModel;
-        const keyFieldName = configOptions.data.keyField.name;
-        const keys = data[configOptions.data.dataSource].map((dataRow) => dataRow[keyFieldName]);
-        if (!configOptions.legend.show) {
-            canvasModel.legendCanvas.setPosition("off");
-            modelInstance.dataModel.initScope(this.getMaximumPossibleScope(keys, modelInstance.dataModel));
-            return;
-        }
-        let position = PolarModel.getLegendPositionByBlockSize(modelInstance.canvasModel);
-        let { amount: maxItemsNumber, size } = this.getLegendDataParams(position, keys, legendCanvas, canvasModel, legendBlock);
-        if (position === "right" &&
-            !PolarModel.doesChartBlockHasEnoughWidthForContainsLegend(canvasModel.getChartBlockWidth(), size.width, legendBlock.coordinate)) {
-            const doesFreeSpaceExist = PolarModel.doesChartBlockHasEnoughHeightForContainsLegend(canvasModel.getChartBlockHeight(), legendBlock.coordinate);
-            if (doesFreeSpaceExist) {
-                const newParams = this.getLegendDataParams("bottom", keys, legendCanvas, canvasModel, legendBlock);
-                position = "bottom";
-                maxItemsNumber = newParams.amount;
-                size = newParams.size;
-            }
-        }
-        //TODO: global refactor of method
-        const allowableKeys = keys.slice(0, maxItemsNumber);
-        const hidedRecordsAmount = keys.length - maxItemsNumber;
-        canvasModel.legendCanvas.setPosition(position);
-        this.polarMarginCalculator.updateMargin(position, canvasModel, legendBlock, position === "bottom" ? size.height : size.width);
-        modelInstance.dataModel.initScope(this.limitAllowableKeys(allowableKeys, hidedRecordsAmount, modelInstance.dataModel));
-    }
-    //TODO: position type
-    static getLegendDataParams(position, keys, legendCanvas, canvasModel, legendBlock) {
-        const legendItemContentOptions = keys.map((k) => ({
-            text: k,
-            markerSize: styledElementValues.defaultLegendMarkerSizes,
-            wrapperSize: { marginRightPx: styledElementValues.legend.inlineDynamicItemWrapperMarginRightPx }
-        }));
-        if (position === "right") {
-            return LegendCanvasModel.findElementsAmountByLegendSize(legendItemContentOptions, position, this.polarMarginCalculator.getMaxLegendWidth(legendCanvas, canvasModel.getBlockSize().width), canvasModel.getChartBlockHeight() - legendBlock.coordinate.right.margin.bottom);
-        }
-        else {
-            return LegendCanvasModel.findElementsAmountByLegendSize(legendItemContentOptions, position, canvasModel.getChartBlockWidth() -
-                legendBlock.coordinate.bottom.margin.left -
-                legendBlock.coordinate.bottom.margin.right, canvasModel.getChartBlockHeight() -
-                legendBlock.coordinate.bottom.margin.bottom -
-                legendBlock.coordinate.bottom.margin.top -
-                MIN_DONUT_BLOCK_SIZE);
-        }
-    }
-    static getMaximumPossibleScope(keys, dataModel) {
-        return this.service.getMaximumPossibleAmount(keys, dataModel.getMaxRecordsAmount());
-    }
-    static limitAllowableKeys(allowableKeys, hidedRecordsAmount, dataModel) {
-        return this.service.limitAllowableKeys(allowableKeys, hidedRecordsAmount, dataModel.getMaxRecordsAmount());
-    }
-    /**
-     * Выводит количество элементов (преимущественно баров) в одной группе. Группа - один ключ
-     * @param configOptions
-     * @param chartsLength
-     */
-    static getElementsInGroupAmount(configOptions) {
-        const bars = this.getBarLikeChartsInGroupAmount(configOptions.charts, "bar");
-        const dots = configOptions.charts.some((chart) => chart.type === "dot") ? 1 : 0;
-        return Math.max(bars, dots);
-    }
-    static getBarLikeChartsInGroupAmount(charts, type) {
-        let barsAmount = 0;
-        charts.forEach((chart) => {
-            if (chart.type === type && chart.isSegmented)
-                barsAmount += 1; // в сегментированном баре все valueFields находятся внутри одного бара, поэтому бар всегда один.
-            else if (chart.type === type)
-                barsAmount += chart.data.valueFields.length;
-        });
-        return barsAmount;
-    }
-    static getScopedData(data, allowableKeys, dataOptions) {
-        const newData = {};
-        newData[dataOptions.dataSource] = this.getScopedChartData(data[dataOptions.dataSource], allowableKeys, dataOptions.keyField.name);
-        return newData;
-    }
-    static getScopedChartData(data, allowableKeys, keyFieldName) {
-        return data.filter((d) => allowableKeys.findIndex((key) => key === d[keyFieldName]) !== -1);
-    }
-    static getDataLimitByItemSize(elementsInGroupAmount, dataLength, axisLength, barOptions) {
-        let sumSize = dataLength *
-            (elementsInGroupAmount * barOptions.minBarWidth +
-                (elementsInGroupAmount - 1) * barOptions.barDistance +
-                barOptions.groupMinDistance);
-        while (dataLength !== 0 && axisLength < sumSize) {
-            dataLength--;
-            // find whole space for bars in group + distance between bars + group distance
-            sumSize =
-                dataLength *
-                    (elementsInGroupAmount * barOptions.minBarWidth +
-                        (elementsInGroupAmount - 1) * barOptions.barDistance +
-                        barOptions.groupMinDistance);
-        }
-        return dataLength;
-    }
+	static getPreparedData(data, allowableKeys, config) {
+		const scopedData = this.getScopedData(data, allowableKeys, config.options.data);
+		return scopedData;
+	}
+	static initDataScope(config, data, designerConfig, legendBlock, modelInstance) {
+		if (config.options.type === "2d") {
+			this.initDataScopeFor2D(config.options, modelInstance, data, designerConfig);
+		} else if (config.options.type === "polar") {
+			this.initDataScopeForPolar(
+				config.options,
+				modelInstance,
+				data,
+				legendBlock,
+				designerConfig.canvas.legendBlock
+			);
+		}
+		this.initScopedData(data, modelInstance, config);
+	}
+	static initScopedData(data, modelInstance, config) {
+		const preparedData = DataManagerModel.getPreparedData(data, modelInstance.dataModel.getAllowableKeys(), config);
+		modelInstance.dataModel.repository.initScopedFullSource(preparedData);
+	}
+	static getDataValuesByKeyField(data, dataSourceName, keyFieldName) {
+		return data[dataSourceName].map((dataRow) => dataRow[keyFieldName]);
+	}
+	static initDataScopeFor2D(configOptions, modelInstance, data, designerConfig) {
+		modelInstance.dataModel.initMaxRecordsAmount(configOptions.data.maxRecordsAmount);
+		const axisLength = AxisModel.getAxisLength(configOptions.orientation, modelInstance.canvasModel);
+		const uniqueKeys = ModelHelper.getUniqueValues(
+			data[configOptions.data.dataSource].map((d) => d[configOptions.data.keyField.name])
+		);
+		const dataLength = uniqueKeys.length;
+		const limit = this.getDataLimitByItemSize(
+			this.getElementsInGroupAmount(configOptions),
+			dataLength,
+			axisLength,
+			designerConfig.canvas.chartOptions.bar
+		);
+		const allowableKeys = uniqueKeys.slice(0, limit);
+		const hidedRecordsAmount = dataLength - allowableKeys.length;
+		modelInstance.dataModel.initScope(
+			this.limitAllowableKeys(allowableKeys, hidedRecordsAmount, modelInstance.dataModel)
+		);
+	}
+	static initDataScopeForPolar(configOptions, modelInstance, data, legendBlock, legendCanvas) {
+		modelInstance.dataModel.initMaxRecordsAmount(configOptions.data.maxRecordsAmount);
+		const canvasModel = modelInstance.canvasModel;
+		const keyFieldName = configOptions.data.keyField.name;
+		const keys = data[configOptions.data.dataSource].map((dataRow) => dataRow[keyFieldName]);
+		if (!configOptions.legend.show) {
+			canvasModel.legendCanvas.setPosition("off");
+			modelInstance.dataModel.initScope(this.getMaximumPossibleScope(keys, modelInstance.dataModel));
+			return;
+		}
+		let position = PolarModel.getLegendPositionByBlockSize(modelInstance.canvasModel);
+		let { amount: maxItemsNumber, size } = this.getLegendDataParams(
+			position,
+			keys,
+			legendCanvas,
+			canvasModel,
+			legendBlock
+		);
+		if (
+			position === "right" &&
+			!PolarModel.doesChartBlockHasEnoughWidthForContainsLegend(
+				canvasModel.getChartBlockWidth(),
+				size.width,
+				legendBlock.coordinate
+			)
+		) {
+			const doesFreeSpaceExist = PolarModel.doesChartBlockHasEnoughHeightForContainsLegend(
+				canvasModel.getChartBlockHeight(),
+				legendBlock.coordinate
+			);
+			if (doesFreeSpaceExist) {
+				const newParams = this.getLegendDataParams("bottom", keys, legendCanvas, canvasModel, legendBlock);
+				position = "bottom";
+				maxItemsNumber = newParams.amount;
+				size = newParams.size;
+			}
+		}
+		//TODO: global refactor of method
+		const allowableKeys = keys.slice(0, maxItemsNumber);
+		const hidedRecordsAmount = keys.length - maxItemsNumber;
+		canvasModel.legendCanvas.setPosition(position);
+		this.polarMarginCalculator.updateMargin(
+			position,
+			canvasModel,
+			legendBlock,
+			position === "bottom" ? size.height : size.width
+		);
+		modelInstance.dataModel.initScope(
+			this.limitAllowableKeys(allowableKeys, hidedRecordsAmount, modelInstance.dataModel)
+		);
+	}
+	//TODO: position type
+	static getLegendDataParams(position, keys, legendCanvas, canvasModel, legendBlock) {
+		const legendItemContentOptions = keys.map((k) => ({
+			text: k,
+			markerSize: styledElementValues.defaultLegendMarkerSizes,
+			wrapperSize: {
+				marginRightPx: styledElementValues.legend.inlineDynamicItemWrapperMarginRightPx
+			}
+		}));
+		if (position === "right") {
+			return LegendCanvasModel.findElementsAmountByLegendSize(
+				legendItemContentOptions,
+				position,
+				this.polarMarginCalculator.getMaxLegendWidth(legendCanvas, canvasModel.getBlockSize().width),
+				canvasModel.getChartBlockHeight() - legendBlock.coordinate.right.margin.bottom
+			);
+		} else {
+			return LegendCanvasModel.findElementsAmountByLegendSize(
+				legendItemContentOptions,
+				position,
+				canvasModel.getChartBlockWidth() -
+					legendBlock.coordinate.bottom.margin.left -
+					legendBlock.coordinate.bottom.margin.right,
+				canvasModel.getChartBlockHeight() -
+					legendBlock.coordinate.bottom.margin.bottom -
+					legendBlock.coordinate.bottom.margin.top -
+					MIN_DONUT_BLOCK_SIZE
+			);
+		}
+	}
+	static getMaximumPossibleScope(keys, dataModel) {
+		return this.service.getMaximumPossibleAmount(keys, dataModel.getMaxRecordsAmount());
+	}
+	static limitAllowableKeys(allowableKeys, hidedRecordsAmount, dataModel) {
+		return this.service.limitAllowableKeys(allowableKeys, hidedRecordsAmount, dataModel.getMaxRecordsAmount());
+	}
+	/**
+	 * Выводит количество элементов (преимущественно баров) в одной группе. Группа - один ключ
+	 * @param configOptions
+	 * @param chartsLength
+	 */
+	static getElementsInGroupAmount(configOptions) {
+		const bars = this.getBarLikeChartsInGroupAmount(configOptions.charts, "bar");
+		const dots = configOptions.charts.some((chart) => chart.type === "dot") ? 1 : 0;
+		return Math.max(bars, dots);
+	}
+	static getBarLikeChartsInGroupAmount(charts, type) {
+		let barsAmount = 0;
+		charts.forEach((chart) => {
+			if (chart.type === type && chart.isSegmented)
+				barsAmount += 1; // в сегментированном баре все valueFields находятся внутри одного бара, поэтому бар всегда один.
+			else if (chart.type === type) barsAmount += chart.data.valueFields.length;
+		});
+		return barsAmount;
+	}
+	static getScopedData(data, allowableKeys, dataOptions) {
+		const newData = {};
+		newData[dataOptions.dataSource] = this.getScopedChartData(
+			data[dataOptions.dataSource],
+			allowableKeys,
+			dataOptions.keyField.name
+		);
+		return newData;
+	}
+	static getScopedChartData(data, allowableKeys, keyFieldName) {
+		return data.filter((d) => allowableKeys.findIndex((key) => key === d[keyFieldName]) !== -1);
+	}
+	static getDataLimitByItemSize(elementsInGroupAmount, dataLength, axisLength, barOptions) {
+		let sumSize =
+			dataLength *
+			(elementsInGroupAmount * barOptions.minBarWidth +
+				(elementsInGroupAmount - 1) * barOptions.barDistance +
+				barOptions.groupMinDistance);
+		while (dataLength !== 0 && axisLength < sumSize) {
+			dataLength--;
+			// find whole space for bars in group + distance between bars + group distance
+			sumSize =
+				dataLength *
+				(elementsInGroupAmount * barOptions.minBarWidth +
+					(elementsInGroupAmount - 1) * barOptions.barDistance +
+					barOptions.groupMinDistance);
+		}
+		return dataLength;
+	}
 }
 DataManagerModel.service = new DataManagerModelService();
 DataManagerModel.polarMarginCalculator = new LegendPolarMarginCalculator();

package/lib/model/dataManagerModel/dataManagerModelService.d.ts

@@ -1,5 +1,5 @@
 import { DataScope } from "../model";
 export declare class DataManagerModelService {
-    getMaximumPossibleAmount(keys: string[], maxPossibleAmount: number): DataScope;
-    limitAllowableKeys(allowableKeys: string[], hidedRecordsAmount: number, globalRecordsMaxAmount: number): DataScope;
+	getMaximumPossibleAmount(keys: string[], maxPossibleAmount: number): DataScope;
+	limitAllowableKeys(allowableKeys: string[], hidedRecordsAmount: number, globalRecordsMaxAmount: number): DataScope;
 }

package/lib/model/dataManagerModel/dataManagerModelService.js

@@ -1,28 +1,27 @@
 export class DataManagerModelService {
-    getMaximumPossibleAmount(keys, maxPossibleAmount) {
-        if (maxPossibleAmount >= keys.length) {
-            return {
-                allowableKeys: keys,
-                hidedRecordsAmount: 0
-            };
-        }
-        else {
-            return {
-                allowableKeys: keys.slice(0, maxPossibleAmount),
-                hidedRecordsAmount: keys.length - maxPossibleAmount
-            };
-        }
-    }
-    limitAllowableKeys(allowableKeys, hidedRecordsAmount, globalRecordsMaxAmount) {
-        if (allowableKeys.length <= globalRecordsMaxAmount) {
-            return {
-                allowableKeys,
-                hidedRecordsAmount
-            };
-        }
-        return {
-            allowableKeys: allowableKeys.slice(0, globalRecordsMaxAmount),
-            hidedRecordsAmount: hidedRecordsAmount + allowableKeys.length - globalRecordsMaxAmount
-        };
-    }
+	getMaximumPossibleAmount(keys, maxPossibleAmount) {
+		if (maxPossibleAmount >= keys.length) {
+			return {
+				allowableKeys: keys,
+				hidedRecordsAmount: 0
+			};
+		} else {
+			return {
+				allowableKeys: keys.slice(0, maxPossibleAmount),
+				hidedRecordsAmount: keys.length - maxPossibleAmount
+			};
+		}
+	}
+	limitAllowableKeys(allowableKeys, hidedRecordsAmount, globalRecordsMaxAmount) {
+		if (allowableKeys.length <= globalRecordsMaxAmount) {
+			return {
+				allowableKeys,
+				hidedRecordsAmount
+			};
+		}
+		return {
+			allowableKeys: allowableKeys.slice(0, globalRecordsMaxAmount),
+			hidedRecordsAmount: hidedRecordsAmount + allowableKeys.length - globalRecordsMaxAmount
+		};
+	}
 }

package/lib/model/featuresModel/axisModel.d.ts

@@ -1,29 +1,80 @@
-import { AxisPosition, ChartOrientation, MdtChartsDataSource, NumberAxisOptions, AxisLabelPosition, MdtChartsTwoDimensionalOptions, DiscreteAxisOptions, NumberSecondaryAxisOptions, AxisLabelFormatter } from "../../config/config";
+import {
+	AxisPosition,
+	ChartOrientation,
+	MdtChartsDataSource,
+	NumberAxisOptions,
+	AxisLabelPosition,
+	MdtChartsTwoDimensionalOptions,
+	DiscreteAxisOptions,
+	NumberSecondaryAxisOptions,
+	AxisLabelFormatter
+} from "../../config/config";
 import { AxisModelOptions, Orient, ScaleValueModel, TickAmountPolicy } from "../model";
 import { AxisType } from "../modelBuilder";
 import { AxisLabelCanvas, TooltipSettings } from "../../designer/designerConfig";
 import { CanvasModel } from "../modelInstance/canvasModel/canvasModel";
 export interface LabelSize {
-    width: number;
-    height: number;
+	width: number;
+	height: number;
 }
 export declare const MINIMAL_VERTICAL_STEP_SIZE = 60;
 export declare const MINIMAL_HORIZONTAL_STEP_SIZE = 100;
 export declare const LABEL_ELEMENT_HEIGHT_PX = 17;
 export declare class AxisModel {
-    private static service;
-    static getKeyAxis(options: MdtChartsTwoDimensionalOptions, data: MdtChartsDataSource, labelConfig: AxisLabelCanvas, canvasModel: CanvasModel, tooltipSettings: TooltipSettings, getZeroCoordinate?: () => number): AxisModelOptions;
-    static getMainValueAxis(defaultFormatter: AxisLabelFormatter, orient: ChartOrientation, position: AxisPosition, axisConfig: NumberAxisOptions, labelConfig: AxisLabelCanvas, canvasModel: CanvasModel, scaleInfo: ScaleValueModel): AxisModelOptions;
-    static getSecondaryValueAxis(defaultFormatter: AxisLabelFormatter, orient: ChartOrientation, mainAxisPosition: AxisPosition, axisConfig: NumberSecondaryAxisOptions, labelConfig: AxisLabelCanvas, canvasModel: CanvasModel, scaleInfo: ScaleValueModel): AxisModelOptions;
-    private static getValueAxis;
-    static getAxisLength(chartOrientation: ChartOrientation, canvasModel: CanvasModel): number;
-    static getAxisOrient(axisType: AxisType, chartOrientation: ChartOrientation, axisPosition: AxisPosition): Orient;
-    static getAxisTranslateX(axisType: AxisType, chartOrientation: ChartOrientation, axisPosition: AxisPosition, canvasModel: CanvasModel): number;
-    static getAxisTranslateY(axisType: AxisType, chartOrientation: ChartOrientation, axisPosition: AxisPosition, canvasModel: CanvasModel): number;
-    static getKeyAxisLabelPosition(canvasModel: CanvasModel, scopedDataLength: number, axisConfig?: DiscreteAxisOptions): AxisLabelPosition;
-    static getLabelSize(labelMaxWidth: number, labelTexts: string[]): LabelSize;
-    static getRoundValue(value: number): number;
-    static getTickAmountPolicy(orient: ChartOrientation, axisConfig: NumberAxisOptions | NumberSecondaryAxisOptions, scaleInfo: ScaleValueModel): TickAmountPolicy;
-    private static getKeyAxisTranslateModel;
-    private static getTickStep;
+	private static service;
+	static getKeyAxis(
+		options: MdtChartsTwoDimensionalOptions,
+		data: MdtChartsDataSource,
+		labelConfig: AxisLabelCanvas,
+		canvasModel: CanvasModel,
+		tooltipSettings: TooltipSettings,
+		getZeroCoordinate?: () => number
+	): AxisModelOptions;
+	static getMainValueAxis(
+		defaultFormatter: AxisLabelFormatter,
+		orient: ChartOrientation,
+		position: AxisPosition,
+		axisConfig: NumberAxisOptions,
+		labelConfig: AxisLabelCanvas,
+		canvasModel: CanvasModel,
+		scaleInfo: ScaleValueModel
+	): AxisModelOptions;
+	static getSecondaryValueAxis(
+		defaultFormatter: AxisLabelFormatter,
+		orient: ChartOrientation,
+		mainAxisPosition: AxisPosition,
+		axisConfig: NumberSecondaryAxisOptions,
+		labelConfig: AxisLabelCanvas,
+		canvasModel: CanvasModel,
+		scaleInfo: ScaleValueModel
+	): AxisModelOptions;
+	private static getValueAxis;
+	static getAxisLength(chartOrientation: ChartOrientation, canvasModel: CanvasModel): number;
+	static getAxisOrient(axisType: AxisType, chartOrientation: ChartOrientation, axisPosition: AxisPosition): Orient;
+	static getAxisTranslateX(
+		axisType: AxisType,
+		chartOrientation: ChartOrientation,
+		axisPosition: AxisPosition,
+		canvasModel: CanvasModel
+	): number;
+	static getAxisTranslateY(
+		axisType: AxisType,
+		chartOrientation: ChartOrientation,
+		axisPosition: AxisPosition,
+		canvasModel: CanvasModel
+	): number;
+	static getKeyAxisLabelPosition(
+		canvasModel: CanvasModel,
+		scopedDataLength: number,
+		axisConfig?: DiscreteAxisOptions
+	): AxisLabelPosition;
+	static getLabelSize(labelMaxWidth: number, labelTexts: string[]): LabelSize;
+	static getRoundValue(value: number): number;
+	static getTickAmountPolicy(
+		orient: ChartOrientation,
+		axisConfig: NumberAxisOptions | NumberSecondaryAxisOptions,
+		scaleInfo: ScaleValueModel
+	): TickAmountPolicy;
+	private static getKeyAxisTranslateModel;
+	private static getTickStep;
 }