@sisense/sdk-ui 0.11.3

package/dist/chart-options-processor/category-chart-options.d.ts

@@ -0,0 +1,16 @@
+import { ChartDesignOptions } from './translations/types';
+import { ChartType, OptionsWithAlerts, CompleteThemeSettings } from '../types';
+import { CategoricalChartData } from '../chart-data/types';
+import { HighchartsOptionsInternal } from './chart-options-service';
+import { ChartDataOptionsInternal } from '../chart-data-options/types';
+/**
+ * Convert intermediate chart data, data options, and design options
+ * into pure highcharts config data.
+ *
+ * @param chartData - the data for the chart in an intermediate format
+ * @param chartType -
+ * @param chartDesignOptions -
+ * @param dataOptions -
+ * @param themeSettings -
+ */
+export declare const getCategoricalChartOptions: (chartData: CategoricalChartData, chartType: ChartType, chartDesignOptions: ChartDesignOptions, dataOptions: ChartDataOptionsInternal, themeSettings?: CompleteThemeSettings) => OptionsWithAlerts<HighchartsOptionsInternal>;

package/dist/chart-options-processor/chart-options-service.d.ts

@@ -0,0 +1,253 @@
+import type { Options, DrilldownOptions } from '@sisense/sisense-charts';
+import { ChartData } from '../chart-data/types';
+import { ChartDesignOptions } from './translations/types';
+import { LegendSettings } from './translations/legend-section';
+import { ValueLabelSettings } from './translations/value-label-section';
+import { MarkerSettings } from './translations/marker-section';
+import { AxisSettings } from './translations/axis-section';
+import { HighchartsType, HighchartsSeriesValues } from './translations/translations-to-highcharts';
+import { TooltipSettings } from './tooltip';
+import { PieOptions } from './translations/pie-plot-options';
+import { FunnelOptions } from './translations/funnel-plot-options';
+import { ChartType, OptionsWithAlerts, CompleteThemeSettings } from '../types';
+import { ChartDataOptionsInternal } from '../chart-data-options/types';
+import { ScatterBubbleOptions } from './translations/scatter-plot-options';
+/**
+ * Highcharts options
+ *
+ * @internal
+ */
+export type HighchartsOptions = Pick<Options, keyof Options>;
+/**
+ * Convert intermediate chart data, data options, and design options
+ * into pure highcharts config data.
+ *
+ * @param chartData - the data for the chart in an intermediate format
+ * @param chartType -
+ * @param chartDesignOptions -
+ * @param dataOptions -
+ * @param themeSettings -
+ * @param dateFormatter
+ */
+export declare const highchartsOptionsService: (chartData: ChartData, chartType: ChartType, chartDesignOptions: ChartDesignOptions, dataOptions: ChartDataOptionsInternal, themeSettings?: CompleteThemeSettings, dateFormatter?: ((date: Date, format: string) => string) | undefined) => OptionsWithAlerts<HighchartsOptionsInternal>;
+export declare const colorChineseSilver = "#CCCCCC";
+export declare const colorWhite = "#FFFFFF";
+export declare const DEFAULT_SERIES_COLORS: string[];
+export type SeriesType = HighchartsSeriesValues & {
+    index?: number;
+    animation?: boolean;
+    showInNavigator?: boolean;
+    showInLegend?: boolean;
+    stickyTracking?: boolean;
+    boostThreshold?: number;
+    turboThreshold?: number;
+    color?: string;
+    yAxis?: number;
+    marker?: MarkerSettings;
+    type?: string;
+    id?: string;
+};
+type ChartPlotOptions = {
+    dataLabels?: ValueLabelSettings;
+    groupPadding?: number;
+    pointPadding?: number;
+    pointPlacement?: null;
+    animation?: boolean;
+    shadow: boolean;
+    marker?: MarkerSettings;
+    borderWidth?: number;
+};
+export type Stacking = 'normal' | 'percent';
+export type PlotOptions = {
+    series: {
+        lineWidth?: number;
+        dataLabels?: ValueLabelSettings;
+        marker?: MarkerSettings;
+        stacking?: Stacking;
+        stickyTracking?: boolean;
+        groupPadding?: number;
+        pointPadding?: number;
+        grouping?: boolean;
+        states?: {
+            select?: {
+                color?: string | null;
+                opacity?: number;
+                borderColor?: string;
+            };
+        };
+        allowPointSelect?: boolean;
+        boostThreshold?: number;
+        turboThreshold?: number;
+        fillOpacity?: number;
+        connectNulls?: boolean;
+        animation?: {
+            duration?: number;
+        };
+    };
+    line?: ChartPlotOptions;
+    area?: ChartPlotOptions;
+    bar?: ChartPlotOptions;
+    column?: ChartPlotOptions;
+    pie?: PieOptions;
+    funnel?: FunnelOptions;
+    bubble?: ScatterBubbleOptions;
+};
+/**
+ * Highcharts options internal
+ */
+export type HighchartsOptionsInternal = {
+    chart: {
+        type: HighchartsType;
+        renderTo?: string;
+        events?: {
+            load?: () => void;
+            redraw?: () => void;
+        };
+        spacing?: number[];
+        marginTop?: number;
+        alignTicks?: boolean;
+        polar: boolean;
+        animation?: {
+            duration?: number;
+        };
+    };
+    title?: {
+        text: string | null;
+    };
+    subtitle?: {
+        text: string | null;
+    };
+    series: SeriesType[];
+    xAxis?: AxisSettings[];
+    yAxis?: AxisSettings[];
+    legend?: LegendSettings;
+    plotOptions?: PlotOptions;
+    navigator?: Navigator | {
+        enabled: boolean;
+    };
+    tooltip?: TooltipSettings;
+    boost?: {
+        useGPUTranslations: boolean;
+        usePreAllocated: boolean;
+    };
+    credits?: {
+        enabled: boolean;
+    };
+    exporting?: {
+        enabled: boolean;
+    };
+    drilldown?: DrilldownOptions;
+};
+export type Style = {
+    fontFamily?: string;
+    fontSize?: string;
+    fontWeight?: string;
+    color?: string;
+    textOutline?: string;
+    pointerEvents?: string;
+    textOverflow?: string;
+    width?: string;
+};
+type Navigator = {
+    series: {
+        type: HighchartsType;
+        dataGrouping: {
+            enabled: boolean;
+        };
+    };
+    enabled: boolean;
+    margin: number;
+    height: number;
+    xAxis: AxisSettings;
+    handles: {
+        symbols: string[];
+        backgroundColor: string;
+        borderColor: string;
+    };
+    maskInside: boolean;
+    maskFill: string;
+    outlineColor: string;
+    outlineWidth: number;
+    threshold?: number;
+    tooltipFormatter?: (min: number, max: number) => {
+        left: string;
+        right: string;
+    };
+};
+declare const DEFAULT_STYLE_OPTIONS: {
+    readonly legend: {
+        readonly enabled: true;
+        readonly position: "bottom";
+    };
+    readonly navigator: {
+        readonly enabled: true;
+    };
+    readonly markers: {
+        readonly enabled: true;
+        readonly fill: "hollow";
+        readonly size: "small";
+    };
+    readonly seriesLabels: {
+        readonly enabled: false;
+        readonly rotation: 0;
+    };
+    readonly xAxis: {
+        readonly enabled: true;
+        readonly gridLines: true;
+        readonly isIntervalEnabled: false;
+        readonly labels: {
+            readonly enabled: true;
+        };
+        readonly logarithmic: false;
+        readonly title: {
+            readonly enabled: false;
+            readonly text: "X Axis title";
+        };
+    };
+    readonly yAxis: {
+        readonly enabled: true;
+        readonly gridLines: true;
+        readonly isIntervalEnabled: false;
+        readonly labels: {
+            readonly enabled: true;
+        };
+        readonly logarithmic: false;
+        readonly title: {
+            readonly enabled: false;
+            readonly text: "Y Axis title";
+        };
+    };
+    readonly y2Axis: {
+        readonly enabled: false;
+        readonly gridLines: true;
+        readonly isIntervalEnabled: false;
+        readonly labels: {
+            readonly enabled: true;
+        };
+        readonly logarithmic: false;
+        readonly title: {
+            readonly enabled: false;
+            readonly text: "Y2 Axis title";
+        };
+    };
+    readonly convolution: {
+        readonly enabled: false;
+        readonly selectedConvolutionType: "byPercentage";
+        readonly minimalIndependentSlicePercentage: 3;
+        readonly independentSlicesCount: 7;
+    };
+    readonly labels: {
+        readonly categories: true;
+        readonly enabled: true;
+        readonly percent: true;
+        readonly decimals: false;
+        readonly value: false;
+    };
+};
+/**
+ * Returns default style options, which can be used as base for custom style options.
+ *
+ * @returns Style options object
+ */
+export declare const getDefaultStyleOptions: () => typeof DEFAULT_STYLE_OPTIONS;
+export {};

