@arcgis/core 5.0.0-next.51 → 5.0.0-next.53

package/rest/support/AttributeBinsQuery.d.ts

@@ -1,4 +1,162 @@
-import "../../interfaces";
+import type AutoIntervalBinParameters from "./AutoIntervalBinParameters.js";
+import type DateBinParameters from "./DateBinParameters.js";
+import type FixedBoundariesBinParameters from "./FixedBoundariesBinParameters.js";
+import type FixedIntervalBinParameters from "./FixedIntervalBinParameters.js";
+import type StatisticDefinition from "./StatisticDefinition.js";
+import type { ClonableMixin, ClonableMixinProperties } from "../../core/Clonable.js";
+import type { JSONSupport, JSONSupportMixinProperties } from "../../core/JSONSupport.js";
+import type { DatumTransformation } from "../../portal/jsonTypes.js";
+import type { QueryMixin, QueryMixinProperties } from "./QueryMixin.js";
+import type { IANATimeZone } from "../../time/interfaces.js";
+import type { FixedIntervalBinParametersProperties } from "./FixedIntervalBinParameters.js";
+import type { FixedBoundariesBinParametersProperties } from "./FixedBoundariesBinParameters.js";
+import type { DateBinParametersProperties } from "./DateBinParameters.js";
+import type { AutoIntervalBinParametersProperties } from "./AutoIntervalBinParameters.js";
+import type { StatisticDefinitionProperties } from "./StatisticDefinition.js";
 
