@arcgis/charts-components 5.0.0-next.99 → 5.1.0-next.0

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

@@ -1,93 +1,25 @@
-import { WebChart, WebGaugeChart } from '../../../spec';
-import { WebChartJSONSchemas } from '../../../json-schema';
-import { ErrorObject } from 'ajv';
-import { QueryObject } from '../../layer/interfaces';
-import { ConfigWarningObject, CustomErrorObject, ValidationStatus } from './interfaces';
-/**
- * Extracts schema name from the schema `$ref` path
- * For e.g.:
- *   - "#/definitions/WebChartInlineDataSource" => "WebChartInlineDataSource"
- *   - "#/definitions/WebChartBarChartSeries" => "WebChartBarChartSeries"
- * @param schemaRefPath
- */
-declare function extractSchemaNameFromRefPath(schemaRefPath: string): string;
-/**
- * Formats specific error messages based on the error keyword.
- * @param errors Array storing the errors met during the validation
- */
-declare function customizeValidationErrors(errors: ErrorObject[]): Promise<ErrorObject[]>;
-/**
- * By default, the JSON schema created by ac-spec is suitable for WebChart validation.
- * If we want to validate any other object, an appropriate schema can be generated via this function.
- * @param schema
- * @param schemaKey
- */
-declare function createStartingSchema(schema: typeof WebChartJSONSchemas, schemaKey: keyof typeof WebChartJSONSchemas.definitions): typeof WebChartJSONSchemas;
-/**
- * Tests whether a layer can be loaded.
- * @param queryObject The query object (layer or feature layer view)
- */
-declare function findLayerLoadError(queryObject: QueryObject): Promise<CustomErrorObject | undefined>;
-/**
- * Check whether there exists a `StatisticDefinition` in any series' `Query` where non-count aggregation is applied to a non-numeric field
- * @param props.seriesConfigs The series config list
- * @param props.queryObject The query object
- * @param props.allowUsingObjectIdStat Whether to allow using the object id field as a statistic field
- */
-declare function findNumericAggregationWarnings(props: {
-    seriesConfigs: WebChart["series"];
-    queryObject: QueryObject;
-    allowUsingObjectIdStat?: boolean;
-}): Promise<ConfigWarningObject[]>;
-/**
- * Verifies that the chart series are unique. Sets a message to display if not.
- * @param chartConfig The chart config
- */
-declare function findDuplicateSeriesIDWarnings(chartConfig?: WebChart): Promise<ConfigWarningObject[]>;
-/**
- * Look for issues of level 'warning' in the chart config.
- * @param props.input The input config
- * @param props.queryObject The query object
- * @param props.allowUsingObjectIdStat Whether to allow using the object id field as a statistic field
- */
-declare function findWarnings(props: {
-    input: WebChart;
-    queryObject: QueryObject;
-    allowUsingObjectIdStat?: boolean;
-}): Promise<ConfigWarningObject[]>;
-/**
- * Look for specific errors independent from the JSON schema.
- * @param queryObject The query object
- * @param chartConfig The chart config
- */
-declare function findCustomErrors(queryObject?: QueryObject, chartConfig?: WebChart | WebGaugeChart): Promise<CustomErrorObject[]>;
+import type { QueryObject } from "../../layer/interfaces.js";
+import type { ValidationStatus } from "./interfaces.js";
+import type { WebChart, WebGaugeChart } from "../../../spec/web-chart.js";
+
 /**
  * Validates the `WebChart` config by checking for  and displays `Errors` and `Warnings`.
  * - `Errors` are violations in the config w.r.t the JSON schema.
  * - `Warnings` are undesired combinations in the config which don't violate the JSON schema but should still be blocked.
- * @param props.input The input config
- * @param props.queryObject The query object
- * @param props.allowUsingObjectIdStat Whether to allow using the object id field as a statistic field
+ *
+ * @param props - The input config
  */
