@techie_doubts/tui.chart.2026 4.6.1

package/dist/esm/component/axis.js

@@ -0,0 +1,176 @@
+import Component from "./component";
+import { makeTickPixelPositions, crispPixel } from "../helpers/calculator";
+import { TICK_SIZE } from "../brushes/axis";
+import { includes } from "../helpers/utils";
+import { getAxisTheme } from "../helpers/axes";
+import { getTitleFontString } from "../helpers/style";
+export var AxisType;
+(function (AxisType) {
+    AxisType["X"] = "xAxis";
+    AxisType["Y"] = "yAxis";
+    AxisType["SECONDARY_Y"] = "secondaryYAxis";
+    AxisType["CIRCULAR"] = "circularAxis";
+    AxisType["VERTICAL"] = "verticalAxis";
+})(AxisType || (AxisType = {}));
+function getOffsetAndAnchorKey(hasBasedYAxis) {
+    return {
+        offsetKey: hasBasedYAxis ? 'y' : 'x',
+        anchorKey: hasBasedYAxis ? 'x' : 'y',
+    };
+}
+export default class Axis extends Component {
+    constructor() {
+        super(...arguments);
+        this.models = { label: [], tick: [], axisLine: [] };
+        this.axisSize = 0;
+    }
+    initialize({ name }) {
+        this.type = 'axis';
+        this.name = name;
+        this.yAxisComponent = includes([AxisType.Y, AxisType.SECONDARY_Y], name);
+    }
+    render({ layout, axes, theme, scale }) {
+        var _a;
+        if (axes.centerYAxis || !axes[this.name]) {
+            return;
+        }
+        this.theme = getAxisTheme(theme, this.name);
+        this.rect = layout[this.name];
+        this.axisSize = this.yAxisComponent ? this.rect.height : this.rect.width;
+        const { viewLabels } = axes[this.name];
+        const { offsetKey, anchorKey } = getOffsetAndAnchorKey(this.yAxisComponent);
+        const renderOptions = this.makeRenderOptions(axes[this.name], (_a = scale) === null || _a === void 0 ? void 0 : _a[this.name]);
+        const hasOnlyAxisLine = this.hasOnlyAxisLine();
+        if (!hasOnlyAxisLine) {
+            this.models.label = this.renderLabelModels(viewLabels, offsetKey, anchorKey, renderOptions);
+            this.models.tick = this.renderTickModels(offsetKey, anchorKey, renderOptions);
+        }
+        this.models.axisLine = [this.renderAxisLineModel()];
+        if (!this.drawModels) {
+            this.drawModels = {
+                tick: [],
+                label: [],
+                axisLine: this.models.axisLine,
+            };
+            ['tick', 'label'].forEach((type) => {
+                this.drawModels[type] = this.models[type].map((m) => {
+                    const drawModel = Object.assign({}, m);
+                    if (this.yAxisComponent) {
+                        drawModel.y = 0;
+                    }
+                    else {
+                        drawModel.x = 0;
+                    }
+                    return drawModel;
+                });
+            });
+        }
+    }
+    renderAxisLineModel() {
+        const zeroPixel = crispPixel(0);
+        let lineModel;
+        const { color: strokeStyle, width: lineWidth } = this.theme;
+        if (this.yAxisComponent) {
+            const x = this.getYAxisXPoint();
+            lineModel = {
+                type: 'line',
+                x,
+                y: zeroPixel,
+                x2: x,
+                y2: crispPixel(this.axisSize),
+                strokeStyle,
+                lineWidth,
+            };
+        }
+        else {
+            lineModel = {
+                type: 'line',
+                x: zeroPixel,
+                y: zeroPixel,
+                x2: crispPixel(this.axisSize),
+                y2: zeroPixel,
+                strokeStyle,
+                lineWidth,
+            };
+        }
+        return lineModel;
+    }
+    renderTickModels(offsetKey, anchorKey, renderOptions) {
+        const tickAnchorPoint = this.yAxisComponent ? this.getYAxisXPoint() : crispPixel(0);
+        const { tickInterval, relativePositions } = renderOptions;
+        const tickSize = includes([AxisType.SECONDARY_Y, AxisType.X], this.name)
+            ? TICK_SIZE
+            : -TICK_SIZE;
+        return relativePositions.reduce((positions, position, index) => {
+            return index % tickInterval
+                ? positions
+                : [
+                    ...positions,
+                    {
+                        type: 'tick',
+                        isYAxis: this.yAxisComponent,
+                        tickSize,
+                        [offsetKey]: crispPixel(position),
+                        [anchorKey]: tickAnchorPoint,
+                        strokeStyle: this.theme.color,
+                        lineWidth: this.theme.width,
+                    },
+                ];
+        }, []);
+    }
+    renderLabelModels(labels, offsetKey, anchorKey, renderOptions) {
+        const { needRotateLabel, radian, offsetY } = renderOptions;
+        const labelTheme = this.theme.label;
+        const font = getTitleFontString(labelTheme);
+        const textAlign = this.getLabelTextAlign(needRotateLabel);
+        const style = ['default', { textAlign, font, fillStyle: labelTheme.color }];
+        const labelAnchorPoint = this.yAxisComponent ? this.getYAxisAnchorPoint() : offsetY;
+        return labels.map(({ text, offsetPos }) => ({
+            type: 'label',
+            text,
+            style,
+            radian,
+            [offsetKey]: crispPixel(offsetPos),
+            [anchorKey]: labelAnchorPoint,
+        }));
+    }
+    makeRenderOptions(axisData, scale) {
+        var _a, _b, _c, _d;
+        const { tickCount, tickInterval } = axisData;
+        const sizeRatio = (_b = (_a = scale) === null || _a === void 0 ? void 0 : _a.sizeRatio, (_b !== null && _b !== void 0 ? _b : 1));
+        const positionRatio = (_d = (_c = scale) === null || _c === void 0 ? void 0 : _c.positionRatio, (_d !== null && _d !== void 0 ? _d : 0));
+        const relativePositions = makeTickPixelPositions(this.axisSize * sizeRatio, tickCount, this.axisSize * positionRatio);
+        if (this.yAxisComponent) {
+            return {
+                relativePositions,
+                tickInterval,
+            };
+        }
+        const { needRotateLabel, radian, offsetY } = axisData;
+        return {
+            relativePositions,
+            tickInterval,
+            needRotateLabel,
+            radian,
+            offsetY,
+        };
+    }
+    getYAxisAnchorPoint() {
+        const padding = TICK_SIZE + 3;
+        return this.isRightSide() ? crispPixel(padding) : crispPixel(this.rect.width - padding);
+    }
+    getLabelTextAlign(needRotateLabel) {
+        const yAxisTextAlign = this.isRightSide() ? 'left' : 'right';
+        const xAxisTextAlign = needRotateLabel ? 'left' : 'center';
+        return this.yAxisComponent ? yAxisTextAlign : xAxisTextAlign;
+    }
+    isRightSide() {
+        return this.name === AxisType.SECONDARY_Y;
+    }
+    getYAxisXPoint() {
+        return this.isRightSide() ? crispPixel(0) : crispPixel(this.rect.width);
+    }
+    hasOnlyAxisLine() {
+        return ((this.yAxisComponent && !this.rect.width) || (this.name === AxisType.X && !this.rect.height));
+    }
+}