-import AttributeBinsQuery = __esri.AttributeBinsQuery;
-export default AttributeBinsQuery;
+export interface AttributeBinsQueryProperties extends JSONSupportMixinProperties, ClonableMixinProperties, QueryMixinProperties, Partial<Pick<AttributeBinsQuery, "binOrder" | "datumTransformation" | "lowerBoundaryAlias" | "outTimeZone" | "returnDistinctValues" | "upperBoundaryAlias">> {
+  /**
+   * Bin parameters describe the characteristics of the bins, including their size and starting value. Each bin's size can either be specified by a parameter
+   * or calculated dynamically. Additionally, bins can be based on either date or numeric values.
+   */
+  binParameters?: ((AutoIntervalBinParametersProperties & { type: "auto-interval" }) | (DateBinParametersProperties & { type: "date" }) | (FixedBoundariesBinParametersProperties & { type: "fixed-boundaries" }) | (FixedIntervalBinParametersProperties & { type: "fixed-interval" }));
+  /**
+   * The definitions for one or more field-based statistics to be calculated. For service-based queries, check the layer's
+   * [query.queryAttributeBins.supportedStatistics](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-interfaces.html#FeatureLayerCapabilities) capabilities to ensure that
+   * the layer supports statistics queries.
+   *
+   * @example
+   * // get the average temperature for each bin
+   * let statisticDefinition = new StatisticDefinition({
+   *   statisticType: "avg",
+   *   onStatisticField: "temp",
+   *   outStatisticFieldName: "temp_avg"
+   * });
+   *
+   * // Query bins with fixed interval bin parameters based on field "temp" with 5 degrees interval.
+   * const binQuery = new AttributeBinsQuery({
+   *   binParameters: new FixedIntervalBinParameters({
+   *     interval: 5, // the interval size for each bin. In this case, 5 degrees celsius
+   *     field: "temp", // the field to bin, containing the temperature data
+   *     start: 0, // the lower boundary of the first bin. 0 degrees celsius
+   *     end: 30 // the upper boundary of the last bin. 30 degrees celsius
+   *   }),
+   *  // get the average temperature for each bin
+   *  outStatistics: [statisticDefinition]
+   * });
+   */
+  outStatistics?: StatisticDefinitionProperties[] | null;
+}
+
+export type BinParameters = AutoIntervalBinParameters | DateBinParameters | FixedBoundariesBinParameters | FixedIntervalBinParameters;
+
+/**
+ * This class configures parameters for the [FeatureLayer#queryAttributeBins()](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-FeatureLayer.html#queryAttributeBins) method, which groups features in a layer or layer view into bins
+ * based on numeric or date fields. This operation is useful for summarizing and analyzing large datasets by organizing them into meaningful groups, or bins, making it easier to detect patterns,
+ * trends, and anomalies across different ranges or time periods.
+ *
+ * The [binParameters](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-AttributeBinsQuery.html#binParameters) property defines bin characteristics like size and start value, while the [outStatistics](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-AttributeBinsQuery.html#outStatistics) parameter specifies the information each bin provides.
+ * Features can be filtered using a [where](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-AttributeBinsQuery.html#where) condition and a [spatial filter](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-AttributeBinsQuery.html#geometry). Bins are arranged consecutively with no gaps:
+ * they are left-inclusive and right-exclusive, except for the last bin, which is right-inclusive. The method supports multiple statistical aggregations per bin and defaults to
+ * a histogram of value frequencies/counts if no specific aggregations are provided in `outStatistics`.
+ *
+ * Bins are defined using one of the bin parameters, each supporting distinct parameters for handling boundaries between bins. Understanding the purpose of each bin parameter is
+ * crucial for understanding binning and boundary settings. There are four types of bin parameters:
+ * | Bin parameter type | Description |
+ * | ------------------- | ----------- |
+ * | [AutoIntervalBinParameters](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-AutoIntervalBinParameters.html) | You specify the number of {@link rest/support/AutoIntervalBinParameters#bins}, [AutoIntervalBinParameters#start](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-AutoIntervalBinParameters.html#start) and [AutoIntervalBinParameters#end](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-AutoIntervalBinParameters.html#end) values of the binning. The bin size is calculated by dividing the dataset's range by this number of bins.|
+ * | [FixedBoundariesBinParameters](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-FixedBoundariesBinParameters.html) | The bins strictly follow the specified [input values](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-FixedBoundariesBinParameters.html#boundaries). The first item in the array specifies the lower boundary of the first bin, while the last item specifies the upper boundary of the last bin. Intermediate values represent the lower boundaries of each bin. |
+ * | [FixedIntervalBinParameters](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-FixedIntervalBinParameters.html) | The number of bins is not important, but the [FixedIntervalBinParameters#interval](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-FixedIntervalBinParameters.html#interval) size must match the input data. Each bin will cover a range that exactly fits the specified interval. |
+ * | [DateBinParameters](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-DateBinParameters.html) | The [intervals](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-DateBinParameters.html#interval) are based on calendar units. For example, with monthly intervals, each bin represents an entire month. |
+ *
+ * @since 4.32
+ * @see [FeatureLayer#queryAttributeBins()](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-FeatureLayer.html#queryAttributeBins)
+ * @see [Sample - Attribute Bins Query](https://developers.arcgis.com/javascript/latest/sample-code/query-attribute-bins/)
+ */
+export default class AttributeBinsQuery extends AttributeBinsQuerySuperclass {
+  constructor(properties?: AttributeBinsQueryProperties);
+  /**
+   * Bins can be returned in ascending or descending order. The default is `ascending`.
+   *
+   * @default "ascending"
+   */
+  binOrder?: "ascending" | "descending" | null;
+  /**
+   * Bin parameters describe the characteristics of the bins, including their size and starting value. Each bin's size can either be specified by a parameter
+   * or calculated dynamically. Additionally, bins can be based on either date or numeric values.
+   */
+  get binParameters(): BinParameters;
+  set binParameters(value: ((AutoIntervalBinParametersProperties & { type: "auto-interval" }) | (DateBinParametersProperties & { type: "date" }) | (FixedBoundariesBinParametersProperties & { type: "fixed-boundaries" }) | (FixedIntervalBinParametersProperties & { type: "fixed-interval" })));
+  /**
+   * Datum transformation used for projecting geometries in the query results when
+   * [outSpatialReference](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-AttributeBinsQuery.html#outSpatialReference) is different than the layer's spatial reference.
+   * Requires ArcGIS Server service 10.5 or greater.
+   */
+  accessor datumTransformation: DatumTransformation | null | undefined;
+  /** Sets the name of the lower boundary property in the response. By default, the lower boundary is name `lowerBoundary` and indicates the value at the edge of each bin. */
+  accessor lowerBoundaryAlias: string | null | undefined;
+  /**
+   * The definitions for one or more field-based statistics to be calculated. For service-based queries, check the layer's
+   * [query.queryAttributeBins.supportedStatistics](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-interfaces.html#FeatureLayerCapabilities) capabilities to ensure that
+   * the layer supports statistics queries.
+   *
+   * @example
+   * // get the average temperature for each bin
+   * let statisticDefinition = new StatisticDefinition({
+   *   statisticType: "avg",
+   *   onStatisticField: "temp",
+   *   outStatisticFieldName: "temp_avg"
+   * });
+   *
+   * // Query bins with fixed interval bin parameters based on field "temp" with 5 degrees interval.
+   * const binQuery = new AttributeBinsQuery({
+   *   binParameters: new FixedIntervalBinParameters({
+   *     interval: 5, // the interval size for each bin. In this case, 5 degrees celsius
+   *     field: "temp", // the field to bin, containing the temperature data
+   *     start: 0, // the lower boundary of the first bin. 0 degrees celsius
+   *     end: 30 // the upper boundary of the last bin. 30 degrees celsius
+   *   }),
+   *  // get the average temperature for each bin
+   *  outStatistics: [statisticDefinition]
+   * });
+   */
+  get outStatistics(): StatisticDefinition[] | null | undefined;
+  set outStatistics(value: StatisticDefinitionProperties[] | null | undefined);
+  /**
+   * Defines the [IANA time zone](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones) used for bin calculations when the bin parameter field is a date field.
+   * If not specified, the UTC time zone is used for binning calculations.
+   * When a time zone is specified, dates and times will be adjusted according to that IANA time zone.
+   *
+   * @see [wikipedia - List of tz database time zones](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones)
+   * @example
+   * // Query bins with date interval bin parameters based on field "date" with monthly intervals.
+   * const binQuery = new AttributeBinsQuery({
+   *   binParameters: new DateBinParameters({
+   *     interval: 3,
+   *     field: "RecordedDate",
+   *     start: new Date(Date.UTC(1980, 0, 2, 0, 0)),
+   *     end: new Date(Date.UTC(1980, 2, 1, 0, 0)),
+   *     number: "1",
+   *     unit: "months"
+   *   }),
+   *   outTimeZone: "America/New_York" // Get the binning results in Eastern Time Zone
+   * });
+   */
+  accessor outTimeZone: IANATimeZone | null | undefined;
+  /**
+   * If `true` then the query returns distinct values based on the field(s) specified in {@link rest/support/AttributeBinsQuery#outFields}.
+   *
+   * > [!WARNING]
+   * >
+   * > **Known Limitations**
+   * >
+   * > For service-based queries, this parameter applies only if the `supportsAdvancedQueries` capability of the layer is `true`.
+   * > Make sure to set {@link rest/support/AttributeBinsQuery#returnGeometry} to `false` when `returnDistinctValues` is true. Otherwise, reliable results will not be returned.
+   *
+   * @default false
+   */
+  accessor returnDistinctValues: boolean | null | undefined;
+  /** Sets the name of the upper boundary property in the response. By default, the upper boundary is name `upperBoundary` and indicates the value at the edge of each bin. */
+  accessor upperBoundaryAlias: string | null | undefined;
+}
+declare const AttributeBinsQuerySuperclass: typeof JSONSupport & typeof ClonableMixin & typeof QueryMixin

