@sisense/sdk-ui 0.15.0 → 1.0.0

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

@@ -9,7 +9,7 @@ import { HighchartsType, HighchartsSeriesValues } from './translations/translati
 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 { ChartType, OptionsWithAlerts, CompleteThemeSettings, ChartStyleOptions, HighchartsSelectEvent } from '../types';
 import { ChartDataOptionsInternal } from '../chart-data-options/types';
 import { ScatterBubbleOptions } from './translations/scatter-plot-options';
 /**
@@ -30,9 +30,6 @@ export type HighchartsOptions = Pick<Options, keyof Options>;
  * @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;
@@ -46,6 +43,14 @@ export type SeriesType = HighchartsSeriesValues & {
     marker?: MarkerSettings;
     type?: string;
     id?: string;
+    medianWidth?: number;
+    maxPointWidth?: number;
+    minPointWidth?: number;
+    whiskerWidth?: number;
+    whiskerLength?: number | string;
+    fillOpacity?: number;
+    strokeOpacity?: number;
+    legendIndex?: number;
 };
 type ChartPlotOptions = {
     dataLabels?: ValueLabelSettings;
@@ -81,6 +86,7 @@ export type PlotOptions = {
         allowPointSelect?: boolean;
         boostThreshold?: number;
         turboThreshold?: number;
+        softThreshold?: boolean;
         fillOpacity?: number;
         connectNulls?: boolean;
         animation?: {
@@ -95,6 +101,8 @@ export type PlotOptions = {
     funnel?: FunnelOptions;
     bubble?: ScatterBubbleOptions;
     sunburst?: ChartPlotOptions;
+    boxplot?: ChartPlotOptions;
+    scatter?: ChartPlotOptions;
 };
 /**
  * Highcharts options internal
@@ -106,6 +114,7 @@ export type HighchartsOptionsInternal = {
         events?: {
             load?: () => void;
             redraw?: () => void;
+            selection?: (nativeEvent: HighchartsSelectEvent) => void;
         };
         spacing?: number[];
         marginTop?: number;
@@ -114,6 +123,9 @@ export type HighchartsOptionsInternal = {
         animation?: {
             duration?: number;
         };
+        zooming?: {
+            type: string;
+        };
     };
     title?: {
         text: string | null;
@@ -158,15 +170,16 @@ type Navigator = {
         dataGrouping: {
             enabled: boolean;
         };
+        color?: string;
     };
     enabled: boolean;
     margin: number;
     height: number;
     xAxis: AxisSettings;
     handles: {
-        symbols: string[];
-        backgroundColor: string;
-        borderColor: string;
+        symbols?: string[];
+        backgroundColor?: string;
+        borderColor?: string;
     };
     maskInside: boolean;
     maskFill: string;
@@ -178,76 +191,7 @@ type Navigator = {
         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: true;
-        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;
-    };
-};
+declare const DEFAULT_STYLE_OPTIONS: ChartStyleOptions;
 /**
  * Returns default style options, which can be used as base for custom style options.
  *

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

@@ -1,4 +1,4 @@
-import { ChartType, StyleOptions } from '../../types';
+import { ChartType, ChartStyleOptions } 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;
+export declare const translateStyleOptionsToDesignOptions: (chartType: ChartType, styleOptions: ChartStyleOptions, dataOptions: ChartDataOptionsInternal) => ChartDesignOptions;

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

@@ -1,5 +1,5 @@
-import { Legend, PolarStyleOptions, PieStyleOptions, StackableStyleOptions, LineStyleOptions, AreaStyleOptions, FunnelStyleOptions, ScatterStyleOptions, TreemapStyleOptions, SunburstStyleOptions } from '../../types';
-import { StackableChartDesignOptions, LineChartDesignOptions, PieChartDesignOptions, FunnelChartDesignOptions, PolarChartDesignOptions, ScatterChartDesignOptions, AreaChartDesignOptions, TreemapChartDesignOptions, SunburstChartDesignOptions } from '../translations/design-options';
+import { Legend, PolarStyleOptions, PieStyleOptions, StackableStyleOptions, LineStyleOptions, AreaStyleOptions, FunnelStyleOptions, ScatterStyleOptions, TreemapStyleOptions, SunburstStyleOptions, BoxplotStyleOptions, ScattermapStyleOptions } from '../../types';
+import { StackableChartDesignOptions, LineChartDesignOptions, PieChartDesignOptions, FunnelChartDesignOptions, PolarChartDesignOptions, ScatterChartDesignOptions, AreaChartDesignOptions, TreemapChartDesignOptions, SunburstChartDesignOptions, BoxplotChartDesignOptions, ScattermapChartDesignOptions } from '../translations/design-options';
 import { LegendPosition } from '../translations/legend-section';
 import { StackType } from '../translations/translations-to-highcharts';
 export declare const getLegend: (legend?: Legend) => LegendPosition;
@@ -14,3 +14,5 @@ export declare const getTreemapChartDesignOptions: (styleOptions: TreemapStyleOp
 export declare const getSunburstChartDesignOptions: (styleOptions: SunburstStyleOptions) => SunburstChartDesignOptions;
 export declare const getPolarChartDesignOptions: (styleOptions: PolarStyleOptions) => PolarChartDesignOptions;
 export declare const getScatterChartDesignOptions: (styleOptions: ScatterStyleOptions) => ScatterChartDesignOptions;
+export declare const getBoxplotChartDesignOptions: (styleOptions: BoxplotStyleOptions) => BoxplotChartDesignOptions;
+export declare const getScattermapChartDesignOptions: (styleOptions: ScattermapStyleOptions) => ScattermapChartDesignOptions;

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

@@ -1,5 +1,5 @@
 import { LineType, StackType } from './translations/translations-to-highcharts';
-import { IndicatorStyleType, PolarType } from './translations/design-options';
+import { IndicatorStyleType, PolarType, BoxplotType } from './translations/design-options';
 /**
  * Property of {@link LineStyleOptions}
  *
@@ -88,11 +88,14 @@ export type IndicatorSubtype = 'indicator/numeric' | 'indicator/gauge';
  */
 export type TreemapSubtype = 'treemap';
 export type SunburstSubtype = 'sunburst';