package/dist/chart-options-processor/common-highcharts-option-service.d.ts

@@ -0,0 +1,4 @@
+import { HighchartsOptionsInternal } from './chart-options-service';
+export declare const DEFAULT_ANIMATION_DURATION_MS_INIT = 600;
+export declare const DEFAULT_ANIMATION_DURATION_MS_UPDATE = 300;
+export declare const applyCommonHighchartsOptions: (chartOptions: HighchartsOptionsInternal) => HighchartsOptionsInternal;

package/dist/chart-options-processor/defaults/cartesian.d.ts

@@ -0,0 +1,45 @@
+import { AxisSettings } from '../translations/axis-section';
+import { Style, HighchartsOptionsInternal, Stacking } from '../chart-options-service';
+import { ChartType } from '../../types';
+import { PolarType } from '../translations/design-options';
+export declare const lineColorDefault = "#d1d1d7";
+export declare const fontStyleDefault: Style;
+export declare const stackTotalFontStyleDefault: Style;
+export declare const xAxisDefaults: AxisSettings;
+export declare const yAxisDefaults: AxisSettings;
+export declare const chartOptionsDefaults: (chartType: ChartType, polarType?: PolarType, stacking?: Stacking) => HighchartsOptionsInternal;
+export declare const cartesianDefaults: HighchartsOptionsInternal;
+export declare const areaDefaults: (stacking?: Stacking) => {
+    plotOptions: {
+        area: {
+            lineColor?: string | undefined;
+        };
+        series: {
+            stacking?: Stacking | undefined;
+        };
+    };
+};
+export declare const columnDefaults: (stacking?: Stacking) => {
+    plotOptions: {
+        column: {
+            borderWidth?: number | undefined;
+            groupPadding: number;
+            pointPadding: number;
+        };
+        series: {
+            stacking?: Stacking | undefined;
+        };
+    };
+};
+export declare const barDefaults: (stacking?: Stacking) => {
+    plotOptions: {
+        bar: {
+            borderWidth?: number | undefined;
+            groupPadding: number;
+            pointPadding: number;
+        };
+        series: {
+            stacking?: Stacking | undefined;
+        };
+    };
+};