package/rest/support/AutoIntervalBinParameters.d.ts

@@ -1,4 +1,48 @@
-import "../../interfaces";
+import type BinParametersBase from "./BinParametersBase.js";
+import type { BinParametersBaseProperties } from "./BinParametersBase.js";
+import type { NormalizationBinParametersMixinProperties, NormalizationBinParametersMixin } from "./NormalizationBinParametersMixin.js";
 
-import AutoIntervalBinParameters = __esri.AutoIntervalBinParameters;
-export default AutoIntervalBinParameters;
+export interface AutoIntervalBinParametersProperties extends BinParametersBaseProperties, NormalizationBinParametersMixinProperties, Partial<Pick<AutoIntervalBinParameters, "end" | "numBins" | "start">> {}
+
+/**
+ * AutoIntervalBinParameters specifies [AttributeBinsQuery#binParameters](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-AttributeBinsQuery.html#binParameters) on [AttributeBinsQuery](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-AttributeBinsQuery.html) object.
+ * It defines the number of {@link rest/support/AutoIntervalBinParameters#bins}, and the [start](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-AutoIntervalBinParameters.html#start) and [end](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-AutoIntervalBinParameters.html#end) values for binning  on a specified [field](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-AutoIntervalBinParameters.html#field). Bin size is automatically calculated based
+ * on the range between the start and end values and the number of bins. The end value will be included in the last bin.
+ * The AutoIntervalBinParameters does not support `timestamp-offset`, `date-only`, or `time-only` field types.
+ *
+ * When analyzing annual accident data across the USA, focusing on the time of day accidents occurred, you can use auto interval bin to visualize the distribution of accidents throughout
+ * different hours of the day. The bin parameters would be:
+ *
+ * ```js
+ * // Query bins with auto interval bin parameters based on field "total" with 3 bins.
+ * const binQuery = new AttributeBinsQuery({
+ *   where: "Unit = 0",
+ *   binParameters: new AutoIntervalBinParameters({
+ *     bins: 24,
+ *     field: "HOUR", // the field to bin, containing the hours of the day
+ *     start: 0, // the lower boundary of the first bin
+ *     end: 24 // the upper boundary of the last bin
+ *   })
+ * });
+ * ```
+ *
+ * <figure>
+ *   <img src="https://developers.arcgis.com/javascript/latest/assets/img/apiref/rest/binQuery/auto-bin.png" alt="color-blend" style="width:400px;"/>
+ *   <figcaption>Total accidents in the USA by hour for the year 2021. Each bin represents the number of accidents that occurred during each hour of the day. The chart is based on the results obtained from the bin query shown above.</figcaption>
+ * </figure>
+ *
+ * @since 4.32
+ * @see [AttributeBinsQuery](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-AttributeBinsQuery.html)
+ */
+export default class AutoIntervalBinParameters extends AutoIntervalBinParametersSuperclass {
+  constructor(properties?: AutoIntervalBinParametersProperties);
+  /** The end value of bins to generate. The value can be a number or a date. */
+  accessor end: number | Date | null | undefined;
+  /** The number of bins to generate. */
+  accessor numBins: number | null | undefined;
+  /** The start value of bins to generate. The value can be a number or a date. */
+  accessor start: number | Date | null | undefined;
+  /** The type of bin parameters. */
+  readonly type: "auto-interval";
+}
+declare const AutoIntervalBinParametersSuperclass: typeof BinParametersBase & typeof NormalizationBinParametersMixin

