@arcgis/charts-components 4.33.0-next.100 → 4.33.0-next.102

package/dist/utils/chart-config/validator/interfaces.d.ts

@@ -0,0 +1,80 @@
+import { default as Ajv } from 'ajv';
+import { RESTFieldType, WebChartStatisticType } from '@arcgis/charts-spec';
+import { ErrorKeywords } from '../../errors/interfaces';
+export declare const ConfigWarningKeywords: {
+    readonly NonNumericAggregation: "nonNumericAggregation";
+    readonly DuplicateSeriesID: "duplicateSeriesId";
+};
+type ConfigWarningKeywords = (typeof ConfigWarningKeywords)[keyof typeof ConfigWarningKeywords];
+interface NumericAggregationParams {
+    fieldName: string;
+    fieldType: RESTFieldType;
+    aggregationRequested: WebChartStatisticType;
+}
+interface DuplicateSeriesIdParams {
+    seriesName: string;
+    seriesId: string;
+}
+interface LayerLoadFailureParams {
+    url: string;
+    portalItemId: string;
+}
+export interface ConfigWarningObject {
+    keyword: ConfigWarningKeywords;
+    dataPath: string;
+    message: string;
+    params: DuplicateSeriesIdParams | NumericAggregationParams;
+}
+export interface CustomErrorObject {
+    keyword: ErrorKeywords;
+    message: string;
+    params: LayerLoadFailureParams | string;
+}
+/**
+ * Validation Status interface which described the validity of the input WebChart config
+ */
+export interface ValidationStatus {
+    valid: boolean;
+    schemaErrors: Ajv.ErrorObject[];
+    customErrors: CustomErrorObject[];
+    warnings: ConfigWarningObject[];
+}
+export declare const ConfigErrorKeywords: {
+    readonly Required: "required";
+    readonly MinLength: "minLength";
+    readonly MinItems: "minItems";
+    readonly MaxItems: "maxItems";
+    readonly Pattern: "pattern";
+    readonly AdditionalProperties: "additionalProperties";
+    readonly Enum: "enum";
+    readonly AnyOf: "anyOf";
+};
+export declare const DataWarningKeywords: {
+    readonly BadData: "badData";
+    readonly EmptyDataSet: "emptyDataSet";
+    readonly HistogramEmptyField: "histogramEmptyField";
+    readonly BarElementExceedsLimit: "barElementExceedsLimit";
+    readonly LineChartExceedsLimit: "lineChartExceedsLimit";
+    readonly BoxPlotExceedsLimit: "boxPlotExceedsLimit";
+    readonly BoxPlotOutliersExceedsLimit: "boxPlotOutliersExceedsLimit";
+    readonly PieChartExceedsLimit: "pieChartExceedsLimit";
+    readonly GaugeExceedsLimit: "gaugeExceedsLimit";
+    readonly PieChartMixOfNegativePositiveSlices: "PieChartMixOfNegativePositiveSlices";
+    readonly NegativeValueInSqrtCalculation: "negativeValueInSqrtCalculation";
+    readonly NegativeValueInLogCalculation: "negativeValueInLogCalculation";
+    readonly NegativeValueInXAxisLogScale: "negativeValueInXAxisLogScale";
+    readonly NegativeValueInYAxisLogScale: "negativeValueInYAxisLogScale";
+};
+export type DataWarningKeywords = (typeof DataWarningKeywords)[keyof typeof DataWarningKeywords];
+interface ElementCountExceededParams {
+    actualCount: number;
+    totalLimit: number;
+    seriesLimit?: number;
+}
+export interface DataWarningObject {
+    keyword: DataWarningKeywords;
+    header: string;
+    message: string;
+    params?: ElementCountExceededParams;
+}
+export {};

package/dist/utils/components/action-bar-utils.d.ts

