@sisense/sdk-ui 0.11.3

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

@@ -0,0 +1,349 @@
+import type { DataColorOptions } from '../chart-data/series-data-color-service';
+import type { NumberFormatConfig, SeriesChartType, SortDirection, ValueToColorMap } from '../types';
+import { Column, MeasureColumn, CalculatedMeasureColumn } from '@sisense/sdk-data';
+/**
+ * Styles for a category/column when visualized in a chart
+ *
+ * @internal
+ */
+export interface CategoryStyle {
+    /** {@inheritDoc NumberFormatConfig} */
+    numberFormatConfig?: NumberFormatConfig;
+    /**
+     * Date format.
+     *
+     * See [ECMAScript Date Time String Format](https://tc39.es/ecma262/multipage/numbers-and-dates.html#sec-date-time-string-format)
+     */
+    dateFormat?: string;
+    /** Boolean flag to toggle continuous timeline on this date column. */
+    continuous?: boolean;
+    /**
+     * Date granularity that works with continuous timeline.
+     *
+     * Values from {@link @sisense/sdk-data!DateLevels}.
+     *
+     */
+    granularity?: string;
+    /**
+     * Toggle flag for this category/column in the chart.
+     *
+     * @internal
+     */
+    enabled?: boolean;
+    /** {@inheritDoc SortDirection} */
+    sortType?: SortDirection;
+    isColored?: boolean;
+}
+/**
+ * Wrapped {@link @sisense/sdk-data!Column} with styles controlling how the column is visualized in a chart.
+ *
+ * @example
+ * An example of using `StyledColumn` to change the date format of the months displayed on the x-axis.
+ *
+ *
+ * ```tsx
+ * <Chart
+ *   dataSet={DM.DataSource}
+ *   chartType={'line'}
+ *   dataOptions={{
+ *     category: [
+ *       {
+ *         column: DM.Commerce.Date.Months,
+ *         dateFormat: 'yy-MM',
+ *       },
+ *     ],
+ *     value: [
+ *       measures.sum(DM.Commerce.Revenue),
+ *       {
+ *         column: measures.sum(DM.Commerce.Quantity),
+ *         showOnRightAxis: true,
+ *         chartType: 'column',
+ *       },
+ *     ],
+ *     breakBy: [],
+ *   }}
+ * />
+ * ```
+ *
+ * <img src="media://chart-mixed-series-example-1.png" width="800px" />
+ *
+ * Also, see {@link StyledMeasureColumn}.
+ */
+export interface StyledColumn extends CategoryStyle {
+    /** Wrapped Column */
+    column: Column;
+}
+/**
+ * Styles for a value/measure when it is visualized in a chart.
+ *
+ * @internal
+ */
+export type ValueStyle = {
+    /** {@inheritDoc SortDirection} */
+    sortType?: SortDirection;
+    /**
+     * Boolean flag whether to show this value/measure
+     * on the right axis (`true`) or on the left axis (`false`).
+     */
+    showOnRightAxis?: boolean;
+    /** {@inheritDoc NumberFormatConfig} */
+    numberFormatConfig?: NumberFormatConfig;
+    /** {@inheritDoc SeriesChartType} */
+    chartType?: SeriesChartType;
+    /** {@inheritDoc DataColorOptions} */
+    color?: DataColorOptions;
+    /**
+     * Toggle flag for this value/measure in the chart.
+     *
+     * @internal
+     */
+    enabled?: boolean;
+    /** Boolean flag whether null values are treated as zeros in the chart */
+    treatNullDataAsZeros?: boolean;
+};
+/**
+ * Wrapped {@link @sisense/sdk-data!MeasureColumn | Measure Column} with styles
+ * controlling how the measure is visualized in a chart.
+ *
+ * @example
+ * Example of using `StyledMeasureColumn` to mix a column series of `Total Revenue` to a line chart.
+ *
+ * Note that the chart doesn't display a second Y-axis on the right but that can be customized by
+ * style options.
+ *
+ * ```tsx
+ * <Chart
+ *   dataSet={DM.DataSource}
+ *   chartType={'line'}
+ *   dataOptions={{
+ *     category: [
+ *       {
+ *         column: DM.Commerce.Date.Months,
+ *         dateFormat: 'yy-MM',
+ *       },
+ *     ],
+ *     value: [
+ *       measures.sum(DM.Commerce.Revenue),
+ *       {
+ *         column: measures.sum(DM.Commerce.Quantity),
+ *         showOnRightAxis: true,
+ *         chartType: 'column',
+ *       },
+ *     ],
+ *     breakBy: [],
+ *   }}
+ * />
+ * ```
+ *
+ * <img src="media://chart-mixed-series-example-1.png" width="800px" />
+ *
+ * See also {@link StyledColumn}.
+ */
+export interface StyledMeasureColumn extends ValueStyle {
+    /** Wrapped MeasureColumn or CalculatedMeasureColumn */
+    column: MeasureColumn | CalculatedMeasureColumn;
+}
+/**
+ * @internal
+ */
+export type AnyColumn = Column | StyledColumn | MeasureColumn | StyledMeasureColumn | CalculatedMeasureColumn;
+/**
+ * Configuration for how to query aggregate data and assign data
+ * to axes of a {@link CartesianChartType | Cartesian chart}.
+ *
+ * These charts can include multiple values on both the X and Y-axis,
+ * as well as a break-down by categories displayed on the Y-axis.
+ */
+export interface CartesianChartDataOptions {
+    /**
+     * Columns (or attributes) whose values are placed on the X-axis.
+     *
+     * Typically, the X-axis represents descriptive data.
+     */
+    category: (Column | StyledColumn)[];
+    /**
+     * Measure columns (or measures) whose values are scaled to the Y-axis of the chart.
+     *
+     * Each measure is represented as a series in the chart.
+     *
+     */
+    value: (MeasureColumn | CalculatedMeasureColumn | StyledMeasureColumn)[];
+    /**
+     * Columns (or attributes) by which to break (group) the data represented in the chart.
+     *
+     * Each group is represented by a different visual encoding - for example, color of bars in a bar chart,
+     * and is automatically added to the chart's legend.
+     */
+    breakBy: (Column | StyledColumn)[];
+    /**
+     * Optional mapping of each of the series to colors.
+     */
+    seriesToColorMap?: ValueToColorMap;
+}
+/**
+ * Configuration for how to query aggregate data and assign data
+ * to a {@link CategoricalChartType | Categorical chart}.
+ */
+export interface CategoricalChartDataOptions {
+    /**
+     * Measure columns (or measures) whose values are scaled to visual elements of the chart.
+     * For example, the size of the pie slices of a pie chart.
+     *
+     * Values are typically used to represent numeric data.
+     */
+    value: (MeasureColumn | CalculatedMeasureColumn | StyledMeasureColumn)[];
+    /**
+     * Columns (or attributes) whose values represent categories in the chart.
+     */
+    category: (Column | StyledColumn)[];
+    /**
+     * Optional mapping of each of the series to colors.
+     */
+    seriesToColorMap?: ValueToColorMap;
+}
+/**
+ * Configuration for how to query aggregate data and assign data
+ * to a {@link IndicatorChartType | Indicator chart}.
+ */
+export interface IndicatorDataOptions {
+    /** 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. */
+    secondary?: (MeasureColumn | CalculatedMeasureColumn | StyledMeasureColumn)[];
+    /** Measure columns (or measures) whose values are used for min value of indicator. */
+    min?: (MeasureColumn | CalculatedMeasureColumn | StyledMeasureColumn)[];
+    /** Measure columns (or measures) whose values are used for max value of indicator. */
+    max?: (MeasureColumn | CalculatedMeasureColumn | StyledMeasureColumn)[];
+}
+/**
+ * Configuration for how to query aggregate data and assign data
+ * to axes of a {@link ScatterChartType | Scatter chart}.
+ *
+ * These charts can include data points scattered on X-Y plane further broken down by categories
+ * and encoded by bubble sizes.
+ */
+export interface ScatterChartDataOptions {
+    /**
+     * A column or measure column whose values are placed on the X-axis.
+     *
+     * Typically, the X-axis of a Scatter Chart is used to represent numeric data.
+     * Alternatively, Descriptive data is also supported. At most one column is allowed.
+     */
+    x?: Column | StyledColumn | MeasureColumn | CalculatedMeasureColumn | StyledMeasureColumn;
+    /**
+     * A column or measure column whose values are placed on the Y-axis.
+     *
+     * Typically, the Y-axis of a Scatter Chart is used to represent numeric data.
+     * Alternatively, Descriptive data is also supported. At most one column is allowed.
+     */
+    y?: Column | StyledColumn | MeasureColumn | CalculatedMeasureColumn | StyledMeasureColumn;
+    /**
+     * A column to be scattered across the chart as circles;
+     * one point (circle) appears on the chart for each member of this column.
+     * These columns must be descriptive data (not numeric data).
+     *
+     * You can only add a break-by point if either the X-axis or the Y-axis was defined to represent numeric data.
+     */
+    breakByPoint?: Column | StyledColumn;
+    /**
+     * Select a column by which to break (group) the columns in the chart.
+     * This must be a descriptive column. If you select descriptive data,
+     * then the points in the chart are grouped into the members of the column.
+     * Each member is represented by a different color.
+     *
+     * OR
+     *
+     * Select a column by which to color the columns in the chart.
+     * This must be a numeric column. If you select numeric data,
+     * then the point color is a gradient where the highest value is
+     * the darkest color and the lowest value is the lightest color.
+     *
+     */
+    breakByColor?: Column | StyledColumn | MeasureColumn | CalculatedMeasureColumn | StyledMeasureColumn;
+    /**
+     * Column that determines the size of the circle. It must be numeric data.
+     *
+     */
+    size?: MeasureColumn | CalculatedMeasureColumn | StyledMeasureColumn;
+    /**
+     * Optional mapping of each of the series created by {@link breakByColor} to colors.
+     */
+    seriesToColorMap?: ValueToColorMap;
+}
+/**
+ * Checks if the given argument is a measure column.
+ *
+ * @param arg
+ * @internal
+ */
+export declare function isMeasureColumn(arg: AnyColumn): arg is MeasureColumn | CalculatedMeasureColumn | StyledMeasureColumn;
+/**
+ * Configuration for how to query data and assign data to {@link Table}.
+ *
+ */
+export type TableDataOptions = {
+    /**
+     * Columns (or attributes) whose values represent data columns in table
+     *
+     */
+    columns: (Column | StyledColumn | MeasureColumn | CalculatedMeasureColumn | StyledMeasureColumn)[];
+};
+/**
+ * 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.
+ */
+export type ChartDataOptions = CartesianChartDataOptions | CategoricalChartDataOptions | ScatterChartDataOptions | IndicatorDataOptions;
+/** @internal */
+export interface Category extends CategoryStyle {
+    name: string;
+    type: string;
+    title?: string;
+}
+/** @internal */
+export declare const isValue: (arg: Category | Value) => arg is Value;
+/** @internal */
+export declare const isCategory: (arg: Category | Value) => arg is Category;
+/** @internal */
+export interface Value extends ValueStyle {
+    name: string;
+    aggregation?: string;
+    title: string;
+}
+/** @internal */
+export interface CartesianChartDataOptionsInternal {
+    x: Category[];
+    y: Value[];
+    breakBy: Category[];
+    seriesToColorMap?: ValueToColorMap;
+}
+/** @internal */
+export interface CategoricalChartDataOptionsInternal {
+    y: Value[];
+    breakBy: Category[];
+    seriesToColorMap?: ValueToColorMap;
+}
+/** @internal */
+export interface ScatterChartDataOptionsInternal {
+    x?: Value | Category;
+    y?: Value | Category;
+    breakByPoint?: Category;
+    breakByColor?: Category | Value;
+    size?: Value;
+    seriesToColorMap?: ValueToColorMap;
+}
+/** @internal */
+export type TableDataOptionsInternal = {
+    columns: (Category | Value)[];
+};
+/** @internal */
+export type ChartDataOptionsInternal = CartesianChartDataOptionsInternal | CategoricalChartDataOptionsInternal | ScatterChartDataOptionsInternal | IndicatorDataOptionsInternal;
+/** @internal */
+export type IndicatorDataOptionsInternal = {
+    min?: Value[];
+    max?: Value[];
+    value?: Value[];
+    secondary?: Value[];
+};

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