package/rest/support/BaseImageMeasureParameters.d.ts

@@ -1,4 +1,46 @@
-import "../../interfaces";
+import type Point from "../../geometry/Point.js";
+import type MosaicRule from "../../layers/support/MosaicRule.js";
+import type { JSONSupport, JSONSupportMixinProperties } from "../../core/JSONSupport.js";
+import type { MosaicRuleProperties } from "../../layers/support/MosaicRule.js";
+import type { PointProperties } from "../../geometry/Point.js";
 
-import BaseImageMeasureParameters = __esri.BaseImageMeasureParameters;
-export default BaseImageMeasureParameters;
+export interface BaseImageMeasureParametersProperties extends JSONSupportMixinProperties {
+  /**
+   * Specifies the [mosaic rule](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-support-MosaicRule.html) on how individual images should be mosaicked
+   * when the measure is computed. When a mosaic rule is not specified, the current settings on the [ImageryLayer#mosaicRule](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-ImageryLayer.html#mosaicRule) will be used.
+   *
+   * @since 4.27
+   */
+  mosaicRule?: MosaicRuleProperties | null;
+  /**
+   * Specifies the pixel size. If pixel size is not specified, `pixelSize` will default to the base resolution of the image service.
+   * The raster at the specified pixel size in the mosaic dataset will be used for the Measure calculation.
+   *
+   * @since 4.27
+   */
+  pixelSize?: PointProperties;
+}
+
+/**
+ * Base class for imagery mensuration operations.
+ *
+ * @since 4.27
+ */
+export default abstract class BaseImageMeasureParameters extends JSONSupport {
+  /**
+   * Specifies the [mosaic rule](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-support-MosaicRule.html) on how individual images should be mosaicked
+   * when the measure is computed. When a mosaic rule is not specified, the current settings on the [ImageryLayer#mosaicRule](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-ImageryLayer.html#mosaicRule) will be used.
+   *
+   * @since 4.27
+   */
+  get mosaicRule(): MosaicRule | null | undefined;
+  set mosaicRule(value: MosaicRuleProperties | null | undefined);
+  /**
+   * Specifies the pixel size. If pixel size is not specified, `pixelSize` will default to the base resolution of the image service.
+   * The raster at the specified pixel size in the mosaic dataset will be used for the Measure calculation.
+   *
+   * @since 4.27
+   */
+  get pixelSize(): Point;
+  set pixelSize(value: PointProperties);
+}

package/rest/support/BaseImageMeasureResult.d.ts

@@ -1,4 +1,16 @@
-import "../../interfaces";
+import type { JSONSupport, JSONSupportMixinProperties } from "../../core/JSONSupport.js";
 
-import BaseImageMeasureResult = __esri.BaseImageMeasureResult;
-export default BaseImageMeasureResult;
+export interface BaseImageMeasureResultProperties extends JSONSupportMixinProperties, Partial<Pick<BaseImageMeasureResult, "name" | "sensorName">> {}
+
+/**
+ * Base class for image service measure result.
+ *
+ * @since 4.26
+ */
+export default class BaseImageMeasureResult extends JSONSupport {
+  constructor(properties?: BaseImageMeasureResultProperties);
+  /** Name of the raster dataset used in the area and height measurement. */
+  accessor name: string;
+  /** Sensor name of the raster dataset used in the area and height measurement. */
+  accessor sensorName: string;
+}

