import { AutocompleteProps } from '@mui/material/Autocomplete';
import { AutocompleteRenderInputParams } from '@mui/material/Autocomplete';
import { AutocompleteRenderOptionState } from '@mui/material/Autocomplete';
import { Components } from '@mui/material/styles';
import { ComponentsOverrides } from '@mui/material/styles';
import { ComponentsVariants } from '@mui/material/styles';
import { CSSInterpolation } from '@mui/system';
import { default as default_2 } from 'react';
import { ic3Breakpoint } from '@ic3/common-api';
import { ic3CorePalette } from '@ic3/common-api';
import { ic3CorePaletteOptions } from '@ic3/common-api';
import { ic3CoreTheme } from '@ic3/common-api';
import { ILogger } from '@ic3/common-api';
import { Interpolation } from '@mui/material/styles';
import { Property } from 'csstype';
import * as React_2 from 'react';
import { ReactElement } from 'react';
import { SvgIcon } from '@mui/material';
import { Theme } from '@mui/material/styles';
import { TypographyStyle } from '@mui/material/styles';

declare class AIWidgetChatBotClasses {
    static root: string;
    static messages: string;
    static message: string;
    static messageIcon: string;
    static messageContent: string;
    static messageOngoing: string;
    static input: string;
    static inputText: string;
    static inputClick: string;
    static footer: string;
    static warning: string;
    static reset: string;
}

declare type AIWidgetChatBotClassKey = keyof AIWidgetChatBotClasses;

/**
 * AI ChatBox Options (fields of the "Chart" tab in the widget editor).
 *
 * <pre>
 *      Plugin ID         : ic3
 *      Widget/Template ID: AIWidgetChatBot
 * </pre>
 *
 * @see WidgetTemplateChartOptions
 */
declare interface AIWidgetChatBotOptions extends FormFieldObject {
    variant: AIWidgetChatBotVariant;
    /**
     * The widget this chatbot is talking about.
     */
    targetWidgetId: string;
    initialQuestion?: string;
    /**
     * In this mode, only the initial question is being sent.
     */
    frozen?: true;
    resetOnDataChanged?: true;
    tableDataMaxRow?: number;
    tableDataCaptionPage0?: string;
    model?: string;
    systemPrompt?: string;
    initialPrompt?: string;
    initialPromptPage0?: string;
}

declare interface AIWidgetChatBotStyleProps {
    variant: AIWidgetChatBotVariant;
}

declare type AIWidgetChatBotVariant = "plain";

export declare class AlertDialogClasses {
    /**
     * Style applied to
     */
    static root: string;
    /**
     * Style applied to
     */
    static formRoot: string;
    static message: string;
    static warning: string;
}

export declare type AlertDialogClassKey = keyof AlertDialogClasses;

export declare type AllowedColumnType<T> = TidyColumnsType.UNKNOWN | TidyColumnsType.MIXED | (NonNullable_2<T> extends Property.Color ? TidyColumnsType.COLOR : TidyColumnsType.UNKNOWN) | (NonNullable_2<T> extends string ? TidyColumnsType.CHARACTER : TidyColumnsType.UNKNOWN) | (NonNullable_2<T> extends number ? TidyColumnsType.NUMERIC | TidyColumnsType.LATITUDE | TidyColumnsType.LONGITUDE : TidyColumnsType.UNKNOWN) | (NonNullable_2<T> extends boolean ? TidyColumnsType.LOGICAL : TidyColumnsType.UNKNOWN) | (NonNullable_2<T> extends any[] ? TidyColumnsType.LIST : TidyColumnsType.UNKNOWN) | (NonNullable_2<T> extends Date ? TidyColumnsType.DATETIME : TidyColumnsType.UNKNOWN) | (NonNullable_2<T> extends unknown ? TidyColumnsType : TidyColumnsType.UNKNOWN) | (T extends null ? TidyColumnsType.NULL : TidyColumnsType.UNKNOWN);

export declare interface Am4BubbleSeriesOptions extends FormFieldObject, IStrokeStyleProperties {
    /**
     * Labels.
     *
     * Names for the bubbles.
     */
    label: TidyTableColumnSelector;
    /**
     * X-Values.
     *
     * The x-coordinates of the bubbles.
     */
    valueX: TidyTableColumnSelector;
    /**
     * Y-Values.
     *
     * The y-coordinates of the bubbles.
     */
    valueY: TidyTableColumnSelector;
    /**
     * Bubble Size
     */
    bubbleSize?: TidyTableColumnSelector;
    /**
     * Group.
     *
     * Create a new series for each group.
     */
    group?: TidyTableColumnSelector;
    /**
     * Color.
     *
     * Color of the item in the scatter plot.
     */
    scatterSeriesColor?: TidyTableColumnSelector;
    /**
     * Tooltip.
     *
     * The text displayed as a tooltip on the points.
     */
    chartCursorTooltipScatter: string;
    /**
     * Min Bubble Size.
     *
     * The minimum bubble size in pixels. The bubble with the smallest value for size gets this size.
     */
    minBubbleSize: number;
    /**
     * Max Bubble Size.
     *
     * The maximum bubble size in pixels. The bubble with the largest value for size gets this size.
     */
    maxBubbleSize: number;
    /**
     * Fill Opacity.
     */
    fillOpacity: number;
}

export declare interface Am4CategoryDateAxisOptions extends FormFieldObject {
    /**
     * If we have (date)times available, then
     * YES -> always use them
     * NO -> never use them
     * AUTO -> use them if the level is a date or datetime (in MDX, these are levels of type DAY, HOUR, MINUTE, SECOND).
     */
    useDatetimeAxis: UseDatetimeAxis;
    /**
     * Axis.
     *
     * Displayed on the x-axis.
     *
     * [Scatter Plot Chart]
     *
     * Labels.
     *
     * Column with the label for the point.
     *
     * [Bar Chart]
     *
     * Axis.
     *
     * Displayed on the y-axis.
     *
     * [Stacked Bar Chart]
     *
     * Axis.
     *
     * Displayed on the y-axis.
     */
    axis: TidyTableColumnSelector;
    /**
     * Group.
     *
     * Create a new series for each group.
     */
    group?: TidyTableColumnSelector;
    /**
     * Level.
     *
     * Adds an extra level to the x-axis.
     *
     * [Bar Chart]
     *
     * Level.
     *
     * Adds an extra level to the y-axis.
     *
     * [Stacked Bar Chart]
     *
     * Level.
     *
     * Adds an extra level to the y-axis.
     */
    level?: TidyTableColumnSelector;
    /**
     * Label Text.
     *
     * Labels of the horizontal axis. Does not work with a date axis.
     *
     * [Bar Chart]
     *
     * Label Text.
     *
     * The labels of the vertical axis. Does not work with a date axis.
     */
    xAxisLabelsText: string;
    /**
     * Label Tooltip.
     *
     * The HTML contents of the axis tooltip when the user hovers the chart and cursor is active.
     * Does not work with a date axis.
     */
    xAxisLabelTooltipText: string;
    /**
     * The date format for the labels that show when the user hovers over the chart with a chart cursor.
     * Leave undefined to use the axis-date format.
     * Read more about the format codes here: https://www.amcharts.com/docs/v4/concepts/formatters/formatting-date-time/#Format_codes
     */
    xAxisLabelTooltipDateFormat?: string;
    /**
     * Title Text.
     *
     * The title of the horizontal axis.
     *
     * [Bar Chart]
     *
     * Title Text.
     *
     * The title of the vertical axis
     */
    xAxisTitleText?: string;
    /**
     * Label Spacing.
     *
     * Controls the minimum space between the labels.
     */
    xAxisLabelSpacing?: number;
    /**
     * Max Label Width.
     *
     * The maximum width in pixels for the labels.
     */
    xAxisLabelMaxWidth?: number;
    /**
     * Label Overflow.
     *
     * Choice of behavior when the label is larger than the max width.
     */
    xAxisLabelOverflow?: OverflowType;
    /**
     * Rotate Label.
     *
     * Rotate the labels on the category axis by 45 degrees.
     */
    xAxisRotateLabels?: CategoryAxisRotateLabels;
    /**
     * Level Label.
     *
     * Edit the HTML of the labels in the levels.
     */
    xAxisLevelLabelsText: string;
    /**
     * Show the level labels on top of the chart outside the grid.
     */
    xAxisLevelLabelsOutside?: boolean;
    /**
     * Cell Start Location.
     *
     * Value between 0 and 1 that indicates where the category starts on the grid.
     */
    xAxisCellStartLocation: number;
    /**
     * Cell End Location.
     *
     * Value between 0 and 1 that indicates where the category ends on the grid.
     */
    xAxisCellEndLocation: number;
    /**
     * Label Type.
     *
     * Render the label as text or as HTML.
     */
    xAxisLabelType: "html" | "text";
    /**
     * Initial Zoom.
     *
     * The start index and the end index seperated by a comma. You can use negative values to get the index from the
     * end of the axis. E.g., `-10,-1` zooms to the last 10 items.
     */
    xAxisInitialZoom?: string;
    /**
     * Show the grid lines perpendicular to the category axis.
     */
    xAxisShowGridLines: boolean;
    /**
     * In-place processing of the amCharts 4 category/date axis instance.
     *
     * <pre>
     *     ( value: CategoryAxis | DateAxis, options: Am4CategoryDateAxisOptions ) => void;
     * </pre>
     */
    xAxisPostRenderHook?: Hook<any, Am4CategoryDateAxisOptions>;
    /**
     * Cache the scrollbar state into local storage. The scrollbar state is kept when refreshing the dashboard.
     */
    xAxisSaveZoom?: boolean;
}

export declare interface Am4ChartCursorOptions extends FormFieldObject {
    /**
     * Chart Cursor.
     */
    chartCursorEnabled: boolean;
    /**
     * Chart Cursor Behavior.
     *
     * Action performed when the user drags the cursor.
     */
    chartCursorBehaviour: "zoomX" | "zoomY" | "zoomXY" | "selectX" | "selectY" | "selectXY" | "panX" | "panY" | "panXY" | "none";
}

export declare interface Am4ChartOptions extends FormFieldObject {
    widgetVariant?: string;
    /**
     * Hook to change the chart series, axes and other components. This hook is called for each data or options update
     * and after all the component have updated. You can use it to change the settings in the chart.
     *
     * <pre>
     *     ( value: PublicAmchartsBase<amcharts4.Chart, options> ) => void;
     *
     *          value.getChart() is returning an instance of amChart 4 class
     *          whose name is available in chart options below.
     * </pre>
     */
    postRenderHook?: Hook<PublicAmCharts4Base<any, any>, any>;
    /**
     * Called once, directly after the chart is created.
     *
     * <pre>
     *     ( chart: amcharts4.Chart, options: Am4ChartOptions ) => void;
     * </pre>
     */
    onChartCreatedHook?: Hook<any, Am4ChartOptions>;
}

export declare type Am4Color = Property.Color;

export declare interface Am4ColumnSeriesOptions extends FormFieldObject, IStrokeStyleProperties {
    /**
     * [Column Chart]
     *
     * Column Values.
     *
     * A column with values for the series.
     *
     * [Bar Chart]
     *
     * Bar Values.
     *
     * A column with values for the bar series.
     *
     * [Stacked Bar Chart]
     *
     * Bar Values.
     *
     * A column with values for the stacked bar series.
     *
     * [Stacked Column Chart]
     *
     * Values Column.
     *
     * A column with values for the stacked column series.
     */
    columnValue: TidyTableColumnSelector[];
    /**
     * Tooltip.
     *
     * Show this text when hovering the column in the chart.
     */
    chartCursorTooltipColumn: string;
    /**
     * Legend Text.
     *
     * The name of the column series in the legend.
     */
    legendColumnSeriesLabel?: string;
    /**
     * Show Value in Legend.
     *
     * Display values in the legend when the user moves the cursor over the chart.
     */
    legendColumnSeriesShowValue: boolean;
    /**
     * Column Color.
     *
     * A column with colors for the columns in the chart.
     */
    columnSeriesColor?: TidyTableColumnSelector;
}

export declare interface Am4ComboSeriesOptions extends FormFieldObject, IStrokeStyleProperties {
    /**
     * Values for the left series. Named line due to legacy.
     */
    lineValue: TidyTableColumnSelector[];
    /**
     * Values for the right series. Named column due to legacy.
     */
    columnValue: TidyTableColumnSelector[];
    /**
     * Draw the line-series in this axis. Defaults to "left".
     */
    lineSeriesDrawOnAxis: DrawSeriesOnAxis;
    /**
     * Draw the column-series in this axis. Defaults to "right".
     */
    columnSeriesDrawOnAxis: DrawSeriesOnAxis;
    /**
     * Type of the left series. Line / Column.
     */
    seriesTypeLeft: SeriesType;
    /**
     * Type of the right series. Line / Column.
     */
    seriesTypeRight: SeriesType;
    lineBulletShapeLeft?: TidyTableColumnSelector;
    hideLineBulletsLeft: boolean;
    chartCursorTooltipLineLeft: string;
    legendLineSeriesLabelLeft?: string;
    legendLineSeriesShowValueLeft: boolean;
    areaFillOpacityLeft: number;
    lineSeriesColorLeft?: TidyTableColumnSelector;
    connectLineSeriesLeft: boolean;
    smoothLineMethodLeft: Amcharts4LineSmoothMethod;
    smoothLineTensionXLeft: number;
    smoothLineTensionYLeft: number;
    chartCursorTooltipColumnLeft: string;
    legendColumnSeriesLabelLeft?: string;
    legendColumnSeriesShowValueLeft: boolean;
    columnSeriesColorLeft?: TidyTableColumnSelector;
    lineBulletShapeRight?: TidyTableColumnSelector;
    hideLineBulletsRight: boolean;
    chartCursorTooltipLineRight: string;
    legendLineSeriesLabelRight?: string;
    legendLineSeriesShowValueRight: boolean;
    areaFillOpacityRight: number;
    lineSeriesColorRight?: TidyTableColumnSelector;
    connectLineSeriesRight: boolean;
    smoothLineMethodRight: Amcharts4LineSmoothMethod;
    smoothLineTensionXRight: number;
    smoothLineTensionYRight: number;
    chartCursorTooltipColumnRight: string;
    legendColumnSeriesLabelRight?: string;
    legendColumnSeriesShowValueRight: boolean;
    columnSeriesColorRight?: TidyTableColumnSelector;
}

export declare interface Am4DateAxisOptions extends FormFieldObject, Pick<Am4ValueAxisOptions, "yAxisTitleText" | "yAxisMinGridDistance" | "yAxisShowGridLines" | "yAxisSaveZoom"> {
    /**
     * In-place processing of the amCharts 4 date axis instance.
     *
     * <pre>
     *     ( value: ValueAxis, options: Am4DateAxisOptions ) => void;
     * </pre>
     */
    yAxisPostRenderHook?: Hook<any, Am4DateAxisOptions>;
}

export declare interface Am4DivergentAxisLabelOptions extends FormFieldObject {
    /**
     * The text to show in the left label. Use a single space to not show the label.
     */
    leftLabelText: string;
    /**
     * The text to show in the right label. Use a single space to not show the label.
     */
    rightLabelText: string;
}

export declare interface Am4DivergentBarSeriesOptions extends FormFieldObject, IStrokeStyleProperties {
    /**
     * Values for the series on the left
     */
    leftValue: TidyTableColumnSelector;
    /**
     * Values for the series on the right
     */
    rightValue: TidyTableColumnSelector;
    /**
     * Tooltip.
     *
     * Show this text when hovering the column in the chart.
     */
    chartCursorTooltipColumn: string;
    /**
     * Legend Text.
     *
     * The name of the column series in the legend.
     */
    legendColumnSeriesLabel?: string;
    /**
     * Show Value in Legend.
     *
     * Display values in the legend when the user moves the cursor over the chart.
     */
    legendColumnSeriesShowValue: boolean;
}

export declare interface Am4DonutLegendOptions extends Am4LegendOptions {
    /**
     * Legend Label.
     *
     * The HTML contents of the legend labels.
     */
    legendLabel: string;
    /**
     * Legend Value.
     *
     * Show a value in the legend next to the label. Leave blank to show no value. The value is rendered as HTML.
     */
    legendValue?: string;
}

export declare interface Am4DonutOptions extends FormFieldObject {
    /**
     * Inner Radius.
     *
     * The inner radius of the donut as a percentage of the outer radius. Set to 0 to get a pie chart.
     */
    donutInnerRadius: number;
    /**
     * Radius.
     *
     * The radius of the chart as a percentage of the available space.
     */
    donutRadius: number;
    /**
     * Start Angle.
     *
     * The donut starts at this angle. "The angle in degrees is a value between 0 and 360. Note, the angle starts
     * at 3 o'clock and rotates clockwise. An angle of 180 starts the donut at 9 o'clock.
     */
    donutStartAngle: number;
    /**
     * End Angle.
     *
     * The angle in degrees is a value between 0 and 360. Note, the angle starts at 3 o'clock and rotates clockwise.
     * An angle of 360 ends the donut at 3 o'clock.
     */
    donutEndAngle: number;
}

export declare interface Am4GanttSeriesOptions extends Omit<Am4ColumnSeriesOptions, "columnValue" | "legendColumnSeriesShowValue"> {
    /**
     * Start datetime values of the gantt series.
     */
    startValue: TidyTableColumnSelector[];
    /**
     * End datetime values of the gantt series.
     */
    endValue: TidyTableColumnSelector[];
    /**
     * If true, show groups in the same lane instead of in their separate lanes.
     */
    showGroupsOnSingleLane?: boolean;
}

export declare interface Am4GaugeAxisOptions extends FormFieldObject {
    /**
     * Minimum.
     *
     * Start value of the axis.
     */
    gaugeAxisMinimum: string;
    /**
     * Maximum.
     *
     * End value of the axis.
     */
    gaugeAxisMaximum: string;
    /**
     * Format.
     *
     * Format pattern. Examples: integer: `#`; two decimals: `#.00`; thousands/millions: `#a`; currency: `€#`.
     */
    gaugeAxisValueFormat?: string;
    /**
     * Min Label Distance.
     *
     * Minimum distance between axis labels.
     */
    gaugeAxisMinGridDistance: number;
    /**
     * Axis Ranges.
     *
     * JSON Axis Ranges. For example:
     *
     * <pre>
     * [
     *   {
     *     "label": "low",
     *     "start": 0,
     *     "end": 50,
     *     "color": "red"
     *   },
     *   {
     *     "label": "high",
     *     "start": 50,
     *     "end": 100,
     *     "color": "green"
     *   }
     * ]
     * </pre>
     */
    gaugeAxisRanges?: string;
    gaugeAxisShowLabels: boolean;
    gaugeAxisBentLabels: boolean;
    gaugeAxisSwapAxes: boolean;
    gaugeAxisLabelsRadius: number;
    gaugeAxisRadius: number;
    gaugeAxisRangesRadius: number;
    gaugeAxisRangeLabelsRadius: number;
    gaugeAxisRangeOpacity: number;
}

export declare interface Am4GaugeHandOptions extends FormFieldObject {
    /**
     * Value.
     *
     * The hand will point to this value on the axis. Note, The gauge only considers the first row.
     */
    value: TidyTableColumnSelector;
    /**
     * Color.
     *
     * The color of the hand.
     */
    gaugeHandColor: string;
    gaugeHandInnerRadius: number;
    gaugeHandStartWidth: number;
    gaugeHandPinDisabled: boolean;
    gaugeHandPinRadius: number;
}

export declare interface Am4GaugeOptions extends FormFieldObject {
    /**
     * Radius.
     *
     * The radius of the chart as a percentage of the available space.
     */
    gaugeRadius: number;
    gaugeInnerRadius: number;
    gaugeStartAngle: number;
    gaugeEndAngle: number;
}

export declare interface Am4GeoSeriesOptions extends FormFieldObject {
    /**
     * Region.
     *
     * Column with [ISO-2 codes](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2#Officially_assigned_code_elements)
     * (e.g., US, CH, GB, FR). Note that provinces, regions, departments are available as well (e.g., FR-30).
     */
    region: TidyTableColumnSelector;
    /**
     * Region Click Column.
     *
     * If defined, the column that is used to fire the region-click event.
     */
    hitColumn?: TidyTableColumnSelector;
    /**
     * Map.
     *
     * The map displayed by the chart. Use any URL to access your own GeoJSON file
     * (e.g., https://customer.com/world.json).
     */
    mapUrl: string;
    /**
     * Map Projection.
     */
    mapProjection: GeoMapChartProjection;
    /**
     * Initial Zoom.
     *
     * To set the currently displayed zoom open the widget's menu (top right) and click on 'Set Zoom & Center'.
     */
    initialZoom?: number;
    /**
     * Initial Latitude.
     *
     * To set the currently displayed latitude open the widget's menu (top right) and click on 'Set Zoom & Center'.
     */
    initialLatitude?: number;
    /**
     * Initial Longitude.
     *
     * To set the currently displayed longitude open the widget's menu (top right) and click on 'Set Zoom & Center'.
     */
    initialLongitude?: number;
    /**
     * Region Tooltip.
     *
     * The region column is the expression default column.
     */
    tooltip?: string;
    /**
     * Unmatched Regions Strategy.
     *
     * Used for missing map regions in the query.
     */
    unmatchedRegionStrategy: GeoMapChartUnMatchedRegionStrategy;
    /**
     * Excluded Regions.
     *
     * A comma separated list of country codes that will be excluded from the map (e.g., US, CH, GB).
     */
    excludedRegions?: string;
    /**
     * Draggable.
     */
    draggable: boolean;
    /**
     * Zoomable.
     */
    zoomable: boolean;
    /**
     * Region Color.
     *
     * A column with the colors of the regions.
     */
    regionColorColumn?: TidyTableColumnSelector;
    /**
     * Default Region Color.
     *
     * Color used for regions without a value in the 'Region Color' column.
     */
    regionColor: IColorDef;
    /**
     * Background Color (Water).
     */
    backgroundColor?: IColorDef;
}

export declare interface Am4LabelOptions extends FormFieldObject {
    /**
     * Text.
     *
     * The text displayed in the center of the chart.
     * Use a single space to show no text and disable the label.
     */
    labelText: string;
    labelTextAlign: 'start' | 'end' | 'middle';
    labelDy: number;
    labelDx: number;
    labelHasBackground: boolean;
    labelBackgroundColor?: IColorDef;
    labelBackgroundOpacity: number;
    labelHorizontalCenter: 'left' | 'middle' | 'right' | 'none';
    labelVerticalCenter: 'bottom' | 'middle' | 'top' | 'none';
}

export declare interface Am4LegendOptions extends FormFieldObject {
    /**
     * Legend.
     */
    legendEnabled: boolean;
    /**
     * Legend Position.
     */
    legendPosition: LegendPositionOption;
    /**
     * Reverse Legend Order.
     *
     * Reverse the items in the legend.
     */
    legendOrderReversed: boolean;
}

export declare interface Am4LineSeriesOptions extends FormFieldObject, IStrokeStyleProperties, IBulletShapeOptions {
    /**
     * [Line Chart]
     *
     * Line Values.
     *
     * A column with values for the line.
     *
     * [Area Chart]
     *
     * Area Values.
     *
     * The values for the area series.
     *
     * [Stacked Area Chart]
     *
     * Area Values.
     *
     * A column with values for the stacked area chart.
     */
    lineValue: TidyTableColumnSelector[];
    /**
     * Shape.
     *
     * Use this column to change the shape of the data-point.
     */
    lineBulletShape?: TidyTableColumnSelector;
    /**
     * Hide Line Bullets
     */
    hideLineBullets: boolean;
    /**
     * Tooltip.
     *
     * The text displayed as a tooltip on the line.
     */
    chartCursorTooltipLine: string;
    /**
     * Legend Text.
     *
     * The name of the line series in the legend.
     */
    legendLineSeriesLabel?: string;
    /**
     * Show Value in Legend.
     *
     * Show values in the legend when the user moves the cursor over the chart.
     */
    legendLineSeriesShowValue: boolean;
    /**
     * Area Fill Opacity.
     *
     * A value on [0, 1], where 0 is fully transparent and 1 is no transparency.
     */
    areaFillOpacity: number;
    /**
     * Line Color.
     *
     * A column with colors for the line and bullets in the chart.
     */
    lineSeriesColor?: TidyTableColumnSelector;
    /**
     * If true, connect the lines over empty data points.
     */
    connectLineSeries: boolean;
    smoothLineMethod: Amcharts4LineSmoothMethod;
    /**
     * Smooth the line chart. The tension is a value between 0 (no tension) and 1 (maximum tension).
     */
    smoothLineTensionX: number;
    smoothLineTensionY: number;
}

export declare interface Am4PieLabelOptions extends FormFieldObject {
    /**
     * Category.
     *
     * Data column that identifies the slices in the pie chart.
     */
    category: TidyTableColumnSelector;
    /**
     * Text.
     *
     * The text displayed on the slices.
     */
    sliceLabelsText: string;
    /**
     * Max Width.
     *
     * Maximum width of the label.
     */
    sliceLabelsMaxWidth: number;
    /**
     * Overflow Type.
     *
     * What happens when the label is larger than the max width?
     */
    sliceLabelsOverflow?: OverflowType;
    /**
     * Align Labels.
     *
     * Align the labels to the left and to the right of the chart.
     */
    sliceLabelsAlignLabels: boolean;
    /**
     * Hide labels below this threshold. Can be a number (e.g., 100) or a percentage (e.g., 5%).
     */
    sliceLabelsHideThreshold?: string;
}

export declare interface Am4PieSeriesOptions extends FormFieldObject, IStrokeStyleProperties {
    /**
     * Values.
     *
     * Data column (numeric) that defines the value of the slices.
     */
    value: TidyTableColumnSelector;
    /**
     * Tooltip.
     *
     * The text displayed as a tooltip on the slices.
     */
    chartCursorTooltipPie: string;
    /**
     * Sort Slices.
     *
     * Preferably, the slices of the donut chart are sorted large to small. Enable this options to sort the slices.
     */
    pieSeriesSortSlices: boolean;
    /**
     * Colors.
     *
     * Data column that defines the colors of the slices. Using the Category (see the Labels section) as default.
     */
    color?: TidyTableColumnSelector;
}

export declare interface Am4SankeyDiagramOptions extends FormFieldObject {
    /**
     * Orientation.
     *
     * Show the Sankey from left to right if 'Horizontal' and from top to bottom if 'Vertical'.
     */
    orientation: 'horizontal' | 'vertical';
    /**
     * If true, the first column describes the from nodes, and the second column the to nodes.
     */
    useFromToDataDefinition: boolean;
}

export declare interface Am4SankeyFlowOptions extends FormFieldObject {
    /**
     * Value.
     *
     * Flow values.
     */
    value: TidyTableColumnSelector;
    /**
     * Link Fill Opacity.
     *
     * Value between 0 and 1 for the opacity of the links/flows between the nodes.
     */
    linkFillOpacity: number;
    /**
     * Flow Tension.
     *
     * Set to 1 for straight flows. Smaller values make the flows curve more.
     */
    flowTension: number;
    /**
     * Color Mode.
     */
    colorMode: 'solid' | 'gradient' | 'fromNode' | 'toNode';
    /**
     * The tooltip for the node
     */
    flowTooltip?: string;
}

export declare interface Am4SankeyNodeOptions extends FormFieldObject, IStrokeStyleProperties {
    /**
     * Width.
     *
     * Depending on the orientation, the width (if horizontal) or height (if vertical) of the node.
     */
    nodeWidth: number;
    /**
     * Tooltip for the node
     */
    nodeTooltip?: string;
}

export declare interface Am4ScatterSeriesOptions extends FormFieldObject, IStrokeStyleProperties, IBulletShapeOptions {
    /**
     * Labels.
     *
     * Column with the names for the scatter points.
     */
    label: TidyTableColumnSelector;
    /**
     * X-Values
     *
     * Column with the x-coordinates for the scatter points.
     */
    valueX: TidyTableColumnSelector;
    /**
     * Y-Values
     *
     * Column with the y-coordinates for the scatter points.
     */
    valueY: TidyTableColumnSelector;
    /**
     * Group.
     *
     * Create a new series for each group.
     */
    group?: TidyTableColumnSelector;
    /**
     * Color.
     *
     * Color of the item in the scatter plot.
     */
    scatterSeriesColor?: TidyTableColumnSelector;
    /**
     * Shape.
     *
     * Use this column to change the shape of the data-point.
     */
    scatterBulletShape?: TidyTableColumnSelector;
    /**
     * Tooltip.
     *
     * The text displayed as a tooltip on the points.
     */
    chartCursorTooltipScatter: string;
}

export declare interface Am4ScatterTrendLineOptions extends FormFieldObject {
    /**
     * Trend Line.
     */
    trendLineEnabled: boolean;
    /**
     * Trend Line Color.
     *
     * Column containing the color for the trend line.
     */
    trendLineColor?: IColorDef;
    /**
     * Stroke Dash Array.
     *
     * Comma separated list of dash-lengths and gap-lengths. Use 0 for solid line.
     */
    trendLineStrokeDashArray: string;
    /**
     * Show in Legend.
     *
     * Display the trend line in the legend (if the legend is enabled).
     */
    trendLineShowInLegend: boolean;
    /**
     * Per Group.
     *
     * Display a trend line for each group?
     */
    trendLinePerGroup: boolean;
}

export declare interface Am4ScrollbarOptions extends FormFieldObject {
    /**
     * Horizontal Scrollbar.
     */
    EnableScrollbarX: boolean;
    /**
     * Horizontal Scrollbar Plot.
     *
     * Show the first series as a plot in the horizontal scrollbar.
     */
    ScrollbarXShowSeries: boolean;
    /**
     * Vertical Scrollbar.
     */
    EnableScrollbarY: boolean;
    /**
     * Vertical Scrollbar Plot.
     *
     * Show the first series as a plot in the vertical scrollbar.
     */
    ScrollbarYShowSeries: boolean;
}

export declare interface Am4SecondValueAxisOptions extends FormFieldObject {
    /**
     * Title Text.
     *
     * The title of the vertical axis.
     */
    yAxisSecondTitleText?: string;
    /**
     * Minimum.
     *
     * The axis starts at this value.
     */
    yAxisSecondMinimum?: number;
    /**
     * Maximum.
     *
     * The axis end at this value.
     */
    yAxisSecondMaximum?: number;
    /**
     * Adjust Minimum By.
     *
     * Expand the calculated axis range by this percentage, making the minimum smaller.
     */
    yAxisSecondExtraMinimum?: number;
    /**
     * Adjust Maximum By.
     * Expand the calculated axis range by this percentage, making the maximum larger.
     */
    yAxisSecondExtraMaximum?: number;
    /**
     * Always Include Zero.
     *
     * Always show zero in the axis.
     */
    yAxisSecondIncludeZero: boolean;
    /**
     * Show Numbers.
     *
     * Display the numbers next to the axis.
     */
    yAxisSecondShowLabels: boolean;
    /**
     * Value Format.
     *
     * Format pattern. Examples: integer: `#`; two decimals: `#.00`; thousands/millions: `#a`; currency: `€#`.
     */
    yAxisSecondValueFormat?: string;
    /**
     * Maximum number of decimals to allow when placing grid lines and labels on axis.
     *
     * Set it to 0 (zero) to force integer-only axis labels.
     */
    yAxisSecondMaxPrecision?: number;
    /**
     * Minimum Grid Distance.
     *
     * The minimum distance between the grid lines.
     */
    yAxisSecondMinGridDistance?: number;
    /**
     * Initial Zoom.
     *
     * The start value and the end value seperated by a comma.
     */
    yAxisSecondInitialZoom?: string;
    /**
     * In-place processing of the amCharts 4 category/date axis instance.
     *
     * <pre>
     *     ( value: ValueAxis, options: Am4SecondValueAxisOptions ) => void;
     * </pre>
     */
    yAxisSecondPostRenderHook?: Hook<any, Am4SecondValueAxisOptions>;
}

export declare interface Am4SecondValueLabelOptions extends FormFieldObject {
    /**
     * @see Am4ValueLabelOptions
     */
    seriesLabelsEnabledSecond: boolean;
    /**
     * @see Am4ValueLabelOptions
     */
    seriesLabelsTextSecond: string;
    /**
     * @see Am4ValueLabelOptions
     */
    seriesLabelsPositionSecond: SeriesLabelsPosition;
    /**
     * @see Am4ValueLabelOptions
     */
    seriesLabelsHideOversizeSecond: boolean;
    /**
     * @see Am4ValueLabelOptions
     */
    seriesLabelsStackTotalTextSecond?: string;
}

export declare interface Am4SimpleCategoryAxisOptions extends FormFieldObject {
    /**
     * Title Text.
     *
     * The title of the horizontal axis.
     *
     * [Bar Chart]
     *
     * Title Text.
     *
     * The title of the vertical axis.
     */
    xAxisTitleText?: string;
    /**
     * Label Spacing.
     *
     * Controls the minimum space between the labels.
     */
    xAxisLabelSpacing?: number;
    /**
     * Max Label Width.
     *
     * The maximum width in pixels for the labels.
     */
    xAxisLabelMaxWidth?: number;
    /**
     * Label Overflow.
     *
     * Choice of behavior when the label is larger than the max width.
     */
    xAxisLabelOverflow?: OverflowType;
    /**
     * Rotate Label.
     *
     * Rotate the labels on the category axis by 45 degrees.
     */
    xAxisRotateLabels?: CategoryAxisRotateLabels;
    /**
     * Cell Start Location.
     *
     * Value between 0 and 1 that indicates where the category starts on the grid.
     */
    xAxisCellStartLocation: number;
    /**
     * Cell End Location.
     *
     * Value between 0 and 1 that indicates where the category ends on the grid.
     */
    xAxisCellEndLocation: number;
    /**
     * Initial Zoom.
     *
     * The start index and the end index seperated by a comma. You can use negative values to get the index from the
     * end of the axis. E.g., `-10,-1` zooms to the last 10 items.
     */
    xAxisInitialZoom?: string;
    /**
     * In-place processing of the amCharts 4 category/date axis instance.
     *
     * <pre>
     *     ( value: CategoryAxis | DateAxis, options?: Am4SimpleCategoryAxisOptions ) => void;
     * </pre>
     */
    xAxisPostRenderHook?: Hook<any, Am4SimpleCategoryAxisOptions>;
    /**
     * Cache the scrollbar state into local storage. The scrollbar state is kept when refreshing the dashboard.
     */
    xAxisSaveZoom?: boolean;
}

export declare interface Am4SimpleColumnSeriesOptions extends FormFieldObject, IStrokeStyleProperties {
    /**
     * Value.
     *
     * Display the distribution of the values in this column.
     */
    value: TidyTableColumnSelector;
    /**
     * Group By.
     *
     * Distribution for each group.
     */
    groupBy?: TidyTableColumnSelector;
    /**
     * Column Color.
     *
     * A column with colors for the columns in the chart.
     */
    columnSeriesColor?: TidyTableColumnSelector;
    /**
     * Tooltip.
     *
     * Show this text when hovering the column in the chart.
     */
    chartCursorTooltipColumn: string;
    /**
     * Legend Text.
     *
     * The name of the column series in the legend.
     */
    legendColumnSeriesLabel?: string;
    /**
     * Show Value in Legend.
     *
     * Show values in the legend when the user moves the cursor over the chart.
     */
    legendColumnSeriesShowValue: boolean;
    /**
     * Clustered.
     *
     * Show the columns in a group next to each other. If false, the chart renders them layered on top of each other.
     */
    clustered: boolean;
    /**
     * Fill Opacity.
     *
     * Opacity of the columns fill (excluding the border).
     */
    columnFillOpacity: number;
}

export declare interface Am4TreeMapSeriesOptions extends FormFieldObject, IStrokeStyleProperties {
    /**
     * First Level.
     *
     * The first level contains the names for the items.
     */
    level0: TidyTableColumnSelector;
    /**
     * Second Level.
     *
     * Adds a hierarchy to the first level.
     */
    level1?: TidyTableColumnSelector;
    /**
     * Values.
     *
     * Sizes of the boxes.
     */
    value: TidyTableColumnSelector;
    /**
     * Color.
     *
     * Column containing colors for the tree items.
     */
    treemapColor?: TidyTableColumnSelector;
    /**
     * Labels when labelType is 'html'. Expression for the labels on the tree items.
     */
    labelExpressionHTML: string;
    /**
     * Labels when labelType is 'text'. Expression for the labels on the tree items.
     */
    labelExpressionText: string;
    /**
     * Label Type.
     *
     * Render the label as text or as HTML.
     */
    labelType: "html" | "text";
    /**
     * Label Overflow.
     *
     * Choice of behavior when the label is larger than the max width.
     */
    labelOverflow?: OverflowType;
    /**
     * Tooltips.
     *
     * Expression for the tooltip when hovering a tree item.
     */
    tooltipExpression: string;
    /**
     * Corner Radius.
     */
    cornerRadius: number;
    /**
     * Layout Algorithm.
     *
     * The algorithm used to divide the area into squares based on their values.
     */
    layoutAlgorithm: "binaryTree" | "dice" | "slice" | "sliceDice" | "squarify";
}

export declare interface Am4TrendLineOptions extends FormFieldObject {
    trendLineType: TrendLineType;
    /**
     * Trend Line
     */
    trendLineEnabled: boolean;
    /**
     * Stroke Dash Array.
     *
     * Comma separated list of dash-lengths and gap-lengths. Use 0 for solid line.
     */
    trendLineStrokeDashArray: string;
    /**
     * Show in Legend.
     *
     * Display the trend line in the legend (if the legend is enabled).
     */
    trendLineShowInLegend: boolean;
    /**
     * Trend Line Color.
     *
     * Column containing the color for the trend line.
     */
    trendLineColor?: IColorDef;
    /**
     * Per Group.
     *
     * Display a trend line for each group?
     */
    trendLinePerGroup: boolean;
}

export declare interface Am4ValueAxisOptions extends FormFieldObject {
    /**
     * Title Text.
     *
     * The title of the vertical axis.
     *
     * [Bar Chart]
     *
     * Title Text.
     *
     * The title of the horizontal axis.
     */
    yAxisTitleText?: string;
    /**
     * Minimum.
     *
     * The axis starts at this value.
     */
    yAxisMinimum?: number;
    /**
     * Maximum.
     *
     * The axis ends at this value.
     */
    yAxisMaximum?: number;
    /**
     * Adjust Minimum By.
     *
     * Expand the calculated axis range by this percentage, making the minimum smaller.
     */
    yAxisExtraMinimum?: number;
    /**
     * Adjust Maximum By.
     *
     * Expand the calculated axis range by this percentage, making the maximum larger.
     */
    yAxisExtraMaximum?: number;
    /**
     * Always Include Zero.
     *
     * Always show zero in the axis.
     */
    yAxisIncludeZero: boolean;
    /**
     * Show Numbers.
     *
     * Display the numbers next to the axis.
     */
    yAxisShowLabels: boolean;
    /**
     * Value Format.
     *
     * Format pattern. Examples: integer: `#`; two decimals: `#.00`; thousands/millions: `#a`; currency: `€#`.
     */
    yAxisValueFormat?: string;
    /**
     * Maximum number of decimals to allow when placing grid lines and labels on axis.
     *
     * Set it to 0 (zero) to force integer-only axis labels.
     */
    yAxisMaxPrecision?: number;
    /**
     * Minimum Grid Distance.
     *
     * The minimum distance between the grid lines.
     */
    yAxisMinGridDistance?: number;
    /**
     * Initial Zoom.
     *
     * The start value and the end value seperated by a comma.
     */
    yAxisInitialZoom?: string;
    /**
     * Show the grid lines perpendicular to the value axis.
     */
    yAxisShowGridLines: boolean;
    /**
     * In-place processing of the amCharts 4 category/date axis instance.
     *
     * <pre>
     *     ( value: ValueAxis, options: Am4ValueAxisOptions ) => void;
     * </pre>
     */
    yAxisPostRenderHook?: Hook<any, Am4ValueAxisOptions>;
    /**
     * Cache the scrollbar state into local storage. The scrollbar state is kept when refreshing the dashboard.
     */
    yAxisSaveZoom?: boolean;
}

export declare interface Am4ValueAxisRangeOptions extends FormFieldObject {
    /**
     * Y-Axis Range.
     *
     * Display a line or a ranged fill/band on the y-axis.
     *
     * [Bar Chart]
     *
     * X-Axis Range.
     *
     * Display a line or a ranged fill / band on the x-axis.
     *
     * [Stacked Bar Chart]
     *
     * X-Axis Range.
     *
     * Display a line or a ranged fill / band on the x-axis.
     */
    axisRangeEnabled: boolean;
    /**
     * Type.
     */
    axisRangeType: AxisRangeType;
    /**
     * Start Value.
     *
     * Starting value of the range or value of the line.
     */
    axisRangeStart: string;
    /**
     * End Value.
     *
     * Ending value for the range.
     */
    axisRangeEnd: string;
    /**
     * Label.
     *
     * Label to display on the range.
     */
    axisRangeLabel: string;
    /**
     * Inside.
     *
     * If enabled, the range renders the label inside the chart.
     */
    axisRangeLabelInside: boolean;
    /**
     * Color.
     *
     * The color of the ranged fill / band or line.
     */
    axisRangeColor?: IColorDef;
    /**
     * Range Opacity.
     *
     * The opacity of the ranged fill / band.
     */
    axisRangeFillOpacity: number;
    /**
     * Stroke Opacity.
     *
     * The opacity of the line.
     */
    axisRangeStrokeOpacity: number;
    /**
     * Stroke Width.
     *
     * The width of the line.
     */
    axisRangeStrokeWidth: number;
    /**
     * Stroke Dash Array.
     *
     * Comma separated list of dash-lengths and gap-lengths. Use 0 for solid line.
     */
    axisRangeStrokeDashArray: string;
    /**
     * Above.
     *
     * If enabled, the chart renders the range or line above the series.
     */
    axisRangeAboveGrid: boolean;
}

export declare interface Am4ValueLabelOptions extends FormFieldObject {
    /**
     * Value Labels.
     *
     * Add a value label for each item in the chart.
     */
    seriesLabelsEnabled: boolean;
    /**
     * Label Text.
     */
    seriesLabelsText: string;
    /**
     * Label Position.
     *
     * Where to show the label on the item.
     */
    seriesLabelsPosition: SeriesLabelsPosition;
    /**
     * Hide Small Labels.
     *
     * Hide labels that don't fit.
     */
    seriesLabelsHideOversize: boolean;
    /**
     * Stack Top Text.
     *
     * Text displayed on top of the stack.
     */
    seriesLabelsStackTotalText?: string;
}

/**
 * The corresponding AmCharts 4 chart class is XYChart.
 */
export declare type AmCharts4BubbleChartOptions = Am4SecondValueAxisOptions & Am4ValueAxisOptions & Am4BubbleSeriesOptions & Am4ValueLabelOptions & Am4ChartCursorOptions & Am4ScatterTrendLineOptions & Am4ScrollbarOptions & Am4LegendOptions & Am4ChartOptions;

/**
 * The corresponding AmCharts 4 chart class is  XYChart.
 */
export declare type AmCharts4ComboChartOptions = Am4CategoryDateAxisOptions & Am4ValueAxisOptions & Am4SecondValueAxisOptions & Am4ComboSeriesOptions & Am4LegendOptions & Am4ChartCursorOptions & Am4ScrollbarOptions & Am4ChartOptions & Am4ValueLabelOptions & Am4SecondValueLabelOptions & Am4ValueAxisRangeOptions;

export declare type AmCharts4CoordinateChartOptions = Am4TrendLineOptions;

/**
 * The corresponding AmCharts 4 chart class is XYChart.
 */
export declare type AmCharts4DivergentBarChartOptions = Am4CategoryDateAxisOptions & Am4ValueAxisOptions & Am4DivergentBarSeriesOptions & Am4LegendOptions & Am4ValueLabelOptions & Am4ChartCursorOptions & Am4ScrollbarOptions & Am4ValueAxisRangeOptions & Am4ChartOptions & Am4DivergentAxisLabelOptions;

/**
 * The corresponding AmCharts 4 chart class is PieChart.
 */
export declare type AmCharts4DonutChartOptions = Am4PieSeriesOptions & Am4PieLabelOptions & Am4LabelOptions & Am4DonutLegendOptions & Am4DonutOptions & Am4ChartOptions;

/**
 * The corresponding AmCharts 4 chart class is XYChart.
 */
export declare type AmCharts4GanttChartOptions = Am4CategoryDateAxisOptions & Am4DateAxisOptions & Am4GanttSeriesOptions & Am4LegendOptions & Am4ValueLabelOptions & Am4ChartCursorOptions & Am4ScrollbarOptions & Am4ChartOptions;

/**
 * The corresponding AmCharts 4 chart class is GaugeChart.
 */
export declare type AmCharts4GaugeChartOptions = Am4GaugeHandOptions & Am4GaugeAxisOptions & Am4LabelOptions & Am4GaugeOptions & Am4ChartOptions;

/**
 * The corresponding AmCharts 4 chart class is XYChart.
 */
export declare type AmCharts4HistogramOptions = Am4SimpleCategoryAxisOptions & Am4ValueAxisOptions & Am4SimpleColumnSeriesOptions & Am4ValueLabelOptions & Am4ChartCursorOptions & Am4ScrollbarOptions & Am4ChartOptions & Am4LegendOptions & TidyHistogramOptions;

export declare enum Amcharts4LineSmoothMethod {
    NONE = "none",
    TENSION = "tension",// See https://www.amcharts.com/docs/v4/chart-types/xy-chart/#Smoothed_lines
    MONOTONE_X = "monotoneX",// See https://www.amcharts.com/docs/v4/chart-types/xy-chart/#Alternate_smoothing_algorithm
    MONOTONE_Y = "monotoneY"
}

/**
 * The corresponding AmCharts 4 chart class is XYChart.
 */
export declare type AmCharts4RegularAreaChartOptions = Am4CategoryDateAxisOptions & Am4ValueAxisOptions & Am4LineSeriesOptions & Am4LegendOptions & Am4ValueLabelOptions & Am4ChartCursorOptions & Am4TrendLineOptions & Am4ScrollbarOptions & Am4ValueAxisRangeOptions & Am4ChartOptions;

/**
 * The corresponding AmCharts 4 chart class is XYChart.
 */
export declare type AmCharts4RegularBarChartOptions = Am4CategoryDateAxisOptions & Am4ValueAxisOptions & Am4ColumnSeriesOptions & Am4LegendOptions & Am4ValueLabelOptions & Am4ChartCursorOptions & Am4TrendLineOptions & Am4ScrollbarOptions & Am4ValueAxisRangeOptions & Am4ChartOptions;

/**
 * The corresponding AmCharts 4 chart class is XYChart.
 */
export declare type AmCharts4RegularColumnChartOptions = Am4CategoryDateAxisOptions & Am4ValueAxisOptions & Am4ValueAxisRangeOptions & Am4ColumnSeriesOptions & Am4ValueLabelOptions & Am4ChartCursorOptions & Am4TrendLineOptions & Am4ScrollbarOptions & Am4ChartOptions & Am4LegendOptions;

/**
 * The corresponding AmCharts 4 chart class is XYChart.
 */
export declare type AmCharts4RegularLineChartOptions = Am4CategoryDateAxisOptions & Am4ValueAxisOptions & Am4LineSeriesOptions & Am4LegendOptions & Am4ValueLabelOptions & Am4ChartCursorOptions & Am4TrendLineOptions & Am4ScrollbarOptions & Am4ChartOptions & Am4ValueAxisRangeOptions;

/**
 * The corresponding AmCharts 4 chart class is SankeyDiagram.
 */
export declare type AmCharts4SankeyDiagramOptions = Am4SankeyFlowOptions & Am4SankeyNodeOptions & Am4SankeyDiagramOptions & Am4ChartOptions;

/**
 * The corresponding AmCharts 4 chart class is XYChart.
 */
export declare type AmCharts4ScatterPlotOptions = Am4SecondValueAxisOptions & Am4ValueAxisOptions & Am4ScatterSeriesOptions & Am4ValueLabelOptions & Am4ChartCursorOptions & Am4ScatterTrendLineOptions & Am4ScrollbarOptions & Am4LegendOptions & Am4ChartOptions;

/**
 * The corresponding AmCharts 4 chart class is XYChart.
 */
export declare type AmCharts4StackedAreaChartOptions = Am4CategoryDateAxisOptions & Am4ValueAxisOptions & Am4LineSeriesOptions & Am4LegendOptions & Am4ValueLabelOptions & Am4ChartCursorOptions & Am4TrendLineOptions & Am4ScrollbarOptions & Am4ChartOptions & Am4ValueAxisRangeOptions;

/**
 * The corresponding AmCharts 4 chart class is XYChart.
 */
export declare type AmCharts4StackedBarChartOptions = Am4CategoryDateAxisOptions & Am4ValueAxisOptions & Am4ColumnSeriesOptions & Am4LegendOptions & Am4ValueLabelOptions & Am4ChartCursorOptions & Am4TrendLineOptions & Am4ScrollbarOptions & Am4ChartOptions & Am4ValueAxisRangeOptions;

/**
 * The corresponding AmCharts 4 chart class is XYChart.
 */
export declare type AmCharts4StackedColumnChartOptions = Am4CategoryDateAxisOptions & Am4ValueAxisOptions & Am4ColumnSeriesOptions & Am4ValueLabelOptions & Am4ChartCursorOptions & Am4TrendLineOptions & Am4ScrollbarOptions & Am4ChartOptions & Am4LegendOptions & Am4ValueAxisRangeOptions;

declare type Amcharts4ThemeDateFormatter = {
    /**
     * Amcharts date formatter.
     * Read more about the format codes here: https://www.amcharts.com/docs/v4/concepts/formatters/formatting-date-time/#Format_codes
     * Read more about how these settings are used here: https://www.amcharts.com/docs/v4/concepts/axes/date-axis/#Setting_date_formats
     */
    dateFormatter: {
        millisecond: {
            dateFormat: string;
            periodChangeFormat: string;
        };
        second: {
            dateFormat: string;
            periodChangeFormat: string;
        };
        minute: {
            dateFormat: string;
            periodChangeFormat: string;
        };
        hour: {
            dateFormat: string;
            periodChangeFormat: string;
        };
        day: {
            dateFormat: string;
            periodChangeFormat: string;
        };
        week: {
            dateFormat: string;
            periodChangeFormat: string;
        };
        month: {
            dateFormat: string;
            periodChangeFormat: string;
        };
        year: {
            dateFormat: string;
            periodChangeFormat: string;
        };
    };
};

/**
 * The corresponding AmCharts 4 chart class is TreeMap.
 */
export declare type AmCharts4TreemapOptions = Am4ChartOptions & Am4LegendOptions & Am4TreeMapSeriesOptions;

export declare interface AmCharts4WrappedDefinition<WIDGET extends WidgetTemplateIDs> {
    /**
     * Some free text used while registering the wrapper (e.g., error purpose).
     */
    readonly registrationInfo: string;
    /**
     * e.g., amCharts4.AmCharts4DonutChart
     */
    readonly wrappedWidgetTemplateId: WIDGET;
    /**
     * New overall meta-information (e.g., id, groupId, image, etc...).
     */
    readonly props: Partial<IPublicWidgetTemplateDefinition<FormFieldObject>>;
    /**
     * Meta-information for the editing of the widget options as well as the actual processing of those options
     * (i.e., AmCharts 4 chart configuration). Lazy-loaded (and the underlying AmCharts 4 library) once required.
     *
     * <pre>
     *      export default {
     *
     *          hookChartOptionsMeta: () => {
     *              ...
     *          },
     *
     *          hookChartOptions: () => {
     *              ...
     *          },
     *
     *      }
     * </pre>
     */
    readonly hooks: Promise<any>;
}

export declare class ApiUtils {
    /**
     * Define the form field as being localized.
     */
    static readonly TAG_I18N_FIELD = "ic3t_";
    static makePlugin(definition: IPluginDefinition): () => IVersionedPluginDefinition;
    /**
     * A helper method to create a widget template using the resolveDefinition method.
     * Webpack lazy load of dependencies.
     *
     * @see IPublicWidgetJsTemplateDefinition#resolveDefinition
     */
    static createLazyJsWidgetTemplateDefinition<OPTIONS extends FormFieldObject>(definition: Omit<IPublicWidgetJsTemplateDefinition<OPTIONS>, "jsCode">): IPublicWidgetJsTemplateDefinition<OPTIONS>;
    static resolveAmCharts4WidgetTemplateDefinition<OPTIONS extends FormFieldObject>(definition: IPublicWidgetTemplateDefinition<OPTIONS>, wrapped: IPublicWidgetTemplateDefinition<any>): IPublicWidgetTemplateDefinition<OPTIONS>;
    /**
     * A utility function creating a wrapper widget template definition for existing AmCharts 4 widgets.
     */
    static makeAmCharts4WrappedWidgetTemplateDefinition<WIDGET extends WidgetTemplateIDs>(props: AmCharts4WrappedDefinition<WIDGET>): IWrappedWidgetTemplateDefinition<WIDGET>;
}

export declare class AppClasses {
    /**
     * Style applied to
     */
    static readonly root: string;
    /**
     * Style applied to
     */
    static readonly topMenu: string;
    /**
     * Style applied to
     */
    static readonly leftToolbar: string;
    /**
     * Style applied to
     */
    static readonly drawer: string;
    static readonly drawerSmall: string;
    /**
     * Dashboard in viewer mode
     */
    static readonly payload: string;
    /**
     * Style applied to
     */
    static readonly error: string;
    /**
     * Style applied to
     */
    static readonly topBar: string;
    static readonly topBarInFloating: string;
    /**
     * Style applied to
     */
    static readonly leftFilter: string;
    /**
     * Style applied to the root div containing the edited dashboard pages.
     */
    static readonly dashboard: string;
    /**
     * Style applied to
     */
    static readonly zoomWidget: string;
    /**
     * Class added to root when the left filter panel is collapsed.
     */
    static readonly leftPanelCollapsed: string;
}

export declare type AppClassKey = keyof AppClasses;

export declare interface AppDivProps {
    dashboardTheme: Theme;
    topBarOptions: TopBarOptions;
    leftBarOptions: LeftBarOptions;
    opacity?: string;
    drawerW: string;
}

export declare interface AppEditReportNotification extends IAppNotification {
    readonly type: "edit-report";
}

export declare interface AppLogoutNotification extends IAppNotification {
    readonly type: "logout";
}

export declare type AppNotification = AppLogoutNotification | AppEditReportNotification | AppPrintReportDialogNotification | AppPrintReportNotification | AppPrintReportWithoutStateNotification | AppPrintReportInBrowserNotification | SaveStateToLocalStorageNotification | RestoreStateFromLocalStorageNotification | SaveOwnPropsToLocalStorageNotification | RestoreWidgetOwnPropsFromLocalStorageNotification | SaveWidgetOwnPropsToLocalStorageNotification | RestoreOwnPropsFromLocalStorageNotification | InitializeSelectionAllWidgetsNotification | ClearSelectionAllWidgetsNotification;

export declare type AppNotificationType = "logout" | "edit-report" | "print-report-dialog" | "print-report" | "print-report-without-state" | "print-report-in-browser" | "clear-selection-all-widgets" | "initialize-selection-all-widgets" | "save-state-to-localstorage" | "restore-state-from-localstorage" | "save-ownprops-to-localstorage" | "restore-ownprops-from-localstorage" | "save-reportwidgets-ownprops-to-localstorage" | "restore-reportwidgets-ownprops-from-localstorage";

export declare interface AppPrintReportDialogNotification extends IAppNotification {
    readonly type: "print-report-dialog";
}

export declare interface AppPrintReportInBrowserNotification extends IAppPrintReportNotification {
    readonly type: "print-report-in-browser";
}

export declare interface AppPrintReportNotification extends IAppPrintReportNotification {
    readonly type: "print-report";
}

export declare interface AppPrintReportNotificationPayload {
    fileName?: string;
    paperSizeName?: PaperSizeName;
    paperOrientation?: PaperOrientation;
    marginTop?: number;
    marginRight?: number;
    marginBottom?: number;
    marginLeft?: number;
}

export declare interface AppPrintReportWithoutStateNotification extends IAppPrintReportNotification {
    readonly type: "print-report-without-state";
}

/**
 * Show an action button below the options
 */
export declare enum AutocompleteActions {
    ADD_COLOR = "ADD_COLOR",
    REFRESH_QUERY = "REFRESH_QUERY"
}

/**
 * Error messages for field suggestions and value candidates.
 * Put translations in ReportLocalization.csv.
 */
export declare enum AutocompleteNoOptionsText {
    NO_OPTIONS = "NO_OPTIONS",
    NO_COLUMNS = "NO_COLUMNS",
    NO_QUERY_RESULT = "NO_QUERY_RESULT",
    QUERY_HAS_ERROR = "QUERY_HAS_ERROR",
    TRANSFORMATION_HAS_ERROR = "TRANSFORMATION_HAS_ERROR",
    QUERY_OUTDATED = "QUERY_OUTDATED"
}

/**
 * The coordinate of an MDX axis. If and only if the columns source is from ON 0, the hierIdx is defined.
 */
export declare interface AxisCoordinate {
    /**
     * Object keeping track of the transformation from the original axis to the current column.
     * If this object is undefined, then the column can not be constructed using a coordinate transformation of the axis.
     */
    repetitionInfo?: MdxRepetitionInfo;
    /**
     * index of the axis. ON 0, ON 1, etc...
     */
    axisIdx: number;
    /**
     * index of the tuple in the axis. E.g. (AF, 2009) in [AF, 2008, AF, 2009, AF, 2010] has index 1.
     */
    tupleIdx?: number;
    /**
     * index of the member in the tuple. E.g. AF in (AF, 2009) has index 0 and 2009 has index 1.
     * undefined means use the whole tuple.
     */
    hierIdx?: number;
}

export declare enum AxisRangeType {
    LINE = "single_line",
    RANGE = "range",
    LINE_PER_MEASURE = "LINE_PER_MEASURE"
}

export declare interface BaseTableChartOptions extends FormFieldObject {
    /**
     * If active, the color defined in the Tidy Table are applied to the table.
     */
    applyHeaderColorDecoration?: boolean;
    /**
     * If enabled, show tooltips on every cell in the table (excluding renderers). Default = true.
     */
    cellTooltips: boolean;
    /**
     * Save the state of the table in the users browsers local storage.
     */
    saveTableStateLocally?: boolean;
    /**
     * Row Height.
     */
    tableSize: TableRowHeightOptions;
    /**
     * Width Mode.
     */
    columnSizing: TableColumnSizing;
    /**
     * The column widths when columnSizing == FLUID
     *
     * A comma separated list of column widths. Defines how the columns will grow compared to other columns
     * (e.g., 2 means twice as wide as 1). The last value repeats itself.
     */
    columnSizes_FLUID?: string;
    /**
     * The column widths when columnSizing == FIXED
     *
     * A comma separated list of column widths. The widths are defined in pixels (without the 'px'). Without any value,
     * similar to the Fluid mode. The 'auto' value means the columns are shrunk to the minimum width required by the
     * cell values and then expanded to fill all the available horizontal space. The last value repeats itself.
     */
    columnSizes_FIXED?: string;
    /**
     * The column widths when columnSizing == USER_RESIZABLE
     *
     * A comma separated list of column widths. The widths are defined in pixels (without the 'px'). Without any value,
     * similar to the Fluid mode. The 'auto' value means the columns are shrunk to the minimum width required by the
     * cell values and then expanded to fill all the available horizontal space. The last value repeats itself.
     */
    columnSizes_USER_RESIZABLE?: string;
    /**
     * Header Alignment (CSV).
     *
     * A comma separated list of values:  'left', 'center', 'right'. The last value repeats itself.
     */
    columnHeaderAlign: string;
    /**
     * Cell Alignment (CSV).
     *
     * A list of values: 'left', 'center', 'right'. The last value repeats itself.
     */
    columnCellAlign: string;
    /**
     * Pinned (CSV).
     *
     * A list of boolean values: 'true', 'false'. The last value repeats itself.
     */
    columnPinned: string;
    /**
     * Visible (CSV).
     *
     * A list of boolean values: 'true', 'false'. The last value repeats itself.
     */
    columnVisible: string;
    /**
     * Columns Header Menu.
     *
     * Activate the options of the menu in the header of the columns.
     */
    columnHeaderMenu: boolean;
    /**
     * Menu (CSV).
     *
     * A list of boolean values: 'true', 'false'. The last value repeats itself.
     */
    columnMenu: string;
    /**
     * Sortable (CSV).
     *
     * Display the sort options. A list of boolean values: 'true', 'false'. The last value repeats itself.
     */
    columnSortable: string;
    /**
     * Column Ordering (CSV).
     *
     * A list of boolean values: 'true', 'false'. The last value repeats itself.
     */
    columnOrdering: string;
    /**
     * Pinnable (CSV).
     *
     * Display the pin options. A list of boolean values: 'true', 'false'. The last value repeats itself.
     */
    columnPinnable: string;
    /**
     * Hideable (CSV).
     *
     * Display the show/hide options. A list of boolean values: 'true', 'false'. The last value repeats itself.
     */
    columnHideable: string;
    /**
     * Filterable (CSV).
     *
     * Display the filter options. A list of boolean values: 'true', 'false'. The last value repeats itself.
     */
    columnFilterable: string;
    /**
     * When exporting to excel, flag use the filtered and sorted version or the orignal table
     */
    exportOriginalTable: boolean;
}

export declare interface BaseTidyColumnCellDecoration {
    /**
     * If true, the renderer handles errors in the cells. If false, the table/pivot table renders an error if the cell
     * has one.
     *
     * Use `column.getError(tidyRow)` to get the error of a cell.
     */
    handlesCellsOnError?: boolean;
    /**
     * Default (i.e., when not defined) is true.
     */
    handlesBackgroundColor?: boolean;
    /**
     * A function that determines if the renderer is applied to a cell. Return true if yes, return false if not.
     * @param rowIdx row index.
     */
    appliesToCell?: (rowIdx: number) => boolean;
    /**
     * If an object is returned the underlying code uses emotion CSS function to convert to a className,
     * so you can do className like CSS :
     *
     * ```TypeScript
     * {
     *      fontSize: "0.7rem",
     *      ':hover': {
     *        fontSize: "1.4rem",
     *      }
     * }
     * ```
     */
    cssStyles?: (rowIdx: number) => Record<string, any> | undefined;
}

export declare enum CategoryAxisRotateLabels {
    YES = "YES",
    NO = "NO"
}

export declare const CharacterTidyColumnProperties: Set<string>;

/**
 * Defines a mapping that maps columns to the coordinate system of the widget.
 * The key represents the internal lowercase-name for the mapping, e.g., axis, group, rows, columns.
 * Note that a mapping can have multiple columns, for example, on the Rows.
 */
export declare type ChartTemplateDataMapping = Record<string, ITidyColumn[] | undefined>;

export declare interface ClearSelectionAllWidgetsNotification extends IAppNotification {
    readonly type: "clear-selection-all-widgets";
}

declare class CodeMirrorClasses {
    static readonly root: string;
}

declare type CodeMirrorClassesKey = keyof CodeMirrorClasses;

export declare type CodeMirrorMode = "plain" | "mdx" | "sql" | "js" | "json" | "csv" | "md" | FormFieldTidyTableExprType;

export declare enum CompareTextInterpretationType {
    MORE = "more=better",
    LESS = "less=better",
    NONE = "none"
}

/**
 * @see FormFieldDef
 */
export declare enum ConditionalRuleOperators {
    EQUALS = "EQUALS",
    NOT_EQUALS = "NOT_EQUALS",
    GREATER_THAN = "GREATER_THAN",
    GREATER_EQUAL_THAN = "GREATER_EQUAL_THAN",
    SMALLER_THAN = "SMALLER_THAN",
    SMALLER_EQUAL_THAN = "SMALLER_EQUAL_THAN",
    CONTAINS = "CONTAINS",
    NOT_CONTAINS = "NOT_CONTAINS",
    STARTS_WITH = "STARTS_WITH",
    ENDS_WITH = "ENDS_WITH"
}

export declare interface ConvertToTypeParseSettings {
    locale?: string;
    dateFormat?: string;
    listSeparator?: string;
}

declare type CSSProperties = any;

/**
 * Date Picker Options (fields of the "Chart" tab in the widget editor).
 *
 * <pre>
 *      Plugin ID         : ic3
 *      Widget/Template ID: DatePicker
 * </pre>
 *
 * @see WidgetTemplateChartOptions
 */
export declare interface DatePickerChartOptions extends FormFieldObject {
    /**
     * Variant.
     *
     * Allows for selecting a set of preset options. Note that a variant is possibly overriding defined options.
     */
    variant?: string;
    /**
     * The label content (i.e Date)
     */
    label?: string;
    /**
     * Helper Text.
     *
     * A text below the date picker to help the user when entering the date
     */
    dateHelperText?: string;
    /**
     * Input Date Format.
     *
     * The input date format
     */
    dateFormat: string;
    /**
     * Initial Date.
     *
     * The initial date. If not defined, the value on the third data row. A 'today' expression can be used:
     * today (+|-) n (d|w|m|y). E.g., today -1w means today minus one week.
     */
    initialDate?: string;
    /**
     * Min. Date.
     *
     * The first valid date. If not defined, the value of the first data row.
     * A 'today' expression can be used: today (+|-) n (d|w|m|y). E.g., today -1w means today minus one week.
     */
    minDate?: string;
    /**
     * Max. Date.
     *
     * The last valid date. If not defined, the value of the second data row.
     * A 'today' expression can be used: today (+|-) n (d|w|m|y). E.g., today -1w means today minus one week.
     */
    maxDate?: string;
    /**
     * Empty Behavior.
     *
     * Controls what to do if the date picker is empty.
     */
    emptyBehaviour: SelectionBehaviour;
    /**
     * Date Caption.
     *
     * The caption of the fired event.
     * For example, dd => 22, MM => 02, MMM => Jan, MMMM => January, yyyy => 2025, EEEE => Monday.
     */
    dateToCaption: string;
    /**
     * Date Unique Name.
     *
     * The value/unique-name of the fired event. The following variables are available: `HierarchyUName`,
     * `LevelUName`, `anyValidFormatString` (note the back ticks).
     */
    dateToUniqueName: string;
    /**
     * Range Picker.
     */
    rangePicker: boolean;
    /**
     * Range Picker: Initial End Date.
     *
     * The initial end date. If not defined, the value of the fourth data row. A 'today' expression can be used:
     * today (+|-) n (d|w|m|y). E.g., today -1w means today minus one week.
     */
    initialEndDate?: string;
    /**
     * The label content for the end date
     */
    endLabel?: string;
    /**
     * Range Picker: Center Text.
     *
     * The text being displayed between the two dates.
     */
    centerText?: string;
    /**
     * Range Picker: Range Caption.
     *
     * The caption of the fired event. The following variables are available: `startUName`, `startCaption`,
     * `endUName`, `endCaption` (note the back ticks).
     */
    rangeToCaption: string;
    /**
     * Range Picker: Range Unique Name.
     *
     * The value/unique-name of the fired event. The following variables are available: `startUName`,
     * `startCaption`, `endUName`, `endCaption` (note the back ticks).
     */
    rangeToUniqueName: string;
    /**
     * The direction of the Picker, horizontal/vertical/auto
     *
     * "auto" will choose the direction depending on the ration width/height > 0.9
     */
    rangeDirection: DatePickerRangeDirection;
    /**
     * Dates.
     *
     * The column of the tidy table containing the dates to display.
     */
    dates?: TidyTableColumnSelector;
    /**
     * Shortcuts
     */
    shortcutsEnabled: boolean;
    /**
     *
     */
    shortcutsAnchorDate?: string;
    /**
     * From where to source the initial date.
     */
    initialDateFrom: InitialDateFrom;
    /**
     * Source the initial date/range from this shortcut.
     */
    initialShortcut?: string;
    /**
     * User can choose from the shortcuts in this group. Edit the groups in the theme plugin.
     */
    allowedShortcutGroup: string;
}

export declare class DatePickerClasses {
    /**
     * Style applied to the root element.
     */
    static readonly root = "ic3DatePicker-root";
    /**
     * Fix div inside the root.
     */
    static readonly container = "ic3DatePicker-container";
    static readonly rowDirection = "ic3DatePicker-row-direction";
    static readonly columnDirection = "ic3DatePicker-column-direction";
    /**
     * + Mui DatePicker and/or DateRangePicker classes
     */
    static readonly fieldSeparator = "ic3DatePicker-fieldSeparator";
    /**
     * Label showing the selected shortcut. Clicking this label opens the shortcut menu.
     */
    static readonly shortcutLabel = "ic3DatePicker-shortcutLabel";
}

export declare type DatePickerClassKey = keyof DatePickerClasses;

export declare enum DatePickerRangeDirection {
    auto = "AUTO",
    horizontal = "HORIZONTAL",
    vertical = "VERTICAL"
}

export declare type DatePickerShortcut<T = any> = IShortcut<T, T | null>;

export declare type DateRangePickerShortcut<T = any> = IShortcut<T, [T | null, T | null]>;

declare type DateType = any;

declare type DeepPartial<T> = {
    [P in keyof T]?: T[P] extends Record<string, unknown> ? DeepPartial<T[P]> : T[P];
};

export declare enum DrawSeriesOnAxis {
    LEFT = "left",
    RIGHT = "right"
}

/**
 * Embedded Report Options (fields of the "Chart" tab in the widget editor).
 *
 * <pre>
 *      Plugin ID         : ic3
 *      Widget/Template ID: EmbeddedReport
 * </pre>
 *
 * @see WidgetTemplateChartOptions
 */
export declare interface EmbeddedReportChartOptions extends FormFieldObject {
    /**
     * Dashboard Name.
     *
     * You can use an event (e.g., @{dashboard-path}).
     */
    "$-MDX-reportName": string;
    /**
     * Events (from/to).
     *
     * Forwarded events.
     */
    "@params"?: IFormEventMappingArrayFieldDefType;
    "@eventsOut"?: IFormEventMappingArrayFieldDefType;
    /**
     * How to export the embedded report to excel.
     */
    exportToExcelMethod: ExportToExcelMethod;
    inheritSchemaName: boolean;
    inheritCubeName: boolean;
    inheritDisableDefaultSchemaAuthCheck: boolean;
}

export declare enum EmbeddedThemeNames {
    Statos = "ic3-statos"
}

export declare const emptySet = "\u2205";

export declare interface EntityItem {
    uniqueName: string;
    key?: any;
    name: string;
    caption: string;
    parentUN?: string;
    hierUN?: string;
    selected?: boolean;
    empty?: boolean;
    tupleUNames?: string[];
}

export declare class ErrorRendererClasses {
    /**
     * Style applied to
     */
    static root: string;
    /**
     * Style applied to
     */
    static logo: string;
    /**
     * Style applied to
     */
    static logoW: string;
    /**
     * Style applied to
     */
    static info: string;
    /**
     * Style applied to
     */
    static schemaNotAuth: string;
    /**
     * Style applied to
     */
    static message: string;
    /**
     * Style applied to
     */
    static detailToggle: string;
    /**
     * Style applied to
     */
    static widget: string;
    /**
     * Style applied to
     */
    static causeMessage: string;
    /**
     * Style applied to
     */
    static causeDetailedMessage: string;
    /**
     * Style applied to
     */
    static causeDetailedInfo: string;
    /**
     * Style applied to
     */
    static causeStacktrace: string;
}

export declare type ErrorRendererClassKey = keyof ErrorRendererClasses;

export declare enum ExportToExcelMethod {
    SHEET_PER_WIDGET = "SHEET_PER_WIDGET",
    ONE_TABLE = "ONE_TABLE"
}

/**
 * Filter Autocomplete (aka. Dropdown) Options (fields of the "Chart" tab in the widget editor).
 *
 * <pre>
 *      Plugin ID         : ic3
 *      Widget/Template ID: FilterAutocomplete
 * </pre>
 *
 * @see WidgetTemplateChartOptions
 */
export declare interface FilterAutocompleteChartOptions extends FilterTidyTableChartOptions {
    /**
     * Variant.
     *
     * Allows for selecting a set of preset options. Note that a variant is possibly overriding defined options.
     */
    variant?: "fixedHeight" | "standard" | "filled" | "outlined";
    /**
     * Size.
     *
     * Rendered items size.
     */
    size: "small" | "medium";
    /**
     * Limit Chips.
     *
     * Maximum number of chips that will be visible
     */
    limitChips: number;
    /**
     * Maximum items that allowed in the selection.
     */
    limitSelection?: number;
    /**
     * Text to show when the filter is empty.
     */
    placeholderText?: string;
}

export declare class FilterAutocompleteClasses {
    /**
     * Style applied to the muiAutocomplete root element
     *
     * You've all mui classes https://mui.com/material-ui/api/autocomplete/
     */
    static readonly muiAutocomplete = "MuiAutocomplete-root";
    static readonly action = "MuiAutocomplete-action";
}

export declare type FilterAutocompleteClassesKey = keyof FilterAutocompleteClasses;

export declare type FilterAutocompleteProps = Pick<FilterAutocompleteChartOptions, 'variant' | 'size'> & {
    hideInput?: boolean;
} & {
    addHOverflow: boolean;
} & {
    hideInputForPrinting?: boolean;
} & {
    hideAdornmentForPrinting?: boolean;
};

/**
 * Filter Buttons Options (fields of the "Chart" tab in the widget editor).
 *
 * <pre>
 *      Plugin ID         : ic3
 *      Widget/Template ID: FilterButtons
 * </pre>
 *
 * @see WidgetTemplateChartOptions
 */
export declare interface FilterButtonsChartOptions extends FilterTidyTableChartOptions {
    /**
     * Variant.
     *
     * Allows for selecting a set of preset options. Note that a variant is possibly overriding defined options.
     */
    variant: "text" | "outlined" | "contained" | string;
    /**
     * Size.
     */
    size: "small" | "medium" | "large";
    /**
     * Grouped.
     *
     * When grouped, the buttons are rendered horizontally or vertically similarly to a toolbar.
     */
    group?: boolean;
    /**
     * Layout (Grouped).
     */
    layout?: "horizontal" | "vertical";
    /**
     * Grid Column Count
     *
     * The buttons will be displayed on a grid. This field sets the number of columns of the grid.
     * Not relevant if the buttons are 'Grouped'.
     */
    columns?: number;
}

export declare class FilterButtonsClasses {
    /**
     * Style applied to the root element.
     */
    static readonly container = "ic3FilterButtons-container";
    /**
     *  Style applied to the mui button elements.
     */
    static readonly button = "ic3FilterSlider-button";
    /**
     *  Style applied to the mui group element (if present).
     */
    static readonly group = "ic3FilterSlider-group";
    /**
     * Slot for MuiButton component(s)
     */
    static readonly muiButton = "";
}

export declare type FilterButtonsClassKey = keyof FilterButtonsClasses;

/**
 * Props for the FilterButtons Container slot.
 */
export declare interface FilterButtonsContainerProps {
    columns?: number;
}

/**
 * Props for the FilterButtons root slot.
 */
export declare interface FilterButtonsProps {
    printing: boolean;
    variant?: string;
    grouped: boolean;
    columns?: number;
}

export declare interface FilterCheckboxProps {
    variant?: string;
    printing: boolean;
}

/**
 * Filter Checkboxes Options (fields of the "Chart" tab in the widget editor).
 *
 * <pre>
 *      Plugin ID         : ic3
 *      Widget/Template ID: FilterCheckboxRadio
 * </pre>
 *
 * @see WidgetTemplateChartOptions
 */
export declare interface FilterCheckboxRadioChartOptions extends FilterTidyTableChartOptions {
    /**
     * Variant.
     *
     * Allows for selecting a set of theme defined variants
     */
    variant?: string;
    /**
     * Size.
     */
    size: "small" | "medium";
    /**
     * Grid Column Count.
     *
     * The checkboxes will be displayed on a grid. Set the number of columns of the grid in this field.
     */
    columns?: number;
}

export declare class FilterCheckBoxRadioClasses {
    /**
     * Style applied to the root element.
     */
    static readonly root = "ic3FilterCheckboxRadio-root";
    /**
     *  Style container for a single Radio or Checkbox
     */
    static readonly radioCheckBoxContainer = "ic3FilterCheckboxRadio-container";
    /**
     *  root element class decoration when the items are radio components  (single selection)
     */
    static readonly radioFlag = "ic3FilterCheckboxRadio-Radio";
    /**
     *  root element class decoration when the items are checkbox components (multiple selection)
     */
    static readonly checkboxFlag = "ic3FilterCheckboxRadio-Checkbox";
}

export declare type FilterCheckboxRadioClassKey = keyof FilterCheckBoxRadioClasses;

export declare interface FilterDatePickerProps {
    /**
     * Variant defined in the theme. If the theme has variants, then the user can select one.
     */
    variant?: string;
}

export declare type FilterFireEventMode = TreeFireEventMode.ALL_SELECTED | TreeFireEventMode.COMPACT_ON_PARENT;

/**
 * Filter Panel Options (fields of the "Chart" tab in the widget editor).
 *
 * <pre>
 *      Plugin ID         : ic3
 *      Widget/Template ID: FilterPanel
 * </pre>
 *
 * @see WidgetTemplateChartOptions
 */
export declare interface FilterPanelChartOptions extends FormFieldObject {
    /**
     * Variant.
     *
     * Allows for selecting a set of preset options. Note that a variant is possibly overriding defined options.
     */
    variant?: string;
    /**
     * As Global Filter.
     *
     * In the widget interaction tab, enable 'Use Global Filter' to see the effects of this option.
     *
     * Default value can NOT be changed in a theme or variant
     */
    asGlobalFilter: boolean;
    /**
     * Schema Name.
     *
     * Using the schema defined at dashboard level when not defined.
     */
    schemaName?: string;
    /**
     * Cube Name.
     *
     * The cube to use. Leave blank to use the default cube.
     */
    cubeName?: string;
    /**
     * Allowed Filters.
     *
     * Only show these options in the data field selector.
     * Easily change by clicking 'Set Allowed Filters' in the user menu of the widget header.
     */
    customFilterConfig?: string;
    /**
     * These filters are not allowed to be selected by the user. These filters are hidden from the add filter menu.
     */
    notAllowedFiltersConfig?: string;
    /**
     * Default Filters.
     *
     * These filters are in the filter panel upon opening the dashboard.
     * Easily change by clicking 'Set Default Filters' in the user menu of the widget header.
     */
    initialFilterConfig?: string;
    /**
     * Allow users to save and load filters. Filters are stored in the users' browser.
     */
    enableViews?: boolean;
    /**
     * Max number of views a user can have. Empty means unlimited.
     */
    maxNumberOfViews?: number;
    /**
     * If true, grow filter in row direction. If false, grow in column direction.
     */
    filterLayoutHorizontal?: boolean;
    /**
     * If defined, the filter panel only shows items where this measure is not NULL. This means, for example, that
     * if there is a filter item setting Continent to Asia, then other filters, e.g., country, only show countries
     * with continent Asia.
     */
    measureMdx?: string;
    /**
     * Name template for the fields with properties. Use 'levelName' and 'propertyName' as placeholders.
     */
    propertyFieldNameTemplate?: string;
    /**
     * Use the simple selection filter if and only if `useSimpleFilterCutoff` is not null and the level
     * has <= `useSimpleFilterCutoff` members.
     */
    useSimpleFilterCutoff?: number;
    /**
     * Per default, the filter panel allows users to filter on properties. You can disable that with this option.
     */
    hidePropertyFilters?: boolean;
    /**
     * Only allow users to select from these operators.
     */
    allowedOperatorsConfig?: IPGFilterItemFilterType[];
    /**
     * Set to `true` to show date picker shortcuts.
     */
    datePickerShortcuts?: boolean;
    /**
     * Anchor date when using shortcuts. This expression is evaluated against the time level used.
     */
    shortcutsAnchorDate?: string;
    /**
     * User can choose from the shortcuts in this group. Edit the groups in the theme plugin.
     */
    allowedShortcutGroup: string;
    /**
     * Add these filters to the filter panel queries.
     */
    eventFilters?: IFormEventArrayFieldDefType;
}

export declare class FilterPanelClasses {
    /**
     * Main content div
     */
    static readonly mainDiv = "ic3FilterPanel-root";
    /**
     * Div containing the loading spinner and text
     */
    static readonly loadingDiv = "ic3FilterPanel-loading";
    /**
     * Div with add filter and remove all filters buttons
     */
    static readonly headerDiv = "ic3FilterPanel-header";
    /**
     * Div containing the 'Filters' text and the help icon button
     */
    static readonly titleDiv = "ic3FilterPanel-title";
    /**
     * Div containing the 'Filters' text
     */
    static readonly titleDivText = "ic3FilterPanel-title-text";
    /**
     * The help button next to the filter panel title
     */
    static readonly titleDivButtons = "ic3FilterPanel-title-buttons";
    /**
     * Icon to make the filter panel collapsed (only available on App Left Panel)
     */
    static readonly collapsibleIcon = "ic3FilterPanel-collapsibleIcon";
    /**
     * Icon showing how many filters you have
     */
    static readonly collapsedNumberOfFiltersIcon = "ic3FilterPanel-collapsedNumberOfFiltersIcon";
    /**
     * Help icon
     */
    static readonly helpIcon = "ic3FilterPanel-helpIcon";
    /**
     * Menu icon for filter panel views.
     */
    static readonly menuIcon = "ic3FilterPanel-menuIcon";
    /**
     * Div containing the add and remove all buttons
     */
    static readonly headerDivButtons = "ic3FilterPanel-header-buttons";
    /**
     * alert
     */
    static readonly alert = "ic3FilterPanel-alert";
    /**
     * Add button
     */
    static readonly headerDivAddButton = "ic3FilterPanel-HeaderDivAddButton";
    /**
     * Reset filter button
     */
    static readonly headerDivResetButton = "ic3FilterPanel-HeaderDivResetButton";
    /**
     * Div of the content root. Used for animation purposes.
     */
    static readonly contentDivRoot = "ic3FilterPanel-content-root";
    /**
     * Div with the stack of filter items
     */
    static readonly contentDiv = "ic3FilterPanel-content";
    /**
     * Div with no filters defined text
     */
    static readonly contentNoFilters = "ic3FilterPanel-NoFilters";
    /**
     * Main filter div
     */
    static readonly filterItemDiv = "ic3FilterPanel-filterItem";
    /**
     * Main filter div
     */
    static readonly filterItemDivHeader = "ic3FilterPanel-filterItemHeader";
    /**
     * Div around the filter clear button. Used for showing the tooltip when hovered.
     */
    static readonly filterItemClearButtonContainer = "ic3FilterPanel-ItemClearButtonContainer";
    /**
     * Class for the clear button itself.
     */
    static readonly filterItemClearButton = "ic3FilterPanel-ItemClearButton";
    static readonly filterItemRemoveButton = "ic3FilterPanel-ItemRemoveButton";
    /**
     * Classname for the TextField component
     */
    static readonly inputField = "ic3FilterPanel-filterInputfield";
    /**
     * Classname for the checkmark 'set' button.
     */
    static readonly inputFieldSetValueButton = "ic3FilterPanel-inputFieldSetValueButton";
    static readonly dateTimePicker = "ic3FilterPanel-dateTimePicker";
    /**
     * Classname for the value selector div.
     */
    static readonly valueSelector = "ic3FilterPanel-valueSelector";
    /**
     * A div with the displayed values for the value selector in preview mode. Only visible when the operator is
     * `Is Any Of` or `Is None Of`.
     */
    static readonly inputFieldPreviewValues = "ic3FilterPanel-PreviewValue";
    /**
     * Classname for the field label
     */
    static readonly fieldName = "ic3FilterPanel-fieldName";
    /**

     * Classname for the field label
     */
    static readonly fieldNameExtra = "ic3FilterPanel-fieldName-extra";
    /**
     * Div with selectable items for filters with few items
     */
    static readonly selectableContent = "ic3FilterPanel-selectableContent";
    /**
     * Div when it is collapsed
     */
    static readonly collapsedDiv = "ic3FilterPanel-collapsedDiv";
}

export declare type FilterPanelClassesKey = keyof FilterPanelClasses;

export declare interface FilterPanelProps {
    /**
     * Variant defined in the theme. If the theme has variants, then the user can select one.
     */
    variant?: string;
    /**
     * If true, grow filter in row direction. If false, grow in column direction.
     */
    filterLayoutHorizontal?: boolean;
    /**
     * Available when the filter panel is used in an application.
     * User can collapse the filter panel.
     */
    isCollapsible?: boolean;
    /**
     * Available when the filter panel is used in an application.
     * The filter panel is on the right of the application.
     */
    isRightFilterPanel?: boolean;
}

export declare class FilterPanelViewsMenuClasses {
    static readonly save = "ic3FilterPanelViewsMenu-save";
    static readonly view = "ic3FilterPanelViewsMenu-view";
    static readonly maxViewsReachedText = "ic3FilterPanelViewsMenu-maxViewsReachedText";
    static readonly viewsText = "ic3FilterPanelViewsMenu-viewsText";
    static readonly errorText = "ic3FilterPanelViewsMenu-errorText";
}

export declare type FilterPanelViewsMenuClassesKey = keyof FilterPanelViewsMenuClasses;

/**
 * Filter Slider Options (fields of the "Chart" tab in the widget editor).
 *
 * <pre>
 *      Plugin ID         : ic3
 *      Widget/Template ID: FilterSlider
 * </pre>
 *
 * @see WidgetTemplateChartOptions
 */
export declare interface FilterSliderChartOptions extends FilterTidyTableChartOptions {
    /**
     * Variant.
     *
     * Allows for selecting a set of preset options. Note that a variant is possibly overriding defined options.
     */
    variant?: string;
    /**
     * Size.
     */
    size: "small" | "medium";
    /**
     * Orientation.
     */
    orientation: "horizontal" | "vertical";
    /**
     * Style.
     */
    style: FilterSliderRenderingType;
    /**
     * Margins.
     *
     * Left/right (or top/down) margins of the slider.
     */
    margin: number;
    /**
     * Mark Each
     *
     * When active, adds a label for each nt step to the mark (1 for each step)
     */
    markLabelEach: number;
    /**
     * Selection Label.
     *
     * An optional label under the slider with selection information
     */
    selectionLabel?: string;
}

export declare class FilterSliderClasses {
    /**
     * Style applied to the root element.
     */
    static readonly root = "ic3FilterSlider-root";
    /**
     *  Style applied to the mui slider element.
     */
    static readonly slider = "ic3FilterSlider-slider";
    /**
     *  Style applied to the tooltip element.
     */
    static readonly tooltip = "ic3FilterSlider-tooltip";
    /**
     * Slot for MuiSlider component
     */
    static readonly muiSlider = "";
    /**
     * Slot for Selection Label (below the slider)
     */
    static readonly selectionLabel = "ic3FilterSlider-SelectionLabel";
    static readonly emptySelection = "ic3FilterSlider-EmptySelection";
    /**
     * root modifiers for horizontal or vertical slider
     */
    static readonly horizontal = "ic3FilterSlider-Horizontal";
    static readonly vertical = "ic3FilterSlider-Vertical";
}

export declare type FilterSliderClassKey = keyof FilterSliderClasses;

export declare interface FilterSliderProps {
    variant?: string;
    thumbColor?: string;
    emptySelection: boolean;
    isVertical?: boolean;
    size?: 'small' | 'medium';
    padding: number;
}

export declare enum FilterSliderRenderingType {
    MARKS = "MARKS",
    TOOLTIPS = "TOOLTIPS",
    MARKS_WITH_TOOLTIPS = "MARKS_WITH_TOOLTIPS",
    NONE = "NONE"
}

/**
 * Filter Switch Options (fields of the "Chart" tab in the widget editor).
 *
 * <pre>
 *      Plugin ID         : ic3
 *      Widget/Template ID: FilterSwitch
 * </pre>
 *
 * @see WidgetTemplateChartOptions
 */
declare interface FilterSwitchChartOptions extends FilterTidyTableChartOptions {
    /**
     * Variant.
     *
     * Allows for selecting a set of preset options. Note that a variant is possibly overriding defined options.
     */
    variant?: string;
    /**
     * Text to show on the right of the switch.
     */
    labelRight: string;
    /**
     * Text to show on the left of the switch.
     */
    labelLeft: string;
}

declare class FilterSwitchClasses {
    /**
     * Style applied to the root element.
     */
    static readonly root = "ic3SwitchFilter-root";
    /**
     * Added class when switch has two options.
     */
    static readonly twoOptions = "ic3SwitchFilter-twoOptions";
}

declare type FilterSwitchClassKey = keyof FilterSwitchClasses;

declare interface FilterSwitchProps {
    variant?: string;
}

declare interface FilterTidyTableChartOptions extends FormFieldObject {
    /**
     * Items.
     *
     * The column defining the members used as items of the filter (default: first axis).
     */
    items: TidyTableColumnSelector;
    /**
     * Active.
     *
     * An item cannot be selected if the corresponding cell in this column evaluates to false.
     */
    itemActive?: TidyTableColumnSelector;
    /**
     * Color.
     *
     * Color of filter items.
     */
    color?: TidyTableColumnSelector;
    /**
     * Selection Color.
     *
     * The color of the item when it is selected. Leave blank to use the theme default.
     */
    colorActive?: TidyTableColumnSelector;
}

/**
 * Filter Tree Options (fields of the "Chart" tab in the widget editor).
 *
 * <pre>
 *      Plugin ID         : ic3
 *      Widget/Template ID: FilterTree
 * </pre>
 *
 * @see WidgetTemplateChartOptions
 */
export declare interface FilterTreeChartOptions extends FilterTidyTableChartOptions {
    /**
     * Variant.
     *
     * Allows for selecting a set of preset options. Note that a variant is possibly overriding defined options.
     */
    variant?: string;
    /**
     * Size.
     */
    size: "small" | "medium";
    /**
     * Use Control Icons.
     *
     * Display a checkbox/radiobutton to the left of each item.
     */
    useControlIcons?: boolean;
    /**
     * Expand/Collapse Depth.
     *
     * Number of levels initially expanded.
     */
    startOpenDepth: number;
    /**
     * Cascade Selection.
     *
     * Select all children as well. Does not apply if single selection.
     */
    cascadeSelection: boolean;
    /**
     * Fire Mode.
     *
     * When firing an event, do not fire children if the parent is selected (i.e. the filter is used as an MDX filter).
     *
     * Does not apply if single selection.
     */
    fireMode: FilterFireEventMode;
    /**
     * Add Search.
     *
     * Add a search bar above the tree.
     */
    addSearch: boolean;
    /**
     * Search Placeholder.
     *
     * Text displayed when the search bar is empty.
     */
    searchPlaceholder?: string;
    /**
     * Dropdown (aka. Autocomplete).
     *
     * The tree is displayed as a dropdown.
     */
    autoComplete: boolean;
    /**
     * Variant.
     */
    autoCompleteVariant?: string;
    /**
     * Size (Dropdown/Autocomplete).
     *
     * Rendered items size.
     */
    autoCompleteSize?: 'small' | 'medium';
    /**
     * Limit Chips.
     *
     * Maximum number of chips that will be visible
     */
    autoCompleteLimitChips: number;
}

export declare class FilterTreeClasses extends LazyTreeClasses {
    /**
     * Style applied to the root element.
     */
    static readonly root = "ic3TreeFilter-root";
    /**
     *  Style applied to the tree item without control icons
     */
    static readonly simpleItemLabel = "ic3TreeFilter-simpleItemLabel";
    /**
     *  Style applied to the tree item witht control icons
     */
    static readonly itemLabelWithIcons = "ic3TreeFilter-itemLabelWithIcons";
}

export declare type FilterTreeClassKey = keyof FilterTreeClasses;

export declare class FilterTreePopOverClasses {
}

export declare type FilterTreePopOverClassKey = keyof FilterTreePopOverClasses;

export declare interface FilterTreePopOverProps {
    variant?: string;
}

export declare interface FilterTreeProps {
    printing: boolean;
    variant?: string;
    size: 'small' | 'medium';
}

/**
 * Top parent node = the node that is a direct child of root and of which node is a descendant.
 */
export declare type ForEachNodeCallbackFn<T> = (node: TidyTreeNode, levelDepth: number, parent: TidyTreeNode, nodeChildrenIdx: number, parentSummary?: T) => boolean | void;

export declare type FormFieldDef = IFormAutocompleteFieldDef<any> | IFormBooleanFieldDef | IFormColorEditorFieldDef | IFormColumnChooserFieldDef | IFormColumnSelectionFieldDef | IFormConstantsFieldDef | IFormEventArrayFieldDef | IFormEventMappingArrayFieldDef | IFormFileUploaderFieldDef | IFormGroupsFieldDef | IFormJsFieldDef | IFormMarkdownFieldDef | IFormMaskFieldDef | IFormMdxFieldDef | IFormNumberFieldDef | IFormOptionFieldDef | IFormOptionFieldSingleDef | IFormOptionFieldMultipleDef | IFormPaletteEditorFieldDef | IFormReportPathFieldDef | IFormReportPermaLinkFieldDef | IFormStringFieldDef | IFormTidyTableHtmlExprFieldDef | IFormTidyTableHtmlRowExprFieldDef | IFormTidyTableNumericExprFieldDef | IFormTidyTableNumericRowExprFieldDef | IFormTidyTableStringRowExprFieldDef | IFormTidyTableColorRowExprFieldDef | IFormTidyTableScaleRowExprFieldDef | IFormTidyTableTextExprFieldDef | IFormTidyTableTextRowExprFieldDef | IFormWidgetVariantFieldDef | IFormFormatterPickerFieldDef | IFormGranularitySelectionFieldDef | IFormSearchAndReplaceArrayFieldDef | IFormPropertyChooserBaseDef | IFormLayoutFieldDef | IFormConditionalColorRulesFieldDef | IFormFilterPanelModelSelectorFieldDef | IFormShortcutChooserDef<any> | IFormIconFieldSingleDef;

export declare type FormFieldDialogEditorModelType = "unknown" | "markdown" | "mdxExpression" | FormFieldTidyTableExprType;

export declare function formFieldIsSelection(field: IFormFieldDef<any>): boolean;

/**
 * The options (possibly edited and/or from the theme) of a widget.
 *
 * Aka Props
 */
export declare interface FormFieldObject {
    readonly '0242ac130003': '0242ac130003';
}

export declare type FormFields<T extends FormFieldObject> = {
    [key in keyof Omit<T, '0242ac130003'>]-?: // make the key mandatory even though the field is optional
    (Required<T>[key] extends FormFieldObject ? {
        defaultValue?: any;
    } : undefined extends NonNullable<T>[key] ? {
        defaultValue?: any;
    } : {
        defaultValue: unknown;
    } | {
        mandatory: true;
    }) & (Required<T>[key] extends FormFieldObject ? unknown : {
        defaultValue?: any;
        mandatory?: true;
    } | {
        defaultValue?: any;
        mandatory?: false;
    }) & (Required<T>[key] extends FormFieldObject ? Omit<IFormEmbeddedFieldDef<Required<T>[key]>, 'fieldPath'> : Required<T>[key] extends IPaletteDef ? Omit<IFormPaletteEditorFieldDef, 'fieldPath'> : Required<T>[key] extends IFormConditionalColorRule[] ? Omit<IFormConditionalColorRulesFieldDef, 'fieldPath'> : Required<T>[key] extends IColorDef ? Omit<IFormColorEditorFieldDef, 'fieldPath'> : Required<T>[key] extends TidyTableColumnSelector[] ? Omit<IFormColumnChooserMultipleFieldDef, 'fieldPath'> : Required<T>[key] extends TidyTableColumnSelector ? Omit<IFormColumnChooserSingleFieldDef, 'fieldPath'> : Required<T>[key] extends IFormEventMappingArrayFieldDefType ? Omit<IFormEventMappingArrayFieldDef, 'fieldPath'> : Required<T>[key] extends IFormEventArrayFieldDefType ? Omit<IFormEventArrayFieldDef, 'fieldPath'> : Required<T>[key] extends IFormSearchAndReplaceArrayFieldDefType ? Omit<IFormSearchAndReplaceArrayFieldDef, 'fieldPath'> : Required<T>[key] extends Hook<any, any> ? Omit<IFormHookFieldDef<any>, 'fieldPath'> : Required<T>[key] extends boolean ? Omit<IFormBooleanFieldDef, 'fieldPath'> : Required<T>[key] extends number ? Omit<IFormNumberFieldDef, 'fieldPath'> : Required<T>[key] extends number ? Omit<IFormMaskFieldDef, 'fieldPath'> : Required<T>[key] extends string ? Omit<IFormOptionFieldSingleDef, 'fieldPath'> | Omit<IFormStringFieldDef, 'fieldPath'> | Omit<IFormFormatterPickerFieldDef, 'fieldPath'> | Omit<IFormWidgetVariantFieldDef, 'fieldPath'> | Omit<IFormTidyTableTextExprFieldDef, 'fieldPath'> | Omit<IFormTidyTableTextRowExprFieldDef, 'fieldPath'> | Omit<IFormTidyTableNumericStringColumnExprFieldDef, 'fieldPath'> | Omit<IFormTidyTableHtmlRowExprFieldDef, 'fieldPath'> | Omit<IFormTidyTableHtmlExprFieldDef, 'fieldPath'> | Omit<IFormTidyTableNumericExprFieldDef, 'fieldPath'> | Omit<IFormTidyTableNumericRowExprFieldDef, 'fieldPath'> | Omit<IFormTidyTableNumericJSColumnExprFieldDef, 'fieldPath'> | Omit<IFormTidyTableColorRowExprFieldDef, 'fieldPath'> | Omit<IFormTidyTableStringRowExprFieldDef, 'fieldPath'> | Omit<IFormTidyTableScaleRowExprFieldDef, 'fieldPath'> | Omit<IFormJsFieldDef, 'fieldPath'> | Omit<IFormJsonFieldDef, 'fieldPath'> | Omit<IFormMarkdownFieldDef, 'fieldPath'> | Omit<IFormOptionFieldReportPathDef, 'fieldPath'> | Omit<IFormPropertyChooserBaseDef, 'fieldPath'> | Omit<IFormLayoutFieldDef, 'fieldPath'> | Omit<IFormLayoutFieldDef, 'fieldPath'> | Omit<IFormFilterPanelModelSelectorFieldDef, 'fieldPath'> | Omit<IFormShortcutChooserDef<string>, 'fieldPath'> | Omit<IFormIconFieldSingleDef, 'fieldPath'> : Required<T>[key] extends string[] ? Omit<IFormOptionFieldMultipleDef, 'fieldPath'> | Omit<IFormGroupsFieldDef, 'fieldPath'> | Omit<IFormShortcutChooserDef<string[]>, 'fieldPath'> : never);
};

export declare type FormFieldTidyTableExprType = 
/**
* @see IFormTidyTableColorRowExprFieldDef
*/
"tidyTableColorRowExpr" | 
/**
* @see IFormTidyTableHtmlExprFieldDef
*/
"tidyTableHtmlExpr" | 
/**
* @see IFormTidyTableHtmlRowExprFieldDef
*/
"tidyTableHtmlRowExpr" | 
/**
* @see IFormTidyTableNumericExprFieldDef
*/
"tidyTableNumericExpr" | 
/**
* @see IFormTidyTableNumericJSColumnExprFieldDef
*/
"tidyTableNumericJSColumnExpr" | 
/**
* @see IFormTidyTableNumericRowExprFieldDef
*/
"tidyTableNumericRowExpr" | 
/**
* @see IFormTidyTableNumericStringColumnExprFieldDef
*/
"tidyTableNumericStringColumnExpr" | 
/**
* @see IFormTidyTableScaleRowExprFieldDef
*/
"tidyTableScaleRowExpr" | 
/**
* @see IFormTidyTableTextExprFieldDef
*/
"tidyTableTextExpr" | 
/**
* @see IFormTidyTableTextRowExprFieldDef
*/
"tidyTableTextRowExpr" | 
/**
* @see IFormTidyTableStringRowExprFieldDef
*/
"tidyTableStringRowExpr";

export declare type FormFieldType = 
/**
* @see IFormReportPathFieldDef
*/
"appPath" | 
/**
* @see IFormAutocompleteFieldDef
*/
"autocomplete" | 
/**
* @see IFormBooleanFieldDef
*/
"boolean" | 
/**
* @see IFormColorEditorFieldDef
*/
"color" | 
/**
* @see IFormColumnChooserFieldDef
*/
"columnsChooser" | 
/**
* @see IFormColumnSelectionFieldDef
*/
"columnSelection" | 
/**
* @see IFormConstantsFieldDef
*/
"constants" | 
/**
* @see IFormArrayStringRecordsFieldDef
*/
"eventMappingArray" | "eventArray" | 
/**
* @see IFormEmbeddedFieldDef
*/
"embedded" | 
/**
* @see IFormFileUploaderFieldDef
*/
"fileUploader" | 
/**
* @see IFormFormatterPickerFieldDef
*/
"formatterPicker" | 
/**
* @see IFormBooleanFieldDef
*/
"fixedBoolean" | 
/**
* @see IFormBooleanFieldDef
*/
"groupBoolean" | 
/**
* @see IFormGroupsFieldDef
*/
"groups" | 
/**
* @see IFormFunctionFieldDef
*/
"hook" | 
/**
* @see IFormJsFieldDef
*/
"js" | 
/**
* @see IFormJsonFieldDef
*/
"json" | 
/**
* @see IFormMarkdownFieldDef
*/
"markdown" | 
/**
* @see IFormMaskFieldDef
*/
"mask" | 
/**
* @see IFormMdxFieldDef
*/
"mdxExpression" | 
/**
* @see IFormMuiVariantFieldDef
*/
"number" | 
/**
* @see IFormOptionFieldDef
*/
"option" | 
/**
* @see IFormColorEditorFieldDef
*/
"palette" | 
/**
* @see IFormReportPathFieldDef
*/
"reportFolder" | 
/**
* @see IFormReportPathFieldDef
*/
"reportPath" | 
/**
* @see IFormReportPermaLinkFieldDef
*/
"reportPermaLink" | 
/**
* @see IFormStringFieldDef
*/
"string" | 
/**
* @see IFormTextFieldDef
*/
"text" | FormFieldTidyTableExprType | 
/**
* @see IFormUrlFieldDef
*/
"url" | 
/**
* @see IFormWidgetVariantFieldDef
*/
"widgetVariant" | 
/**
* @see IFormGranularitySelectionFieldDef
*/
"granularityChooser" | 
/**
* @see IFormSearchAndReplaceArrayFieldDefType
*/
"searchAndReplaceArray" | 
/**
* @see IFormPropertyChooserBaseDef
*/
"propertyChooser" | 
/**
* @see IFormLayoutFieldDef
*/
"layout" | 
/**
* @see IFormConditionalColorRulesFieldDef
*/
"conditionalColorRules" | 
/**
* @see IFormFilterPanelModelSelectorFieldDef
*/
"filterPanelModelSelector" | 
/**
* @see IFormShortcutChooserDef
*/
"shortcutChooser" | 
/**
* @see IFormIconFieldSingleDef
*/
"icon";

declare type GenerateStringUnion<T> = Extract<{
    [Key in keyof T]: true extends T[Key] ? Key : never;
}[keyof T], string>;

/**
 * The corresponding AmCharts 4 chart class is MapChart.
 */
export declare type GeoMapChartOptions = Am4GeoSeriesOptions;

export declare enum GeoMapChartProjection {
    Albers = "Albers",
    AlbersUsa = "AlbersUsa",
    AzimuthalEqualArea = "AzimuthalEqualArea",
    Eckert6 = "Eckert6",
    EqualEarth = "EqualEarth",
    Projection = "Projection",
    Mercator = "Mercator",
    Miller = "Miller",
    NaturalEarth1 = "NaturalEarth1",
    Orthographic = "Orthographic",
    Stereographic = "Stereographic"
}

export declare enum GeoMapChartUnMatchedRegionStrategy {
    USE_DEFAULT_COLOR = "USE_DEFAULT_COLOR",
    EXCLUDE_FROM_MAP = "EXCLUDE_FROM_MAP"
}

/**
 * Image Options (fields of the "Chart" tab in the widget editor).
 *
 * google.maps.visualization.HeatmapLayerOptions
 *
 * <pre>
 *      Plugin ID         : ic3
 *      Widget/Template ID: GoogleHeatMap
 * </pre>
 *
 * @see WidgetTemplateChartOptions
 */
export declare interface GoogleHeatMapChartOptions extends GoogleMapCoordinateChartOptions, GoogleMapChartOptions {
    /**
     * Weight.
     *
     * Weight of the data points.
     */
    weight?: TidyTableColumnSelector;
    /**
     * Color Gradient.
     */
    colorGradient?: IPaletteDef;
    /**
     * Add Transparent Color.
     */
    addTransparentColor: boolean;
    /**
     * Dissipating.
     *
     * Specifies whether heatmaps dissipate on zoom. When dissipating is disabled the radius of influence increases
     * with zoom level to ensure that the color intensity is preserved at any given geographic location.
     */
    dissipating?: boolean;
    /**
     * Max Intensity.
     *
     * The maximum intensity of the heatmap. By default, heatmap colors are dynamically scaled according to
     * the greatest concentration of points at any particular pixel on the map. This property allows you to
     * specify a fixed maximum.
     */
    maxIntensity?: number;
    /**
     * Opacity.
     *
     * The opacity of the heatmap, expressed as a number between 0 and 1.
     */
    opacity: number;
    /**
     * Radius.
     *
     * The radius of influence for each data point, in pixels.
     */
    radius?: number;
}

/**
 * Google KML Map Options (fields of the "Chart" tab in the widget editor).
 *
 * google.maps.KmlLayerOptions
 *
 * <pre>
 *      Plugin ID         : ic3
 *      Widget/Template ID: GoogleKmlLayer
 * </pre>
 *
 * @see WidgetTemplateChartOptions
 */
export declare interface GoogleKmlLayerChartOptions extends GoogleMapChartOptions {
    /**
     * Preserve Viewport.
     *
     * By default, the input map is centered and zoomed to the bounding box of the contents of the layer.
     * If this option is set to true, the viewport is left unchanged, unless the map's center and zoom
     * were never set.
     */
    preserveViewport: boolean;
    /**
     * Screen Overlays.
     *
     * Whether to render the screen overlays.
     */
    screenOverlays: boolean;
    /**
     * Suppress Info Windows.
     *
     * Suppress the rendering of info windows when layer features are clicked.
     */
    suppressInfoWindows: boolean;
    /**
     * KML URL.
     */
    kmlUrl: TidyTableColumnSelector;
}

export declare interface GoogleMapChartOptions extends FormFieldObject {
    /**
     * Internal usage.
     */
    groupsOrder?: string[];
    mapOptions: GoogleMapCommonFieldProps;
}

/**
 * google.maps.MapOptions
 */
export declare interface GoogleMapCommonFieldProps extends FormFieldObject {
    /**
     * Map Type.
     */
    mapType: GoogleMapTypeId[];
    /**
     * Features.
     */
    showFeatures: GoogleMapFeaturesStyles[];
    /**
     * Zoom.
     *
     * To set the currently displayed zoom open the widget's menu (top right) and click on 'Set Zoom & Center'.
     *
     * Integers between zero, and up to the supported <a href="https://developers.google.com/maps/documentation/javascript/maxzoom">maximum zoom level</a>.
     */
    zoom: number;
    /**
     * Latitude.
     *
     * To set the currently displayed latitude open the widget's menu (top right) and click on 'Set Zoom & Center'.
     */
    latitude: number;
    /**
     * Longitude.
     *
     * To set the currently displayed longitude open the widget's menu (top right) and click on 'Set Zoom & Center'.
     */
    longitude: number;
    /**
     * Zoom Control.
     */
    zoomControl?: boolean;
    /**
     * Full Screen Control.
     */
    fullscreenControl?: boolean;
    /**
     * Street View Control.
     */
    streetViewControl?: boolean;
}

export declare interface GoogleMapCoordinateChartOptions extends FormFieldObject {
    /**
     * Location.
     *
     * A column/member with latitude/longitude properties.
     */
    location?: TidyTableColumnSelector;
    /**
     * Latitude.
     *
     * A column/member with latitude properties.
     */
    latitude?: TidyTableColumnSelector;
    /**
     * Longitude.
     *
     * A column/member with longitude properties.
     */
    longitude?: TidyTableColumnSelector;
}

/**
 * https://developers.google.com/maps/documentation/javascript/style-reference
 */
export declare enum GoogleMapFeaturesStyles {
    ALL = "all",
    ADMINISTRATIVE = "administrative",
    ADMINISTRATIVE_COUNTRY = "administrative.country",
    ADMINISTRATIVE_LAND_PARCEL = "administrative.land_parcel",
    ADMINISTRATIVE_LOCALITY = "administrative.locality",
    ADMINISTRATIVE_NEIGHBORHOOD = "administrative.neighborhood",
    ADMINISTRATIVE_PROVINCE = "administrative.province",
    LANDSCAPE = "landscape",
    LANDSCAPE_MAN_MADE = "landscape.man_made",
    LANDSCAPE_NATURAL = "landscape.natural",
    LANDSCAPE_NATURAL_LANDCOVER = "landscape.natural.landcover",
    LANDSCAPE_NATURAL_TERRAIN = "landscape_natural.terrain",
    POI = "poi",
    POI_ATTRACTION = "poi.attraction",
    POI_BUSINESS = "poi.business",
    POI_GOVERNMENT = "poi.government",
    POI_MEDICAL = "poi.medical",
    POI_PARK = "poi.park",
    POI_PLACE_OF_WORSHIP = "poi.place_of_worship",
    POI_SCHOOL = "poi.school",
    POI_SPORTS_COMPLEX = "poi.sports_complex",
    ROAD = "road",
    ROAD_ARTERIAL = "road.arterial",
    ROAD_HIGHWAY = "road.highway",
    ROAD_HIGHWAY_CONTROLLED_ACCESS = "road.highway.controlled_access",
    ROAD_LOCAL = "road.local",
    TRANSIT = "transit",
    TRANSIT_LINE = "transit.line",
    TRANSIT_STATION = "transit.station",
    TRANSIT_STATION_AIRPORT = "transit.station.airport",
    TRANSIT_STATION_BUS = "transit.station.bus",
    TRANSIT_STATION_RAIL = "transit.station.rail",
    WATER = "water"
}

export declare enum GoogleMapTypeId {
    /**
     * This map type displays a transparent layer of major streets on satellite
     * images.
     */
    HYBRID = "hybrid",
    /**
     * This map type displays a normal street map.
     */
    ROADMAP = "roadmap",
    /**
     * This map type displays satellite images.
     */
    SATELLITE = "satellite",
    /**
     * This map type displays maps with physical features such as terrain and
     * vegetation.
     */
    TERRAIN = "terrain"
}

/**
 * Google Marker Options (fields of the "Chart" tab in the widget editor).
 *
 * google.maps.Symbol
 *
 * <pre>
 *      Plugin ID         : ic3
 *      Widget/Template ID: GoogleHeatMap
 * </pre>
 *
 * @see WidgetTemplateChartOptions
 */
export declare interface GoogleMarkerChartOptions extends GoogleMapCoordinateChartOptions, GoogleMapChartOptions {
    /**
     * Marker's Variant.
     */
    markersVariant?: string;
    /**
     * Icon Path.
     *
     * An SVG path for the icon of size 22x22 ([doc](https://developers.google.com/maps/documentation/javascript/markers#symbols).
     * You can use [Material-UI] ones (https://material-ui.com/components/material-icons/) (you have to use DevTools inspect).
     */
    path: string;
    /**
     * Fill Opacity.
     */
    fillOpacity: number;
    /**
     * Stroke Weight
     */
    strokeWeight?: number;
    /**
     * Marker Scale.
     *
     * The amount by which the symbol is scaled in size. For symbol markers, this defaults to 1; after scaling,
     * the symbol may be of any size. For symbols on a polyline, this defaults to the stroke weight of the polyline;
     * after scaling, the symbol must lie inside a square 22 pixels in size centered at the symbol's anchor.
     *
     * A row expression: c.scaleNormalize() or 1.
     */
    scale: string;
    /**
     * Scale Column.
     *
     * The column used in the scale expression.
     */
    scaleColumn?: TidyTableColumnSelector;
    /**
     * Tooltip.
     */
    tooltip?: string;
    /**
     * Anchor X
     *
     * (0,0) is top left.
     */
    markerAnchorX?: number;
    /**
     * Anchor Y
     *
     * (0,0) is top left.
     */
    markerAnchorY?: number;
    /**
     * Use Marker Clusters.
     *
     * Creates per-zoom-level clusters for large amounts of markers.
     */
    useMarkerClusterer: boolean;
    /**
     * Max Zoom.
     *
     * The maximum zoom level at which clustering is enabled.
     */
    maxZoom: number;
    /**
     * Min Cluster Size.
     *
     * The minimum number of markers needed in a cluster before the markers are hidden and a cluster marker appears.
     */
    minimumClusterSize?: number;
    /**
     * Cluster Title.
     *
     * The tooltip to display when the mouse moves over a cluster marker.
     */
    clusterTitle?: string;
    /**
     * Zoom On Click.
     *
     * Zoom the area when clicking a clustered marker.
     */
    zoomOnClick: boolean;
    /**
     * Marker Click Event Column.
     *
     * Column used when firing a marker-click event.
     */
    clickEventColumn?: TidyTableColumnSelector;
    /**
     * Markers Fill Color.
     *
     * Column used containing the color of the markers.
     */
    color?: TidyTableColumnSelector;
}

export declare interface GoogleMarkerVariantChartOptions {
    /**
     * The symbol's path, which is a built-in symbol path, or a custom path expressed using
     * <a href="http://www.w3.org/TR/SVG/paths.html#PathData">SVG path notation</a>.
     *
     * 22px,22px expected.
     */
    path: string;
    /**
     * The symbol's fill opacity. Defaults to 0.
     */
    fillOpacity?: number;
    /**
     * The amount by which the symbol is scaled in size. For symbol markers, this defaults to 1; after scaling,
     * the symbol may be of any size. For symbols on a polyline, this defaults to the stroke weight of the polyline;
     * after scaling, the symbol must lie inside a square 22 pixels in size centered at the symbol's anchor.
     */
    scale?: number;
    /**
     * Anchor for the marker (0,0 is top left).
     */
    anchorX?: number;
    anchorY?: number;
    /**
     * The symbol's stroke color. All CSS3 colors are supported except for extended named colors. For symbol markers,
     * this defaults to 'black'. For symbols on a polyline, this defaults to the stroke color of the polyline.
     */
    strokeColor?: string | null | undefined;
    /**
     * The symbol's stroke opacity. For symbol markers, this defaults to 1. For symbols on a polyline,
     * this defaults to the stroke opacity of the polyline.
     */
    strokeOpacity?: number | null | undefined;
    /**
     * The symbol's stroke weight. Defaults to the <code>scale</code> of the symbol.
     */
    strokeWeight?: number | null | undefined;
}

export declare type GroupRowIndices = [number, ...number[]];

export declare enum HistogramBinType {
    AUTOMATIC_WITH_BINS = "automatic",
    USER_DEFINED = "userDefined",
    /**
     * Makes sure that the automatic buckets do not consist of floating point numbers with many decimals.
     * E.g., it uses [0, 0.5, 1] instead of [0.001, 0.4955, 0.99]. User cannot set the number of bins however.
     */
    INTERVAL_STEPS = "roundedIntervals"
}

export declare interface HistogramBucket {
    /**
     * Bucket start range. Undefined = -Infinity.
     */
    from?: number;
    /**
     * Bucket end range. Undefined = Infinity.
     */
    to?: number;
    /**
     * The name of the bucket
     */
    name?: string;
}

export declare interface HistogramData extends HistogramBucket {
    /**
     * Number of values that fall in the range [from, to).
     */
    count: number;
    /**
     * Row indices where the value falls in the bucket
     */
    rows: number[];
}

export declare interface HistogramOptions {
    /**
     * The number of bins to use in the histogram or an object with custom bins. Default = 10.
     *
     * If bins is a number, then the algorithm generates the bins. The included endpoint of the bin is rounded with
     * a precision of 1e10 in the direction that makes the bin larger.
     */
    bins: number | HistogramBucket[];
    /**
     * The type of interval. Default = RIGHT_CLOSED.
     */
    intervalType: TidyHistogramBucketType;
    /**
     * If true, put the minimum value in the first bucket if intervalType = (from, to] or put the maximum value
     * in the last bucket if intervalType = [from, to).
     * If false, exclude the minimum or maximum value in the above scenario.
     * Default = true.
     */
    includeEndPoints: boolean;
}

export declare class HomeCardClasses {
    static readonly background = "ic3HomeCard-background";
    static readonly card = "ic3HomeCard-card";
    static readonly menuIcon = "ic3HomeCard-menuIcon";
}

export declare type HomeCardClassKey = keyof HomeCardClasses;

export declare interface HomeCardProps {
    appId: string;
}

export declare class HomeConsoleClasses {
    static readonly logoBg = "ic3HomeConsole-logoBg";
    static readonly logoFg = "ic3HomeConsole-logoFg";
    static readonly logoBgSvg = "ic3HomeConsole-logoBgSvg";
    static readonly logoFgSvg = "ic3HomeConsole-logoFgSvg";
    static readonly cardTextureAdmin = "ic3HomeConsole-cardTextureAdmin";
    static readonly backgroundOthers = "ic3HomeConsole-backgroundOthers";
    static readonly textureLeft = "ic3HomeConsole-textureLeft";
    static readonly textureRight = "ic3HomeConsole-textureRight";
    static readonly customLayout = "ic3HomeConsole-customLayout";
    static readonly caption = "ic3HomeConsole-caption";
    static readonly appName = "ic3HomeConsole-appName";
    static readonly appNameRecent = "ic3HomeConsole-appName-recent";
    static readonly slogan = "ic3HomeConsole-slogan";
}

export declare type HomeConsoleClassKey = keyof HomeConsoleClasses;

export declare type Hook<T, P> = {
    hook: (value: T, options: P) => void;
};

export declare class HtmlBoxClasses {
    /**
     * Style applied to the root element.
     */
    static root: string;
}

export declare type HtmlBoxClassKey = keyof HtmlBoxClasses;

export declare type HtmlBoxVariant = "plain" | 
/**
* Used by the editor documentation dialog and text box used for Live Demo documentation.
*/
"doc" | 
/**
* Used by the dashboard documentation dialog (e.g., filter panel usage, box help icon).
*/
"dashboardDoc" | 
/**
* Used by the widget box tooltip/help icon.
*/
"widgetHelp" | 
/**
* Used for help tooltip & tooltip in table
*/
"tooltip" | 
/**
* Based on dashboard theme definition (h1,h2...)
*/
"dashboardTheme";

export declare interface HtmlTidyColumnCellDecoration extends BaseTidyColumnCellDecoration {
    /**
     * True if your renderer returns a HTML string.
     */
    stringRenderer: true;
    /**
     * The cell renders the returned string as HTML.
     */
    renderer: (rowIdx: number) => string;
}

export declare interface I18nIFormFieldDef {
    fieldType?: FormFieldType;
    fieldPath: string;
    fieldPrefixTag?: string;
    fieldDescription?: string;
    localizationTag?: string;
}

/**
 * Objects that have this type are used in chart.data in amCharts.
 */
export declare interface IAmCharts4Data {
    /**
     * The date/string value of the axis.
     */
    axis: Date | string;
    /**
     * The row number of the axis. Uses first row if multiple rows are in the dataItem for the axis.
     */
    row: number;
    /**
     * Other values for the series
     */
    [key: string]: any;
}

export declare enum IAmcharts4DataKey {
    /**
     * Data key for the date/string value of the axis.
     */
    AXIS = "axis",
    /**
     * Data key for the tidy-row number.
     */
    ROW = "row",
    /**
     * Data key for accessing the value of a dataItem. Used when there are no groups or levels in the data.
     */
    NULL = "_"
}

export declare interface IAmCharts4DataTreeMap {
    children: {
        [key: string]: any;
    }[];
    [key: string]: any;
}

/**
 * Controls when to add / remove / dispose / update series. This class exists because using chart.setSeries removes
 * trend-series. This class handles the adding and removing of series and keeps the series in the order of the data.
 */
export declare interface IAmchartsSeriesControl<T> {
    /**
     * If defined, only call create, update and remove where `typeFilter(type)` returns true.
     */
    typeFilter?: (type: ISeriesValuesType) => boolean;
    /**
     * Create a new series if it is not in itemControl. Use 'add' to add it to the chart.
     * @param seriesId unique id of the series
     * @param groupKey key for the group by (if defined). If not defined, use _
     * @param valueKey series value dataField
     * @param fillKey series fill dataField
     * @param sValue the onValues part used.
     */
    create: (seriesId: string, groupKey: string, valueKey: string, fillKey: string, sValue: ISeriesValues) => T;
    /**
     * Update a series.
     * @param seriesId unique id of the series
     * @param groupKey key for the group by (if defined). If not defined, use _
     * @param series the charts series to update
     * @param sValue the onValues part used
     * @param groupRows row indices of the group. Length >= 1.
     */
    update: (seriesId: string, groupKey: string, series: T, sValue: ISeriesValues, groupRows: GroupRowIndices) => void;
    /**
     * Destroy an item. Called when the item can be cleared from memory. E.g., dispose() on the series.
     */
    remove: (item: T) => void;
}

export declare interface IAppNotification {
    /**
     * E.g., print-report.
     */
    readonly type: AppNotificationType;
}

export declare interface IAppNotificationCallback {
    onStarted: (token: IAppNotificationToken) => void;
    onSuccess: (token: IAppNotificationToken) => void;
    /**
     * Return true if the error has been handled : the app. error handler won't be called.
     */
    onError: (token: IAppNotificationToken, error: any) => void | boolean;
}

export declare interface IAppNotificationToken {
    type: AppNotificationType;
    uid: number;
}

export declare interface IAppNotificationWithPayload<PAYLOAD> extends IAppNotification {
    /**
     * E.g., print-report.
     */
    readonly type: AppNotificationType;
    /**
     * E.g., print-report file name.
     */
    readonly payload: PAYLOAD;
}

export declare interface IAppPrintReportNotification extends IAppNotificationWithPayload<AppPrintReportNotificationPayload> {
}

export declare interface IBulletShapeOptions extends FormFieldObject {
    bulletShapeWidth: number;
    bulletShapeHeight: number;
}

declare class ic3AppMenuIconClasses {
    static readonly root = "ic3AppMenuIcon-root";
}

declare type ic3AppMenuIconClassKey = keyof ic3AppMenuIconClasses;

declare class ic3AppMenuItemClasses {
}

declare type ic3AppMenuItemClassKey = keyof ic3AppMenuItemClasses;

declare class ic3AppMenuItemHeaderClasses {
}

declare type ic3AppMenuItemHeaderClassKey = keyof ic3AppMenuItemHeaderClasses;

export declare interface ic3BaseComponents {
    AIWidgetChatBot?: {
        styleOverrides?: ComponentsOverrides["AIWidgetChatBot"];
        variants?: ComponentsVariants["AIWidgetChatBot"];
    };
    AlertDialog?: {
        styleOverrides?: ComponentsOverrides["AlertDialog"];
    };
    App?: {
        styleOverrides?: ComponentsOverrides["App"];
    };
    ErrorRenderer?: {
        styleOverrides?: ComponentsOverrides["ErrorRenderer"];
    };
    FilterCheckbox?: {
        styleOverrides?: ComponentsOverrides["FilterCheckbox"];
        variants?: ComponentsVariants["FilterCheckbox"];
    };
    FilterButtons?: {
        styleOverrides?: ComponentsOverrides["FilterButtons"];
        variants?: ComponentsVariants["FilterButtons"];
    };
    LazyTreeViewStyled?: {
        styleOverrides?: ComponentsOverrides["LazyTreeViewStyled"];
        variants?: ComponentsVariants["LazyTreeViewStyled"];
    };
    FilterPanel?: {
        variants?: ComponentsVariants['FilterPanel'];
        styleOverrides?: ComponentsOverrides["FilterPanel"];
    };
    RegexFilter?: {
        variants?: ComponentsVariants['RegexFilter'];
        styleOverrides?: ComponentsOverrides["RegexFilter"];
    };
    FilterSlider?: {
        styleOverrides?: ComponentsOverrides["FilterSlider"];
        variants?: ComponentsVariants["FilterSlider"];
    };
    ListCounter?: {
        styleOverrides?: ComponentsOverrides["ListCounter"];
        variants?: ComponentsVariants["ListCounter"];
    };
    FilterTree?: {
        styleOverrides?: ComponentsOverrides["FilterTree"];
        variants?: ComponentsVariants["FilterTree"];
    };
    FilterTreePopOver?: {
        styleOverrides?: ComponentsOverrides["FilterTreePopOver"];
        variants?: ComponentsVariants["FilterTreePopOver"];
    };
    FilterDatePicker?: {
        styleOverrides?: ComponentsOverrides["FilterDatePicker"];
        variants?: ComponentsVariants["FilterDatePicker"];
    };
    FilterAutocomplete?: {
        styleOverrides?: ComponentsOverrides["FilterAutocomplete"];
        variants?: ComponentsVariants["FilterAutocomplete"];
    };
    FilterAutocompletePopper?: {
        styleOverrides?: ComponentsOverrides["MuiPopper"];
        variants?: ComponentsVariants["MuiPopper"];
    };
    GoogleMarker?: {
        variants?: ComponentsVariants['GoogleMarker'];
    };
    HtmlBox?: {
        styleOverrides?: ComponentsOverrides["HtmlBox"];
        variants?: ComponentsVariants["HtmlBox"];
    };
    KpiCard?: {
        styleOverrides?: ComponentsOverrides["KpiCard"];
        variants?: ComponentsVariants["KpiCard"];
    };
    Layout?: {
        styleOverrides?: ComponentsOverrides["Layout"];
    };
    LayoutPage?: {
        styleOverrides?: ComponentsOverrides["LayoutPage"];
    };
    PivotTable?: {
        variants?: ComponentsVariants['PivotTable'];
        styleOverrides?: ComponentsOverrides["PivotTable"];
    };
    ReportAppBar?: {
        styleOverrides?: ComponentsOverrides["ReportAppBar"];
    };
    ReportAppLeftPanel?: {
        styleOverrides?: ComponentsOverrides["ReportAppLeftPanel"];
    };
    Table?: {
        variants?: ComponentsVariants['Table'];
        styleOverrides?: ComponentsOverrides["Table"];
    };
    WidgetBox?: {
        variants?: ComponentsVariants['WidgetBox'];
        styleOverrides?: ComponentsOverrides["WidgetBox"];
    };
    WidgetBoxContentMessage?: {
        styleOverrides?: ComponentsOverrides["WidgetBoxContentMessage"];
    };
    ic3AppMenuIcon?: {
        styleOverrides?: ComponentsOverrides["ic3AppMenuIcon"];
    };
    Ic3AppMenuItemHeader?: {
        styleOverrides?: ComponentsOverrides["Ic3AppMenuItemHeader"];
    };
    ic3AppMenuItem?: {
        styleOverrides?: ComponentsOverrides["ic3AppMenuItem"];
    };
    QueryBuilderNode?: {
        styleOverrides?: ComponentsOverrides["QueryBuilderNode"];
    };
    PrintButton?: {
        styleOverrides?: ComponentsOverrides["PrintButton"];
        variants?: ComponentsVariants["PrintButton"];
    };
    CodeMirror?: {
        styleOverrides?: ComponentsOverrides["CodeMirror"];
    };
    WidgetBoxFilteredByTooltip?: {
        styleOverrides?: ComponentsOverrides["WidgetBoxFilteredByTooltip"];
    };
    Ic3TableCell?: {
        styleOverrides?: ComponentsOverrides["Ic3TableCell"];
    };
    Ic3TableCellDrilldown?: {
        styleOverrides?: ComponentsOverrides["Ic3TableCellDrilldown"];
    };
    Ic3TableCellError?: {
        styleOverrides?: ComponentsOverrides["Ic3TableCellError"];
    };
    Ic3WidgetBoxSpinner?: {
        defaultProps?: Partial<Ic3WidgetBoxSpinnerProps>;
        styleOverrides?: ComponentsOverrides["Ic3WidgetBoxSpinner"];
    };
    Ic3FilterSwitch?: {
        styleOverrides?: ComponentsOverrides["Ic3FilterSwitch"];
        variants?: ComponentsVariants["Ic3FilterSwitch"];
    };
    "amCharts4.AmCharts4BubbleChart"?: {
        variants?: Ic3ChartVariants["amCharts4.AmCharts4BubbleChart"];
    };
    "amCharts4.AmCharts4ComboChart"?: {
        variants?: Ic3ChartVariants["amCharts4.AmCharts4ComboChart"];
    };
    "amCharts4.AmCharts4RegularAreaChart"?: {
        variants?: Ic3ChartVariants["amCharts4.AmCharts4RegularAreaChart"];
    };
    "amCharts4.AmCharts4RegularBarChart"?: {
        variants?: Ic3ChartVariants["amCharts4.AmCharts4RegularBarChart"];
    };
    "amCharts4.AmCharts4RegularColumnChart"?: {
        variants?: Ic3ChartVariants["amCharts4.AmCharts4RegularColumnChart"];
    };
    "amCharts4.AmCharts4RegularLineChart"?: {
        variants?: Ic3ChartVariants["amCharts4.AmCharts4RegularLineChart"];
    };
    "amCharts4.AmCharts4ScatterPlot"?: {
        variants?: Ic3ChartVariants["amCharts4.AmCharts4ScatterPlot"];
    };
    "amCharts4.AmCharts4StackedAreaChart"?: {
        variants?: Ic3ChartVariants["amCharts4.AmCharts4StackedAreaChart"];
    };
    "amCharts4.AmCharts4StackedBarChart"?: {
        variants?: Ic3ChartVariants["amCharts4.AmCharts4StackedBarChart"];
    };
    "amCharts4.AmCharts4StackedColumnChart"?: {
        variants?: Ic3ChartVariants["amCharts4.AmCharts4StackedColumnChart"];
    };
    "amCharts4.AmCharts4DonutChart"?: {
        variants?: Ic3ChartVariants["amCharts4.AmCharts4DonutChart"];
    };
    "amCharts4.AmCharts4GaugeChart"?: {
        variants?: Ic3ChartVariants["amCharts4.AmCharts4GaugeChart"];
    };
    "amCharts4.AmCharts4Histogram"?: {
        variants?: Ic3ChartVariants["amCharts4.AmCharts4Histogram"];
    };
    "amCharts4.AmCharts4SankeyDiagram"?: {
        variants?: Ic3ChartVariants["amCharts4.AmCharts4SankeyDiagram"];
    };
    "amCharts4.AmCharts4TreeMap"?: {
        variants?: Ic3ChartVariants["amCharts4.AmCharts4TreeMap"];
    };
    "amCharts4.AmCharts4GeoMap"?: {
        variants?: Ic3ChartVariants["amCharts4.AmCharts4GeoMap"];
    };
    HomeCard?: {
        styleOverrides?: ComponentsOverrides["HomeCard"];
    };
    HomeConsole?: {
        styleOverrides?: ComponentsOverrides["HomeConsole"];
    };
}

export declare type Ic3ChartVariants = {
    [Name in keyof WidgetTemplateChartOptions]?: Array<{
        props: {
            variant: string;
        };
        /**
         * Default props define the default options for the widget.
         */
        defaultProps: Partial<WidgetTemplateChartOptions[Name]>;
    }>;
};

export declare interface ic3ComponentNameToClassKey {
    AIWidgetChatBot: AIWidgetChatBotClassKey;
    AlertDialog: AlertDialogClassKey;
    App: AppClassKey;
    ErrorRenderer: ErrorRendererClassKey;
    FilterCheckbox: FilterCheckboxRadioClassKey;
    FilterButtons: FilterButtonsClassKey;
    LazyTreeViewStyled: LazyTreeClassesClassKey;
    FilterPanel: FilterPanelClassesKey;
    FilterPanelViewsMenu: FilterPanelViewsMenuClassesKey;
    Ic3CustomDrilldownMenu: Ic3CustomDrilldownMenuClassesKey;
    RegexFilter: RegexFilterClassesKey;
    FilterSlider: FilterSliderClassKey;
    ListCounter: ListCounterClassKey;
    FilterTree: FilterTreeClassKey;
    Ic3FilterSwitch: FilterSwitchClassKey;
    FilterTreePopOver: FilterTreePopOverClassKey;
    FilterDatePicker: DatePickerClassKey;
    FilterAutocomplete: FilterAutocompleteClassesKey;
    HtmlBox: HtmlBoxClassKey;
    KpiCard: KpiCardClassKey;
    Layout: LayoutClassKey;
    LayoutPage: LayoutPageClassKey;
    PivotTable: PivotTableClassKey;
    Table: TableClassKey;
    ReportAppBar: ReportAppBarClassKey;
    WidgetBox: WidgetBoxClassKey;
    WidgetBoxContentMessage: WidgetBoxContentMessageClassKey;
    ReportAppLeftPanel: ReportAppLeftPanelClassKey;
    ic3AppMenuIcon: ic3AppMenuIconClassKey;
    Ic3AppMenuItemHeader: ic3AppMenuItemHeaderClassKey;
    ic3AppMenuItem: ic3AppMenuItemClassKey;
    QueryBuilderNode: QueryBuilderNodeClassKey;
    PrintButton: PrintButtonClassKey;
    CodeMirror: CodeMirrorClassesKey;
    WidgetBoxFilteredByTooltip: WidgetFilteredByClassesKey;
    Ic3TableCell: ThemeIc3TableCellClassesKey;
    Ic3TableCellDrilldown: ThemeIc3TableCellDrilldownClassesKey;
    Ic3TableCellError: ThemeIc3TableCellClassesKey;
    Ic3WidgetBoxSpinner: ThemeIc3WidgetBoxSpinnerClassesKey;
    HomeCard: HomeCardClassKey;
    HomeConsole: HomeConsoleClassKey;
}

export declare interface ic3ComponentsPropsList {
    AIWidgetChatBot: AIWidgetChatBotStyleProps;
    FilterCheckbox: FilterCheckboxProps;
    FilterButtons: FilterButtonsProps;
    LazyTreeViewStyled: LazyTreeProps;
    FilterPanel: FilterPanelProps;
    RegexFilter: RegexFilterProps;
    FilterSlider: FilterSliderProps;
    ListCounter: ListCounterProps;
    FilterTree: FilterTreeProps;
    Ic3FilterSwitch: FilterSwitchProps;
    FilterTreePopOver: FilterTreePopOverProps;
    FilterDatePicker: FilterDatePickerProps;
    FilterAutocomplete: FilterAutocompleteProps;
    HtmlBox: StyledHtmlBoxProps;
    KpiCard: KpiCardProps;
    PivotTable: PivotTableProps;
    Table: TableProps;
    WidgetBox: WidgetBoxDivProps;
    GoogleMarker: GoogleMarkerVariantChartOptions;
    App: AppDivProps;
    QueryBuilderNode: QueryBuilderNodeProps;
    PrintButton: StyledPrintButtonDivProps;
    Ic3TableCell: Ic3TableCellProps;
    Ic3TableCellDrilldown: Ic3TableCellDrilldownProps;
    Ic3TableCellError: Ic3TableCellProps;
    Ic3WidgetBoxSpinner: Ic3WidgetBoxSpinnerProps;
}

export declare class Ic3CustomDrilldownMenuClasses {
    static readonly header = "Ic3CustomDrilldownMenu-header";
    static readonly list = "Ic3CustomDrilldownMenu-list";
    static readonly headerText = "Ic3CustomDrilldownMenu-headerText";
    static readonly back = "Ic3CustomDrilldownMenu-back";
}

export declare type Ic3CustomDrilldownMenuClassesKey = keyof Ic3CustomDrilldownMenuClasses;

export declare class Ic3GlobalClasses {
    static readonly singleSelection = "ic3-SingleSelection";
    static readonly multipleSelection = "ic3-MultipleSelection";
}

export declare interface ic3Palette extends ic3CorePalette {
    /**
     * The color for the page background (can be overridden at layout level).
     */
    pageBackgroundColor: Property.Color;
    /**
     * The color for a selected item
     */
    selected: Property.Color;
    /**
     * For charts, you can define a function that derives the selected color from the color of the clicked item without
     * selection. For example, you can use darken(color) from Mui-Material to get a darker color.
     * @param color the color of the item without selection.
     * @Return the color for the item in the selected state.
     */
    selectedChart?: (color: Property.Color | undefined | null) => Property.Color;
    /**
     * The text color for a selected item
     */
    selectedText: Property.Color;
    /**
     * The text background color for a selected item
     */
    selectedBackground: Property.Color;
    selectedOpacity: number;
    unSelectedOpacity: number;
    hoverBackground: Property.Color;
    /**
     * List of named color palettes available on chart options
     */
    chartPalettes: {
        'default': Property.Color[];
    } & Record<string, Property.Color[]>;
    /**
     * List of named single colors available on chart options
     */
    chartSingleColors: MandatorySingleColors & Record<string, Property.Color>;
    /**
     * Report Application Menu
     */
    reportAppMenu: string;
}

export declare interface ic3PaletteOptions extends ic3CorePaletteOptions {
    selected?: Property.Color;
    selectedText?: Property.Color;
    selectedBackground?: Property.Color;
    selectedOpacity?: number;
    /**
     * For charts, you can define a function that derives the selected color from the color of the clicked item without
     * selection. For example, you can use darken(color) from Mui-Material to get a darker color.
     * @param color the color of the item without selection.
     * @Return the color for the item in the selected state.
     */
    selectedChart?: (color: Property.Color | undefined | null) => Property.Color;
    unSelectedOpacity?: number;
    hoverBackground?: Property.Color;
    chartPalettes?: {
        'default': Property.Color[];
    } & Record<string, Property.Color[]>;
    chartSingleColors?: Partial<MandatorySingleColors> & Record<string, Property.Color>;
    reportAppMenu?: Property.Color;
}

declare interface Ic3TableCellDrilldownProps {
    levelDepth: number;
    hasRender: boolean;
    hasChildren: boolean;
}

export declare interface Ic3TableCellProps {
    align?: 'left' | 'right' | 'center';
    /**
     * True if and only if the cell has a cell-renderer.
     */
    hasRenderer?: boolean;
}

export declare interface ic3Theme extends ic3CoreTheme {
    cssClass: string;
    waitForFonts?: () => Promise<any>;
    formatter: ThemeFormatterPerLocale | ThemeFormatters;
    /**
     * For the App Viewer the height of the Application header (css style)
     */
    appViewer?: {
        appTopPanelHeight?: string;
        appTopPanelWithFilterHeight?: string;
        appLeftPanelWidth?: string;
        appLeftPanelCollapsedWidth?: string;
        appMenuInnerPercentage?: string;
        appMenuOuterPercentage?: string;
    };
    /**
     * Icons used in tables and trees
     */
    icons: {
        none: (className: string) => ReactElement | string;
        expanded: (className: string) => ReactElement | string;
        collapse: (className: string) => ReactElement | string;
        loading: (className: string) => ReactElement | string;
        sort: (className: string) => ReactElement | string;
        sortAsc: (className: string) => ReactElement | string;
        sortDesc: (className: string) => ReactElement | string;
        datePickerIcon?: React_2.ElementType;
        menuIcon: JSX.Element;
        statusWaiting: JSX.Element;
        statusWaitingResult: JSX.Element;
        statusRendering: JSX.Element;
        statusDone: JSX.Element;
        queryError: JSX.Element;
        queryWarning: JSX.Element;
        helpIcon: JSX.Element;
        helpIconOutlined: JSX.Element;
        closeQueryIcon: JSX.Element;
        interactionModeSelection: JSX.Element;
        interactionModeDrilldown: JSX.Element;
        widgetFilterActive: React_2.ReactNode | undefined;
        autocompleteClearIcon: JSX.Element | undefined;
        autocompletePopupIcon: JSX.Element | undefined;
        nodeOpened: JSX.Element;
        nodeClosed: JSX.Element;
        checkBoxUnselected: React_2.ReactNode | undefined;
        checkBoxSelected: React_2.ReactNode | undefined;
        checkIndeterminate: React_2.ReactNode | undefined;
        radioUnselected: React_2.ReactNode | undefined;
        radioSelected: React_2.ReactNode | undefined;
        hasDescendantsIndicatorIcon: React_2.ReactNode | undefined;
        getViewsMenuCustomButtonIcon: (name: string | undefined) => React_2.ReactNode | undefined;
    };
    /**
     * Additional icons in the icon cell renderer.
     */
    iconsCellRenderer?: Record<string, typeof SvgIcon>;
    palette: {
        darken: (color: string, factor: number) => string;
        lighten: (color: string, factor: number) => string;
    };
    table: Record<TableRowHeightOptions, {
        rowHeight: number;
        headerRowHeight: number;
    }>;
    treeFilter: {
        itemHeight: number;
    };
    googleMap: {
        options?: google.maps.MapOptions;
        markerClustererOptions?: MarkerClustererOptions;
    };
    drilldown?: {
        disableDrilldownInTitle?: boolean;
    };
    userMenu: {
        disableUserMenuEdition: boolean;
        userMenuFilter?: (options: IUserMenuOptions[], templateDef?: IPublicWidgetTemplateDefinition<any>) => IUserMenuOptions[];
    };
    widgetIcons?: IWidgetIcons;
    widgetBox: {
        extraHeight?: number;
        contentOffset: {
            top: number;
            left: number;
        };
    };
    amCharts4: {
        icons: {
            zoomOutButton?: {
                /**
                 * The radius of the corners
                 * tl – Top-left corner
                 * tr – Top-right corner
                 * bl – Bottom-left corner
                 * br – Bottom-right corner
                 */
                cornerRadius: [number, number, number, number];
                fill: string;
                stroke: string;
                strokeWidth: number;
                hoverColor: string;
                downColor: string;
            };
        };
    };
    /**
     * A zoom applied to the widget content when rendered for printing.
     * Defaulted to 0.64.
     */
    widgetContentPrintScale?: number;
    /**
     * The first defined layout is used as the default one.
     */
    layouts: IWidgetLayoutDefinition[];
    /**
     * Default values (e.g., box options, chart options, etc...).
     */
    widgetDefaults?: IThemeWidgetDefaults;
    /**
     * Styling for the sparklines in the sparkline transformation and the KPI card.
     */
    sparklineSettings: {
        /**
         * Line sparkline settings.
         */
        line: {
            /**
             * The width of the line in the sparkline
             */
            lineWidth: number;
            /**
             * The cursor when the user hovers over the sparkline
             */
            cursor: {
                color: Property.Color;
                /**
                 * the width of the cursor dot when hovering.
                 */
                spotRadius: number;
                /**
                 * The width of the stroke when hovering
                 */
                width: number;
            };
        };
        /**
         * Column sparkline settings.
         */
        column: {
            /**
             * Radius of the columns rounded corners.
             */
            cornerRadius: number;
            /**
             * Space between columns.
             */
            columnSpacing: number;
        };
    };
    noSchemaRenderer?: (context: IPublicContext, options: INoSchemaRendererOptions) => ReactElement;
    /**
     * Options for date/range pickers. Filter panel / date picker filter.
     */
    datePicker: {
        shortcuts: Record<'default', {
            datePickerShortcuts: DatePickerShortcut[];
            rangePickerShortcuts: DateRangePickerShortcut[];
        }> & Record<string, {
            datePickerShortcuts: DatePickerShortcut[];
            rangePickerShortcuts: DateRangePickerShortcut[];
        }>;
    };
    /**
     * Options for saving the state of all dashboard filters into local storage.
     */
    filterState?: {
        /**
         * Set to true to disable auto save for all dashboards/apps and make the option inactive.
         */
        disableFilterStateOption?: boolean;
        /**
         * The default value for auto-saving filter setting in the dashboards.
         */
        autosaveFilterStateToSessionStorage?: boolean;
        /**
         * The default value for auto-saving filter setting in the application filter panel.
         */
        autosaveReportAppFilterStateToSessionStorage?: boolean;
    };
}

export declare interface ic3ThemeOptions {
    /**
     * For editor theme, the id to use in your app-local/ic3report-config.js:
     *
     * <pre>
     *     options.defaultEditorThemeId = ...
     * </pre>
     */
    id: string;
    caption: string;
    cssClass?: string;
    /**
     * For the App Viewer the height of the Application header (css style)
     */
    appViewer?: {
        appTopPanelHeight?: string;
        appTopPanelWithFilterHeight?: string;
        appLeftPanelWidth?: string;
        appLeftPanelCollapsedWidth?: string;
    };
    /**
     * The recommended setup is to use document.fonts.ready here and put document.fonts.load(...) for all your added
     * fonts in the theme definition .ts file.
     */
    waitForFonts?: () => Promise<any>;
    formatter?: DeepPartial<ThemeFormatterPerLocale | ThemeFormatters>;
    icons?: Partial<ic3Theme['icons']>;
    /**
     * Additional icons in the icon cell renderer.
     */
    iconsCellRenderer?: Record<string, typeof SvgIcon>;
    table?: Record<TableRowHeightOptions, Partial<{
        rowHeight: number;
        headerRowHeight: number;
    }>>;
    treeFilter?: {
        /**
         * Define the height for an item in the tree. This cannot be done using css, because the tree is virtualized and
         * requires a fixed height setting.
         */
        itemHeight?: number;
    };
    googleMap?: {
        options?: google.maps.MapOptions;
    };
    drilldown?: {
        disableDrilldownInTitle?: boolean;
    };
    /**
     * Change the settings for the user menu for some or all widgets.
     */
    userMenu?: {
        /**
         * Set to true to make the user menu option readonly (non-editable) for all widgets.
         */
        disableUserMenuEdition?: boolean;
        /**
         * Filter the items in the user menu. Return an empty array to disable and not show the user menu.
         */
        userMenuFilter?: (options: IUserMenuOptions[], templateDef?: IPublicWidgetTemplateDefinition<any>) => IUserMenuOptions[];
    };
    /**
     * Controls the icons to show for all widgets. To hide icons for a single widget, see `widgetDefaults`.
     * @see {ic3ThemeOptions.widgetDefaults}.
     */
    widgetIcons?: IWidgetIcons;
    widgetBox?: {
        /**
         * Used when computing the height of the widget when (vertical) auto-expand is being applied.
         * E.g., margins, paddings, ...
         */
        extraHeight?: number;
        contentOffset: {
            /**
             * Corresponds to the actual height as defined for WidgetBoxClasses.header.
             */
            top: number;
            left: number;
        };
    };
    /**
     * Default values (e.g., box options, chart options, etc...).
     */
    widgetDefaults?: IThemeWidgetDefaults;
    /**
     * Settings for the filter state.
     */
    filterState?: Partial<ic3Theme['filterState']>;
    /**
     * A scale applied to the widget content when rendered for printing.
     * Defaulted to 0.64.
     */
    widgetContentPrintScale?: number;
    /**
     * The first defined layout is used as the default one.
     */
    layouts?: IWidgetLayoutDefinition[];
    /**
     * Styling for the sparklines in the sparkline transformation and the KPI card
     */
    sparklineSettings?: {
        /**
         * The width of the line in the sparkline
         */
        lineWidth: number;
        /**
         * The cursor when the user hovers over the sparkline
         */
        cursor: {
            color: Property.Color;
            /**
             * The radius of the dot when hovering
             */
            radius: number;
            /**
             * The width of the stroke when hovering
             */
            width: number;
        };
    };
    noSchemaRenderer?: (context: IPublicContext, options: INoSchemaRendererOptions) => ReactElement;
    /**
     * Theme settings for the editor (application & report).
     */
    editor?: {
        /**
         * Editor logo.
         *
         * Default: icCube logo.
         */
        logo?: string;
        /**
         * Alt text for the logo image.
         *
         * Default: "icCube".
         */
        logoAlt?: string;
        /**
         * Top offset of the edited dashboard page in the editor.
         *
         * Default: 25.
         */
        viewPortOffsetTop?: number;
        /**
         * Left offset of the edited dashboard page in the editor.
         *
         * Default: 25.
         */
        viewPortOffsetLeft?: number;
    };
    amCharts4?: {
        icons?: {
            zoomOutButton?: {
                /**
                 * The radius of the corners
                 * tl – Top-left corner
                 * tr – Top-right corner
                 * bl – Bottom-left corner
                 * br – Bottom-right corner
                 */
                cornerRadius: [number, number, number, number];
                fill: string;
                stroke: string;
                strokeWidth: number;
                hoverColor: string;
                downColor: string;
            };
        };
    };
    datePicker?: DeepPartial<ic3Theme['datePicker']>;
}

export declare interface ic3Typography {
    amCharts4: TypographyStyle;
}

export declare interface ic3TypographyOptions {
    /**
     * Typography for the amCharts plugin.
     */
    amCharts4?: TypographyStyle;
}

export declare interface Ic3WidgetBoxSpinnerProps {
    /**
     * Size of the spinner. Default = 48.
     */
    size: number;
}

export declare type Ic3WidgetComponentVariants = Array<{
    props: {
        variant: string;
    };
    style: Interpolation<{
        theme: Theme;
    }>;
}>;

export declare enum IcEventType {
    TIDY_SELECTION = 0,
    TIDY_FIRE = 1,
    TIDY_ACTION = 2,
    API = 3,
    IC3_CORE = 4
}

export declare interface IChartVisualizationTypedInput<T extends FormFieldObject> {
    table: ITidyTable;
    inter: ITidyTableInteraction;
    options: T;
}

export declare interface IColorDef {
    /**
     * aka. name
     */
    path: string;
}

export declare enum IContentMessageType {
    info = 0,
    error = 1
}

/**
 * A generic object.
 *
 * Use the editorConf to provide the list of options to choose from and the function that is displaying
 * the label/caption of the options. Check the editorConf for more configuration.
 *
 * This is quite a generic editor that should not be used directly.
 *
 * @see FormFieldDef
 */
export declare interface IFormAutocompleteFieldDef<OPTION> extends IFormFieldDef<OPTION> {
    fieldType: "autocomplete";
    editorConf: {
        multiple?: boolean;
        groupBy?: (option: OPTION | undefined) => string;
        getOptionLabel?: (option: OPTION | undefined | null) => string;
        isOptionEqualToValue?: (option: OPTION | undefined | null, value: OPTION | undefined | null) => boolean;
        freeSolo?: boolean;
        optionValues?: OPTION[] | ((callback: ((suggestions: OPTION[]) => void), dependsOnValue?: any, param?: {
            theme: Theme;
        }) => void);
        noOptionsText?: AutocompleteNoOptionsText;
        /**
         * Show an action button below the options.
         *
         * If the query is outdated or not run yet, it shows a refresh action instead.
         */
        action?: AutocompleteActions;
        renderInput?: (params: AutocompleteRenderInputParams) => React_2.ReactNode;
        renderOption?: (props: React_2.HTMLAttributes<HTMLLIElement>, option: OPTION, state: AutocompleteRenderOptionState, onClose: () => void) => React_2.ReactNode;
        disableClearable?: boolean;
        renderTags?: AutocompleteProps<OPTION, any, any, any>['renderTags'];
    };
}

/**
 * The "groupBoolean" allows for using that field as a group header and as a way
 * to enable/disable the options in the group.
 *
 * @see FormFieldDef
 * @see IFormGroupsFieldDef
 */
export declare interface IFormBooleanFieldDef extends IFormFieldDef<boolean> {
    fieldType: "boolean" | "fixedBoolean" | "groupBoolean";
}

/**
 * @see FormFieldDef
 */
export declare interface IFormColorEditorFieldDef extends IFormFieldDef<IColorDef> {
    fieldType: "color";
}

declare interface IFormColumnChooserBaseDef<T extends TidyTableColumnSelector | TidyTableColumnSelector[]> extends IFormFieldDef<T> {
    fieldType: "columnsChooser";
    editorConf?: {
        /**
         * The user can select multiple columns / selectors
         */
        multiple?: boolean;
        /**
         * The user can select the same column more than once
         */
        allowDuplicate?: boolean;
        /**
         * Only columns of this/these type(s) are allowed.
         */
        allowedTypes?: TidyColumnsType[];
        /**
         * The user can select properties of columns
         */
        includeProperties?: boolean;
        /**
         * The user can choose a selector, see TidyTableMappingColumnSelectorOptions
         */
        includeSelectors?: boolean;
        /**
         * The user can select columns based on their role
         */
        includeRoles?: boolean;
        /**
         * Search the table for a default column.
         *
         * Set to true to use the default fallback logic:
         *
         *      Fallback to a column that has a type that is allowed. Note, properties of columns are not considered.
         *
         *      It finds the column to fallback on by
         *      1. role equal to fieldPath and type is allowed,
         *      2. role equal to editorConfig.alias and type is allowed,
         *      3. type is allowed.
         *
         *      Already mapped columns are skipped.
         *
         * You can also use your own fallback logic. The currentMapping is the object used when building the mapping
         * from the options meta. It contains the mapped options from metas defined before this meta. Note, the order
         * is important here.
         */
        fallback?: boolean | ((table: ITidyTable, currentMapping: ChartTemplateDataMapping) => ITidyColumn[] | undefined);
        /**
         * In the expression editor, use the alias to reference the column. Use the alias in table.getColumnByAlias(...).
         */
        alias?: string;
    };
}

/**
 * @see FormFieldDef
 *
 * Use the fieldPath to access the column directly in the tidy table with table.getColumnByAlias(...).
 * If multiple columns are in this field, it returns the first column.
 *
 * If the columns chooser is mandatory, the widget or transformation returns an error if there is no column either
 * selected by the user or in the fallback.
 *
 */
export declare type IFormColumnChooserFieldDef = IFormColumnChooserSingleFieldDef | IFormColumnChooserMultipleFieldDef;

export declare type IFormColumnChooserMultipleFieldDef = IFormColumnChooserBaseDef<TidyTableColumnSelector[]>;

export declare type IFormColumnChooserSingleFieldDef = IFormColumnChooserBaseDef<TidyTableColumnSelector>;

/**
 * @see FormFieldDef
 */
export declare interface IFormColumnSelectionFieldDef extends IFormFieldDef<any> {
    fieldType: "columnSelection";
    editorConf: {
        multiple?: boolean;
    };
}

export declare interface IFormConditionalColorRule {
    operator: ConditionalRuleOperators;
    value?: string;
    color?: IColorDef;
}

export declare interface IFormConditionalColorRulesFieldDef extends IFormFieldDef<IFormConditionalColorRule[]> {
    fieldType: "conditionalColorRules";
}

/**
 * @see FormFieldDef
 */
export declare interface IFormConstantsFieldDef extends IFormFieldDef<any> {
    fieldType: "constants";
}

export declare interface IFormEmbeddedFieldDef<T extends FormFieldObject> extends IFormFieldDef<T> {
    fieldType: "embedded";
    editorConf: {
        fieldPathPrefix: string;
        meta: FormFields<T>;
    };
}

export declare interface IFormEventArrayFieldDef extends IFormFieldDef<IFormEventArrayFieldDefType> {
    fieldType: "eventArray";
    arrayField: string;
}

/**
 * @see FormFieldDef
 */
export declare type IFormEventArrayFieldDefType = {
    event: string;
}[];

export declare interface IFormEventMappingArrayFieldDef extends IFormFieldDef<IFormEventMappingArrayFieldDefType> {
    fieldType: "eventMappingArray";
}

/**
 * @see FormFieldDef
 */
export declare type IFormEventMappingArrayFieldDefType = {
    toEvent: string;
    fromEvent: string;
}[];

export declare interface IFormFieldDef<DEFAULT_VALUE_TYPE> {
    /**
     * The path of the field within the edited bean.
     */
    fieldPath: string;
    /**
     * Default: false ,
     *
     * If defaultValue is defined,
     */
    mandatory?: boolean;
    /**
     * The default value defined at field level (note: can be defined at Theme level as well).
     */
    defaultValue?: DEFAULT_VALUE_TYPE;
    /**
     * Override fieldPath to search for a default value in the Theme.
     */
    defaultValuePath?: string;
    /**
     * The optional group a field belongs too
     *
     * @see IFormGroupsFieldDef
     * @see IFormBooleanFieldDef
     */
    group?: string;
    /**
     * When defined, the value is added as a prefix to the fieldPath to define the localization tag.
     */
    fieldPrefixTag?: IFormFieldGroupTypes | string;
    /**
     * When defined, this tag is used for localization
     */
    localizationTag?: string;
    /**
     * Default: "string".
     */
    fieldType: FormFieldType;
    /**
     * Override default localization.
     */
    fieldDescription?: string;
    /**
     * Default: false
     */
    readOnly?: boolean;
    /**
     * An optional field path value. The value of this field depends on the value of the dependsOn field.
     */
    dependsOn?: string | string[];
    /**
     * Clear the field if the value in the depends-on field changes.
     */
    dependsOnReset?: true;
    /**
     * When defined a function that returns the visibility of the field according to the dependsOn value.
     */
    dependsOnVisibility?: boolean | ((dependsOnValue?: any) => boolean);
    valueFromDependsOnValue?: (dependsOnValue?: string) => any;
    /**
     * When defined a function that returns the visibility of the field.
     */
    visibility?: boolean | ((context: IWidgetEditorPublicContext) => boolean);
    /**
     * When defined the content of the field is translated (using context.translateContent).
     *
     * Only works for chart/widgetOptions !!
     */
    translated?: boolean;
    /**
     * Allow for group of fields, disabled help in form wrapper
     */
    disableHelpInWrapper?: boolean;
    onValueSet?: (value: any) => void;
}

/**
 * When selected, include all column info in the selection.
 */
export declare interface IFormFieldGranularityColumns {
    type: "all_columns";
}

export declare type IFormFieldGranularityItem = IFormFieldGranularityItemColumn | IFormFieldGranularityItemRole | IFormFieldGranularityItemHierarchy | IFormFieldGranularityColumns;

export declare interface IFormFieldGranularityItemColumn {
    type: "column";
    /**
     * For selecting columns from the tidy table
     */
    name: string;
}

/**
 * Only include columns info from this hierarchy in the selection.
 */
export declare interface IFormFieldGranularityItemHierarchy {
    type: "hierarchy";
    /**
     * Show in editor.
     */
    caption: string;
    /**
     * Hierarchy for entity items in columns
     */
    hierarchyIdx: number;
}

export declare interface IFormFieldGranularityItemRole {
    type: "role";
    /**
     * For selecting mapping/roles in a chart
     */
    role: string;
}

export declare enum IFormFieldGroupTypes {
    Selection = "groupSelection",
    FilterGeneralOption = "filterGeneralOptionsGroup",
    FilterItem = "filterItemGroup"
}

/**
 * @see FormFieldDef
 */
export declare interface IFormFileUploaderFieldDef extends IFormFieldDef<any> {
    fieldType: "fileUploader";
    editorConf: {
        acceptedFileExt?: string;
        dropMessage: string;
    };
}

/**
 * @see FormFieldDef
 */
export declare interface IFormFilterPanelModelSelectorFieldDef extends IFormFieldDef<string> {
    fieldType: "filterPanelModelSelector";
}

export declare interface IFormFormatterPickerFieldDef extends IFormFieldDef<string> {
    fieldType: "formatterPicker";
}

/**
 * @see FormFieldDef
 */
export declare interface IFormGranularitySelectionFieldDef extends IFormFieldDef<IFormFieldGranularityItem> {
    fieldType: "granularityChooser";
    editorConf: {
        options: (table: ITidyTable) => IFormFieldGranularityItem[];
    };
}

/**
 * Contains the ordering of the groups.
 *
 * An optional (and invisible) field that is defining how the groups are ordered (does not need to contain all
 * the groups). When none defined, the groups order depends on the field order themselves.
 *
 * @see FormFieldDef
 * @see IFormBooleanFieldDef
 */
export declare interface IFormGroupsFieldDef extends IFormFieldDef<string[]> {
    fieldType: "groups";
    groups: string[];
}

/**
 * @see FormFieldDef
 */
export declare interface IFormHookFieldDef<T> extends IFormFieldDef<Hook<T, any>> {
    fieldType: "hook";
}

export declare interface IFormIconFieldSingleDef extends IFormFieldDef<string> {
    fieldType: "icon";
}

/**
 * @see FormFieldDef
 */
export declare interface IFormJsFieldDef extends IFormFieldDef<string> {
    fieldType: "js";
    editorConf?: {
        helpMdFile: string;
        doNotCompleteEventNames?: true;
    };
}

/**
 * @see FormFieldDef
 */
export declare interface IFormJsonFieldDef extends IFormFieldDef<string> {
    fieldType: "json";
    editorConf?: {
        helpMdFile: string;
    };
}

export declare interface IFormLayoutFieldDef extends IFormFieldDef<string> {
    fieldType: "layout";
}

/**
 * @see FormFieldDef
 */
export declare interface IFormMarkdownFieldDef extends IFormFieldDef<string> {
    fieldType: "markdown";
    editorConf?: {
        singleLine: false;
    };
}

/**
 * @see FormFieldDef
 */
export declare interface IFormMaskFieldDef extends IFormFieldDef<number> {
    fieldType: "mask";
    editorConf: {
        items: [number, string][];
        name: string;
    };
}

/**
 * @see FormFieldDef
 */
export declare interface IFormMdxFieldDef extends IFormFieldDef<string> {
    fieldType: "mdxExpression";
    editorConf: {
        mdxExpressionType: MdxExpressionType;
        metaReadOnly?: boolean;
        schemaName?: string;
        cubeName?: string;
    };
}

/**
 * @see FormFieldDef
 */
export declare interface IFormNumberFieldDef extends IFormFieldDef<number> {
    fieldType: "number";
}

/**
 * A string that is chosen from the list of available values (aka. options).
 *
 * Typically used to edit an "enum" where the user can select the value from a list of "localized" options.
 * The editorConf is setup as following:
 * <pre>
 *      editorConf: {
 *          optionValues: Object.values(SortingType),
 *          optionName: "SortingType"                    -- localization purpose
 *      }
 * </pre>
 *
 * This editor is not limited to enum as the editorConf.optionValues is accepting a function resolving the
 * actual list of options as an array of {id,caption} objects. E.g., editing a locale, theme, etc...
 *
 * Editing a list of strings is supported using the editorConf.multiple flag.
 *
 * @see FormFieldDef
 */
export declare type IFormOptionFieldDef = IFormOptionFieldMultipleDef | IFormOptionFieldSingleDef;

export declare interface IFormOptionFieldMultipleDef extends IFormFieldDef<string[]> {
    fieldType: "option";
    editorConf: {
        freeSolo?: boolean;
        multiple: true;
        allowDuplicate?: boolean;
        optionValues?: string[] | IOption[] | ((callback: ((suggestions: string[] | IOption[]) => void), dependsOnValue?: any) => void);
        optionName?: string;
        getCaption?: (id: string) => string;
    };
}

export declare interface IFormOptionFieldReportPathDef extends IFormFieldDef<string> {
    fieldType: "reportPath";
}

export declare interface IFormOptionFieldSingleDef extends IFormFieldDef<string> {
    fieldType: "option";
    editorConf: {
        freeSolo?: boolean;
        multiple?: false;
        allowDuplicate?: boolean;
        optionValues?: string[] | IOption[] | ((callback: ((suggestions: string[] | IOption[]) => void), dependsOnValue?: any) => void);
        optionName?: string;
        getCaption?: (id: string) => string;
    };
}

/**
 * @see FormFieldDef
 */
export declare interface IFormPaletteEditorFieldDef extends IFormFieldDef<IPaletteDef> {
    fieldType: "palette";
    editorConfig?: {
        path: string;
        reversed: boolean;
    };
}

export declare interface IFormPropertyChooserBaseDef extends IFormFieldDef<string> {
    fieldType: "propertyChooser";
    editorConf?: {
        /**
         * Only columns of this/these type(s) are allowed.
         */
        allowedTypes?: TidyColumnsType[];
    };
}

/**
 * @see FormFieldDef
 */
export declare interface IFormReportPathFieldDef extends IFormFieldDef<string> {
    fieldType: "appPath" | "reportFolder" | "reportPath";
}

/**
 * @see FormFieldDef
 */
export declare interface IFormReportPermaLinkFieldDef extends IFormFieldDef<string> {
    fieldType: "reportPermaLink";
}

export declare interface IFormSearchAndReplaceArrayFieldDef extends IFormFieldDef<IFormSearchAndReplaceArrayFieldDefType> {
    fieldType: "searchAndReplaceArray";
}

/**
 * @see FormFieldDef
 */
export declare type IFormSearchAndReplaceArrayFieldDefType = {
    from?: string;
    to?: string;
}[];

export declare interface IFormShortcutChooserDef<T extends string | string[]> extends IFormFieldDef<T> {
    fieldType: "shortcutChooser";
    editorConf?: {
        getOptions: (deps: any, theme: Theme, context: LocalizeContext) => IOption[];
    };
}

/**
 * Use editorConf.suggestions to provide a list of possible values. Then the editor is an autocomplete
 * displaying the suggestions using the freeSolo mode to enter any kind of value.
 *
 * @see FormFieldDef
 */
export declare interface IFormStringFieldDef extends IFormFieldDef<string> {
    fieldType: "string" | "url" | "text";
    editorConf?: {
        /**
         * A list of possible strings...
         */
        suggestions?: string[] | ((callback: ((candidates: string[]) => void), dependsOnValue?: any) => void);
        copyToClipboard?: boolean;
        /**
         * Show an error if the value is not valid. Return an empty string if the value is valid.
         */
        valueValidator?: (value: any) => string;
    };
}

export declare interface IFormTextFieldDef extends IFormFieldDef<string> {
    fieldType: "text";
}

/**
 * A color (i.e., string) expression containing tidy table value accessor (e.g., chart's value axis minimum).
 * The evaluation context is the table.
 *
 * @see FormFieldDef
 */
export declare interface IFormTidyTableColorRowExprFieldDef extends IFormTidyTableExprFieldDef<"tidyTableColorRowExpr"> {
}

declare interface IFormTidyTableExprFieldDef<FIELD_TYPE extends FormFieldType> extends IFormFieldDef<string> {
    fieldType: FIELD_TYPE;
    editorConf?: {
        /**
         * If true, user can use select a column in the dialog editor. This column then is the _currentColumn in the
         * expression when evaluating in the dialog editor.
         */
        userSelectsCurrentColumn?: boolean;
        /**
         * If true, user can use _currentColumn in the expression.
         * The default current column comes from the first dependsOn option.
         */
        useCurrentColumn?: boolean;
        /**
         * Selector for populating the current column in the editor.
         */
        initialCurrentColumn?: TidyTableColumnSelector;
        /**
         * If true, user can use _selectedColumns in the expression.
         * The default selected columns come from the second dependsOn option.
         */
        useSelectedColumns?: boolean;
        /**
         * Set here to override the available columns and roles in the completion meta.
         */
        completionMeta?: string[];
    };
}

/**
 * A Markdown text expression containing tidy table value accessor (e.g., Donut's center text).
 * The evaluation context is the table.
 *
 * @see FormFieldDef
 */
export declare interface IFormTidyTableHtmlExprFieldDef extends IFormTidyTableExprFieldDef<"tidyTableHtmlExpr"> {
}

/**
 * An Markdown text expression containing tidy table value accessor (e.g., chart's tooltip).
 * The evaluation context is a row.
 *
 * @see FormFieldDef
 */
export declare interface IFormTidyTableHtmlRowExprFieldDef extends IFormTidyTableExprFieldDef<"tidyTableHtmlRowExpr"> {
}

/**
 * A numeric expression containing tidy table value accessor (e.g., chart's value axis minimum).
 * The evaluation context is the table.
 *
 * @see FormFieldDef
 */
export declare interface IFormTidyTableNumericExprFieldDef extends IFormTidyTableExprFieldDef<"tidyTableNumericExpr"> {
}

/**
 * A numeric expression containing tidy table value accessor (e.g., chart's value axis minimum).
 * The evaluation context is a column.
 *
 * @see FormFieldDef
 */
export declare interface IFormTidyTableNumericJSColumnExprFieldDef extends IFormTidyTableExprFieldDef<"tidyTableNumericJSColumnExpr"> {
}

/**
 * A numeric expression containing tidy table value accessor (e.g., chart's value axis minimum).
 * The evaluation context is a row.
 *
 * @see FormFieldDef
 */
export declare interface IFormTidyTableNumericRowExprFieldDef extends IFormTidyTableExprFieldDef<"tidyTableNumericRowExpr"> {
}

/**
 * A text expression containing tidy table value accessor (e.g., cell renderer link).
 * The evaluation context is a column.
 *
 * @see FormFieldDef
 */
export declare interface IFormTidyTableNumericStringColumnExprFieldDef extends IFormTidyTableExprFieldDef<"tidyTableNumericStringColumnExpr"> {
}

/**
 * A numeric expression containing tidy table value accessor (e.g., chart's value axis minimum).
 * The evaluation context is a row.
 *
 * @see FormFieldDef
 */
export declare interface IFormTidyTableScaleRowExprFieldDef extends IFormTidyTableExprFieldDef<"tidyTableScaleRowExpr"> {
}

/**
 * A string expression containing tidy table value accessor (e.g., chart's value axis minimum).
 * The evaluation context is the table.
 *
 * @see FormFieldDef
 */
export declare interface IFormTidyTableStringRowExprFieldDef extends IFormTidyTableExprFieldDef<"tidyTableStringRowExpr"> {
}

/**
 * A text expression containing tidy table value accessor (e.g., Donut's center text).
 * The evaluation context is the table.
 *
 * @see FormFieldDef
 */
export declare interface IFormTidyTableTextExprFieldDef extends IFormTidyTableExprFieldDef<"tidyTableTextExpr"> {
}

/**
 * A text expression containing tidy table value accessor (e.g., cell renderer link).
 * The evaluation context is a row.
 *
 * @see FormFieldDef
 */
export declare interface IFormTidyTableTextRowExprFieldDef extends IFormTidyTableExprFieldDef<"tidyTableTextRowExpr"> {
}

/**
 * icCube variants (defined in the theme's ic3.widgetVariants).
 *
 * @see FormFieldDef
 */
export declare interface IFormWidgetVariantFieldDef extends IFormFieldDef<string> {
    fieldType: "widgetVariant";
    editorConf?: {
        componentName: string;
        predefinedVariants?: string[];
    };
}

/**
 * From icCube server print component configuration.
 */
export declare interface IKnownPageSize extends IPageSize {
    type: "known";
    name: string;
}

export declare interface ILazyTreeViewLoader {
    /**
     * This will build the tree with react children
     */
    mapTree<T>(expanded: (index: number) => boolean, factory: (index: number, isCollapsed: boolean) => T, filter?: (info: MdxInfo) => boolean): T[];
    /**
     * Returns true if and only if the node has children that are to be lazilly loaded.
     */
    hasLazyChildren(index: number): boolean;
    /**
     * Returns true if and only if the node has children in the already loaded data.
     */
    hasChildren(index: number): boolean;
    getColumnLevelDepth(index: number): number;
    lazyLoadChildren(index: number): void | number;
    getNodeIdAndCaption(index: number): [string, string];
    getNodeId(index: number): string;
    getItemCount(): number;
    setCallbackOnChange(callback: () => void): void;
    toEntityItems(nodeIds: string[]): EntityItem[];
    mapNodeIds<T>(nodeIds: string[], callbackfn: (columnIdx: number) => T | null | undefined): T[];
    map<T>(callback: (index: number) => T | undefined): T[];
}

export declare interface ILocalizationContext {
    localizeDescription(...args: any[]): string;
    localizeDescriptionEx<T extends FormFieldObject>(context: ILocalizationContext, fieldMeta: FormFieldDef[] | FormFields<T>, persistentOption: T, ...fields: (keyof T)[]): string;
    localize(name: string, ...args: any[]): string;
}

export declare interface ILocalizationManager {
    registerLocalization(data: string): void;
}

/**
 * Image Options (fields of the "Chart" tab in the widget editor).
 *
 * <pre>
 *      Plugin ID         : ic3
 *      Widget/Template ID: Image
 * </pre>
 *
 * @see WidgetTemplateChartOptions
 */
export declare interface ImageChartOptions extends FormFieldObject {
    /**
     * URL.
     *
     * An absolute or relative URL.
     */
    urlToImage: string;
    /**
     * Resize the image, read more here, https://www.w3schools.com/css/css3_object-fit.asp.
     */
    resizeImage: ImageResizingOptions;
}

export declare enum ImageResizingOptions {
    NONE = "none",
    FILL = "fill",
    CONTAIN = "contain",
    COVER = "cover",
    SCALE_DOWN = "scale-down"
}

export declare interface IManualPageSize extends IPageSize {
    type: "manual";
    pageSizeUnits: PaperSizeUnits;
    pageWidth: number;
    pageHeight: number;
}

export declare interface IMdxAxisSeriesInfo {
    hierarchyName?: string;
    hierarchyUN?: string;
    hierarchyType?: string;
    /**
     * A single level name is being specified in the guts for all the axis values.
     */
    levelUN?: string;
    levelName?: string;
    levelCaption?: string;
    levelType?: MdxLevelType;
    levelSubType?: MdxLevelSubType;
    /**
     * The unique name of the default member of the dimension.
     */
    defaultMemberUN?: string;
    defaultMemberName?: string;
    defaultMemberCaption?: string;
    defaultMemberKey?: string;
}

export declare interface IMigrationManager {
    registerLayoutConfigId(from: string, to: string): void;
    registerTemplateId(from: string, to: string): void;
}

export declare enum InitialDateFrom {
    MANUAL_DATES = "manual",
    SHORTCUT = "shortcut"
}

export declare interface InitializeSelectionAllWidgetsNotification extends IAppNotification {
    readonly type: "initialize-selection-all-widgets";
}

export declare interface INoSchemaRendererOptions {
    missingSchema: string;
}

export declare enum InterpolationAppliedTo {
    COLUMNS = "COLUMNS",
    ROWS = "ROWS",
    TABLE = "TABLE"
}

export declare enum InterpolationType {
    NONE = "none",
    RGB = "rgb",
    HCL = "hcl",
    HSL = "hsl",
    LAB = "lab"
}

export declare interface IOption {
    id: string;
    caption: string;
}

export declare interface IPageHeaderFooterContentDefinition {
    /**
     * Used for formatting @dateTime variable
     */
    dateTimeFormat: string;
    /**
     * Used for formatting @date variable
     */
    dateFormat: string;
    /**
     * Used for formatting @time variable
     */
    timeFormat: string;
    text: string;
    style?: CSSProperties;
    align?: 'inherit' | 'left' | 'center' | 'right' | 'justify';
    color?: string;
    variant?: string;
}

export declare interface IPageHeaderFooterDefinition {
    sizeUnits: PaperSizeUnits;
    height: number;
    style?: CSSProperties;
    left?: IPageHeaderFooterPartDefinition;
    center?: IPageHeaderFooterPartDefinition;
    right?: IPageHeaderFooterPartDefinition;
    printOnly?: true;
}

export declare interface IPageHeaderFooterLogoDefinition {
    style?: CSSProperties;
    src: string;
}

export declare interface IPageHeaderFooterPartDefinition {
    style?: CSSProperties;
    /**
     * Available variables:
     *
     * <pre>
     *      @pageNb
     *      @pageCount
     *      @reportName
     *
     *      @dateTime
     *      @date
     *      @time
     * </pre>
     */
    content?: IPageHeaderFooterContentDefinition;
    logo?: IPageHeaderFooterLogoDefinition;
}

export declare interface IPageMargin {
    sizeUnits: PaperSizeUnits;
    top: number;
    bottom: number;
    left: number;
    right: number;
}

export declare interface IPageSize {
    type: PageSize;
}

export declare interface IPaletteDef {
    /**
     * aka. name
     */
    path: string;
    reversed: boolean;
}

export declare type IPGFilterItemFilterType = TextFilterType | "IS_ANY_OF" | "IS_NONE_OF" | "GREATER_THAN" | "GREATER_EQUAL_THAN" | "SMALLER_THAN" | "SMALLER_EQUAL_THAN" | "BETWEEN" | "IS_EMPTY" | "IS_NOT_EMPTY";

export declare interface IPluginDefinition {
    /**
     * Keep that id simple (i.e., ASCII letter without any dot, space, separator, etc...) as it will be used
     * as a folder name (once deployed into an icCube server), Webpack module name, localization id, etc...
     *
     * That name must be unique across all the plugins loaded into an icCube server.
     */
    id: string;
    /**
     * When defining new widgets using amCharts 4, this method registers the icCube license.
     */
    registerAmCharts4?: (logger: ILogger, callback: (am4core: any) => void) => void;
    registerMigrator?: (logger: ILogger, manager: IMigrationManager) => void;
    registerLocalization?: (logger: ILogger, manager: ILocalizationManager) => void;
    registerUserMenuOptions?: (logger: ILogger, manager: IUserMenuOptionManager) => void;
    registerThemes?: (logger: ILogger, manager: IThemeManager) => void;
    registerWidgets?: (logger: ILogger, manager: IWidgetManager) => void;
    registerTidyTableTransformations?: (logger: ILogger, manager: ITidyTableTransformationManager) => void;
    /**
     * Register widget defaults for all themes.
     */
    registerWidgetDefaults?: (logger: ILogger, theme: Theme, manager: IWidgetDefaultsManager) => void;
    /**
     * Allows for selecting the available widgets.
     *
     * @param id pluginId.widgetId (e.g., ic3.Table)
     */
    acceptWidget?: (id: WidgetTemplateIDs | string, widget: IPublicWidgetTemplateDefinition<FormFieldObject>) => boolean;
}

/**
 * Definition - static - of a widget template
 */
declare interface IPublicCommonWidgetTemplateDefinition<OPTIONS extends FormFieldObject> {
    /**
     * [BETA]
     *
     * Introduced to tag a template as part of the AI [BETA] features.
     * Currently used to filter out the template when AI not enabled.
     */
    ai?: true;
    /**
     * Used for finding the right documentation of `typeForHelp` is not defined.
     * Determine the widget icon in the widget infos.
     */
    type: WidgetTemplateDefinitionType;
    /**
     * Used for finding the right documentation (override `type`).
     */
    typeForHelp?: WidgetTemplateDefinitionType;
    /**
     * Unique within the plugin. Must not contain any dot (this is NOT the templateId)
     *
     * The widget chooser is using that id to localize its name and description.
     *
     * <pre>
     *     plugin-id.id.$caption, ...
     *     plugin-id.id.$caption.description, ...
     * </pre>
     */
    id: string;
    /**
     * Internal usage: while investigating lazy registration (setup upon registration).
     */
    debug?: string;
    /**
     * Internal usage: the wrapped pluginId.templateId (setup upon registration).
     */
    wrapped?: string;
    /**
     * Internal usage: pluginId.templateId (setup upon registration).
     */
    qualifiedId?: string;
    /**
     * Internal usage: pluginId (setup upon registration).
     */
    pluginId?: string;
    /**
     * Used for localization right now.
     *
     * The widget chooser is using that id to localize its name.
     *
     * <pre>
     *     plugin-id.$groupId, ...
     * </pre>
     *
     * Should you like to reuse an existing group, localize the group using an existing one:
     *
     * <pre>
     *     MyPlugin.$myMaps, Maps
     * </pre>
     *
     * then widgets defined ih the group "myMaps" of the plugin whose id=MyPlugin will be shown
     * in the "Maps" group in the widget chooser.
     */
    groupId: string;
    /**
     * A way to ensure we do not display in the widget chooser templates that cannot
     * be used because the rendering depends on a given theme.
     */
    dependsOnTheme?: string;
    /**
     * A sort of "preview" of the widget in the widget chooser. Providing an empty string will display a default image.
     *
     * <pre>
     *     import donut from "./images/donut.svg";
     *
     *     {
     *          image: "donut",
     *     }
     * </pre>
     */
    image: string;
    /**
     * No widget box decoration.
     */
    noDecoration?: boolean;
    /**
     * No widget *** box *** header (aka. title) is rendered. This widget template is taking care of it.
     */
    withoutHeader?: boolean;
    /**
     * No title is being edited/rendered.
     */
    withoutTitle?: boolean;
    /**
     * This widget does not require any query for rendering.
     */
    withoutQuery?: boolean;
    withoutSelection?: boolean;
    withoutInitialSelection?: boolean;
    withoutDrilldown?: boolean;
    withoutEvents?: boolean;
    withoutUserMenu?: boolean;
    withoutGlobalFilter?: boolean;
    /**
     * Otherwise the widget box is rendering a floating icon to mention some data errors.
     */
    handleCellsOnError?: boolean;
    renderIfNotInViewport?: boolean;
    /**
     * This widget needs to render even if its query has not been executed yet. The default is false.
     */
    renderIfQueryNotExecuted?: boolean;
    /**
     * Whether or not this widget can expand vertically according to its actual data
     * (e.g., table, repetition widget).
     */
    withOptionAutoExpand?: boolean;
    /**
     * When auto-expand applies and the layout is multi-page, this options controls whether the table
     * header is repeating on each page.
     */
    withOptionAutoExpandKeepTableHeader?: boolean;
    withOptionAutoExpandHeightNotDependingOnWidth?: boolean;
    /**
     * If and only if not null, hide option 'Interactions' > 'Drilldown' > 'Pivot Table Like' and set it default value to withDrilldownPivotTableLikeAs.
     */
    withDrilldownPivotTableLikeAs?: boolean;
    /**
     * Extra options for in the widgets user menu when in viewer mode.
     */
    userMenuOptions?: string[];
    /**
     * Additional widget user menu options when in editing mode.
     */
    userMenuOptionsOnEditing?: string[];
    /**
     * Disables the user menu option to switch between selection and drilldown
     *
     * E.g a Pivot table can manage both modes
     */
    userMenuDisableInteractionMode?: boolean;
    /**
     * This widget knows how to render a result without any data.
     */
    handlesNoData?: boolean;
    /**
     * This widget knows how to render when it has an empty query result.
     */
    handlesEmptyQuery?: boolean;
    /**
     * When the widget is just created, it shows an edit widget button. Set true here to show the widget instead.
     */
    canRenderWithoutUserConfig?: boolean;
    /**
     * This widget is responsible to notify its rendered status. Required with asynchronous rendering
     * (e.g., Google maps).
     *
     * @see IWidgetPublicContext#onWidgetRenderStatusChange
     */
    handlesWidgetStatus?: boolean;
    eventRoles?: ITemplateEventActionDef;
    selection?: {
        /**
         * The default selection granularity.
         */
        defaultGranularityItems?: IFormFieldGranularityItem[];
        /**
         * The list of columns/roles that can be part of the selection granularity. The granularity editor shows
         * when there are 2 or more roles.
         */
        granularityItems?: (table: ITidyTable) => IFormFieldGranularityItem[];
    };
    mdxBuilderSettings?: IWidgetTemplateMdxBuilderMapping;
    /**
     * Setup how to get default mappings from the table and options for this widget.
     * If undefined, it uses the default fallback logic.
     *
     * Note, the mapping keys must be in lower case.
     */
    defaultMapping?: (data: IWidgetTemplateTidyOptions<OPTIONS>) => ChartTemplateDataMapping;
    /**
     * The meta information required for editing the widget options.
     */
    chartOptionsMeta?: FormFields<OPTIONS>;
    /**
     * An optional hook that allows for modifying the chart options passed as parameter.
     * Used when extending existing widget definition.
     */
    hookChartOptions?: (options: any) => any;
    /**
     * When registering a variant add the following field editor meta:
     * <pre>
     * widgetVariant: {
     *    fieldType: "widgetVariant",
     *    localizationTag: "variant"   // icCube localization,
     * },
     * </pre>
     */
    registerVariants?: (theme: Theme, manager: IWidgetVariantManager) => void;
    /**
     * e.g., amCharts4.
     * */
    lazyLibs?: string;
    /**
     * Whether or not that component is using React for rendering.
     */
    reactComponent?: boolean;
    /**
     * Only the widget template meta information is required when starting the application.
     *
     * This method gives the opportunity for a widget template to load (Webpack) its actual jsCode logic when required.
     * For example, AmCharts 4 widgets are loading the AmCharts 4 actual JS libraries once their rendering is actually
     * required.
     *
     * @param definitionW a resolved wrapped widget (extending widget).
     */
    resolveDefinition?: (definitionW?: IPublicWidgetTemplateDefinition<any>) => Promise<IPublicWidgetTemplateDefinition<OPTIONS>>;
    /**
     * When defining new widgets using amCharts 4, this method registers the icCube license.
     */
    registerAmCharts4?: (logger: ILogger, callback: (am4core: any) => void) => void;
    /**
     * When opening "Use Global Filter" option on Interaction tab
     */
    enableUseGlobalFilter?: boolean;
    /**
     *  Returns true if the widget fires a global event at initialization (start)
     */
    firesGlobalEventAtStart?: (options: OPTIONS | undefined, templateDef: IPublicWidgetTemplateDefinition<OPTIONS>) => boolean;
    /**
     * Limit on the rows of the tidy result to both prevent the server and the browser to process
     * too many items. Set to -1 to have no limit. Note that the server side is defining a limit as well.
     * See icCube/help?ic3topic=dashboards.gettingstarted.Configuration for more details.
     *
     * Note: can be overridden via Dashboards options (ic3report-config.js).
     */
    maxTidyRowCount?: number;
    /**
     * List of supported types of query.
     *
     * Defaults: all of them.
     */
    withQueryTypes?: QueryType[];
    /**
     * Change the data to show when the user presses show-data from the widget menu.
     * @param ownProps
     */
    getShowHideDataTable?: (table: ITidyTable | undefined, options: OPTIONS, ownProps: any, theme: Theme) => ITidyTable | undefined;
    /**
     * For lazy filters or widgets with selection do not clean initial Selection based on initial tidy table
     */
    doNotCleanSelectionOnInitialProps?: true;
}

export declare interface IPublicContext {
    logger(): ILogger;
    /**
     * It is the reporting console.
     */
    isAppConsole(): boolean;
    /**
     * It is the dashboard viewer.
     */
    isAppReportViewer(): boolean;
    /**
     * Is an application in viewer mode.
     */
    isAppReportAppViewer(): boolean;
    /**
     * Is an application or dashboard in viewer mode.
     */
    isAppViewer(): boolean;
    /**
     * It is the dashboard editor.
     */
    isAppReportEditor(): boolean;
    /**
     * It is the dashboard editor with the dashboard in preview mode.
     */
    isAppReportEditorPreview(): boolean;
    /**
     * It is the application editor.
     */
    isAppReportAppEditor(): boolean;
    /**
     * It is the gadget editor.
     */
    isAppGadgetEditor(): boolean;
    /**
     * React, returns true when loaded
     */
    useGoogleMapHook(): boolean | Error;
    getTheme(): Theme;
    /**
     * Return the formatter for the current user's locale.
     */
    getThemeFormatter(): ThemeFormatters;
    getUserName(): string;
    getReportName(): string;
    getReportPath(): string;
    getReportFolderName(): string;
    getReportLocale(): string;
    /**
     * @param format Formatter. Defaults to `defaultNumber` from the theme.
     */
    getNumberFormatter(format: ThemeTextFormatter | null | undefined): (value: any | undefined) => string;
    /**
     * @param format Formatter. Defaults to `defaultDate` or `defaultDatetime` from the theme.
     */
    getDateFormatter(format: ThemeTextFormatter | null | undefined): (value: any | undefined) => string;
    /**
     * translate the content of a report (the title of widgets, content of some widgets...). This does use another file
     *
     * aka content localization
     */
    translateContent(content: string, ...args: any[]): string;
    /**
     * localized report application tags (e.g. edit, write, save.. )
     */
    localize(name: string, ...args: any[]): string;
    /**
     * localized report application error tags
     */
    localizeError(name: string, ...args: any[]): string;
    /**
     * Localization for transformations
     */
    localizeTransformationCaption(template: ITidyTableTransformation<any>): {
        info: string;
        description?: string;
    };
    localizeFormField(pluginId: string, widgetTemplateId: string, name: string, ...args: any[]): [string, string | undefined, string | undefined];
    /**
     * markdown to sanitized html
     */
    markdownToHtml(markDown: string): string;
    /**
     * A bunch of mathematical functions related to the tidy table.
     */
    tidyMath(): ITidyMath;
    /**
     * Create an expression from a field.
     *
     * @param expression typically coming from a widget field so it cannot be null if there is a default value.
     * To prevent usage of the default, pass a string with a single space to make this method return undefined.
     * @param selectedColumns get the row of these columns using `_rowOfSelectedColumns` or `_selectedColumns`.
     * @param isRowSelected function for usage with `totalSelectedOrTotal`. Use tableInter.isSelected(rowIdx).
     */
    createExpression<T extends FormFieldTidyTableExprType>(fieldType: T, field: string, table: ITidyTable, currentColumn: ITidyColumn | undefined, expression: string | undefined, selectedColumns: ITidyColumn[] | undefined, isRowSelected?: TidyRowFilter): T extends "tidyTableColorRowExpr" | "tidyTableScaleRowExpr" | "tidyTableHtmlRowExpr" | "tidyTableNumericRowExpr" | "tidyTableStringRowExpr" | "tidyTableTextRowExpr" ? ((rowIdx: number) => string) | undefined : (() => string) | undefined;
    /**
     * Not in widget public context because of transformation not applied from a widget context always.
     *
     * @param expression typically coming from a widget field so it cannot be null if there is a default value.
     * To prevent usage of the default, pass an "empty" string that makes this method returns
     * undefined.
     * @param selectedColumns get the row of these columns using `_rowOfSelectedColumns` or `_selectedColumns`.
     * @param isRowSelected function for usage with `totalSelectedOrTotal`. Use tableInter.isSelected(rowIdx).
     *
     * @deprecated will be removed in version >=9.1.0. Use `createExpression` instead.
     */
    createTableRowTextExpr(field: string, table: ITidyTable, currentColumn: ITidyColumn | undefined, expression: string | undefined, selectedColumns: ITidyColumn[] | undefined, isRowSelected?: TidyRowFilter): ((rowIdx: number) => string) | undefined;
    /**
     * Not in widget public context because of transformation not applied from a widget context always.
     *
     * @param expression typically coming from a widget field so it cannot be null if there is a default value.
     * To prevent usage of the default, pass an "empty" string that makes this method returns
     * undefined.
     * @param isRowSelected function for usage with `totalSelectedOrTotal`. Use tableInter.isSelected(rowIdx).
     *
     * @deprecated will be removed in version >=9.1.0. Use `createExpression` instead.
     */
    createTableTextExpr(field: string, table: ITidyTable, currentColumn: ITidyColumn | undefined, expression: string | undefined, isRowSelected?: TidyRowFilter): (() => string) | undefined;
    /**
     * Not in widget public context because of transformation not applied from a widget context always.
     *
     * @param expression typically coming from a widget field so it cannot be null if there is a default value.
     * To prevent usage of the default, pass an "empty" string that makes this method returns
     * undefined.
     * @param selectedColumns get the row of these columns using `_rowOfSelectedColumns` or `_selectedColumns`.
     * @param isRowSelected function for usage with `totalSelectedOrTotal`. Use tableInter.isSelected(rowIdx).
     *
     * @deprecated will be removed in version >=9.1.0. Use `createExpression` instead.
     */
    createTableRowMarkdownExpr(field: string, table: ITidyTable, currentColumn: ITidyColumn | undefined, expression: string | undefined, selectedColumns: ITidyColumn[] | undefined, isRowSelected?: TidyRowFilter): ((rowIdx: number) => string) | undefined;
    /**
     * Not in widget public context because of transformation not applied from a widget context always.
     *
     * @param expression typically coming from a widget field so it cannot be null if there is a default value.
     * To prevent usage of the default, pass an "empty" string that makes this method returns
     * undefined.
     * @param selectedColumns get the row of these columns using `_rowOfSelectedColumns` or `_selectedColumns`.
     * @param isRowSelected function for usage with `totalSelectedOrTotal`. Use tableInter.isSelected(rowIdx).
     *
     * @deprecated will be removed in version >=9.1.0. Use `createExpression` instead.
     */
    createTableMarkdownExpr(field: string, table: ITidyTable, currentColumn: ITidyColumn | undefined, expression: string | undefined, selectedColumns: ITidyColumn[] | undefined, isRowSelected?: TidyRowFilter): (() => string) | undefined;
    /**
     * Not in widget public context because of transformation not applied from a widget context always.
     *
     * @param expression typically coming from a widget field so it cannot be null if there is a default value.
     * To prevent usage of the default, pass an "empty" string that makes this method returns
     * undefined.
     * @param selectedColumns get the row of these columns using `_rowOfSelectedColumns` or `_selectedColumns`.
     * @param isRowSelected function for usage with `totalSelectedOrTotal`. Use tableInter.isSelected(rowIdx).
     *
     * @deprecated will be removed in version >=9.1.0. Use `createExpression` instead.
     */
    createTableRowNumericExpr(field: string, table: ITidyTable, currentColumn: ITidyColumn | undefined, expression: string | undefined, selectedColumns: ITidyColumn[] | undefined, isRowSelected?: TidyRowFilter): ((rowIdx: number) => number | undefined) | undefined;
    /**
     * same as  createTableRowNumericExpr but returning a string
     * @param selectedColumns get the row of these columns using `_rowOfSelectedColumns` or `_selectedColumns`.
     * @param isRowSelected function for usage with `totalSelectedOrTotal`. Use tableInter.isSelected(rowIdx).
     *
     * @deprecated will be removed in version >=9.1.0. Use `createExpression` instead.
     */
    createTableRowNumericStringExpr(field: string, table: ITidyTable, currentColumn: ITidyColumn | undefined, expression: string | undefined, selectedColumns: ITidyColumn[] | undefined, isRowSelected?: TidyRowFilter): ((rowIdx: number) => string | undefined) | undefined;
    /**
     * @param selectedColumns get the row of these columns using `_rowOfSelectedColumns` or `_selectedColumns`.
     * @param isRowSelected function for usage with `totalSelectedOrTotal`. Use tableInter.isSelected(rowIdx).
     *
     * @deprecated will be removed in version >=9.1.0. Use `createExpression` instead.
     */
    createTableScaleRowNumericExpr(field: string, table: ITidyTable, currentColumn: ITidyColumn | undefined, expression: string | undefined, selectedColumns: ITidyColumn[] | undefined, isRowSelected?: TidyRowFilter): ((rowIdx: number) => number | undefined) | undefined;
    /**
     * Not in widget public context because of transformation not applied from a widget context always.
     *
     * @param expression typically coming from a widget field so it cannot be null if there is a default value.
     * To prevent usage of the default, pass an "empty" string that makes this method returns
     * undefined.
     * @param selectedColumns get the row of these columns using `_rowOfSelectedColumns` or `_selectedColumns`.
     * @param isRowSelected function for usage with `totalSelectedOrTotal`. Use tableInter.isSelected(rowIdx).
     *
     * @deprecated will be removed in version >=9.1.0. Use `createExpression` instead.
     */
    createTableNumericExpr(field: string, table: ITidyTable, currentColumn: ITidyColumn | undefined, expression: string | undefined, selectedColumns: ITidyColumn[] | undefined, isRowSelected?: TidyRowFilter): (() => number | undefined) | undefined;
    /**
     * same as  createTableNumericExpr but returning a javascript object
     *
     * @deprecated will be removed in version >=9.1.0. Use `createExpression` instead.
     */
    createTableNumericStringExpr(field: string, table: ITidyTable, currentColumn: ITidyColumn | undefined, expression: string | undefined, selectedColumns: ITidyColumn[] | undefined, isRowSelected?: TidyRowFilter): (() => any | undefined) | undefined;
    /**
     * same as  createTableNumericExpr but returning a javascript object
     *
     * @deprecated will be removed in version >=9.1.0. Use `createExpression` instead.
     */
    createTableNumericJSExpr(field: string, table: ITidyTable, currentColumn: ITidyColumn | undefined, expression: string | undefined, selectedColumns: ITidyColumn[] | undefined, isRowSelected?: TidyRowFilter): (() => any | undefined) | undefined;
    /**
     * Event methods that do not depend on a Table
     *
     * @see ITidyTableInteractionEvent for more
     */
    /**
     * actionName if the action is bound to a channel, clears the event (has no value)
     */
    fireClearEventName(actionName: string): void;
    /**
     * actionName if the action is bound to a channel, send an Mdx Event (value,mdx)
     */
    fireMdxEventName(actionName: string, value: string, mdx: string): void;
    /**
     * Used for publishing app notifications (e.g., print the report).
     */
    fireAppNotification(notification: AppNotification): void;
    formatDate(value: Date | string | undefined | null, format: ThemeTextFormatter | null | undefined, locale?: string): string;
    formatNumber(value: number | string | undefined | null, format: ThemeTextFormatter | null | undefined, locale?: string): string;
    /**
     * A shortcut for formatNumber( theme.formatter.defaultNumber )
     */
    formatAmount(value: number | string | undefined | null, locale?: string): string;
    /**
     * A shortcut for formatNumber( theme.formatter.defaultPercent )
     */
    formatPercent(value: number | string | undefined | null, locale?: string): string;
}

export declare interface IPublicErrorDefinition {
    /**
     * e.g. a user defined javascript error vs a programming error
     */
    expected?: boolean;
    name: string;
    args?: any[];
    cause?: any;
}

/**
 * A widget that renders using plain JavaScript/TypeScript.
 *
 * @see FormFieldObject
 */
export declare interface IPublicJsChartTemplate<T extends FormFieldObject> {
    /**
     * @param data the actual result of the widget's query
     * @param options the options (possibly edited and/or from the theme) of this widget
     * @param header aka. widget title
     */
    renderJS: (data: IWidgetTemplateTidyData, options: T, header: string) => void;
    renderOnResizeJS?: (data: IWidgetTemplateTidyData, options: T, header: string, info: IWidgetLayoutInfo) => void;
    dispose: () => void;
}

/**
 * A widget that renders using React.
 *
 * @see FormFieldObject
 */
export declare interface IPublicReactChartTemplate<T extends FormFieldObject> {
    /**
     * @param data the actual result of the widget's query
     * @param options the options (possibly edited and/or from the theme) of this widget
     * @param header aka. widget title
     */
    reactElement: (data: IWidgetTemplateTidyData, options: T, header: string) => ReactElement;
}

export declare interface IPublicWidgetBoxSettings {
    widgetId: string;
    waitingEventOrResult?: string;
    emptyResult?: string;
}

/**
 * The definition of a widget that renders using plain JavaScript/TypeScript.
 *
 * @see IPublicJsChartTemplate
 * @see FormFieldObject
 */
export declare interface IPublicWidgetJsTemplateDefinition<OPTIONS extends FormFieldObject> extends IPublicCommonWidgetTemplateDefinition<OPTIONS> {
    /**
     * Actual widget rendering logic.
     */
    jsCode: (context: IWidgetPublicContext, container: HTMLDivElement) => IPublicJsChartTemplate<OPTIONS>;
    reactComponent?: false;
    /**
     * Only the widget template meta information is required when starting the application.
     *
     * This method gives the opportunity for a widget template to load (Webpack) its actual jsCode logic when required.
     * For example, AmCharts 4 widgets are loading the AmCharts 4 actual JS libraries once their rendering is actually
     * required.
     *
     * @param definitionW a resolved wrapped widget (extending widget).
     */
    resolveDefinition?: (definitionW?: IPublicWidgetTemplateDefinition<any>) => Promise<IPublicWidgetTemplateDefinition<OPTIONS>>;
}

export declare interface IPublicWidgetReactMdxResultOnErrorProps {
    error: IPublicErrorDefinition;
}

export declare interface IPublicWidgetReactProps<OPTIONS> {
    wContext: IWidgetPublicContext;
    data: IWidgetTemplateTidyData;
    options: OPTIONS;
    widgetHeader: string;
}

/**
 *
 *
 * @see IPublicReactChartTemplate
 * @see FormFieldObject
 */
export declare interface IPublicWidgetReactTemplateDefinition<OPTIONS extends FormFieldObject> extends IPublicCommonWidgetTemplateDefinition<OPTIONS> {
    /**
     * Deprecated: use reactEl instead.
     */
    jsCode?: (context: IWidgetPublicContext) => IPublicReactChartTemplate<OPTIONS>;
    /**
     * The React Hook component  (function with props as parameter)
     */
    reactEl?: React.FunctionComponent<IPublicWidgetReactProps<OPTIONS>>;
    reactElMdxResultOnError?: React.FunctionComponent<IPublicWidgetReactMdxResultOnErrorProps>;
    reactComponent: true;
    /**
     * Only the widget template meta information is required when starting the application.
     *
     * This method gives the opportunity for a widget template to load (Webpack) its actual jsCode logic when required.
     * For example, AmCharts 4 widgets are loading the AmCharts 4 actual JS libraries once their rendering is actually
     * required.
     *
     * @param definitionW a resolved wrapped widget (extending widget).
     */
    resolveDefinition?: (definitionW?: IPublicWidgetTemplateDefinition<any>) => Promise<IPublicWidgetTemplateDefinition<OPTIONS>>;
}

export declare type IPublicWidgetTemplateDefinition<T extends FormFieldObject> = IPublicWidgetReactTemplateDefinition<T> | IPublicWidgetJsTemplateDefinition<T>;

export declare interface IRectangle extends IRectanglePosition, IRectangleSize {
}

export declare interface IRectanglePosition {
    top: number;
    left: number;
}

export declare interface IRectangleSize {
    height: number;
    width: number;
}

export declare interface IRemotePluginName {
    url: string;
    scope: string;
    module: string;
}

export declare interface IResponsiveBreakpoint {
    md: number;
    xs: number;
}

export declare interface IScriptCallback {
    onSuccess: () => void;
    onError: (event: Event | string, source?: string, lineno?: number, colno?: number, error?: Error) => void;
}

export declare interface ISeriesValues {
    type: ISeriesValuesType;
    /**
     * Value column.
     * @see {PublicAmchartsData.TAG_VALUE}.
     */
    values: ITidyColumn;
    /**
     * Color column.
     * @see {PublicAmchartsData.TAG_COLOR}.
     */
    colors?: ITidyColorColumn;
    /**
     * Extra values.
     * @see {PublicAmchartsData.TAG_ADDITIONAL_VALUE}.
     */
    additionalValues?: ITidyColumn;
    parentValueColIdx?: number;
}

export declare enum ISeriesValuesType {
    LINE = 0,
    COLUMN = 1,
    TREND = 2,
    DIVERGENT = 3,
    LEFT_SERIES = 4,
    RIGHT_SERIES = 5
}

declare interface IShortcut<D, T> {
    /**
     * Show this name in the datepicker.
     *
     * Localize depending on the anchor date:
     * — if undefined, Translate with `shortcutItemsDatePicker.<name>` in the localization.
     * — if present, Translate with `shortcutItemsDatePicker.<name>.$anchor` in the localization. Fallback to translation with no anchor.
     */
    name: string;
    /**
     * Return the range of the dates that this shortcut selects. The date to return should be of type
     * Dayjs. See the `dayjs` library. Return `null` to clear the start/end value.
     *
     * A datepicker shortcut returns the date. Return null to reset the date.
     *
     * A range picker shortcut returns a range: [startDate (included), endDate (included)]. Return [null, null] to reset
     * the date.
     *
     * If the date returned is outside the allowed range of dates in the widget, then the datepicker disables the
     * option.
     */
    getValue: (util: PublicDateShortcutUtils<D>) => T;
    /**
     * If an anchor date is defined, then this shortcut will show.
     * — true: only show the shortcut when there is an anchor date.
     * — false: do not show this shortcut when there is an anchor date.
     * — undefined: always show the shortcut.
     */
    needsAnchor?: boolean;
}

export declare function isThemeFormatterPerLocale(x: DeepPartial<ThemeFormatterPerLocale | ThemeFormatters> | undefined): x is ThemeFormatterPerLocale;

export declare function isTidyTableExpr(type: FormFieldType): type is FormFieldTidyTableExprType;

export declare function isTidyTableExprColumn(type: FormFieldType): boolean;

export declare function isTidyTableExprJS(type: FormFieldType): boolean;

export declare function isTidyTableExprNumeric(type: FormFieldType): type is "tidyTableNumericExpr" | "tidyTableNumericRowExpr";

export declare function isTidyTableExprNumericJS(type: FormFieldType): type is "tidyTableNumericJSColumnExpr";

export declare function isTidyTableExprNumericString(type: FormFieldType): type is "tidyTableColorRowExpr" | "tidyTableStringRowExpr" | "tidyTableNumericStringColumnExpr";

export declare function isTidyTableExprRow(type: FormFieldType): boolean;

export declare function isTidyTableExprScale(type: FormFieldType): type is "tidyTableScaleRowExpr";

export declare function isTidyTableExprTable(type: FormFieldType): type is "tidyTableHtmlExpr" | "tidyTableNumericExpr" | "tidyTableTextExpr";

export declare function isTidyTableExprText(type: FormFieldType): type is "tidyTableTextExpr" | "tidyTableTextRowExpr";

export declare function isTidyTableExprTextHtml(type: FormFieldType): type is "tidyTableHtmlExpr" | "tidyTableHtmlRowExpr";

export declare interface IStrokeStyleProperties extends FormFieldObject {
    /**
     * Stroke color of the border.
     */
    itemStrokeFill?: string;
    /**
     * Width of the border.
     */
    itemStrokeWidth: number;
    /**
     * Opacity of the border.
     */
    itemStrokeOpacity: number;
}

/**
 *
 * Definition of the actions supported by a template
 *
 *
 * ( e.g., publish: 'onClick'  )
 */
export declare interface ITemplateEventActionDef {
    /**
     *  The actions publishing to a channel
     */
    publish?: string[];
    /**
     *  The actions subscribing to a channel  (only new events value are sent, state change)
     */
    subscribe?: string[];
    /**
     *  The actions being notified by a channel  (on each new event generated)
     */
    notify?: string[];
    /**
     * The actions publishing to the 'selection' channel (it's internally managed by TidyTableInteraction)
     */
    selectionPublish?: string;
    /**
     * The actions subscribing to the 'selection' channel
     */
    selectionSubscribe?: string;
    /**
     * Return true if the widget fires the event on its first render. This forces other widgets that use this event
     * to wait before rendering.
     */
    isEventFiredAtStart?: (roleName: string, options: any) => boolean;
}

export declare interface IThemeManager {
    /**
     * Used by IReportDefinition.setThemeProcessorCall().
     */
    registerThemeProcessor(name: string, processor: IThemeProcessor): void;
    /**
     * The theme decorator allows to setup the Theme.components and Theme.ic3 using the theme
     * created from its partial options (e.g., using palette, typography, spacing, etc...)
     */
    registerTheme(themeOptions: any, themeDecorator?: (theme: any) => Components, baseTheme?: EmbeddedThemeNames): void;
    /**
     * Register editor themes. Change the editor theme in ic3report-config.js by setting defaultEditorThemeId to a
     * themeId from a theme using this method.
     */
    registerEditorTheme(themeOptions: any, themeDecorator?: (theme: any) => Components): void;
}

/**
 * Examples:
 * - Change the primary color of the theme to red: `theme.palette.primary.main = "#ff0000";`
 * - Change default chart color: `theme.palette.ic3.chartSingleColors.default = "#ff0000";`
 * - Change background: `theme.palette.ic3.pageBackgroundColor = "#ff0000";`
 * - Change selected color: `theme.palette.ic3.selected = "#ff0000";`
 */
export declare type IThemeProcessor = (theme: any, params?: any) => void;

export declare type IThemeRegisterVariant = Record<variantName, {
    /**
     * for styled MUI like components additional properties defining when the variant applies
     */
    props?: {
        variant: string;
    } & Record<string, any>;
    /**
     * default properties for the fields/options of the widget
     */
    defaultProps: Record<string, any>;
    /**
     * for styled MUI like components, css styles
     */
    style?: CSSInterpolation;
}>;

/**
 * Default values (e.g., box options, chart options, etc...).
 */
export declare interface IThemeWidgetDefaults {
    /**
     * Default values for widget boxes. Lookup order:
     *
     * <pre>
     *      plugin-id.template-id.option
     *      plugin-id.option
     *      option
     * </pre>
     *
     * @see WidgetBoxOptions (ThemeWidgetBox.ts)
     */
    box?: Record<string, any>;
    /**
     * Default values for widget chart options. Lookup order:
     *
     * <pre>
     *      plugin-id.template-id.option
     *      plugin-id.option
     *      option
     * </pre>
     *
     * @see IWidgetTemplateChartOptions (PublicTemplates.ts)
     */
    options?: Record<string, any>;
    /**
     * Default values for widget icons. These settings override the defaults set in the theme in `widgetIcons`.
     *
     * Lookup order:
     *
     * <pre>
     *      plugin-id.template-id.option
     *      plugin-id.option
     *      option
     * </pre>
     *
     * @see IWidgetIcons (PublicTheme.ts)
     */
    widgetIcons?: Record<string, any>;
}

/**
 * Sort of named set of predefined options.
 */
export declare type IThemeWidgetVariant = {
    props: {
        variant: string;
    } & Record<string, string>;
    style: CSSInterpolation;
    defaultProps?: Record<string, any>;
} | {
    props: {
        variant: string;
    } & Record<string, string>;
    defaultProps: Record<string, any>;
};

/**
 * Base interface for nullable column.
 */
export declare interface ITidyBaseColumn<T> extends ITidyBaseColumnReadonly<T> {
    /**
     * Set the color for the columns header
     */
    setHeaderColor(color: (string | undefined)[] | string | undefined): void;
    isSameDimensionality(other: ITidyBaseColumn<any>): boolean;
    getErrors(): (TidyCellError | undefined)[];
    /**
     * If an error occurred in the calculation of cells for a column, then the error can be
     * retrieved using this function.
     * @param idx the row index of the cell to retrieve the error of.
     */
    getError(idx: number): TidyCellError | undefined;
    /**
     * Returns first value where callback does not return undefined.
     * @param callback given the row index, outputs a value or undefined.
     */
    findFirst<P>(callback: (idx: number) => P | undefined): P | undefined;
    /**
     * returns true if the column as a property defining the formatted value.
     */
    hasFormattedValue(): boolean;
    /**
     * Get the formatted value of the column at position idx.
     *
     * undefined - if the formatted_value is not available
     *
     * @param idx the position to return the value of.
     */
    getFormattedValue(idx: number): string | undefined;
    /**
     * Return the formatted value. Returns undefined if the value is undefined.
     * If the value has no format, then it uses the default format from the theme.
     *
     * @param idx row index
     * @param context the widget context. Used to access the default formatters. Leave undefined to not use the theme
     * default formatters.
     */
    getFormattedValueOrValue(idx: number, context?: IPublicContext): string | undefined;
    getNumberFormatInfo(): string | undefined;
    /**
     * Get cell as expected by XLSX library (do not include the interface as it is lazy loaded!).
     * Does not return the format string.
     *
     * @param idx the position to return the value of.
     * @param prettyHierarchy indent hierarchy columns with space-characters. This results in a nice visual hierarchy in
     * Excel.
     */
    getExcelCell(idx: number, prettyHierarchy?: boolean): ITidyColumnXlsxCell | undefined;
    /**
     * Returns excel format, best effort
     */
    getExcelFormat(): string | undefined;
    /**
     * Returns the type for Material-UI Table/Grid
     */
    getXGridType(): "string" | "number" | "date" | "dateTime" | "boolean" | undefined;
    /**
     * Return the cell decoration of the column at `rowIdx`. If the cell has multiple renderers, this method returns
     * the last added one.
     */
    getCellDecoration(rowIdx: number): PublicTidyColumnCellDecorationRendered | undefined;
    /**
     * Returns true if the column has a property of requested name.
     */
    hasProperty(name: ITidyColumnNamedProperties | string): boolean;
    /**
     * Returns the color column (if defined).
     *
     * If the column has type 'color', then it returns itself. Else it returns the
     * column of the first property(1) with type 'color' (if it is defined).
     *
     * (1) the fore color property is excluded.
     */
    getColorColumn(): ITidyColorColumn | undefined;
    /**
     * Returns the color of a cell (if defined).
     *
     * If the column has type 'color', then it returns the cell value. Else it returns the
     * value at rowIdx of the first property(1) with type 'color' (if it is defined).
     *
     * (1) the fore color property is excluded.
     */
    getColor(rowIdx: number): Property.Color | undefined;
    /**
     * Returns the property at the specified property coordinate.
     * @param name name of the property.
     */
    getProperty(name: ITidyColumnNamedProperties | string): ITidyUnknownColumn;
    /**
     * Returns the property at the specified property coordinate.
     * @param name name of the property.
     */
    getOptionalProperty(name: ITidyColumnNamedProperties | string): ITidyUnknownColumn | undefined;
    /**
     * Get the value of the property for the given property coordinate, and the given row (undefined if the property
     * does not exist).
     * @param name name of the property.
     * @param rowIdx row index for the value to return.
     */
    getPropertyAt(name: ITidyColumnNamedProperties | string, rowIdx: number): any;
    /**
     * Return available properties for this column as a list of columns.
     */
    getPropertiesAsColumns(): ITidyUnknownColumn[];
    isWithEntityItem(): boolean;
    /**
     * Create and return the entity item at position idx for generating events.
     */
    getEntityItem(idx: number): EntityItem | undefined;
    /**
     * Get the entity item for the column. Used in column selection.
     * Returns an empty array if no entityItems.
     * @param hierarchyIndices only include these hierarchies for generating the EntityItem. Leave undefined to include
     * all.
     */
    getColumnEntityItem(hierarchyIndices?: number[]): EntityItem[];
    /**
     * Get the index of the parent. Returns -1 if the parent is the root.
     * @param idx the index to find the parent of.
     */
    getParentIdx(idx: number): number;
    /**
     * Return the descendants of the node in the hierarchy at the index.
     * Returned set excludes the node itself.
     * @param index
     */
    getDescendants(index: number): number[];
    /**
     * Returns true if and only if the node in the hierarchy has children.
     */
    hasChildren(index: number): boolean;
    /**
     * Returns the children of the node at `index`.
     */
    getChildren(index: number): number[];
    /**
     * Return the siblings of the node in the hierarchy at the index.
     * Including the node itself.
     * @param index
     */
    getSiblings(index: number): number[];
    /**
     * Get the default member of the dimension that the column represents. Returns undefined
     * if the column is not a MDX dimension.
     */
    getHierarchyDefaultMember(): EntityItem | undefined;
    /**
     * Get the array of MDX info in the column.
     * Returns an empty array if no MDX info.
     */
    getMdxInfos(): (MdxInfo | undefined)[];
    /**
     * Returns the MDX info at a row index.
     */
    getMdxInfo(idx: number): MdxInfo | undefined;
    /**
     * Returns the key from the model. Values with the same key are the same in the underlying model. Rows
     * with the same value but with a different key, are treated as different values.
     * @param rowIdx
     */
    getUid(rowIdx: number): string;
    /**
     * Get extra information of the MDX axis used for this column, if available.
     */
    getAxisInfo(): IMdxAxisSeriesInfo | undefined;
    /**
     * Get the MDX axis coordinate, if available.
     * @see AxisCoordinate
     */
    getAxisCoordinate(): AxisCoordinate | undefined;
    /**
     * Get the axis values in this column.
     *
     * If it is an MDX Axis, the potentially sorted MDX axis (e.g., pivot table sort)
     *
     * If it is not, return undefined
     */
    mdxAxis(): ReadonlyArray<T> | undefined;
    /**
     * Get the unique values in this column.
     */
    unique(ignoreNull: boolean): T[];
    /**
     * Set the name of the column.
     * @param name set this as the caption of the column.
     *
     * Note, do not use this for columns that are in tables as it can cause duplicate columns in a table.
     * Use setCaption to change the name visible to the user.
     */
    setName(name: string): void;
    /**
     * Set the number/date formatter of the column, calculating and adding the 'formattedValue' property.
     */
    setNumberFormat(format: ThemeTextFormatter | undefined): void;
    /**
     * Set the caption of the column. The caption is used for displaying localised
     * or custom captions for the axis, header, etc.
     * @param caption set this as the caption of the column.
     */
    setCaption(caption: string): void;
    /**
     * Returns true if and only if the column has a caption different from the default. The default caption is the
     * columns name.
     */
    hasCaption(): boolean;
    /**
     * Convert the column to another type. This modifies the values to be of that type.
     *
     * If type is datetime, then the settings contain the date locale (default='en_US'), and
     * the dateformat (default = 'yyyy-MM-dd').
     */
    convertToType(type: TidyColumnsType, settings?: ConvertToTypeParseSettings): void;
    /**
     * Same as convertToType but creating a new column.
     */
    convertToTypeN(type: TidyColumnsType, settings?: ConvertToTypeParseSettings): ITidyBaseColumn<T>;
    /**
     * Create a new column with the content of this column changing both its name and its caption.
     */
    duplicate(name: string, caption: string): ITidyBaseColumn<T>;
    /**
     * Change the values of the column.
     * @param values the new values for the column.
     * @param newType the new type for the column. Leave undefined for automatic inference.
     */
    setValues<P>(values: P[], newType?: AllowedColumnType<P>): void;
    /**
     * Apply a transformation to all values in the column. Note, this functions alters the values in the column.
     * @param fun function with one parameter. Describes the transformation. In the function, index represents the
     * index of the internal data structure.
     * @param newType new type for the column. Leave blank for auto inference of the type.
     */
    apply<P>(fun: (value: T, index: number) => P, newType?: AllowedColumnType<P>): void;
    /**
     * Insert values at a row index.
     * Structure: Map: row idx -> values to insert
     *
     * e.g., add totals.
     */
    insertValues(inserts: Map<number, ITidyColumnAddValue[]>): void;
    /**
     * Repeat the values in the column.
     *
     * Examples:
     * column.getValues() --> ['a','b','c']
     * column.repeat(6,1) --> ['a','b','c','a','b','c']
     * column.repeat(6,2) --> ['a','a','b','b','c','c']
     * column.repeat(12,2) --> ['a','a','b','b','c','c','a','a','b','b','c','c']
     *
     * @param newLength new length of the array.
     * @param repetition how many times to repeat each value.
     */
    repeat(newLength: number, repetition?: number): void;
    /**
     * Same as repeat but creating a new column leaving this column untouched.
     *
     * @see repeat
     */
    repeatN(newLength: number, repetition?: number): ITidyBaseColumn<T>;
    /**
     * Push a value to the end of the column's values.
     */
    pushValue(pushValue: ITidyColumnTypedValue): void;
    /**
     * Apply a new index to the column and its properties (e.g., limiting rows, reordering rows, copying rows).
     *
     * Examples:
     * <pre>
     *      initial values       -> [ 'a', 'b', 'c']
     *        reIndex: [2,1,0]   -> [ 'c', 'b', 'a']
     *        reIndex: [2,2,1]   -> [ 'c', 'c', 'b']
     *        reIndex: [0,1,2,2] -> [ 'a', 'b', 'c','c']
     *        reIndex: [0]       -> [ 'a' ]
     *        reIndex: [0,5]     -> [ 'a', null ]
     * </pre>
     *
     * @param index new row indices
     *
     * @see ITidyColumn.reIndexN
     */
    reIndex(index: number[]): void;
    /**
     * Reset the index set using `reIndex`.
     */
    resetIndex(): void;
    /**
     * Set the formatted values. Use this if you have the formatted values pre-calculated,
     * or a function to calculate the formatted values.
     * @param caption the caption for the added property.
     */
    setFormattedValues(formattedValues: (string | null)[] | ((value: T | undefined) => string), caption?: string): void;
    /**
     * Resets the formatted value
     *
     * @see setFormattedValues
     */
    resetFormat(context: IPublicContext, format: ThemeTextFormatter): void;
    /**
     * Set the colors for the column.
     * @param caption the caption for the added property.
     */
    setColors(colors: (Property.Color | null)[], caption?: string): void;
    /**
     * Return a new column with transformed values.
     * @param fun function with one parameter. Describes the transformation.
     * @param columnName the name of the new column.
     * @param newType new type for the column. Leave blank for auto inference of the type.
     */
    mapToColumn<P>(fun: (value: T, index: number) => P, columnName: string, newType: AllowedColumnType<P>): ITidyBaseColumn<P>;
    /**
     *
     * if it's an mdx axis, for each row of the undelying mdx Axis
     * if no, for each row
     *
     * @see mdxAxis
     */
    mapAxisOrRows<K>(callbackfn: (rowIdx: number, column: ITidyBaseColumn<T>) => K): K[];
    /**
     * @param callbackFn  if the return value of callbackFn is undefined, then it is not included in the returned array.
     * @param forceMapAllRows if true, also include values returned by callbackFn that are undefined.
     */
    mapAllRows<P>(callbackFn: (index: number, column: ITidyBaseColumn<T>) => P | undefined, forceMapAllRows?: boolean): P[];
    /**
     * Map the rows that are visible given a hierarchical axis, and an array of boolean values
     * @param expanded a function indicating for each index if it is expanded or not. If it is collapsed, then all
     * children are not visible.
     * @param fun function to apply.
     */
    mapVisibleRows<P>(expanded: (rowIdx: number) => boolean, fun: (index: number) => P): P[];
    /**
     * Apply a function to all visible nodes in the column. A nodes' children are visible if expanded evaluates to
     * true for that node.
     * @param filter Possibly filter the nodes.
     */
    mapTreeVisibleRows<P>(expanded: (rowIdx: number) => boolean, fun: (rowIdx: number, isCollapsed: boolean) => P, filter?: (info: MdxInfo) => boolean): P[];
    /**
     * Set a property on the column. If the property already exists, it is overwritten.
     * @param property the column to set as a property. Ensure that the lengths are the same.
     */
    setProperty(property: ITidyColumn): void;
    /**
     * Delete a property on the column
     */
    deleteProperty(propertyName: ITidyColumn | string): void;
    /**
     * The ITidyTableSelection row identifier for the row (uniqueName if it is an MDX like column).
     */
    getSelectionRowIdentifier(idx: number): string;
    /**
     * Returns the row index of the first occurrence where the values of this column equals value.
     * Returns undefined if it did not find the value.
     *
     * @param value value to search for.
     */
    getRowIndexOf(value: T): number | undefined;
    /**
     * For a hierarchical columns returns a list of transformed columns as needed by a pivot table like structure.
     * If this column is not hierarchical, return this unchanged.
     *
     * E.g., a columns with Year, Quarter and Month will be converted into 3 columns [Year, Quarter, Month].
     */
    toFlatColumns(nullValue: any, rows: number[] | undefined): ITidyUnknownColumn[];
    /**
     * Returns the tree-path for the node, including the node itself. The path starts at the node at rowIdx and contains
     * its parents.
     * @param rowIdx column index of the node.
     */
    getNodePath(rowIdx: number): number[];
    /**
     * Returns if present a notification as defined by the properties of the columns.
     */
    getAppNotification(rowIdx: number): AppNotification | undefined;
    /**
     * Returns if present an action as defined by the properties of the columns.
     */
    getEventAction(rowIdx: number): [string, TidyActionEvent] | undefined;
    mapUniqueNames<T>(uniqueNames: string[], mapper: (idx: number) => T | null | undefined): T[];
    /**
     * Add the renderer to the column. If a cell has multiple renderers, it uses the last added renderer.
     *
     * @see {BaseTidyColumnCellDecoration.appliesToCell}.
     */
    setCellDecoration(decoration: PublicTidyColumnCellDecoration): void;
    /**
     * Return the index of the column.
     * @see tidyTable.
     */
    getIndex(): ITidyColumnIndex[];
    /**
     * undefined if it is not an MDX member column
     */
    getQueryNodeIdentifier(idx: number): MdxNodeIdentifier | undefined;
    /**
     * Returns the group key at the row index for use with `table.toAmcharts4Data`.
     */
    getAmcharts4GroupKey(rowIdx: number): string;
    /**
     * Mark the column as a total column. Total columns have a different styling and css-class in tables and pivot
     * tables.
     * @param isTotal new value. Set to true to mark this column as a total. Use false to remove the mark.
     * @see isTotalColumn
     */
    setIsTotalColumn(isTotal: boolean): void;
    /**
     * Returns true if and only if the column contains total values.
     * @see setTotalColumn
     */
    getIsTotalColumn(): boolean;
    /**
     * return true if the column was created from an MDX axis (i.e., [Geo].[Countries] on 0).
     */
    isMdxAxis(): boolean;
    addRowValue(insert: ITidyColumnAddValueInsert): void;
    /**
     * Returns true if and only if the all the datetime values in the column are dates (and do not have a time
     * component).
     */
    hasOnlyDates(): boolean;
    /**
     * Returns the level depth of the column.
     *
     * E.g., if you have a table with `2018`, `2018 Q1` as columns, then the level depths are 0 and 1.
     */
    getColumnLevelDepth(): number;
    /**
     * Set the style of the header of this column. Used in tables, and the Excel export.
     * @param style the styles
     * @param hierarchyIdx only set the style of this hierarchy. Default is apply to all hierarchies.
     */
    setHeaderStyle(style: ITidyColumnHeaderStyle | undefined, hierarchyIdx?: number): void;
}

export declare interface ITidyBaseColumnReadonly<T> {
    /**
     * Returns the length of the value array.
     */
    length(): number;
    /**
     * Returns true if and only if the column has zero rows.
     */
    isEmpty(): boolean;
    getSource(): ITidyColumnsSource;
    /**
     * Get the MDX role of the column
     */
    getRole(): string | undefined;
    /**
     * Return the type of the column
     */
    getType(): AllowedColumnType<T>;
    /**
     * e.g., List<T>.
     */
    getTypeParam(): TidyColumnsType | undefined;
    /**
     * E.g., datetime column: YEAR, ...
     */
    getSubType(): TidyColumnsSubType | undefined;
    /**
     * Check if column is of type
     * @param type check this type
     */
    is<T extends TidyColumnsType>(type: T): this is ITidyColumnIsType<T>;
    /**
     * Returns true if and only if the column is of the type(s) specified
     * @param typesToCheck one or more types to check this column against
     */
    isOfType(...typesToCheck: TidyColumnsType[]): boolean;
    /**
     * Returns the name of the column.
     */
    getName(): string;
    /**
     * Get the display name of the column. Both the name and the caption form the display name of the column.
     */
    getDisplayName(): string;
    /**
     * Returns the caption of the column. The caption is used for displaying localised
     * or custom captions for the axis, header, etc.
     */
    getCaption(): string;
    /**
     * Returns the formatter of the column.
     */
    getNumberFormat(): ThemeTextFormatter | undefined;
    /**
     * Returns true if the column is a hierarchical structure
     */
    isHierarchy(): boolean;
    /**
     * For hierarchical structures the tree depth (starts at zero).
     */
    getLevelDepthR(idx: number): number;
    /**
     * Returns the column values.
     */
    getValues(): ReadonlyArray<T>;
    /**
     * Get the value of the column at position idx.
     * @param idx the position to return the value of.
     */
    getValue(idx: number): T;
    /**
     * Function used for value comparison in sorting and ranking. Return a positive number if a > b, a negative
     * number if a < b and 0 otherwise.
     * @param a value 1
     * @param b value 2
     */
    compare(a: T, b: T): number;
    /**
     * Apply a function to the groups of unique values in this column
     *
     * @param useMdx If true, use MDX-unique names to construct groups. If false, use the columns values.
     * Default = false.
     *
     * @returns a map with indexes for each group. Key -> row indeces
     */
    groupBy(useMdx?: boolean): Map<string, GroupRowIndices>;
    /**
     * Same as reIndex but creating a new column leaving this column untouched.
     *
     * @see ITidyBaseColumn.reIndex
     */
    reIndexN(index: number[]): ITidyBaseColumn<T>;
    /**
     * Returns the color of this columns' header.
     * @param hierarchyIdx return the color of this hierarchy. Use if you have multiple column rows in your table.
     */
    getHeaderColor(hierarchyIdx?: number): string | undefined;
    /**
     * Returns the colors of this columns header.
     */
    getHeaderColors(): (string | undefined)[] | string | undefined;
    /**
     * Get the style of the header of this column.
     * @param hierarchyIdx return the style of this hierarchy. Use if you have multiple column rows in your table.
     */
    getHeaderStyle(hierarchyIdx?: number): ITidyColumnHeaderStyle | undefined;
}

export declare type ITidyCharacterColumn = ITidyBaseColumn<string | null>;

export declare type ITidyColorColumn = ITidyBaseColumn<Property.Color | null>;

export declare type ITidyColumn = ITidyBaseColumn<any>;

export declare type ITidyColumnAddValue = ITidyColumnAddValueInsert | ITidyColumnAddValueCopyRow;

export declare interface ITidyColumnAddValueCopyRow {
    options: "COPY_ROW";
    rowIndex: number;
}

export declare interface ITidyColumnAddValueInsert {
    options: "INSERT";
    value: ITidyColumnTypedValue;
}

export declare interface ITidyColumnHeaderStyle {
    fontSize?: string;
    fontWeight?: string;
    fontFamily?: string;
}

export declare interface ITidyColumnIndex {
    /**
     * Name of the node in the index
     */
    name: string;
    /**
     * Display label for index
     */
    label: string;
    /**
     * Unique name of mdx member
     */
    mdxUniqueName?: string;
    /**
     * Level of mdx member
     */
    mdxLevel?: string;
}

export declare type ITidyColumnIsType<T extends TidyColumnsType> = T extends TidyColumnsType.ANY ? ITidyColumn : T extends TidyColumnsType.COLOR ? ITidyColorColumn : T extends TidyColumnsType.LONGITUDE ? ITidyBaseColumn<number | null> : T extends TidyColumnsType.LATITUDE ? ITidyBaseColumn<number | null> : T extends TidyColumnsType.ISO2_LOCATION_CODE ? ITidyCharacterColumn : T extends TidyColumnsType.DATETIME ? ITidyDateColumn : T extends TidyColumnsType.NUMERIC ? ITidyNumericColumn : T extends TidyColumnsType.CHARACTER ? ITidyCharacterColumn : T extends TidyColumnsType.LOGICAL ? ITidyLogicalColumn : T extends TidyColumnsType.LIST ? ITidyListColumn : T extends TidyColumnsType.MIXED ? ITidyColumn : T extends TidyColumnsType.NULL ? ITidyNullColumn : ITidyUnknownColumn;

/**
 * Properties with a special meaning
 */
export declare enum ITidyColumnNamedProperties {
    /**
     * The value of a cell.
     */
    mdxCellValue = "value",
    /**
     * The formatted value of a cell. For example, 5003 in euros is formatted as €5,003
     */
    mdxCellFormattedValue = "formattedValue",
    /**
     * MDX related colorings
     */
    mdxCellBackColor = "mdxCellBackColor",
    /**
     * MDX related colorings
     */
    mdxCellForeColor = "mdxCellForeColor",
    /**
     * The format string for the cell value. For example, euros are formatted using €#,###.
     * and percentages using #0.00%.
     */
    mdxCellFormatString = "mdxCellFormatString",
    /**
     * The main color of the cell
     */
    mdxCellColor = "color",
    /**
     * Column defined to fire an app. notification.
     *
     * The name of the notification (e.g., print-report).
     */
    appNotificationType = "appNotificationType",
    /**
     * Column defined to fire an app. notification.
     *
     * The parameters of the notification (e.g., page size, filename, ...) as a JSON or a string.
     */
    appNotificationPayload = "appNotificationPayload",
    /**
     * Column defined to fire events, the name of the event
     */
    eventName = "eventName",
    /**
     * Column defined to fire events, the value of the event (e.g. used in title)
     */
    eventValue = "eventValue",
    /**
     * Column defined to fire events, the mdx value of the event (e.g. used in queries)
     */
    eventMdxValue = "eventMdxValue",
    /**
     * Column defined as an MDX axis, the unique name of the column  (the name is the value of the column).
     * This value is fired when doing selection events.
     * @see {ITidyColumn.getMdxInfo}
     */
    uniqueName = "uniqueName",
    /**
     * The caption of the selection event to use. Returned by getMdxInfo(..).
     * @see {ITidyColumn.getMdxInfo}
     */
    mdxInfoCaption = "mdxInfoCaption",
    /**
     * The MdxInfo
     * @see {ITidyColumn.getMdxInfo}
     */
    mdxInfo = "mdxInfo",
    /**
     * Column defined as an MDX axis, the caption of the column
     */
    caption = "caption",
    /**
     * Column defined as an MDX axis, the key of the column
     */
    mdxCellKey = "key",
    /**
     * Show this when hovering over the cell (or the visualisation representing the cell)
     */
    tooltip = "tooltip",
    /**
     * Name for datetime properties for levels of type Year, Month, Day, Hour, etc..
     */
    datetime = "datetime"
}

export declare enum ITidyColumnsSource {
    QUERY = "query",
    TRANSFORMATION = "transformation",
    UNKNOWN = "unknown"
}

export declare interface ITidyColumnTypedValue {
    value: any;
    fValue?: string;
    type: TidyColumnsType;
    /**
     * Insert this mdx value for this row. Leave undefined to set the mdx info of the row to undefined.
     */
    mdxInfo?: MdxInfo | null;
}

/**
 * A copy from XLSX CellObject (we don't want the link to the library !)
 */
export declare interface ITidyColumnXlsxCell {
    /** The raw value of the cell.  Can be omitted if a formula is specified. */
    v?: string | number | boolean | Date;
    /** Number format string associated with the cell (if requested) */
    z?: string;
    /**
     * Back color of the cell.
     */
    c?: string;
    /**
     * Text color of the cell (`FORE_COLOR`).
     */
    textColor?: string;
    /**
     * Text style bold
     */
    bold?: boolean;
    /**
     * Cell contains an error. Value will be red `error`.
     */
    error?: TidyCellError;
    /**
     * Font size in px (number)
     */
    fontSize?: number;
    /**
     * Font family
     */
    fontFamily?: string;
}

export declare type ITidyDateColumn = ITidyBaseColumn<Date | null>;

export declare type ITidyListColumn = ITidyBaseColumn<any[] | null>;

export declare type ITidyLogicalColumn = ITidyBaseColumn<boolean | null>;

/**
 * Utility class for doing maths in columns
 *
 *
 * As a general rule, functions will return NaN once a value of the column is Nan
 */
export declare interface ITidyMath {
    /**
     * For each not null column value (numbers including Nan or Infinity)
     *
     * @param callback true to stop the for each
     */
    forEachNotNull(column: ITidyBaseColumnReadonly<number | null> | ITidyBaseColumnReadonly<number | null>[], callback: (value: number) => void): void;
    /**
     * Sum of all values in the column.
     */
    sum(column: ITidyBaseColumnReadonly<number | null> | ITidyBaseColumnReadonly<number | null>[]): number | null;
    /**
     * Sum of all values in the column where filter evaluates to true. Returns the sum if filter is undefined.
     */
    sumFiltered(column: ITidyBaseColumnReadonly<number | null>, filter: TidyRowFilter | undefined): number | null;
    /**
     * Get the extreme value of the column. Null values are skipped.
     * @param column
     * @returns the minimum value of the column. Returns undefined if the column has no values.
     */
    min<T>(column: ITidyBaseColumnReadonly<T> | ITidyBaseColumnReadonly<T | null>[]): T | undefined;
    /**
     * Get the extreme value of the column. Null values are skipped.
     * @param column
     * @returns the maximum value of the column. Returns undefined if the column has no values.
     */
    max<T>(column: ITidyBaseColumnReadonly<T> | ITidyBaseColumnReadonly<T | null>[]): T | undefined;
    /**
     * Get the maximum of the absolute values of the column.
     * @param column
     * @returns If x_1, x_2, ..., x_n are the columns values, then it returns max(|x_1|, ..., |x_n|). Null values are
     * skipped.
     */
    absoluteMax(column: ITidyBaseColumnReadonly<number | null> | ITidyBaseColumnReadonly<number | null>[]): number | undefined;
    /**
     * Sum all values matching the lowest depth level of axis column
     */
    sumOnRoot(column: ITidyBaseColumnReadonly<number | null>, tree: ITidyBaseColumnReadonly<any>): number;
    /**
     * Estimate the population mean of the column, skipping null values.
     *
     * @returns the mean of the numeric column. Returns undefined if the column has no values.
     */
    mean(column: ITidyBaseColumnReadonly<number | null> | ITidyBaseColumnReadonly<number | null>[]): number | undefined;
    /**
     * Estimate the population variance of the column. Null values are skipped.
     * @param column
     * @returns the variance of the column. Returns undefined if the column has no values
     */
    variance(column: ITidyBaseColumnReadonly<number | null> | ITidyBaseColumnReadonly<number | null>[]): number | undefined;
    /**
     * Estimate the population standard deviation of the column. Null values are skipped.
     * @param column
     * @returns the standard deviation of the column. Returns undefined if the column has no values
     */
    standardDeviation(column: ITidyBaseColumnReadonly<number | null> | ITidyBaseColumnReadonly<number | null>[]): number | undefined;
    /**
     * Return the number of non-null values in the column.
     */
    count(column: ITidyBaseColumnReadonly<any> | ITidyBaseColumnReadonly<any>[]): number;
    /**
     * Calculate the median of the column. Null-values are ignored.
     * @param column
     * @returns the median of the numeric column. Returns undefined if the column has no values
     */
    median(column: ITidyBaseColumnReadonly<number | null>): number | undefined;
    /**
     * Creates a histogram data object from the column.
     * @param column
     * @param options see HistogramOptions
     *
     * @Returns an array of histogram buckets
     */
    hist(column: ITidyBaseColumnReadonly<number | null>, options: Partial<HistogramOptions>): HistogramData[];
    trendLine(trendLine: TrendLineType, y: ITidyBaseColumnReadonly<number | null>, x: ITidyBaseColumnReadonly<number | null>): ((x: number) => number) | undefined;
    /**
     * Return a regression model with one predictor: y = a0 + a1*x + error
     * @param y column x
     * @param x column y
     */
    ols(y: ITidyBaseColumnReadonly<number | null>, x: ITidyBaseColumnReadonly<number | null>): ((x: number) => number) | undefined;
    /**
     * Returns the previous value in the column , undefined if idx is 0
     * @param column
     * @param idx row index.
     */
    prev(column: ITidyBaseColumnReadonly<number | null>, idx: number): number | undefined | null;
    /**
     * Returns the next value in the column , undefined if idx is last one
     * @param column
     * @param idx row index.
     */
    next(column: ITidyBaseColumnReadonly<number | null>, idx: number): number | undefined | null;
    /**
     * Returns the first value in the column
     * @param column
     * @param idx row index.
     */
    first(column: ITidyBaseColumnReadonly<number | null>, idx: number): number | undefined | null;
    /**
     * Returns the last value in the column
     * @param column
     * @param idx row index.
     */
    last(column: ITidyBaseColumnReadonly<number | null>, idx: number): number | undefined | null;
    /**
     * Calculate the percentage w.r.t. the total of the column.
     * @param column
     * @param idx row index of the cell to calculate the percentage of.
     */
    percent(column: ITidyBaseColumnReadonly<number | null>, idx: number): number | undefined;
    /**
     * Calculate the percentage w.r.t. the first value of the column.
     * @param column
     * @param idx row index of the cell to calculate the percentage of.
     */
    percentFirst(column: ITidyBaseColumnReadonly<number | null>, idx: number): number | undefined;
    /**
     * Calculate the percentage w.r.t. the last value of the column.
     * @param column
     * @param idx row index of the cell to calculate the percentage of.
     */
    percentLast(column: ITidyBaseColumnReadonly<number | null>, idx: number): number | undefined;
    /**
     * Calculate the percentage w.r.t. the table total value (all numeric columns).
     * @param column
     * @param idx row index of the cell to calculate the percentage of.
     */
    percentTable(table: ITidyTable, column: ITidyBaseColumnReadonly<number | null>, idx: number): number | undefined;
    /**
     * Calculate the percentage w.r.t. the row value of all numeric columns.
     * @param column
     * @param idx row index of the cell to calculate the percentage of.
     */
    percentRow(table: ITidyTable, column: ITidyBaseColumnReadonly<number | null>, idx: number): number | undefined | null;
    /**
     * Count the values in the column. For example: [a, b, b] -> {a: 1, b: 2}.
     */
    valueCounts<T>(column: ITidyBaseColumnReadonly<T>): Map<T, number>;
    /**
     * Normalize a numeric column so that its values are on [0, 1].
     * For each value x, return (x - x_min) / (x_max - x_min).
     *
     * @returns undefined if one of the values in the scalar could not be calculated.
     */
    scaleNormalize(column: ITidyBaseColumnReadonly<number | null> | undefined, idx: number, min: number | undefined, max: number | undefined, val: number | undefined): number | undefined;
    /**
     * Scale a numeric column so that its values are on [-1, 1].
     * For each value x, return x / max(|x_1|, ..., |x_n|).
     *
     * @returns undefined if one of the values in the scalar could not be calculated.
     */
    scaleMaxAbsolute(column: ITidyBaseColumnReadonly<number | null>, idx: number): number | undefined;
    /**
     * Standardize the column.
     * For each value x, return (x - x_mean) / x_stdev.
     *
     * @returns undefined if one of the values in the scalar could not be calculated.
     */
    scaleStandardize(column: ITidyBaseColumnReadonly<number | null>, idx: number): number | undefined;
    /**
     * Returns the covariance between two columns. Nulls are interpreted as zeros.
     */
    covariance(x: ITidyBaseColumnReadonly<number | null>, y: ITidyBaseColumnReadonly<number | null>): number | undefined;
}

export declare type ITidyNullColumn = ITidyBaseColumn<null>;

export declare type ITidyNumericColumn = ITidyBaseColumn<number | null>;

export declare type ITidyRow = any[];

/**
 * Result of a MDX, SQL, ... query with additional transformations (e.g., colors, sizes, changing MDX names,...).
 * A tidy table has axes and measures. The axes describe the coordinates for each measure.
 * The columns of a tidy table are thus structured as follows: columns = axes + measures.
 *
 * For example:
 * axes         | measures
 * Brand | Year | Size (m)
 * Volvo | 2018 | 234
 * MBW   | 2019 | 456
 *
 * In this chart the Brand and Year columns are axes and Size (m) is the measure.
 * The columns of this table are Brand, Year, Size (m).
 */
export declare interface ITidyTable {
    /**
     * Get the query uid
     */
    getQueryUid(): number;
    isSameDimensionality(other: ITidyTable): boolean;
    asPivotTableForExcel(nullValue: any, rows: number[] | undefined): ITidyColumn[];
    /**
     * Return all columns in the table
     */
    getColumns(): ITidyColumn[];
    /**
     * Get the number of rows.
     */
    getRowCount(): number;
    /**
     * Get the number of columns.
     */
    getColumnCount(): number;
    /**
     * Get the nth character column in the table
     * @param axisPosition
     */
    getAxisN(axisPosition: number): ITidyCharacterColumn;
    /**
     * @see {getAxisN}
     */
    getOptionalAxisN(axisPosition: number): ITidyCharacterColumn | undefined;
    /**
     * Get the nth numeric column in the table
     * @param axisPosition
     */
    getMeasureN(axisPosition: number): ITidyNumericColumn;
    /**
     * @see {getMeasureN}
     * @param axisPosition
     */
    getOptionalMeasureN(axisPosition: number): ITidyNumericColumn | undefined;
    /**
     * Get a column by name (case insensitive) or index. If no column is found, it gives an error.
     * @param identifier name or index of the column
     */
    getColumn(identifier: string | number): ITidyColumn;
    /**
     * @see {getColumn}
     */
    getOptionalColumn(identifier: string | number): ITidyColumn | undefined;
    /**
     * Column getters with mapping defined, throws an error if the column is not found.
     *
     * The idea is then to have a function: getColumnByAlias that requests mapping name.
     * The widget can check for if the mapping is undefined or not. If it is defined,
     * it will result in a column (which can be empty). If it is undefined it will try to
     * fallback to another column that has the mapping specification.
     *
     * @param alias mapping name
     */
    getColumnByAlias(alias: string): ITidyColumn;
    /**
     * Returns multiple columns. For example, in the line chart, this function returns all the columns mapped in the
     * values option.
     * @see getColumnByAlias
     * @param alias
     */
    getColumnsByAlias(alias: string): ITidyColumn[];
    /**
     * @see {getOptionalColumnByRole}
     * @param role mapping name
     * @returns list of columns with the role 'role'.
     */
    getColumnsByRole(role: string): ITidyColumn[];
    /**
     * @see {getColumnByAlias}
     */
    getOptionalColumnByAlias(alias: string): ITidyColumn | undefined;
    /**
     * @see {getColumnByAlias}
     */
    getOptionalColumnsByAlias(alias: string): ITidyColumn[] | undefined;
    /**
     * Get the coordinate of the column using the alias for the mapping
     * @param alias the name of the mapping
     */
    getOptionalColumnCoordinateByAlias(alias: string): TidyTableColumnIdentifier | undefined;
    /**
     * Get columns using a selector
     * @param selector selector object
     */
    getColumnsBySelector(selector: TidyTableColumnSelector | TidyTableColumnSelector[]): ITidyColumn[];
    /**
     * Get a column using the coordinate of an axis.
     * @param coordinate
     * @see {AxisCoordinate}
     */
    getColumnByMdxAxis(coordinate: AxisCoordinate): ITidyColumn | undefined;
    /**
     * Get all columns on an axis.
     * @param axisIdx index of the axis. ON 0, ON 1, etc..
     */
    getColumnsByMdxAxis(axisIdx: number): ITidyColumn[];
    /**
     * Get the number of MDX axis.
     */
    getMdxAxisCount(): number;
    /**
     * Get the column for the text formatter
     * @param nameOrAlias the name or the mapping alias for the column
     */
    getColumnForTextFormatter(nameOrAlias: string): ITidyColumn | undefined;
    /**
     * Convert the tidy table to an array of arrays.
     * @param major the major-ordering of the arrays. If 'column', the result is an array of columns. If 'row', the
     * result is an array of rows. The default is 'row'.
     */
    toArray(major?: 'row' | 'column'): any[][];
    /**
     * Get the column names of the tidy table. Each column in the table has a unique name.
     */
    getColumnNames(): string[];
    /**
     * Get the column captions of the tidy table
     */
    getColumnCaptions(): string[];
    /**
     * Get a column by its type
     * @param type columns of this type are in the result set
     * @param position get the nth column of the result set, default = 0
     */
    getColumnByType(type: TidyColumnsType, position?: number): ITidyColumn;
    /**
     * @see {getColumnByType}
     */
    getOptionalColumnByType(type: TidyColumnsType, position?: number): ITidyColumn | undefined;
    /**
     * Search through the columns in the table returning the n-th column that is found.
     * @param predicate function that returns true if and only if the column is in the result set.
     * @param position the position in the result set. Defaults to 0.
     */
    searchColumn(predicate: (column: ITidyColumn) => boolean, position?: number): ITidyColumn | undefined;
    /**
     * Return a list of the types of the column in the table
     */
    getColumnTypes(): TidyColumnsType[];
    /**
     * Get the index of the column in the table
     * @param col
     */
    lookupColumnIdx(col?: ITidyColumn): number;
    /**
     * Returns the value of the cell. Does not search properties.
     * @param columnName name of the column in the table
     * @param row row of the table
     */
    getValue(columnName: string, row: number): any;
    /**
     * Apply a mapper function to each row. Returns a list with length equal to the number of rows in the table.
     * @param mapper the function to use.
     */
    mapRows<T>(mapper: (rowIdx: number, rowData: (colIdx: number) => any, colCount: number) => T): T[];
    /**
     * Map the columns of the table, resulting in a list with length equal to the number of columns.
     * @param mapper
     */
    mapColumns<T>(mapper: (colIdx: ITidyColumn, colData: (rowIdx: number) => any, rowCount: number) => T): T[];
    /**
     * Take the sum of the column, but if it is a hierarchical column only the sum at the root level will be
     * calculated
     * @param axisColIdx the (hierarchical) axis
     * @param measureColIdx measures to take the sum of
     */
    sumRoot(axisColIdx: number, measureColIdx: number): number;
    /**
     * build a tidy tree where the levels are defined by the treeLevels parameter, using
     * the column values for creating unique tree nodes.
     *
     *  ColA   |  ColB  | Value
     *  Europe   Bike     1
     *  Europe   Car      2
     *  America  Foot     4
     *
     * is transformed into :
     *
     * root
     *  |
     *  --- Europe
     *  |     |
     *  |     --- Bike  1
     *  |     |
     *  |     --- Car   2
     *  |
     *  --- America
     *       |
     *       --- Foot   4
     *
     * The values of the measures are added to the leafs unless expandHierarchicalColumn is true.
     *
     *
     * @param treeColumns  columns to build the levels
     * @param rootLabel    the label of the root
     * @param expandHierarchicalColumn  if true, hierarchical columns will be expanded as a tree (all nodes except the root one will have measures values)
     */
    buildTidyTree(treeColumns: ITidyColumn[], rootLabel?: string, expandHierarchicalColumn?: boolean): TidyTree;
    /**
     * Group the table by some of its columns. Rows are in the same group, if their values are equal.
     * @param columns groupIdx and groupRows for each unique value in this(ese) column(s)
     * @param useMdx If true, use MDX values. Default = use column values.
     * @returns an array with indexes for each group. The ith item represents the rows of the group, where i is the
     * index of the ith unique value in the group column.
     */
    groupBy(columns: ITidyColumn[], useMdx?: boolean): GroupRowIndices[];
    /**
     * Pivot a tidy table from wide to long format. See pivot longer in the documentation.
     * @param columns columns to melt.
     * @param variableName name of the column to which the variable name are melted.
     * @param valuesName name of the column to which the values are melted.
     */
    melt(columns: ITidyColumn[], variableName?: string, valuesName?: string): void;
    /**
     * Pivot a tidy table from long to wide format
     * Duplicated rows are discarded.
     * @param toColumns Pivot the row-values of this column to the columns of the table.
     * @param valueCols transpose the values in these column.
     * @param toRows Each unique combination in these columns is a row in the transformed table. Leave undefined to take all remaining columns.
     */
    cast(toColumns: ITidyColumn[], valueCols: ITidyColumn[], toRows?: ITidyColumn[]): void;
    /**
     * Cast to create a new table
     * @see cast
     */
    castN(toColumns: ITidyColumn[], valueCols: ITidyColumn[], toRows?: ITidyColumn[]): ITidyTable;
    /**
     * Sort the table based on the certain columns. Default sorting is descending.
     * @param columns column(s) used for sorting. Columns earlier in the list take priority over columns with
     * higher indexes in determining the order.
     * @param order sorting order. Default = descending.
     */
    sort(columns: ITidyColumn[], order?: SortingType[]): void;
    /**
     * Sort the table while keeping the parent/child structure in treeColumns intact.
     * @param treeColumns one or more columns with a tree like structure
     * @param sortingColumns columns to sort on
     * @param order sorting order. Default = descending.
     */
    sortInTree(treeColumns: ITidyColumn[], sortingColumns: ITidyColumn[], order?: SortingType[]): void;
    /**
     * Get the ranking of one or more columns. Smallest value gets rank 0,
     * second smallest rank 1, etc. until rank n-1. Sort ascending by default.
     * @param columns columns used for finding the order. Columns earlier in the list take priority over columns with
     * higher indexes in determining the order.
     * @param order sorting order. Default = ascending.
     */
    getRank(columns: ITidyColumn[], order?: SortingType[]): number[];
    /**
     * Add a new column to the table. If the column name already exits, a new name is generated.
     * If the column is already in the table, nothing is done.
     */
    addColumn(column: ITidyColumn): void;
    /**
     * Convert the tidy table to a data object that can be used by amCharts V5.
     */
    toAmcharts5Data(axis: ITidyColumn, group: ITidyColumn | undefined, value: Record<string, ITidyColumn | undefined>): any;
    /**
     * Convert the tidy table to a data object that can be used by amCharts.
     * Note, duplicated rows in 'group' are skipped.
     *
     * See the tests for examples.
     *
     * @param category the column with labels for the category axis.
     * @param value this is an object with columns. Each column is converted to <group>.<key> = <column-value>.
     * @param group column indicating the groups. Each unique value in this column forms a new group. Groups in
     * the resulting data object are given by '<group_id>.' preceding the values.
     * @param level this column expands the axis so that widgets can plot level-like charts using guides. This expansion
     * follows the patters axis-label[level-label].
     * @param hideNulls column, do not include records where all rows in group evaluate to NULL.
     * @param disableGroupRecords if true, all the rows become a single object. Else all data per group becomes a single object. Default = false.
     */
    toAmcharts4Data<F extends string>(category: ITidyColumn, value: Record<F, ITidyColumn | undefined>, group?: ITidyColumn | ITidyColumn[], level?: ITidyColumn, hideNulls?: ITidyColumn, disableGroupRecords?: boolean): IAmCharts4Data[];
    /**
     * Creates a data object for the Amcharts treemap
     * @param level0 names for the parent nodes
     * @param level1 names for the child nodes
     * @param value values to use in the node data
     */
    toAmcharts4DataTreeMap(level0: ITidyColumn, level1: ITidyColumn, value: Record<string, ITidyColumn | undefined>): IAmCharts4DataTreeMap[];
    /**
     * Convert the tidy table to json.
     *
     * For example, let table =
     * col1 | col2 | value1 | value2
     * a      b      1        2
     * a      bar    5        3
     *
     * then, table.toJson('r', {c1: col1, c2: col2, v2: value2}) results in
     * [
     *    {row: 0, c1: a, c2: b, v2: 2},
     *    {row: 1, c1: a, c2: bar, v2: 3}
     * ]
     *
     * Note that 'row' represents the index of the row in the tidy table.
     *
     * Another example, now without arguments:
     * table.toJson() results in
     * [
     *  {
     *      row: 0,
     *      col1: a,
     *      col2: b,
     *      value1: 1,
     *      value2: 2
     *  },
     *  {
     *      row: 1,
     *      col1: a,
     *      col2: bar,
     *      value1: 5,
     *      value2: 3
     *  }
     * ]
     *
     * @param rowIdxTag if defined, include the row number of the tidy table in the result. Use rowIdxTag as the key in the object.
     * @param colTags if defined, this is how the columns in the tidy table are mapped. If not defined, the captions of the
     * tidy table are used as keys in the row objects.
     */
    toJson(rowIdxTag?: string, colTags?: Record<string, ITidyColumn | undefined>): Record<string, any>[];
    /**
     * Get a row as an object.
     * @param rowIdx index of the row to query.
     */
    getRowJson(rowIdx: number): Record<string, any>;
    /**
     * Convert the table to html table string
     */
    toHtml(): string;
    /**
     * throws an exception if the column does not belong to the table
     */
    assertColumnExists(column: ITidyColumn): void;
    hasEmptyDrilldown(nodeInfo: MdxNodeIdentifier): boolean;
    /**
     * Apply a new index to the table. Used for sorting, filtering and duplication of rows.
     *
     * Examples:
     *
     * table.toString() -->
     *     Country   |Amount    |Count     |
     * ----------------------------------------
     * 0   France    |10        |5         |
     * 1   Holland   |20        |4         |
     * 2   China     |25        |3         |
     * 3   Germany   |20        |2         |
     * 4   Belgium   |25        |1         |
     *
     * column.reIndex([0,0,2,4,1,-1,-1,999]) -->
     *     Country   |Amount    |Count     |
     * ----------------------------------------
     * 0   France    |10        |5         |
     * 1   France    |10        |5         |
     * 2   China     |25        |3         |
     * 3   Belgium   |25        |1         |
     * 4   Holland   |20        |4         |
     * 5   undefined |undefined |undefined |
     * 6   undefined |undefined |undefined |
     * 7   undefined |undefined |undefined |
     *
     * @param index list of integers.
     */
    reIndex(index: number[]): void;
    /**
     * Delete a column from the table (if it exists).
     * @param column
     */
    deleteColumn(column: ITidyColumn | string): boolean;
    /**
     * Keep a subset of columns from the table.
     * @param columns list of columns, note that the length of each column must be the same as the number of rows
     * in the table. Duplicates will be ignored. Columns with the same name get an index added to the name.
     */
    setColumns(columns: ITidyColumn[]): void;
    /**
     * Create a new column. The column is not added to the table.
     * @param name name of the column.
     * @param values cell values for the column.
     * @param type if undefined, the type is inferred. Note that the provided type is not checked against the values
     * for speed. Be sure that the type you set is correct to prevent unexpected behaviour.
     */
    createColumn<T>(name: string, values: T[], type?: AllowedColumnType<T>): ITidyBaseColumn<T>;
    createTable(): ITidyTable;
    /**
     * Returns a new table with the original columns and rows filtered and in a new order.
     * It leaves the original table intact.
     *
     * cols : [2,1,4]  -> 3 columns in a new order
     * rowIdx:[55,2,3,5] -> 4 rows in a new order
     */
    createFilteredTable(colIdx: number[] | undefined, rowIdx: number[] | undefined): ITidyTable;
    /**
     * Print the table as a markdown table (e.g., used for internal documentation).
     */
    toMarkdown(): string;
    /**
     * Return the values of the tidy table (debugging purpose).
     *
     * @param order how to structure the array, default = column-major.
     *     Say the table has n rows and m columns, then
     *     > row-major - returns an array of row-values
     *         [
     *            [val11, val12, ..., val1m],
     *            [val21, val22, ..., val2m],
     *            ...,
     *            [valn1, valn2, ..., valnm]
     *         ]
     *
     *     > column-major - returns an array of column-values
     *         [
     *            [val11, val21, ..., valn1],
     *            [val21, val22, ..., valn2],
     *            ...,
     *            [valm1, valm2, ..., valnm]
     *         ]
     */
    getValues(order?: "row-major" | "column-major"): ReadonlyArray<ReadonlyArray<any>>;
    /**
     * Add a tag, name combination to the mapping
     * @param tag name, mapping, role, etc..
     * @param identifier name of the column in the table. Not exist = error.
     */
    addToColumnIndex(tag: string, identifier: string | number): void;
    /**
     * Add a new index to the existing index, overwriting what already exists.
     */
    addColumnIndex(index: TidyColumnIndex): void;
    /**
     * The limit used when lazy search is enabled.
     */
    getLazySearchLimit(): number | undefined;
    isTotalRow(rowIdx: number): boolean;
    /**
     * Transform the table to a table where each row is a bucket in the histogram for that group.
     * Returns a new tidy table. Function does not mutate old tidy table and its columns.
     *
     * @see TidyHistogramBucketColName
     * @see TidyHistogramCountColName
     */
    toHistogram(context: IPublicContext, valueCol: ITidyBaseColumnReadonly<number | null>, groupCol: ITidyColumn | undefined, options: TidyHistogramOptions): ITidyTable;
    /**
     * Create a histogram bucket column from the value column.
     */
    toHistogramBucketColumn(context: IPublicContext, valueCol: ITidyBaseColumnReadonly<number | null>, options: TidyHistogramOptions): ITidyColumn;
    addTotalRows(totals: Map<number, ITotalRowValues[]>): void;
    /**
     * Mark these rows as total rows in the table.
     * @param totalRows
     */
    setTotalRows(totalRows: (rowIdx: number) => boolean): void;
    setTotalRowsCol(col: ITidyLogicalColumn): void;
    /**
     * Get a column by its role as defined in the mdxBuilderSettings.
     * @param role name of the axis-role
     */
    getOptionalColumnByRole(role: string): ITidyUnknownColumn | undefined;
    /**
     * Pivot Table
     * @param nodeInfo
     */
    getLevelDepthR(nodeInfo: MdxNodeIdentifier): any;
    hasMdxChildren(nodeInfo: MdxNodeIdentifier): boolean;
    isLeaf(nodeInfo: MdxNodeIdentifier): boolean;
    /**
     * Sort the tidy table pivot style
     */
    sortLikePivotTable(sortingColumn: ITidyColumn, type: SortingType, rowIds: number[]): void;
    /**
     * The tidy table internally keeps track how columns are mapped to roles. If you apply a transformation
     * in the widget template, you can update the mapping after whith this function.
     * @param mapping new mapping = {old mapping , ...mapping}
     */
    updateMapping(mapping: ChartTemplateDataMapping): void;
    /**
     * Utility class for doing maths on columns
     */
    getMath(): ITidyMath;
    /**
     * Returns true if and only if the table is truncated by the server (too many rows otherwise).
     */
    reachedMaxTidyRowCount(): boolean;
    /**
     * Some MDX queries return headers that have a hierarchy. This function returns the number of header rows.
     * For example, the table below has two headers.
     *
     *     2020 |         | 2021      |
     *     car  | bike    | car       | bike
     *   -------------------------------------
     *     40   | 50      | 55        | 35
     *
     */
    getTopHeaderHierarchyCount(): number;
    /**
     * Clear the index. Use for resetting sorting / filtering.
     */
    resetIndex(): void;
}

export declare interface ITidyTableDrilldown {
    handleDrilldown(rowIdx: number, event: TidyEvent | undefined, stopDrillDownDepth?: number): void;
    hasDrilldown(): boolean;
    hasNodeDrilldown(nodeInfo: MdxNodeIdentifier, stopDrillDownDepth?: number): boolean;
    hasPivotLikeDrilldown(): boolean;
}

export declare interface ITidyTableInteraction extends ITidyTableInteractionSelection, ITidyTableInteractionEvent, ITidyTableDrilldown {
    /**
     * Handles a row hit/click, doing a selection or a drilldown depending on the widget status
     *
     * The column(s) for the selection or the drilldown are based on the widget options/settings
     *
     * This does not fire any event. To fire an event, use fireEvent.
     *
     * @see fireEvent
     */
    handleRowHit(rowIdx: number, event: TidyEvent | undefined): void;
    /**
     * Handles a cell click in the tidy table.
     * @param rowIdx row index of the cell
     * @param colIdx column index of the cell
     * @param event mouse/touch event
     *
     * @see handleRowHit
     */
    handleCellHit(rowIdx: number, colIdx: number, event: TidyEvent | undefined): void;
    /**
     * Handles a column click in the tidy table.
     * @param colIdx index of clicked column in the tidy table
     * @param event mouse/touch event
     *
     * @see handleRowHit
     */
    handleColumnHit(colIdx: number, event: TidyEvent | undefined): void;
    /**
     * Handles a row hit for the sankey diagram. The sankey differs from normal selection because it makes a tuple,
     * not a set.
     */
    handleRowHitSankey(rowIdx: number, column: ITidyColumn, event: TidyEvent | undefined): void;
    /**
     * Collapsed / Expand on a column row (i.e. it's a tree)
     */
    toggleCollapse(column: ITidyColumn, rowIdx: number): void;
    /**
     * returns the collapse/expand state that has not yet been set by the end user (i.e. first time, on drilldowns..)
     */
    setCollapseUnsetFunction(collapseUnsetFunction?: (nodeInfo: MdxNodeIdentifier) => boolean): void;
    /**
     * Map a function to the visible rows only. Used in tree structures with expanded or collapsed items.
     * @param column column to map the values of
     * @param mapper function
     * @param inverse per default, all items are expanded. If inverse is true, all items are collapsed per default.
     */
    mapVisibleRows<T>(column: ITidyColumn, mapper: (index: number) => T, inverse?: boolean): T[];
    isCollapsed(column: ITidyColumn, rowIdx: number): boolean;
    /**
     * Is the node loading
     */
    isLoading(column: ITidyColumn, rowIdx: number): boolean;
    setSelectionColumns(columns: ITidyColumn[] | ((oldColumns: ITidyColumn[]) => ITidyColumn[])): void;
    /**
     * Change the default drilldown column.
     * @param column column to use for the drill-downs. Use undefined to reset to default.
     */
    setDrilldownColumn(column: ITidyColumn | undefined): void;
    /**
     * Pivot Type behavior ( nodes can collapse/expand + drilldown might return some values)
     *
     * pay attention that the query needs to set the flag, pivot table like (to insert data)
     */
    pivotTableLikeDrilldown(event: TidyEvent, column: ITidyColumn, rowIdx: number, stopDrillDownDepth?: number): void;
    pivotTableLikeDrilldownOnNode(event: TidyEvent, nodeInfo: MdxNodeIdentifier, stopDrillDownDepth?: number): void;
    pivotTableLikeNodeStatus(column: ITidyColumn, rowIdx: number, stopDrillDownDepth?: number): TidyPivotTableLikeNodeStatus;
    asLazyTreeViewLoader(column: ITidyColumn): ILazyTreeViewLoader;
    getCompactedSelectionNames(): string[] | undefined;
    /**
     * Returns true if the column is used for the row selection.
     */
    isSelectable(col: ITidyColumn): boolean;
    isHierarchyIdxSelectable(hierIndex: number): boolean;
    /**
     * Returns the rows of the items currently in the selection. Note, the item must be present in the current tidy
     * table.
     */
    getSelectedRows(): number[];
    setSortSelectionToColumnOrder(value: boolean): void;
    /**
     * Returns compacted selection if TreeFireEventMode === COMPACT_ON_PARENT. Else returns undefined.
     */
    getCompactedSelectionItems(): ITidyTableSelection[] | undefined;
    /**
     * Returns the widgets selection options.
     */
    getWidgetSelectionOptions(): WidgetTidySelectionOptions;
    /**
     * Returns the selection in the interaction object.
     */
    getSelectedItems(): ITidyTableSelection[];
    /**
     * Add an item to the interactions selection.
     */
    setSelection(items: ITidyTableSelection | ITidyTableSelection[]): void;
    /**
     * Use for publishing app notifications, e.g., print the report.
     */
    publishAppNotification(notification: AppNotification): void;
    /**
     * Get a column from the underlying tidy table.
     * @param columnIdx
     */
    getDrilldownColumn(columnIdx: number): ITidyColumn;
    /**
     * Return the selection behaviour when the selection is empty.
     */
    getEmptyMode(): SelectionBehaviour | undefined;
}

export declare interface ITidyTableInteractionEvent {
    /**
     * actionName if the action is bound to a channel, sends the events ( e.g. 'onClick' to the channel 'year' )
     *
     * If rowIdx is an empty array, [], fires a mdx empty set event -> ∅
     */
    fireEvent(actionName: string, column: ITidyColumn | ITidyColumn[] | undefined, rowIdx: number | number[]): void;
    fireClearEvent(actionName: string): void;
    /**
     * actionName if the action is bound to a channel, sends the emptySet event, ∅
     */
    fireEmptySetEvent(actionName: string): void;
    /**
     * actionName if the action is bound to a channel, send an Mdx Event (value,mdx)
     */
    fireMdxEvent(actionName: string, value: string, mdx: string): void;
    /**
     * returns the value of the event
     */
    getEventValue(actionName: string): PublicIcEvent | undefined;
    /**
     * returns true if the actionName in bound to a channel
     */
    firesEvent(actionName: string): boolean;
    /**
     * Returns a function that evaluates to true if and only if that row is selected.
     * Returns undefined if there is no selection.
     */
    getIsRowSelectedFilter(): TidyRowFilter | undefined;
}

export declare interface ITidyTableInteractionSelection {
    /**
     * Sets the selection at the creation of the widget.
     */
    initializeSelection(isRangeSelection?: boolean): void;
    /**
     * Sets the selection at the creation of the widget: autocomplete-lazy.
     */
    initializeLazySelection(items?: EntityItem[]): void;
    /**
     * Returns true if the selection if empty. Returns false otherwise.
     */
    isSelectionEmpty(): boolean;
    firstIdxSelected(): number | undefined;
    /**
     * A row is selected if all cells in the row are selected
     * @param rowIdx the index of the row
     */
    isSelected(rowIdx: number): boolean;
    /**
     * Returns true if and only if the column is selected.
     * @param colIdx index of the column in the tidy table.
     * @param hierIdx optional. Use to check if the hierarchy index is selected. Leave undefined to check the column.
     */
    isColumnSelected(colIdx: number, hierIdx?: number): boolean;
    /**
     * Returns true if and only if the cell is selected.
     * @param rowIdx
     */
    isCellSelected(rowIdx: number, colIdx: number): boolean;
    /**
     * For the sankey diagram, a row is selected if connecting nodes are in the selection.
     * @param rowIdx the index of the row
     * @param column selection should be in this column
     */
    isSelectedSankey(rowIdx: number, column: ITidyColumn): boolean;
    /**
     * map function on selected rows
     */
    mapSelectedRows<T>(callback: (rowIdx: number) => T | null | undefined): T[];
    /**
     * Creates a new Column of size Table row count with the following values
     *
     * @param selectedItemValue  if the row is selected
     * @param notSelectedItemValue  if the row is not selected
     * @param noSelectionValue   if defined an the selection is empty, all row values have this value
     */
    applySelectionToNewColumn<T>(selectedItemValue: T, notSelectedItemValue: T, noSelectionValue?: T): ITidyBaseColumn<T>;
    /**
     * Handles the row click event for the selection
     * @param rowIdx index of row clicked
     * @param event the mouse event of the click
     */
    handleClickSelection(rowIdx: number, event?: TidyEvent): void;
    /**
     * Handles the click event for the selection on a given column.
     *
     * If the column is not part of the selection columns of the widget nothing will happen
     *
     * @param column column index of the tidy table
     * @param event the mouse event of the click
     */
    handleColumnSelection(colIdx: number, event?: TidyEvent): void;
    /**
     * Handles the click event for the selection of a given cell
     *
     * If the columns is not part of the selection columns of the widget nothing will happen
     *
     * @param rowIdx row index of clicked cell in the tidy table
     * @param colIdx column index of clicked cell in the tidy table
     * @param event the mouse event of the click
     */
    handleCellSelection(rowIdx: number, colIdx: number, event?: TidyEvent): void;
    /**
     * Get the interaction mode:
     * undefined = no interactions in the widget,
     * selection = perform selection interaction,
     * drilldown = perform drilldown interaction.
     */
    getInteractionMode(): IWidgetInteractionMode | undefined;
    getColorOnSelection(theme: Theme, color: string | undefined, rowIdx: number): string | undefined;
    /**
     * Select multiple rows at once
     */
    handleMultipleRowSelection(rowIds: number[]): void;
    /**
     * Perform a row-selection click on multiple rows at the same time. Has similair CTRL functionality as
     * handleClickSelection(...). SHIFT is not supported.
     */
    handleMultipleRowSelectionClick(rowIds: number[], event?: TidyEvent): void;
    /**
     * Clear the selection and fire an empty event value. Note, this resets the
     * selection to the initial selection.
     */
    handleClearSelection(): void;
    /**
     * Resets the selection to his default/initial state.
     */
    handleToInitialSelection(): void;
    /**
     * Get the selection mode (single or multiple) of the interaction object.
     */
    getSelectionMode(): SelectionMode_2;
    /**
     * Set the selection mode of the interaction.
     * @param mode
     */
    setSelectionMode(mode: SelectionMode_2): void;
    /**
     * Set the selection behaviour for when the selection is empty.
     * @param behaviour
     */
    setSelectionEmptyBehaviour(behaviour: SelectionBehaviour): void;
    setSelectionAllBehaviour(behaviour: SelectionBehaviour): void;
    /**
     * If the selection is on a tree, this determines how the fired event is optimized for the
     * tree structure. Collapsed means that if all children are selected, we only use the parent. Children means
     * that we use leaves only. All means that we fire both parent and child nodes.
     * @param mode
     */
    setTreeFireEventMode(mode: TreeFireEventMode): void;
    setTreeCascade(value: boolean): void;
    /**
     * the selection will treat a click without ctr or shift as with a ctr key pressed  (e.g. check boxes)
     */
    setNoKeyModifierAsCtrl(value?: boolean): void;
    /**
     * Set to true to enable selection on the interaction object.
     * @param enabled if true, the selection is enabled. If false, the interaction object does not respond to
     * methods setting the selection (e.g. click).
     */
    setSelectionActive(enabled?: boolean): void;
    /**
     * Returns true if the selection is activated, e.g. the interaction object responds to click and other selection
     * events.
     */
    isSelectionActive(): boolean;
}

/**
 * This is produced by a hit (click) event
 *
 * it might actually 'select' one or multiple rows in a Tidy table (e.g. all rows for [Time].[2010])
 * it can be defined using one or multiple TidyColumns ( kinda forEachMatchingRow)
 *
 * uniqueNames are used so it survives drill-downs, filter or new queries, in this
 * scenario a coordinate might not longer match any rowIdx
 */
export declare interface ITidyTableSelection {
    /**
     * Fired event value. Arrays are combined into a single event.
     */
    items: EntityItem[];
}

export declare interface ITidyTableTransformation<OPTIONS extends FormFieldObject> {
    /**
     * The id of the transformation. Use this id to reference the transformation in the localization.
     */
    id: string;
    /**
     * The id of the editor group that the transformation is in.
     */
    groupId: string;
    /**
     * Internal usage: pluginID.id
     */
    qualifiedId?: string;
    /**
     * Widgets from these templates can use the transformation. Leave undefined for all widgets.
     * E.g., ic3.Table for the table widget.
     */
    allowedByWidgetTemplate?: string[];
    /**
     * Return the description to show below the transformation in the 'TRANSFORMATION' tab of the editor
     * @param context used for accessing localization functions
     * @param options user-set options for the transformation
     */
    getDescription?(context: ILocalizationContext, options: OPTIONS): string;
    /**
     * Return the field meta for the user-editable options
     */
    getFieldMeta(): FormFieldDef[] | FormFields<OPTIONS>;
    /**
     * Run the transformation.
     * @param context public context
     * @param table modify this table in the transformation. It is mutable.
     * @param options user-set options for the transformation
     */
    apply(context: IPublicContext, table: ITidyTable, options: OPTIONS): void;
}

export declare interface ITidyTableTransformationManager {
    registerTransformation(transformation: ITidyTableTransformation<any>): void;
}

export declare type ITidyUnknownColumn = ITidyBaseColumn<unknown>;

/**
 * Interface for adding a single row to a tidy table
 */
export declare interface ITotalRowValues {
    /**
     * Keys as column names.
     */
    totalValues: Record<string, ITidyColumnAddValueInsert>;
    /**
     * Keys as column names.
     */
    totalTexts: Record<string, ITidyColumnAddValueInsert | ITidyColumnAddValueCopyRow>;
}

/**
 * Unlimited in height.
 */
export declare interface IUnlimitedPageSize extends IPageSize {
    type: "unlimited";
    pageSizeUnits: PaperSizeUnits;
    pageWidth: number;
}

export declare interface IUserMenuOptionDefinition {
    /**
     * IUserMenuOptions.
     */
    option: string;
    /**
     * WidgetNotificationType.
     */
    notification: string;
}

export declare interface IUserMenuOptionManager {
    registerUserMenuOption(option: IUserMenuOptionDefinition): void;
}

export declare type IUserMenuOptions = 'editGadget' | 'editWidget' | 'deleteWidget' | 'deleteGadget' | 'convertGadgetToWidget' | 'addEventToAllQueries' | 'migrateWidget' | 'maximize' | 'clearSorting' | 'showData' | 'resetDrilldown' | 'clearState' | 'clearSelection' | 'toInitialSelectionOnEditing' | 'toInitialSelection' | 'export_xls' | 'export_csv' | 'export_png' | 'export_svg';

export declare interface IVersionedPluginDefinition extends IPluginDefinition {
    /**
     * The version of the API used while building the customer's plugin module.
     */
    apiVersion: ReportingVersion;
}

/**
 * Support for repetition widget | pivot table expanding to make the whole content visible.
 */
export declare interface IWidgetBoxExpandOptions {
    active: boolean;
    keepBoxHeader: boolean;
    keepTableHeader: boolean;
    onlyWhenPrinting: boolean;
}

/**
 * Widget box configuration when the widget is rendered in the responsive grid layout.
 * This is used instead of the regular rectangle and positionOrder configuration.
 */
export declare interface IWidgetBoxGridLayoutInfo {
    /**
     * Handy (same as in IWidgetDefinition).
     */
    widgetId: string;
    /**
     * The responsive grid layout is made of a single flex (row) box.
     * The index in the only row of the 'flex' layout.
     */
    position: number;
    /**
     * A part of the total number of columns in the 'flex' layout.
     */
    colSpan: number;
    /**
     * The actual physical height.
     */
    height: number;
    /**
     * The group (i.e., nested grid layout) this widget belongs to.
     */
    group?: IWidgetBoxGroupGridLayoutInfo;
}

/**
 * Support for nested grid layout : a grid item can be a group of widgets rendered as a grid layout.
 *
 * The actual number of columns of this nested grid layout is the colSpan of the group seen as a regular
 * item of the containing grid layout. The group inherit both the column and row spacing of its containing
 * grid layout and has no margin.
 *
 * For the sake of simplicity a group cannot contain a group.
 */
export declare interface IWidgetBoxGroupGridLayoutInfo {
    groupId: string;
    /**
     * A group is a regular item of its containing grid layout.
     * @see IWidgetBoxGridLayoutInfo
     */
    position: number;
    /**
     * A group is a regular item of its containing grid layout.
     * @see IWidgetBoxGridLayoutInfo
     */
    colSpan: number;
    /**
     * A group is a regular item of its containing grid layout.
     * @see IWidgetBoxGridLayoutInfo
     */
    height: number;
}

/**
 * Set to `true` to hide the icon.
 */
export declare interface IWidgetBoxIconsDefinition {
    disableQueryFilter?: boolean;
    disableQueryCellOnError?: boolean;
    disableQueryMaxRowsReached?: boolean;
    disableDrilldown?: boolean;
    disableHelp?: boolean;
    disableInteractionSwitch?: boolean;
}

export declare interface IWidgetDefaultsManager {
    registerWidgetDefaults(defaults: IThemeWidgetDefaults): void;
}

export declare interface IWidgetEditorPublicContext {
    /**
     * The variants available in the theme for the edited widget.
     */
    getWidgetVariantIds(componentName?: string): string[];
}

declare interface IWidgetIcons extends IWidgetBoxIconsDefinition, Record<string, any> {
    /**
     * Set to true to make the widget icon options readonly (non-editable) for all widgets. Also, this enforces to
     * always use the default values set in the theme.
     * @see {ic3ThemeOptions.widgetIcons}
     * @see {ic3ThemeOptions.widgetDefaults}
     */
    disableWidgetIconsEdition?: boolean;
}

export declare type IWidgetInteractionMode = "drilldown" | "selection";

/**
 * Experimental.
 */
export declare interface IWidgetLayoutCssGridDefinition {
    gridTemplateColumns: string;
    gridTemplateRows: string;
    gridTemplateAreas: string;
}

export declare interface IWidgetLayoutData {
    /**
     * Keep box header settings for additional (i.e., generated) pages.
     */
    keepBoxHeader: boolean;
    /**
     * Keep box header settings for additional (i.e., generated) pages.
     */
    keepTableHeader: boolean;
    startRow: number;
    endRow: number;
}

/**
 * E.g., size, orientation, ...
 */
export declare interface IWidgetLayoutDefinition {
    /**
     * icCube internal : used to create a missing layout when resolving
     * the layout definition id of the dashboard definition.
     */
    missing?: true;
    /**
     * icCube internal : used to create a missing layout when resolving
     * the layout definition id of the dashboard definition.
     */
    missingLayoutConfigId?: string;
    layoutConfigId: string;
    layoutGroup: string;
    layoutName: string;
    /**
     * CSS class of the layout.
     */
    cssClass?: string;
    /**
     * The theme is defining a scale (widgetContentPrintScale) applied to the widget content
     * when rendered for printing. The following flag is requesting to render the widget content
     * on screen using the printing scale.
     *
     * We advise defining it for any layout dedicated for printing (e.g., A4, Letter) to get a
     * visual rendering close to the printed one.
     */
    applyWidgetContentPrintScaleForRendering?: true;
    /**
     * Not relevant if responsiveness is being defined: always an unlimited portrait.
     */
    pageSize: IKnownPageSize | IManualPageSize | IUnlimitedPageSize;
    /**
     * Not relevant if responsiveness is being defined: always an unlimited portrait.
     */
    pageOrientation: PaperOrientation;
    /**
     * Not relevant if responsiveness is being defined: margins are defined per breakpoint.
     */
    pageMargin: IPageMargin;
    /**
     * Use the one defined from the theme (ic3 palette) when not defined here.
     */
    pageBackgroundColor?: Property.Color;
    /**
     * Widgets are zoomed so that their bounding box fits the horizontal page area.
     * Not relevant if responsiveness is being defined.
     */
    expandH?: boolean;
    /**
     * Control how this layout is responding to width change : check ic3-demo-plugin-them
     * (https://github.com/ic3-software/ic3-demo-plugin-theme) for a complete example.
     */
    responsiveness?: IWidgetLayoutResponsivenessDefinition;
    /**
     * Experimental.
     */
    cssGrid?: IWidgetLayoutCssGridDefinition;
    /**
     * The background grid used for example to snap widgets to.
     * Not related to the grid layout itself.
     */
    grid: IWidgetLayoutGridDefinition;
    header?: IPageHeaderFooterDefinition;
    footer?: IPageHeaderFooterDefinition;
}

/**
 * The background grid used for example to snap widgets to.
 * Not related to the grid layout itself.
 */
export declare interface IWidgetLayoutGridDefinition {
    snap: boolean;
    show: boolean;
    width: number;
    height: number;
}

export declare interface IWidgetLayoutInfo extends IRectangle {
    pageNb: number;
    positionOrder: number;
    gridLayoutInfo?: IWidgetBoxGridLayoutInfo;
    data?: IWidgetLayoutData;
    resizingConstraint?: ResizingConstraintOptions;
    positionMode?: PositionModeOptions;
    /**
     * When _ printing _, the widget's layout has been converted and this scale has been applied to compute
     * the new widget size.
     */
    widgetContentScaled?: number;
}

/**
 * Control how the layout is responding to width change.
 */
export declare interface IWidgetLayoutResponsivenessDefinition {
    /**
     * Grid only for now.
     */
    type: "grid";
    /**
     * The number of virtual columns the widgets are aligned to (e.g., 12).
     */
    columnCount: number;
    /**
     * The number of pixels of each virtual column.
     */
    columnWidth: number;
    /**
     * Setup once the layout configuration is being resolved against the theme.
     */
    themeSpacing: number;
    /**
     * The grid column span multiplier (i.e., x2 when the tables so widgets are twice as wide).
     */
    multiplier: ResponsiveValue;
    /**
     * The grid margins.
     */
    margin: ResponsiveValue;
    /**
     * Defines the horizontal space between the widgets.
     */
    columnSpacing?: ResponsiveValue;
    /**
     * Defines the vertical space between the widgets.
     */
    rowSpacing?: ResponsiveValue;
    print?: {
        multiplier: number;
        columnSpacing: number;
        rowSpacing: number;
    };
    printLandscape?: {
        multiplier: number;
        columnSpacing: number;
        rowSpacing: number;
    };
    /**
     * Defines a grid to snap the height of the widgets in group.
     *
     * When the group grid is defined as %, the grid percentages will be kept on group height resizing
     * (not the case if the grid is defined in pixels).
     *
     * <ul>
     *     <li> undefined   : no constraint.
     *     <li> array       : a list of percentages to snap the widgets (e.g., [0.1,.0.2,0.3....1.0] to have
     *                        a grid 10% of group height, 20%, etc...).
     *     <li> number < 1  : a percentage of the group height.
     *     <li> number >= 1 : grid in pixels
     * </ul>
     */
    groupSnapSteps: number[] | number;
}

export declare interface IWidgetManager {
    registerWidget<OPTIONS extends FormFieldObject>(widget: IPublicWidgetTemplateDefinition<OPTIONS>): void;
    registerWrappedWidget<WIDGET extends WidgetTemplateIDs>(widget: IWrappedWidgetTemplateDefinition<WIDGET>): void;
}

export declare interface IWidgetPublicContext extends IPublicContext {
    /**
     * Context unlikely to change during the lifecycle of a widget
     * more appropriate to use in a React hook context.
     */
    getStableContext(): IWidgetStableContext;
    /**
     * Get the width of the widget box in pixels.
     */
    getWidgetWidth(): number | undefined;
    /**
     * Get the height of the widget box in pixels.
     */
    getWidgetHeight(): number | undefined;
    getWidgetPageNb(): number;
    /**
     * Returns true if and only if the widgets has a header (from the chart box settings).
     */
    widgetHasHeader(): boolean;
    getBoxSettings(): IPublicWidgetBoxSettings;
    /**
     * True if and only if the widget is invisible, e.g., it has display none.
     */
    isInvisible(): boolean;
}

export declare interface IWidgetRectangle {
    top: number;
    left: number;
    height: number;
    width: number;
}

export declare interface IWidgetStableContext extends IPublicContext {
    getTemplateId(): string;
    getNsId(): string;
    getWidgetId(): string;
    getTemplateId(): string;
    isPrintingMode(): boolean;
    renderWidgetContentMessage(type: IContentMessageType, message: string): any;
    renderLazyTreeView<T>(props: LazyTreeViewProps): T;
    wrapWithTooltip(tooltip: string | undefined, wrappedElement: React.ReactElement): React.ReactElement;
    onWidgetRenderStatusChange(status: WidgetRenderLayoutStatus): void;
    /**
     * Event methods that do not depend on a Table
     *
     * @see ITidyTableInteractionEvent for more
     */
    /**
     * returns true if the actionName in bound to a channel
     */
    firesEvent(actionName: string): boolean;
    /**
     * actionName if the action is bound to a channel, clears the event (has no value)
     */
    fireClearEvent(actionName: string): void;
    /**
     * actionName if the action is bound to a channel, send an Mdx Event (value,mdx)
     */
    fireMdxEvent(actionName: string, value: string, mdx: string): void;
    fireMdxEvents(events: {
        actionName: string;
        value: string;
        mdx: string;
    }[]): void;
    /**
     * Cypress testing purpose, after a rendering of the chart
     */
    incrementWidgetContentRendering(): void;
    getWidgetTemplateDefinition(qualifiedId: string): IPublicWidgetTemplateDefinition<any>;
    resolveWidgetTemplateDefinition(definition: IPublicWidgetTemplateDefinition<any>): Promise<IPublicWidgetTemplateDefinition<any>>;
    /**
     * React -> combines useReduxOwnProps and setReduxOwnProps with a similar syntax to Redux.useState
     *
     * Note it's NOT the initial value but value if undefined
     */
    useReduxOwnPropsState<T>(fieldName: string, valueIfUndefined?: T): [T, (newValue: T | undefined) => void];
    /**
     * React -> useSelector on widgetOwnProps[fieldName]
     */
    useReduxOwnProps<T>(fieldName: string): T;
    /**
     * Redux -> set in Redux value in widgetOwnProps[fieldName]
     */
    setReduxOwnProps(fieldName: string, value: any): void;
    /**
     * Google map
     */
    /**
     * React only, like an use function
     *
     * Loads Google map library with the API key as set
     *
     * return
     *          true when the google map is ready (lib loaded)
     *          error when
     */
    reactUseGoogleMap(): boolean | Error;
    /**
     * React only, like an use function
     *
     * reactUseGoogleMap() + rendered the map into the div referenced by ref with mapOptions
     *
     * @param mapOptions google.maps.MapOptions
     * @param ref ref React.RefObject<HTMLDivElement>
     *
     * return
     *          undefined if loading
     *          {map} google.maps.Map instance when loaded
     *          {error} if loaded on error
     */
    reactUseGoogleMapPlus(mapOptions: any, ref: any): undefined | {
        map?: any;
        error?: Error;
    };
    /**
     * Returns latitude and longitude with the same logic as for internal maps
     *
     *
     */
    getMapCoordinates(table: ITidyTable): [ITidyNumericColumn, ITidyNumericColumn] | [];
    getGoogleMapRenderedDelayMS(): number;
    /**
     * Displays an warning icon in the widget header showing the warning when the user hovers the icon.
     * Be sure to clear all warnings before rendering using {@see widgetClearWarnings}
     */
    addWidgetWarning(warning: string, severity?: WidgetWarningSeverity): void;
    /**
     * Clear the warnings in the widget.
     */
    widgetClearWarnings(): void;
    /**
     * Notification
     *
     * like a listener on the components, for React the implementation uses a useEffect, it should
     * NOT be called conditionally.
     */
    useNotification(notifications: WidgetNotificationHandler | WidgetNotificationHandler[], deps: ReadonlyArray<unknown> | undefined): void;
    useUserMenu(handler: (userMenu: string) => any | void, deps: ReadonlyArray<unknown> | undefined): void;
    /**
     * doExport callback is called on each exportToExcel from the userMenu of the widget
     *
     * if the callback returns a tidyTable, this table will be exported
     * if undefined is returned no further action
     *
     * disabled === true, the doExport function is not used
     */
    onExportToExcel(doExport: undefined | (() => ITidyTable | undefined | null), disabled?: boolean): void;
    /**
     * Export the widget data to Excel or CSV.
     * @param table data in the widget (with transformations applied).
     * @param asPivotForExcel If true, convert hierarchical structures to flat columns. Default = false for Excel
     * exports and true for CSV exports.
     * @param rows filter the table by these rows before exporting.
     * @param event object. If `event.format = 'csv'` then this method makes a CSV export. Default is Excel.
     * `event.value` (optional) is the file name of the export.
     */
    exportToExcel(table: ITidyTable, asPivotForExcel: boolean | undefined, rows: number[] | undefined, event?: {
        format?: 'csv' | 'xlsx';
        value?: string;
    }): void;
    useUserMenuWidth(): number | undefined;
    /**
     * Get the (translated) file name for exporting. Does not include file extension. Method returns 'export-file'
     * if no file name is found.
     * @param defaultName if not undefined, method returns this.
     * @param defaultFileName
     */
    getExportFileName(defaultFileName?: string): string;
    /**
     * Returns the report name of the report defining this widget (i.e. could be the embedding)
     */
    getDefiningReportName(): string;
    /**
     * Returns the report path of the report defining this widget (i.e. could be the embedding)
     */
    getDefiningReportPath(): string;
    /**
     * Returns the report folder name of the report defining this widget (i.e. could be the embedding)
     */
    getDefiningReportFolderName(): string;
}

declare interface IWidgetTemplateChartOptions {
    "ic3.AIChatBox": AIWidgetChatBotOptions;
    "ic3.DatePicker": DatePickerChartOptions;
    "ic3.EmbeddedReport": EmbeddedReportChartOptions;
    "ic3.FilterAutocomplete": FilterAutocompleteChartOptions;
    "ic3.FilterAutocompleteLazy": FilterAutocompleteChartOptions;
    "ic3.FilterButtons": FilterButtonsChartOptions;
    "ic3.FilterCheckboxRadio": FilterCheckboxRadioChartOptions;
    "ic3.FilterPanel": FilterPanelChartOptions;
    "ic3.FilterSlider": FilterSliderChartOptions;
    "ic3.FilterTree": FilterTreeChartOptions;
    "ic3.FilterSwitch": FilterSwitchChartOptions;
    "ic3.GoogleHeatMap": GoogleHeatMapChartOptions;
    "ic3.GoogleKmlLayer": GoogleKmlLayerChartOptions;
    "ic3.GoogleMarker": GoogleMarkerChartOptions;
    "ic3.Image": ImageChartOptions;
    "ic3.KpiBox": KpiBoxChartOptions;
    "ic3.KpiCard": KpiCartChartOptions;
    "ic3.MarkdownText": MarkdownTextChartOptions;
    "ic3.PrintButton": PrintButtonChartOptions;
    "ic3.PivotTable": PivotTableChartOptions;
    "ic3.RepetitionWidget": RepetitionWidgetChartOptions;
    "ic3.Table": TableChartOptions;
    "amCharts4.AmCharts4BubbleChart": AmCharts4BubbleChartOptions;
    "amCharts4.AmCharts4ComboChart": AmCharts4ComboChartOptions;
    "amCharts4.AmCharts4RegularAreaChart": AmCharts4RegularAreaChartOptions;
    "amCharts4.AmCharts4RegularBarChart": AmCharts4RegularBarChartOptions;
    "amCharts4.AmCharts4RegularColumnChart": AmCharts4RegularColumnChartOptions;
    "amCharts4.AmCharts4RegularLineChart": AmCharts4RegularLineChartOptions;
    "amCharts4.AmCharts4ScatterPlot": AmCharts4ScatterPlotOptions;
    "amCharts4.AmCharts4StackedAreaChart": AmCharts4StackedAreaChartOptions;
    "amCharts4.AmCharts4StackedBarChart": AmCharts4StackedBarChartOptions;
    "amCharts4.AmCharts4StackedColumnChart": AmCharts4StackedColumnChartOptions;
    "amCharts4.AmCharts4DonutChart": AmCharts4DonutChartOptions;
    "amCharts4.AmCharts4GaugeChart": AmCharts4GaugeChartOptions;
    "amCharts4.AmCharts4Histogram": AmCharts4HistogramOptions;
    "amCharts4.AmCharts4SankeyDiagram": AmCharts4SankeyDiagramOptions;
    "amCharts4.AmCharts4TreeMap": AmCharts4TreemapOptions;
    "amCharts4.AmCharts4GanttChart": AmCharts4GanttChartOptions;
    "amCharts4.AmCharts4DivergentBarChart": AmCharts4DivergentBarChartOptions;
    "amCharts4.AmCharts4GeoMap": GeoMapChartOptions;
}

/**
 * The mapping meta are all the column that the user can select in the chart options. These options are checked for
 * validity. The widget generates an error if columns are selected that are not in the allowed properties, or if
 * columns are mandatory but there is no selection or fallback.
 */
export declare type IWidgetTemplateDataMappingDef = IFormColumnChooserFieldDef;

export declare interface IWidgetTemplateMdxBuilderAxisProps {
    /**
     * Unique name used in the UI and if mdxAxisName not defined for building the query.
     * If name is 'rows' for example, then in the query it will use 'ON "rows"'.
     */
    name: string;
    /**
     * The axis can be empty
     */
    isOptional?: true;
    /**
     * All axes with the same (not null) value for mdxAxisName are put as a tuple on the same axis. And the roles are
     * comma separated.
     */
    mdxAxisName?: string;
    /**
     * Disable empty
     */
    disableNonEmpty?: true;
    /**
     * For filters add lazy load feature to the axis.
     */
    withLazySearch?: true;
    /**
     * Allow only a single member
     */
    singleMember?: true;
    /**
     * Allow a multiple hierarchies to build a crossjoin
     */
    multipleHierarchy?: true;
    /**
     * Additional constraints for the set/members
     */
    constraint?: IWidgetTemplateMdxBuilderAxisPropsConstraint;
    decoration?: {
        with?: string;
        set: string;
    };
    /**
     * Show the mdxAxis names in this order in the builder
     */
    showOrder?: number;
    /**
     * Allows to overwrite the ON "rows"in the MDX query  (to be used on modifyDefinition function)
     */
    overwriteAxisName?: string;
    /**
     * This is used to give end customers information on the limit of the query (column have 1000 by default, rows 100'000)
     */
    infoForSizing?: "TIDY_ROW" | "TIDY_COL";
}

export declare enum IWidgetTemplateMdxBuilderAxisPropsConstraint {
    DateType = "DateType",
    GeoLatLong = "GeoLatLong",
    GeoIso2Code = "GeoIso2Code"
}

export declare interface IWidgetTemplateMdxBuilderMapping {
    /**
     * The order determines the order of the statements in the query. E.g., the first position is ON 0, the second ON 1,
     * etc., where '0' and '1' are replaced by the name.
     */
    mdxAxis: Readonly<IWidgetTemplateMdxBuilderAxisProps[]>;
    /**
     * The generated MDX is for a filter (the cell values are not of interest).
     */
    mdxIsForFilter?: true;
    /**
     * The cell values are not needed.
     */
    withoutCellValues?: true;
    /**
     * The cell values are not needed if there is a single axis in the query.
     */
    withoutCellValuesSingleAxis?: true;
    /**
     * An MDX query if the builder is empty.
     */
    mdxQueryIfEmpty?: boolean;
    /**
     *  model is a IMdxQueryBuilderModel, that is not shared publicly yet
     *
     *  returns a modified definition or an MDX statement in a string
     *
     *  If we return a string (MDX Statement), the Filters are still going to be appended to the end
     */
    modifyDefinition?: (model: any, definition: IWidgetTemplateMdxBuilderMapping) => IWidgetTemplateMdxBuilderMapping | string;
}

export declare interface IWidgetTemplateTidyData {
    table: ITidyTable;
    inter: ITidyTableInteraction;
}

export declare interface IWidgetTemplateTidyOptions<T extends FormFieldObject> {
    table: ITidyTable;
    options: T;
}

export declare interface IWidgetVariantManager {
    registerVariants(variants: IThemeRegisterVariant): void;
}

export declare interface IWrappedWidgetTemplateDefinition<WIDGET extends WidgetTemplateIDs> {
    /**
     * Some free text used while registering the wrapper (e.g., error purpose).
     */
    readonly registrationInfo: string;
    /**
     * e.g., ic3.Table
     */
    readonly wrappedWidgetTemplateId: WIDGET;
    /**
     * A function generating the widget template definition based on the wrapped widget template definition.
     */
    readonly wrapper: (wrapped: IPublicWidgetTemplateDefinition<WidgetTemplateChartOptions[WIDGET]>) => IPublicWidgetTemplateDefinition<FormFieldObject>;
}

/**
 * KPI Box Options (fields of the "Chart" tab in the widget editor).
 *
 * <pre>
 *      Plugin ID         : ic3
 *      Widget/Template ID: KpiBox
 * </pre>
 *
 * @see WidgetTemplateChartOptions
 */
export declare interface KpiBoxChartOptions extends FormFieldObject {
    variant?: HtmlBoxVariant;
    /**
     * Pre Markdown.
     *
     * Expression that returns a markdown text. Evaluated once before row's markdown.
     */
    preMarkdown?: string;
    /**
     * Markdown.
     *
     * Expression that returns a markdown text. Evaluated for each row of the tidy table.
     */
    markdown: string;
    /**
     * Post Markdown.
     *
     * Expression that returns a markdown text. Evaluated once after row's markdown.
     */
    postMarkdown?: string;
}

export declare class KpiCardClasses {
    static root: string;
    static valuesContent: string;
    static chartContent: string;
    static valueTitle: string;
    static valueText: string;
    static kpiCompareTextRoot: string;
    static kpiCompareTextRootEmpty: string;
    static comparePercentageText: string;
    static compareTargetText: string;
    static comparePercentZero: string;
    static comparePercentUp: string;
    static comparePercentDown: string;
}

export declare type KpiCardClassKey = keyof KpiCardClasses;

export declare interface KpiCardProps {
    /**
     * Variant defined in the theme. If the theme has variants, then the user can select one.
     */
    variant?: string;
    sparklinePosition: SparklinePosition;
    targetPosition: TargetTextPosition;
}

/**
 * KPI Card Options (fields of the "Chart" tab in the widget editor).
 *
 * <pre>
 *      Plugin ID         : ic3
 *      Widget/Template ID: KpiCard
 * </pre>
 *
 * @see WidgetTemplateChartOptions
 */
export declare interface KpiCartChartOptions extends SparkChartOptionsMeta {
    /**
     * Variant defined in the theme. If the theme has variants, then the user can select one.
     */
    variant?: string;
    /**
     * Value.
     *
     * The KPI value to show in the widget.
     */
    value: TidyTableColumnSelector;
    /**
     * Target.
     *
     * Compare the value with this target value.
     */
    target?: TidyTableColumnSelector;
    /**
     * Historical Data.
     *
     * The data for the sparkline. This must be a list of numbers, e.g., [43, 5, 2, 4].
     * The color of the sparkline depends on the trend of the sparkline.
     */
    data?: TidyTableColumnSelector;
    /**
     * Title Text.
     *
     * The text above the value.
     */
    titleText: string;
    /**
     * Value Text.
     *
     * The text for the value.
     */
    valueText: string;
    /**
     * Target Text.
     *
     * The text to display after the percentage difference.
     */
    targetText: string;
    /**
     * Interpretation.
     *
     * How to compare the value and the target.
     */
    targetInterpretation: CompareTextInterpretationType;
    /**
     * Target Position.
     *
     * Where to display the target.
     */
    targetPosition: TargetTextPosition;
    /**
     * Trend Icon.
     *
     * Display the trend icon?
     */
    includeTrendIcon: boolean;
    /**
     * Delta for zero value
     *
     * If the target value is below this delta value it is considered as a delta value  (rounding issue)
     */
    deltaZero?: number;
    /**
     * Icon.
     *
     * The icon that indicate the trend.
     */
    iconSet: TargetTextIconSet;
    /**
     * Position.
     *
     * Where to display the sparkline.
     */
    sparklinePosition: SparklinePosition;
}

export declare class LayoutClasses {
    /**
     * When dragging a box, to keep the cursor on move
     */
    static widgetBoxDragActiveClass: string;
    static widgetSelector: string;
    static widgetBoxSelected: string;
    static widgetBoxSelectedEx: string;
}

export declare type LayoutClassKey = keyof LayoutClasses;

export declare class LayoutPageClasses {
    static root: string;
    /**
     * Style applied to the root element containing the dashboard pages.
     */
    static widgetPage: string;
    /**
     * Style applied to
     */
    static widgetPageMargin: string;
    /**
     * Style applied to
     */
    static widgetPageGrid: string;
    /**
     * Style applied to
     */
    static widgetPageWidgets: string;
    /**
     * Style applied to the page on hover.
     */
    static widgetPagePH: string;
}

export declare type LayoutPageClassKey = keyof LayoutPageClasses;

export declare class LazyTreeClasses {
    /**
     * Style applied to the root element.
     */
    static readonly lazyRoot = "ic3LazyTreeView-root";
    /** Styles applied to the search toolbar element */
    static readonly toolbar = "ic3LazyTreeView-toolbar";
    /** Styles applied to the search search input element */
    static readonly input = "ic3LazyTreeView-toolbar-input";
    /** Styles applied to the select filter button (on) */
    static readonly button = "ic3LazyTreeView-toolbar-button";
    /** Styles applied to the select filter button (on) */
    static readonly buttonFilterSelectedOn = "ic3LazyTreeView-toolbar-buttonOn";
    /** Styles applied to the select filter button (off) */
    static readonly buttonFilterSelectedOff = "ic3LazyTreeView-toolbar-buttonOff";
    /** Styles applied to the TreeRoot element */
    static readonly treeRoot = "ic3LazyTreeView-treeRoot";
    /**
     * Item classes
     */
    static readonly itemRoot = "ic3LazyTreeView-itemRoot";
    static readonly itemContainer = "ic3LazyTreeView-itemContainer";
    static readonly leftDiv = "ic3LazyTreeView-itemLeftDiv";
    static readonly itemLabelContainer = "ic3LazyTreeView-itemLabelContainer";
    static readonly itemIcon = "ic3LazyTreeView-itemIcon";
}

export declare type LazyTreeClassesClassKey = keyof LazyTreeClasses;

/**
 * A copy of MUI TreeItemClasses
 */
export declare interface LazyTreeItemClasses {
    /** Styles applied to the root element. */
    root: string;
    /** Styles applied to the transition component. */
    group: string;
    /** Styles applied to the content element. */
    content: string;
    /** Pseudo-class applied to the content element when expanded. */
    expanded: string;
    /** Pseudo-class applied to the content element when selected. */
    selected: string;
    /** Pseudo-class applied to the content element when focused. */
    focused: string;
    /** Pseudo-class applied to the element when disabled. */
    disabled: string;
    /** Styles applied to the tree node icon. */
    iconContainer: string;
    /** Styles applied to the label element. */
    label: string;
}

export declare interface LazyTreeProps {
}

/**
 * Controlled properties of LazyTreeView (doesn't has to be lazy)
 */
export declare interface LazyTreeViewProps {
    logId: string;
    lazyLoader: ILazyTreeViewLoader;
    /**
     *
     */
    addFilterSelected?: boolean;
    /**
     * Adds a search input to the tree filter
     */
    addSearch?: boolean;
    /**
     * Search/Filter text when controlled (addSearch needs to be false)
     */
    search?: string;
    /**
     * Message for the search/filter when empty
     */
    searchPlaceholder?: string;
    /**
     * Message for the search/filter component (might be 'compacted' selection)
     */
    searchMessage?: string;
    toggleFilterSelected?: string;
    disableSelection?: boolean;
    /**
     * the selection state is managed by the lazy tree as well
     */
    selected: string[];
    /**
     * Controlled mode for selection
     */
    setSelected?: (event: default_2.MouseEvent, treeNode: TreeRowPropsTreeData) => void;
    /**
     * Controlled mode for expanded or initial expanded if not controlled
     */
    expanded?: string[];
    /**
     * Controlled mode for expanded
     */
    setExpanded?: (nodeIdx: string[]) => void;
    /**
     * The level depth of initially open nodes ( 0 first level )
     */
    openDepthLevel?: number;
    /**
     * Material-UI tree item classes Partial<TreeItemClasses>
     */
    treeItemClasses?: Partial<LazyTreeItemClasses>;
    /**
     * Create a custom label for the tree item.
     * @param rowIndex the index of the data object (e.g. column, tidy table)
     * @param label current label. Use this label as text because the filtering is highlighted.
     */
    getTreeItemLabel?: (rowIndex: number, label: string | ReactElement) => string | ReactElement;
    /**
     * If undefined, width and height are calculated automatically.
     */
    width?: number;
    height?: number;
    /**
     * Height of an item in the tree. Defaults to 38.
     */
    itemSize?: number;
    /**
     * @See react-window List
     */
    initialScrollOffset?: number | undefined;
    /**
     * @See react-window List
     */
    onScroll?: ((props: ListOnScrollProps) => any) | undefined;
}

export declare enum LeftBarOptions {
    None = 0,
    EditorMode = 1,
    AppViewerLeftFilter = 2,
    AppViewerRightFilter = 3
}

export declare enum LegendPositionOption {
    "bottom_left" = "bottom_left",
    "bottom_center" = "bottom_center",
    "bottom_right" = "bottom_right",
    "right_bottom" = "right_bottom",
    "right_middle" = "right_middle",
    "right_top" = "right_top",
    "top_right" = "top_right",
    "top_center" = "top_center",
    "top_left" = "top_left",
    "left_top" = "left_top",
    "left_middle" = "left_middle",
    "left_bottom" = "left_bottom"
}

declare class ListCounterClasses {
    static readonly counter = "ic3Counter";
    /**
     * Classname added to the root when the orientation is vertical.
     */
    static readonly vertical = "ic3ListCounter-vertical";
    static readonly labelRoot = "ic3ListCounter-labelRoot";
    static readonly label = "ic3ListCounter-Label";
    static readonly labelRemove = "ic3ListCounter-labelRemove";
    static readonly labelSmallSize = "ic3ListCounter-Label-SizeMin";
    static readonly labelMediumSize = "ic3ListCounter-Label-SizeMedium";
}

declare type ListCounterClassKey = keyof ListCounterClasses;

declare interface ListCounterProps {
}

export declare interface ListOnScrollProps {
    scrollDirection: ScrollDirection;
    scrollOffset: number;
    scrollUpdateWasRequested: boolean;
}

export declare type LocalizeContext = Pick<IPublicContext, 'localize'>;

declare interface MandatorySingleColors {
    /**
     * if not defined, primary color of MUI theme
     */
    default: Property.Color;
    /**
     * if not defined, secondary color of MUI theme
     */
    secondary: Property.Color;
    /**
     * if not defined, selection color of ic3.palette theme
     */
    selected: Property.Color;
    /**
     * if not defined, text.disabled MUI theme
     */
    disabled: Property.Color;
    /**
     * if not defined, success MUI theme
     */
    success: Property.Color;
    /**
     * if not defined, error MUI theme
     */
    error: Property.Color;
    /**
     * if not defined, warning MUI theme
     */
    warning: Property.Color;
    /**
     * if not defined, text.primary MUI theme
     */
    text: Property.Color;
    /**
     * if not defined, grey100 MUI theme
     */
    white: Property.Color;
    /**
     * if not defined, grey100 MUI theme
     */
    grey100: Property.Color;
    /**
     * if not defined, grey200 MUI theme
     */
    grey200: Property.Color;
    /**
     * if not defined, grey400 MUI theme
     */
    grey400: Property.Color;
    /**
     * if not defined, grey700 MUI theme
     */
    grey700: Property.Color;
    /**
     * if not defined, grey900 MUI theme  (kind of a less agressive black)
     */
    grey900: Property.Color;
}

/**
 * Markdown Text Options (fields of the "Chart" tab in the widget editor).
 *
 * <pre>
 *      Plugin ID         : ic3
 *      Widget/Template ID: MarkdownText
 * </pre>
 *
 * @see WidgetTemplateChartOptions
 */
export declare interface MarkdownTextChartOptions extends FormFieldObject {
    /**
     * Variant.
     *
     * Allows for selecting a set of preset options. Note that a variant is possibly overriding defined options.
     */
    variant?: HtmlBoxVariant;
    /**
     * Markdown.
     *
     * A text following the basic syntax of the markdown (GitHub Flavored Markdown (GFM)) markup language
     * ([www](https://www.markdownguide.org/basic-syntax/)).
     */
    "$-markdown"?: string;
}

export declare type MdxExpressionType = "calcMeasure" | "drilldown";

export declare interface MdxInfo {
    uniqueName: string;
    /**
     * The key parsed as date|time.
     */
    key: any;
    /**
     * The key as converted to string in the client.
     */
    keyS: string | undefined;
    name: string;
    caption: string;
    isAll?: boolean;
    pun?: string;
    /**
     * Children count
     */
    cc?: number;
    levelCaption?: string;
    /**
     * Relative: starts at 0 + visual depths for ragged dimension.
     */
    levelDepthR: number;
    /**
     * Actual MDX level depth
     */
    levelDepth: number;
    /**
     * hierUN
     */
    hierUN: string;
}

export declare type MdxLevelSubType = "YEAR" | "HALF_YEAR" | "QUARTER" | "MONTH" | "WEEK" | "DAY" | "DAY_MONTH" | "DAY_YEAR" | "HOUR" | "HALF_HOUR" | "QUARTER_HOUR" | "MINUTE" | "SECOND";

export declare type MdxLevelType = "date" | "time";

/**
 *  Identifies a Mdx node in a query.
 *
 *  For queries with more than 2 axis multiple rows might point to the same NodeIdentifier
 */
export declare interface MdxNodeIdentifier {
    readonly uid: string;
    readonly axis: number;
    readonly hierarchyIdx: number;
    readonly tupleUNs: ReadonlyArray<string>;
    readonly captions?: ReadonlyArray<string>;
    readonly tupleIdx: number;
    readonly levelDepthR?: number;
}

export declare interface MdxRepetitionInfo {
    /**
     * The number of members in the axis (From 'len' in the json axis guts).
     */
    axisLength: number;
    /**
     * Number of repetitions for each member. See ITidyBaseColumn > repeat.
     */
    repetition: number;
}

declare type NonNullable_2<T> = Exclude<T, null | undefined>;

export declare enum OverflowType {
    WRAP = "WRAP",
    TRUNCATE = "TRUNCATE",
    NONE = "NONE"
}

/**
 * <pre>
 *     unlimited: in height (page width is always known).
 * </pre>
 */
export declare type PageSize = "known" | "manual" | "unlimited";

export declare type PaperOrientation = "portrait" | "landscape";

export declare type PaperSizeName = "A5" | "A4" | "A3" | "B5" | "B4" | "Letter" | "Legal" | "Ledger" | "JIS-B5" | "JIS-B4";

export declare type PaperSizeUnits = "px" | "mm" | "cm" | "in";

/**
 * Pivot Table Options (fields of the "Chart" tab in the widget editor).
 *
 * <pre>
 *      Plugin ID         : ic3
 *      Widget/Template ID: PivotTable
 * </pre>
 *
 * @see WidgetTemplateChartOptions
 */
export declare interface PivotTableChartOptions extends BaseTableChartOptions {
    /**
     * Name of a variant. Note that a variant is possibly overriding defined options.
     */
    variant?: string;
    /**
     * Left Header Names (CSV).
     *
     * Names of the columns in the left header. A comma separated list of values
     * ($h for the hierarchy name, $l for the level name). The last value repeat itsef.
     */
    cornerText?: string;
    /**
     * Sortable (CSV).
     *
     * Display the sort options for the top left header. A list of boolean values: 'true', 'false'. The last value repeats itself.
     */
    leftHeaderSortable: string;
    /**
     * Merge Left Header.
     *
     * Use a single cell int the top left corner of the table.
     */
    mergeLeftHeader: boolean;
    /**
     * Wrap Top Header.
     *
     * Display the top header content on multiple lines.
     */
    topHeaderWrap: boolean;
    /**
     * Flatten Top Header.
     *
     * Removes drilldown and parent/child relations from top header.
     */
    flattenTopHeader: boolean;
    /**
     * Left Header Alignment (CSV).
     *
     * The first column (possibly a multi-hierarchy axis). A comma separated list of values:
     * 'left', 'center', 'right'. The last value repeats itself.
     */
    columnLeftHeaderAlign: string;
    /**
     * Hover Behavior.
     *
     * Highlight rows and/or columns on hover.
     */
    hoverOptions: PivotTableHoverEffectOptions;
}

export declare class PivotTableClasses {
    static readonly main = "ic3-pt";
    static readonly cell = "ic3-pt-cell";
    static readonly totalRow = "ic3-pt-row.ic3-totalRow";
    static readonly leftHeaderCell = "ic3-pt-col.lh";
    static readonly leftHeaderTitle = "ic3-pt-col.lh .ic3-pt-header-label";
    static readonly topHeaderCell = "ic3-pt-col.th";
    static readonly topHeaderTitle = "ic3-pt-col.th .ic3-pt-header-label";
    static readonly column = "ic3-pt-col";
    static readonly columnSeparator = "ic3-pt .ic3-pt-col-separator";
    static readonly columnSeparatorContent = "ic3-pt .ic3-pt-col-separator-content";
    static readonly icon = "ic3-pt-icon";
    static readonly iconSort = "ic3-pt-icon-sort";
    static readonly emptyHeader = "ic3-pt-empty-header";
    static readonly selected = "ic3-pt-selected";
    static readonly hover = "ic3-pt-hover";
}

/**
 * List of classNames available
 */
export declare type PivotTableClassKey = keyof PivotTableClasses;

export declare enum PivotTableHoverEffectOptions {
    NONE = "NONE",
    SELECTION_OR_ROW = "SELECTION_OR_ROW",
    ROW_OR_COLUMN = "ROW_OR_COLUMN",
    ROW_AND_COLUMN = "ROW_AND_COLUMN",
    ROW_ONLY = "ROW_ONLY",
    COLUMN_ONLY = "COLUMN_ONLY"
}

export declare interface PivotTableProps {
    variant?: string;
}

export declare enum PositionModeOptions {
    Fixed = "Fixed"
}

/**
 * Print Button Options (fields of the "Chart" tab in the widget editor).
 *
 * <pre>
 *      Plugin ID         : ic3
 *      Widget/Template ID: PrintButton
 * </pre>
 *
 * @see WidgetTemplateChartOptions
 */
export declare interface PrintButtonChartOptions extends FormFieldObject {
    caption: string;
    variant: "text" | "outlined" | "contained" | string;
    withDialog: boolean;
    paperSizeName?: string;
    paperOrientation?: PaperOrientation;
    "$-fileName"?: string;
}

export declare class PrintButtonClasses {
    static readonly root: string;
    static readonly progress: string;
    static readonly cancel: string;
}

export declare type PrintButtonClassKey = keyof PrintButtonClasses;

export declare interface PublicAm4ColorManager {
    /**
     * Generate a color column.
     * @param table create the color column for this table (same length).
     * @param categoryColumn if available, use the values in this column to generate colors.
     */
    generateColors(table: ITidyTable, categoryColumn?: ITidyColumn): ITidyColorColumn;
    /**
     * Get a color
     * @param dataKey string to generate color for
     */
    getColor(dataKey: unknown): Am4Color;
    /**
     * Returns the default single color
     */
    getDefaultColor(): Am4Color;
}

export declare interface PublicAmCharts4Base<CHART, OPTIONS extends Am4ChartOptions> {
    readonly context: IWidgetPublicContext;
    /**
     * The theme of the report
     */
    readonly theme: Theme;
    tidyMath(): ITidyMath;
    /**
     * Get the color manager of the chart. This manager can create color columns using the default
     * theme palette.
     */
    getColorManager(): PublicAm4ColorManager;
    /**
     * Render the chart. Function called by plugin module.
     */
    renderJS(template: IWidgetTemplateTidyData, options: OPTIONS): void;
    /**
     * Dispose/ destroy the chart.
     */
    dispose(): void;
    /**
     * Adds an event listener to a series in the chart. This function adds the selection and the
     * events to fire that are in 'getEventsToFire'.
     * @param sprite a amcharts series object.
     * @param dataKey the data key identifies the series in the chart data.
     */
    addClickEventOnSprite(sprite: any, dataKey: string | undefined): void;
    /**
     * Returns the row for a certain data item.
     * @param dataItem the data item of a sprite (bar, line, circle, etc..)
     * @param dataKey the data key identifies the series in the chart data.
     */
    getRowFromDataItem(dataItem: unknown, dataKey: string | undefined): number | undefined;
    /**
     * Get the tidy table. Only use this function in update methods, otherwise it might not be defined and then it
     * throws an error.
     */
    getTable(): ITidyTable;
    /**
     * Get the options. Only use this function in update methods, otherwise it might not be defined and then it
     * throws an error.
     */
    getOptions(): OPTIONS;
    getInter(): ITidyTableInteraction;
    getChart(): CHART;
    /**
     * Perform interactions on the chart. Possible interaction can be a selection,
     * a drilldown or the firing of an event.
     *
     * Available interactions are set via the 'Interactions' tab in the widget editor.
     *
     * @param rowIdx the index of the row.
     * @param mouseEvent the html mouse event of the click. Used for multiple selection using ctrl and shift.
     */
    performInteraction(rowIdx: number, mouseEvent: MouseEvent | TouchEvent): void;
    /**
     * Returns the am4core instance used by the amCharts4 plugin.
     */
    getAm4core(): any;
    /**
     * Returns the am4charts instance used by the amCharts4 plugin.
     */
    getAm4charts(): any;
}

/**
 * Used for managing amcharts data in the Amcharts plugin. This class controls both the creation of the charts
 * data and the creation of the series of that chart.
 */
export declare class PublicAmchartsData {
    static readonly TAG_VALUE = "v";
    static readonly TAG_COLOR = "c";
    static readonly TAG_ADDITIONAL_VALUE = "v2";
    private readonly onValues;
    private readonly onAxis;
    private readonly onLevel;
    private readonly onGroup;
    private readonly table;
    private readonly disableGroupRecords?;
    constructor(table: ITidyTable, onValues: ISeriesValues[], onAxis: ITidyColumn, onGroup?: ITidyColumn, onLevel?: ITidyColumn, disableGroupRecords?: boolean);
    static getSeriesId(groupKey: string, valueColIdx: number): string;
    /**
     * Get the data for the chart.
     */
    getChartData(): IAmCharts4Data[];
    /**
     * Create, update and remove series in the chart.
     * @param itemControl map keeping track of current series in the chart.
     * @param seriesControl object controlling the adding/removing/updating of series.
     * @param firstGroupOnly only call the first group.
     */
    updateSeries<T>(itemControl: Map<string, T>, seriesControl: IAmchartsSeriesControl<T>, firstGroupOnly?: boolean): void;
    getAxis(): ITidyColumn;
    getLevel(): ITidyColumn | undefined;
    getGroup(): ITidyColumn | undefined;
    /**
     * Return the nth value column.
     * @param idx n
     */
    getValueColumn(idx: number): ITidyNumericColumn;
    getValueColumns(): ITidyNumericColumn[];
    /**
     * Call a function on each series, and its column
     * @param itemControl map keeping track of current series in the chart.
     */
    forEachSeries<T>(itemControl: Map<string, T>, callback: (col: ITidyNumericColumn, seriesId: string, series: T) => void): void;
    /**
     * Returns the first item in the onValues argument of the constructor.
     */
    getFirstValue(): ITidyNumericColumn;
    /**
     * Returns true if and only if multiple non-trend measures are in the chart.
     */
    isMultiMeasure(): boolean;
    /**
     * Returns the first column used for a series type.
     */
    getFirstColumnOfType(seriesType: ISeriesValuesType): ITidyColumn | undefined;
}

export declare interface PublicDateShortcutUtils<T = DateType> {
    /**
     * Get a date. See documentation for `new Date(…)` for the year, month and day arguments.
     */
    asDate(year: number, month: number, day: number): T;
    /**
     * Return the current datetime.
     */
    now(): T;
    /**
     * Return the current date. Returns the anchor date if it exists. The date returned has time 00:00:00.
     * To get the date and time, use `current()`.
     */
    currentDate(): T;
    /**
     * Return the current datetime. Returns the anchor datetime if it exists.
     */
    current(): T;
    /**
     * Returns the anchor date.
     */
    getAnchorDate(): T | null;
    /**
     * Return the date of today with the time 00:00:00. To get the date and time, use `now()`.
     */
    today(): T;
    /**
     * Get the bottom limit of the allowed date range (included). Returns `null` if no bottom limit.
     */
    minAllowedDate(): T | null;
    /**
     * Get the upper limit of the allowed date range (included). Returns `null` if no upper limit.
     */
    maxAllowedDate(): T | null;
    /**
     * Returns intersect of `range` and [minDate, maxDate].
     */
    clampDates(range: [T | null, T | null]): [T | null, T | null];
}

/**
 * Event mandatory events as sent by the widgets -> @{eventName}
 */
export declare interface PublicIcEvent {
    /**
     * The value of the event
     */
    readonly value: string;
    /**
     * The MDX version of the events
     */
    readonly mdx: string;
    /**
     * If available the key of the MDX member
     */
    readonly key?: any | any[];
    /**
     * These two strings together define an unique id for a widget in a report
     */
    sourceNid?: string;
    sourceWid?: string;
    /**
     * special 'tag' to
     */
    isEmpty?: boolean;
    /**
     * the type of event
     */
    readonly type?: IcEventType;
}

export declare type PublicTidyColumnCellDecoration = ReactTidyColumnCellDecoration | HtmlTidyColumnCellDecoration;

/**
 * The renderer for a cell at a row index.
 *
 * @see {PublicTidyColumnCellDecoration}
 */
export declare type PublicTidyColumnCellDecorationRendered = ({
    stringRenderer: true;
    renderer: () => string;
} | {
    stringRenderer?: false;
    renderer?: () => React.ReactElement;
}) & {
    handlesCellsOnError?: boolean;
    handlesBackgroundColor?: boolean;
    cssStyles?: () => Record<string, any> | undefined;
};

declare class QueryBuilderNodeClasses {
    static readonly root = "ic3QueryBuilderNode-root";
    static readonly content = "ic3QueryBuilderNode-content";
    static readonly itemText = "ic3QueryBuilderNode-itemText";
    static readonly mdxIcon = "ic3QueryBuilderNode-mdxInfo";
    static readonly extraInfo = "ic3QueryBuilderNode-extraInfo";
    static readonly expandButton = "ic3QueryBuilderNode-expandButton";
}

declare type QueryBuilderNodeClassKey = keyof QueryBuilderNodeClasses;

declare interface QueryBuilderNodeProps {
    depth: number;
    type: string;
}

export declare enum QueryType {
    MDX = "mdx",
    SQL = "sql",
    EMBEDDED = "embedded",
    HTTP_CSV = "HTTP_CSV"
}

export declare interface ReactTidyColumnCellDecoration extends BaseTidyColumnCellDecoration {
    /**
     * False if your renderer returns a React element or if you have no renderer.
     */
    stringRenderer?: false;
    /**
     * The cell renders the returned React element. Note that for the Pivot Table, Emotion CSS and JS does not work.
     */
    renderer?: (rowIdx: number) => React.ReactElement;
}

export declare class RegexFilterClasses {
    /**
     * Additional root-class when using the preview.
     */
    static readonly previewRoot = "ic3RegexFilter-previewRoot";
    /**
     * Additional root-class when using the selection box.
     */
    static readonly selectionBoxRoot = "ic3RegexFilter-selectionBoxRoot";
    /**
     * Class for the div with the search box.
     */
    static readonly searchBoxContainer = "ic3RegexFilter-searchBoxContainer";
    static readonly reachedLimitText = "ic3RegexFilter-reachedLimitText";
    static readonly filterPreview = "ic3RegexFilter-filterPreview";
    static readonly searchContent = "ic3RegexFilter-searchContent";
    static readonly footer = "ic3RegexFilter-footer";
    static readonly footerButtons = "ic3RegexFilter-footerButtons";
    static readonly filterCount = "ic3RegexFilter-filterCount";
    static readonly selectResultsButton = "ic3RegexFilter-selectResultsButton";
}

export declare type RegexFilterClassesKey = keyof RegexFilterClasses;

export declare interface RegexFilterProps {
}

export declare class RemoteContainerUtils {
    static loadScript(tenant: string | null, url: string, callback: IScriptCallback): void;
    static loadModule(scope: string, module: string): () => Promise<any>;
}

/**
 * Repetition Widget Options (fields of the "Chart" tab in the widget editor).
 *
 * <pre>
 *      Plugin ID         : ic3
 *      Widget/Template ID: RepetitionWidget
 * </pre>
 *
 * @see WidgetTemplateChartOptions
 */
export declare interface RepetitionWidgetChartOptions extends FormFieldObject {
    /**
     * (Repetition) Rows.
     *
     * The items on the vertical axis. Refer to the editor documentation for default behavior.
     */
    row?: TidyTableColumnSelector;
    /**
     * (Repetition) Columns.
     *
     * The items on the horizontal axis. Refer to the editor documentation for default behavior.
     */
    column?: TidyTableColumnSelector;
    /**
     * Visual Row Count.
     *
     * Defaulted to the number of items in the vertical axis.
     */
    visualRowNumber?: number;
    /**
     * Visual Column Count.
     *
     * Defaulted to the number of items in the horizontal axis. When defined,
     * takes precedence over the visual column count.
     */
    visualColumnNumber?: number;
    /**
     * Right Padding.
     *
     * Defines the horizontal space between the repeated widgets.
     */
    rightPadding?: number;
    /**
     * Bottom Padding.
     *
     * Defines the vertical space between the repeated widgets.
     */
    bottomPadding?: number;
    /**
     * Disable Inner widget Resizing
     *
     * If disabled, the inner widgets will not resize on a change of the page size (keeping original size).
     */
    disableWidgetResizing?: boolean;
}

/**
 * A dashboard application (i.e., list of dashboard, global filters...).
 */
export declare class ReportAppBarClasses {
    /**
     * Style applied to
     */
    static root: string;
    /**
     * Style applied to
     */
    static title: string;
    static titleC: string;
    static globalFilter: string;
    static globalFilterPanel: string;
}

export declare type ReportAppBarClassKey = keyof ReportAppBarClasses;

export declare class ReportAppLeftPanelClasses {
    static readonly root = "ic3ReportAppLeftPanel-root";
    static readonly menu = "ic3ReportAppLeftPanel-menu";
    static readonly title = "ic3ReportAppLeftPanel-title";
    static readonly filter = "ic3ReportAppLeftPanel-filter";
}

export declare type ReportAppLeftPanelClassKey = keyof ReportAppLeftPanelClasses;

declare class ReportingVersion {
    /**
     * e.g., 8.0.0-alpha.1
     */
    readonly version: string;
    readonly timestamp: string;
    constructor(version: string | undefined, timestamp: string | undefined);
    getInfo(): string;
}

export declare enum ResizingConstraintOptions {
    FixedWidthLeftAligned = "FixedWidthLeftAligned",
    FixedWidthRightAligned = "FixedWidthRightAligned"
}

export declare type ResponsiveValue = {
    [key in GenerateStringUnion<ic3Breakpoint>]: number;
};

export declare interface RestoreOwnPropsFromLocalStorageNotification extends IAppNotification {
    readonly type: "restore-ownprops-from-localstorage";
}

export declare interface RestoreStateFromLocalStorageNotification extends IAppNotification {
    readonly type: "restore-state-from-localstorage";
}

export declare interface RestoreWidgetOwnPropsFromLocalStorageNotification extends IAppNotification {
    readonly type: "restore-reportwidgets-ownprops-from-localstorage";
}

export declare interface SaveOwnPropsToLocalStorageNotification extends IAppNotification {
    readonly type: "save-ownprops-to-localstorage";
}

export declare interface SaveStateToLocalStorageNotification extends IAppNotification {
    readonly type: "save-state-to-localstorage";
}

export declare interface SaveWidgetOwnPropsToLocalStorageNotification extends IAppNotification {
    readonly type: "save-reportwidgets-ownprops-to-localstorage";
}

export declare type ScrollDirection = "forward" | "backward";

export declare enum SelectionBehaviour {
    /**
     * Clear the event value. Default behaviour.
     */
    CLEAR_EVENT = "CLEAR_EVENT",
    /**
     * Select all items in the filter.
     */
    SELECT_ALL = "SELECT_ALL",
    /**
     * Easy to guess
     */
    SELECT_FIRST = "SELECT_FIRST",
    SELECT_LAST = "SELECT_LAST",
    /**
     * Select no items in the filter and clear the event.
     */
    SELECT_NONE = "SELECT_NONE",
    /**
     * Fire the default member. The selection remains empty.
     */
    MDX_DEFAULT = "MDX_DEFAULT",
    /**
     * Fire the empty set in the event. The selection remains empty.
     */
    EMPTY_SET = "EMPTY_SET",
    /**
     * The filter can not be empty. The click is canceled. If no initial selection, the first value is used.
     */
    NOT_ALLOW_EMPTY = "NOT_ALLOW_EMPTY"
}

declare enum SelectionMode_2 {
    /**
     * User can only select one item.
     */
    SINGLE = "SINGLE",
    /**
     * User can select multiple items.
     */
    MULTIPLE = "MULTIPLE"
}
export { SelectionMode_2 as SelectionMode }

export declare enum SeriesLabelsPosition {
    START = "START",
    MIDDLE = "MIDDLE",
    END = "END",
    OUTSIDE = "OUTSIDE"
}

export declare enum SeriesType {
    LINE = "LINE",
    COLUMN = "COLUMN"
}

/**
 * Single Panel Filter Options (fields of the "Chart" tab in the widget editor).
 *
 * <pre>
 *      Plugin ID : ic3
 *      Widget/Template ID: SinglePanelFilter
 * </pre>
 *
 * @see WidgetTemplateChartOptions
 */
export declare interface SinglePanelFilterChartOptions extends FormFieldObject, Pick<FilterPanelChartOptions, "variant" | "initialFilterConfig" | "measureMdx" | "useSimpleFilterCutoff" | "useSimpleFilterCutoff" | "allowedOperatorsConfig" | "datePickerShortcuts" | "shortcutsAnchorDate" | "allowedShortcutGroup"> {
    /**
     * The ID of the level / hierarchy that is used in the filter. Equal to `IPGFilterItem.fieldId`.
     */
    levelId: string;
}

export declare enum SortingMethod {
    NONE = "NONE",
    COLUMN = "COLUMN"
}

export declare enum SortingType {
    ASCENDING = "ASCENDING",
    DESCENDING = "DESCENDING",
    KEEP_ORDER = "KEEP_ORDER"
}

export declare interface SparkChartOptionsMeta extends FormFieldObject {
    /**
     * Sparkline Type.
     */
    sparkChartType: SparkChartType;
    /**
     * Tooltips.
     *
     * Enable tooltips when the user hovers over the sparkline.
     */
    sparklineTooltips: boolean;
    /**
     * Fill Mode.
     *
     * Fill the area under the sparkline.
     */
    sparklineHasArea: boolean;
}

export declare enum SparkChartType {
    LINE = "line",
    COLUMN = "column"
}

export declare enum SparklinePosition {
    BELOW_VALUE = "BELOW_VALUE",
    RIGHT_OF_VALUE = "RIGHT_OF_VALUE"
}

export declare interface StyledHtmlBoxProps {
    sizing?: boolean;
    sizingW?: number;
    variant?: HtmlBoxVariant;
}

export declare interface StyledPrintButtonDivProps {
    variant: "text" | "outlined" | "contained" | string;
}

/**
 * Table Options (fields of the "Chart" tab in the widget editor).
 *
 * <pre>
 *      Plugin ID         : ic3
 *      Widget/Template ID: Table
 * </pre>
 *
 * @see WidgetTemplateChartOptions
 */
export declare interface TableChartOptions extends BaseTableChartOptions {
    /**
     * Name of a variant. Note that a variant is possibly overriding defined options.
     */
    variant?: string;
    /**
     * Footer.
     *
     * Display a footer. Does not apply when the table is auto-expanding vertically.
     */
    footer: boolean;
    /**
     * Add Pagination.
     *
     * Incompatible with 'Row Count' and/or 'Selected Row Count' settings.
     */
    footerPagination: boolean;
    /**
     * Add Row Count.
     *
     * Incompatible with 'Pagination'.
     */
    footerRowCount: boolean;
    /**
     * Page Size.
     *
     * Set the initial number of rows in one page.
     */
    pageSize: number;
    /**
     * Page Size Options (CSV).
     *
     * Select the 'Page Size' dynamically using the component UI. A comma separated list of integer values.
     *
     * E.g., 10,20,50
     */
    rowsPerPageOptions: string;
    /**
     * Use column header groups.
     */
    useColumnGrouping: boolean;
    /**
     * Use checkbox selection. Adds a column with checkboxes as the first column.
     */
    useCheckboxSelection: boolean;
    /**
     * Show the first column as a hierarchy instead of a flat list.
     */
    showHierarchy: boolean;
    /**
     * MDX Console support for now.
     */
    showRowNumbers?: boolean;
}

/**
 * Copy of
 * MUI CSS :  https://mui.com/api/data-grid/data-grid-pro/#css
 */
export declare class TableClasses {
    static readonly 'autoHeight' = "MuiDataGrid-autoHeight";
    static readonly 'booleanCell' = "MuiDataGrid-booleanCell";
    static readonly 'cell--editable' = "MuiDataGrid-cell--editable";
    static readonly 'cell--editing' = "MuiDataGrid-cell--editing";
    static readonly 'cell--textCenter' = "MuiDataGrid-cell--textCenter";
    static readonly 'cell--textLeft' = "MuiDataGrid-cell--textLeft";
    static readonly 'cell--textRight' = "MuiDataGrid-cell--textRight";
    static readonly 'cell' = "MuiDataGrid-cell";
    static readonly 'cellCheckbox' = "MuiDataGrid-cellCheckbox";
    static readonly 'checkboxInput' = "MuiDataGrid-checkboxInput";
    static readonly 'columnHeader--alignCenter' = "MuiDataGrid-columnHeader--alignCenter";
    static readonly 'columnHeader--alignLeft' = "MuiDataGrid-columnHeader--alignLeft";
    static readonly 'columnHeader--alignRight' = "MuiDataGrid-columnHeader--alignRight";
    static readonly 'columnHeader--dragging' = "MuiDataGrid-columnHeader--dragging";
    static readonly 'columnHeader--moving' = "MuiDataGrid-columnHeader--moving";
    static readonly 'columnHeader--numeric' = "MuiDataGrid-columnHeader--numeric";
    static readonly 'columnHeader--sortable' = "MuiDataGrid-columnHeader--sortable";
    static readonly 'columnHeader--sorted' = "MuiDataGrid-columnHeader--sorted";
    static readonly 'columnHeader' = "MuiDataGrid-columnHeader";
    static readonly 'columnHeaderCheckbox' = "MuiDataGrid-columnHeaderCheckbox";
    static readonly 'columnHeaderDraggableContainer' = "MuiDataGrid-columnHeaderDraggableContainer";
    static readonly 'columnHeaderDropZone' = "MuiDataGrid-columnHeaderDropZone";
    static readonly 'columnHeaderTitle' = "MuiDataGrid-columnHeaderTitle";
    static readonly 'columnHeaderTitleContainer' = "MuiDataGrid-columnHeaderTitleContainer";
    static readonly 'columnHeaders' = "MuiDataGrid-columnHeaders";
    static readonly 'columnSeparator--resizable' = "MuiDataGrid-columnSeparator--resizable";
    static readonly 'columnSeparator--resizing' = "MuiDataGrid-columnSeparator--resizing";
    static readonly 'columnSeparator--sideLeft' = "MuiDataGrid-columnSeparator--sideLeft";
    static readonly 'columnSeparator--sideRight' = "MuiDataGrid-columnSeparator--sideRight";
    static readonly 'columnSeparator' = "MuiDataGrid-columnSeparator";
    static readonly 'columnsPanel' = "MuiDataGrid-columnsPanel";
    static readonly 'columnsPanelRow' = "MuiDataGrid-columnsPanelRow";
    static readonly 'panel' = "MuiDataGrid-panel";
    static readonly 'panelHeader' = "MuiDataGrid-panelHeader";
    static readonly 'panelWrapper' = "MuiDataGrid-panelWrapper";
    static readonly 'panelContent' = "MuiDataGrid-panelContent";
    static readonly 'panelFooter' = "MuiDataGrid-panelFooter";
    static readonly 'paper' = "MuiDataGrid-paper";
    static readonly 'editBooleanCell' = "MuiDataGrid-editBooleanCell";
    static readonly 'filterForm' = "MuiDataGrid-filterForm";
    static readonly 'editInputCell' = "MuiDataGrid-editInputCell";
    static readonly 'filterIcon' = "MuiDataGrid-filterIcon";
    static readonly 'footerContainer' = "MuiDataGrid-footerContainer";
    static readonly 'iconButtonContainer' = "MuiDataGrid-iconButtonContainer";
    static readonly 'iconSeparator' = "MuiDataGrid-iconSeparator";
    static readonly 'main' = "MuiDataGrid-main";
    static readonly 'menu' = "MuiDataGrid-menu";
    static readonly 'menuIcon' = "MuiDataGrid-menuIcon";
    static readonly 'menuIconButton' = "MuiDataGrid-menuIconButton";
    static readonly 'menuOpen' = "MuiDataGrid-menuOpen";
    static readonly 'menuList' = "MuiDataGrid-menuList";
    static readonly 'overlay' = "MuiDataGrid-overlay";
    static readonly 'virtualScroller' = "MuiDataGrid-virtualScroller";
    static readonly 'virtualScrollerContent' = "MuiDataGrid-virtualScrollerContent";
    static readonly 'virtualScrollerRenderZone' = "MuiDataGrid-virtualScrollerRenderZone";
    static readonly 'pinnedColumns' = "MuiDataGrid-pinnedColumns";
    static readonly 'pinnedColumns--left' = "MuiDataGrid-pinnedColumns--left";
    static readonly 'pinnedColumns--right' = "MuiDataGrid-pinnedColumns--right";
    static readonly 'root' = "MuiDataGrid-root";
    static readonly 'row--editable' = "MuiDataGrid-row--editable";
    static readonly 'row--editing' = "MuiDataGrid-row--editing";
    static readonly 'row' = "MuiDataGrid-row";
    static readonly 'rowCount' = "MuiDataGrid-rowCount";
    static readonly 'scrollArea' = "MuiDataGrid-scrollArea";
    static readonly 'scrollArea--left' = "MuiDataGrid-scrollArea--left";
    static readonly 'scrollArea--right' = "MuiDataGrid-scrollArea--right";
    static readonly 'selectedRowCount' = "MuiDataGrid-selectedRowCount";
    static readonly 'sortIcon' = "MuiDataGrid-sortIcon";
    static readonly 'toolbarContainer' = "MuiDataGrid-toolbarContainer";
    static readonly 'toolbarFilterList' = "MuiDataGrid-toolbarFilterList";
    static readonly 'withBorder' = "MuiDataGrid-withBorder";
    static readonly 'treeDataGroupingCell' = "MuiDataGrid-treeDataGroupingCell";
    static readonly 'treeDataGroupingCellToggle' = "MuiDataGrid-treeDataGroupingCellToggle";
}

/**
 * List of classNames available
 */
export declare type TableClassKey = keyof TableClasses;

export declare enum TableColumnSizing {
    FLUID = "FLUID",
    FIXED = "FIXED",
    USER_RESIZABLE = "USER_RESIZABLE"
}

/**
 * All props of Mui-DataGridPro ( + variant )
 *
 * GridClasses
 *
 * https://mui.com/api/data-grid/data-grid-pro/
 */
export declare interface TableProps {
    noHeader: boolean;
    variant?: string;
    printing: boolean;
}

export declare enum TableRowHeightOptions {
    standard = "standard",
    compact = "compact",
    small = "small"
}

export declare enum TargetTextIconSet {
    TREND_ICONS = "TREND_ICONS",
    TRIANGLE_ICONS = "TRIANGLE_ICONS"
}

export declare enum TargetTextPosition {
    DISABLE = "DISABLE",
    ALIGN_TOP = "ALIGN_TOP",
    ALIGN_BOTTOM = "ALIGN_BOTTOM"
}

/**
 * Predefined roles
 */
export declare enum TemplateEventActionNames {
    SELECTION = "Selection",
    DRILLDOWN = "Drilldown",
    ADD_SELECTION = "AddSelection",
    FILTER_TO_DEFAULT = "FilterToDefault"
}

export declare type TextFilterType = "EQUALS" | "NOT_EQUALS" | "STARTS_WITH" | "ENDS_WITH" | "CONTAINS" | "NOT_CONTAINS" | "REGEX";

export declare interface ThemeFormatterPerLocale {
    /**
     * Fallback formatter for when no language is specified or a language is specified that is not defined in this
     * model.
     */
    default: ThemeFormatters;
    /**
     * A formatter per locale. Use JAVA locale tags for defining a formatter for that locale, e.g., en, en_US, nl, nl_NL, etc..
     * Longer tags have prio over shorter tags. For example, if the user has locale en_US, the dashboards first use
     * the en_US tag. If it isn't found, it will use the en tag. If that also isn't found, it will use the default.
     */
    [k: string]: ThemeFormatters;
}

export declare type ThemeFormatters = {
    text: ThemeTextFormatters;
    amCharts4: Amcharts4ThemeDateFormatter;
    /**
     * When using #a in a formatter, large values get divided and a letter gets added. Here, you can specify the number
     * to divide by and which letter to add. E.g., 1.000 and 'k' divides numbers between 1.000 and 1.000.000 by a
     * thousand and adds an 'k'.
     */
    bigNumberPrefixes?: {
        number: number;
        suffix: string;
    }[];
    /**
     * When using #a in a formatter, small values get multiplied and a letter gets added. Here, you can specify the
     * multiplier and the letter. For example, { "number": 1e-6, "suffix": "μ" }, multiplies numbers between 1e-6 and
     * 1e-9 by 1e6 and adds the letter μ.
     */
    smallNumberPrefixes?: {
        number: number;
        suffix: string;
    }[];
};

export declare class ThemeIc3TableCellClasses {
}

export declare type ThemeIc3TableCellClassesKey = keyof ThemeIc3TableCellClasses;

declare class ThemeIc3TableCellDrilldownClasses {
    static loading: string;
    static normal: string;
    static expanded: string;
    static iconDiv: string;
}

declare type ThemeIc3TableCellDrilldownClassesKey = keyof ThemeIc3TableCellDrilldownClasses;

/**
 * The spinner when a widget is loading.
 */
export declare class ThemeIc3WidgetBoxSpinner {
    static readonly overlay = "Ic3WidgetBoxSpinner-spinnerOverlayEx";
    static readonly spinner = "Ic3WidgetBoxSpinner-spinner";
    static readonly spinnerProgress = "Ic3WidgetBoxSpinner-spinnerProgress";
}

export declare type ThemeIc3WidgetBoxSpinnerClassesKey = keyof ThemeIc3WidgetBoxSpinner;

export declare type ThemeTextFormatter = {
    /**
     * Format used in the reporting application.
     */
    formatReport: ((value: any, locale: string) => string) | string;
    /**
     * Format used when exporting to Excel.
     */
    formatExcel?: string;
};

export declare type ThemeTextFormatters = Record<string, ThemeTextFormatter> & {
    /**
     * The default formatter for displaying date values.
     * Also used in the expressions when using $value.formatDate()$.
     *
     * Default: {
     *     formatReport: "yyyy-MM-dd"
     * }
     */
    defaultDate: ThemeTextFormatter;
    /**
     * The default formatter for displaying datetime values.
     * Also used in the expressions when using $value.formatDate()$.
     *
     * Default: {
     *     formatReport: "yyyy-MM-dd HH:mm:ss"
     * }
     */
    defaultDatetime: ThemeTextFormatter;
    /**
     * The default way to format any number that has no format defined.
     * Used in the expressions when using $value.formatNumber()$.
     *
     * Default: {
     *     formatReport: "#,###.####"
     * }
     */
    defaultNumber: ThemeTextFormatter;
    /**
     * Used in the expressions when using $value.formatAmount()$.
     *
     * Default: {
     *     formatReport: "#,###"
     * }
     */
    defaultAmount: ThemeTextFormatter;
    /**
     * Default formatter for percentage values.
     * Used in the expressions when using $value.formatPercentage()$.
     *
     * Default: {
     *     formatReport: "##.0%"
     * }
     */
    defaultPercentage: ThemeTextFormatter;
};

export declare type ThemeTextFormattersOptions = Record<string, ThemeTextFormatter> & {
    defaultDate?: ThemeTextFormatter;
    defaultNumber?: ThemeTextFormatter;
    defaultAmount?: ThemeTextFormatter;
    defaultPercentage?: ThemeTextFormatter;
};

export declare interface TidyActionEvent extends PublicIcEvent {
    readonly type: IcEventType.TIDY_ACTION;
    readonly tidyIdxHint: number;
}

export declare interface TidyCellError {
    errorCode: string;
    errorDescription: string;
}

/**
 * identifier of a column value ( uniqueName if it´s an axis or idx if measure )
 */
export declare type TidyColumnCoordinateUniqueName = MdxNodeIdentifier['uid'];

/**
 * Defines an index from column tag (name, mapping, role, etc..) to the name or index of the column in the table.
 * The column tag is converted to lower case.
 */
export declare type TidyColumnIndex = Record<string, string | number>;

export declare type TidyColumnsSubType = "YEAR" | "HALF_YEAR" | "QUARTER" | "MONTH" | "WEEK" | "DAY" | "DAY_MONTH" | "DAY_YEAR" | "HOUR" | "HALF_HOUR" | "QUARTER_HOUR" | "MINUTE" | "SECOND";

export declare enum TidyColumnsType {
    /**
     * Values represent a color, e.g. 'red', 'rbg(10, 10, 10)' or '#fff'. Can be null.
     */
    COLOR = "color",
    LONGITUDE = "longitude",
    LATITUDE = "latitude",
    /**
     * ISO2 location (country, region, city...) codes
     */
    ISO2_LOCATION_CODE = "iso2Location",
    /**
     * date, time or combination of the two. Can be null.
     */
    DATETIME = "datetime",
    /**
     * numeric data, e.g., double, float, integer, etc. Can be null.
     */
    NUMERIC = "numeric",
    /**
     * Textual data, string type. Can be null.
     */
    CHARACTER = "character",
    /**
     * Boolean data type, true, false. Can be null.
     */
    LOGICAL = "logical",
    /**
     * array of values. Can be null.
     */
    LIST = "list",
    /**
     * Column has values of multiple types
     */
    MIXED = "mixed",
    /**
     * The column type is not known
     */
    UNKNOWN = "unknown",
    /**
     * The column has null values only
     */
    NULL = "null",
    /**
     * Use any to opt-out of type checking
     */
    ANY = "any"
}

export declare type TidyEvent = MouseEvent | TouchEvent;

export declare const TidyHistogramBucketColName = "bucket";

export declare enum TidyHistogramBucketFormat {
    INTERVAL = "interval",
    MATH_INTERVAL = "mathInterval",
    MATH_INTERVAL_REVERSED = "mathIntervalReversed",
    FROM_ONLY = "fromOnly",
    TO_ONLY = "toOnly"
}

export declare enum TidyHistogramBucketType {
    /**
     * [from, to)
     */
    LEFT_CLOSED = "leftClosed",
    /**
     * (from, to]
     */
    RIGHT_CLOSED = "rightClosed"
}

export declare const TidyHistogramCountColName = "count";

export declare const TidyHistogramMetaOptions: (group?: string, hideSort?: boolean) => FormFields<TidyHistogramOptions>;

export declare interface TidyHistogramOptions extends FormFieldObject {
    /**
     * Bucket Mode.
     *
     * Automatically create buckets or define them yourself.
     */
    binType: HistogramBinType;
    /**
     * Bucket Count.
     *
     * The number of buckets to auto generate.
     */
    numberOfBins: number;
    /**
     * Number of buckets per interval step.
     */
    prettyIntervalCount: number;
    /**
     * Custom Buckets.
     *
     * A list of objects `{from,to,name}`. Each object describes the range `from < x <= to`. No `from` or `to`
     * means that the range is unbounded on that side.
     */
    customBins: string;
    /**
     * Sort Buckets.
     *
     * Sort the buckets in this order. The sort uses the `from` of each bucket.
     */
    sortBins: SortingType;
    /**
     * Bucket Name Format.
     *
     * How to format the names for the bucket. If there is a name in the user defined specification,
     * then the bucket takes that name.
     */
    bucketFormat: TidyHistogramBucketFormat;
    /**
     * Bucket Type.
     *
     * Which side of the bucket is closed?
     */
    intervalType: TidyHistogramBucketType;
    /**
     * Include row ids of the rows that are in the bucket. Added in the table as a column with array values. E.g.,
     * value [0,4,5] means rows 0, 4 and 5 are in the bucket.
     */
    includeRowIds?: boolean;
}

export declare const TidyHistogramRowIdsName = "rowIds";

export declare enum TidyPivotTableLikeNodeStatus {
    COLLAPSED = 0,
    EXPANDED = 1,
    NO_CHILDREN_OR_DRILLDOWN = 2,
    WITH_DRILLDOWN = 3,
    LOADING = 4
}

/**
 * Function filtering the rows of a column / table. Returns true if the row is included, false if the row is excluded.
 */
export declare type TidyRowFilter = (rowIdx: number) => boolean;

export declare interface TidyTableColumnIdentifier {
    /**
     * Search column by name
     */
    name: string;
    /**
     * If we want a property, the name of the column's property.
     */
    property?: string;
}

export declare type TidyTableColumnSelector = TidyTableColumnIdentifier | TidyTableMappingColumnSelectorOptions | TidyTableRoleSelector;

export declare enum TidyTableMappingColumnSelectorOptions {
    ALL = "@IC3_ALL",
    ALL_NUMERIC = "@IC3_ALL_NUMERIC",
    ALL_CHARACTER = "@IC3_ALL_CHARACTER",
    ALL_MEASURES = "@IC3_ALL_MEASURES",
    ALL_AXIS = "@IC3_ALL_AXIS"
}

export declare interface TidyTableRoleSelector {
    /**
     * Search columns by role
     */
    role: string;
}

/**
 * A tree structure that was generated from a TidyTable.
 *
 * Table:
 * budget type | cc
 * Monthly Budget | Savings
 * Monthly Budget | Mortgage/Rent
 * Yearly Budget | Car Payment
 *
 * converts to <nodeLabel> <rowIds>:
 * root (undefined)
 *  |
 *  --- Monthly Budget [0,1]
 *  |     |
 *  |     --- Savings [0]
 *  |     |
 *  |     --- Mortgage/Rent [1]
 *  |
 *  --- Yearly Budget [3]
 *       |
 *       --- Car Payment [3]
 *
 */
export declare class TidyTree {
    root: TidyTreeNode;
    constructor(root?: TidyTreeNode);
    /**
     * A unique id for each node of the tree
     * returns levelDepth + "--" + node.nodeLabel, or "root" for the root node.
     */
    static getUniqueId(node: TidyTreeNode, levelDepth: number): string;
    /**
     * Performs the specified action on each node of the tree.
     * If callbackfn return false, it will not perform a foreach on it's children.
     * The callback function does not run for the root node.
     * Leveldepth = number of nodes between node and the root node.
     */
    forEach<T>(callbackfn: ForEachNodeCallbackFn<T>, getTopParentStat?: (topParentNode: TidyTreeNode) => T): void;
    /**
     * aggregates all children measures values on parents using aggregation function recursively
     * aggrfn is sum by default
     */
    getNodeValue(node: TidyTreeNode, measure: ITidyNumericColumn): number | null;
}

/**
 * A tree node that with origin in a TidyColumn
 */
export declare interface TidyTreeNode {
    /**
     * The column the tree node was generated from
     */
    originalColumn?: ITidyColumn;
    /**
     * The rows that the node is created from. Undefined if and only if the node is the root node.
     */
    rowIds?: GroupRowIndices;
    /**
     * The label/value of this node
     */
    nodeLabel: string;
    /**
     * Children of this tree
     */
    children: TidyTreeNode[];
}

export declare enum TopBarOptions {
    None = 0,
    EditorMode = 1,
    AppViewerTopFilter = 2,
    AppViewerTopMenu = 3,
    AppViewerTopMenuFloating = 4
}

export declare enum TreeFireEventMode {
    ALL_SELECTED = "ALL_SELECTED",
    /**
     * if all children are selected,  fire only the parent
     */
    COMPACT_ON_PARENT = "COMPACT_ON_PARENT"
}

export declare interface TreeRowPropsTreeData {
    rowIndex: number;
    nodeId: string;
    isCollapsed: boolean;
    hasChildren: boolean;
    isSelected: boolean;
}

export declare enum TrendLineType {
    MEAN = "MEAN",
    OLS = "OLS"
}

/**
 * If we have (date)times available, then
 * YES -> always use them
 * NO -> never use them
 * AUTO -> use them if the level is a date or datetime (in MDX, these are levels of type DAY, HOUR, MINUTE, SECOND).
 */
export declare enum UseDatetimeAxis {
    YES = "YES",
    NO = "NO",
    AUTO = "AUTO"
}

declare type variantName = string;

export declare class WidgetBoxClasses {
    /**
     * Root Styles applied to the widgetBox
     */
    static readonly root: string;
    /**
     * Root Styles applied to the widgetBox root element for a 'standard' widget -> &.className !
     */
    static readonly standard: string;
    /**
     * Root Styles applied to the widgetBox root element for a 'embedded' widget (the widget is inside another widget)
     */
    static readonly embedded: string;
    /**
     * Root Styles applied to the widgetBox root element for a 'zoomed' widget
     */
    static readonly zoom: string;
    /**
     * Root Styles applied to the widgetBox root element for a 'no decoration' widget (template definition setting, no borders ...)
     */
    static readonly noDecoration: string;
    /**
     * Styles applied to the widgetBox container element
     */
    static readonly container: string;
    /**
     * Styles applied to the template JS content
     */
    static readonly templateJSContent: string;
    /**
     * Styles applied to the template React content
     */
    static readonly templateReactContent: string;
    /**
     * Styles applied to the widgetBox content element (the widget without header and user menu)
     */
    static readonly content: string;
    /**
     * Styles applied to child of content (above)
     */
    static readonly contentRoot: string;
    /**
     * Styles applied to the widgetBox user menu element (the icons for the user menu)
     */
    static readonly userMenu: string;
    /**
     * Styles applied to the widgetBox header element
     */
    static readonly header: string;
    /**
     * Styles applied to the widgetBox header left element ( title and drilldown )
     */
    static readonly headerLeft: string;
    /**
     * Styles applied to the widgetBox header right element ( user menu )
     */
    static readonly headerRight: string;
    /**
     * Styles applied to the header element has no title
     */
    static readonly headerNoTitle: string;
    /**
     * Styles applied to the header element container has no title
     */
    static readonly headerNoTitleContainer: string;
    /**
     * Styles applied to the widgetBox header Title element
     */
    static readonly headerTitle: string;
    /**
     * Styles applied to the widgetBox header Drilldown element
     */
    static readonly headerLeftSeparator: string;
    /**
     * Styles applied to the widgetBox header Drilldown element
     */
    static readonly headerDrilldown: string;
    /**
     * Root Styles applied to the widgetBox root element when the box is with header
     */
    static readonly withHeader: string;
    /**
     * Root Styles applied to the widgetBox root element when the box is without header
     */
    static readonly withoutHeader: string;
    /**
     * Styles applied to the widgetBox user menu element when the userMenu is open
     */
    static readonly userMenuOpen: string;
    /**
     * Styles applied to the widgetBox user menu element when the userMenu id closed
     */
    static readonly userMenuClosed: string;
    /**
     * attribute for the root div containing the widgetId
     */
    static readonly widgetIdAttribute: string;
    static readonly nsIdAttribute: string;
}

export declare type WidgetBoxClassKey = keyof WidgetBoxClasses;

export declare class WidgetBoxContentMessageClasses {
    /**
     * Style applied to the root div of the widget box content.
     */
    static root: string;
    /**
     * Style applied to the div containing the message.
     */
    static content: string;
}

export declare type WidgetBoxContentMessageClassKey = keyof WidgetBoxContentMessageClasses;

export declare interface WidgetBoxDivProps {
    variant: string;
}

/**
 * Widget Box Options (fields of the "Box" tab in the widget editor).
 *
 * @see https://github.com/ic3-software/ic3-demo-plugin-theme
 */
export declare interface WidgetBoxOptions {
    /**
     * Name of a variant. Note that a variant is possibly overriding defined options.
     */
    variant?: string;
    /**
     * Message that is displayed when the widget cannot render yet
     * (waiting for its initial result or mandatory event value).
     */
    waitingEventOrResult?: string;
    /**
     * Use the chart title to define the information displayed in the widget box header.
     */
    withHeader: boolean;
    visibility: WidgetBoxVisibilityType;
    /**
     * Behavior of the widget when the dashboard is being resized.
     */
    resizingConstraint?: ResizingConstraintOptions;
    /**
     * The widget will (vertically) expand to fit its content.
     */
    autoExpandContent: IWidgetBoxExpandOptions;
    rectangle: IWidgetRectangle;
}

export declare enum WidgetBoxTooltipType {
    dialog = "dialog",
    tooltip = "tooltip"
}

export declare enum WidgetBoxVisibilityType {
    default = "default",
    invisible = "invisible",
    invisibleInPrinting = "invisibleInPrinting"
}

export declare class WidgetFilteredByClasses {
    static readonly text: string;
    static readonly table: string;
}

export declare type WidgetFilteredByClassesKey = keyof WidgetFilteredByClasses;

export declare type WidgetNotificationHandler = {
    type: WidgetNotificationType;
    handler: (type: WidgetNotificationType, event: PublicIcEvent) => void;
};

export declare enum WidgetNotificationType {
    doAllEvents = "ic3doAllEvents",
    doCustomAction = "ic3doCustomAction",
    doExportWidgetData = "ic3exportWidgetData",
    doExportToExcel = "ic3exportToExcel",
    doExportToPNG = "ic3exportToPNG",
    doExportToSVG = "ic3exportToSVG",
    toInitialSelection = "ic3toInitialSelection",
    clearSelection = "ic3clearSelection",
    clearState = "ic3clearState",
    doTemplateUserMenuAction = "ic3doTemplateUserMenuAction",
    doPrintReport = "ic3doPrintReport",
    onWidgetZoom = "ic3onWidgetZoom"
}

export declare enum WidgetRenderLayoutStatus {
    RENDERING = "RENDERING",
    RENDERED = "RENDERED"
}

export declare type WidgetTemplateChartOptions = IWidgetTemplateChartOptions & {
    [key: string]: FormFieldObject;
};

/**
 * *********************************************************************************************************************
 *                  DO NOT CHANGE THEIR VALUE : USED FOR FINDING THE DOCUMENTATION.
 * *********************************************************************************************************************
 */
export declare enum WidgetTemplateDefinitionType {
    Chart = "chart",
    Filter = "filter",
    Map = "map",
    Misc = "misc"
}

export declare type WidgetTemplateIDs = keyof IWidgetTemplateChartOptions;

export declare interface WidgetTidySelectionOptions {
    /**
     * If true, the widget responds to selection events.
     */
    isSelectionActive: boolean;
    /**
     * User can set the selection mode in the interaction-settings.
     */
    selectionMode: SelectionMode_2;
    /**
     * These columns are considered in the selection.
     */
    selectionGranularity?: IFormFieldGranularityItem[];
    /**
     * Behaviour when all items in the filter are selected.
     */
    selectionAllBehaviour?: SelectionBehaviour;
    /**
     * Behaviour when the selection is empty, e.g. when no items are selected.
     */
    selectionEmptyBehaviour?: SelectionBehaviour;
    /**
     * List with items in the initial selection.
     */
    initSelectionUserDefined?: string[] | string;
    /**
     * Column with items in the initial selection. The column has a truthy value for items that are in the initial
     * selection.
     */
    initSelectionColumn?: TidyTableColumnSelector;
    /**
     * Initialize selection on new query
     */
    initSelectionOnNewQuery?: boolean;
    /**
     * Add a chip in the widget header that shows what items are selected.
     */
    showSelectionInWidgetHeader?: boolean;
    /**
     * Normally, the widget clears the selection if it is not anymore in the data. Enable this to keep the selection.
     */
    keepSelectionWhenNotInData?: boolean;
}

export declare enum WidgetWarningSeverity {
    WARNING = 0,
    ERROR = 1
}

export { }


/**
 *
 * MUI Module augmentation
 *
 */
declare module "@mui/material/styles" {
    interface Palette {
        ic3: ic3Palette;
    }
    interface PaletteOptions {
        ic3?: ic3PaletteOptions;
    }
    interface TypographyVariants {
        ic3: ic3Typography;
    }
    interface TypographyVariantsOptions {
        ic3?: ic3TypographyOptions;
    }
    interface Theme {
        ic3: ic3Theme;
    }
    /**
     * Input of createTheme( {...} )
     */
    interface ThemeOptions {
        ic3: ic3ThemeOptions;
    }
    interface Components extends ic3BaseComponents {
    }
    interface ComponentNameToClassKey extends ic3ComponentNameToClassKey {
    }
    interface ComponentsPropsList extends ic3ComponentsPropsList {
    }
}