@@ -0,0 +1,11 @@
+import { Attribute, CalculatedMeasureColumn, Column, Measure, MeasureColumn } from '@sisense/sdk-data';
+import { Category, Value, StyledColumn, StyledMeasureColumn, AnyColumn } from './types';
+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;
+export declare const translateMeasureToValue: (measure: Measure) => Value;
+export declare const translateAttributeToCategory: (attribute: Attribute) => Category;
+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;

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

@@ -0,0 +1,21 @@
+import { ChartDataOptions, ChartDataOptionsInternal, Value } from './types';
+import { ChartType } from '../types';
+import { Attribute, Data, Filter, Measure } from '@sisense/sdk-data';
+import { DataTable } from '../chart-data-processor/table-processor';
+export type DataColumnNamesMapping = Record<string, string>;
+/**
+ * Generates and applies unique data column names and creates a mapping of new names to original names.
+ *
+ * @param measures - An array of Value objects representing measures.
+ * @returns - The mapping of unique names to original names.
+ */
+export declare const generateUniqueDataColumnsNames: (measures: Value[]) => DataColumnNamesMapping;
+/**
+ * Applies default chart data options based on input chart type.
+ */
+export declare const applyDefaultChartDataOptions: (chartDataOptions: ChartDataOptionsInternal, chartType: ChartType) => ChartDataOptionsInternal;
+/**
+ * Validates attributes, measures, filters, and highlights against the columns in data.
+ */
+export declare const validateDataOptionsAgainstData: (data: Data | DataTable, attributes: Attribute[], measures: Measure[], dataColumnNamesMapping: DataColumnNamesMapping, filters?: Filter[], highlights?: Filter[]) => boolean;
+export declare function validateDataOptions(chartType: ChartType, dataOptions: ChartDataOptions): void;