@@ -0,0 +1,41 @@
+import { ChartTypes, DefaultChartActions } from '../../utils';
+import { WebChart } from '@arcgis/charts-spec';
+import { ArcGISChart } from '../../components/arcgis-chart/customElement.js';
+import { ArcGISChartsActionBar } from '../../components/arcgis-charts-action-bar/customElement.js';
+/**
+ * Returns the default actions for a given chart type
+ *
+ * @param {ChartTypes} chartType The chart type for which to get the default actions
+ * @returns {DefaultChartActions[]} The default actions for the given chart type
+ */
+export declare function getDefaultChartActions(chartType: ChartTypes | undefined): DefaultChartActions[];
+/**
+ * Creates a new tooltip object and adds it to the DOM
+ *
+ * @param innerHTML HTML to be displayed inside tooltip
+ * @param referenceElement Element for which the tooltip will be shown
+ * @returns The tooltip object that was created
+ */
+export declare function createTooltip(innerHTML: string, referenceElement?: HTMLElement): HTMLCalciteTooltipElement;
+/**
+ * Destroys tooltip by removing it from the DOM
+ *
+ * @param tooltip The tooltip to be destroyed
+ * @returns Null return for caller to easily reset tooltip object to null
+ */
+export declare function destroyTooltip(tooltip: HTMLCalciteTooltipElement | null): null;
+/**
+ * Event handler for action bar slot change.
+ *
+ * @param e
+ * @param layer
+ */
+export declare const onActionBarSlotChange: (e: Event, chartComponent: HTMLArcgisChartElement, config?: WebChart) => HTMLArcgisChartsActionBarElement | undefined;
+/**
+ * Updates the action bar states based on the properties of the chart component and the config object.
+ *
+ * @param actionBar
+ * @param chartComponent
+ * @param config
+ */
+export declare function updateActionBarStates(actionBar: HTMLArcgisChartsActionBarElement, chartComponent: HTMLArcgisChartElement, config?: WebChart): void;

package/dist/utils/components/chart-ui-utils.d.ts

