@arcgis/charts-components 4.34.0-next.112 → 4.34.0-next.113

package/dist/model/shared/axes.d.ts

@@ -1,5 +1,5 @@
 import { ChartConfig } from '../../utils';
-import { CategoryFormatOptions, DateTimeFormatOptions, NumberFormatOptions, WebChart, WebChartAxis, WebChartStatisticType } from '../../spec';
+import { CategoryFormatOptions, DateTimeFormatOptions, NumberFormatOptions, WebChart, WebChartAxis, WebChartAxisScrollBar, WebChartStatisticType } from '../../spec';
 import { LayerInfo } from '../interfaces/common';
 /**
  * Updates the axis config with the provided title text. Provides a default title object if one does not exist.
@@ -23,66 +23,41 @@ export declare function getYAxisTitleLabel(props: {
  */
 export declare const getAxes: (config: WebChart) => WebChartAxis[] | undefined;
 export declare const getAxis: (config: WebChart, axisIndex: number) => Promise<WebChartAxis>;
-export declare const setAxis: (config: WebChart, axis: WebChartAxis, axisIndex: number) => void;
+export declare const setAxis: (props: {
+    config: WebChart;
+    axis: WebChartAxis;
+    axisIndex: number;
+}) => void;
 /**
  * Get the maximum or minimum bound of the axis
- * @param config - the config object
- * @param axisIndex - the index of the axis
- * @param isMax - whether it is the max bound or not
+ * @param {WebChart} props.config - the config object
+ * @param {number} props.axisIndex - the index of the axis
+ * @param {boolean} props.isMax - whether it is the max bound or not
  */
-export declare const getAxisBound: (config: WebChart, axisIndex: number, isMax: boolean) => number;
+export declare const getAxisBound: (props: {
+    config: WebChart;
+    axisIndex: number;
+    isMax: boolean;
+}) => number;
 /**
  * Set the axis bound
- * @param config - the config object
- * @param value - the value to set
- * @param axisIndex - the index of the axis
- * @param isMax - whether it is the max bound
- */
-export declare const setAxisBound: (config: WebChart, value: number | null, axisIndex: number, isMax: boolean) => Promise<void>;
-/**
- * Get the maximum bound for the y-axis
- * @param config - the config object
- */
-export declare const getMaxYBound: (config: ChartConfig) => number;
-/**
- * Set the maximum Y bound
- * @param config - the config object
- * @param newMaxYBound - the value to set
- */
-export declare const setMaxYBound: (config: ChartConfig, newMaxYBound: number | null) => Promise<void>;
-/**
- * Get the minimum bound for the y-axis
- * @param config - the config object
- */
-export declare const getMinYBound: (config: ChartConfig) => number;
-/**
- * Set the minimum Y bound
- * @param config - the config object
- * @param newMinYBound - the value to set
- */
-export declare const setMinYBound: (config: ChartConfig, newMinYBound: number | null) => Promise<void>;
-/**
- * Get the maximum bound for the x-axis
- * @param config - the config object
- */
-export declare const getMaxXBound: (config: ChartConfig) => number;
-/**
- * Set the maximum X bound
- * @param config - the config object
- * @param newMaxXBound - the value to set
- */
-export declare const setMaxXBound: (config: ChartConfig, newMaxXBound: number | null) => Promise<void>;
-/**
- * Get the minimum bound for the x-axis
- * @param config - the config object
- */
-export declare const getMinXBound: (config: ChartConfig) => number;
+ * @param {WebChart} props.config - the config object
+ * @param {number | null} props.value - the value to set
+ * @param {number} props.axisIndex - the index of the axis
+ * @param {boolean} props.isMax - whether it is the max bound
+ */
+export declare const setAxisBound: (props: {
+    config: WebChart;
+    value: number | null;
+    axisIndex: number;
+    isMax: boolean;
+}) => void;
 /**
  * Set the minimum X bound
  * @param config - the config object
  * @param newMinXBound - the value to set
  */
-export declare const setMinXBound: (config: ChartConfig, newMinXBound: number | null) => Promise<void>;
+export declare const setMinXBound: (config: ChartConfig, newMinXBound: number | null) => void;
 /**
  * Get the valueFormat of the x-axis
  * @param config
@@ -103,3 +78,97 @@ export declare const setYAxisValueFormat: (config: ChartConfig, valueFormat?: Nu
  * @param integerOnlyValues - the value to set
  */
 export declare const setIntegerOnlyValuesInAxis: (config: WebChart, axisIndex: number, integerOnlyValues: boolean) => void;
