@sisense/sdk-ui 0.15.0 → 1.0.0

package/dist/api/types/dashboard-dto.d.ts

@@ -1,8 +1,9 @@
 import { WidgetDto, Datasource } from '../../dashboard-widget/types';
 import { FilterJaql } from '@sisense/sdk-data';
+import { AnyObject } from '../../utils/utility-types';
 export type Filter = {
     isCascading?: false;
-    jaql: FilterJaql;
+    jaql: FilterJaql & AnyObject;
     instanceid?: string;
     disabled?: boolean;
 };
@@ -18,4 +19,4 @@ export type DashboardDto = {
     datasource: Datasource;
     widgets?: WidgetDto[];
     filters?: Array<Filter | CascadingFilter>;
-};
+} & AnyObject;

package/dist/area-chart.d.ts

@@ -12,11 +12,11 @@ import { AreaChartProps } from './props';
  *   dataSet={DM.DataSource}
  *   dataOptions={{
  *     category: [DM.Commerce.Date.Years],
- *     value: [measures.sum(DM.Commerce.Revenue)],
+ *     value: [measureFactory.sum(DM.Commerce.Revenue)],
  *     breakBy: [DM.Commerce.Gender],
  *   }}
  *   styleOptions={{ subtype: 'area/stacked' }}
- *   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/bar-chart.d.ts

@@ -12,10 +12,10 @@ import { BarChartProps } from './props';
  *   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.greaterThan(DM.Commerce.Revenue, 1000)]}
+ *   filters={[filterFactory.greaterThan(DM.Commerce.Revenue, 1000)]}
  *   onDataPointClick={(point, nativeEvent) => {
  *     console.log('clicked', point, nativeEvent);
  *   }}

package/dist/boxplot-chart.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="react" />
+import { BoxplotChartProps } from './props';
+/**
+ * A React component representing data in a way that visually describes the distribution, variability,
+ * and center of a data set along an axis.
+ * See [Boxplot Chart](https://docs.sisense.com/main/SisenseLinux/box-and-whisker-plot.htm) for more information.
+ *
+ * This component is still in beta.
+ *
+ * @example
+ * An example of using the component to visualize the `Sample ECommerce` data source:
+ * ```tsx
+ * <BoxplotChart
+ *   dataSet={DM.DataSource}
+ *   dataOptions={{
+ *     category: [DM.Category.Category],
+ *     value: [DM.Commerce.Cost],
+ *     boxType: 'iqr',
+ *     outliersEnabled: true,
+ *   }}
+ *   filters={[
+ *     filterFactory.members(DM.Category.Category, ['Calculators', 'DVD Players', 'Routers']),
+ *     filterFactory.members(DM.Commerce.AgeRange, ['19-24']),
+ *   ]}
+ *   styleOptions={{
+ *     seriesLabels: {
+ *       enabled: true,
+ *     }
+ *   }}
+ * />
+ * ```
+ *
+ * <img src="media://boxplot-chart-example-1.png" width="600px" />
+ * @param props - Boxplot chart properties
+ * @returns Boxplot Chart component
+ * @beta
+ */
+export declare const BoxplotChart: import("react").FunctionComponent<BoxplotChartProps>;

package/dist/boxplot-utils.d.ts

@@ -0,0 +1,30 @@
+import { Attribute, Measure, Filter, QueryResultData, DataSource } from '@sisense/sdk-data';
+import { ClientApplication } from './app/client-application.js';
+import { BoxplotChartCustomDataOptions, BoxplotChartDataOptionsInternal } from './chart-data-options/types.js';
+/**
+ * Processes box whisker data and outliers data to combine them into a single data set.
+ *
+ * @param {QueryResultData} boxWhiskerData - The data for the box whisker.
+ * @param {QueryResultData} outliersData - The data for the outliers.
+ * @param {BoxplotChartDataOptionsInternal} [dataOptions] - Optional data options for customizing data processing.
+ * @returns {QueryResultData} The combined data with outliers included in the box whisker plot.
+ */
+export declare const boxWhiskerProcessResultInternal: (boxWhiskerData: QueryResultData, outliersData: QueryResultData, dataOptions?: BoxplotChartDataOptionsInternal) => QueryResultData;
+/**
+ * Processes box whisker data and outliers data to combine them into a single data set.
+ *
+ * @param {QueryResultData} boxWhiskerData - The data for the box whisker.
+ * @param {QueryResultData} outliersData - The data for the outliers.
+ * @param {BoxplotChartCustomDataOptions} [dataOptions] - Optional data options for customizing data processing.
+ * @returns {QueryResultData} The combined data with outliers included in the box whisker plot.
+ */
+export declare function boxWhiskerProcessResult(boxWhiskerData: QueryResultData, outliersData: QueryResultData, dataOptions?: BoxplotChartCustomDataOptions): QueryResultData;
+export declare const executeBoxplotQuery: ({ app, chartDataOptions, dataSource, attributes, measures, filters, highlights, }: {
+    app: ClientApplication;
+    chartDataOptions: BoxplotChartDataOptionsInternal;
+    dataSource?: string | undefined;
+    attributes: Attribute[];
+    measures: Measure[];
+    filters?: Filter[] | undefined;
+    highlights?: Filter[] | undefined;
+}) => Promise<QueryResultData>;