package/dist/chart-data-processor/categorical-distribution.d.ts

@@ -0,0 +1,10 @@
+export type CategoricalStat = 'count' | 'countdistinct';
+export declare class CategoricalDistribution {
+    data: string[];
+    countDistinct: number | undefined;
+    constructor(data: string[]);
+    getStat(stat: string): number;
+    getN(): number;
+    getCount(): number;
+    getCountDistinct(): number;
+}

package/dist/chart-data-processor/data-table-date-period.d.ts

@@ -0,0 +1,37 @@
+import type { Locale } from 'date-fns';
+export type SystemSettings = {
+    language: string;
+};
+export declare const getBaseDateFnsLocale: (systemSettings?: SystemSettings) => Locale;
+export declare enum DatePeriod {
+    YEAR = "years",
+    QUARTER = "quarters",
+    MONTH = "months",
+    WEEK = "weeks",
+    DATE = "dates"
+}
+export type DateFnsDate = Date | number;
+export declare const startOfPeriod: (period: DatePeriod, date: DateFnsDate, locale: Locale) => Date;
+export declare const formatPeriod: (period: ExtendedDatePeriod, date: number, locale: Locale) => string;
+export declare const parseDataTableDateValue: (value: string) => Date;
+export declare const toPeriodCompareValue: (period: ExtendedDatePeriod, value: string, locale: Locale) => number;
+export declare const periodCompareValueForSpecificDate: (period: DatePeriod, date: Date | number, locale: Locale) => number;
+export declare const periodCompareValueForNow: (period: DatePeriod, locale: Locale) => number;
+export declare const periodCompareValueForPastPeriod: (period: DatePeriod, num: number, refDate: number | undefined, locale: Locale) => number;
+export declare const periodCompareValueForFuturePeriod: (period: DatePeriod, num: number, refDate: number | undefined, locale: Locale) => number;
+export declare enum PseudoDatePeriod {
+    QUARTER_NUM = "quarterNumber",
+    MONTH_NAME = "monthName",
+    DAY_OF_WEEK = "dayOfWeek",
+    TIME_OF_DAY = "timeOfDay"
+}
+export type ExtendedDatePeriod = DatePeriod | PseudoDatePeriod;
+export declare const isDatePeriod: (period: ExtendedDatePeriod) => period is DatePeriod;
+export declare const isPseudoDatePeriod: (period: ExtendedDatePeriod) => period is PseudoDatePeriod;
+export type PseudoDatePeriodConfig<T> = {
+    [key in PseudoDatePeriod]: T;
+};
+export declare const formatPseudoPeriod: (period: PseudoDatePeriod, date: number, locale: Locale) => string;
+export declare const PSEUDO_PERIOD_VALUES: PseudoDatePeriodConfig<number[]>;
+export declare const toPseudoPeriodCompareValue: (period: PseudoDatePeriod, value: string) => number;
+export declare const today: () => Date;