package/dist/esm/component/axisTitle.d.ts

@@ -0,0 +1,25 @@
+import Component from "./component";
+import { ChartState, Options, CircularAxisData } from "../../types/store/store";
+import { AxisType } from "./axis";
+import { AxisTitleOption, Rect } from "../../types/options";
+import { FontTheme } from "../../types/theme";
+import { LabelModel } from "../../types/components/axis";
+export default class AxisTitle extends Component {
+    models: LabelModel[];
+    isYAxis: boolean;
+    isCircularAxis: boolean;
+    theme: Required<FontTheme>;
+    initialize({ name }: {
+        name: AxisType;
+    }): void;
+    getTitlePosition(offsetX: number, offsetY: number): number[];
+    renderAxisTitle(option: Required<AxisTitleOption>, textAlign: CanvasTextAlign): LabelModel[];
+    getTextAlign(hasCenterYAxis?: boolean): "left" | "center" | "right";
+    getCircularAxisTitleRect(option: Required<AxisTitleOption>, plotRect: Rect, circularAxisData: CircularAxisData): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    render({ axes, radialAxes, layout, theme }: ChartState<Options>): void;
+}

package/dist/esm/component/axisTitle.js

@@ -0,0 +1,67 @@
+import Component from "./component";
+import { AxisType } from "./axis";
+import { includes } from "../helpers/utils";
+import { getTitleFontString } from "../helpers/style";
+import { getAxisTheme } from "../helpers/axes";
+export default class AxisTitle extends Component {
+    initialize({ name }) {
+        this.type = 'axisTitle';
+        this.name = name;
+        this.isYAxis = includes([AxisType.Y, AxisType.SECONDARY_Y], name);
+        this.isCircularAxis = this.name === AxisType.CIRCULAR;
+    }
+    getTitlePosition(offsetX, offsetY) {
+        if (this.isCircularAxis) {
+            return [this.rect.width / 2 + offsetX, this.rect.height / 2 + offsetY];
+        }
+        return this.isYAxis
+            ? [this.name === AxisType.Y ? offsetX : this.rect.width + offsetX, offsetY]
+            : [this.rect.width + offsetX, offsetY];
+    }
+    renderAxisTitle(option, textAlign) {
+        const { text, offsetX, offsetY } = option;
+        const [x, y] = this.getTitlePosition(offsetX, offsetY);
+        const font = getTitleFontString(this.theme);
+        const fillStyle = this.theme.color;
+        return [
+            {
+                type: 'label',
+                text,
+                x,
+                y,
+                style: ['axisTitle', { textAlign, fillStyle, font }],
+            },
+        ];
+    }
+    getTextAlign(hasCenterYAxis = false) {
+        if (this.name === AxisType.Y) {
+            return hasCenterYAxis ? 'center' : 'left';
+        }
+        if (this.isCircularAxis) {
+            return 'center';
+        }
+        return 'right';
+    }
+    getCircularAxisTitleRect(option, plotRect, circularAxisData) {
+        const { x, y } = plotRect;
+        const { centerX, centerY, axisSize, radius: { outer: outerRadius }, } = circularAxisData;
+        const { offsetY } = option;
+        return {
+            x: centerX + x - axisSize / 2,
+            y: centerY + y - outerRadius / 2,
+            width: axisSize,
+            height: this.theme.fontSize + offsetY,
+        };
+    }
+    render({ axes, radialAxes, layout, theme }) {
+        var _a, _b, _c;
+        const titleOption = this.isCircularAxis ? (_a = radialAxes[this.name]) === null || _a === void 0 ? void 0 : _a.title : (_b = axes[this.name]) === null || _b === void 0 ? void 0 : _b.title;
+        this.isShow = !!titleOption;
+        if (!this.isShow) {
+            return;
+        }
+        this.theme = getAxisTheme(theme, this.name).title;
+        this.rect = layout[`${this.name}Title`];
+        this.models = this.renderAxisTitle(titleOption, this.getTextAlign(!!((_c = axes) === null || _c === void 0 ? void 0 : _c.centerYAxis)));
+    }
+}