@@ -0,0 +1,117 @@
+import { RESTSimpleLineSymbolStyle } from '@arcgis/charts-spec';
+import { NumericFieldsChangeProps } from '../../interfaces';
+import { FormatKeys } from '../../model';
+export interface RGB {
+    r: number;
+    g: number;
+    b: number;
+}
+export declare const UIDefaults: {
+    readonly DebounceTimer: 400;
+    readonly SliderTimer: 100;
+    readonly PopoverTimer: 60;
+    readonly customSortLimit: 100;
+};
+export declare const DefaultStatNumberFormat: {
+    readonly style: "decimal";
+    readonly minimumFractionDigits: 0;
+    readonly maximumFractionDigits: 3;
+};
+export declare const aggregationList: ("count" | "avg" | "max" | "min" | "percentile-continuous" | "sum" | "no_aggregation")[];
+export declare const pieAggregationList: ("count" | "sum")[];
+export declare function getFormatIcon(formatKey: FormatKeys | undefined): string | undefined;
+/**
+ * Validates a value entered in a numeric calcite-input.
+ * Controls that the value is not undefined, not empty (invalid) and in between the [min, max] range if provided
+ *
+ * @param value
+ * @param min
+ * @param max
+ */
+export declare function isCalciteInputValidNumber(value: number | string, min?: number | string, max?: number | string): boolean;
+/**
+ * Secures a provided number by returning either the same number, or a default value, or undefined.
+ * The actual value is typed as "string" because the calcite-input inputs returns a string value
+ * no matter the type of input used (text, number, textarea...).
+ *   - If the value is valid (not NaN, finite), the value is returned
+ *   - If not and if a valid default value is provided, the default value is returned
+ *   - If not, an empty string is returned
+ *
+ * @param value
+ * @param defaultValue
+ */
+export declare function sanitizeNumber(value?: number | string | null, defaultValue?: number): string | undefined;
+/**
+ * Modifies a calcite-input status
+ *
+ * @param props
+ */
+export declare function modifyCalciteInputStatus(props: {
+    inputElement: HTMLCalciteInputElement;
+    status: string;
+}): void;
+export declare const UIInputStatus: Record<string, "idle" | "invalid" | "valid">;
+/**
+ * Formats a number according to the locale and optionally rounds it
+ *
+ * @param value
+ * @param precision
+ */
+export declare function formatNumberToLocale(value?: number, formatOptions?: Intl.NumberFormatOptions): string;
+/**
+ * Indicates whether the item matches the provided string,
+ * or one of the strings in the array of strings.
+ *
+ * @param item
+ * @param selectedContent
+ */
+export declare function itemMatchesSelectedContent(item: string, selectedContent?: string[] | string): boolean;
+/**
+ * Returns the offset distance based on the provided placement option of a popover;
+ * For now, the popover will display either on top of the target element using the 'trailing' placement option,
+ * or to the left of the target element using the 'leading' placement option.
+ *
+ * @param placement
+ */
+export declare function getPopoverOffsetDistance(placement: HTMLCalcitePopoverElement["placement"] | undefined): number;
+/**
+ * Helper function to sanitize a color with NaNs
+ *  - Returns null if color is undefined or contains NaN values
+ *  - Returns the color otherwise
+ *
+ * @param color RGB | undefined
+ */
+export declare function sanitizeColor(color: RGB | undefined): RGB | null;
+/**
+ * Handler for "keydown" event on numberic input element. Prevents input of "e" character.
+ *
+ * @param e Input element "keydown" event
+ */
+export declare const blockNumericE: (e: KeyboardEvent) => void;
+/**
+ * Creates a tooltip for the hovered action.
+ *
+ * @param actionElement
+ */
+export declare const createActionTooltip: (actionElement: HTMLCalciteActionElement | HTMLCalciteIconElement | HTMLCalciteListElement) => HTMLCalciteTooltipElement;
+/**
+ * Destroys tooltip for the action that was being hovered.
+ *
+ * @param tooltip
+ */
+export declare const destroyActionTooltip: (tooltip: HTMLCalciteTooltipElement | undefined) => void;
+/**
+ * emit numeric field change event
+ *
+ * @param props.pickListElement
+ * @param props.eventEmitter
+ * @param props.contentKind
+ * @category Public
+ */
+export declare const emitNumericFieldsChange: (props: NumericFieldsChangeProps) => void;
+/**
+ * Returns the line style type based on the provided line style.
+ *
+ * @param lineStyle
+ */
+export declare function getLineStyleType(lineStyle: RESTSimpleLineSymbolStyle | undefined): string;

package/dist/utils/components/config-update.d.ts

@@ -0,0 +1,46 @@
+import { SupportedLayer, WebChart, WebChartLegendPositions } from '@arcgis/charts-spec';
+import { default as FeatureLayerView } from '@arcgis/core/views/layers/FeatureLayerView';
+import { ChartOptions } from '../../chart-rendering/common/interfaces';
+import { ArcGISChart } from '../../components/arcgis-chart/customElement.js';
+/**
+ * Updates the legend position for a given WebChart config.
+ * Returns the updated config.
+ *
+ * @param newLegendPosition
+ * @param config
+ */
+export declare function updateLegendPosition(newLegendPosition: WebChartLegendPositions, config?: WebChart): WebChart | undefined;
+/**
+ * Updates the legend visibility for a given WebChart config.
+ * Returns the updated config.
+ *
+ * @param visible
+ * @param config
+ */
+export declare function updateLegendVisibility(visible: boolean, config?: WebChart): WebChart | undefined;
+/**
+ * Resets the axes bounds.
+ * Returns the updated config.
+ *
+ * @param config
+ */
+export declare function resetAxesBounds(config?: WebChart): WebChart | undefined;
+/**
+ * Checks whether the provided data source is valid. The conditions are:
+ * - iLayer is defined
+ * - OR Layer / FeatureLayerView instance is provided
+ *
+ * @param config The component's config
+ * @param layer The component's layer
+ */
+export declare function isValidDataSource(config?: WebChart, layer?: FeatureLayerView | SupportedLayer): boolean;
+/**
+ * Will add missing series to the chart config if:
+ * - the config uses a split-by field
+ * - adding missing series was requested (through the `updateSplitBySeries` property)
+ * - unique values for the given split-by field don't have a series associated
+ *
+ * @param component The chart component
+ * @param options The runtime options
+ */
+export declare function addMissingSplitBySeries(component: ArcGISChart, options: ChartOptions): Promise<void>;