package/dist/chart-data-processor/distribution.d.ts

@@ -0,0 +1,22 @@
+export type Stat = 'sum' | 'max' | 'min' | 'count' | 'countdistinct' | 'average' | 'mean' | 'avg' | 'variance' | 'var' | 'stddev';
+export declare class Distribution {
+    data: number[];
+    sum: number | undefined;
+    max: number | undefined;
+    min: number | undefined;
+    avg: number | undefined;
+    variance: number | undefined;
+    stddev: number | undefined;
+    constructor(data: number[]);
+    getStat(stat: string): number;
+    getSum(): number;
+    getMax(): number;
+    getMin(): number;
+    getMean(): number;
+    getAverage(): number;
+    getN(): number;
+    getCount(): number;
+    getCountDistinct(): number;
+    getVariance(): number;
+    getStdDev(): number;
+}

package/dist/chart-data-processor/row-comparator.d.ts

@@ -0,0 +1,24 @@
+import { Row, Column, ComparableData, CompareValue } from './table-processor';
+export declare const createCompareValue: (displayValue: string | undefined | null, columnType: string) => CompareValue;
+type ComparableValue = string | number | ComparableData | null | undefined;
+export declare enum SortDirectionValue {
+    ASC = 1,
+    DESC = -1,
+    NONE = 0
+}
+/**
+ * Compares the two values as ComparableData objects.
+ *
+ * @param data1 - The first data to compare.
+ * @param data2 - The second data to compare.
+ * @param direction - The sorting direction. A positive number for ascending order, a negative number for descending order.
+ * @param type - The data type of comparison to perform. Defaults to 'string'.
+ * @returns {number} Returns -1 if data1 is smaller, 1 if data1 is larger, or 0 if they are equal.
+ */
+export declare function compareValues(data1: ComparableValue, data2: ComparableValue, direction?: SortDirectionValue, type?: string): number;
+export declare class RowComparator {
+    columns: readonly Column[];
+    constructor(columns: readonly Column[]);
+    compare(row1: Row, row2: Row): number;
+}
+export {};