package/dist/esm/component/axisUsingCenterY.d.ts

@@ -0,0 +1,32 @@
+import Component from "./component";
+import Painter from "../painter";
+import { ChartState, Options, CenterYAxisData, ViewAxisLabel } from "../../types/store/store";
+import { TickModel, LineModel, AxisModels, LabelModel } from "../../types/components/axis";
+import { AxisTheme } from "../../types/theme";
+import { AxisType } from "./axis";
+declare type CoordinateKey = 'x' | 'y';
+interface RenderOptions {
+    tickInterval: number;
+    centerYAxis: CenterYAxisData;
+    needRotateLabel?: boolean;
+    radian?: number;
+    offsetY?: number;
+    relativePositions: number[];
+}
+export default class AxisUsingCenterY extends Component {
+    name: AxisType;
+    models: AxisModels;
+    drawModels: AxisModels;
+    yAxisComponent: boolean;
+    theme: Required<AxisTheme>;
+    initialize({ name }: {
+        name: AxisType;
+    }): void;
+    render({ layout, axes, theme }: ChartState<Options>): void;
+    renderAxisLineModel({ xAxisHalfSize, secondStartX }: CenterYAxisData): LineModel[];
+    renderTickModels(offsetKey: CoordinateKey, anchorKey: CoordinateKey, renderOptions: RenderOptions): TickModel[];
+    renderLabelModels(labels: ViewAxisLabel[], offsetKey: CoordinateKey, anchorKey: CoordinateKey, renderOptions: RenderOptions): LabelModel[];
+    axisSize(centerYAxis: CenterYAxisData): any;
+    beforeDraw(painter: Painter): void;
+}
+export {};