package/dist/utils/components/event-payloads.d.ts

@@ -0,0 +1,52 @@
+import { ChartModel } from '../../model';
+import { DefaultChartActions, PieSlicesSymbols, SelectionData, SeriesSymbolsMap } from '../../utils';
+import { CalculatedMinMaxBoundsPayload, LegendItemVisibility, WebChartDataTypes, WebChartLegendPositions } from '@arcgis/charts-spec';
+import { JsxNode } from '@arcgis/lumina';
+export type PanelNumberChangePayload = {
+    panelNumber: number;
+    modelList: ChartModel[];
+};
+export type DataChangeErrorPayload = {
+    error: Error;
+    model: ChartModel;
+};
+export type PopoverOpenChangePayload = {
+    open: boolean | undefined;
+};
+export type PopoverChangePayload = {
+    open: boolean | undefined;
+    element: JsxNode;
+};
+export type ModelListChangePayload = {
+    modelList: ChartModel[];
+};
+export type DataProcessCompletePayload = {
+    chartData: WebChartDataTypes;
+    model: ChartModel | undefined;
+};
+export type AxesMinMaxChangePayload = {
+    bounds: CalculatedMinMaxBoundsPayload[];
+    model: ChartModel | undefined;
+};
+export type SeriesColorChangePayload = {
+    data: PieSlicesSymbols | SeriesSymbolsMap;
+    colorMatchApplied: boolean;
+    model: ChartModel | undefined;
+};
+export type NoRenderPropChangePayload = {
+    propName: string;
+    value: WebChartLegendPositions | boolean;
+    model: ChartModel | undefined;
+};
+export type LegendItemVisibilityChangePayload = {
+    legendItemVisibility: LegendItemVisibility;
+    model: ChartModel | undefined;
+};
+export type SelectionCompletePayload = {
+    selectionData: SelectionData;
+    model: ChartModel | undefined;
+};
+export type DefaultActionSelectPayload = {
+    actionId: DefaultChartActions;
+    actionActive: boolean;
+};

package/dist/utils/components/interfaces.d.ts

@@ -0,0 +1,11 @@
+import { SupportedCharts } from '../../utils';
+import { WebChartBarChartSeries, WebChartBoxPlotSeries, WebChartLineChartSeries, WebChartRadarChartSeries } from '@arcgis/charts-spec';
+/** Supported chart types. */
+export declare const supportedChartTypes: SupportedCharts[];
+export declare const maximumNumberOfSimultaneousUpdates = 1;
+export interface MissingSplitBySeriesProps {
+    addMissingSeries: boolean;
+    seriesTemplate?: WebChartBarChartSeries | WebChartBoxPlotSeries | WebChartLineChartSeries | WebChartRadarChartSeries;
+}
+export type WebChartSeriesUsingSplitBy = WebChartBarChartSeries | WebChartBoxPlotSeries | WebChartLineChartSeries | WebChartRadarChartSeries;
+export type WebChartComponentVersion = "beta" | "stable";

package/dist/utils/components/message-utils.d.ts

@@ -0,0 +1,9 @@
+import { ErrorStrings } from '../../utils';
+import { WebChartTypes } from '@arcgis/charts-spec';
+/**
+ * Pulls the proper placeholder according to the chart type
+ *
+ * @param chartType The chart type to get the placeholder for
+ * @category Private
+ */
+export declare function getChartPlaceholder(chartType?: WebChartTypes, strings?: ErrorStrings): string | undefined;

package/dist/utils/components/type-guards.d.ts

@@ -0,0 +1,2 @@
+import { ArcGISChart } from '../../components/arcgis-chart/customElement.js';
+export declare function isChartElement(element: HTMLElement | null | undefined): element is HTMLArcgisChartElement;