package/dist/chart-data-processor/table-creators.d.ts

@@ -0,0 +1,39 @@
+import { Cell, Data } from '@sisense/sdk-data';
+import { DataTable } from './table-processor';
+export declare const itemIndexColumnName = "$itemIndex";
+export type TableColumn = {
+    readonly name: string;
+    readonly type: string;
+};
+export type TableData = {
+    columns: readonly TableColumn[];
+    rows: readonly (readonly string[])[];
+};
+export declare const createSortableTable: (tableData: TableData) => {
+    columns: {
+        name: string;
+        type: string;
+        index: number;
+        direction: number;
+    }[];
+    rows: {
+        displayValue: string;
+    }[][];
+};
+export declare const createSortableFromColumnsRows: (columns: TableData['columns'], rows: TableData['rows'], rownumColumn?: string) => {
+    columns: {
+        name: string;
+        type: string;
+        index: number;
+        direction: number;
+    }[];
+    rows: {
+        displayValue: string;
+    }[][];
+};
+type RowValue = Data['rows'][number][number];
+export declare const isCell: (rowValue: RowValue) => rowValue is Cell;
+export declare const isDataTableEmpty: (dataTable: DataTable) => boolean;
+export declare const rownumColumnName = "$rownum";
+export declare const createDataTableFromData: (data: Data) => DataTable;
+export {};