package/rest/support/BaseImageMeasureResultValue.d.ts

@@ -0,0 +1,19 @@
+import type { JSONSupport, JSONSupportMixinProperties } from "../../core/JSONSupport.js";
+
+export interface BaseImageMeasureResultValueProperties extends JSONSupportMixinProperties, Partial<Pick<BaseImageMeasureResultValue, "displayValue" | "uncertainty" | "unit" | "value">> {}
+
+/**
+ * An object containing measurement values returned from a mensuration operation. See the object specification table below for details.
+ *
+ * @since 4.26
+ */
+export abstract class BaseImageMeasureResultValue extends JSONSupport {
+  /** Measured value represented in significant figures in string format. Display value takes a count into uncertainty. */
+  accessor displayValue: string;
+  /** Uncertainty of the measurement. Used together with the measured value. */
+  accessor uncertainty: number | null | undefined;
+  /** Unit used in the mensuration operation. */
+  accessor unit: string;
+  /** Measured value. Used together with [uncertainty](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-BaseImageMeasureResultValue.html#uncertainty). */
+  accessor value: number;
+}

package/rest/support/BinParametersBase.d.ts

@@ -1,4 +1,194 @@
-import "../../interfaces";
+import type AttributeBinsGrouping from "./AttributeBinsGrouping.js";
+import type { ClonableMixin, ClonableMixinProperties } from "../../core/Clonable.js";
+import type { JSONSupport, JSONSupportMixinProperties } from "../../core/JSONSupport.js";
+import type { AttributeBinsGroupingProperties } from "./AttributeBinsGrouping.js";
 