package/dist/utils/components/watch-handlers.d.ts

@@ -0,0 +1,37 @@
+import { ArcGISChart } from '../../components/arcgis-chart/customElement.js';
+/**
+ * Adds a listener on the feature layer, so every time the definition expression (filter) is modified we update
+ * the chart.
+ *
+ * @param component The chart component
+ */
+export declare function addLayerFilterListener(component: ArcGISChart): Promise<IHandle | undefined>;
+/**
+ * Adds a listener on the feature layer, so every time the renderer is modified we update the chart.
+ *
+ * @param component The chart component
+ */
+export declare function addLayerRendererListener(component: ArcGISChart): Promise<IHandle | undefined>;
+/**
+ * Adds a listener on the feature layer view, so every time the view's extent is modified we update
+ * the chart.
+ *
+ * @param props.component The chart component
+ */
+export declare function addExtentChangeListener(component: ArcGISChart): Promise<IHandle[] | undefined>;
+/**
+ * Adds a listener on the view's time extent, so every time extent is modified we update the chart.
+ * @param component The chart component
+ */
+export declare function addViewTimeExtentListener(component: ArcGISChart): Promise<IHandle | undefined>;
+/**
+ * Adds a listener on the feature layer, so every time the fields are modified we update the chart.
+ *
+ * @param component The chart component
+ */
+export declare function addLayerFieldsListener(component: ArcGISChart): Promise<IHandle | undefined>;
+/**
+ * Adds a listener on the layer's view; so every time the selection data is modified, we update the chart.
+ * @param component The chart component
+ */
+export declare function addSelectionsChangeInViewListener(component: ArcGISChart): Promise<IHandle | undefined>;

package/dist/utils/cursor/interfaces.d.ts

@@ -0,0 +1,14 @@
+export declare const ActionModes: {
+    readonly MonoSelection: "monoSelection";
+    readonly MultiSelection: "multiSelection";
+    readonly MultiSelectionWithCtrlKey: "multiSelectionWithCtrlKey";
+    readonly Zoom: "zoom";
+    readonly None: "none";
+};
+export type ActionModes = (typeof ActionModes)[keyof typeof ActionModes];
+export declare const CursorRange: {
+    readonly MultiAxes: "multi-axes";
+    readonly XAxis: "x-axis";
+    readonly YAxis: "y-axis";
+};
+export type CursorRange = (typeof CursorRange)[keyof typeof CursorRange];

package/dist/utils/data/categorical-data/index.d.ts

@@ -0,0 +1,29 @@
+import { WebChartQuery } from '@arcgis/charts-spec';
+import { ChartElementLimit } from '../../defaults/interfaces';
+import { AbortControllerKeyType } from '../../layer/query-features/interfaces';
+import { QueryObject } from '../../layer/interfaces';
+/**
+ * Fetches the unique values from a given field.
+ * /!\ Currently the results for a same split-by field might differ from a category field to another.
+ * This is due to the server not being able to make a distinction in some cases between values having for
+ * only difference trailing spaces (e.g. `value` and `value ` and `value  `). It means it will aggregate the
+ * stats for those similar values.
+ * Given the stats for the similar values will be later aggregated, we also want the unique value list to carry
+ * the same approximation.
+ * To get a list of unique values that will match the chart's data, we simulate the data query and retain the unique
+ * values for given the split-by field.
+ * @param props.queryObject The object used to query the features (layer or feature layer view)
+ * @param props.queryConfig The query configuration
+ * @param props.category The category
+ * @param props.splitByField The split-by field
+ * @param props.chartLimits The chart limits
+ * @param props.abortKey The key to abort the request
+ */
+export declare function uniqueValues(props: {
+    queryObject?: QueryObject;
+    queryConfig: WebChartQuery;
+    category: string;
+    splitByField?: string;
+    chartLimits?: ChartElementLimit;
+    abortKey?: AbortControllerKeyType;
+}): Promise<(number | string)[]>;

package/dist/utils/data/index.d.ts