package/dist/chart-data-processor/table-processor.d.ts

@@ -0,0 +1,93 @@
+export type FilterTypes = 'greater' | 'lesser' | 'equal' | 'contains' | 'not equal';
+export type Value = string | number;
+export type BooleanOperator = 'or' | 'and';
+export type CompareValue = {
+    value: Value;
+    valueUndefined: boolean;
+    valueIsNaN: boolean;
+    lowercaseValue?: string;
+};
+export type ComparableData = {
+    readonly displayValue: string;
+    compareValue?: CompareValue;
+    rawValue?: string | number;
+    blur?: boolean;
+    color?: string;
+};
+export type Row = readonly ComparableData[];
+export type Column = {
+    readonly name: string;
+    readonly type: string;
+    readonly index: number;
+    direction: number;
+};
+export type DataTable = {
+    readonly columns: readonly Column[];
+    readonly rows: readonly Row[];
+};
+export type ColumnMeasure = {
+    readonly column: string;
+    readonly agg: string;
+    readonly title: string;
+};
+export type AggregationColumn = {
+    readonly aggFunc: string;
+    readonly aggName: string;
+    readonly column: Column;
+};
+export type IndexedRows = {
+    [key: string]: Row[];
+};
+export declare const separateBy: (rows: readonly Row[], separateByColumns: Column[]) => Row[][];
+export declare const orderBy: (table: DataTable, sortColumns: readonly Column[]) => {
+    columns: readonly Column[];
+    rows: Row[];
+};
+export declare const groupBy: (table: DataTable, groupByColumns: Column[], aggregationColumns: ColumnMeasure[]) => {
+    rows: ComparableData[][];
+    columns: {
+        index: number;
+        name: string;
+        type: string;
+        direction: number;
+    }[];
+};
+export declare const getColumnByName: (table: DataTable, name: string) => Column | undefined;
+export declare const getColumnsByName: (table: DataTable, names: string[]) => Column[];
+export declare const selectColumns: (table: DataTable, selectColumns: Column[]) => {
+    columns: {
+        index: number;
+        name: string;
+        type: string;
+        direction: number;
+    }[];
+    rows: ComparableData[][];
+};
+export declare const filterBy: (table: DataTable, filterColumns: Column[], filterValues: Value[], filterTypes: FilterTypes[], caseInsensitive?: boolean, booleanOperator?: BooleanOperator) => {
+    columns: readonly Column[];
+    rows: Row[];
+};
+export declare const getValue: (row: Row, column: Column) => Value | undefined;
+export declare const isBlurred: (row: Row, column: Column) => boolean;
+export declare const getValues: (row: Row, columns: readonly Column[]) => ComparableData[];
+export declare const getValuesAsString: (row: Row, columns: readonly Column[]) => string;
+export declare const getIndexedRows: (rows: readonly Row[], indexColumns: Column[]) => IndexedRows;
+export declare const getDistinctTable: (table: DataTable, distinctColumns: Column[]) => {
+    rows: Row[];
+    columns: {
+        index: number;
+        name: string;
+        type: string;
+        direction: number;
+    }[];
+};
+export declare const getColumnValues: (table: DataTable, column: Column) => (Value | undefined)[];
+export declare const emptyTable: (table: DataTable) => boolean;
+export declare const limitRows: (table: DataTable, limit: number) => {
+    columns: Column[];
+    rows: Row[];
+};
+export declare const innerJoin: (table: DataTable, joinTable: DataTable, joinKeys: string[]) => {
+    rows: Row[];
+    columns: Column[];
+};