package/dist/esm/component/axisUsingCenterY.js

@@ -0,0 +1,175 @@
+import Component from "./component";
+import { makeTickPixelPositions, crispPixel } from "../helpers/calculator";
+import { getAxisTheme } from "../helpers/axes";
+import { getTitleFontString } from "../helpers/style";
+import { AxisType } from "./axis";
+export default class AxisUsingCenterY extends Component {
+    constructor() {
+        super(...arguments);
+        this.models = { label: [], tick: [], axisLine: [] };
+    }
+    initialize({ name }) {
+        this.type = 'axis';
+        this.name = name;
+        this.yAxisComponent = name === AxisType.Y;
+    }
+    render({ layout, axes, theme }) {
+        const { centerYAxis } = axes;
+        if (!centerYAxis) {
+            return;
+        }
+        this.theme = getAxisTheme(theme, this.name);
+        this.rect = layout[this.name];
+        if (this.name === 'yAxis') {
+            this.rect = Object.assign(Object.assign({}, this.rect), { x: centerYAxis.x });
+        }
+        const { viewLabels, tickCount, tickInterval, needRotateLabel, radian, offsetY } = axes[this.name];
+        const renderOptions = {
+            tickInterval,
+            centerYAxis,
+            needRotateLabel,
+            radian,
+            offsetY,
+            relativePositions: makeTickPixelPositions(this.axisSize(centerYAxis), tickCount),
+        };
+        const offsetKey = this.yAxisComponent ? 'y' : 'x';
+        const anchorKey = this.yAxisComponent ? 'x' : 'y';
+        this.models.label = this.renderLabelModels(viewLabels, offsetKey, anchorKey, renderOptions);
+        this.models.tick = this.renderTickModels(offsetKey, anchorKey, renderOptions);
+        this.models.axisLine = this.renderAxisLineModel(centerYAxis);
+        if (!this.drawModels) {
+            this.drawModels = {
+                tick: [],
+                label: [],
+                axisLine: this.models.axisLine,
+            };
+            ['tick', 'label'].forEach((type) => {
+                this.drawModels[type] = this.models[type].map((m) => {
+                    const drawModel = Object.assign({}, m);
+                    if (this.yAxisComponent) {
+                        drawModel.y = 0;
+                    }
+                    else {
+                        drawModel.x = 0;
+                    }
+                    return drawModel;
+                });
+            });
+        }
+    }
+    renderAxisLineModel({ xAxisHalfSize, secondStartX }) {
+        const zeroPixel = crispPixel(0);
+        const widthPixel = crispPixel(this.rect.width);
+        let axisLine;
+        if (this.yAxisComponent) {
+            const heightPixel = crispPixel(this.rect.height);
+            axisLine = [
+                {
+                    type: 'line',
+                    x: widthPixel,
+                    y: zeroPixel,
+                    x2: widthPixel,
+                    y2: heightPixel,
+                },
+                {
+                    type: 'line',
+                    x: zeroPixel,
+                    y: zeroPixel,
+                    x2: zeroPixel,
+                    y2: heightPixel,
+                },
+            ];
+        }
+        else {
+            axisLine = [
+                {
+                    type: 'line',
+                    x: zeroPixel,
+                    y: zeroPixel,
+                    x2: crispPixel(xAxisHalfSize),
+                    y2: zeroPixel,
+                },
+                {
+                    type: 'line',
+                    x: crispPixel(secondStartX),
+                    y: zeroPixel,
+                    x2: widthPixel,
+                    y2: zeroPixel,
+                },
+            ];
+        }
+        return axisLine;
+    }
+    renderTickModels(offsetKey, anchorKey, renderOptions) {
+        const tickAnchorPoint = this.yAxisComponent ? crispPixel(this.rect.width) : crispPixel(0);
+        const { tickInterval, centerYAxis: { secondStartX }, relativePositions, } = renderOptions;
+        return relativePositions.reduce((positions, position, index) => {
+            if (index % tickInterval) {
+                return positions;
+            }
+            const model = {
+                type: 'tick',
+                isYAxis: this.yAxisComponent,
+                tickSize: this.yAxisComponent ? -5 : 5,
+                [offsetKey]: crispPixel(position),
+                [anchorKey]: tickAnchorPoint,
+            };
+            const addedTickModel = Object.assign({}, model);
+            if (this.yAxisComponent) {
+                addedTickModel[anchorKey] = crispPixel(0);
+                addedTickModel.tickSize = 5;
+            }
+            else {
+                addedTickModel[offsetKey] = crispPixel(position + secondStartX);
+            }
+            return [...positions, model, addedTickModel];
+        }, []);
+    }
+    renderLabelModels(labels, offsetKey, anchorKey, renderOptions) {
+        const { centerYAxis: { secondStartX, yAxisLabelAnchorPoint }, offsetY, needRotateLabel, radian, } = renderOptions;
+        const labelTheme = this.theme.label;
+        const font = getTitleFontString(labelTheme);
+        let labelAnchorPoint, textAlign, textLabels;
+        if (this.yAxisComponent) {
+            labelAnchorPoint = crispPixel(yAxisLabelAnchorPoint);
+            textAlign = 'center';
+            textLabels = labels;
+        }
+        else {
+            labelAnchorPoint = offsetY;
+            textLabels = [...labels].reverse();
+            textAlign = needRotateLabel ? 'left' : 'center';
+        }
+        const style = ['default', { textAlign, font, fillStyle: labelTheme.color }];
+        return textLabels.reduce((positions, { text, offsetPos }, index) => {
+            const model = {
+                type: 'label',
+                text,
+                style,
+                [offsetKey]: crispPixel(offsetPos) + (this.yAxisComponent ? 0 : secondStartX),
+                [anchorKey]: labelAnchorPoint,
+                radian,
+            };
+            const models = [model];
+            if (!this.yAxisComponent) {
+                const addedLabelModel = Object.assign(Object.assign({}, model), { text: labels[index].text, [offsetKey]: crispPixel(model[offsetKey] - secondStartX) });
+                models.push(addedLabelModel);
+            }
+            return [...positions, ...models];
+        }, []);
+    }
+    axisSize(centerYAxis) {
+        let size;
+        if (this.yAxisComponent) {
+            size = this.rect.height;
+        }
+        else {
+            size = centerYAxis.xAxisHalfSize;
+        }
+        return size;
+    }
+    beforeDraw(painter) {
+        painter.ctx.strokeStyle = 'rgba(0, 0, 0, 0.5)';
+        painter.ctx.lineWidth = 1;
+    }
+}