+/**
+ * Check if the chart supports dual axes
+ * @param config - the chart configuration
+ * @returns boolean - true if the config has dual axes, false otherwise
+ */
+export declare const isDualAxisSupported: (config: WebChart) => boolean;
+/**
+ * Validates the axis index based on the chart configuration and whether it supports dual axes.
+ *
+ * @param {number} props.axisIndex - axisIndex The index of the axis (0 for X-axis, 1 for Y-axis, 2 for second Y-axis).
+ * @param {WebChart} props.config - config The chart config.
+ * @param {boolean} [props.isMultiAxis] - isMultiAxis Optional flag indicating if the chart supports multiple axes (has a x-axis and y-axis).
+ * @returns {boolean} - Returns true if the axis index is valid, false otherwise.
+ */
+export declare const validateAxisIndex: (props: {
+    axisIndex: number;
+    config: WebChart;
+    isMultiAxis?: boolean;
+}) => boolean;
+/**
+ * Run a util function on valid axis, ensuring that only valid changes are applied on the valid axes.
+ * If the index is invalid, it returns undefined.
+ *
+ * @param {number} props.axisIndex - The index of the axis to validate (0 for X-axis, 1 for Y-axis, 2 for second Y-axis).
+ * @param {function} props.func - The function to run with the valid axis index.
+ * @param {WebChart} props.config - The chart configuration object.
+ */
+export declare const runWithDualAxisGuard: <T>(props: {
+    axisIndex: number;
+    func: (validIndex: number) => T;
+    config: WebChart;
+}) => T | undefined;
+/**
+ * Get the value format of the axis based on the axis index
+ * @param {number} axisIndex The index of the axis (0 for X-axis, 1 for Y-axis, 2 for second Y-axis).
+ * @returns {CategoryFormatOptions | DateTimeFormatOptions | NumberFormatOptions | undefined} The value format options for the specified axis index
+ */
+export declare const getAxisValueFormat: (axisIndex: number, config: WebChart) => CategoryFormatOptions | DateTimeFormatOptions | NumberFormatOptions | undefined;
+/**
+ * Sets the value format for the specified axis.
+ * @param {WebChart} props.config - The chart configuration object
+ * @param {CategoryFormatOptions | DateTimeFormatOptions | NumberFormatOptions} [props.valueFormat] - The value format to set
+ * @param {number} [props.axisIndex=0] - The index of the axis (0 for X-axis, 1 for Y-axis, 2 for second Y-axis)
+ */
+export declare const setAxisValueFormat: (props: {
+    config: WebChart;
+    valueFormat?: CategoryFormatOptions | DateTimeFormatOptions | NumberFormatOptions;
+    axisIndex?: number;
+}) => Promise<void>;
+/**
+ * Gets whether logarithmic scale is enabled for the specified axis.
+ * @param {WebChart} config The chart configuration object.
+ * @param {number} axisIndex The index of the axis (0 for X-axis, 1 for Y-axis, 2 for second Y-axis).
+ *
+ * `true`: Logarithmic scale is enabled for the specified axis.
+ *
+ * `false`: Logarithmic scale is disabled for the specified axis.
+ *
+ * @returns {boolean}
+ */
+export declare const getAxisLogarithmic: (config: WebChart, axisIndex: number) => boolean;
+/**
+ * Sets whether logarithmic scale is enabled for the specified axis.
+ *
+ * `true`: Enable logarithmic scale for the specified axis.
+ *
+ * `false`: Disable logarithmic scale for the specified axis.
+ *
+ * @param {WebChart} props.config The chart configuration object.
+ * @param {boolean} props.isLogarithmic Whether to enable logarithmic scale for the specified axis.
+ * @param {number} props.axisIndex The index of the axis (0 for X-axis, 1 for Y-axis, 2 for second Y-axis).
+ */
+export declare const setAxisLogarithmic: (props: {
+    config: WebChart;
+    isLogarithmic: boolean;
+    axisIndex: number;
+}) => void;
+/**
+ * Gets the scrollbar configuration for the specified axis.
+ * @param {WebChart} config The chart configuration object.
+ * @param {number} axisIndex The index of the axis (0 for X-axis, 1 for Y-axis, 2 for second Y-axis).
+ * @returns {WebChartAxisScrollBar | undefined} The scrollbar configuration for the specified axis.
+ */
+export declare const getAxisScrollbar: (config: WebChart, axisIndex: number) => WebChartAxisScrollBar | undefined;
+/**
+ * Sets the scrollbar configuration for the specified axis.
+ * @param {WebChartAxisScrollBar} scrollbar The scrollbar configuration to set.
+ * @param {number} axisIndex The index of the axis (0 for X-axis, 1 for Y-axis, 2 for second Y-axis).
+ */
+export declare const setAxisScrollbar: (props: {
+    config: WebChart;
+    scrollbar: WebChartAxisScrollBar;
+    axisIndex: number;
+}) => void;

