@geoscene/charts-components 5.0.19

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

@@ -0,0 +1,347 @@
+import type { ChartElementLimit } from "../defaults/interfaces.js";
+import type { SelectionData, ChartSubType } from "./interfaces.js";
+import type { WebChartSortOrderKinds, WebChartTemporalBinningUnits, WebChartTypes, WebChartStackedKinds } from "../../spec/chart-object-literals.js";
+import type { WebBoxPlot, WebChart, WebChartSeries, WebChartSeriesType } from "../../spec/web-chart.js";
+import type { IField } from "../../spec/rest-js-types.js";
+import type { WebChartDataItem, WebChartDataItemValue } from "../../spec/data-source.js";
+import type { OverlayTerms, LegendItemVisibility } from "../../spec/events.js";
+
+/** @internal */
+export type XYChartType = typeof WebChartTypes.BarSeries | typeof WebChartTypes.BoxPlotSeries | typeof WebChartTypes.ComboLineAndBarSeries | typeof WebChartTypes.HeatSeries | typeof WebChartTypes.HistogramSeries | typeof WebChartTypes.LineSeries | typeof WebChartTypes.RadarSeries | typeof WebChartTypes.ScatterSeries;
+
+/** @internal */
+export type SerialChartType = typeof WebChartTypes.BarSeries | typeof WebChartTypes.ComboLineAndBarSeries | typeof WebChartTypes.HeatSeries | typeof WebChartTypes.LineSeries | typeof WebChartTypes.RadarSeries;
+
+/** @internal */
+export type SupportedChartType = typeof WebChartTypes.BarSeries | typeof WebChartTypes.BoxPlotSeries | typeof WebChartTypes.HeatSeries | typeof WebChartTypes.HistogramSeries | typeof WebChartTypes.LineSeries | typeof WebChartTypes.PieSeries | typeof WebChartTypes.RadarSeries | typeof WebChartTypes.ScatterSeries;
+
+/** @internal */
+export type ChartTypes = Extract<WebChartTypes, WebChartType>;
+
+/** @internal */
+export type XYChartTypes = Extract<WebChartTypes, XYChartType>;
+
+/** @internal */
+export type SerialChartTypes = Extract<WebChartTypes, SerialChartType>;
+
+/** @internal */
+export type SupportedCharts = Extract<ChartTypes, SupportedChartType>;
+
+/**
+ * Returns the color policy for the chart.  If it's not defined, `WebChartColoringPatterns.Single` will be used.
+ *
+ * @param chartConfig - the chart config.
+ * @returns the color policy.
+ * @internal
+ */
+export function getColorMatch(chartConfig?: WebChart): boolean;
+
+/**
+ * Indicates whether or not the chart is rotated.
+ *
+ * @param chartConfig - the chart config.
+ * @internal
+ */
+export function isChartRotated(chartConfig?: WebChart): boolean;
+
+/**
+ * Getting the list of series types from a series config array.
+ *
+ * @param chartSeries - The array of chart's series
+ * @internal
+ */
+export function getSeriesTypes(chartSeries?: WebChartSeries[]): ChartTypes[];
+
+/**
+ * Returns the type of stacking (side-by-side, stacked...) to be used to display the chart.
+ * For Line, Bar, Box-plot, and Radar chart, default option is 'sideBySide'
+ *
+ * @param config
+ * @internal
+ */
+export function getStackedType(config?: WebChart): WebChartStackedKinds | undefined;
+
+/**
+ * Escapes any single quote in the input string with a single quote for SQL.
+ * For example: Cote d'Ivoire -> Cote d''Ivoire
+ *
+ * @param string - input string to replace for any special characters.
+ * @internal
+ */
+export function escapeSQLString(string: string): string;
+
+/**
+ * Normalizes a string by
+ *   - trimming off white spaces
+ *   - if the value is a string and keepSurroundingQuotes is not true: stripping ' (single inverted comma), if present on both sides
+ *   - if escape is true (or undefined): escaping special characters like ", \, /.
+ * E.g.:
+ * "'alpha'" => "alpha"
+ * "'alpha" => No change
+ * "alpha'" => No change
+ * "alp'ha'" => alp''ha
+ * "  'alpha'" => "alpha"
+ * "alp"\/ha" => "alp\"\\\/ha"
+ *
+ * @param props - The string to normalize
+ * @internal
+ */
+export function normalizeString(props: {
+    value: string;
+    keepSurroundingQuotes?: boolean;
+    escape?: boolean;
+}): string;
+
+/**
+ * Indicates whether a chart respects the number limit of elements (bars, markers, cells or slices).
+ * For bar chart, different limits are set according to the number of series.
+ * For line chart, a limit on the number of series and the total number of markers are set.
+ * For heat chart, a limit on the number of cells is set.
+ * For pie chart, a limit on the number of slices is set.
+ *
+ * @param props - Number total of elements on the chart
+ * @internal
+ */
+export function isNumberOfElementsUnderLimit(props: {
+    count: number;
+    seriesCount: number;
+    chartType?: WebChartTypes;
+    chartLimits?: ChartElementLimit;
+}): boolean;
+
+/**
+ * Returns the alias for the field name if it exists; otherwise return the field name itself.
+ *
+ * @param fields - The field name to look for in the field array
+ * @param fieldName - The list of fields containing all the information regarding the fields, including the alias
+ * @internal
+ */
+export function getFieldAlias(fields: IField[] | undefined, fieldName: string): string;
+
+/**
+ * @param fields
+ * @param fieldName
+ * @internal
+ */
+export function getFieldAlias(fields: IField[] | undefined, fieldName: undefined): undefined;
+
+/**
+ * @param fields
+ * @param fieldName
+ * @internal
+ */
+export function getFieldAlias(fields: IField[] | undefined, fieldName: string | undefined): string | undefined;
+
+/**
+ * @param fields
+ * @param fieldName
+ * @internal
+ */
+export function getFieldAlias(fields: IField[] | undefined, fieldName: string | undefined): string | undefined;
+
+/**
+ * Return the field name for the field alias if it exists; otherwise return the field alias itself.
+ *
+ * @param fields - The field alias to look for in the field array
+ * @param fieldAlias - The list of fields containing all the information regarding the fields, including the alias
+ * @internal
+ */
+export function getFieldNameFromFieldAlias(fields: IField[] | undefined, fieldAlias: string): string;
+
+/**
+ * Decides whether we can show the legend or not. If it returns `false`, then we should not show the legend even if `legend.visible` is `true`.
+ * For Pie charts, hide the legend when there is only one slice.
+ *
+ * @param chartSeries
+ * @internal
+ */
+export function canShowLegend(chartSeries: WebChartSeries[]): boolean;
+
+/**
+ * Based on a provided list of supported chart types, this function returns a boolean indicating if the config
+ * contains supported series. An extra test is done for the scatterplot, pie, and histogram series.
+ *
+ * @param supportedChartTypes - The list of supported chart types
+ * @param config - The chart's config
+ * @internal
+ */
+export function isSupportedChart(supportedChartTypes: WebChartTypes[], config?: WebChart): boolean;
+
+/**
+ * Indicates whether a string field is empty (different from undefined, null and empty string).
+ * The value is stringified before being trimmed to debunk edge cases like when the value is a numeric value.
+ *
+ * @param value - The value to test
+ * @returns `true` if empty, `false` otherwise
+ * @internal
+ */
+export function isEmptyStringField(value: string | null | undefined): boolean;
+
+/**
+ * Indicates whether an object contains a property key from list of properties.
+ *
+ * @param data - the object to look into
+ * @param propertyList - the array of property keys to search the data if one of them is present.
+ * @returns An object containing a boolean indicating the propertyList presence, and the property key that matched
+ * @internal
+ */
+export function isPropertyKeyInData<T extends WebChartDataItem>(data: T, propertyList: string[]): {
+    isInItem: boolean;
+    expr?: string;
+};
+
+/**
+ * Indicates whether an object contains the result of a calculated expression coming from a
+ * query (similar to "EXPR_1").
+ *
+ * @param dataItem - the object to look into
+ * @returns An object containing a boolean indicating the expression's presence, and the expression key that matched
+ * @internal
+ */
+export function isQueryCalculatedExprInItem(dataItem: WebChartDataItem): {
+    isInItem: boolean;
+    expr?: string;
+};
+
+/**
+ * Finds localized string for the given `WebChartTemporalBinningUnits` unit type.
+ *
+ * @param unit
+ * @param strings
+ * @returns Localized unit type label
+ * @internal
+ */
+export function getTimeIntervalUnitLabel(unit: WebChartTemporalBinningUnits, strings: {
+    seconds?: string;
+    minutes?: string;
+    hours?: string;
+    days?: string;
+    weeks?: string;
+    months?: string;
+    years?: string;
+}): string;
+
+/**
+ * Returns the appropriate `index` to fetch the default color from `overlayRamp[]` array for a histogram overlay
+ *
+ * @param overlayType
+ * @internal
+ */
+export function getOverlayColorIndex(overlayType: OverlayTerms | undefined): number;
+
+/**
+ * Assigns visible property to a series or an overlay
+ *
+ * @param event - The config that gets updated for each series visibility
+ * @param config - The event that is currently being called
+ * @internal
+ */
+export function updateSeriesVisibility(event: Pick<CustomEvent<LegendItemVisibility>, "detail">, config?: WebBoxPlot | WebChart): void;
+
+/**
+ * Sanitize an HTML string to prevent XSS attacks (https://owasp.org/www-community/attacks/xss/)
+ *
+ * @param inputToSanitize - The HTML string to sanitize
+ * @internal
+ */
+export function sanitizeHTMLOutput(inputToSanitize: string): string;
+
+/**
+ * .
+ * Indicates if a provided number value is valid.
+ * An invalid value is: undefined | NaN | Infinite | -Infinite | null
+ * See for more details:
+ *   - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite
+ *   - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN
+ *
+ * @param value
+ * @internal
+ */
+export function isValidNumber(value: WebChartDataItemValue): boolean;
+
+/**
+ * Gets the sorting field or (sorting type for box-plot) and orderBy from an input string.
+ *
+ * @param stringToParse - The input string to parse, like `orderByField` of a query clause or `orderDataBy` property of a chart config.
+ * @param useDefault - If set to `false`, the default sort order will not be used.
+ * @internal
+ */
+export function getOrderByComponents(stringToParse: string, useDefault?: boolean): {
+    fieldToSort: string;
+    orderBy?: WebChartSortOrderKinds;
+};
+
+/**
+ * Gets the fields listed in the `orderByFields` property of a chart config.
+ *
+ * @param chartConfig - The chart config
+ * @returns The list of fields to sort by
+ * @internal
+ */
+export function getOrderByFields(chartConfig: WebChart): string[];
+
+/**
+ * Determines if certain chart subtype is a split by chart.
+ *
+ * @param chartSubType - The chart subtype
+ * @returns `true` if the chart subtype is a split by chart, `false` otherwise
+ * @internal
+ */
+export function isSplitByChart(chartSubType: ChartSubType): boolean;
+
+/**
+ * Util function to know if the selection data changed.
+ * The selection items and selection OIDs are compared, not the selection source nor the selection indexes.
+ *
+ * @param selectionA - The first selection data
+ * @param selectionB - The second selection data
+ * @returns a boolean indicating whether the two selections are equal
+ * @internal
+ */
+export function hasSelectionChanged(selectionA?: SelectionData, selectionB?: SelectionData): boolean;
+
+/**
+ * Indicates whether the selection data is empty.
+ *
+ * @param selectionData - The selection data to check
+ * @internal
+ */
+export function isSelectionEmpty(selectionData: SelectionData | undefined): boolean;
+
+/**
+ * Sorts `arrayA` based on the indexes of the elements in `arrayB`.
+ *
+ * @param props - The array to be sorted
+ * @internal
+ */
+export function sortArrayAUsingArrayB<T, K>(props?: {
+    arrayA: T[];
+    arrayB: T[];
+    getKey: (item: T) => K;
+}): T[];
+
+/**
+ * Gets the display x field for a chart subtype.
+ *
+ * @param chartSubType - The chart subtype.
+ * @param series - The series.
+ * @returns The default x field.
+ * @internal
+ */
+export function getDisplayXField(chartSubType: ChartSubType, series?: WebChartSeriesType): string;
+
+/**
+ * Determines if an RGBA color is light or dark, considering opacity.
+ *
+ * @param props - Red (0-255)
+ * @returns boolean
+ * @internal
+ */
+export function isColorLight(props: {
+    r: number;
+    g: number;
+    b: number;
+    a?: number;
+}): boolean;
+
+export type WebChartType = typeof WebChartTypes.BarSeries | typeof WebChartTypes.BoxPlotSeries | typeof WebChartTypes.ComboLineAndBarSeries | typeof WebChartTypes.GaugeSeries | typeof WebChartTypes.HeatSeries | typeof WebChartTypes.HistogramSeries | typeof WebChartTypes.LineSeries | typeof WebChartTypes.PieSeries | typeof WebChartTypes.RadarSeries | typeof WebChartTypes.ScatterSeries;

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