package/dist/esm/component/backButton.d.ts

@@ -0,0 +1,13 @@
+import Component from "./component";
+import { ChartState, Options } from "../../types/store/store";
+import { BackButtonModels } from "../../types/components/resetButton";
+import { RectResponderModel } from "../../types/components/series";
+export default class BackButton extends Component {
+    responders: RectResponderModel[];
+    models: BackButtonModels;
+    initialize(): void;
+    onClick({ responders }: {
+        responders: RectResponderModel[];
+    }): void;
+    render({ options, layout }: ChartState<Options>, computed: any): void;
+}

package/dist/esm/component/backButton.js

@@ -0,0 +1,26 @@
+import Component from "./component";
+import { isUsingResetButton } from "../store/layout";
+import { BUTTON_RECT_SIZE } from "./exportMenu";
+export default class BackButton extends Component {
+    initialize() {
+        this.type = 'backButton';
+        this.name = 'backButton';
+    }
+    onClick({ responders }) {
+        if (responders.length) {
+            this.store.dispatch('zoomBack');
+            this.eventBus.emit('resetSelectedSeries');
+        }
+    }
+    render({ options, layout }, computed) {
+        if (!isUsingResetButton(options)) {
+            return;
+        }
+        this.rect = layout.resetButton;
+        this.isShow = computed.isTreemapSeriesZooming;
+        this.models = this.isShow ? [{ type: 'backButton', x: 0, y: 0 }] : [];
+        this.responders = this.isShow
+            ? [{ type: 'rect', x: 0, y: 0, width: BUTTON_RECT_SIZE, height: BUTTON_RECT_SIZE }]
+            : [];
+    }
+}