-import BinParametersBase = __esri.BinParametersBase;
-export default BinParametersBase;
+export interface BinParametersBaseProperties extends JSONSupportMixinProperties, ClonableMixinProperties, Partial<Pick<BinParametersBase, "expression" | "expressionValueType" | "field" | "firstDayOfWeek" | "hideUpperBound">> {
+  /**
+   * The `splitBy` parameter divides data into separate bins for each unique value in the categorical field. Each category will have different bin boundaries based on the data distribution within that category.
+   * For example, when analyzing sales by region (e.g., Central, Northeast, etc.), `splitBy` will create separate bin ranges for each region, allowing the boundaries to adjust to the specific data distribution of each region.
+   * The `splitBy` parameter is useful when the distribution of values within each category (e.g., branch or region) differs significantly, and you want each category’s binning to reflect its unique data range.
+   *
+   * > [!WARNING]
+   * >
+   * > Field with many unique values are not appropriate for splitting bins into multiple series.
+   *
+   * @example
+   * // create bins based on the SalesTotal field, split by the Branch field.
+   * const binQuery = new AttributeBinsQuery({
+   *   binParameters: new AutoIntervalBinParameters({
+   *     numBins: 5, // the interval size for each bin
+   *     field: "SalesTotal",
+   *     splitBy: { // autocasts to AttributeBinsGrouping
+   *       type: "field",
+   *       value: "Branch"
+   *     }
+   *   })
+   * });
+   * const result = await layer.queryAttributeBins(binQuery);
+   */
+  splitBy?: AttributeBinsGroupingProperties | null;
+  /**
+   * The `stackBy` parameter divides each bin into segments based on unique values from a categorical field, allowing you to compare multiple categories within the same bin
+   * while keeping the bin boundaries consistent across all categories. This enables you to visualize or analyze the distribution of categories stacked together within the same range of values.
+   * For example, with 3 bins based on total sales with ranges like $0 to $5000, $5001 to $10,000, and $10,001 to $15,000, setting `stackBy = SalesRep` will stack each sales rep's contribution
+   * within the same bin range. The bin boundaries remain the same, and each segment within the bin shows how individual categories contribute to the total frequency or value.
+   *
+   * > [!WARNING]
+   * >
+   * > Field with many unique values are not appropriate for splitting bins into multiple series.
+   *
+   * @example
+   * // create bins based on the SalesTotal field, stacked by the Month field.
+   * const binQuery = new AttributeBinsQuery({
+   *   binParameters: new AutoIntervalBinParameters({
+   *     numBins: 5, // the interval size for each bin
+   *     field: "SalesTotal",
+   *     stackBy: {
+   *       value: "EXTRACT(MONTH from invoiceDate)",
+   *       type: "expression",
+   *       valueType: "double",
+   *       alias: "Month"
+   *     }
+   *   })
+   * });
+   * const result = await layer.queryAttributeBins(binQuery);
+   */
+  stackBy?: AttributeBinsGroupingProperties | null;
+}
+
+export type BinParameterFiledType = "small-integer" | "integer" | "single" | "double" | "long" | "date" | "date-only" | "time-only" | "timestamp-offset";
+
+/**
+ * Mixin for binning parameters.
+ *
+ * @since 4.32
+ */
+export default abstract class BinParametersBase extends BinParametersBaseSuperclass {
+  /**
+   * A standardized SQL expression used to calculate the bins, rather than referencing a [field](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-BinParametersBase.html#field). The specified SQL expression must evaluate to a numeric or date type.
+   * Both [field](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-BinParametersBase.html#field) and the `expression` cannot be specified for the same bin. The [expressionValueType](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-BinParametersBase.html#expressionValueType) property must be set to the expected data type
+   * of the output from the expression.
+   *
+   * > [!WARNING]
+   * >
+   * > **Known Limitations**
+   * >
+   * >  The `expression` is only supported with server-side [FeatureLayers](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-FeatureLayer.html).
+   *
+   * @see [expressionValueType](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-BinParametersBase.html#expressionValueType)
+   * @example
+   * const binQuery = new AttributeBinsQuery({
+   *   binParameters: new AutoIntervalBinParameters({
+   *     numBins: 5, // the interval size for each bin
+   *     // sql expression to calculate the bins based on the product of Quantity and SalesAmount
+   *     expression: "Quantity * SalesAmount"
+   *     expressionValueType: "double"
+   *   })
+   * });
+   */
+  accessor expression: string | null | undefined;
+  /**
+   * Specifies the expected data type of the output from the [expression](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-BinParametersBase.html#expression), based on the type of value the expression generates.
+   * The [expression](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-BinParametersBase.html#expression) property must be set when this property is set.
+   *
+   * > [!WARNING]
+   * >
+   * > **Known Limitations**
+   * >
+   * >  The `expressionValueType` is only supported with server-side [FeatureLayers](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-FeatureLayer.html).
+   *
+   * @see [expression](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-BinParametersBase.html#expression)
+   * @example
+   * const binQuery = new AttributeBinsQuery({
+   *   binParameters: new AutoIntervalBinParameters({
+   *     numBins: 5, // the interval size for each bin
+   *     // sql expression to calculate the bins based on the product of Quantity and SalesAmount
+   *     expression: "Quantity * SalesAmount"
+   *     expressionValueType: "double"
+   *   })
+   * });
+   */
+  expressionValueType?: BinParameterFiledType | null;
+  /**
+   * The field name used to calculate the bins. The [expression](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-BinParametersBase.html#expression) property cannot be set when this property is set.
+   *
+   * @see [expression](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-BinParametersBase.html#expression)
+   */
+  accessor field: string | null | undefined;
+  /**
+   * 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.
+   *
+   * > [!WARNING]
+   * >
+   * > **Known Limitations**
+   * >
+   * >  The `firstDayOfWeek` is only supported with server-side [FeatureLayers](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-FeatureLayer.html).
+   */
+  accessor firstDayOfWeek: number | null | undefined;
+  /**
+   * If `true`, the  `upperBoundary` and `bin` fields will not be included in the attributes.
+   *
+   * > [!WARNING]
+   * >
+   * > **Known Limitations**
+   * >
+   * >  The `hideUpperBound` is only supported with server-side [FeatureLayers](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-FeatureLayer.html).
+   */
+  accessor hideUpperBound: boolean | null | undefined;
+  /**
+   * The `splitBy` parameter divides data into separate bins for each unique value in the categorical field. Each category will have different bin boundaries based on the data distribution within that category.
+   * For example, when analyzing sales by region (e.g., Central, Northeast, etc.), `splitBy` will create separate bin ranges for each region, allowing the boundaries to adjust to the specific data distribution of each region.
+   * The `splitBy` parameter is useful when the distribution of values within each category (e.g., branch or region) differs significantly, and you want each category’s binning to reflect its unique data range.
+   *
+   * > [!WARNING]
+   * >
+   * > Field with many unique values are not appropriate for splitting bins into multiple series.
+   *
+   * @example
+   * // create bins based on the SalesTotal field, split by the Branch field.
+   * const binQuery = new AttributeBinsQuery({
+   *   binParameters: new AutoIntervalBinParameters({
+   *     numBins: 5, // the interval size for each bin
+   *     field: "SalesTotal",
+   *     splitBy: { // autocasts to AttributeBinsGrouping
+   *       type: "field",
+   *       value: "Branch"
+   *     }
+   *   })
+   * });
+   * const result = await layer.queryAttributeBins(binQuery);
+   */
+  get splitBy(): AttributeBinsGrouping | null | undefined;
+  set splitBy(value: AttributeBinsGroupingProperties | null | undefined);
+  /**
+   * The `stackBy` parameter divides each bin into segments based on unique values from a categorical field, allowing you to compare multiple categories within the same bin
+   * while keeping the bin boundaries consistent across all categories. This enables you to visualize or analyze the distribution of categories stacked together within the same range of values.
+   * For example, with 3 bins based on total sales with ranges like $0 to $5000, $5001 to $10,000, and $10,001 to $15,000, setting `stackBy = SalesRep` will stack each sales rep's contribution
+   * within the same bin range. The bin boundaries remain the same, and each segment within the bin shows how individual categories contribute to the total frequency or value.
+   *
+   * > [!WARNING]
+   * >
+   * > Field with many unique values are not appropriate for splitting bins into multiple series.
+   *
+   * @example
+   * // create bins based on the SalesTotal field, stacked by the Month field.
+   * const binQuery = new AttributeBinsQuery({
+   *   binParameters: new AutoIntervalBinParameters({
+   *     numBins: 5, // the interval size for each bin
+   *     field: "SalesTotal",
+   *     stackBy: {
+   *       value: "EXTRACT(MONTH from invoiceDate)",
+   *       type: "expression",
+   *       valueType: "double",
+   *       alias: "Month"
+   *     }
+   *   })
+   * });
+   * const result = await layer.queryAttributeBins(binQuery);
+   */
+  get stackBy(): AttributeBinsGrouping | null | undefined;
+  set stackBy(value: AttributeBinsGroupingProperties | null | undefined);
+}
+declare const BinParametersBaseSuperclass: typeof JSONSupport & typeof ClonableMixin