@@ -0,0 +1,111 @@
+import { WebChart, WebChartBin, WebChartDataItem, WebChartDataTypes, WebChartSeriesType, WebGaugeChart } from '@arcgis/charts-spec';
+import { ChartSubType } from '../misc/interfaces';
+import { BoxPlotYValueProps, DataMinMax, BoxPlotYFieldKeys } from './interfaces';
+/**
+ * Generates the y field names for box plot
+ * @param y
+ * @returns
+ */
+export declare function getBoxPlotStatisticFieldNames(y?: string): Record<BoxPlotYFieldKeys, string>;
+/**
+ * Check the `subType` in the chart config to determine whether the chart is a gauge by feature.
+ * If `subType` is not defined, the chart is defaulted to be a statistic gauge.
+ *
+ * @param config the chart config
+ * @default false
+ */
+export declare function isGaugeByFeature(config: WebGaugeChart): boolean;
+/**
+ * From fetched data (type: WebChartDataTypes) returns the part containing the data that
+ * is to be assigned to the chart (WebChartDataItem[] | WebChartBin[])
+ * @param props.fetchedData The fetched finished data
+ */
+export declare function extractChartDataFromFetchedData(fetchedData?: WebChartDataTypes): WebChartBin[] | WebChartDataItem[] | undefined;
+/**
+ * Determine whether the current box plot has multi-fields or not based on its query type
+ * @param chartSubType: Box plot sub type
+ */
+export declare function isMultiFieldsBoxPlot(chartSubType?: ChartSubType): boolean;
+/**
+ * Compute Y value for given Box Plot Y field key based on the provided config
+ * @param props.key The BoxPlotYFieldKeys related to the stat
+ * @param props.y The y field to use to get the y value
+ * @param props.chartSubType The box plot sub type
+ * @param props.splitBy The where clause used as a split-by value for a given series
+ * @param props.splitByValue The split-by value for a given series
+ * @param props.showOutliers Whether to show the outliers
+ * @param props.standardizeValues Whether to show the standardized values
+ */
+export declare function getBoxPlotYValue(props: BoxPlotYValueProps): string;
+/**
+ * Check if the Box-plot data item has valid open or close (first quartile/third quartile) values since those values are considered as necessary.
+ * @param props.dataItem The WebChartDataItem to check for valid values
+ * @param props.y The y value
+ * @param props.splitBy The split-by value
+ * @param props.showOutliers Whether the outliers are shown
+ */
+export declare function doesBoxPlotItemHaveValidQuartiles(props: {
+    dataItem: WebChartDataItem;
+    y?: string;
+    splitBy?: string;
+    showOutliers?: boolean;
+}): boolean;
+/**
+ * Gathers the list of `y` values used by a chart from the series configs.
+ * For non-aggregated split-by bar/line charts, the y values are constructed from the series's where clauses.
+ *
+ * Notes:
+ * 1. If the list of visible series id is provided it will be used to filter out the series, otherwise they will all be considered.
+ * 2. The returned y list should be independently from any prefix or suffix that are used for other features like
+ * color match, selection, tooltips, etc.
+ * @param seriesConfig The array of configs for the chart series.
+ * @param filteredSeriesIds List of series ids to use as a filter.
+ */
+export declare function getYList(seriesConfig: WebChartSeriesType[], filteredSeriesIds?: string[]): string[];
+/**
+ * Gathers the list of `y` values used by a box plot from the series configs.
+ * @param props.showMean Whether the box plot mean lines are shown
+ * @param props.seriesConfig The array of configs for the chart series.
+ * @param props.filteredSeriesIds List of series ids to use as a filter.
+ */
+export declare function getBoxPlotYList(props: {
+    showMean?: boolean;
+    seriesConfig: WebChartSeriesType[];
+    filteredSeriesIds?: string[];
+}): string[];
+/**
+ * validate the individual bar chart data item using its x and y values
+ * @param props.dataItem The bar/line chart data item
+ * @param props.x The x value from series config
+ * @param props.y The y value from series config
+ * @param props.nullAsValid Whether to consider `null` values as valid
+ */
+export declare function validateBarNLineChartDataItem(props: {
+    dataItem: WebChartDataItem;
+    x: string;
+    y: string;
+    nullAsValid?: boolean;
+}): boolean;
+/**
+ * Indicates whether a data set is empty (no bar, no slice, etc.) and contains at least one valid item.
+ * @param props.config The chart's config
+ * @param props.nullAsValid Whether to consider `null` values as valid
+ * @param props.dataSet The chart's data
+ * @returns A boolean
+ */
+export declare function isEmptyDataset(props: {
+    chartConfig?: WebChart | WebGaugeChart;
+    nullAsValid?: boolean;
+    dataSet?: WebChartDataItem[];
+}): boolean;
+/**
+ * Looks for the min and max values from a data set, considering only the visible series.
+ * @param props.chartConfig The chart config
+ * @param props.chartData The chart's data (as fed to the amCharts chart)
+ * @param props.filteredSeriesIds List of series ids to use as a filter
+ */
+export declare function getDataMinMaxFromSeries(props: {
+    chartConfig: WebChart;
+    chartData: WebChartDataItem[];
+    filteredSeriesIds?: string[];
+}): DataMinMax;