package/dist/chart-options-processor/apply-event-handlers.d.ts

@@ -0,0 +1,49 @@
+import { DataPoint, HighchartsPointerEvent, HighchartsSelectEvent, ScatterDataPoint } from '../types';
+import { HighchartsOptionsInternal } from '../chart-options-processor/chart-options-service';
+/** Click handler for when multiple data points are selected. */
+export type DataPointsEventHandler = (
+/** Data points that were selected */
+points: DataPoint[], 
+/** Native MouseEvent */
+nativeEvent: MouseEvent) => void;
+/** Click handler for when a data point is clicked. One parameter, `DataPoint`, is passed to the function. */
+export type DataPointEventHandler = (
+/** Data point that was clicked */
+point: DataPoint, 
+/** Native PointerEvent */
+nativeEvent: PointerEvent) => void;
+/** Click handler for when a scatter data point is clicked */
+export type ScatterDataPointEventHandler = (
+/** Data point that was clicked */
+point: ScatterDataPoint, 
+/** Native PointerEvent */
+nativeEvent: PointerEvent) => void;
+/** Click handler for when multiple scatter data points are selected. */
+export type ScatterDataPointsEventHandler = (
+/** Data points that were selected */
+points: ScatterDataPoint[], 
+/** Native MouseEvent */
+nativeEvent: MouseEvent) => void;
+export type HighchartsEventOptions = {
+    chart: {
+        zoomType?: string;
+        events: {
+            selection?: (ev: HighchartsSelectEvent) => void;
+        };
+    };
+    plotOptions: {
+        series: {
+            point: {
+                events: {
+                    click?: (ev: HighchartsPointerEvent) => void;
+                    contextmenu?: (ev: HighchartsPointerEvent) => void;
+                };
+            };
+        };
+    };
+};
+export declare const applyEventHandlersToChart: (chartOptions: HighchartsOptionsInternal, { onDataPointClick, onDataPointContextMenu, onDataPointsSelected, }?: {
+    onDataPointClick?: DataPointEventHandler | ScatterDataPointEventHandler | undefined;
+    onDataPointContextMenu?: DataPointEventHandler | ScatterDataPointEventHandler | undefined;
+    onDataPointsSelected?: DataPointsEventHandler | ScatterDataPointsEventHandler | undefined;
+}) => HighchartsOptionsInternal;

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

@@ -0,0 +1,18 @@
+import { ChartData } from '../chart-data/types';
+import { ChartDesignOptions } from './translations/types';
+import { ChartType, CompleteThemeSettings } from '../types';
+import { CartesianChartDataOptionsInternal } from '../chart-data-options/types';
+import { HighchartsOptionsInternal } from './chart-options-service';
+import { OptionsWithAlerts } from './../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 -
+ * @param dateFormatter
+ */
+export declare const getCartesianChartOptions: (chartData: ChartData, chartType: ChartType, chartDesignOptions: ChartDesignOptions, dataOptions: CartesianChartDataOptionsInternal, themeSettings?: CompleteThemeSettings, dateFormatter?: ((date: Date, format: string) => string) | undefined) => OptionsWithAlerts<HighchartsOptionsInternal>;