package/dist/chart-options-processor/plot-bands.d.ts

@@ -0,0 +1,23 @@
+import { CartesianChartDataOptionsInternal, ChartDataOptionsInternal } from '../chart-data-options/types';
+import { ChartData } from '../chart-data/types';
+import { PlotBand } from './translations/axis-section';
+import { ChartDesignOptions } from './translations/types';
+type CategoryIndexMapPlotBands = {
+    categories: string[];
+    indexMap: number[];
+    plotBands: PlotBand[];
+};
+export declare const applyNumberFormatToPlotBands: (chartDataOptions: ChartDataOptionsInternal, categoryIndexMapPlotBands: CategoryIndexMapPlotBands) => CategoryIndexMapPlotBands;
+/**
+ * This method returns three arrays to create chart options
+ * categories - values to display on the bottom X1 axis
+ * indexMap - tic index to xValue index
+ * plotBands - information to create plot bands for X2 axis
+ *
+ * @param data -
+ * @param dataOptions -
+ * @param designOptions -
+ * @param continuousDatetimeXAxis -
+ */
+export declare const getCategoriesIndexMapAndPlotBands: (data: ChartData, dataOptions: CartesianChartDataOptionsInternal, designOptions: ChartDesignOptions, continuousDatetimeXAxis: boolean) => CategoryIndexMapPlotBands;
+export {};

