@arcgis/charts-components 5.0.0-next.14 → 5.0.0-next.141

package/dist/utils/layer/query-features/index.d.ts

@@ -1,78 +1,69 @@
-/// <reference types="@arcgis/core/interfaces.d.ts" />
-import { default as AttributeBinsFeatureSet } from '@arcgis/core/rest/support/AttributeBinsFeatureSet.js';
-import { WebBoxPlot, WebChart, WebChartDataItem, WebChartQuery, WebChartTemporalBinning, WebHeatChart } from '../../../spec';
-import { ErrorStrings } from '../../localization/interfaces';
-import { ChartSubType } from '../../misc/interfaces';
-import { QueryObject } from '../interfaces';
-import { AbortControllerKeyType, Features } from './interfaces';
+import type AttributeBinsGraphic from "@arcgis/core/AttributeBinsGraphic.js";
+import type AttributeBinsFeatureSet from "@arcgis/core/rest/support/AttributeBinsFeatureSet.js";
+import type { ErrorStrings } from "../../localization/interfaces.js";
+import type { ChartSubType } from "../../misc/interfaces.js";
+import type { QueryObject } from "../interfaces.js";
+import type { AbortControllerKeyType, Features } from "./interfaces.js";
+import type { WebChartQuery, WebChartTemporalBinning, WebHeatChart } from "../../../spec/web-chart.js";
+import type { WebChartDataItem } from "../../../spec/data-source.js";
+
 /**
  * Performs a query analytic.
- * @param props.queryObject The object used to query (FL or FLV)
- * @param props.queryConfig The WebChartQuery
- * @param props.outAnalytics The out analytics
- * @param props.outputFormat The output format
- * @param props.dataFormat The data format
+ *
+ * @param props - The object used to query (FL or FLV)
  */