package/dist/model/shared/type-guards.d.ts

@@ -1,6 +1,6 @@
 import { WebChart } from '../../spec';
 import { BarChartModel, BoxPlotModel, ChartModel, HistogramModel, LineChartModel, ModelOfType, ModelTypes, PieChartModel, ScatterplotModel, SerialChartModel } from '..';
-import { ModelWithBasicXAxis, ModelWithDataLabels, ModelWithGuides, ModelWithLegend, ModelWithRotation, ModelWithTemporalBinning, ModelWithXGuides, ModelWithXYAxes, ModelWithYGuides } from '../mixins/index';
+import { ModelWithBasicXAxis, ModelWithDataLabels, ModelWithGuides, ModelWithLegend, ModelWithRotation, ModelWithTemporalBinning, ModelWithXGuides, ModelWithYGuides, ModelWithMultiAxes } from '../mixins/index';
 /**
  * Determines if the provided model or config is a `ChartModel`.
  * @param model The model to check.
@@ -49,10 +49,10 @@ export declare function isHistogramModel(model: ChartModel | undefined): model i
  */
 export declare function isModelWithBasicXAxis(model: ChartModel | undefined): model is ModelWithBasicXAxis;
 /**
- * Type guard for ModelWithXYAxes
+ * Type guard for ModelWithMultiAxes
  * @param model
  */