package/dist/chart-options-processor/scatter-chart-options.d.ts

@@ -0,0 +1,22 @@
+import { ChartDesignOptions } from './translations/types';
+import { ChartType, OptionsWithAlerts, CompleteThemeSettings } from '../types';
+import { ScatterChartData } from '../chart-data/types';
+import { HighchartsOptionsInternal } from './chart-options-service';
+import { ChartDataOptionsInternal } from '../chart-data-options/types';
+import { LegendPosition, LegendSettings } from './translations/legend-section';
+/**
+ * @param position
+ * @internal
+ */
+export declare const getScatterLegendSettings: (position: LegendPosition) => LegendSettings;
+/**
+ * Convert intermediate chart data, data options, and design options
+ * into pure highcharts config data.
+ *
+ * @param chartData - the data for the chart in an intermediate format
+ * @param chartType -
+ * @param chartDesignOptions -
+ * @param dataOptions -
+ * @param themeSettings -
+ */
+export declare const getScatterChartOptions: (chartData: ScatterChartData, chartType: ChartType, chartDesignOptions: ChartDesignOptions, dataOptions: ChartDataOptionsInternal, themeSettings?: CompleteThemeSettings) => OptionsWithAlerts<HighchartsOptionsInternal>;

package/dist/chart-options-processor/style-to-design-options-translator/translate-style-to-design-options.d.ts

@@ -0,0 +1,4 @@
+import { ChartType, StyleOptions } from '../../types';
+import { ChartDesignOptions } from '../translations/types';
+import { ChartDataOptionsInternal } from '../../chart-data-options/types';
+export declare const translateStyleOptionsToDesignOptions: (chartType: ChartType, styleOptions: StyleOptions, dataOptions: ChartDataOptionsInternal) => ChartDesignOptions;

package/dist/chart-options-processor/style-to-design-options-translator/translate-to-highcharts-options.d.ts

@@ -0,0 +1,13 @@
+import { PolarStyleOptions, PieStyleOptions, StackableStyleOptions, LineStyleOptions, AreaStyleOptions, FunnelStyleOptions, ScatterStyleOptions, TreemapStyleOptions } from '../../types';
+import { StackableChartDesignOptions, LineChartDesignOptions, PieChartDesignOptions, FunnelChartDesignOptions, PolarChartDesignOptions, ScatterChartDesignOptions, AreaChartDesignOptions, TreemapChartDesignOptions } from '../translations/design-options';
+import { StackType } from '../translations/translations-to-highcharts';
+export declare const DefaultStackType: StackType;
+export declare const getStackableChartDesignOptions: (styleOptions: AreaStyleOptions | StackableStyleOptions, hasY2Axis: boolean) => StackableChartDesignOptions;
+export declare const getLineChartDesignOptions: (styleOptions: LineStyleOptions, hasY2Axis: boolean) => LineChartDesignOptions;
+export declare const getAreaChartDesignOptions: (styleOptions: AreaStyleOptions, hasY2Axis: boolean) => AreaChartDesignOptions;
+export declare const DefaultPieType = "classic";
+export declare const getPieChartDesignOptions: (styleOptions: PieStyleOptions) => PieChartDesignOptions;
+export declare const getFunnelChartDesignOptions: (styleOptions: FunnelStyleOptions) => FunnelChartDesignOptions;
+export declare const getTreemapChartDesignOptions: (styleOptions: TreemapStyleOptions) => TreemapChartDesignOptions;
+export declare const getPolarChartDesignOptions: (styleOptions: PolarStyleOptions) => PolarChartDesignOptions;
+export declare const getScatterChartDesignOptions: (styleOptions: ScatterStyleOptions) => ScatterChartDesignOptions;