@@ -0,0 +1,116 @@
+import type { WebChartHeatChartHeatRulesTypes } from "../../spec/chart-object-literals.js";
+import type { WebChartDataItem } from "../../spec/data-source.js";
+import type { Color, ISimpleFillSymbol, ISimpleLineSymbol, ISimpleMarkerSymbol } from "../../spec/rest-js-types.js";
+import type { WebChartPieChartGroupSlice, WebChartPieChartSlice } from "../../spec/web-chart.js";
+
+export const ChartSubType: {
+    readonly NonSpecific: "nonSpecific";
+    readonly BarAndLineNoAggregation: "barAndLineNoAggregation";
+    readonly BarAndLineMonoField: "barAndLineMonoField";
+    readonly BarAndLineMultiFields: "barAndLineMultiFields";
+    readonly BarAndLineFromFields: "barAndLineFromFields";
+    readonly BarAndLineSplitBy: "barAndLineSplitBy";
+    readonly BarAndLineSplitByNoAggregation: "barAndLineSplitByNoAggregation";
+    readonly PieNoAggregation: "pieNoAggregation";
+    readonly PieFromCategory: "pieFromCategory";
+    readonly PieFromFields: "pieFromFields";
+    readonly BoxPlotMonoField: "boxPlotMonoField";
+    readonly BoxPlotMultiFields: "boxPlotMultiFields";
+    readonly BoxPlotMonoFieldAndCategory: "boxPlotMonoFieldAndCategory";
+    readonly BoxPlotMultiFieldsAndCategory: "boxPlotMultiFieldsAndCategory";
+    readonly BoxPlotMonoFieldAndSplitBy: "boxPlotMonoFieldAndSplitBy";
+    readonly BoxPlotMultiFieldsAndSplitBy: "boxPlotMultiFieldsAndSplitBy";
+    readonly BoxPlotMonoFieldAndCategoryAndSplitBy: "boxPlotMonoFieldAndCategoryAndSplitBy";
+};
+
+export type ChartSubType = (typeof ChartSubType)[keyof typeof ChartSubType];
+
+export const SelectionSource: {
+    readonly SelectionByClick: "SelectionByClick";
+    readonly SelectionByRange: "SelectionByRange";
+    readonly ProgrammaticSelection: "ProgrammaticSelection";
+    readonly ClearSelection: "ClearSelection";
+};
+
+export type SelectionSource = (typeof SelectionSource)[keyof typeof SelectionSource];
+
+export type SelectionIndexes = Map<number, { indexesToSelect?: number[]; }>;
+
+export interface SelectionData {
+  selectionItems?: WebChartDataItem[];
+  selectionIndexes?: SelectionIndexes;
+  selectionOIDs?: (number | string)[];
+  selectionSource?: SelectionSource;
+}
+
+export interface SelectionThemeProperties {
+  elementColor?: Color;
+  elementOutlineColor?: Color;
+  elementOutlineWidth?: number;
+  rotation?: number;
+  transformation?: {
+      opacity?: number;
+      scale?: number;
+  };
+}
+
+export interface SelectionTheme {
+  selectedElementsTheme?: SelectionThemeProperties;
+  nonSelectedElementsTheme?: SelectionThemeProperties;
+}
+
+export interface LoaderColors {
+  curtainColor?: Color;
+  spinnerColor?: Color;
+}
+
+export interface HeatSeriesColorChangePayload {
+  heatRulesType?: WebChartHeatChartHeatRulesTypes;
+  seriesColors?: HeatSeriesColorChangePayloadClassSymbols[] | HeatSeriesColorChangePayloadGradient;
+}
+
+export interface HeatSeriesColorChangePayloadGradient {
+  startColor: readonly [number, number, number, number];
+  endColor: readonly [number, number, number, number];
+}
+
+export type HeatSeriesColorChangePayloadClassSymbols = {
+  label: string;
+  symbol: ISimpleFillSymbol;
+};
+
+export type BoxPlotSymbols = { fillSymbol?: ISimpleFillSymbol; } | {
+    lineSymbol: ISimpleLineSymbol;
+    markerSymbol?: ISimpleMarkerSymbol;
+};
+
+export type LineChartSymbols = {
+  lineSymbol: ISimpleLineSymbol;
+  markerSymbol?: ISimpleMarkerSymbol;
+};
+
+export type SeriesSymbols = BoxPlotSymbols | ISimpleFillSymbol | ISimpleLineSymbol | ISimpleMarkerSymbol | LineChartSymbols | PieSlicesSymbols;
+
+/**
+ * Type used to provide information regarding a pie chart's slices:
+ * - `slices` contains an array of `WebChartPieChartSlice` related to the non-grouped slices.
+ * - `groupedSlices` contains an array of `WebChartPieChartSlice` related to the non-visible grouped slices.
+ * - `groupOfSlices` contains a `WebChartPieChartSlice`related to the group of slices.
+ *
+ * The `WebChartPieChartSlice` contains information regarding a slice's id, symbol and label.
+ */
+export type PieSlicesSymbols = {
+  slices: WebChartPieChartSlice[];
+  groupedSlices?: WebChartPieChartSlice[];
+  groupOfSlices?: WebChartPieChartGroupSlice;
+};
+
+/**
+ * Map containing a chart's series symbols.
+ * The numeric key is the series' position in the series array.
+ * The value is either:
+ *   - A fill symbol (bar chart and histogram).
+ *   - A marker symbol (scatterplot).
+ *   - An object containing a line symbol and a marker symbol (line chart).
+ */
+export type SeriesSymbolsMap = Map<number, SeriesSymbols | undefined>;

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