package/rest/support/BufferParameters.d.ts

@@ -1,4 +1,92 @@
-import "../../interfaces";
+import type SpatialReference from "../../geometry/SpatialReference.js";
+import type { JSONSupport, JSONSupportMixinProperties } from "../../core/JSONSupport.js";
+import type { GeometryUnion } from "../../geometry/support/typeUtils.js";
+import type { GeometryOperationLengthUnit } from "./interfaces.js";
+import type { SpatialReferenceProperties } from "../../geometry/SpatialReference.js";
+import type { MeshProperties } from "../../geometry/Mesh.js";
+import type { PolylineProperties } from "../../geometry/Polyline.js";
+import type { PolygonProperties } from "../../geometry/Polygon.js";
+import type { PointProperties } from "../../geometry/Point.js";
+import type { MultipointProperties } from "../../geometry/Multipoint.js";
+import type { ExtentProperties } from "../../geometry/Extent.js";
 
-import BufferParameters = __esri.BufferParameters;
-export default BufferParameters;
+export interface BufferParametersProperties extends JSONSupportMixinProperties, Partial<Pick<BufferParameters, "distances" | "geodesic" | "unionResults" | "unit">> {
+  /**
+   * The spatial reference in which the geometries are buffered.
+   *
+   * If `bufferSpatialReference` is not specified, the geometries are buffered in the spatial
+   * reference specified by `outSpatialReference`. If `outSpatialReference` is also not specified,
+   * they are buffered in the spatial reference of the features.
+   */
+  bufferSpatialReference?: SpatialReferenceProperties | null;
+  /** The input geometries to buffer. */
+  geometries?: ((ExtentProperties & { type: "extent" }) | (MultipointProperties & { type: "multipoint" }) | (PointProperties & { type: "point" }) | (PolygonProperties & { type: "polygon" }) | (PolylineProperties & { type: "polyline" }) | (MeshProperties & { type: "mesh" }))[];
+  /**
+   * The spatial reference for the returned geometries.
+   *
+   * If `outSpatialReference` is not specified, the output geometries are in the spatial reference
+   * specified by `bufferSpatialReference`. If `bufferSpatialReference` also is not specified, they
+   * are in the spatial reference of the features.
+   */
+  outSpatialReference?: SpatialReferenceProperties | null;
+}
+
+/**
+ * Sets the distances, units, and other parameters for the [buffer()](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-geometryService.html#buffer)
+ * method on the [geometryService](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-geometryService.html).
+ *
+ * @since 4.20
+ * @see [buffer()](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-geometryService.html#buffer)
+ * @see [ArcGIS REST API - Buffer](https://developers.arcgis.com/rest/services-reference/buffer.htm)
+ */
+export default class BufferParameters extends JSONSupport {
+  constructor(properties?: BufferParametersProperties);
+  /**
+   * The spatial reference in which the geometries are buffered.
+   *
+   * If `bufferSpatialReference` is not specified, the geometries are buffered in the spatial
+   * reference specified by `outSpatialReference`. If `outSpatialReference` is also not specified,
+   * they are buffered in the spatial reference of the features.
+   */
+  get bufferSpatialReference(): SpatialReference | null | undefined;
+  set bufferSpatialReference(value: SpatialReferenceProperties | null | undefined);
+  /** The distances the input features are buffered. The distance units are specified by `unit`. */
+  accessor distances: number[] | null | undefined;
+  /**
+   * If the input geometries are in a geographic coordinate system, set geodesic to `true` to
+   * generate a buffer polygon using a geodesic distance. The `bufferSpatialReference` property is
+   * ignored when geodesic is set to `true`. Requires ArcGIS Server 10.1 or greater geometry service.
+   * For more information, see the ArcGIS REST API documentation on the GeometryService buffer
+   * operation and the geodesic property.
+   *
+   * @default false
+   */
+  accessor geodesic: boolean;
+  /** The input geometries to buffer. */
+  get geometries(): GeometryUnion[];
+  set geometries(value: ((ExtentProperties & { type: "extent" }) | (MultipointProperties & { type: "multipoint" }) | (PointProperties & { type: "point" }) | (PolygonProperties & { type: "polygon" }) | (PolylineProperties & { type: "polyline" }) | (MeshProperties & { type: "mesh" }))[]);
+  /**
+   * The spatial reference for the returned geometries.
+   *
+   * If `outSpatialReference` is not specified, the output geometries are in the spatial reference
+   * specified by `bufferSpatialReference`. If `bufferSpatialReference` also is not specified, they
+   * are in the spatial reference of the features.
+   */
+  get outSpatialReference(): SpatialReference | null | undefined;
+  set outSpatialReference(value: SpatialReferenceProperties | null | undefined);
+  /**
+   * If `true`, all geometries buffered at a given distance are unioned into a single (possibly
+   * multipart) polygon, and the unioned geometry is placed in the output array.
+   *
+   * @default false
+   */
+  accessor unionResults: boolean;
+  /**
+   * The units for calculating each buffer distance. If `unit` is not specified, the units are
+   * derived from `bufferSpatialReference`. If `bufferSpatialReference` is not specified,
+   * the units are derived from the features.
+   *
+   * For a list of valid units, see [esriSRUnitType Constants](https://resources.arcgis.com/en/help/arcobjects-cpp/componenthelp/index.html#/esriSRUnitType_Constants/000w00000042000000/) and [esriSRUnit2Type Constants](https://resources.arcgis.com/en/help/arcobjects-cpp/componenthelp/index.html#/esriSRUnit2Type_Constants/000w00000041000000/).
+   */
+  accessor unit: GeometryOperationLengthUnit | null | undefined;
+}