package/dist/chart-options-processor/style-to-design-options-translator/translate-to-indicator-options.d.ts

@@ -0,0 +1,3 @@
+import { IndicatorStyleOptions } from '../../types';
+import { IndicatorChartDesignOptions } from '../translations/design-options';
+export declare function getIndicatorChartDesignOptions(styleOptions: IndicatorStyleOptions): IndicatorChartDesignOptions;

package/dist/chart-options-processor/subtype-to-design-options.d.ts

@@ -0,0 +1,97 @@
+import { LineType, StackType } from './translations/translations-to-highcharts';
+import { IndicatorStyleType, PolarType } from './translations/design-options';
+/**
+ * Property of {@link LineStyleOptions}
+ *
+ * Subtype of {@link LineChart}
+ *
+ * **Values**
+ *
+ * - `line/spline` - curved line from point to point.
+ * - `line/basic` - straight line from point to point.
+ *
+ */
+export type LineSubtype = 'line/spline' | 'line/basic';
+/**
+ * Property of {@link AreaStyleOptions}
+ *
+ * Subtype of {@link AreaChart}
+ *
+ * **Values**
+ *
+ * - `area/basic` - straight lines showing areas that overlap so that smaller areas appear on top of larger areas and cover them.
+ * - `area/stacked` - straight lines showing areas that are stacked on top of each other and do not overlap.
+ * - `area/stacked100` - straight lines showing areas that are stacked on top of each other but do not overlap so that the combined area is stretched to the top representing 100%.
+ * - `area/spline` - curved lines showing areas that overlap so that smaller areas appear on top of larger areas and cover them.
+ * - `area/stackedspline` - curved lines showing areas that are stacked on top of each other and do not overlap.
+ * - `area/stackedspline100` - curved lines showing areas that are stacked on top of each other but do not overlap so that the combined area is stretched to the top representing 100%.
+ *
+ */
+export type AreaSubtype = 'area/basic' | 'area/stacked' | 'area/stacked100' | 'area/spline' | 'area/stackedspline' | 'area/stackedspline100';
+/**
+ * Property of {@link StackableSubtype}
+ *
+ * Subtype of {@link BarChart}
+ *
+ *  **Values**
+ * - `bar/classic` - y axis values displayed vertically.
+ * - `bar/stacked` - y axis values are stacked next to each other and do not overlap.
+ * - `bar/stacked100` - y axis values are stacked next to each other but do not overlap and combined and stretched to represent 100%.
+ * - `column/classic` - columns are displayed side by side.
+ * - `column/stackedcolumn` - columns are stacked on top of each other and do not overlap.
+ * - `column/stackedcolumn100` - columns are stacked on top of each other but do not overlap and combined and stretched to represent 100%.
+ *
+ */
+export type StackableSubtype = 'bar/classic' | 'bar/stacked' | 'bar/stacked100' | 'column/classic' | 'column/stackedcolumn' | 'column/stackedcolumn100';
+/**
+ * Property of {@link PieStyleOptions}
+ *
+ * Subtype of {@link PieChart}
+ *
+ * **Values**
+ *
+ * - `pie/classic` - a circle divided into a series of segments where each segment represents a particular category.
+ * - `pie/donut` - a circle divided into a series of segments where each segment represents a particular category with its center cut out to look like a donut.
+ * - `pie/ring` - a circle divided into a series of segments where each segment represents a particular category with its center cut out to look like a ring.
+ *
+ */
+export type PieSubtype = 'pie/classic' | 'pie/donut' | 'pie/ring';
+/**
+ * Property of {@link PolarStyleOptions}
+ *
+ * Subtype of {@link PolarChart}
+ *
+ * **Values**
+ *
+ * - `polar/column` - a chart where data points are displayed using the angle and distance from the center point.
+ * - `polar/area` - a chart in which the data points are connected by a line with the area below the line filled.
+ * - `polar/line` -  a chart in which the data points are connected by a line.
+ */
+export type PolarSubtype = 'polar/column' | 'polar/area' | 'polar/line';
+/**
+ *
+ * Subtype of {@link IndicatorChart}
+ *
+ * **Values**
+ *
+ * - `indicator/numeric` - a numeric value representing a value.
+ * - `indicator/gauge` - a gauge representing a value  between the min and the max.
+ */
+export type IndicatorSubtype = 'indicator/numeric' | 'indicator/gauge';
+/**
+ *
+ * Subtype of {@link TreemapChart}
+ *
+ * **Values**
+ *
+ * - `treemap` - default treemap.
+ */
+export type TreemapSubtype = 'treemap';
+export type ChartSubtype = LineSubtype | AreaSubtype | StackableSubtype | PieSubtype | PolarSubtype | IndicatorSubtype | TreemapSubtype;
+export declare const chartSubtypeToDesignOptions: Readonly<Record<ChartSubtype, {
+    lineType?: LineType | undefined;
+    stackType?: StackType | undefined;
+    pieType?: "classic" | "donut" | "ring" | undefined;
+    polarType?: PolarType | undefined;
+    indicatorType?: IndicatorStyleType | undefined;
+}>>;

