@arcgis/charts-components 5.1.0-next.13 → 5.1.0-next.130

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

@@ -1,12 +1,15 @@
-import type { ChartOptions } from "../../../chart-rendering/common/interfaces.js";
-import type { DataUpdateDetails } from "../../data/interfaces.js";
-import type { ChartSubType } from "../../misc/interfaces.js";
-import type { WebChartSeriesSupportingTemporalBinning } from "./interfaces.js";
+import type { DataOrderParameters } from "../../../chart-rendering/common/data/utils/summarize-data/interfaces.js";
 import type { WebChartTypes, WebChartVersionStatus } from "../../../spec/chart-object-literals.js";
-import type { WebBoxPlot, WebChart, WebChartLegend, WebChartSeriesType, WebHeatChart } from "../../../spec/web-chart.js";
 import type { RESTSymbolType } from "../../../spec/rest-js-object-literals.js";
-import type { TimeIntervalInfo } from "../../../spec/data-source.js";
 import type { IField } from "../../../spec/rest-js-types.js";
+import type { WebBoxPlot, WebChart, WebChartLegend, WebChartSeriesType, WebHeatChart } from "../../../spec/web-chart.js";
+import type { DataUpdateDetails } from "../../data/interfaces.js";
+import type { ChartElementLimit } from "../../defaults/interfaces.js";
+import type { QueryObjectOrRaster as QueryObject } from "../../layer/interfaces.js";
+import type { ChartSubType, SelectionData } from "../../misc/interfaces.js";
+import type { WebChartSeriesSupportingTemporalBinning } from "./interfaces.js";
+import type { ChartOptions } from "../../../chart-rendering/common/interfaces.js";
+import type { WebChartBin, WebChartDataItem } from "../../../spec/data-source.js";
 
 /**
  * Retrieve and construct chart version information based on the input version and the currently supported ArcGIS Chart versions
@@ -94,6 +97,7 @@ export function isAbsoluteTruthWhereClause(where?: string): boolean;
  *   - where = "field = 5" => returns "field = 5"
  *   - where = "field = 'value'" => returns "field = 'value'"
  *   - where = "field = 'va'lue'" => returns "field = 'va''lue'"
+ *   - where = "field = null => returns "field IS NULL"
  *
  * @param props - the where clause to normalize
  * @internal
@@ -127,6 +131,33 @@ export function getBoxPlotChartSubType(seriesConfig: WebChartSeriesType[]): Char
  */
 export function getChartSubType(series?: WebChartSeriesType[]): ChartSubType;
 
+/**
+ * A function to determine whether the scatterplot is aggregated.
+ * It can use a map of statistics containing the number of points (computed from the data side) or
+ * a data context object usually stored within each marker.
+ *
+ * @param props - an optional map of statistics
+ * @returns A boolean indicating whether the scatterplot is aggregated
+ */
+export function isScatterplotAggregated(props: {
+    statsMap?: Map<string, number>;
+    dataContext?: WebChartDataItem;
+    chartLimits?: ChartElementLimit;
+}): boolean;
+
+/**
+ * A function to determine whether a chart is aggregated.
+ * Supports scatterplot, bar, line, combo, and pie chart. Defaults to true for the other types of chart.
+ *
+ * @param props - An optional data context object
+ * @returns A boolean indicating whether the chart is aggregated
+ */
+export function isChartAggregated(props: {
+    dataContext?: WebChartBin | WebChartDataItem;
+    chartConfig: WebChart;
+    chartLimits?: ChartElementLimit;
+}): boolean;
+
 /**
  * Indicates whether the bar or line series is configured to use time binning.
  *
@@ -137,6 +168,7 @@ export function isSeriesUsingTimeBinning(props: {
     seriesConfig: WebChartSeriesType;
     xAxisValueFormatType?: WebChartTypes;
     setTimeBinningInfoWhenNotProvided?: boolean;
+    queryObject?: QueryObject;
 }): boolean;
 
 /**
@@ -145,7 +177,7 @@ export function isSeriesUsingTimeBinning(props: {
  * @param series - The series to test
  * @internal
  */