-export declare function isModelWithXYAxes(model: ChartModel | undefined): model is ModelWithXYAxes;
+export declare function isModelWithMultiAxes(model: ChartModel | undefined): model is ModelWithMultiAxes;
 /**
  * Type guard for ModelWithRotation
  * @param model

package/dist/model.js

@@ -1,10 +1,10 @@
 import { M as i } from "./chunks/common.js";
-import { B as m, C as y, F as g, G as C, L as w, P as f, a as b, b as u, S as L, T } from "./chunks/common.js";
+import { B as m, C as y, F as g, G as C, L as w, P as f, a as u, b, S as L, T } from "./chunks/common.js";
 import { o as r, p as s, q as n } from "./chunks/type-guards.js";
-import { n as B, s as P, m as k, d as x, f as S, u as W, c as v, j as G, k as K, e as D, g as F, t as H, i as O, b as R, a as X, h as Y, l as A, r as E } from "./chunks/type-guards.js";
+import { n as B, s as P, m as k, d as x, f as S, u as W, c as v, j as G, k as K, e as D, b as F, g as H, t as O, i as R, a as A, h as E, l as X, r as Y } from "./chunks/type-guards.js";
 /*! All material copyright Esri, All Rights Reserved, unless otherwise specified.
 See https://js.arcgis.com/4.34/esri/copyright.txt for details.
-v4.34.0-next.112 */
+v4.34.0-next.113 */
 async function c(a) {
   const o = "config" in a ? r(a.config) : a.chartType;
   let t;
@@ -81,8 +81,8 @@ export {
   w as LineFormatKeys,
   i as ModelTypes,
   f as PieChartDataModes,
-  b as PieChartDataSortingKinds,
-  u as PieChartSlicesDisplay,
+  u as PieChartDataSortingKinds,
+  b as PieChartSlicesDisplay,
   L as SerialChartDataSortingKinds,
   T as TextFormatKeys,
   c as createModel,
@@ -96,12 +96,12 @@ export {
   G as isModelWithDataLabels,
   K as isModelWithGuides,
   D as isModelWithLegend,
-  F as isModelWithRotation,
-  H as isModelWithTemporalBinning,
-  O as isModelWithXGuides,
-  R as isModelWithXYAxes,
-  X as isModelWithYGuides,
-  Y as isPieChartModel,
-  A as isScatterplotModel,
-  E as isSerialChartModel
+  F as isModelWithMultiAxes,
+  H as isModelWithRotation,
+  O as isModelWithTemporalBinning,
+  R as isModelWithXGuides,
+  A as isModelWithYGuides,
+  E as isPieChartModel,
+  X as isScatterplotModel,
+  Y as isSerialChartModel
 };

package/dist/spec/chart-object-literals.d.ts

@@ -91,14 +91,6 @@ export declare const WebChartLineSmoothedKinds: {
     readonly MonotoneY: "monotoneY";
 };
 export type WebChartLineSmoothedKinds = (typeof WebChartLineSmoothedKinds)[keyof typeof WebChartLineSmoothedKinds];
-/**
- * Represents the different types of temporal binning that can be applied to a chart.
- */
-export declare const WebChartTemporalBinningTypes: {
-    readonly FixedDateBased: "fixedDateBased";
-    readonly CalendarBased: "calendarBased";
-};
-export type WebChartTemporalBinningTypes = (typeof WebChartTemporalBinningTypes)[keyof typeof WebChartTemporalBinningTypes];
 /**
  * The temporal binning units
  */
@@ -124,33 +116,6 @@ export declare const WebChartCalendarDatePartsUnits: {
     readonly MonthOfYear: "monthOfYear";
 };
 export type WebChartCalendarDatePartsUnits = (typeof WebChartCalendarDatePartsUnits)[keyof typeof WebChartCalendarDatePartsUnits];
-/**
- * The temporal binning units for fixed-date based binning
- */
-export declare const WebChartFixedDateBinningUnits: {
-    readonly Second: "seconds";
-    readonly Minute: "minutes";
-    readonly Hour: "hours";
-    readonly Day: "days";
-    readonly Week: "weeks";
-    readonly Month: "months";
-    readonly Year: "years";
-};
-export type WebChartFixedDateBinningUnits = (typeof WebChartFixedDateBinningUnits)[keyof typeof WebChartFixedDateBinningUnits];
-/**
- * The temporal binning units for calendar based binning
- */
-export declare const WebChartCalendarBinningUnits: {
-    readonly Second: "seconds";
-    readonly Minute: "minutes";
-    readonly Hour: "hours";
-    readonly Day: "days";
-    readonly Week: "weeks";
-    readonly Month: "months";
-    readonly Quarter: "quarters";
-    readonly Year: "years";
-};
-export type WebChartCalendarBinningUnits = (typeof WebChartCalendarBinningUnits)[keyof typeof WebChartCalendarBinningUnits];
 /**
  * The temporal binning units for the calendar based binning offset
  */

package/dist/spec/web-chart.d.ts

@@ -1,12 +1,12 @@
 /// <reference types="@arcgis/core/interfaces.d.ts" />
-import { GaugeChartSubTypes, SizePolicyScaleTypes, WebChartCalendarBinningOffsetUnits, WebChartCalendarBinningUnits, WebChartCalendarDatePartsUnits, WebChartDataTransformations, WebChartDirectionalDataOrder, WebChartFixedDateBinningUnits, WebChartLabelBehavior, WebChartLegendPositions, WebChartNullPolicyTypes, WebChartOrderSeriesBy, WebChartPredefinedLabelsDataOrder, WebChartRadarChartAxisLabelsOrientation, WebChartStackedKinds, WebChartTemporalBinningTypes, WebChartTimeAggregationTypes, WebChartTypes } from './chart-object-literals';
+import { GaugeChartSubTypes, SizePolicyScaleTypes, WebChartCalendarDatePartsUnits, WebChartDataTransformations, WebChartDirectionalDataOrder, WebChartLabelBehavior, WebChartLegendPositions, WebChartNullPolicyTypes, WebChartOrderSeriesBy, WebChartPredefinedLabelsDataOrder, WebChartRadarChartAxisLabelsOrientation, WebChartStackedKinds, WebChartTemporalBinningUnits, WebChartTimeAggregationTypes, WebChartTypes } from './chart-object-literals';
 import { TimeIntervalInfo } from './data-source';
 import { RESTUnits } from './rest-js-object-literals';
 import { Color, IDrawingInfo, IEnvelope, IExtent, IFeatureLayer, IPoint, IPolygon, IPolygonWithCurves, IPolyline, ISimpleFillSymbol, ISimpleLineSymbol, ISimpleMarkerSymbol, IStatisticDefinition, ITextSymbol } from './rest-js-types';
 /**
  * Version of the current specification.
  */
-export declare const WebChartCurrentVersion = "23.3.0";
+export declare const WebChartCurrentVersion = "24.0.0";
 /**
  * Stores information regarding a numeric conversion
  */
@@ -687,11 +687,10 @@ export interface WebChartSeries {
      */
     assignToSecondValueAxis?: boolean;
 }
-interface WebChartDateBinning {
-    /**
-     * The span of time that will be binned or aggregated together. Works in coordination with `unit`.
-     */
-    size?: number;
+/**
+ * Describes the basic properties available for a temporal binning
+ */
+interface WebChartTemporalBinningBase {
     /**
      * Determines whether incomplete time intervals at the start or end of the data span (depending on the `timeAggregationType`) will be removed from the chart.
      * Incomplete intervals on a chart can cause misleading results in which the period in question is under- or over reported due to a different amount of time in the interval.
@@ -700,70 +699,71 @@ interface WebChartDateBinning {
      */
     trimIncompleteTimeInterval?: boolean;
     /**
-     * The time interval alignment type. Valid options include `equalIntervalsFromStartTime` and `equalIntervalsFromEndTime`.
-     * @default "equalIntervalsFromStartTime"
-     */
-    timeAggregationType?: WebChartTimeAggregationTypes;
-    /**
-     * How summarized bins returning a null value are displayed. Supported options are:
-     * - `null`, `zero`, and `interpolate` for line series
-     * - `null` and `zero` for bar series
-     * @default "null"
-     */
-    nullPolicy?: WebChartNullPolicyTypes;
-}
-/**
- * Represents the properties related to the the fixed-date temporal binning. It currently covers the same scope as `WebChartDateBinning`.
- */
-export interface WebChartFixedDateBinning extends WebChartDateBinning {
-    type: typeof WebChartTemporalBinningTypes.FixedDateBased;
-    /**
-     * The unit of time to use to bin the temporal data.
-     */
-    unit?: WebChartFixedDateBinningUnits;
-}
-/**
- * Represents the properties related to the calendar-based temporal binning. It supports the same properties as `WebChartDateBinning` and adds some.
- */
-export interface WebChartCalendarBasedBinning extends WebChartDateBinning {
-    type: typeof WebChartTemporalBinningTypes.CalendarBased;
-    /**
-     * The unit of time to use to bin the temporal data.
-     */
-    unit?: WebChartCalendarBinningUnits;
-    /**
-     * The binning start date
+     * The binning start date.
+     * Current limitation: this is applied only when the provided layer supports the `queryBins` operation.
      */
     start?: number;
     /**
      * The binning end date
+     * Current limitation: this is applied only when the provided layer supports the `queryBins` operation.
      */
     end?: number;
     /**
      * Offset to apply to the results
+     * Current limitation: this is applied only when the provided layer supports the `queryBins` operation.
      */
     offset?: {
-        unit: WebChartCalendarBinningOffsetUnits;
+        unit: WebChartTemporalBinningUnits;
         size: number;
     };
+}
+/**
+ * Describes the extra properties available for a temporal series and for the heat chart
+ */
+interface WebChartTemporalBinningExtras {
     /**
      * Defines the [IANA time zone](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones) used for temporal bin calculations
+     * Current limitation: this is applied only when the provided layer supports the `queryBins` operation.
      */
     outTimeZone?: string;
+    /**
+     * The first day of the week. This property is used to determine the start of the week for date-based bins. The default value is 7, representing Sunday, if no value is specified.
+     * Current limitation: this is applied only when the provided layer supports the `queryBins` operation.
+     */
+    firstDayOfWeek?: number;
+    /**
+     * How summarized bins returning a null value are displayed. Supported options are:
+     * - `null`, `zero`, and `interpolate` for line series
+     * - `null` and `zero` for bar series
+     * @default "null"
+     */
+    nullPolicy?: WebChartNullPolicyTypes;
+}
+export interface WebChartCalendarDatePartsBinning extends WebChartTemporalBinningBase {
+    /**
+     * Represents the unit to use to bin the data.
+     */
+    unit: WebChartCalendarDatePartsUnits;
 }
 /**
- * Represents the properties related to the calendar-based date parts binning.
+ * Describes the properties available for a temporal binning for a bar or line
  */
-export interface WebChartCalendarDatePartsBinning {
-    type: typeof WebChartTypes.CalendarDateParts;
+export interface WebChartTemporalBinning extends WebChartTemporalBinningBase, WebChartTemporalBinningExtras {
     /**
-     * The unit to use to bin the data.
+     * The unit of time to use to bin the temporal data.
+     * Current limitation: the "quarters" unit is only supported if the provided layer supports the `queryBins` operation.
      */
-    unit: WebChartCalendarDatePartsUnits;
+    unit?: WebChartTemporalBinningUnits;
     /**
-     * Defines the [IANA time zone](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones) used for temporal bin calculations
+     * The span of time that will be binned or aggregated together. Works in coordination with `unit`.
      */
-    outTimeZone?: string;
+    size?: number;
+    /**
+     * The time interval alignment type. Valid options include `equalIntervalsFromStartTime` and `equalIntervalsFromEndTime`.
+     * When specific the binning will start at the first or last date of the dataset.
+     * @default "equalIntervalsFromStartTime"
+     */
+    timeAggregationType?: WebChartTimeAggregationTypes;
 }
 /**
  * Describes the properties related to a temporal series
@@ -776,12 +776,9 @@ export interface WebChartTemporalSeries {
      */
     binTemporalData?: boolean;
     /**
-     * Defines the pattern to apply to bin the data.
-     * The "calendarBased" type will make the bins start at the beginning of the given period (1st of the week, 1st of the month, 1st or the day, etc.)
-     * The "fixedDateBased" type will make the bins start at the dataset first entry (e.g. if the first date is 1/18/20 and the binning is done by month, the bins
-     * will go from the 18th of January to the 17th of February).
+     * Describes how to bin the temporal data.
      */
-    temporalBinning?: WebChartCalendarBasedBinning | WebChartFixedDateBinning;
+    temporalBinning?: WebChartTemporalBinning;
 }
 /**
  * Bar Chart Interfaces
@@ -1272,24 +1269,13 @@ export interface WebChartHeatChartSeries extends WebChartSeries {
      */
     y: string;
     /**
-     * Defines the pattern to apply to bin the data for the x-axis, when the x-axis field is a date field.
-  
-     * The "calendarDateParts" type will create bins extracting date parts from date values (e.g. a bin for each day of the week, a bin for each month or the year, etc.)
-     * The "calendarBased" type will make the bins start at the beginning of the given period (1st of the week, 1st of the month, 1st or the day, etc.)
-     * For example, if the first date is 1/18/20 and the binning is done by month, the bins will go from the 18th of January to the 17th of February.
+     * Describes how to bin the temporal data when the x-axis field is a date.
      */
-    xTemporalBinning?: WebChartCalendarBasedBinning | WebChartCalendarDatePartsBinning;
+    xTemporalBinning?: WebChartCalendarDatePartsBinning;
     /**
-     * Defines the pattern to apply to bin the data for the y-axis, when the y-axis field is a date field.
-     * The "calendarDateParts" type will create bins extracting date parts from date values (e.g. a bin for each day of the week, a bin for each month or the year, etc.)
-     * The "calendarBased" type will make the bins start at the beginning of the given period (1st of the week, 1st of the month, 1st or the day, etc.)
-     * For example, if the first date is 1/18/20 and the binning is done by month, the bins will go from the 18th of January to the 17th of February.
+     * Describes how to bin the temporal data when the y-axis field is a date.
      */
-    yTemporalBinning?: WebChartCalendarBasedBinning | WebChartCalendarDatePartsBinning;
-    /**
-     * The first day of the week. This property is used to determine the start of the week for date-based bins. The default value is 7, representing Sunday, if no value is specified.
-     */
-    firstDayOfWeek?: number;
+    yTemporalBinning?: WebChartCalendarDatePartsBinning;
 }
 export type WebChartRadarChartSeries = WebChartLineChartSeries<"radarSeries">;
 /**
@@ -1500,7 +1486,7 @@ export interface WebRadarChart extends WebChart {
 /**
  * Gives a JSON representation of the Heat Chart object.
  */
-export interface WebHeatChart extends WebChart {
+export interface WebHeatChart extends WebChart, WebChartTemporalBinningExtras {
     /**
      * The heat chart series
      * @minItems 1

package/dist/spec.js

@@ -1,9 +1,9 @@
-import { G as o, S as d, r as S, u as b, p as h, v as m, q as T, s as C, f as W, b as c, i as p, g as y, m as _, o as f, l as g, d as u, t as R, c as F, n as E, a as B, h as D, k as P, j as v, W as x, e as L } from "./chunks/chart-object-literals.js";
-import { a as U, i as A, h as N, g as O, f as V, k, b as K, c as j, d as z, R as G, j as q, e as H } from "./chunks/rest-js-object-literals.js";
+import { G as o, S, o as d, r as b, n as h, s as m, p as T, f as C, b as c, g as y, k as p, m as W, j as _, d as f, q as g, c as u, l as R, a as F, h as E, i as D, W as P, e as B } from "./chunks/chart-object-literals.js";
+import { a as v, i as x, h as M, g as A, f as N, k as O, b as V, c as k, d as K, R as U, j, e as z } from "./chunks/rest-js-object-literals.js";
 /*! All material copyright Esri, All Rights Reserved, unless otherwise specified.
 See https://js.arcgis.com/4.34/esri/copyright.txt for details.
-v4.34.0-next.112 */
-const a = "23.3.0", e = "arcgis_charts_pie_from_fields_name", s = "arcgis_charts_pie_from_fields_value", t = "arcgis_charts_bar_line_from_fields_name", r = "arcgis_charts_bar_line_from_fields_value", i = {
+v4.34.0-next.113 */
+const a = "24.0.0", e = "arcgis_charts_pie_from_fields_name", s = "arcgis_charts_pie_from_fields_value", t = "arcgis_charts_bar_line_from_fields_name", r = "arcgis_charts_bar_line_from_fields_value", i = {
   Mean: "Mean",
   Median: "Median",
   StdDev: "Standard Deviation",
@@ -13,43 +13,40 @@ const a = "23.3.0", e = "arcgis_charts_pie_from_fields_name", s = "arcgis_charts
 export {
   o as GaugeChartSubTypes,
   i as OverlayTerms,
-  U as RESTFieldType,
-  A as RESTFontDecoration,
-  N as RESTFontStyle,
-  O as RESTFontWeight,
-  V as RESTHorizontalAlignment,
-  k as RESTRendererType,
-  K as RESTSimpleFillSymbolStyle,
-  j as RESTSimpleLineSymbolStyle,
-  z as RESTSimpleMarkerSymbolStyle,
-  G as RESTSymbolType,
-  q as RESTUnits,
-  H as RESTVerticalAlignment,
-  d as SizePolicyScaleTypes,
-  S as StatisticsDefaults,
+  v as RESTFieldType,
+  x as RESTFontDecoration,
+  M as RESTFontStyle,
+  A as RESTFontWeight,
+  N as RESTHorizontalAlignment,
+  O as RESTRendererType,
+  V as RESTSimpleFillSymbolStyle,
+  k as RESTSimpleLineSymbolStyle,
+  K as RESTSimpleMarkerSymbolStyle,
+  U as RESTSymbolType,
+  j as RESTUnits,
+  z as RESTVerticalAlignment,
+  S as SizePolicyScaleTypes,
+  d as StatisticsDefaults,
   b as WebChartAxisTypes,
   h as WebChartBoxPlotMultipleSeriesKinds,
   m as WebChartCalendarBinningOffsetUnits,
-  T as WebChartCalendarBinningUnits,
-  C as WebChartCalendarDatePartsUnits,
-  W as WebChartColoringPatterns,
+  T as WebChartCalendarDatePartsUnits,
+  C as WebChartColoringPatterns,
   a as WebChartCurrentVersion,
   c as WebChartDataTransformations,
-  p as WebChartFixedDateBinningUnits,
   y as WebChartLabelBehavior,
-  _ as WebChartLegendPositions,
-  f as WebChartLineSmoothedKinds,
-  g as WebChartNullPolicyTypes,
-  u as WebChartOrderDataByTypes,
-  R as WebChartRadarChartAxisLabelsOrientation,
-  F as WebChartSortOrderKinds,
-  E as WebChartStackedKinds,
-  B as WebChartStatisticType,
-  D as WebChartTemporalBinningTypes,
-  P as WebChartTemporalBinningUnits,
-  v as WebChartTimeAggregationTypes,
-  x as WebChartTypes,
-  L as WebChartVersionStatus,
+  p as WebChartLegendPositions,
+  W as WebChartLineSmoothedKinds,
+  _ as WebChartNullPolicyTypes,
+  f as WebChartOrderDataByTypes,
+  g as WebChartRadarChartAxisLabelsOrientation,
+  u as WebChartSortOrderKinds,
+  R as WebChartStackedKinds,
+  F as WebChartStatisticType,
+  E as WebChartTemporalBinningUnits,
+  D as WebChartTimeAggregationTypes,
+  P as WebChartTypes,
+  B as WebChartVersionStatus,
   t as defaultBarLineFromFieldsName,
   r as defaultBarLineFromFieldsValue,
   e as defaultPieFromFieldsName,

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

@@ -1,5 +1,5 @@
-import { SupportedLayer, WebBoxPlot, WebChart, WebChartBoxPlotSeries, WebChartDirectionalDataOrder, WebChartLineChartSeries, WebGaugeChart, WebChartOrderDataByTypes } from '../../../spec';
 import { FeatureLayerView } from '@arcgis/core/views/layers/FeatureLayerView';
+import { SupportedLayer, WebBoxPlot, WebChart, WebChartBoxPlotSeries, WebChartDirectionalDataOrder, WebChartLineChartSeries, WebGaugeChart, WebChartOrderDataByTypes } from '../../../spec';
 import { FormerWebChartBoxPlotDataSortTypes, FormerWebChartDataValueTypes } from './interfaces';
 /**
  * Matches the config properties that have field names which mismatch the layer data source fields.
@@ -210,7 +210,6 @@ declare function applyDataOrderInstructionForFromFieldsCharts(configToUpdate: We
  *         "trimIncompleteTimeInterval": true,
  *         "nullPolicy": "null"
  *       }
- * @param configToUpdate
  * @param configToUpdate Config to update
  * @returns the updated chart config
  */
@@ -222,6 +221,11 @@ declare function convertRESTStatisticTypeToWebChartStatisticType(configToUpdate:
  * @returns
  */
 declare function renameChartSubtitle(configToUpdate: WebChart): WebChart;
+/**
+ * Converts the temporal binning properties from the old pattern to the new pattern introduced in version 24.0.0.
+ * @param configToUpdate The chart's config to update
+ */
+declare function convertTemporalBinningProps2(configToUpdate: WebChart): WebChart;
 /** **********************************************************************************************************
  *                                                                                                          *
  * Conversion functions to be called in `convertChartSpec()`                                      *
@@ -360,9 +364,16 @@ declare function convertTo21x1x0(configToUpdate: WebChart): WebChart;
  * Conversion for v23.3.0:
  * - Rename the subTitle property to subtitle
  * @param configToUpdate The chart's config to update
- * @returns
+ * @returns The updated chart config
  */
 declare function convertTo23x3x0(configToUpdate: WebChart): WebChart;
+/**
+ * Conversion for v24.0.0:
+ * - Converts the temporal binning properties from the old pattern to the new pattern
+ * @param configToUpdate The chart's config to update
+ * @returns The updated chart config
+ */
+declare function convertTo24x0x0(configToUpdate: WebChart): WebChart;
 /**
  * Apply the needed function calls depending on the current chart version.
  * Note: Additional switch cases and convertToxxx functions are to be added to this function accordingly.
@@ -445,6 +456,8 @@ export declare const chartConfigConverterPrivateFunctions: {
     convertTo20x2x0: typeof convertTo20x2x0;
     convertTo21x1x0: typeof convertTo21x1x0;
     convertTo23x3x0: typeof convertTo23x3x0;
+    convertTo24x0x0: typeof convertTo24x0x0;
+    convertTemporalBinningProps2: typeof convertTemporalBinningProps2;
     applyConversions: typeof applyConversions;
     convertDataSourceToILayer: typeof convertDataSourceToILayer;
 };