-export type ChartSubtype = LineSubtype | AreaSubtype | StackableSubtype | PieSubtype | PolarSubtype | IndicatorSubtype | TreemapSubtype | SunburstSubtype;
+export type BoxplotSubtype = 'boxplot/full' | 'boxplot/hollow';
+export type ScattermapSubtype = 'scattermap';
+export type ChartSubtype = LineSubtype | AreaSubtype | StackableSubtype | PieSubtype | PolarSubtype | IndicatorSubtype | TreemapSubtype | SunburstSubtype | BoxplotSubtype | ScattermapSubtype;
 export declare const chartSubtypeToDesignOptions: Readonly<Record<ChartSubtype, {
     lineType?: LineType | undefined;
     stackType?: StackType | undefined;
     pieType?: "classic" | "donut" | "ring" | undefined;
     polarType?: PolarType | undefined;
     indicatorType?: IndicatorStyleType | undefined;
+    boxplotType?: BoxplotType | undefined;
 }>>;

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

@@ -5,7 +5,6 @@ export declare const applyThemeToChart: (chartOptions: 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/translations/axis-section.d.ts

@@ -2,6 +2,7 @@ import { Style } from '../chart-options-service';
 import { ChartDataOptionsInternal, Category } from '../../chart-data-options/types';
 import { ChartType } from '../../types';
 import { CategoricalXValues } from '../../chart-data/types';
+import { AxisClipped } from './translations-to-highcharts';
 export type Axis = {
     enabled?: boolean;
     titleEnabled?: boolean;
@@ -18,7 +19,7 @@ export type AxisMinMax = {
     max: number;
 };
 export type AxisOrientation = 'horizontal' | 'vertical';
-interface AxisLabelsFormatterContextObject {
+export interface AxisLabelsFormatterContextObject {
     value: string | number;
     axis: {
         categories: (string | number)[];
@@ -68,6 +69,7 @@ export type AxisSettings = {
     minorGridLineDashStyle?: string;
     stackLabels?: StackLabel;
     showLastLabel?: boolean;
+    visible?: boolean;
 };
 export type StackLabel = {
     style: Style;
@@ -102,5 +104,4 @@ export declare const getCategoricalCompareValue: (value: CategoricalXValues) =>
 export declare const getDateFormatter: (category: Category, dateFormatter?: ((date: Date, format: string) => string) | undefined) => (time: number) => string;
 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 {};
+export declare const getYAxisSettings: (axis: Axis, axis2: Axis | undefined, axisMinMax: AxisMinMax, axis2MinMax: AxisMinMax | undefined, showTotal: boolean, chartDataOptions: ChartDataOptionsInternal) => [AxisSettings[], AxisClipped[]];

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

@@ -0,0 +1,10 @@
+import { BoxplotChartData } from '../../../chart-data/types';
+import { Axis, AxisSettings } from '../axis-section';
+import { Value, type Category } from '../../../chart-data-options/types';
+export declare const commonColor = "#d1d1d7";
+export declare const calculateYAxisMinMax: (chartData: BoxplotChartData) => {
+    min: number;
+    max: number;
+};
+export declare const getBoxplotXAxisSettings: (axis: Axis, categories: string[], axisDataOption?: Category) => AxisSettings[];
+export declare const getBoxplotYAxisSettings: (axis: Axis, chartData: BoxplotChartData, axisDataOption?: Value) => AxisSettings[];

package/dist/chart-options-processor/translations/boxplot/boxplot-plot-options.d.ts

@@ -0,0 +1,3 @@
+import { PlotOptions } from '../../chart-options-service.js';
+import { ValueLabel } from '../value-label-section.js';
+export declare const getBoxplotPlotOptions: (valueLabel: ValueLabel) => PlotOptions;

package/dist/chart-options-processor/translations/boxplot/boxplot-series.d.ts

@@ -0,0 +1,5 @@
+import { SeriesType } from '../../chart-options-service.js';
+import { BoxplotChartData } from '../../../chart-data/types.js';
+import { SeriesWithAlerts } from '../../../types.js';
+import { BoxplotChartDesignOptions } from '../design-options.js';
+export declare const buildBoxplotSeries: (data: BoxplotChartData, chartDesignOptions: BoxplotChartDesignOptions) => SeriesWithAlerts<SeriesType[]>;

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

@@ -0,0 +1,3 @@
+import { BoxplotChartDataOptionsInternal } from '../../../chart-data-options/types';
+import { TooltipSettings } from '../tooltip-utils';
+export declare const getBoxplotTooltipSettings: (dataOptions: BoxplotChartDataOptionsInternal) => TooltipSettings;

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

@@ -5,7 +5,7 @@ import { LegendPosition } from './legend-section';
 import { LineType, StackType } from './translations-to-highcharts';
 import { PieType, PieLabels } from './pie-plot-options';
 import { FunnelSize, FunnelType, FunnelDirection, FunnelLabels } from './funnel-plot-options';
-import { Convolution, SunburstStyleOptions, TreemapStyleOptions } from '../../types';
+import { Convolution, ScattermapMarkers, SunburstStyleOptions, TreemapStyleOptions } from '../../types';
 import { ScatterMarkerSize } from './scatter-plot-options';
 type DataLimits = {
     seriesCapacity: number;
@@ -81,7 +81,7 @@ export type IndicatorComponents = {
         /** The text of the title */
         text?: string;
     };
-    /** The secondary title of the indicator chart to be shown when `secondary` is specified in {@link IndicatorDataOptions} */
+    /** The secondary title of the indicator chart to be shown when `secondary` is specified in {@link IndicatorChartDataOptions} */
     secondaryTitle?: {
         /** The text of the secondary title */
         text?: string;
@@ -116,4 +116,11 @@ export type PolarType = 'line' | 'area' | 'column';
 export type PolarChartDesignOptions = BaseDesignOptionsType & {
     polarType: PolarType;
 };
+export type BoxplotType = 'full' | 'hollow';
+export type BoxplotChartDesignOptions = BaseDesignOptionsType & {
+    boxplotType: BoxplotType;
+};
+export type ScattermapChartDesignOptions = BaseDesignOptionsType & {
+    markers: Required<ScattermapMarkers>;
+};
 export {};

package/dist/chart-options-processor/translations/funnel-series.d.ts

@@ -1,9 +1,8 @@
-import { Color, SeriesWithAlerts, CompleteThemeSettings } from '../../types';
+import { SeriesWithAlerts, CompleteThemeSettings } from '../../types';
 import { SeriesType } from '../chart-options-service';
 import { FunnelChartDesignOptions } from './design-options';
 import { CategoricalChartData } from '../../chart-data/types';
 import { CategoricalChartDataOptionsInternal } from '../../chart-data-options/types';
-export declare const getAPaletteColor: (colors: Color[] | undefined, index: number) => string;
 /**
  * Convert categorical chart data into renderable highcharts funnel series. *
  *

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

@@ -2,16 +2,16 @@ import { Style } from '../chart-options-service';
 export type LegendPosition = 'top' | 'left' | 'right' | 'bottom' | null;
 export type LegendSettings = {
     enabled: boolean;
-    align: 'center' | 'left' | 'right';
-    verticalAlign: 'top' | 'middle' | 'bottom';
-    layout: 'horizontal' | 'vertical';
+    align?: 'center' | 'left' | 'right';
+    verticalAlign?: 'top' | 'middle' | 'bottom';
+    layout?: 'horizontal' | 'vertical';
     itemStyle?: Style & {
         cursor?: string;
     };
     symbolRadius?: number;
     symbolHeight?: number;
     symbolWidth?: number;
-    borderWidth?: string;
+    borderWidth?: number;
     borderColor?: string;
     backgroundColor?: string;
     title?: {
@@ -19,5 +19,7 @@ export type LegendSettings = {
             [key: string]: string | number;
         };
     };
+    maxHeight?: number;
 };
+export declare const legendItemStyleDefault: LegendSettings['itemStyle'];
 export declare const getLegendSettings: (position: LegendPosition) => LegendSettings;

package/dist/chart-options-processor/translations/pie-series.d.ts

@@ -1,9 +1,8 @@
-import { Color, SeriesWithAlerts, CompleteThemeSettings } from '../../types';
+import { SeriesWithAlerts, CompleteThemeSettings } from '../../types';
 import { CategoricalChartDataOptionsInternal } from '../../chart-data-options/types';
 import { SeriesType } from '../chart-options-service';
 import { PieChartDesignOptions } from './design-options';
 import { CategoricalChartData } from '../../chart-data/types';
-export declare const getAPaletteColor: (colors: Color[] | undefined, index: number) => string;
 type FormattedPieChartData = SeriesWithAlerts<SeriesType[]> & {
     convolutionSeries: SeriesType[];
 };

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

@@ -26,6 +26,11 @@ export type InternalSeries = {
         x?: number | string;
         y?: number;
         z?: number;
+        high?: number;
+        low?: number;
+        q1?: number;
+        q3?: number;
+        median?: number;
         name: string;
         color: string;
         custom?: {

package/dist/chart-options-processor/translations/translations-to-highcharts.d.ts

@@ -2,7 +2,7 @@ import { ChartType } from '../../types';
 import { ChartDataOptionsInternal, CategoricalChartDataOptionsInternal, CartesianChartDataOptionsInternal } from '../../chart-data-options/types';
 import { CategoricalSeriesValues, ChartData, CartesianChartData } from '../../chart-data/types';
 import { StackableChartDesignOptions } from './design-options';
-import { AxisMinMax } from './axis-section';
+import { AxisMinMax, AxisSettings } from './axis-section';
 import { Stacking } from '../chart-options-service';
 import { ChartDesignOptions } from './types';
 export type LineType = 'straight' | 'smooth';
@@ -40,6 +40,10 @@ export type SeriesPointStructure = {
     drilldown?: string;
     parent?: string;
 };
+export type AxisClipped = {
+    minClipped: boolean;
+    maxClipped: boolean;
+};
 /**
  * Translate public-facing chart type and chart design options to internal highcharts chart type
  *
@@ -61,9 +65,13 @@ export declare const addStackingIfSpecified: (chartType: ChartType, designOption
  * @param categories -
  * @param index -
  */
-export declare const indexMapWhenOnlyY: (categories: string[], index: number) => (0 | -1)[];
-export declare const formatSeriesContinuousXAxis: (series: CategoricalSeriesValues, indexMap: number[], treatNullDataAsZeros: boolean, interval: number, maxCategories: number, dateFormatter: (time: number) => string) => HighchartsSeriesValues;
+export declare const indexMapWhenOnlyY: (categories: string[], index: number) => (-1 | 0)[];
+export declare const formatSeriesContinuousXAxis: (series: CategoricalSeriesValues, indexMap: number[], treatNullDataAsZeros: boolean, interval: number, maxCategories: number, dateFormatter: (time: number) => string, yAxisSettings: AxisSettings, axisClipped: AxisClipped) => HighchartsSeriesValues;
 export declare const formatSeries: (series: CategoricalSeriesValues, indexMap: number[], treatNullDataAsZeros: boolean, categories?: string[], categoryColors?: string[]) => HighchartsSeriesValues;
+export declare const adjustMinMaxWhenInvalid: (explicitAxis: AxisMinMax, autoMinMax: AxisMinMax) => {
+    min: number;
+    max: number;
+};
 export declare const adjustMinWhenColumnBar: (chartType: ChartType, autoMinMax: AxisMinMax) => {
     min: number;
     max: number;

package/dist/chart-options-processor/translations/types.d.ts

@@ -1,6 +1,6 @@
 import { ChartDataOptionsInternal } from '../../chart-data-options/types';
 import { ChartType } from '../../types';
-import { LineChartDesignOptions, AreaChartDesignOptions, BarChartDesignOptions, ColumnChartDesignOptions, PieChartDesignOptions, FunnelChartDesignOptions, IndicatorChartDesignOptions, PolarChartDesignOptions, ScatterChartDesignOptions, TreemapChartDesignOptions } from './design-options';
+import { LineChartDesignOptions, AreaChartDesignOptions, BarChartDesignOptions, ColumnChartDesignOptions, PieChartDesignOptions, FunnelChartDesignOptions, IndicatorChartDesignOptions, PolarChartDesignOptions, ScatterChartDesignOptions, TreemapChartDesignOptions, BoxplotChartDesignOptions, ScattermapChartDesignOptions } from './design-options';
 export declare const POLAR_CHART_TYPES: readonly ["polar"];
 export type PolarChartType = (typeof POLAR_CHART_TYPES)[number];
 export declare const CARTESIAN_CHART_TYPES: readonly ["line", "area", "bar", "column", "polar"];
@@ -18,10 +18,16 @@ export type TableType = (typeof TABLE_TYPES)[number];
 declare const INDICATOR_CHART_TYPES: readonly ["indicator"];
 /** Indicator chart types @expandType */
 export type IndicatorChartType = (typeof INDICATOR_CHART_TYPES)[number];
+declare const BOXPLOT_CHART_TYPES: readonly ["boxplot"];
+/** Boxplot chart types  @expandType */
+export type BoxplotChartType = (typeof BOXPLOT_CHART_TYPES)[number];
 declare const IMAGE_CHART_TYPES: readonly ["image"];
 export type ImageChartType = (typeof IMAGE_CHART_TYPES)[number];
+export declare const SCATTERMAP_CHART_TYPES: readonly ["scattermap"];
+/** Scattermap chart types  @expandType */
+export type ScattermapChartType = (typeof SCATTERMAP_CHART_TYPES)[number];
 export type ChartDataType = 'cartesian' | 'categorical' | 'scatter' | 'table' | 'indicator';
-export type ChartDesignOptions = LineChartDesignOptions | AreaChartDesignOptions | BarChartDesignOptions | ColumnChartDesignOptions | PieChartDesignOptions | FunnelChartDesignOptions | PolarChartDesignOptions | IndicatorChartDesignOptions | ScatterChartDesignOptions | TreemapChartDesignOptions;
+export type ChartDesignOptions = LineChartDesignOptions | AreaChartDesignOptions | BarChartDesignOptions | ColumnChartDesignOptions | PieChartDesignOptions | FunnelChartDesignOptions | PolarChartDesignOptions | IndicatorChartDesignOptions | ScatterChartDesignOptions | TreemapChartDesignOptions | BoxplotChartDesignOptions | ScattermapChartDesignOptions;
 export type ChartConfig = {
     chartType: ChartType;
     dataOptions: ChartDataOptionsInternal;
@@ -30,7 +36,9 @@ export type ChartConfig = {
 export declare const isCartesian: (chartType: ChartType) => chartType is "area" | "line" | "bar" | "column" | "polar";
 export declare const isCategorical: (chartType: ChartType) => chartType is "pie" | "funnel" | "treemap" | "sunburst";
 export declare const isScatter: (chartType: ChartType) => chartType is "scatter";
+export declare const isScattermap: (chartType: ChartType) => chartType is "scattermap";
 export declare const isIndicator: (chartType: ChartType) => chartType is "indicator";
 export declare const isPolar: (chartType: ChartType) => chartType is "polar";
 export declare const isTable: (chartType: ChartType | TableType) => chartType is "table";
+export declare const isBoxplot: (chartType: ChartType) => chartType is "boxplot";
 export {};

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

@@ -1,3 +1,4 @@
+import type { DataLabelsOptions } from '@sisense/sisense-charts';
 import { Style } from '../chart-options-service';
 import { NumberFormatConfig } from './number-format-config';
 import { AxisOrientation } from './axis-section';
@@ -21,7 +22,7 @@ export type ValueLabelSettings = {
         relative: boolean;
         totals: boolean;
     };
-    formatter?: (this: InternalSeries) => string;
+    formatter?: (this: InternalSeries, options?: DataLabelsOptions, valuePropName?: string) => string;
 };
 export declare const createValueLabelFormatter: (numberFormatConfig?: NumberFormatConfig) => (this: InternalSeries) => string;
 export declare const getValueLabelSettings: (xAxisOrientation: AxisOrientation, valueLabel: ValueLabel, inside?: boolean) => ValueLabelSettings;

package/dist/chart.d.ts

@@ -14,10 +14,10 @@ export declare const shouldSkipSisenseContextWaiting: (props: ChartProps) => boo
  *   dataSet={DM.DataSource}
  *   dataOptions={{
  *     category: [DM.Commerce.AgeRange],
- *     value: [measures.sum(DM.Commerce.Revenue)],
+ *     value: [measureFactory.sum(DM.Commerce.Revenue)],
  *     breakBy: [DM.Commerce.Gender],
  *   }}
- *   filters={[filters.members(DM.Commerce.Gender,['Female', 'Male'])]}
+ *   filters={[filterFactory.members(DM.Commerce.Gender,['Female', 'Male'])]}
  *   onDataPointClick= {(point, nativeEvent) => { console.log('clicked', point, nativeEvent); }}
  * />
  * ```

package/dist/charts/indicator/indicator-legacy-chart-data-options.d.ts

@@ -1,9 +1,9 @@
-import { IndicatorDataOptions } from '../../chart-data-options/types';
+import { IndicatorChartDataOptions } from '../../chart-data-options/types';
 import { IndicatorChartDesignOptions } from '../../chart-options-processor/translations/design-options';
 import { IndicatorChartData } from '../../chart-data/types';
 import { LegacyIndicatorChartTypes } from './types';
 export type IndicatorLegacyChartDataOptions = ReturnType<typeof createLegacyChartDataOptions>;
-export declare const createLegacyChartDataOptions: (chartData: IndicatorChartData, chartDesignOptions: IndicatorChartDesignOptions, chartDataOptions: IndicatorDataOptions) => {
+export declare const createLegacyChartDataOptions: (chartData: IndicatorChartData, chartDesignOptions: IndicatorChartDesignOptions, chartDataOptions: IndicatorChartDataOptions) => {
     type: LegacyIndicatorChartTypes;
     skin: 1 | 2 | "vertical" | "horizontal";
     title: {

package/dist/charts/indicator/indicator-legacy-chart-options/indicator-legacy-chart-options.d.ts

@@ -1,10 +1,10 @@
 import { IndicatorStyleType, NumericIndicatorSubType } from '../../../chart-options-processor/translations/design-options';
-import { IndicatorDataOptions, ThemeSettings } from '../../../types';
+import { IndicatorChartDataOptions, ThemeSettings } from '../../../types';
 import { LegacyIndicatorChartOptions } from '../types';
 import { IndicatorChartData } from '../../../chart-data/types';
 export type ChartRenderingOptions = {
     chartData: IndicatorChartData;
-    dataOptions: IndicatorDataOptions;
+    dataOptions: IndicatorChartDataOptions;
     themeSettings?: ThemeSettings;
 };
 export type IndicatorTypeOptions = {

package/dist/charts/indicator/indicator-legacy-chart-options/override-with-value-color.d.ts

@@ -1,4 +1,4 @@
-import { IndicatorDataOptions, ConditionalDataColorOptions, DataColorOptions, UniformDataColorOptions } from '../../../types';
+import { IndicatorChartDataOptions, ConditionalDataColorOptions, DataColorOptions, UniformDataColorOptions } from '../../../types';
 import { LegacyIndicatorChartOptions } from '../types';
 import { IndicatorTypeOptions } from './indicator-legacy-chart-options';
 /**
@@ -15,7 +15,7 @@ export type AllowedIndicatorColoringTypes = 'Static' | 'Absolute';
  * @param dataOptions - The indicator data options to extract the color options from.
  * @returns The color options from the indicator data options.
  */
-export declare function getValueColorOptions(dataOptions: IndicatorDataOptions): DataColorOptions | undefined;
+export declare function getValueColorOptions(dataOptions: IndicatorChartDataOptions): DataColorOptions | undefined;
 /**
  * Overrides the value color in the legacy indicator chart options with the specified color.
  *

package/dist/charts/scattermap/hooks/use-locations.d.ts

@@ -0,0 +1,3 @@
+import { Location } from '../types.js';
+import { ScattermapLocationLevel } from '../../../chart-data-options/types.js';
+export declare const useLocations: (locationsNames: string[], locationLevel: ScattermapLocationLevel) => Location[] | null;

package/dist/charts/scattermap/hooks/use-settings.d.ts

@@ -0,0 +1,5 @@
+type GeoSettings = {
+    maps_api_provider: string;
+};
+export declare const useGeoSettings: () => GeoSettings | null;
+export {};

package/dist/charts/scattermap/hooks/use-tooltip-handler.d.ts

@@ -0,0 +1,14 @@
+import { ScattermapChartLocation } from '../../../chart-data/types';
+import { ScattermapChartDataOptionsInternal } from '../../../chart-data-options/types.js';
+import { DataSource, Filter } from '@sisense/sdk-data';
+export type TooltipOptions = {
+    content: string;
+    postponedContent?: Promise<string>;
+};
+type TooltipHandler = (location: ScattermapChartLocation) => TooltipOptions;
+export declare const useTooltipHandler: ({ dataOptions, dataSource, filters, }: {
+    dataOptions: ScattermapChartDataOptionsInternal;
+    dataSource: DataSource | null;
+    filters?: Filter[] | undefined;
+}) => TooltipHandler;
+export {};

package/dist/charts/scattermap/scattermap.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import { ScattermapChartData } from '../../chart-data/types.js';
+import { ScattermapChartDataOptionsInternal } from '../../chart-data-options/types.js';
+import { ScattermapChartDesignOptions } from '../../chart-options-processor/translations/design-options.js';
+import { DataSource, Filter, FilterRelation } from '@sisense/sdk-data';
+export type ScattermapProps = {
+    chartData: ScattermapChartData;
+    dataOptions: ScattermapChartDataOptionsInternal;
+    designOptions: ScattermapChartDesignOptions;
+    dataSource: DataSource | null;
+    filters?: Filter[] | FilterRelation;
+};
+export declare const Scattermap: ({ chartData, dataOptions, dataSource, filters, designOptions, }: ScattermapProps) => JSX.Element;

package/dist/charts/scattermap/types.d.ts

@@ -0,0 +1,16 @@
+export type Coordinates = {
+    lat: number;
+    lng: number;
+};
+export type Location = {
+    _id: string;
+    lookupKey: string;
+    placetype: null | string;
+    context: null | string;
+    err: null | string;
+    latLng: Coordinates;
+    name: string;
+    place_name: string;
+    text: string;
+    version: string;
+};

package/dist/charts/scattermap/utils/color.d.ts

@@ -0,0 +1,3 @@
+import { ScattermapChartLocation } from '../../../chart-data/types.js';
+import { DataColorOptions } from '../../../types.js';
+export declare function getLocationsMarkerColors(locations: ScattermapChartLocation[], colorOptions?: DataColorOptions): string[];

package/dist/charts/scattermap/utils/copyright.d.ts

@@ -0,0 +1,2 @@
+import leaflet from 'leaflet';
+export declare function addCopyright(map: leaflet.Map, mapUrl: string): leaflet.Control.Attribution;

package/dist/charts/scattermap/utils/location.d.ts

@@ -0,0 +1,5 @@
+import { ScattermapLocationLevel } from 'packages/sdk-ui/src/chart-data-options/types';
+export declare const LOCATION_DELIMITER = ",";
+export declare function combineLocationNames(names: string[]): string;
+export declare function splitLocationName(combinedLocation: string): string[];
+export declare function getLocationGeoLevel(level: ScattermapLocationLevel): "country" | "city" | "adm" | undefined;

package/dist/charts/scattermap/utils/map.d.ts

@@ -0,0 +1,2 @@
+import leaflet from 'leaflet';
+export declare function fitMapToBounds(map: leaflet.Map, markers: leaflet.CircleMarker[]): void;

package/dist/charts/scattermap/utils/markers.d.ts

@@ -0,0 +1,28 @@
+import leaflet from 'leaflet';
+import { ScattermapMarkers } from 'packages/sdk-ui/src/types';
+type PrepareMarkerOptionsProps = {
+    color: string;
+    size: number;
+    fill: Required<ScattermapMarkers>['fill'];
+    blur: boolean;
+};
+type CreateMarkerProps = {
+    coordinates: {
+        lat: number;
+        lng: number;
+    };
+    style: PrepareMarkerOptionsProps;
+};
+export declare function prepareMarkerOptions(style: PrepareMarkerOptionsProps): {
+    radius: number;
+    fillOpacity: number;
+    opacity: number;
+    fillColor: string;
+    color: string;
+    stroke: boolean;
+    weight: number;
+    customStyle: PrepareMarkerOptionsProps;
+};
+export declare function createMarker({ coordinates, style }: CreateMarkerProps): leaflet.CircleMarker<any>;
+export declare function removeMarkers(markers: leaflet.CircleMarker[]): void;
+export {};