package/dist/utils/data/interfaces.d.ts

@@ -0,0 +1,39 @@
+import { WebChartDataTypes, WebChartQuery } from '@arcgis/charts-spec';
+import { DataWarningKeywords } from '../chart-config/validator/interfaces';
+import { ChartSubType } from '../misc/interfaces';
+import { BinnedServerData } from './time-binning/interfaces';
+export interface DataMinMax {
+    minY: number;
+    maxY: number;
+    minX?: number;
+    maxX?: number;
+}
+export interface DataInfo {
+    valid: boolean;
+    invalidType?: DataWarningKeywords;
+    count?: number;
+    data?: WebChartDataTypes;
+    binnedServerData?: BinnedServerData;
+    queryConfig?: WebChartQuery;
+}
+export declare const BoxPlotYFieldKeys: {
+    Min: string;
+    FirstQuartile: string;
+    Median: string;
+    ThirdQuartile: string;
+    Max: string;
+    IQR: string;
+    Average: string;
+    StandardDeviation: string;
+    Outlier: string;
+};
+export type BoxPlotYFieldKeys = (typeof BoxPlotYFieldKeys)[keyof typeof BoxPlotYFieldKeys];
+export interface BoxPlotYValueProps {
+    key: BoxPlotYFieldKeys;
+    y?: string;
+    chartSubType?: ChartSubType;
+    splitBy?: string;
+    splitByValue?: number | string | null;
+    showOutliers?: boolean;
+    standardizeValues?: boolean;
+}

package/dist/utils/data/time-binning/interfaces.d.ts

@@ -0,0 +1,29 @@
+import { TimeIntervalInfo, WebChartDataItem, WebChartTemporalBinningUnits } from '@arcgis/charts-spec';
+export interface DateRange {
+    dateMinTimestamp: number;
+    dateMaxTimestamp: number;
+}
+export interface IntervalUnitHelper {
+    unit: WebChartTemporalBinningUnits;
+    threshold: number;
+    unitMs: number;
+    preferredIntervalSize: number[];
+}
+export declare const timeUnitHelper: IntervalUnitHelper[];
+export interface TimeBinningStatistics {
+    dateRange: DateRange;
+    numberOfFeatures: number;
+}
+export interface BinnedServerData {
+    data: WebChartDataItem[];
+    timeBinningStats: TimeBinningStatistics;
+}
+export interface GroupProps {
+    binFirstOrLastIndex: number;
+    data: WebChartDataItem[];
+    x: string;
+    timeIntervalInfo: TimeIntervalInfo;
+    newDateMin: number;
+    newDateMax: number;
+}
+export declare const groupByWhenCaseForMedianTimeBinning = "${ groupByFieldsForStatistics } WHEN ${ dateField }>='${ startDate }' AND ${ dateField }${ endDateOperand }'${ endDate }' THEN '${ y }|${ binIndex}'";