package/dist/chart-data/boxplot-data.d.ts

@@ -0,0 +1,11 @@
+import { DataTable } from '../chart-data-processor/table-processor.js';
+import { BoxplotChartData } from './types.js';
+import { BoxplotChartDataOptionsInternal } from '../chart-data-options/types.js';
+/**
+ * Creates data for box plot charts given chart data table and data options
+ *
+ * @param chartDataOptions - Data options for box plot chart
+ * @param dataTable - Chart data table
+ * @returns Box plot chart data
+ */
+export declare const boxplotData: (chartDataOptions: BoxplotChartDataOptionsInternal, dataTable: DataTable) => BoxplotChartData;

package/dist/chart-data/cartesian-data.d.ts

@@ -1,5 +1,8 @@
-import { DataTable } from '../chart-data-processor/table-processor';
-import { CartesianChartData } from './types';
-import { CartesianChartDataOptionsInternal } from '../chart-data-options/types';
+import { Column, DataTable } from '../chart-data-processor/table-processor';
+import { CartesianChartData, CategoricalXValues } from './types';
+import { CartesianChartDataOptionsInternal, Value } from '../chart-data-options/types';
+import { SortDirection } from '../types';
 export declare const validateCartesianChartDataOptions: (chartDataOptions: CartesianChartDataOptionsInternal) => CartesianChartDataOptionsInternal;
 export declare const cartesianData: (chartDataOptions: CartesianChartDataOptionsInternal, dataTable: DataTable) => CartesianChartData;
+export declare const sortDirection: (sortType: SortDirection | undefined) => 1 | -1 | 0;
+export declare const getOrderedXValues: (dataTable: DataTable, sortedMeasures: Value[], xColumns: Column[], rownumColumnName?: string) => CategoricalXValues[];

package/dist/chart-data/data-coloring/create-data-coloring-function.d.ts

@@ -0,0 +1,7 @@
+import { DataColorOptions } from './types';
+export type DataStructureOperator<DataStructure extends {}, ColoredDataStructure extends {}> = {
+    getValueFromDataStructure: (data: DataStructure) => number;
+    applyColorToDataStructure: (data: DataStructure, color?: string) => ColoredDataStructure;
+};
+export type ColoringFunction<DataStructure extends {}, ColoredDataStructure extends {}> = (dataStructures: DataStructure[], colorOpts: DataColorOptions) => ColoredDataStructure[];
+export declare const createDataColoringFunction: <DataStructure extends {}, ColoredDataStructure extends {}>(dsOperator: DataStructureOperator<DataStructure, ColoredDataStructure>) => ColoringFunction<DataStructure, ColoredDataStructure>;

package/dist/chart-data/data-coloring/index.d.ts

@@ -0,0 +1,3 @@
+export * from './legend-color.js';
+export * from './series-data-coloring-function.js';
+export * from './types.js';

package/dist/chart-data/{series-data-color-service → data-coloring}/legend-color.d.ts

@@ -1,2 +1,2 @@
-import { DataColorOptions } from './types';
+import { DataColorOptions } from './types.js';
 export declare const legendColor: (colorOpts?: DataColorOptions) => string | undefined;

package/dist/chart-data/data-coloring/series-data-coloring-function.d.ts

@@ -0,0 +1,11 @@
+import { SeriesValueData } from '../types.js';
+export declare const seriesDataColoringFunction: import("./create-data-coloring-function.js").ColoringFunction<SeriesValueData, {
+    color: string | undefined;
+    value: number;
+    blur?: boolean | undefined;
+    rawValue?: string | number | undefined;
+    xValue?: (string | number)[] | undefined;
+    xDisplayValue?: string[] | undefined;
+    xCompareValue?: (string | number)[] | undefined;
+    parent?: string | undefined;
+}>;