package/dist/chart-options-processor/theme-option-service.d.ts

@@ -0,0 +1,11 @@
+import { CompleteThemeSettings } from '../types';
+import { HighchartsOptionsInternal } from './chart-options-service';
+export declare const applyThemeToChart: (chartOptions: HighchartsOptionsInternal, themeSettings?: CompleteThemeSettings) => HighchartsOptionsInternal;
+/**
+ * Returns default theme settings, which can be used as base for custom theme options.
+ *
+ * @returns Theme settings object
+ *
+ * @internal
+ */
+export declare const getDefaultThemeSettings: () => CompleteThemeSettings;

package/dist/chart-options-processor/tooltip.d.ts

@@ -0,0 +1,29 @@
+import { ChartDataOptionsInternal } from '../chart-data-options/types';
+import { TooltipOptions } from '@sisense/sisense-charts';
+export type TooltipSettings = TooltipOptions;
+export type InternalSeriesNode = {
+    val: number;
+    name: string;
+    parentNode?: InternalSeriesNode;
+};
+export type InternalSeries = {
+    series: {
+        name: string;
+        color: string;
+    };
+    x: string;
+    y: number;
+    point: {
+        name: string;
+        color: string;
+        custom?: {
+            number1?: number;
+            string1?: string;
+            xDisplayValue?: string;
+        };
+        node?: InternalSeriesNode;
+    };
+    percentage?: number;
+    color?: string;
+};
+export declare const getTooltipSettings: (showDecimals: boolean | undefined, chartDataOptions: ChartDataOptionsInternal) => TooltipSettings;

package/dist/chart-options-processor/translations/axis-section.d.ts