package/dist/esm/component/background.d.ts

@@ -0,0 +1,10 @@
+import Component from "./component";
+import { ChartState, Options } from "../../types/store/store";
+import { ChartTheme } from "../../types/theme";
+import { BackgroundModel } from "../../types/components/series";
+export default class Background extends Component {
+    models: BackgroundModel;
+    theme: Required<ChartTheme>;
+    initialize(): void;
+    render({ layout, theme }: ChartState<Options>): void;
+}

package/dist/esm/component/background.js

@@ -0,0 +1,15 @@
+import Component from "./component";
+export default class Background extends Component {
+    initialize() {
+        this.type = 'background';
+        this.name = 'background';
+    }
+    render({ layout, theme }) {
+        const { width, height } = layout.chart;
+        this.theme = theme.chart;
+        this.rect = { x: 0, y: 0, width, height };
+        this.models = [
+            Object.assign(Object.assign({ type: 'rect' }, this.rect), { color: this.theme.backgroundColor }),
+        ];
+    }
+}

package/dist/esm/component/boxPlotSeries.d.ts

@@ -0,0 +1,126 @@
+import Component from "./component";
+import { BoxPlotSeriesType, BoxPlotChartOptions, BoxTypeEventDetectType } from "../../types/options";
+import { ChartState } from "../../types/store/store";
+import { BoxPlotSeriesModels, RectModel, CircleModel, BoxPlotModel, RectResponderModel, BoxPlotResponderTypes } from "../../types/components/series";
+import { TooltipData } from "../../types/components/tooltip";
+import { LineModel } from "../../types/components/axis";
+import { BoxPlotChartSeriesTheme } from "../../types/theme";
+import { SelectSeriesHandlerParams } from "../charts/chart";
+declare type RenderOptions = {
+    ratio: number;
+    tickDistance: number;
+    barWidth: number;
+    minMaxBarWidth: number;
+};
+declare type BoxPlotModelData = Array<BoxPlotModel | CircleModel>;
+declare type TooltipRectMap = Record<string, BoxPlotResponderTypes[]>;
+export default class BoxPlotSeries extends Component {
+    models: BoxPlotSeriesModels;
+    drawModels: BoxPlotSeriesModels;
+    responders: BoxPlotResponderTypes[];
+    activatedResponders: BoxPlotResponderTypes[];
+    eventDetectType: BoxTypeEventDetectType;
+    tooltipRectMap: TooltipRectMap;
+    theme: Required<BoxPlotChartSeriesTheme>;
+    initialize(): void;
+    render(state: ChartState<BoxPlotChartOptions>): void;
+    makeTooltipRectMap(boxPlotModelData: BoxPlotModelData, tooltipData: TooltipData[]): Record<string, BoxPlotResponderTypes[]>;
+    makeGroupedResponderModel(boxPlotModelData: BoxPlotModelData): RectResponderModel[];
+    makeDefaultResponderModel(boxPlotModelData: BoxPlotModelData, tooltipDataArr: TooltipData[]): ({
+        data: TooltipData;
+        color: string;
+        x: number;
+        y: number;
+        type: "circle";
+        radius: number;
+        style?: import("../../types/components/series").StyleProp<import("../../types/components/series").CircleStyle, import("../../types/brushes").CircleStyleName> | undefined;
+        seriesIndex?: number | undefined;
+        index?: number | undefined;
+        angle?: {
+            start: number;
+            end: number;
+        } | undefined;
+        name?: string | undefined;
+        borderWidth?: number | undefined;
+        borderColor?: string | undefined;
+    } | {
+        data: TooltipData;
+        color: string;
+        x: number;
+        y: number;
+        type: "boxPlot";
+        name: string;
+        rect: RectModel | null;
+        median: LineModel | null;
+        upperWhisker: LineModel | null;
+        lowerWhisker: LineModel | null;
+        minimum: LineModel | null;
+        maximum: LineModel | null;
+        index?: number | undefined;
+        boxPlotDetection: {
+            x: number;
+            width: number;
+        };
+    })[];
+    makeHoveredModel(model: BoxPlotModel | CircleModel): {
+        x: number;
+        y: number;
+        type: "circle";
+        radius: number;
+        color: string;
+        style?: import("../../types/components/series").StyleProp<import("../../types/components/series").CircleStyle, import("../../types/brushes").CircleStyleName> | undefined;
+        seriesIndex?: number | undefined;
+        index?: number | undefined;
+        angle?: {
+            start: number;
+            end: number;
+        } | undefined;
+        name?: string | undefined;
+        borderWidth?: number | undefined;
+        borderColor?: string | undefined;
+    } | {
+        x: number;
+        y: number;
+        type: "boxPlot";
+        color: string;
+        name: string;
+        rect: RectModel | null;
+        median: LineModel | null;
+        upperWhisker: LineModel | null;
+        lowerWhisker: LineModel | null;
+        minimum: LineModel | null;
+        maximum: LineModel | null;
+        index?: number | undefined;
+        boxPlotDetection: {
+            x: number;
+            width: number;
+        };
+    };
+    getResponderModelFromMap(responders: BoxPlotResponderTypes[]): BoxPlotResponderTypes[];
+    onMousemove({ responders }: {
+        responders: any;
+    }): void;
+    onClick({ responders }: {
+        responders: any;
+    }): void;
+    renderSeriesModels(boxPlots: BoxPlotModelData): BoxPlotSeriesModels;
+    makeBoxPlots(seriesData: BoxPlotSeriesType[], renderOptions: RenderOptions): BoxPlotModelData;
+    makeTooltipModel(seriesData: BoxPlotSeriesType[], categories: string[]): TooltipData[];
+    getStartX(seriesIndex: number, dataIndex: number, renderOptions: RenderOptions, seriesLength: number): number;
+    getYPos(value: number, ratio: number, lineWidth?: number): number;
+    onMouseoutComponent: () => void;
+    getBarWidths(tickDistance: number, seriesLength: number): {
+        barWidth: number;
+        minMaxBarWidth: number;
+    };
+    getRespondersWithTheme(responders: BoxPlotResponderTypes[], type: 'hover' | 'select'): any[];
+    getRect(datum: number[], startX: number, seriesColor: string, { barWidth, ratio }: RenderOptions): RectModel;
+    getWhisker(datum: number[], startX: number, seriesColor: string, { barWidth, ratio }: RenderOptions, rect: RectModel): Record<'upperWhisker' | 'lowerWhisker', LineModel>;
+    getMedian(datum: number[], startX: number, seriesColor: string, { barWidth, ratio }: RenderOptions): LineModel;
+    getMinimum(datum: number[], startX: number, seriesColor: string, { barWidth, ratio, minMaxBarWidth }: RenderOptions): LineModel;
+    getMaximum(datum: number[], startX: number, seriesColor: string, { barWidth, ratio, minMaxBarWidth }: RenderOptions): LineModel;
+    getSeriesColor(seriesName: string, seriesColor: string): string;
+    selectSeries: ({ index, seriesIndex, state, }: SelectSeriesHandlerParams<BoxPlotChartOptions>) => void;
+    showTooltip: ({ index, seriesIndex, state }: SelectSeriesHandlerParams<BoxPlotChartOptions>) => void;
+}
+export {};