-export function doesSeriesSupportTemporalBinning(series: WebChartSeriesType): series is WebChartSeriesSupportingTemporalBinning;
+export function doesSeriesSupportTemporalBinning(series?: WebChartSeriesType): series is WebChartSeriesSupportingTemporalBinning;
 
 /**
  * Compares two config data filters and returns true if they are identical, false otherwise
@@ -203,7 +235,7 @@ export function hasAdditionalTooltipFieldsChanged(props: {
  * @param newConfig - The updated config
  * @internal
  */
-export function hasColorMatchChanged(oldConfig: WebChart, newConfig: WebChart): boolean;
+export function hasColorMatchChanged(oldConfig: WebChart | undefined, newConfig: WebChart): boolean;
 
 /**
  * Compares two configs and indicates whether the stacked type changed
@@ -267,7 +299,7 @@ export function hasHeatRulesTypeChanged(oldConfig: WebHeatChart, newConfig: WebH
  * @internal
  */
 export function hasSlicesConfigChanged(props: {
-    oldConfig: WebChart;
+    oldConfig: WebChart | undefined;
     newConfig: WebChart;
 }): boolean;
 
@@ -277,7 +309,8 @@ export function hasSlicesConfigChanged(props: {
  */
 export function hasDataForFilterBySelectionChanged(props: {
     previousSelectionOIDs?: (number | string)[];
-    options?: ChartOptions;
+    selectionData?: SelectionData;
+    filterBySelection?: boolean;
 }): boolean;
 
 /**
@@ -368,7 +401,7 @@ export function hasStandardizeValuesVisibilityChanged(oldConfig: WebBoxPlot, new
  * @param newConfig - the new chart config
  * @internal
  */
-export function hasChartRendererChanged(oldConfig: WebChart, newConfig: WebChart): boolean;
+export function hasChartRendererChanged(oldConfig?: WebChart, newConfig?: WebChart): boolean;
 
 /**
  * Returns true if the 'timeZone' property from the axis value format changed in the chart config since the previous update.
@@ -407,11 +440,14 @@ export function doSizePolicyChangesRequireSeriesReinit(oldConfig: WebChart, newC
 export function doesConfigChangeRequireNewData(props: {
     previousConfig: WebBoxPlot | WebChart;
     newConfig: WebBoxPlot | WebChart;
-    options?: ChartOptions;
     previousFilterBySelection?: boolean;
-    previousTimeIntervalInfo?: TimeIntervalInfo;
     previousSelectionOIDs?: (number | string)[];
     fieldList?: IField[];
+    queryObject?: QueryObject;
+    filterBySelection?: ChartOptions["filterBySelection"];
+    selectionData?: ChartOptions["selectionData"];
+    setTimeBinningInfoWhenNotProvided?: ChartOptions["setTimeBinningInfoWhenNotProvided"];
+    chartLimits?: ChartOptions["chartLimits"];
 }): {
     dataUpdateNeeded: boolean;
     dataUpdateDetails: DataUpdateDetails;
@@ -426,4 +462,36 @@ export function doesConfigChangeRequireNewData(props: {
  * @returns The updated chart config with the series sorted, or undefined if the input config is undefined
  * @internal
  */
-export function sortConfigSeries<T extends WebChart | undefined>(chartConfig: T, chartContainer?: HTMLElement): T;
+export function sortConfigSeries<T extends WebChart | undefined>(chartConfig: T, chartContainer?: HTMLElement): T;
+
+/**
+ * Retrieves the configured sort order for one heat-chart axis.
+ *
+ * This allows x and y category lists to be ordered independently from the flattened cell data traversal.
+ *
+ * @param props - The chart config containing the heat-chart multi-axis sort instructions
+ */
+export function getHeatChartAxisDataOrderInstruction(props: {
+    chartConfig: WebHeatChart;
+    field: string;
+}): string[] | string | undefined;
+
+/**
+ * Constructs the `sortingField`, `orderBy`, and/or optionally `preferLabel` for sorting the chart data.
+ *
+ * @param chartConfig - The chart configuration
+ * @returns An array of objects with sortingField, optionally an orderBy and preferLabel, or undefined.
+ */
+export function getDataOrderParameters(chartConfig: WebChart | undefined): DataOrderParameters[] | undefined;
+
+/**
+ * Returns true if the data order instructions (orderType or sortingField, orderBy, and/or preferLabel) have changed, or
+ * the data update is needed.
+ *
+ * @param props - The previous chart config
+ */
+export function isNewSortNeeded(props: {
+    oldConfig: WebChart | undefined;
+    newConfig: WebChart;
+    dataWasUpdated: boolean;
+}): boolean;

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

@@ -1,5 +1,6 @@
-import type { QueryObject } from "../../layer/interfaces.js";
+import type { QueryObjectOrRaster } from "../../layer/interfaces.js";
 import type { ValidationStatus } from "./interfaces.js";
+import type { CommonStrings } from "../../localization/interfaces.js";
 import type { WebChart, WebGaugeChart } from "../../../spec/web-chart.js";
 
 /**
@@ -8,13 +9,15 @@ import type { WebChart, WebGaugeChart } from "../../../spec/web-chart.js";
  * - `Errors`: Violations in the config with regard to the JSON schema.
  * - `Warnings`: Undesired combinations in the config which don't violate the JSON schema but should still be blocked.
  *
+ * @deprecated since 5.1. Won't be replaced.
  * @param props - The input config, the query object and whether to allow using the object id field as a statistic field.
  * @returns The validation status.
  */
 export function validateWebChart(props: {
     input?: WebChart | WebGaugeChart;
-    queryObject?: QueryObject;
+    queryObject?: QueryObjectOrRaster;
     allowUsingObjectIdStat?: boolean;
+    errorStrings?: CommonStrings["errorStrings"];
 }): Promise<ValidationStatus>;
 
 /**

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

@@ -30,6 +30,7 @@ export interface CustomErrorObject {
 /**
  * Validation Status interface which described the validity of the input WebChart config
  *
+ * @deprecated since 5.1. Won't be replaced.
  * @internal
  */
 export interface ValidationStatus {
@@ -55,6 +56,7 @@ export const ConfigErrorKeywords: {
 export const DataWarningKeywords: {
     readonly BadData: "badData";
     readonly EmptyDataSet: "emptyDataSet";
+    readonly NoValue: "noValue";
     readonly InvalidConfig: "invalidConfig";
     readonly HistogramEmptyField: "histogramEmptyField";
     readonly BarElementExceedsLimit: "barElementExceedsLimit";
@@ -83,7 +85,7 @@ export interface ElementCountExceededParams {
 /** @internal */
 export interface DataWarningObject {
   keyword: DataWarningKeywords;
-  header: string;
+  header?: string;
   message: string;
   params?: ElementCountExceededParams;
 }

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

@@ -1,6 +1,6 @@
-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 MapView from "@arcgis/core/views/MapView.js";
+import type SceneView from "@arcgis/core/views/SceneView.js";
+import type { DOMContainerAria } from "@arcgis/core/views/DOMContainer.js";
 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";

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

@@ -0,0 +1,8 @@
+/** Interface representing the name of the CSS variables to pull the theme colors from. */
+export interface CalciteThemeCSSVariables {
+  background: string;
+  text: string;
+  line: string;
+  secondaryLine: string;
+  spinner: string;
+}

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

@@ -0,0 +1,14 @@
+import type { ArcgisChart } from "../../components/arcgis-chart/customElement.js";
+import type { WebChart } from "../../spec/web-chart.js";
+
+/**
+ * Indicates whether the chart's needs to be synced with the view's time zone
+ *
+ * @param props
+ * @internal
+ */
+export function doesViewTimeZoneNeedToBeSynced(props: {
+    syncViewTimeZone: boolean;
+    syncViewTimeZoneInclusionList?: ArcgisChart["syncViewTimeZoneInclusionList"];
+    chartConfig?: WebChart;
+}): boolean;

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

@@ -1,7 +1,8 @@
+import type { WebChartQuery } from "../../../spec/web-chart.js";
 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";
+import type { ErrorStrings } from "../../localization/interfaces.js";
 
 /**
  * Fetches the unique values from a given field.
@@ -18,10 +19,12 @@ import type { WebChartQuery } from "../../../spec/web-chart.js";
  * @internal
  */
 export function uniqueValues(props: {
-    queryObject?: QueryObject;
+    queryObject: QueryObject;
     queryConfig: WebChartQuery;
     category: string;
     splitByField?: string;
     chartLimits?: ChartElementLimit;
+    errorStrings: ErrorStrings;
     abortKey?: AbortControllerKeyType;
+    abortSignal?: AbortSignal;
 }): Promise<(number | string)[]>;

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

@@ -1,7 +1,11 @@
+import type { ChartOptions } from "../../chart-rendering/common/interfaces.js";
+import type { WebChartStatisticType } from "../../spec/chart-object-literals.js";
+import type { WebChartBin, WebChartDataItem, WebChartDataTypes } from "../../spec/data-source.js";
+import type { WebChart, WebChartSeriesType, WebGaugeChart } from "../../spec/web-chart.js";
+import type { QueryObject } from "../layer/interfaces.js";
+import type { ErrorStrings } from "../localization/interfaces.js";
 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
@@ -96,6 +100,7 @@ export function validateBarNLineChartDataItem(props: {
     x: string;
     y: string;
     nullAsValid?: boolean;
+    aggregationType?: WebChartStatisticType;
 }): boolean;
 
 /**
@@ -111,6 +116,16 @@ export function isEmptyDataset(props: {
     dataSet?: WebChartDataItem[];
 }): boolean;
 
+/**
+ * Gathers the list of `y` values used by a chart, grouped by series type.
+ * If the list of visible series id is provided it will be used to filter out the series, otherwise they will all be considered.
+ *
+ * @param seriesConfig - The config for the series
+ * @param filteredSeriesIds - List of series ids to use as a filter
+ * @internal
+ */
+export function getYListPerSeriesType(seriesConfig: WebChartSeriesType[], filteredSeriesIds?: string[]): Map<string, string[]>;
+
 /**
  * Gets the data min and max values for a stacked series; also an indicator whether the data has negative values.
  *
@@ -120,7 +135,7 @@ export function isEmptyDataset(props: {
 export function getDataMinMaxFromStackedSeries(props: {
     seriesConfig: WebChartSeriesType[];
     filteredSeriesIds?: string[];
-    filteredData: WebChartDataItem[];
+    filteredData: WebChartBin[] | WebChartDataItem[];
 }): {
     stackedMinY: number;
     stackedMaxY: number;
@@ -135,10 +150,69 @@ export function getDataMinMaxFromStackedSeries(props: {
  */
 export function getDataMinMaxFromSeries(props: {
     chartConfig: WebChart;
-    chartData: WebChartDataItem[];
+    chartData: WebChartBin[] | WebChartDataItem[];
     filteredSeriesIds?: string[];
 }): DataMinMax;
 
+/**
+ * Get the series id related to the given axis (useful in dual axis mode).
+ *
+ * @param props - The chart configuration
+ */
+export function getAxisSeriesIds(props: {
+    chartConfig: WebChart;
+    isSecondValueAxis?: boolean;
+    seriesIds?: string[];
+}): string[] | undefined;
+
+/**
+ * Indicates whether the axis log scale is compatible with the data.
+ *
+ * @param props - The chart config
+ * @internal
+ */
+export function whetherLogScaleIsDataCompatible(props: {
+    chartConfig?: WebChart;
+    axisConfigIndex: number;
+    chartData?: WebChartBin[] | WebChartDataItem[];
+}): boolean;
+
+/**
+ * This function reassigns the category/field name and stat value to the series x and y, while deleting the
+ * technical field used during the rendering for technical reasons.
+ *
+ * @param modifiedData - The data to revert
+ * @param seriesConfig - The series config
+ */
+export function revertPieFromFieldsProperties<T extends WebChartDataItem[] | WebChartDataTypes>(modifiedData: T, seriesConfig?: WebChart["series"]): T;
+
+/**
+ * This function reverts some changes done to process the chart's data set:
+ * - removes the formatted dates used specifically for the queries
+ * - switches back the values of the modified dates/categories to accommodate the rendering (axis labels, sort...)
+ *
+ * @param data - The data containing modified x or y values
+ * @param seriesConfig - The series config
+ */
+export function revertOriginalXAndYValues<T extends WebChartDataItem[] | WebChartDataTypes>(data: T, seriesConfig?: WebChart["series"]): T;
+
+/**
+ * Removes some technical properties including color ones from a data item
+ *
+ * @param dataItem - The data item to sanitize
+ * @returns The sanitized data item
+ */
+export function removeAdditionalStatisticsPerItem(dataItem: WebChartDataItem): WebChartDataItem;
+
+/**
+ * Before sending the event payload containing the data, we need to revert some changes done to sort the charts.
+ *
+ * @param data - The data set to modify
+ * @param seriesConfig - The series config
+ * @returns The sanitized data
+ */
+export function removeAdditionalStatistics(data: WebChartDataTypes, seriesConfig: WebChartSeriesType[]): WebChartDataTypes;
+
 /**
  * Rounds a number to a given number of decimals
  *
@@ -146,4 +220,52 @@ export function getDataMinMaxFromSeries(props: {
  * @param dec - The number of decimals
  * @internal
  */
-export function roundToDecimals(num: number, dec: number): number;
+export function roundToDecimals(num: number, dec: number): number;
+
+/**
+ * Sanitizes data by reverting technical changes made to the data set.
+ * The point is to send meaningful data to the user through events or the `chartWillRender()` function.
+ *
+ * @param props - The data to sanitize
+ */
+export function sanitizeData(props: {
+    data?: WebChartDataTypes;
+    seriesConfig: WebChartSeriesType[];
+}): WebChartDataTypes | undefined;
+
+/**
+ * Fetches data from a list of OIDs. If the chart is non aggregated we directly read the OIDs stored in the data context,
+ * and if the chart is aggregated we perform queries to fetch the data.
+ *
+ * @param props - A snapshot of the updated props, used to determine whether the selection OIDs have changed
+ */
+export function getSelectionItemsFromOIDs(props: {
+    chartData?: WebChartDataTypes;
+    chartConfig: WebChart;
+    queryObject: QueryObject;
+    dataWasUpdated?: boolean;
+    selectionData?: ChartOptions["selectionData"];
+    replaceNoValueCategoryWithZero?: ChartOptions["replaceNoValueCategoryWithZero"];
+    hideZeroCountCategories?: ChartOptions["hideZeroCountCategories"];
+    chartLimits?: ChartOptions["chartLimits"];
+    setTimeBinningInfoWhenNotProvided?: ChartOptions["setTimeBinningInfoWhenNotProvided"];
+    returnFeaturesExtent?: ChartOptions["returnFeaturesExtent"];
+    popupTemplateFieldInfosEnabled?: ChartOptions["popupTemplateFieldInfosEnabled"];
+    view?: ChartOptions["view"];
+    viewExtentUpdated?: ChartOptions["viewExtentUpdated"];
+    returnSelectionOIDs?: ChartOptions["returnSelectionOIDs"];
+    runtimeDataFilters?: ChartOptions["runtimeDataFilters"];
+    ignoreViewExtent?: ChartOptions["ignoreViewExtent"];
+    errorStrings: ErrorStrings;
+    selectionIDsChanged: boolean;
+}): Promise<WebChartDataItem[] | undefined>;
+
+export const dataPrivateFunctions: {
+    shouldCheckDataMinMaxForLogScaleOnXAxis: (chartConfig?: WebChart | undefined) => boolean;
+    minMaxHasZeroOrNegativeValues: (min?: number | undefined, max?: number | undefined) => boolean;
+    isChartWithZeroOrNegativeValues: (props: {
+        chartConfig: WebChart;
+        chartData: Array<WebChartDataItem> | Array<WebChartBin>;
+        axisConfigIndex: number;
+    }) => boolean;
+};

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

@@ -1,3 +1,4 @@
+import type { GaugeMinMaxFromData } from "../../chart-rendering/common/interfaces.js";
 import type { WebChartDataTypes } from "../../spec/data-source.js";
 import type { WebChartQuery } from "../../spec/web-chart.js";
 import type { DataWarningKeywords } from "../chart-config/validator/interfaces.js";
@@ -18,6 +19,7 @@ export interface DataInfo {
   count?: number;
   data?: WebChartDataTypes;
   queryConfig?: WebChartQuery;
+  gaugeMinMaxFromData?: GaugeMinMaxFromData;
 }
 
 /** @internal */
@@ -59,7 +61,6 @@ export interface DataUpdateDetails {
       dataForFilterBySelectionChanged?: boolean;
       binTemporalDataChanged?: boolean;
       timeBinningChanged?: boolean;
-      timeIntervalUnitChanged?: boolean;
       newTimeBinningWillBeCalculated?: boolean;
       valueFormatChangeRequiresNewData?: boolean;
   };

package/dist/utils/data/pie-chart/index.d.ts

@@ -0,0 +1,31 @@
+import type { WebChartDataItem } from "../../../spec/data-source.js";
+import type { WebChart, WebChartPieChartSeries } from "../../../spec/web-chart.js";
+import type { UtilsStrings } from "../../localization/interfaces.js";
+import type { DataInfo } from "../interfaces.js";
+
+/**
+ * Builds the data necessary for the pie chart group of slices.
+ *
+ * @param props - the dataset
+ * @internal
+ */
+export function getPieChartGroupOfSlicesData(props: {
+    data: WebChartDataItem[];
+    seriesConfig: WebChartPieChartSeries[];
+    utilsStrings: UtilsStrings;
+}): WebChartDataItem[];
+
+/**
+ * Updates the provided dataset with data related to the pie chart group of slices.
+ *
+ * @param props - indicates whether the chart is being created (true) or updated (false)
+ * @internal
+ */
+export function updatePieChartGroupOfSlicesData(props: {
+    creation: boolean;
+    previousConfig: WebChart | undefined;
+    newConfig: WebChart | undefined;
+    dataInfo: DataInfo;
+    dataUpdateNeeded: boolean;
+    utilsStrings: UtilsStrings;
+}): boolean;

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

@@ -7,7 +7,6 @@ import type { ChartElementLimit, ChartElementTechnicalLimit, ChartTextProps, Que
 /** @internal */
 export const histogramBinCount: 32;
 
-/** @internal */
 export const featuresExtentField: "arcgis_charts_features_extent";
 
 /** @internal */
@@ -75,6 +74,31 @@ export const darkModeRamp: Color[];
 /** @internal */
 export const darkModeOverlayRamp: Color[];
 
+/** @internal */
+export const loaderBackgroundLight: Color;
+
+/**
+ * Same as --calcite-color-foreground-1 in dark mode
+ *
+ * @internal
+ */
+export const loaderBackgroundDark: Color;
+
+/**
+ * @deprecated since 5.1. Will be replaced by the Calcite CSS variable --calcite-color-brand-hover.
+ * @internal
+ */
+export const loaderSpinnerColor: Color;
+
+/** @internal */
+export const lightTextColor: Color;
+
+/** @internal */
+export const darkTextColor: Color;
+
+/** @internal */
+export const grayColor: Color;
+
 /**
  * Returns a specific color from the default ramp, given an index. If the index is > than the ramp length,
  * we use modulo to get the corresponding color.
@@ -187,7 +211,7 @@ export function getDefaultTitle(commonStrings: CommonStrings): string;
  * @param useRandomColor
  * @internal
  */
-export function getDefaultBoxPlotElementSymbol(seriesIndex: number | undefined, useRandomColor?: boolean): ISimpleFillSymbol;
+export function getDefaultBoxPlotElementSymbol(seriesIndex?: number, useRandomColor?: boolean): ISimpleFillSymbol;
 
 /**
  * Returns a default marker symbol for a line chart
@@ -246,6 +270,20 @@ export function getDefaultAxes(commonStrings: CommonStrings, chartType: WebChart
  */
 export function getDefaultGaugeNeedle(): WebChartNeedle;
 
+/**
+ * Returns the default progress base band symbol for gauge charts
+ *
+ * @internal
+ */
+export function getDefaultProgressBaseBandSymbol(): ISimpleFillSymbol;
+
+/**
+ * Returns the default progress target band symbol for gauge charts
+ *
+ * @internal
+ */
+export function getDefaultProgressTargetBandSymbol(): ISimpleFillSymbol;
+
 /**
  * Returns the gauge axes
  *
@@ -411,7 +449,7 @@ export function getDefaultHistogramOverlays(): Required<HistogramOverlays>;
 export function getDefaultHistogramSymbol(): ISimpleFillSymbol;
 
 /** @internal */
-export function getDefaultHistogramSeries(): Omit<Required<WebChartHistogramSeries>, "dataTooltipDateFormat" | "dataTooltipPercentFormat" | "dataTooltipValueFormat" | "query">;
+export function getDefaultHistogramSeries(): Omit<Required<WebChartHistogramSeries>, "dataTooltipDateFormat" | "dataTooltipFontSize" | "dataTooltipPercentFormat" | "dataTooltipValueFormat" | "query">;
 
 /**
  * @param commonStrings
@@ -482,4 +520,7 @@ export const boxPlotZScoreSuffix: "_arcgis_charts_z_score";
 export const defaultColorForBoxPlotWithMeanLines: Color;
 
 /** @internal */
-export const percentageSuffix: " percentage ";
+export const percentageSuffix: " percentage ";
+
+/** @internal */
+export const heatChartFirstDayOfWeek: 7;

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

@@ -52,6 +52,9 @@ export interface QueryDefaults {
   outStatistics: Readonly<IStatisticDefinition>;
   uniqueIdsName: number | string;
   orderByJSAPIDelimiter: string;
+  heatChartLowerBoundaryAlias: string;
+  heatChartUpperBoundaryAlias: string;
+  defaultStatParameterValue: number;
 }
 
 /** @internal */

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

@@ -1,6 +1,6 @@
 /**
  * Class that enhances the debugging and error handling process. Rather than returning a generic [JavaScript
- * error](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error), this class returns a standardized error object with several properties.
+ * error](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error), this class returns a standardized error object with several properties.
  */
 export class ArcgisChartsError<T = any> extends Error {
   /** Creates a new `ArcgisChartsError` instance. */

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

@@ -4,6 +4,7 @@ export const ErrorKeywords: {
     readonly QueryFeaturesError: "queryFeaturesError";
     readonly ChartDisposed: "ChartDisposeError";
     readonly LayerFieldsNotFound: "layerFieldsNotFound";
+    readonly LayerNotSupported: "layerNotSupported";
 };
 
 export type ErrorKeywords = (typeof ErrorKeywords)[keyof typeof ErrorKeywords];