-export declare function validateWebChart(props: {
+export function validateWebChart(props: {
     input?: WebChart | WebGaugeChart;
     queryObject?: QueryObject;
     allowUsingObjectIdStat?: boolean;
 }): Promise<ValidationStatus>;
+
 /**
  * Checks whether the config is "partial", meaning it has been initialized for a given chart type
  * but has not been provided the minimum required prop(s) yet.
- * @param config The config to analyze
+ *
+ * @param config - The config to analyze
+ * @internal
  */
-export declare function isPartialConfig(config?: WebChart): boolean;
-export declare const chartConfigValidatorPrivateFunctions: {
-    findCustomErrors: typeof findCustomErrors;
-    findWarnings: typeof findWarnings;
-    findNumericAggregationWarnings: typeof findNumericAggregationWarnings;
-    findDuplicateSeriesIDWarnings: typeof findDuplicateSeriesIDWarnings;
-    findLayerLoadError: typeof findLayerLoadError;
-    createStartingSchema: typeof createStartingSchema;
-    extractSchemaNameFromRefPath: typeof extractSchemaNameFromRefPath;
-    customizeValidationErrors: typeof customizeValidationErrors;
-};
-export {};
+export function isPartialConfig(config?: WebChart): boolean;

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

@@ -1,45 +1,46 @@
-import { default as Ajv } from 'ajv';
-import { RESTFieldType, WebChartStatisticType } from '../../../spec';
-import { ErrorKeywords } from '../../errors/interfaces';
-export declare const ConfigWarningKeywords: {
+import type Ajv from "ajv";
+import type { ErrorKeywords } from "../../errors/interfaces.js";
+import type { RESTFieldType } from "../../../spec/rest-js-object-literals.js";
+import type { WebChartStatisticType } from "../../../spec/chart-object-literals.js";
+
+/** @internal */
+export 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;
-}
+
+/** @internal */
+export type ConfigWarningKeywords = (typeof ConfigWarningKeywords)[keyof typeof ConfigWarningKeywords];
+
+/** @internal */
 export interface ConfigWarningObject {
-    keyword: ConfigWarningKeywords;
-    dataPath: string;
-    message: string;
-    params: DuplicateSeriesIdParams | NumericAggregationParams;
+  keyword: ConfigWarningKeywords;
+  dataPath: string;
+  message: string;
+  params: DuplicateSeriesIdParams | NumericAggregationParams;
 }
+
+/** @internal */
 export interface CustomErrorObject {
-    keyword: ErrorKeywords;
-    message: string;
-    params: LayerLoadFailureParams | string;
+  keyword: ErrorKeywords;
+  message: string;
+  params: LayerLoadFailureParams | string;
 }
+
 /**
  * Validation Status interface which described the validity of the input WebChart config
+ *
+ * @internal
  */
 export interface ValidationStatus {
-    valid: boolean;
-    schemaErrors: Ajv.ErrorObject[];
-    customErrors: CustomErrorObject[];
-    warnings: ConfigWarningObject[];
+  valid: boolean;
+  schemaErrors: Ajv.ErrorObject[];
+  customErrors: CustomErrorObject[];
+  warnings: ConfigWarningObject[];
 }
-export declare const ConfigErrorKeywords: {
+
+/** @internal */
+export const ConfigErrorKeywords: {
     readonly Required: "required";
     readonly MinLength: "minLength";
     readonly MinItems: "minItems";
@@ -49,9 +50,12 @@ export declare const ConfigErrorKeywords: {
     readonly Enum: "enum";
     readonly AnyOf: "anyOf";
 };
-export declare const DataWarningKeywords: {
+
+/** @internal */
+export const DataWarningKeywords: {
     readonly BadData: "badData";
     readonly EmptyDataSet: "emptyDataSet";
+    readonly InvalidConfig: "invalidConfig";
     readonly HistogramEmptyField: "histogramEmptyField";
     readonly BarElementExceedsLimit: "barElementExceedsLimit";
     readonly LineChartExceedsLimit: "lineChartExceedsLimit";
@@ -66,16 +70,36 @@ export declare const DataWarningKeywords: {
     readonly NegativeValueInXAxisLogScale: "negativeValueInXAxisLogScale";
     readonly NegativeValueInYAxisLogScale: "negativeValueInYAxisLogScale";
 };
+
 export type DataWarningKeywords = (typeof DataWarningKeywords)[keyof typeof DataWarningKeywords];
-interface ElementCountExceededParams {
-    actualCount: number;
-    totalLimit: number;
-    seriesLimit?: number;
+
+/** @internal */
+export interface ElementCountExceededParams {
+  actualCount: number;
+  totalLimit: number;
+  seriesLimit?: number;
 }
+
+/** @internal */
 export interface DataWarningObject {
-    keyword: DataWarningKeywords;
-    header: string;
-    message: string;
-    params?: ElementCountExceededParams;
+  keyword: DataWarningKeywords;
+  header: string;
+  message: string;
+  params?: ElementCountExceededParams;
+}
+
+export interface NumericAggregationParams {
+  fieldName: string;
+  fieldType: RESTFieldType;
+  aggregationRequested: WebChartStatisticType;
+}
+
+export interface DuplicateSeriesIdParams {
+  seriesName: string;
+  seriesId: string;
 }
-export {};
+
+export interface LayerLoadFailureParams {
+  url: string;
+  portalItemId: string;
+}

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

@@ -1,51 +1,69 @@
-import { default as MapView } from '@arcgis/core/views/MapView';
-import { default as SceneView } from '@arcgis/core/views/SceneView';
-import { ChartModel } from '../../model';
-import { DefaultChartActions, PieSlicesSymbols, SelectionData, SeriesSymbolsMap } from '../../utils';
-import { CalculatedMinMaxBoundsPayload, LegendItemVisibility, WebChartDataTypes, WebChartLegendPositions } from '../../spec';
-import { JsxNode } from '@arcgis/lumina';
+import type MapView from "@arcgis/core/views/MapView";
+import type SceneView from "@arcgis/core/views/SceneView";
+import type { DOMContainerAria } from "@arcgis/core/views/DOMContainer";
+import type { JsxNode } from "@arcgis/lumina";
+import type { ChartModel } from "../../model/chart-model/chart-model.js";
+import type { PieSlicesSymbols, SelectionData, SeriesSymbolsMap } from "../misc/interfaces.js";
+import type { WebChartDataTypes } from "../../spec/data-source.js";
+import type { CalculatedMinMaxBoundsPayload, LegendItemVisibility } from "../../spec/events.js";
+import type { WebChartLegendPositions } from "../../spec/chart-object-literals.js";
+import type { DefaultChartActions } from "../types/index.js";
+
+/** @internal */
 export type PanelNumberChangePayload = {
-    panelNumber: number;
-    modelList: ChartModel[];
+  panelNumber: number;
+  modelList: ChartModel[];
 };
+
+/** @internal */
 export type DataChangeErrorPayload = {
-    error: Error;
-    model: ChartModel;
+  error: Error;
+  model: ChartModel;
 };
+
+/** @internal */
 export type PopoverChangePayload = {
-    open: boolean | undefined;
-    element: JsxNode;
+  open?: boolean;
+  element: JsxNode;
 };
+
 export type ModelListChangePayload = {
-    modelList: ChartModel[];
+  modelList: ChartModel[];
 };
+
 export type DataProcessCompletePayload = {
-    chartData: WebChartDataTypes;
-    model: ChartModel | undefined;
+  chartData: WebChartDataTypes;
+  model?: ChartModel;
 };
+
 export type AxesMinMaxChangePayload = {
-    bounds: CalculatedMinMaxBoundsPayload[];
-    model: ChartModel | undefined;
+  bounds: CalculatedMinMaxBoundsPayload[];
+  model?: ChartModel;
 };
+
 export type SeriesColorChangePayload = {
-    data: PieSlicesSymbols | SeriesSymbolsMap;
-    colorMatchApplied: boolean;
-    model: ChartModel | undefined;
+  data: PieSlicesSymbols | SeriesSymbolsMap;
+  colorMatchApplied: boolean;
+  model?: ChartModel;
 };
+
 export type NoRenderPropChangePayload = {
-    propName: string;
-    value: MapView | SceneView | WebChartLegendPositions | boolean | number | undefined;
-    model: ChartModel | undefined;
+  propName: string;
+  value?: DOMContainerAria | MapView | SceneView | WebChartLegendPositions | boolean | number;
+  model?: ChartModel;
 };
+
 export type LegendItemVisibilityChangePayload = {
-    legendItemVisibility: LegendItemVisibility;
-    model: ChartModel | undefined;
+  legendItemVisibility: LegendItemVisibility;
+  model?: ChartModel;
 };
+
 export type SelectionCompletePayload = {
-    selectionData: SelectionData;
-    model: ChartModel | undefined;
+  selectionData: SelectionData;
+  model?: ChartModel;
 };
+
 export type DefaultActionSelectPayload = {
-    actionId: DefaultChartActions;
-    actionActive: boolean;
-};
+  actionId: DefaultChartActions;
+  actionActive: boolean;
+};

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

@@ -1,16 +1,14 @@
-import { SupportedCharts } from '../../utils';
-import { WebChartBarChartSeries, WebChartBoxPlotSeries, WebChartLineChartSeries, WebChartRadarChartSeries } from '../../spec';
-/** Supported chart types. */
-export declare const supportedChartTypes: SupportedCharts[];
-export declare const maximumNumberOfSimultaneousUpdates = 1;
+import type { WebChartBarChartSeries, WebChartBoxPlotSeries, WebChartLineChartSeries, WebChartRadarChartSeries } from "../../spec/web-chart.js";
+
 export interface MissingSplitBySeriesProps {
-    addMissingSeries: boolean;
-    seriesTemplate?: WebChartBarChartSeries | WebChartBoxPlotSeries | WebChartLineChartSeries | WebChartRadarChartSeries;
+  addMissingSeries: boolean;
+  seriesTemplate?: WebChartBarChartSeries | WebChartBoxPlotSeries | WebChartLineChartSeries | WebChartRadarChartSeries;
 }
-export type WebChartSeriesUsingSplitBy = WebChartBarChartSeries | WebChartBoxPlotSeries | WebChartLineChartSeries | WebChartRadarChartSeries;
-export declare const DownloadableChartImagesTypes: {
+
+export const DownloadableChartImagesTypes: {
     readonly PNG: "png";
     readonly JPEG: "jpeg";
     readonly SVG: "svg";
 };
-export type DownloadableChartImagesTypes = (typeof DownloadableChartImagesTypes)[keyof typeof DownloadableChartImagesTypes];
+
+export type DownloadableChartImagesTypes = (typeof DownloadableChartImagesTypes)[keyof typeof DownloadableChartImagesTypes];

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

@@ -1,14 +1,17 @@
-export declare const ActionModes: {
+export 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: {
+
+export const CursorRange: {
     readonly MultiAxes: "multi-axes";
     readonly XAxis: "x-axis";
     readonly YAxis: "y-axis";
 };
-export type CursorRange = (typeof CursorRange)[keyof typeof CursorRange];
+
+export type CursorRange = (typeof CursorRange)[keyof typeof CursorRange];

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

@@ -1,7 +1,8 @@
-import { WebChartQuery } from '../../../spec';
-import { ChartElementLimit } from '../../defaults/interfaces';
-import { QueryObject } from '../../layer/interfaces';
-import { AbortControllerKeyType } from '../../layer/query-features/interfaces';
+import type { ChartElementLimit } from "../../defaults/interfaces.js";
+import type { QueryObject } from "../../layer/interfaces.js";
+import type { AbortControllerKeyType } from "../../layer/query-features/interfaces.js";
+import type { WebChartQuery } from "../../../spec/web-chart.js";
+
 /**
  * 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.
@@ -12,18 +13,15 @@ import { AbortControllerKeyType } from '../../layer/query-features/interfaces';
  * 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
+ *
+ * @param props - The object used to query the features (layer or feature layer view)
+ * @internal
  */
-export declare function uniqueValues(props: {
+export function uniqueValues(props: {
     queryObject?: QueryObject;
     queryConfig: WebChartQuery;
     category: string;
     splitByField?: string;
     chartLimits?: ChartElementLimit;
     abortKey?: AbortControllerKeyType;
-}): Promise<(number | string)[]>;
+}): Promise<(number | string)[]>;

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

@@ -1,57 +1,63 @@
-import { WebChart, WebChartBin, WebChartDataItem, WebChartDataTypes, WebChartSeriesType, WebGaugeChart } from '../../spec';
-import { ChartSubType } from '../misc/interfaces';
-import { BoxPlotYValueProps, DataMinMax, BoxPlotYFieldKeys } from './interfaces';
+import type { ChartSubType } from "../misc/interfaces.js";
+import type { BoxPlotYValueProps, DataMinMax, BoxPlotYFieldKeys } from "./interfaces.js";
+import type { WebChart, WebChartSeriesType, WebGaugeChart } from "../../spec/web-chart.js";
+import type { WebChartBin, WebChartDataItem, WebChartDataTypes } from "../../spec/data-source.js";
+
 /**
  * Generates the y field names for box plot
+ *
  * @param y
- * @returns
+ * @internal
  */
-export declare function getBoxPlotStatisticFieldNames(y?: string): Record<BoxPlotYFieldKeys, string>;
+export 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
+ * @internal
  */
-export declare function isGaugeByFeature(config: WebChart): boolean;
+export function isGaugeByFeature(config: WebChart): 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
+ * @param fetchedData - The fetched finished data
+ * @internal
  */
-export declare function extractChartDataFromFetchedData(fetchedData?: WebChartDataTypes): WebChartBin[] | WebChartDataItem[] | undefined;
+export 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
+ * @internal
  */
-export declare function isMultiFieldsBoxPlot(chartSubType?: ChartSubType): boolean;
+export 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
+ * @param props - The BoxPlotYFieldKeys related to the stat
+ * @internal
  */
-export declare function getBoxPlotYValue(props: BoxPlotYValueProps): string;
+export 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
+ *
+ * @param props - The WebChartDataItem to check for valid values
+ * @internal
  */
-export declare function doesBoxPlotItemHaveValidQuartiles(props: {
+export 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.
@@ -60,53 +66,58 @@ export declare function doesBoxPlotItemHaveValidQuartiles(props: {
  * 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.
+ *
+ * @param seriesConfig - The array of configs for the chart series.
+ * @param filteredSeriesIds - List of series ids to use as a filter.
+ * @internal
  */
-export declare function getYList(seriesConfig: WebChartSeriesType[], filteredSeriesIds?: string[]): string[];
+export 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.
+ *
+ * @param props - Whether the box plot mean lines are shown
+ * @internal
  */
-export declare function getBoxPlotYList(props: {
+export 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
+ *
+ * @param props - The bar/line chart data item
+ * @internal
  */
-export declare function validateBarNLineChartDataItem(props: {
+export 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
+ *
+ * @param props - The chart's config
  * @returns A boolean
+ * @internal
  */
-export declare function isEmptyDataset(props: {
+export function isEmptyDataset(props: {
     chartConfig?: WebChart | WebGaugeChart;
     nullAsValid?: boolean;
     dataSet?: WebChartDataItem[];
 }): boolean;
+
 /**
  * Gets the data min and max values for a stacked series; also an indicator whether the data has negative values.
- * @param seriesConfig The config for the series
- * @param filteredSeriesIds List of series ids to use as a filter
- * @param filteredData The data to look into
+ *
+ * @param props - The config for the series
+ * @internal
  */
-export declare function getDataMinMaxFromStackedSeries(props: {
+export function getDataMinMaxFromStackedSeries(props: {
     seriesConfig: WebChartSeriesType[];
     filteredSeriesIds?: string[];
     filteredData: WebChartDataItem[];
@@ -115,14 +126,15 @@ export declare function getDataMinMaxFromStackedSeries(props: {
     stackedMaxY: number;
     dataHasNegativeValues: 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
+ *
+ * @param props - The chart config
+ * @internal
  */
-export declare function getDataMinMaxFromSeries(props: {
+export function getDataMinMaxFromSeries(props: {
     chartConfig: WebChart;
     chartData: WebChartDataItem[];
     filteredSeriesIds?: string[];
-}): DataMinMax;
+}): DataMinMax;