package/dist/chart-data/indicator-data.d.ts

@@ -1,4 +1,4 @@
 import { DataTable } from '../chart-data-processor/table-processor';
-import { IndicatorDataOptionsInternal } from '../chart-data-options/types';
+import { IndicatorChartDataOptionsInternal } from '../chart-data-options/types';
 import { IndicatorChartData } from './types';
-export declare const indicatorData: (chartDataOptions: IndicatorDataOptionsInternal, dataTable: DataTable) => IndicatorChartData;
+export declare const indicatorData: (chartDataOptions: IndicatorChartDataOptionsInternal, dataTable: DataTable) => IndicatorChartData;

package/dist/chart-data/scatter-data.d.ts

@@ -1,5 +1,5 @@
 import { ComparableData, DataTable } from '../chart-data-processor/table-processor';
-import { ScatterCategories, ScatterChartData, ScatterAxisCategoriesMap, ScatterDataTable } from './types';
+import { ScatterAxisCategoriesMap, ScatterCategories, ScatterChartData, ScatterDataTable } from './types';
 import { ScatterChartDataOptionsInternal } from '../chart-data-options/types';
 export declare const defaultScatterDataValue: ComparableData;
 export type AxisColumnName = 'xAxis' | 'yAxis';
@@ -14,7 +14,7 @@ export declare const buildCategories: (data: ScatterDataTable, axisColumnName: A
 export declare const createCategoriesMap: (xCategories?: ScatterCategories, yCategories?: ScatterCategories) => ScatterAxisCategoriesMap;
 export declare const groupData: (chartDataOptions: ScatterChartDataOptionsInternal, dataTable: DataTable) => ScatterDataTable;
 /**
- * Creates data for scatter charts given chart data table and data options,
+ * Creates data for scatter charts given chart data table and data options
  *
  * @param chartDataOptions - Data options for scatter chart
  * @param dataTable - Chart data table

package/dist/chart-data/scattermap-data.d.ts

@@ -0,0 +1,4 @@
+import { ScattermapChartDataOptionsInternal } from '../chart-data-options/types.js';
+import { DataTable } from '../chart-data-processor/table-processor.js';
+import { ScattermapChartData } from './types.js';
+export declare const scattermapData: (chartDataOptions: ScattermapChartDataOptionsInternal, dataTable: DataTable) => ScattermapChartData;

package/dist/chart-data/types.d.ts

@@ -22,6 +22,30 @@ export type CategoricalSeriesValues = {
     title?: string;
     data: SeriesValueData[];
 };
+export type BoxplotSeriesValueData = {
+    low: number;
+    median: number;
+    high: number;
+    q1: number;
+    q3: number;
+    outliers: number[];
+    blur?: boolean;
+};
+export type BoxplotSeriesValues = {
+    name: string;
+    title?: string;
+    data: BoxplotSeriesValueData[];
+};
+export type BoxplotOutliersSeriesValueData = {
+    x: number;
+    y: number;
+    blur?: boolean;
+};
+export type BoxplotOutliersSeriesValues = {
+    name: string;
+    title?: string;
+    data: BoxplotOutliersSeriesValueData[];
+};
 export type Column = {
     name: string;
     type: string;
@@ -60,6 +84,17 @@ export type ScatterChartData = {
     xCategories: ScatterCategories;
     yCategories: ScatterCategories;
 };
+export type ScattermapChartLocation = {
+    name: string;
+    value: number;
+    colorValue?: number;
+    details?: number | string[];
+    blur: boolean;
+};
+export type ScattermapChartData = {
+    type: 'scattermap';
+    locations: ScattermapChartLocation[];
+};
 /**
  * Fact final data that will be passed to chart-component to render
  *
@@ -77,4 +112,14 @@ export type IndicatorChartData = {
  *
  * @internal
  */
-export type ChartData = CartesianChartData | CategoricalChartData | ScatterChartData | IndicatorChartData;
+export type BoxplotChartData = {
+    type: 'boxplot';
+    xValues: CategoricalXValues[];
+    series: [BoxplotSeriesValues, BoxplotOutliersSeriesValues?];
+};
+/**
+ * Fact final data that will be passed to chart-component to render
+ *
+ * @internal
+ */
+export type ChartData = CartesianChartData | CategoricalChartData | ScatterChartData | IndicatorChartData | BoxplotChartData | ScattermapChartData;

package/dist/chart-data-options/coloring/consts.d.ts

@@ -1 +1,4 @@
 export declare const DEFAULT_COLOR = "#dcdcdc";
+export declare const colorChineseSilver = "#CCCCCC";
+export declare const colorWhite = "#FFFFFF";
+export declare const DEFAULT_PALETTE_COLORS: string[];

package/dist/chart-data-options/coloring/utils.d.ts

@@ -0,0 +1,6 @@
+import { Color } from '../../types';
+/**
+ * Returns a color from the given palette colors array based on index.
+ * If no custom palette supplied, returns a color from the default palette.
+ */
+export declare const getPaletteColor: (customPaletteColors: Color[] | undefined, index: number) => string;

package/dist/chart-data-options/get-translated-data-options.d.ts

@@ -0,0 +1,6 @@
+import { ChartDataOptions, ChartType } from '../types';
+export declare function getTranslatedDataOptions(dataOptions: ChartDataOptions, chartType: ChartType): {
+    chartDataOptions: import("./types").ChartDataOptionsInternal;
+    attributes: import("packages/sdk-data/dist").Attribute[];
+    measures: import("packages/sdk-data/dist").Measure[];
+};

package/dist/chart-data-options/translate-boxplot-data-options.d.ts

@@ -0,0 +1,7 @@
+import { CalculatedMeasureColumn, Column, MeasureColumn } from '@sisense/sdk-data';
+import { BoxplotChartDataOptions, BoxplotChartCustomDataOptions, BoxplotChartDataOptionsInternal, StyledColumn, BoxWhiskerType, StyledMeasureColumn } from './types';
+export declare const generateBoxplotValues: (targetValue: Column | StyledColumn, boxType: BoxWhiskerType, outliersEnabled: boolean) => {
+    values: (MeasureColumn | CalculatedMeasureColumn | StyledMeasureColumn)[];
+    outliers: Column | StyledColumn | undefined;
+};
+export declare const translateBoxplotDataOptions: (boxplotDataOptions: BoxplotChartDataOptions | BoxplotChartCustomDataOptions) => BoxplotChartDataOptionsInternal;

package/dist/chart-data-options/translate-scattermap-data-options.d.ts

@@ -0,0 +1,3 @@
+import { ScattermapChartDataOptions, ScattermapChartDataOptionsInternal, ScattermapLocationLevel } from './types';
+export declare function getLocationLevel(locationDataOptions: ScattermapChartDataOptions['locations']): ScattermapLocationLevel;
+export declare function translateScattermapChartDataOptions(scattermap: ScattermapChartDataOptions): ScattermapChartDataOptionsInternal;

package/dist/chart-data-options/types.d.ts

@@ -1,4 +1,4 @@
-import type { DataColorOptions } from '../chart-data/series-data-color-service';
+import type { DataColorOptions } from '../chart-data/data-coloring';
 import type { NumberFormatConfig, SeriesChartType, SortDirection, ValueToColorMap, MultiColumnValueToColorMap } from '../types';
 import { Column, MeasureColumn, CalculatedMeasureColumn } from '@sisense/sdk-data';
 /**
@@ -56,9 +56,9 @@ export interface CategoryStyle {
  *       },
  *     ],
  *     value: [
- *       measures.sum(DM.Commerce.Revenue),
+ *       measureFactory.sum(DM.Commerce.Revenue),
  *       {
- *         column: measures.sum(DM.Commerce.Quantity),
+ *         column: measureFactory.sum(DM.Commerce.Quantity),
  *         showOnRightAxis: true,
  *         chartType: 'column',
  *       },
@@ -128,9 +128,9 @@ export type ValueStyle = {
  *       },
  *     ],
  *     value: [
- *       measures.sum(DM.Commerce.Revenue),
+ *       measureFactory.sum(DM.Commerce.Revenue),
  *       {
- *         column: measures.sum(DM.Commerce.Quantity),
+ *         column: measureFactory.sum(DM.Commerce.Quantity),
  *         showOnRightAxis: true,
  *         chartType: 'column',
  *       },
@@ -211,7 +211,7 @@ export interface CategoricalChartDataOptions {
  * Configuration for how to query aggregate data and assign data
  * to a {@link IndicatorChartType | Indicator chart}.
  */
-export interface IndicatorDataOptions {
+export interface IndicatorChartDataOptions {
     /** Measure columns (or measures) whose values are used for main value of indicator. */
     value?: (MeasureColumn | CalculatedMeasureColumn | StyledMeasureColumn)[];
     /** Measure columns (or measures) whose values are used for secondary value of indicator. */
@@ -294,14 +294,106 @@ export interface TableDataOptions {
      */
     columns: (Column | StyledColumn | MeasureColumn | CalculatedMeasureColumn | StyledMeasureColumn)[];
 }
+/**
+ * Geographic location level for a Scattermap column.
+ * This type can have one of the following values:
+ * - 'auto': Automatically determines the appropriate location level.
+ * - 'country': Represents the country level in the geographical hierarchy.
+ * - 'state': Represents the state or province level in the geographical hierarchy.
+ * - 'city': Represents the city level in the geographical hierarchy.
+ */
+export type ScattermapLocationLevel = 'auto' | 'country' | 'state' | 'city';
+/**
+ * Scattermap column that allows to specify the geographic location level.
+ */
+export interface ScattermapColumn extends StyledColumn {
+    level: ScattermapLocationLevel;
+}
+/**
+ * Configuration for how to query aggregate data and assign data
+ * to axes of a Scattermap chart.
+ */
+export interface ScattermapChartDataOptions {
+    /**
+     * Columns (or attributes) whose values represent locations on the map.
+     */
+    locations: (Column | StyledColumn | ScattermapColumn)[];
+    /**
+     * Measure column (or measure) representing the size of the points on the map.
+     */
+    size?: MeasureColumn | CalculatedMeasureColumn | StyledMeasureColumn;
+    /**
+     * Measure column (or measure) representing the color of the points on the map.
+     */
+    colorBy?: MeasureColumn | CalculatedMeasureColumn | StyledMeasureColumn;
+    /**
+     * Column or measure column representing the additional details for the points on the map.
+     */
+    details?: Column | StyledColumn | MeasureColumn | CalculatedMeasureColumn | StyledMeasureColumn;
+}
+/**
+ * Represents the type of box whisker data algorithm, which can be either `iqr`, `extremums`, or `standardDeviation`.
+ */
+export type BoxWhiskerType = 'iqr' | 'extremums' | 'standardDeviation';
+/**
+ * Configuration for how to query aggregate data and assign data
+ * to axes of a Boxplot chart.
+ *
+ * The Boxplot chart can receive a singular numeric column, which is utilized internally to calculate multiple metrics
+ * such as `whisker max`, `whisker min`, `box max`, `box median`, and `box min`.
+ */
+export type BoxplotChartDataOptions = {
+    /**
+     * Columns (or attributes) whose values represent categories in the chart.
+     */
+    category: [(Column | StyledColumn)?];
+    /**
+     * Columns (or attributes) whose values represent the target numeric value column for computing boxplot metrics according to the selected `boxType`
+     */
+    value: [Column | StyledColumn];
+    /**
+     * The type of box whisker data algorithm to be used.
+     */
+    boxType: BoxWhiskerType;
+    /**
+     * Toggle flag whether outliers should be enabled in the boxplot chart.
+     */
+    outliersEnabled?: boolean;
+};
+/**
+ * Configuration for how to query aggregate data and assign data
+ * to axes of a Boxplot chart.
+ *
+ * The Boxplot chart can receive multiple numeric columns, which represent all the metrics
+ * such as `whisker max`, `whisker min`, `box max`, `box median`, and `box min`.
+ */
+export type BoxplotChartCustomDataOptions = {
+    /**
+     * Columns (or attributes) whose values represent categories in the chart.
+     */
+    category: [(Column | StyledColumn)?];
+    /**
+     * Measure columns (or measures) representing the target numeric values used for computing boxplot metrics.
+     */
+    value: (Column | StyledColumn | MeasureColumn | CalculatedMeasureColumn | StyledMeasureColumn)[];
+    /**
+     * Optional measure columns (or measures) representing the boxplot outliers value.
+     */
+    outliers?: [Column | StyledColumn];
+    /**
+     * The title for the numeric value column in the chart.
+     */
+    valueTitle: string;
+};
 /**
  * Configuration for querying aggregate data and assigning data to chart encodings.
  *
  * There are separate configurations for {@link CartesianChartDataOptions | Cartesian},
  * {@link CategoricalChartDataOptions | Categorical},
- * {@link ScatterChartDataOptions | Scatter}, and {@link IndicatorDataOptions | Indicator} charts.
+ * {@link ScatterChartDataOptions | Scatter}, {@link IndicatorChartDataOptions | Indicator},
+ * and {@link BoxplotChartDataOptions | Boxplot} charts.
  */
-export type ChartDataOptions = CartesianChartDataOptions | CategoricalChartDataOptions | ScatterChartDataOptions | IndicatorDataOptions;
+export type ChartDataOptions = CartesianChartDataOptions | CategoricalChartDataOptions | ScatterChartDataOptions | IndicatorChartDataOptions | BoxplotChartDataOptions | BoxplotChartCustomDataOptions | ScattermapChartDataOptions;
 /** @internal */
 export interface Category extends CategoryStyle {
     name: string;
@@ -341,15 +433,35 @@ export interface ScatterChartDataOptionsInternal {
     seriesToColorMap?: ValueToColorMap;
 }
 /** @internal */
+export interface ScattermapChartDataOptionsInternal {
+    locations: Category[];
+    size?: Value;
+    colorBy?: Value;
+    details?: Category | Value;
+    locationLevel: ScattermapLocationLevel;
+}
+/** @internal */
 export type TableDataOptionsInternal = {
     columns: (Category | Value)[];
 };
 /** @internal */
-export type ChartDataOptionsInternal = CartesianChartDataOptionsInternal | CategoricalChartDataOptionsInternal | ScatterChartDataOptionsInternal | IndicatorDataOptionsInternal;
+export type ChartDataOptionsInternal = CartesianChartDataOptionsInternal | CategoricalChartDataOptionsInternal | ScatterChartDataOptionsInternal | IndicatorChartDataOptionsInternal | BoxplotChartDataOptionsInternal | ScattermapChartDataOptionsInternal;
 /** @internal */
-export type IndicatorDataOptionsInternal = {
+export type IndicatorChartDataOptionsInternal = {
     min?: Value[];
     max?: Value[];
     value?: Value[];
     secondary?: Value[];
 };
+/** @internal */
+export interface BoxplotChartDataOptionsInternal {
+    category?: Category;
+    boxMin: Value;
+    boxMedian: Value;
+    boxMax: Value;
+    whiskerMin: Value;
+    whiskerMax: Value;
+    outliersCount: Value;
+    outliers?: Category;
+    valueTitle: string;
+}

package/dist/chart-data-options/utils.d.ts

@@ -1,5 +1,9 @@
 import { Attribute, CalculatedMeasureColumn, Column, Measure, MeasureColumn } from '@sisense/sdk-data';
-import { Category, Value, StyledColumn, StyledMeasureColumn, AnyColumn } from './types';
+import { Category, Value, StyledColumn, StyledMeasureColumn, AnyColumn, CategoryStyle } from './types';
+export declare const splitColumn: (c: StyledColumn | Column) => {
+    column: Column;
+    style: CategoryStyle | undefined;
+};
 export declare const translateColumnToCategory: (c: StyledColumn | Column) => Category;
 export declare const translateColumnToValue: (c: MeasureColumn | CalculatedMeasureColumn | StyledMeasureColumn) => Value;
 export declare const translateColumnToCategoryOrValue: (value: AnyColumn) => Value | Category;
@@ -9,3 +13,4 @@ export declare const translateValueToMeasure: (value: Value) => Measure;
 export declare const translateCategoryToAttribute: (category: Category) => Attribute;
 export declare const getDataOptionTitle: (option: Category | Value) => string;
 export declare const translateColumnToAttribure: (c: StyledColumn | Column) => Attribute;
+export declare const translateColumnToMeasure: (c: MeasureColumn | CalculatedMeasureColumn | StyledMeasureColumn) => Measure;

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

@@ -0,0 +1,10 @@
+import { BoxplotChartData } from '../chart-data/types';
+import { BoxplotChartDataOptionsInternal } from '../chart-data-options/types';
+import { HighchartsOptionsInternal } from './chart-options-service';
+import { OptionsWithAlerts } from '../types';
+import { BoxplotChartDesignOptions } from './translations/design-options';
+/**
+ * Convert intermediate chart data, data options, and design options
+ * into pure highcharts config data.
+ */
+export declare const getBoxplotChartOptions: (chartData: BoxplotChartData, chartDesignOptions: BoxplotChartDesignOptions, dataOptions: BoxplotChartDataOptionsInternal) => OptionsWithAlerts<HighchartsOptionsInternal>;