@@ -0,0 +1,229 @@
+import type { ModelTypes } from "../../model/interfaces/common.js";
+import type { WebChartStackedKinds } from "../../spec/chart-object-literals.js";
+import type { WebChartDataTypes, WebChartGenericDataItem, WebChartHistogramDataItem, WebChartScatterplotDataItem } from "../../spec/data-source.js";
+import type { IFeatureLayer, ISimpleFillSymbol, ISimpleLineSymbol, ISimpleMarkerSymbol } from "../../spec/rest-js-types.js";
+import type { CategoryFormatOptions, DateTimeFormatOptions, NumberFormatOptions, WebBoxPlot, WebChart, WebChartBarChartSeries, WebChartBoxPlotSeries, WebChartHeatChartSeries, WebChartLineChartSeries, WebChartRadarChartSeries, WebChartSeries, WebChartTextSymbol, WebGaugeChart, WebHeatChart } from "../../spec/web-chart.js";
+import type { ChartTypes } from "../misc/index.js";
+import type { ChartConfig } from "../types/index.js";
+
+/** @internal */
+export type StringIndexable<T> = Record<string, unknown>
+  & T;
+
+/**
+ * Web chart series with rotated property
+ *
+ * @internal
+ */
+export type WebChartSeriesWithRotatedProp = WebChartSeries
+  & {
+  rotated?: boolean;
+};
+
+/**
+ * Check if the chart config supports rotation or not.
+ *
+ * @param config - the chart config
+ * @internal
+ */
+export function isRotationSupported(config: WebChart): config is WebChart & { series: WebChartSeriesWithRotatedProp[]; };
+
+/**
+ * Web chart series with stackedType property
+ *
+ * @internal
+ */
+export type WebChartSeriesWithStackedTypeProp = WebChartSeries
+  & {
+  stackedType?: WebChartStackedKinds;
+};
+
+/**
+ * Check if the chart config supports rotation or not.
+ *
+ * @param config - the chart config
+ * @internal
+ */
+export function isStackedTypeSupported(config: WebChart): config is WebChart & { series: WebChartSeriesWithStackedTypeProp[]; };
+
+/**
+ * Type guard for `ISimpleFillSymbol`
+ *
+ * @param symbol
+ * @internal
+ */
+export function isSFS(symbol: any): symbol is ISimpleFillSymbol;
+
+/**
+ * Type guard for `ISimpleLineSymbol`
+ *
+ * @param symbol
+ * @internal
+ */
+export function isSLS(symbol: any): symbol is ISimpleLineSymbol;
+
+/**
+ * Type guard for `ISimpleMarkerSymbol`
+ *
+ * @param symbol
+ * @internal
+ */
+export function isSMS(symbol: any): symbol is ISimpleMarkerSymbol;
+
+/**
+ * Type guard for `WebChartTextSymbol`
+ *
+ * @param symbol
+ * @internal
+ */
+export function isWebChartTextSymbol(symbol: any): symbol is WebChartTextSymbol;
+
+/**
+ * Determines if the provided `config` has a `iLayer` property.
+ *
+ * @param config
+ * @internal
+ */
+export function hasILayer<T extends ModelTypes>(config: ChartConfig<T> | undefined): config is ChartConfig<T, T extends "boxPlot" ? WebBoxPlot : T extends "gauge" ? WebGaugeChart : T extends "heatChart" ? WebHeatChart : WebChart>;
+
+/**
+ * @param config
+ * @internal
+ */
+export function hasILayer(config: WebChart | undefined): config is WebChart & { iLayer: IFeatureLayer; };
+
+/**
+ * @param config
+ * @internal
+ */
+export function hasILayer<T extends ModelTypes>(config: ChartConfig<T> | undefined): unknown;
+
+/**
+ * Determines if the provided `config` is the specified chart type `T`.
+ *
+ * @param config - The chart config to check.
+ * @param chartType - The chart type to check against.
+ * @internal
+ */
+export function isChartType<T extends ChartConfig>(config: WebChart | undefined, chartType: ChartTypes | undefined): config is T;
+
+/**
+ * Determines if the series is a box plot series.
+ *
+ * @param series - The series to check.
+ * @internal
+ */
+export function isBoxPlotSeries(series: WebChartSeries | undefined): series is WebChartBoxPlotSeries;
+
+/**
+ * Determines if the series is a line chart series.
+ *
+ * @param series - The series to check.
+ * @internal
+ */
+export function isLineChartSeries(series: WebChartSeries | undefined): series is WebChartLineChartSeries;
+
+/**
+ * Determines if the series is a radar chart series.
+ *
+ * @param series - The series to check.
+ * @internal
+ */
+export function isRadarChartSeries(series: WebChartSeries | undefined): series is WebChartRadarChartSeries;
+
+/**
+ * Determines if the series is a bar chart series.
+ *
+ * @param series - The series to check.
+ * @internal
+ */
+export function isBarChartSeries(series: WebChartSeries | undefined): series is WebChartBarChartSeries;
+
+/**
+ * Determines if the series is a heat chart series.
+ *
+ * @param series - | undefined} series The series to check.
+ * @internal
+ */
+export function isHeatChartSeries(series: WebChartSeries | undefined): series is WebChartHeatChartSeries;
+
+/**
+ * Type guard to check if the series is a `BarChartSeries`.
+ *
+ * @param series - The series to check.
+ * @internal
+ */
+export function isBarChartSeriesArray(series: WebChartSeries[]): series is WebChartBarChartSeries[];
+
+/**
+ * Type guard to check if the series is a `LineChartSeries`.
+ *
+ * @param series - The series to check.
+ * @internal
+ */
+export function isLineChartSeriesArray(series: WebChartSeries[]): series is WebChartLineChartSeries[];
+
+/**
+ * Type guard to check if the series is a `RadarChartSeries`.
+ *
+ * @param series - The series to check.
+ * @internal
+ */
+export function isRadarChartSeriesArray(series: WebChartSeries[]): series is WebChartRadarChartSeries[];
+
+/**
+ * Type guard to check if the series is a HeatChartSeries.
+ *
+ * @param series - series - The series to check.
+ * @returns {series is WebChartHeatChartSeries[]}
+ * @internal
+ */
+export function isHeatChartSeriesArray(series: WebChartSeries[]): series is WebChartHeatChartSeries[];
+
+/**
+ * Determines if the series array is of type box plot series.
+ *
+ * @param series - The series to check.
+ * @internal
+ */
+export function isBoxPlotSeriesArray(series: WebChartSeries[]): series is WebChartBoxPlotSeries[];
+
+/**
+ * Type guard for axis format being `NumberFormatOptions`
+ *
+ * @param valueFormat - valueFormat to check
+ * @internal
+ */
+export function isNumberFormatOptions(valueFormat: CategoryFormatOptions | DateTimeFormatOptions | NumberFormatOptions | undefined): valueFormat is NumberFormatOptions;
+
+/**
+ * Type guard for `WebChartDataTypes` being `WebChartHistogramDataItem`.
+ *
+ * @param data - dataItem to check
+ * @internal
+ */
+export function isWebChartHistogramDataItemOrUndefined(data: WebChartDataTypes | undefined): data is WebChartHistogramDataItem | undefined;
+
+/**
+ * Type guard for `WebChartDataTypes` being `WebChartGenericDataItem`.
+ *
+ * @param data - dataItem to check
+ * @internal
+ */
+export function isWebChartGenericDataItemOrUndefined(data: WebChartDataTypes | undefined): data is WebChartGenericDataItem | undefined;
+
+/**
+ * Type guard for `WebChartDataTypes` being `WebChartScatterplotDataItem`.
+ *
+ * @param data - dataItem to check
+ * @internal
+ */
+export function isWebChartScatterplotDataItemOrUndefined(data: WebChartDataTypes | undefined): data is WebChartScatterplotDataItem | undefined;
+
+/**
+ * TODO: Once charts-shared-utils is merged into charts-components, we can create a more official version of this type-guard using the AmCharts types.
+ *
+ * @param axisDataItem
+ * @internal
+ */
+export function isValueAxisDataItem<T extends object>(axisDataItem: T): axisDataItem is T & { value: number; };