-export declare function queryAnalytic(props: {
+export function queryAnalytic(props: {
     queryObject: QueryObject;
     queryConfig: WebChartQuery;
     outAnalytics: string;
     outputFormat: string;
     dataFormat: string;
 }): Promise<WebChartDataItem | undefined>;
+
 /**
  * Generates the aliases to use in the queryAttributeBins query to name the stacks and boundaries for the x field
- * @param x The x field used for the stack alias
- * @param y The y field used by the stacks
+ *
+ * @param x - The x field used for the stack alias
+ * @param y - The y field used by the stacks
  */
-export declare function getQueryAttributeBinsForScatterplotFieldsAlias(x: string, y: string): {
+export function getQueryAttributeBinsForScatterplotFieldsAlias(x: string, y: string): {
     lowerBoundaryAlias: string;
     upperBoundaryAlias: string;
     stackAlias: string;
 };
+
 /**
  * Fetches and returns the heat chart data using query(Attribute)Bins
- * @param props.chartConfig The chart configuration
- * @param props.queryObject The object used to query (FL or FLV)
- * @param props.queryConfig The query configuration
- * @param props.errorStrings The t9n error strings
+ *
+ * @param props - The chart configuration
  */
-export declare function queryAttributeBinsForHeatChart(props: {
-    chartConfig: WebBoxPlot | WebChart | WebHeatChart;
+export function queryAttributeBinsForHeatChart(props: {
+    chartConfig: WebHeatChart;
     queryObject: QueryObject;
     queryConfig: WebChartQuery;
     errorStrings: ErrorStrings;
 }): Promise<AttributeBinsFeatureSet | undefined>;
+
 /**
  * Query the features for the matrix heat chart.
- * @param props.chartConfig The chart configuration
- * @param props.queryObject The object used to query (FL or FLV)
- * @param props.queryConfig The query configuration
- * @param props.returnFeaturesExtent Whether to add an out statistic to fetch the features extent
- * @param props.errorStrings The t9n error strings
- * @param props.abortKey The key to abort the query
+ *
+ * @param props - The chart configuration
  */
-export declare function queryFeaturesForMatrixHeatChart(props: {
-    chartConfig: WebBoxPlot | WebChart | WebHeatChart;
+export function queryFeaturesForMatrixHeatChart(props: {
+    chartConfig: WebHeatChart;
     queryObject: QueryObject;
     queryConfig: WebChartQuery;
     returnFeaturesExtent?: boolean;
     errorStrings: ErrorStrings;
     abortKey?: AbortControllerKeyType;
 }): Promise<Features | undefined>;
+
 /**
  * Uses query(Attribute)Bins to fetch the aggregated scatterplot data
- * @param props.queryObject The object used to query (FL or FLV)
- * @param props.queryConfig The query configuration
- * @param props.xStep The x step
- * @param props.yStep The y step
- * @param props.xMin The x min
- * @param props.xMax The x max
- * @param props.x The x field
- * @param props.y The y field
- * @param props.errorStrings The t9n error strings
+ *
+ * @param props - The object used to query (FL or FLV)
  */
-export declare function queryAttributeBinsForScatterplot(props: {
+export function queryAttributeBinsForScatterplot(props: {
     queryObject: QueryObject;
     queryConfig: WebChartQuery;
     xStep: number;
@@ -83,44 +74,39 @@ export declare function queryAttributeBinsForScatterplot(props: {
     y: string;
     errorStrings: ErrorStrings;
 }): Promise<AttributeBinsFeatureSet | undefined>;
+
 /**
  * Performs a query feature count based on the provided parameters.
- * @param props.queryObject The object used to query (FL or FLV)
- * @param props.queryConfig The WebChartQuery containing parameters about the query to execute
- * @param props.chartSubType The chart sub type
- * @param props.x The x field
- * @param props.isGaugeByFeature Indicate whether it's a gauge by feature. Will be defaulted to `false` if not provided.
+ *
+ * @param props - The object used to query (FL or FLV)
  */
-export declare function queryFeatureCount(props: {
+export function queryFeatureCount(props: {
     queryObject: QueryObject;
     queryConfig: WebChartQuery;
     chartSubType: ChartSubType;
     x: string;
     isGaugeByFeature?: boolean;
 }): Promise<number | undefined>;
+
 /**
  * Fetches multiple statistics (min, max, count...).
  * Returns an object mapping the outStatisticFieldName with its value
- * @param props.queryObject The object used to query (FL or FLV)
- * @param props.queryConfig The WebChartQuery containing parameters about the query to execute
- * @param props.abortKey The key to abort the query
+ *
+ * @param props - The object used to query (FL or FLV)
  */
-export declare function queryStatistics<T extends Date | number | string>(props: {
+export function queryStatistics<T extends Date | number | string>(props: {
     queryObject: QueryObject;
     queryConfig: WebChartQuery;
     abortKey?: AbortControllerKeyType;
 }): Promise<Map<string, T>>;
+
 /**
  * Fetches all the features from the input QueryObject, according to the other specified input settings (query, outFields...).
  * Handles the paging.
- * @param props.queryObject The object used to query (FL or FLV)
- * @param props.queryConfig The WebChartQuery containing parameters about the query to execute
- * @param props.returnUniqueIdsOnly If true, the function will return only the unique IDs of the features
- * @param props.featureCount The number of features to fetch
- * @param props.noBatch If true, the function will not use the batching mechanism
- * @param props.abortKey The key to abort the query
+ *
+ * @param props - The object used to query (FL or FLV)
  */
-export declare function queryAllFeatures(props: {
+export function queryAllFeatures(props: {
     queryObject?: QueryObject;
     queryConfig?: WebChartQuery;
     returnUniqueIdsOnly?: boolean;
@@ -128,45 +114,45 @@ export declare function queryAllFeatures(props: {
     noBatch?: boolean;
     abortKey?: AbortControllerKeyType;
 }): Promise<Features>;
+
 /**
  * Fetches the extent of all the features that are represented by their object ids
- * @param props.queryObject The object used to query (FL or FLV)
- * @param props.queryConfig The WebChartQuery containing parameters about the query to execute
- * @param props.uniqueFeature Whether the query is made to fetch a unique feature
- * @param props.abortKey The key to abort the query
+ *
+ * @param props - The object used to query (FL or FLV)
  */
-export declare function queryUniqueIDs(props: {
+export function queryUniqueIDs(props: {
     queryObject?: QueryObject;
     queryConfig: WebChartQuery;
     uniqueFeature?: boolean;
     abortKey?: AbortControllerKeyType;
-}): Promise<number[]>;
+}): Promise<(number | string)[]>;
+
 /**
  * Aborts all existing queries and initializes a controller for new ones. The queries are associated
  * to a unique key to avoid cancelling queries for other charts.
- * @param key The key pointing to the abort controller to execute
+ *
+ * @param key - The key pointing to the abort controller to execute
  */
-export declare function abortPendingQueries(key?: AbortControllerKeyType): void;
-export declare function getQueryAttributeBinsForTemporalDataAliases(x: string): {
+export function abortPendingQueries(key?: AbortControllerKeyType): void;
+
+/** @param x */
+export function getQueryAttributeBinsForTemporalDataAliases(x: string): {
     lowerBoundaryAlias: string;
     upperBoundaryAlias: string;
 };
+
 /**
  * Fetches binned temporal data using queryAttributeBins().
  * TODO: support for offset
  * TODO: support for abortKey input parameter
- * @param props.queryObject The object used to query (FL or FLV)
- * @param props.queryConfig The WebChartQuery containing parameters about the query to execute
- * @param props.temporalBinning The temporal binning configuration
- * @param props.dateField The date field to bin
- * @param props.splitByField The split-by field
- * @param props.abortKey The key to abort the query
+ *
+ * @param props - The object used to query (FL or FLV)
  */
-export declare function queryAttributeBinsForTemporalData(props: {
+export function queryAttributeBinsForTemporalData(props: {
     queryObject?: QueryObject;
     queryConfig: WebChartQuery;
     temporalBinning?: WebChartTemporalBinning;
     dateField: string;
     splitByField?: string;
     abortKey?: AbortControllerKeyType;
-}): Promise<__esri.AttributeBinsGraphic[]>;
+}): Promise<AttributeBinsGraphic[]>;

package/dist/utils/layer/query-features/interfaces.d.ts

@@ -1,4 +1,7 @@
-import { default as Graphic } from '@arcgis/core/Graphic';
+import type Graphic from "@arcgis/core/Graphic";
+
 export type AbortControllerKeyType = Date | number | string;
-export declare const abortControllerMap: Map<AbortControllerKeyType, AbortController>;
-export type Features = (number | string)[] | Graphic[];
+
+export const abortControllerMap: Map<AbortControllerKeyType, AbortController>;
+
+export type Features = (number | string)[] | Graphic[];

package/dist/utils/layer/query-parser/index.d.ts

@@ -1,85 +1,87 @@
-/// <reference types="@arcgis/core/interfaces.d.ts" />
-import { default as Geometry } from '@arcgis/core/geometry/Geometry';
-import { default as AttributeBinsQuery } from '@arcgis/core/rest/support/AttributeBinsQuery.js';
-import { default as Query } from '@arcgis/core/rest/support/Query.js';
-import { default as TimeExtent } from '@arcgis/core/time/TimeExtent.js';
-import { SupportedLayer, WebChartHeatChartSeries, WebChartQuery, WebChartTemporalBinning, RESTFieldType } from '../../../spec';
-import { QueryObject } from '../interfaces';
+import type Geometry from "@arcgis/core/geometry/Geometry";
+import type FeatureLayer from "@arcgis/core/layers/FeatureLayer.js";
+import type SubtypeSublayer from "@arcgis/core/layers/support/SubtypeSublayer.js";
+import type AttributeBinsQuery from "@arcgis/core/rest/support/AttributeBinsQuery.js";
+import type Query from "@arcgis/core/rest/support/Query.js";
+import type TimeExtent from "@arcgis/core/time/TimeExtent.js";
+import type { QueryProperties } from "@arcgis/core/rest/support/Query.js";
+import type { RESTFieldType } from "../../../spec/rest-js-object-literals.js";
+import type { WebChartHeatChartSeries, WebChartQuery, WebChartTemporalBinning } from "../../../spec/web-chart.js";
+import type { QueryObject } from "../interfaces.js";
+
 /**
  * Indicates whether a query can be cached. It is not when:
  * - a geometry is set (unless it's an extent)
  * - a date filter is set
- * @param query The query object or query parameters
+ *
+ * @param query - The query object or query parameters
  */
-export declare function isQueryCacheable(query: __esri.QueryProperties | AttributeBinsQuery | Query): boolean;
-export declare function getMaxRecords(layer?: SupportedLayer): number;
+export function isQueryCacheable(query: AttributeBinsQuery | Query | QueryProperties): boolean;
+
+/** @param layer */
+export function getMaxRecords(layer?: Pick<FeatureLayer, "sourceJSON"> | SubtypeSublayer): number;
+
 /**
  * Function building a where clause by concatenating a list of filters by using the AND operator.
- * @param filterList The list of filters to combine
- * @param operand The operand to use to combine the filters (OR, AND...)
+ *
+ * @param filterList - The list of filters to combine
+ * @param operand - The operand to use to combine the filters (OR, AND...)
  */
-export declare function combineFilters(filterList: (string | null | undefined)[], operand?: string): string;
+export function combineFilters(filterList: (string | null | undefined)[], operand?: string): string;
+
 /**
  * Computes the time extent to be used by the query.
- * @param queryObject The layer or feature layer view
- * @param defaultTimeExtent The time extent defined at the series config level or provided at runtime
+ *
+ * @param queryObject - The layer or feature layer view
+ * @param defaultTimeExtent - The time extent defined at the series config level or provided at runtime
  */
-export declare function getQueryTimeExtent(queryObject: QueryObject, defaultTimeExtent?: WebChartQuery["timeExtent"]): WebChartQuery["timeExtent"] | undefined;
+export function getQueryTimeExtent(queryObject: QueryObject, defaultTimeExtent?: WebChartQuery["timeExtent"]): WebChartQuery["timeExtent"] | undefined;
+
 /**
  * Computes the extent to be used by the query. We prioritize the feature layer view extent
  * over the series config extent, unless `ignoreViewExtent` is set to true.
- * @param props.queryObject The layer or feature layer view
- * @param props.defaultGeometry The geometry defined at the series config level or provided at runtime
- * @param props.ignoreViewExtent Whether to ignore the view's extent
+ *
+ * @param props - The layer or feature layer view
  */
-export declare function getQueryGeometry(props: {
+export function getQueryGeometry(props: {
     queryObject: QueryObject;
     defaultGeometry?: WebChartQuery["geometry"];
     ignoreViewExtent?: boolean;
 }): WebChartQuery["geometry"] | undefined;
+
 /**
  * Transforms a [timestamp, timestamp] to a JSAPI TimeExtent object
- * @param timeExtentConfig The time extent filter from the config
+ *
+ * @param timeExtentConfig - The time extent filter from the config
  */
-export declare function mapQueryTimeExtent(timeExtentConfig?: WebChartQuery["timeExtent"]): TimeExtent | undefined;
+export function mapQueryTimeExtent(timeExtentConfig?: WebChartQuery["timeExtent"]): TimeExtent | undefined;
+
 /**
  * Transforms a IGeometry to a JSAPI Geometry
- * @param geometryConfig The geometry from the config
+ *
+ * @param geometryConfig - The geometry from the config
  */
-export declare function mapQueryGeometry(geometryConfig?: WebChartQuery["geometry"]): Geometry | null | undefined;
-/**
- * Sanitizes an outFields array by:
- * - removing the duplicates
- * @param outFields The array to sanitize
- * @returns The sanitized array
- */
-declare function sanitizeOutFields(outFields?: string[]): string[];
+export function mapQueryGeometry(geometryConfig?: WebChartQuery["geometry"]): Geometry | null | undefined;
+
 /**
  * Maps properties from a WebChartQuery and properties specific to temporal binning into an AttributeBinsQuery object.
- * @param props.queryObject The layer or feature layer view
- * @param props.queryConfig The query configuration
- * @param props.temporalBinning The temporal binning configuration
- * @param props.dateField The date field to bin
- * @param props.splitByField The split-by field
+ *
+ * @param props - The layer or feature layer view
  */
-export declare function mapAttributeBinsQueryForTemporalData(props: {
+export function mapAttributeBinsQueryForTemporalData(props: {
     queryObject?: QueryObject;
     queryConfig?: WebChartQuery;
     temporalBinning: WebChartTemporalBinning;
     dateField: string;
     splitByField?: string;
 }): Promise<AttributeBinsQuery>;
+
 /**
  * Builds a SQL expression as well as the start and end values necessary for the calendar date parts binning.
- * @param props.field The field used by the heat chart
- * @param props.fieldType The field type
- * @param props.unit The unit of the temporal binning
- * @param props.addIntervalStatement Whether to add the interval statement to shift the date from the data time zone to the output time zone
- * @param props.outTimeZone The output time zone
- * @param props.dataTimeZone The data time zone
- * @param props.runsOnClientQueryEngine Whether the query will be executed on the client query engine (FeatureLayerView) or on the server
+ *
+ * @param props - The field used by the heat chart
  */
-export declare function getCalendarDatePartsParameters(props: {
+export function getCalendarDatePartsParameters(props: {
     field: string;
     fieldType?: RESTFieldType;
     unit?: string;
@@ -87,23 +89,19 @@ export declare function getCalendarDatePartsParameters(props: {
     outTimeZone?: string;
     dataTimeZone?: string | null;
     runsOnClientQueryEngine?: boolean;
+    addLeapDayExpression?: boolean;
 }): {
     expression?: string;
     start?: number;
     end?: number;
 };
+
 /**
  * Maps properties from a WebChartQuery and properties specific to heat chart into an AttributeBinsQuery object.
- * @param props.queryObject The layer or feature layer view
- * @param props.queryConfig The query configuration
- * @param props.x The x field
- * @param props.y The y field
- * @param props.xTemporalBinning The x temporal binning configuration
- * @param props.yTemporalBinning The y temporal binning configuration
- * @param props.firstDayOfWeek The first day of the week, used for date-based bins
- * @param props.outTimeZone The IANA time zone used for temporal bin calculations
+ *
+ * @param props - The layer or feature layer view
  */
-export declare function mapAttributeBinsQueryForHeatChart(props: {
+export function mapAttributeBinsQueryForHeatChart(props: {
     queryObject?: QueryObject;
     queryConfig?: WebChartQuery;
     x: string;
@@ -112,19 +110,15 @@ export declare function mapAttributeBinsQueryForHeatChart(props: {
     yTemporalBinning?: WebChartHeatChartSeries["yTemporalBinning"];
     firstDayOfWeek?: number;
     outTimeZone?: string;
+    includeLeapDay?: boolean;
 }): Promise<AttributeBinsQuery>;
+
 /**
  * Maps properties from a WebChartQuery and properties specific to temporal binning into an AttributeBinsQuery object.
- * @param props.queryObject The layer or feature layer view
- * @param props.queryConfig The query configuration
- * @param props.xStep The x step
- * @param props.yStep The y step
- * @param props.xMin The x min
- * @param props.xMax The x max
- * @param props.x The x field
- * @param props.y The y field
+ *
+ * @param props - The layer or feature layer view
  */
-export declare function mapAttributeBinsQueryForScatterplot(props: {
+export function mapAttributeBinsQueryForScatterplot(props: {
     queryObject?: QueryObject;
     queryConfig?: WebChartQuery;
     xStep: number;
@@ -134,19 +128,17 @@ export declare function mapAttributeBinsQueryForScatterplot(props: {
     x: string;
     y: string;
 }): AttributeBinsQuery;
+
 /**
  * Maps properties from a WebChartQuery into a Query object.
- * @param props.queryObject The layer or feature layer view
- * @param props.queryConfig The query configuration
- * @param props.maxRecordCountFactor When set, the maximum number of features returned by the query will equal the `maxRecordCount` of the service multiplied by this factor.
+ *
+ * @param props - The layer or feature layer view
  */
-export declare function mapQuery(props: {
+export function mapQuery(props: {
     queryObject?: QueryObject;
     queryConfig?: WebChartQuery;
     maxRecordCountFactor?: number;
 }): Query;
-export declare function getMaxRecordCountFactor(layer?: SupportedLayer): number | undefined;
-export declare const queryParserPrivateFunctions: {
-    sanitizeOutFields: typeof sanitizeOutFields;
-};
-export {};
+
+/** @param layer */
+export function getMaxRecordCountFactor(layer?: Pick<FeatureLayer, "sourceJSON"> | SubtypeSublayer): number | undefined;

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

@@ -1,39 +1,53 @@
-import { default as FeatureLayer } from '@arcgis/core/layers/FeatureLayer';
-import { default as SubtypeGroupLayer } from '@arcgis/core/layers/SubtypeGroupLayer';
-import { default as SubtypeSublayer } from '@arcgis/core/layers/support/SubtypeSublayer';
-import { default as FeatureLayerView } from '@arcgis/core/views/layers/FeatureLayerView.js';
-import { SupportedLayer, WebChart } from '../../../spec';
-import { QueryObject } from '../interfaces';
+import type FeatureLayer from "@arcgis/core/layers/FeatureLayer";
+import type SubtypeGroupLayer from "@arcgis/core/layers/SubtypeGroupLayer";
+import type SubtypeSublayer from "@arcgis/core/layers/support/SubtypeSublayer";
+import type FeatureLayerView from "@arcgis/core/views/layers/FeatureLayerView.js";
+import type { QueryObject } from "../interfaces.js";
+import type { SupportedLayer } from "../../../interfaces.js";
+import type { WebChart } from "../../../spec/web-chart.js";
+
 /**
  * Indicates whether the input object is a feature collection.
+ *
  * @param queryObject
  */
-export declare function isFeatureCollectionLayer(queryObject: QueryObject): queryObject is FeatureLayerView;
+export function isFeatureCollectionLayer(queryObject: QueryObject): queryObject is FeatureLayerView;
+
 /**
  * Indicates whether the input object is an instance of `FeatureLayerView`.
+ *
  * @param queryObject
  */
-export declare function isFeatureLayerView(queryObject: QueryObject | SubtypeGroupLayer): queryObject is FeatureLayerView;
+export function isFeatureLayerView(queryObject: QueryObject | SubtypeGroupLayer): queryObject is FeatureLayerView;
+
 /**
  * Indicates whether the input object is an instance of `FeatureLayer`.
+ *
  * @param queryObject
  */
-export declare function isFeatureLayer(queryObject: QueryObject): queryObject is FeatureLayer;
+export function isFeatureLayer(queryObject: QueryObject): queryObject is FeatureLayer;
+
 /**
  * Indicates whether the input object is an instance of `SubtypeGroupLayer`.
+ *
  * @param queryObject
  */
-export declare function isSubtypeGroupLayer(queryObject: QueryObject | SubtypeGroupLayer): queryObject is SubtypeGroupLayer;
+export function isSubtypeGroupLayer(queryObject: QueryObject | SubtypeGroupLayer): queryObject is SubtypeGroupLayer;
+
 /**
  * Indicates whether the input object is an instance of `SubtypeSublayer`.
+ *
  * @param queryObject
  */
-export declare function isSubtypeSublayer(queryObject: QueryObject): queryObject is SubtypeSublayer;
+export function isSubtypeSublayer(queryObject: Pick<SubtypeSublayer, "type"> | QueryObject): queryObject is SubtypeSublayer;
+
 /**
  * Indicates whether the input object is an instance of `SupportedLayer` (`FeatureLayer` or `SubtypeSublayer`).
+ *
  * @param queryObject
  */
-export declare function isSupportedLayer(queryObject: QueryObject): queryObject is SupportedLayer;
+export function isSupportedLayer(queryObject: QueryObject): queryObject is SupportedLayer;
+
 /**
  * Returns the main `Layer` instance associated with the layer being used.
  *
@@ -41,69 +55,92 @@ export declare function isSupportedLayer(queryObject: QueryObject): queryObject
  *
  * @param layer
  */
-export declare function getMainLayer(layer: SupportedLayer): FeatureLayer | SubtypeGroupLayer;
-export declare function getMainLayer(layer: SupportedLayer | undefined): FeatureLayer | SubtypeGroupLayer | null | undefined;
+export function getMainLayer(layer: FeatureLayer | Pick<SubtypeSublayer, "parent" | "type">): FeatureLayer | SubtypeGroupLayer;
+
+/** @param layer */
+export function getMainLayer(layer: FeatureLayer | Pick<SubtypeSublayer, "parent" | "type"> | undefined): FeatureLayer | SubtypeGroupLayer | null | undefined;
+
+/** @param layer */
+export function getMainLayer(layer: FeatureLayer | Pick<SubtypeSublayer, "parent" | "type"> | undefined): FeatureLayer | SubtypeGroupLayer | null | undefined;
+
 /**
  * Indicates whether a layer supports queries with a `distance` parameter
- * @param layer The layer to test
+ *
+ * @param layer - The layer to test
  * @returns A boolean
  */
-export declare function doesLayerSupportQueryWithDistance(layer: SupportedLayer): boolean;
+export function doesLayerSupportQueryWithDistance(layer: SupportedLayer): boolean;
+
 /**
  * Indicates whether a layer supports the queryBins operation for the heat chart use case.
- * @param layer The layer to test
+ *
+ * @param layer - The layer to test
+ * @param queryObject
  * @returns A boolean indicating whether the operation is supported
  */
-export declare function doesLayerSupportsQueryBinsForHeatChart(layer: SupportedLayer, queryObject: QueryObject): boolean;
+export function doesLayerSupportsQueryBinsForHeatChart(layer: SupportedLayer, queryObject: QueryObject): boolean;
+
 /**
  * Indicates whether a layer supports the queryBins operation for the temporal data use case.
  * We currently only use the "date" operation.
  * If a split-by field is provided we verify whether `stackBy` parameter is supported (refer to `mapAttributeBinsQuery()`).
- * @param layer The layer to test
- * @param splitByField The split-by field
+ *
+ * @param layer - The layer to test
+ * @param splitByField - The split-by field
  * @returns A boolean indicating whether the operation is supported
  */
-export declare function doesLayerSupportsQueryBinsForTemporalData(layer?: FeatureLayerView | SubtypeGroupLayer | SupportedLayer, splitByField?: string): boolean;
+export function doesLayerSupportsQueryBinsForTemporalData(layer?: FeatureLayerView | SubtypeGroupLayer | SupportedLayer, splitByField?: string): boolean;
+
 /**
  * Indicates whether the layer supports the cacheHint parameter for the queryBins operation
- * @param queryObject The layer or feature layer view
+ *
+ * @param queryObject - The layer or feature layer view
  */
-export declare function doesLayerSupportsCacheHintForQueryBins(queryObject: QueryObject): boolean;
+export function doesLayerSupportsCacheHintForQueryBins(queryObject: QueryObject): boolean;
+
 /**
  * Indicates whether the layer supports the query bins operation for scatterplot:
  * - supports queryBins
  * - supports the type `fixedIntervalBin`
  * - statistics: supports MAX and COUNT
- * @param queryObject The layer or feature layer view
+ *
+ * @param queryObject - The layer or feature layer view
  */
-export declare function doesLayerSupportsQueryBinsForScatterplot(queryObject: QueryObject): boolean;
+export function doesLayerSupportsQueryBinsForScatterplot(queryObject: QueryObject): boolean;
+
 /**
  * Returns a feature layer from a QueryObject instance.
  * It will use the QueryObject itself if it's a Feature Layer, or the `layer` property from it if it's a Feature Layer View.
- * @param queryObject
+ *
+ * @param layerOrLayerView
  */
-export declare function getLayerFromLayerOrLayerView(layerOrLayerView: FeatureLayerView | SupportedLayer): SupportedLayer;
+export function getLayerFromLayerOrLayerView(layerOrLayerView: FeatureLayerView | SupportedLayer): SupportedLayer;
+
 /**
  * Returns a feature layer from a QueryObject instance.
  * It will use the QueryObject itself if it's a Feature Layer, or the `layer` property from it if it's a Feature Layer View.
+ *
  * @param queryObject
  */
-export declare function getLayerFromQueryObject(queryObject: QueryObject): SupportedLayer;
+export function getLayerFromQueryObject(queryObject: QueryObject): SupportedLayer;
+
 /**
  * Computes a feature layer capabilities regarding its spatial aggregation statistics.
  * Only considers the 'EnvelopeAggregate' for now.
- * @param layer The layer instance
+ *
+ * @param layer - The layer instance
  * @returns A sum up of the capabilities
  */
-export declare function getLayerSpatialAggregationStatisticsCapabilities(layer: SupportedLayer): boolean;
+export function getLayerSpatialAggregationStatisticsCapabilities(layer: SupportedLayer): boolean;
+
 /**
  * Adds a iLayer to a WebChart.
  * If the `queryObject` prop is provided an `iLayer` is added to the config.
- * @param props.chartConfig The chart config with no iLayer
- * @param props.queryObject The layer or feature layer view instance. Its information are **not** used to create the iLayer.
+ *
+ * @param props - The chart config with no iLayer
  * @returns The update chart config with a `iLayer` property
  */
-export declare function addILayer<T extends WebChart>(props: {
+export function addILayer<T extends WebChart>(props: {
     chartConfig: T;
     queryObject?: FeatureLayerView | SupportedLayer;
-}): T & WebChart;
+}): T & WebChart;