package/rest/support/CameraInfo.d.ts

@@ -1,4 +1,20 @@
-import "../../interfaces";
+import type { JSONSupport, JSONSupportMixinProperties } from "../../core/JSONSupport.js";
+import type { CameraInfoMixin, CameraInfoMixinProperties } from "./CameraInfoMixin.js";
 
-import CameraInfo = __esri.CameraInfo;
-export default CameraInfo;
+export interface CameraInfoProperties extends JSONSupportMixinProperties, CameraInfoMixinProperties, Partial<Pick<CameraInfo, "id">> {}
+
+/**
+ * Camera information returned as a result of running [ImageryLayer#queryGPSInfo()](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-ImageryLayer.html#queryGPSInfo)
+ * or [queryGPSInfo()](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-imageService.html#queryGPSInfo) methods.
+ *
+ * @since 4.29
+ * @see [ImageGPSInfoResult](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-ImageGPSInfoResult.html)
+ * @see [ImageGPSInfoParameters](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-support-ImageGPSInfoParameters.html)
+ * @see [ImageryLayer#queryGPSInfo()](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-ImageryLayer.html#queryGPSInfo)
+ * @see [queryGPSInfo()](https://developers.arcgis.com/javascript/latest/api-reference/esri-rest-imageService.html#queryGPSInfo)
+ */
+export default abstract class CameraInfo extends CameraInfoSuperclass {
+  /** Camera id. */
+  accessor id: string;
+}
+declare const CameraInfoSuperclass: typeof JSONSupport & typeof CameraInfoMixin