@@ -0,0 +1,105 @@
+import { Style } from '../chart-options-service';
+import { ChartDataOptionsInternal, Category } from '../../chart-data-options/types';
+import { ChartType } from '../../types';
+import { CategoricalXValues } from '../../chart-data/types';
+export type Axis = {
+    enabled?: boolean;
+    titleEnabled?: boolean;
+    title?: string | null;
+    gridLine?: boolean;
+    labels?: boolean;
+    type?: 'linear' | 'logarithmic';
+    min?: number | null;
+    max?: number | null;
+    tickInterval?: number | null;
+};
+export type AxisMinMax = {
+    min: number;
+    max: number;
+};
+export type AxisOrientation = 'horizontal' | 'vertical';
+interface AxisLabelsFormatterContextObject {
+    value: string | number;
+    axis: {
+        categories: (string | number)[];
+    };
+}
+export type AxisSettings = {
+    type?: 'linear' | 'logarithmic';
+    title?: {
+        text?: string | null;
+        enabled?: boolean;
+        margin?: number;
+        style?: Style;
+    };
+    gridLineDashStyle?: 'Dot';
+    gridLineWidth?: number;
+    gridLineColor?: string;
+    tickWidth?: number;
+    lineColor?: string;
+    lineWidth?: number;
+    labels?: {
+        overflow?: 'none' | 'justify';
+        enabled?: boolean;
+        autoRotation?: number[];
+        style?: Style;
+        rotation?: number;
+        formatter?: (this: AxisLabelsFormatterContextObject) => string;
+    };
+    min?: number | null;
+    max?: number | null;
+    minPadding?: number;
+    maxPadding?: number;
+    tickInterval?: number | null;
+    categories?: string[];
+    opposite?: boolean;
+    plotBands?: AxisPlotBand[];
+    plotLines?: AxisPlotLine[];
+    tickmarkPlacement?: string;
+    minorGridLineWidth?: number;
+    minorTickWidth?: number;
+    startOnTick?: boolean;
+    endOnTick?: boolean;
+    tickColor?: string;
+    tickLength?: number;
+    minorTickColor?: string;
+    minorTickLength?: number;
+    minorGridLineColor?: string;
+    minorGridLineDashStyle?: string;
+    stackLabels?: StackLabel;
+    showLastLabel?: boolean;
+};
+export type StackLabel = {
+    style: Style;
+    crop: boolean;
+    allowOverlap: boolean;
+    enabled: boolean;
+    rotation: number;
+    labelrank: number;
+};
+export type PlotBand = {
+    text: string;
+    from: number;
+    to: number;
+};
+export type AxisPlotLine = {
+    color: string;
+    dashStyle: string;
+    width: number;
+    value: number;
+};
+export type AxisPlotBand = {
+    isPlotBand: boolean;
+    from: number;
+    to: number;
+    label: {
+        text: string;
+        y: number;
+        style?: Style;
+    };
+};
+export declare const getCategoricalCompareValue: (value: CategoricalXValues) => number;
+export declare const getXAxisDatetimeSettings: (axis: Axis, category: Category, values: number[], dateFormatter?: ((date: Date, format: string) => string) | undefined) => AxisSettings[];
+export declare const getXAxisSettings: (axis: Axis, axis2: Axis | undefined, categories: string[], plotBands: PlotBand[], xAxisOrientation: AxisOrientation, chartDataOptions: ChartDataOptionsInternal, chartType: ChartType) => AxisSettings[];
+export declare const getYAxisSettings: (axis: Axis, axis2: Axis | undefined, axisMinMax: AxisMinMax, axis2MinMax: AxisMinMax, showTotal: boolean, chartDataOptions: ChartDataOptionsInternal) => AxisSettings[];
+export {};

package/dist/chart-options-processor/translations/base-design-options.d.ts

@@ -0,0 +1,7 @@
+import { ChartDesignOptions } from './types';
+import { Merge } from '../../utils/utility-types';
+export declare const SERIES_CAPACITY = 50;
+export declare const SCATTER_CATEGORIES_CAPACITY = 500;
+export declare const CATEGORIES_CAPACITY = 100000;
+export declare const BaseDesignOptions: Merge<ChartDesignOptions>;
+export declare const BaseDesignOptionsMultipleAxis: ChartDesignOptions;