@feltmaps/js-sdk 1.5.0-next.5 → 1.5.0-next.7

package/dist/{types-BKxKmuZn.d.cts → types-XLCA2cX-.d.cts}

@@ -378,7 +378,7 @@ declare const ImageCreateSchema: z.ZodObject<Omit<{
     attributes?: Record<string, unknown> | undefined;
     opacity?: number | undefined;
 }>;
-declare const PlaceReadSchema: z.ZodObject<Omit<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+declare const PlaceReadSchema: z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<{
     id: z.ZodString;
     groupId: z.ZodNullable<z.ZodString>;
     color: z.ZodString;
@@ -393,9 +393,10 @@ declare const PlaceReadSchema: z.ZodObject<Omit<z.objectUtil.extendShape<z.objec
     symbol: z.ZodString;
     frame: z.ZodNullable<z.ZodEnum<["frame-circle", "frame-square"]>>;
     hideLabel: z.ZodBoolean;
-}>, "coordinates">, "strip", z.ZodTypeAny, {
+}>, "strip", z.ZodTypeAny, {
     symbol: string;
     type: "Place";
+    coordinates: [number, number];
     id: string;
     groupId: string | null;
     color: string;
@@ -408,6 +409,7 @@ declare const PlaceReadSchema: z.ZodObject<Omit<z.objectUtil.extendShape<z.objec
 }, {
     symbol: string;
     type: "Place";
+    coordinates: [number, number];
     id: string;
     groupId: string | null;
     color: string;
@@ -515,7 +517,7 @@ declare const PolygonReadSchema: z.ZodObject<Omit<z.objectUtil.extendShape<z.obj
     fillOpacity: number;
     areaMarker: boolean;
 }>;
-declare const CircleReadSchema: z.ZodObject<Omit<z.objectUtil.extendShape<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+declare const CircleReadSchema: z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<z.objectUtil.extendShape<{
     id: z.ZodString;
     groupId: z.ZodNullable<z.ZodString>;
     color: z.ZodString;
@@ -536,8 +538,9 @@ declare const CircleReadSchema: z.ZodObject<Omit<z.objectUtil.extendShape<z.obje
     radiusDisplayUnit: z.ZodNullable<z.ZodEnum<["meter", "kilometer", "foot", "mile"]>>;
     fillOpacity: z.ZodNumber;
     radiusMarker: z.ZodBoolean;
-}>, "coordinates">, "strip", z.ZodTypeAny, {
+}>, "strip", z.ZodTypeAny, {
     type: "Circle";
+    coordinates: [number, number];
     id: string;
     groupId: string | null;
     color: string;
@@ -555,6 +558,7 @@ declare const CircleReadSchema: z.ZodObject<Omit<z.objectUtil.extendShape<z.obje
     radiusMarker: boolean;
 }, {
     type: "Circle";
+    coordinates: [number, number];
     id: string;
     groupId: string | null;
     color: string;
@@ -1317,7 +1321,7 @@ declare const GetElementGroupsConstraintSchema: z.ZodObject<{
     ids?: string[] | undefined;
 }>;
 /**
- * The parameters for the `onElementChange` listener.
+ * The parameters for the `onElementChange` and the `onElementCreate` listeners.
  *
  * @group Elements
  */
@@ -1326,6 +1330,22 @@ interface ElementChangeCallbackParams {
      * The new data for the element or null if the element was removed.
      */
     element: Element | null;
+    /**
+     * Whether or not this element is still being created by a drawing tool.
+     *
+     * For example, if the user begins drawing a polygon, they need to place
+     * multiple points until they've ultimately completed the polygon. All
+     * the time they are still placing points, this will be true.
+     *
+     * For elements that require text entry (such as Places, Text and Notes)
+     * this will be true all the time the user is typing text until the point
+     * at which the user finishes, by pressing Escape for example.
+     *
+     * If the user is editing an existing element, this will be false.
+     *
+     * For elements that are created programatically, this will be false.
+     */
+    isBeingCreated: boolean;
 }
 /**
  * The parameters for the `onElementGroupChange` listener.
@@ -1350,22 +1370,40 @@ interface LatLng {
  * GeoJSON.
  */
 type LngLatTuple = [longitude: number, latitude: number];
+interface PointGeometry extends zInfer<typeof PointGeometrySchema> {
+}
 /**
  * A GeoJSON point geometry.
  */
-type PointGeometry = {
+declare const PointGeometrySchema: z.ZodObject<{
+    type: z.ZodLiteral<"Point">;
+    coordinates: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+}, "strip", z.ZodTypeAny, {
     type: "Point";
-    coordinates: LngLatTuple;
-};
+    coordinates: [number, number];
+}, {
+    type: "Point";
+    coordinates: [number, number];
+}>;
+interface PolygonGeometry extends zInfer<typeof PolygonGeometrySchema> {
+}
 /**
  * A GeoJSON polygon geometry.
  */
-type PolygonGeometry = {
+declare const PolygonGeometrySchema: z.ZodObject<{
+    type: z.ZodLiteral<"Polygon">;
+    coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">;
+}, "strip", z.ZodTypeAny, {
     type: "Polygon";
-    coordinates: LngLatTuple[][];
-};
+    coordinates: [number, number][][];
+}, {
+    type: "Polygon";
+    coordinates: [number, number][][];
+}>;
 /**
  * A GeoJSON multi-polygon geometry.
+ *
+ * @interface
  */
 type MultiPolygonGeometry = {
     type: "MultiPolygon";
@@ -1373,6 +1411,8 @@ type MultiPolygonGeometry = {
 };
 /**
  * A GeoJSON line string geometry.
+ *
+ * @interface
  */
 type LineStringGeometry = {
     type: "LineString";
@@ -1380,6 +1420,8 @@ type LineStringGeometry = {
 };
 /**
  * A GeoJSON multi-line string geometry.
+ *
+ * @interface
  */
 type MultiLineStringGeometry = {
     type: "MultiLineString";
@@ -1442,6 +1484,40 @@ declare const SetVisibilityRequestSchema: z.ZodObject<{
     show?: string[] | undefined;
     hide?: string[] | undefined;
 }>;
+/**
+ * Specifies the direction to sort data in
+ *
+ * @group Types
+ */
+type SortDirection = z.infer<typeof SortDirectionSchema>;
+/** @ignore */
+declare const SortDirectionSchema: z.ZodEnum<["asc", "desc"]>;
+/**
+ * Configuration for sorting data by a specific attribute
+ *
+ * @group Types
+ */
+interface SortConfig extends zInfer<typeof SortConfigSchema> {
+}
+/** @ignore */
+declare const SortConfigSchema: z.ZodObject<{
+    /**
+     * The attribute to sort by. What this represents depends on the context.
+     * For instance, when sorting features in a data table, the attribute is
+     * the column to sort by.
+     */
+    attribute: z.ZodString;
+    /**
+     * The direction to sort in
+     */
+    direction: z.ZodEnum<["asc", "desc"]>;
+}, "strip", z.ZodTypeAny, {
+    attribute: string;
+    direction: "asc" | "desc";
+}, {
+    attribute: string;
+    direction: "asc" | "desc";
+}>;
 
 /**
  * A feature is a single geographical item in a layer.
@@ -1866,6 +1942,31 @@ declare const FilterLogicGateSchema: z.ZodEnum<["and", "or"]>;
 type FilterExpression = z.infer<typeof FilterExpressionSchema>;
 declare const FilterExpressionSchema: z.ZodUnion<[z.ZodTuple<[z.ZodUnion<[z.ZodString, z.ZodNull]>, z.ZodEnum<["in", "ni"]>, z.ZodUnion<[z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>, "many">, z.ZodNull]>], null>, z.ZodTuple<[z.ZodUnion<[z.ZodString, z.ZodNull]>, z.ZodEnum<["lt", "gt", "le", "ge", "eq", "ne", "cn", "nc", "is", "isnt"]>, z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>], null>]>;
 /**
+ * A `FilterTernary` is a tree structure for combining expressions with logical operators.
+ *
+ * When combining three or more conditions, you must use proper nesting rather than a flat list.
+ *
+ * @example
+ * ```typescript
+ * // A simple filter with a single condition
+ * const filter = [
+ *   ["AREA", "gt", 30_000],
+ *   "and",
+ *   ["COLOR", "eq", "red"]
+ * ]
+ *
+ * // A complex filter with multiple conditions
+ * const filter = [
+ *   ["AREA", "gt", 30_000],
+ *   "and",
+ *   [
+ *     ["COLOR", "eq", "red"],
+ *     "or",
+ *     ["TYPE", "eq", "residential"]
+ *   ]
+ * ]
+ * ```
+ *
  * @group Filters
  */
 type FilterTernary = [
@@ -1878,6 +1979,12 @@ type FilterTernary = [
  * Filters can be used to change which features in a layer are rendered. Filters can be
  * applied to a layer by the `setLayerFilters` method on the Felt controller.
  *
+ * Filters use a tree structure for combining expressions with logical operators, called a
+ * {@link FilterTernary}. When combining three or more conditions, you must use proper nesting
+ * rather than a flat list.
+ *
+ * See the examples below for the correct structure to use when building complex filters.
+ *
  * @remarks
  * The possible operators are:
  * - `lt`: Less than
@@ -1895,17 +2002,82 @@ type FilterTernary = [
  *
  * @example
  * ```typescript
- * // a simple filter
+ * // 1. Simple filter: single condition
  * felt.setLayerFilters({
  *   layerId: "layer-1",
  *   filters: ["AREA", "gt", 30_000],
  * });
  *
- * // compound filters can be constructed using boolean logic:
+ * // 2. Basic compound filter: two conditions with AND
  * felt.setLayerFilters({
  *   layerId: "layer-1",
- *   filters: [["AREA", "gt", 30_000], "and", ["COLOR", "eq", "red"]]
- * })
+ *   filters: [
+ *     ["AREA", "gt", 30_000],  // First condition
+ *     "and",                   // Logic operator
+ *     ["COLOR", "eq", "red"]   // Second condition
+ *   ]
+ * });
+ *
+ * // 3. Complex filter: three or more conditions require nesting
+ * // ⚠️ IMPORTANT: Filters use a tree structure, not a flat list
+ * felt.setLayerFilters({
+ *   layerId: "layer-1",
+ *   filters: [
+ *     ["AREA", "gt", 30_000],                // First condition
+ *     "and",                                 // First logic operator
+ *     [                                      // Nested group starts
+ *       ["COLOR", "eq", "red"],              //   Second condition
+ *       "and",                               //   Second logic operator
+ *       ["TYPE", "eq", "residential"]        //   Third condition
+ *     ]                                      // Nested group ends
+ *   ]
+ * });
+ *
+ * // 4. Even more complex: four conditions with proper nesting
+ * // Visual structure:
+ * //          AND
+ * //         /   \
+ * //    condition  AND
+ * //              /   \
+ * //        condition  AND
+ * //                  /   \
+ * //            condition  condition
+ * felt.setLayerFilters({
+ *   layerId: "layer-1",
+ *   filters: [
+ *     ["AREA", "gt", 30_000],                // First condition
+ *     "and",
+ *     [
+ *       ["COLOR", "eq", "red"],              // Second condition
+ *       "and",
+ *       [
+ *         ["TYPE", "eq", "residential"],     // Third condition
+ *         "and",
+ *         ["YEAR", "gt", 2000]               // Fourth condition
+ *       ]
+ *     ]
+ *   ]
+ * });
+ *
+ * // 5. Mixed operators: combining AND and OR
+ * // Visual structure:
+ * //          AND
+ * //         /   \
+ * //    condition  OR
+ * //              /  \
+ * //        condition condition
+ * felt.setLayerFilters({
+ *   layerId: "layer-1",
+ *   filters: [
+ *     ["AREA", "gt", 30_000],                // Must have large area
+ *     "and",
+ *     [
+ *       ["COLOR", "eq", "red"],              // Must be either red
+ *       "or",
+ *       ["TYPE", "eq", "residential"]        // OR residential type
+ *     ]
+ *   ]
+ * });
  * ```
  *
  * @group Filters
@@ -1945,6 +2117,582 @@ interface LayerFilters {
     combined: Filters;
 }
 
+declare const AggregateMethodSchema: z.ZodEnum<["avg", "max", "min", "sum", "median"]>;
+declare const AggregationConfigSchema: z.ZodObject<{
+    /**
+     * The operation to use on the values from the features in the layer
+     */
+    method: z.ZodEnum<["avg", "max", "min", "sum", "median"]>;
+    /**
+     * The attribute to use for the aggregation. This must be a numeric attribute.
+     */
+    attribute: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    attribute: string;
+    method: "avg" | "max" | "min" | "sum" | "median";
+}, {
+    attribute: string;
+    method: "avg" | "max" | "min" | "sum" | "median";
+}>;
+declare const MutliAggregationConfigSchema: z.ZodObject<{
+    /**
+     * The operations to use on the values from the features in the layer
+     */
+    methods: z.ZodArray<z.ZodUnion<[z.ZodEnum<["avg", "max", "min", "sum", "median"]>, z.ZodLiteral<"count">]>, "many">;
+    /**
+     * The attribute to use for the aggregation. This must be a numeric attribute.
+     */
+    attribute: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    methods: ("avg" | "max" | "min" | "sum" | "median" | "count")[];
+    attribute?: string | undefined;
+}, {
+    methods: ("avg" | "max" | "min" | "sum" | "median" | "count")[];
+    attribute?: string | undefined;
+}>;
+/**
+ * Defines how to aggregate a value across features in a layer.
+ */
+interface AggregationConfig extends zInfer<typeof AggregationConfigSchema> {
+    /**
+     * The method to use for the aggregation.
+     */
+    method: AggregationMethod;
+}
+/**
+ * The method to use for the aggregation.
+ */
+type AggregationMethod = z.infer<typeof AggregateMethodSchema>;
+/**
+ * Defines how to aggregate a value across features in a layer with multiple aggregations
+ * returned at once.
+ */
+interface MultiAggregationConfig<T extends AggregationMethod | "count"> extends zInfer<typeof MutliAggregationConfigSchema> {
+    methods: T[];
+    /**
+     * The attribute to use for the aggregation when aggregations other than "count" are used.
+     *
+     * This can be omitted if the only aggregation is "count", but must be a numeric attribute
+     * otherwise.
+     */
+    attribute?: string;
+}
+declare const ValueConfigurationSchema: z.ZodObject<{
+    boundary: z.ZodOptional<z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+        type: z.ZodLiteral<"Polygon">;
+        coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">;
+    }, "strip", z.ZodTypeAny, {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    }, {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    }>, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">]>>;
+    filters: z.ZodOptional<z.ZodUnion<[z.ZodType<FilterTernary, z.ZodTypeDef, FilterTernary>, z.ZodUnion<[z.ZodTuple<[z.ZodUnion<[z.ZodString, z.ZodNull]>, z.ZodEnum<["in", "ni"]>, z.ZodUnion<[z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>, "many">, z.ZodNull]>], null>, z.ZodTuple<[z.ZodUnion<[z.ZodString, z.ZodNull]>, z.ZodEnum<["lt", "gt", "le", "ge", "eq", "ne", "cn", "nc", "is", "isnt"]>, z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>], null>]>, z.ZodNull, z.ZodBoolean]>>;
+    aggregation: z.ZodOptional<z.ZodObject<{
+        /**
+         * The operation to use on the values from the features in the layer
+         */
+        method: z.ZodEnum<["avg", "max", "min", "sum", "median"]>;
+        /**
+         * The attribute to use for the aggregation. This must be a numeric attribute.
+         */
+        attribute: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        attribute: string;
+        method: "avg" | "max" | "min" | "sum" | "median";
+    }, {
+        attribute: string;
+        method: "avg" | "max" | "min" | "sum" | "median";
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    boundary?: [number, number][] | {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    } | [number, number, number, number] | undefined;
+    filters?: boolean | [string | null, "in" | "ni", (string | number | boolean | null)[] | null] | [string | null, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", string | number | boolean | null] | FilterTernary | null | undefined;
+    aggregation?: {
+        attribute: string;
+        method: "avg" | "max" | "min" | "sum" | "median";
+    } | undefined;
+}, {
+    boundary?: [number, number][] | {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    } | [number, number, number, number] | undefined;
+    filters?: boolean | [string | null, "in" | "ni", (string | number | boolean | null)[] | null] | [string | null, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", string | number | boolean | null] | FilterTernary | null | undefined;
+    aggregation?: {
+        attribute: string;
+        method: "avg" | "max" | "min" | "sum" | "median";
+    } | undefined;
+}>;
+/**
+ * Configuration for filtering and aggregating values across features.
+ *
+ * This can be used to restrict the features considered for aggregation via the `boundary`
+ * and `filters` properties.
+ *
+ * It can also be used to specify how to aggregate the values via the `aggregation` property.
+ */
+interface ValueConfiguration extends zInfer<typeof ValueConfigurationSchema> {
+    /**
+     * A spatial boundary to filter what gets counted or aggregated, while still including
+     * all possible categories or bin ranges in the results.
+     */
+    boundary?: PolygonGeometry | LngLatTuple[] | FeltBoundary;
+    /**
+     * Attribute filters to determine what gets counted or aggregated, while still including
+     * all possible categories or bin ranges in the results.
+     */
+    filters?: Filters;
+    /**
+     * Specifies how to aggregate values within each category or bin. When omitted,
+     * features are counted. When specified, the chosen calculation (avg, sum, etc.)
+     * is performed on the specified attribute.
+     *
+     * For example, instead of counting buildings in each category, you might want
+     * to sum their square footage or average their assessed values.
+     */
+    aggregation?: AggregationConfig;
+}
+declare const GetLayerCategoriesParamsSchema: z.ZodObject<{
+    /**
+     * The ID of the layer to get categories from.
+     */
+    layerId: z.ZodString;
+    /**
+     * The attribute to use for categorization.
+     */
+    attribute: z.ZodString;
+    /**
+     * The maximum number of categories to return.
+     */
+    limit: z.ZodOptional<z.ZodNumber>;
+    boundary: z.ZodOptional<z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+        type: z.ZodLiteral<"Polygon">;
+        coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">;
+    }, "strip", z.ZodTypeAny, {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    }, {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    }>, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">]>>;
+    filters: z.ZodOptional<z.ZodUnion<[z.ZodType<FilterTernary, z.ZodTypeDef, FilterTernary>, z.ZodUnion<[z.ZodTuple<[z.ZodUnion<[z.ZodString, z.ZodNull]>, z.ZodEnum<["in", "ni"]>, z.ZodUnion<[z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>, "many">, z.ZodNull]>], null>, z.ZodTuple<[z.ZodUnion<[z.ZodString, z.ZodNull]>, z.ZodEnum<["lt", "gt", "le", "ge", "eq", "ne", "cn", "nc", "is", "isnt"]>, z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>], null>]>, z.ZodNull, z.ZodBoolean]>>;
+    values: z.ZodOptional<z.ZodObject<{
+        boundary: z.ZodOptional<z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+            type: z.ZodLiteral<"Polygon">;
+            coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">;
+        }, "strip", z.ZodTypeAny, {
+            type: "Polygon";
+            coordinates: [number, number][][];
+        }, {
+            type: "Polygon";
+            coordinates: [number, number][][];
+        }>, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">]>>;
+        filters: z.ZodOptional<z.ZodUnion<[z.ZodType<FilterTernary, z.ZodTypeDef, FilterTernary>, z.ZodUnion<[z.ZodTuple<[z.ZodUnion<[z.ZodString, z.ZodNull]>, z.ZodEnum<["in", "ni"]>, z.ZodUnion<[z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>, "many">, z.ZodNull]>], null>, z.ZodTuple<[z.ZodUnion<[z.ZodString, z.ZodNull]>, z.ZodEnum<["lt", "gt", "le", "ge", "eq", "ne", "cn", "nc", "is", "isnt"]>, z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>], null>]>, z.ZodNull, z.ZodBoolean]>>;
+        aggregation: z.ZodOptional<z.ZodObject<{
+            /**
+             * The operation to use on the values from the features in the layer
+             */
+            method: z.ZodEnum<["avg", "max", "min", "sum", "median"]>;
+            /**
+             * The attribute to use for the aggregation. This must be a numeric attribute.
+             */
+            attribute: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            attribute: string;
+            method: "avg" | "max" | "min" | "sum" | "median";
+        }, {
+            attribute: string;
+            method: "avg" | "max" | "min" | "sum" | "median";
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        boundary?: [number, number][] | {
+            type: "Polygon";
+            coordinates: [number, number][][];
+        } | [number, number, number, number] | undefined;
+        filters?: boolean | [string | null, "in" | "ni", (string | number | boolean | null)[] | null] | [string | null, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", string | number | boolean | null] | FilterTernary | null | undefined;
+        aggregation?: {
+            attribute: string;
+            method: "avg" | "max" | "min" | "sum" | "median";
+        } | undefined;
+    }, {
+        boundary?: [number, number][] | {
+            type: "Polygon";
+            coordinates: [number, number][][];
+        } | [number, number, number, number] | undefined;
+        filters?: boolean | [string | null, "in" | "ni", (string | number | boolean | null)[] | null] | [string | null, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", string | number | boolean | null] | FilterTernary | null | undefined;
+        aggregation?: {
+            attribute: string;
+            method: "avg" | "max" | "min" | "sum" | "median";
+        } | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    attribute: string;
+    layerId: string;
+    values?: {
+        boundary?: [number, number][] | {
+            type: "Polygon";
+            coordinates: [number, number][][];
+        } | [number, number, number, number] | undefined;
+        filters?: boolean | [string | null, "in" | "ni", (string | number | boolean | null)[] | null] | [string | null, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", string | number | boolean | null] | FilterTernary | null | undefined;
+        aggregation?: {
+            attribute: string;
+            method: "avg" | "max" | "min" | "sum" | "median";
+        } | undefined;
+    } | undefined;
+    boundary?: [number, number][] | {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    } | [number, number, number, number] | undefined;
+    filters?: boolean | [string | null, "in" | "ni", (string | number | boolean | null)[] | null] | [string | null, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", string | number | boolean | null] | FilterTernary | null | undefined;
+    limit?: number | undefined;
+}, {
+    attribute: string;
+    layerId: string;
+    values?: {
+        boundary?: [number, number][] | {
+            type: "Polygon";
+            coordinates: [number, number][][];
+        } | [number, number, number, number] | undefined;
+        filters?: boolean | [string | null, "in" | "ni", (string | number | boolean | null)[] | null] | [string | null, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", string | number | boolean | null] | FilterTernary | null | undefined;
+        aggregation?: {
+            attribute: string;
+            method: "avg" | "max" | "min" | "sum" | "median";
+        } | undefined;
+    } | undefined;
+    boundary?: [number, number][] | {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    } | [number, number, number, number] | undefined;
+    filters?: boolean | [string | null, "in" | "ni", (string | number | boolean | null)[] | null] | [string | null, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", string | number | boolean | null] | FilterTernary | null | undefined;
+    limit?: number | undefined;
+}>;
+/**
+ * The parameters for getting categories from a layer, passed to
+ * the {@link LayersController.getCategoryData} method.
+ */
+interface GetLayerCategoriesParams extends zInfer<typeof GetLayerCategoriesParamsSchema> {
+    /**
+     * Attribute filters to determine what gets counted or aggregated.
+     */
+    filters?: Filters;
+    /**
+     * A spatial boundary to filter what gets counted or aggregated. This can be either
+     * a [w, s, e, n] bounding box, a GeoJSON Polygon geometry, or a list of coordinates
+     * that form a polyline.
+     */
+    boundary?: PolygonGeometry | LngLatTuple[] | FeltBoundary;
+    /**
+     * Configuration for filtering and aggregating values while preserving the full set of
+     * categories in the results.
+     *
+     * This is particularly useful when you want to compare different subsets of data while
+     * maintaining consistent categories. For example:
+     *
+     * - Show all building types in a city, but only count recent buildings in each type
+     * - Keep all neighborhood categories but only sum up residential square footage
+     *
+     * Unlike top-level filters which affect both what categories appear AND their values,
+     * filters in this configuration only affect the values while keeping all possible
+     * categories in the results.
+     */
+    values?: ValueConfiguration;
+}
+declare const GetLayerCategoriesGroupSchema: z.ZodObject<{
+    /**
+     * The category for which the value was calculated.
+     */
+    key: z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean]>;
+    /**
+     * The value calculated for the category, whether a count, sum, average, etc.
+     *
+     * `null` is returned if there are no features in the category as opposed to zero,
+     * so as not to confuse with a real zero value from some aggregation.
+     */
+    value: z.ZodNullable<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    value: number | null;
+    key: string | number | boolean;
+}, {
+    value: number | null;
+    key: string | number | boolean;
+}>;
+/**
+ * A single category from the response from the {@link LayersController.getCategoryData} method.
+ */
+interface GetLayerCategoriesGroup extends zInfer<typeof GetLayerCategoriesGroupSchema> {
+}
+declare const GetLayerHistogramParamsSchema: z.ZodObject<{
+    layerId: z.ZodString;
+    attribute: z.ZodString;
+    steps: z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"equal-intervals">;
+        count: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        type: "equal-intervals";
+        count: number;
+    }, {
+        type: "equal-intervals";
+        count: number;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"time-interval">;
+        interval: z.ZodEnum<["hour", "day", "week", "month", "year"]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "time-interval";
+        interval: "hour" | "day" | "week" | "month" | "year";
+    }, {
+        type: "time-interval";
+        interval: "hour" | "day" | "week" | "month" | "year";
+    }>, z.ZodArray<z.ZodNumber, "many">]>;
+    boundary: z.ZodOptional<z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+        type: z.ZodLiteral<"Polygon">;
+        coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">;
+    }, "strip", z.ZodTypeAny, {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    }, {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    }>, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">]>>;
+    filters: z.ZodOptional<z.ZodUnion<[z.ZodType<FilterTernary, z.ZodTypeDef, FilterTernary>, z.ZodUnion<[z.ZodTuple<[z.ZodUnion<[z.ZodString, z.ZodNull]>, z.ZodEnum<["in", "ni"]>, z.ZodUnion<[z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>, "many">, z.ZodNull]>], null>, z.ZodTuple<[z.ZodUnion<[z.ZodString, z.ZodNull]>, z.ZodEnum<["lt", "gt", "le", "ge", "eq", "ne", "cn", "nc", "is", "isnt"]>, z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>], null>]>, z.ZodNull, z.ZodBoolean]>>;
+    /**
+     * Configuration for filtering and aggregating values while preserving the full set of
+     * bin ranges in the results.
+     *
+     * This is particularly useful when you want to compare different subsets of data while
+     * maintaining consistent ranges. For example:
+     *
+     * - Use the same height ranges for comparing old vs new buildings
+     *
+     * Unlike top-level filters which affect both what ranges appear AND their values,
+     * filters in this configuration only affect the values while keeping all possible
+     * ranges in the results.
+     */
+    values: z.ZodOptional<z.ZodObject<{
+        boundary: z.ZodOptional<z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+            type: z.ZodLiteral<"Polygon">;
+            coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">;
+        }, "strip", z.ZodTypeAny, {
+            type: "Polygon";
+            coordinates: [number, number][][];
+        }, {
+            type: "Polygon";
+            coordinates: [number, number][][];
+        }>, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">]>>;
+        filters: z.ZodOptional<z.ZodUnion<[z.ZodType<FilterTernary, z.ZodTypeDef, FilterTernary>, z.ZodUnion<[z.ZodTuple<[z.ZodUnion<[z.ZodString, z.ZodNull]>, z.ZodEnum<["in", "ni"]>, z.ZodUnion<[z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>, "many">, z.ZodNull]>], null>, z.ZodTuple<[z.ZodUnion<[z.ZodString, z.ZodNull]>, z.ZodEnum<["lt", "gt", "le", "ge", "eq", "ne", "cn", "nc", "is", "isnt"]>, z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>], null>]>, z.ZodNull, z.ZodBoolean]>>;
+        aggregation: z.ZodOptional<z.ZodObject<{
+            /**
+             * The operation to use on the values from the features in the layer
+             */
+            method: z.ZodEnum<["avg", "max", "min", "sum", "median"]>;
+            /**
+             * The attribute to use for the aggregation. This must be a numeric attribute.
+             */
+            attribute: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            attribute: string;
+            method: "avg" | "max" | "min" | "sum" | "median";
+        }, {
+            attribute: string;
+            method: "avg" | "max" | "min" | "sum" | "median";
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        boundary?: [number, number][] | {
+            type: "Polygon";
+            coordinates: [number, number][][];
+        } | [number, number, number, number] | undefined;
+        filters?: boolean | [string | null, "in" | "ni", (string | number | boolean | null)[] | null] | [string | null, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", string | number | boolean | null] | FilterTernary | null | undefined;
+        aggregation?: {
+            attribute: string;
+            method: "avg" | "max" | "min" | "sum" | "median";
+        } | undefined;
+    }, {
+        boundary?: [number, number][] | {
+            type: "Polygon";
+            coordinates: [number, number][][];
+        } | [number, number, number, number] | undefined;
+        filters?: boolean | [string | null, "in" | "ni", (string | number | boolean | null)[] | null] | [string | null, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", string | number | boolean | null] | FilterTernary | null | undefined;
+        aggregation?: {
+            attribute: string;
+            method: "avg" | "max" | "min" | "sum" | "median";
+        } | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    attribute: string;
+    layerId: string;
+    steps: number[] | {
+        type: "equal-intervals";
+        count: number;
+    } | {
+        type: "time-interval";
+        interval: "hour" | "day" | "week" | "month" | "year";
+    };
+    values?: {
+        boundary?: [number, number][] | {
+            type: "Polygon";
+            coordinates: [number, number][][];
+        } | [number, number, number, number] | undefined;
+        filters?: boolean | [string | null, "in" | "ni", (string | number | boolean | null)[] | null] | [string | null, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", string | number | boolean | null] | FilterTernary | null | undefined;
+        aggregation?: {
+            attribute: string;
+            method: "avg" | "max" | "min" | "sum" | "median";
+        } | undefined;
+    } | undefined;
+    boundary?: [number, number][] | {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    } | [number, number, number, number] | undefined;
+    filters?: boolean | [string | null, "in" | "ni", (string | number | boolean | null)[] | null] | [string | null, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", string | number | boolean | null] | FilterTernary | null | undefined;
+}, {
+    attribute: string;
+    layerId: string;
+    steps: number[] | {
+        type: "equal-intervals";
+        count: number;
+    } | {
+        type: "time-interval";
+        interval: "hour" | "day" | "week" | "month" | "year";
+    };
+    values?: {
+        boundary?: [number, number][] | {
+            type: "Polygon";
+            coordinates: [number, number][][];
+        } | [number, number, number, number] | undefined;
+        filters?: boolean | [string | null, "in" | "ni", (string | number | boolean | null)[] | null] | [string | null, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", string | number | boolean | null] | FilterTernary | null | undefined;
+        aggregation?: {
+            attribute: string;
+            method: "avg" | "max" | "min" | "sum" | "median";
+        } | undefined;
+    } | undefined;
+    boundary?: [number, number][] | {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    } | [number, number, number, number] | undefined;
+    filters?: boolean | [string | null, "in" | "ni", (string | number | boolean | null)[] | null] | [string | null, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", string | number | boolean | null] | FilterTernary | null | undefined;
+}>;
+/**
+ * The params used to request a histogram of values from a layer, passed to
+ * the {@link LayersController.getHistogramData} method.
+ */
+interface GetLayerHistogramParams extends zInfer<typeof GetLayerHistogramParamsSchema> {
+    /**
+     * Attribute filters to determine what gets counted or aggregated.
+     */
+    filters?: Filters;
+    /**
+     * A spatial boundary to filter what gets counted or aggregated. This can be either
+     * a [w, s, e, n] bounding box, a GeoJSON Polygon geometry, or a list of coordinates
+     * that form a polyline.
+     */
+    boundary?: PolygonGeometry | LngLatTuple[] | FeltBoundary;
+}
+declare const GetLayerHistogramBinSchema: z.ZodObject<{
+    /**
+     * The left edge of the bin.
+     */
+    min: z.ZodNumber;
+    /**
+     * The right edge of the bin.
+     */
+    max: z.ZodNumber;
+    /**
+     * The number of features in the bin.
+     */
+    value: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    value: number;
+    max: number;
+    min: number;
+}, {
+    value: number;
+    max: number;
+    min: number;
+}>;
+/**
+ * One bin from the response from the {@link LayersController.getHistogramData} method.
+ */
+interface GetLayerHistogramBin extends zInfer<typeof GetLayerHistogramBinSchema> {
+}
+declare const GetLayerCalculationParamsSchema: z.ZodObject<{
+    /**
+     * The ID of the layer to calculate an aggregate value for.
+     */
+    layerId: z.ZodString;
+    boundary: z.ZodOptional<z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+        type: z.ZodLiteral<"Polygon">;
+        coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">;
+    }, "strip", z.ZodTypeAny, {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    }, {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    }>, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">]>>;
+    filters: z.ZodOptional<z.ZodUnion<[z.ZodType<FilterTernary, z.ZodTypeDef, FilterTernary>, z.ZodUnion<[z.ZodTuple<[z.ZodUnion<[z.ZodString, z.ZodNull]>, z.ZodEnum<["in", "ni"]>, z.ZodUnion<[z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>, "many">, z.ZodNull]>], null>, z.ZodTuple<[z.ZodUnion<[z.ZodString, z.ZodNull]>, z.ZodEnum<["lt", "gt", "le", "ge", "eq", "ne", "cn", "nc", "is", "isnt"]>, z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>], null>]>, z.ZodNull, z.ZodBoolean]>>;
+    aggregation: z.ZodObject<{
+        /**
+         * The operations to use on the values from the features in the layer
+         */
+        methods: z.ZodArray<z.ZodUnion<[z.ZodEnum<["avg", "max", "min", "sum", "median"]>, z.ZodLiteral<"count">]>, "many">;
+        /**
+         * The attribute to use for the aggregation. This must be a numeric attribute.
+         */
+        attribute: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        methods: ("avg" | "max" | "min" | "sum" | "median" | "count")[];
+        attribute?: string | undefined;
+    }, {
+        methods: ("avg" | "max" | "min" | "sum" | "median" | "count")[];
+        attribute?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    layerId: string;
+    aggregation: {
+        methods: ("avg" | "max" | "min" | "sum" | "median" | "count")[];
+        attribute?: string | undefined;
+    };
+    boundary?: [number, number][] | {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    } | [number, number, number, number] | undefined;
+    filters?: boolean | [string | null, "in" | "ni", (string | number | boolean | null)[] | null] | [string | null, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", string | number | boolean | null] | FilterTernary | null | undefined;
+}, {
+    layerId: string;
+    aggregation: {
+        methods: ("avg" | "max" | "min" | "sum" | "median" | "count")[];
+        attribute?: string | undefined;
+    };
+    boundary?: [number, number][] | {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    } | [number, number, number, number] | undefined;
+    filters?: boolean | [string | null, "in" | "ni", (string | number | boolean | null)[] | null] | [string | null, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", string | number | boolean | null] | FilterTernary | null | undefined;
+}>;
+/**
+ * The parameters for calculating a single aggregate value for a layer, passed to
+ * the {@link LayersController.getAggregates} method.
+ */
+interface GetLayerCalculationParams<T extends AggregationMethod | "count"> extends z.infer<typeof GetLayerCalculationParamsSchema> {
+    /**
+     * Attribute filters to determine what gets counted or aggregated.
+     */
+    filters?: Filters;
+    /**
+     * A spatial boundary to filter what gets counted or aggregated. This can be either
+     * a [w, s, e, n] bounding box, a GeoJSON Polygon geometry, or a list of coordinates
+     * that form a polyline.
+     */
+    boundary?: PolygonGeometry | LngLatTuple[] | FeltBoundary;
+    /**
+     * Specifies how to aggregate values within each category or bin. When omitted,
+     * features are counted. When specified, the chosen calculation (avg, sum, etc.)
+     * is performed on the specified attribute.
+     */
+    aggregation: MultiAggregationConfig<T>;
+}
+
 /**
  * The event object passed to the interaction listeners.
  */
@@ -2446,4 +3194,4 @@ declare const ViewportFitBoundsParamsSchema: z.ZodObject<{
     bounds: [number, number, number, number];
 }>;
 
-export type { NoteElementRead as $, ViewportConstraints as A, ViewportFitBoundsParams as B, ConfigurableToolType as C, ViewportCenterZoom as D, Element as E, Filters as F, Geometry as G, CircleElementCreate as H, InputToolSettings as I, CircleElementRead as J, CircleElementUpdate as K, Layer as L, MapInteractionEvent as M, HighlighterElementCreate as N, HighlighterElementRead as O, HighlighterElementUpdate as P, ImageElementCreate as Q, ImageElementRead as R, SetVisibilityRequest as S, ToolType as T, ImageElementUpdate as U, ViewportState as V, LinkElementRead as W, MarkerElementCreate as X, MarkerElementRead as Y, MarkerElementUpdate as Z, NoteElementCreate as _, GetElementsConstraint as a, NoteElementUpdate as a0, PathElementCreate as a1, PathElementRead as a2, PathElementUpdate as a3, PlaceElementCreate as a4, PlaceElementRead as a5, PlaceElementUpdate as a6, PolygonElementCreate as a7, PolygonElementRead as a8, PolygonElementUpdate as a9, NoteToolSettings as aA, PinToolSettings as aB, PlaceFrame as aC, PlaceSymbol as aD, PolygonToolSettings as aE, RouteToolSettings as aF, TextToolSettings as aG, UnionToIntersection as aH, PromiseOrNot as aI, TextElementCreate as aa, TextElementRead as ab, TextElementUpdate as ac, LayerProcessingStatus as ad, RasterValue as ae, FilterExpression as af, FilterLogicGate as ag, FilterTernary as ah, ElementGroupNode as ai, ElementNode as aj, FeatureNode as ak, LayerGroupNode as al, LayerNode as am, FeltBoundary as an, FeltZoom as ao, LatLng as ap, LineStringGeometry as aq, LngLatTuple as ar, MultiLineStringGeometry as as, MultiPolygonGeometry as at, PointGeometry as au, PolygonGeometry as av, CircleToolSettings as aw, HighlighterToolSettings as ax, LineToolSettings as ay, MarkerToolSettings as az, ElementGroup as b, GetElementGroupsConstraint as c, ElementChangeCallbackParams as d, ElementGroupChangeCallbackParams as e, ElementCreate as f, ElementUpdate as g, GetLayersConstraint as h, LayerChangeCallbackParams as i, LayerGroup as j, GetLayerGroupsConstraint as k, LayerGroupChangeCallbackParams as l, LegendItemIdentifier as m, LegendItem as n, LegendItemsConstraint as o, LegendItemChangeCallbackParams as p, LayerFilters as q, GetRenderedFeaturesConstraint as r, Feature as s, MapDetails as t, EntityNode as u, FeatureSelection as v, ToolSettingsMap as w, ToolSettingsChangeEvent as x, SetViewportCenterZoomParams as y, zInfer as z };
+export type { ImageElementRead as $, AggregationMethod as A, FeatureSelection as B, ConfigurableToolType as C, ToolSettingsMap as D, Element as E, Filters as F, Geometry as G, ToolSettingsChangeEvent as H, InputToolSettings as I, zInfer as J, SortConfig as K, Layer as L, MapInteractionEvent as M, SetViewportCenterZoomParams as N, ViewportConstraints as O, ViewportFitBoundsParams as P, ViewportCenterZoom as Q, CircleElementCreate as R, SetVisibilityRequest as S, ToolType as T, CircleElementRead as U, ViewportState as V, CircleElementUpdate as W, HighlighterElementCreate as X, HighlighterElementRead as Y, HighlighterElementUpdate as Z, ImageElementCreate as _, GetElementsConstraint as a, ImageElementUpdate as a0, LinkElementRead as a1, MarkerElementCreate as a2, MarkerElementRead as a3, MarkerElementUpdate as a4, NoteElementCreate as a5, NoteElementRead as a6, NoteElementUpdate as a7, PathElementCreate as a8, PathElementRead as a9, LineStringGeometry as aA, LngLatTuple as aB, MultiLineStringGeometry as aC, MultiPolygonGeometry as aD, PointGeometry as aE, PolygonGeometry as aF, SortDirection as aG, CircleToolSettings as aH, HighlighterToolSettings as aI, LineToolSettings as aJ, MarkerToolSettings as aK, NoteToolSettings as aL, PinToolSettings as aM, PlaceFrame as aN, PlaceSymbol as aO, PolygonToolSettings as aP, RouteToolSettings as aQ, TextToolSettings as aR, UnionToIntersection as aS, PromiseOrNot as aT, PathElementUpdate as aa, PlaceElementCreate as ab, PlaceElementRead as ac, PlaceElementUpdate as ad, PolygonElementCreate as ae, PolygonElementRead as af, PolygonElementUpdate as ag, TextElementCreate as ah, TextElementRead as ai, TextElementUpdate as aj, LayerProcessingStatus as ak, RasterValue as al, FilterExpression as am, FilterLogicGate as an, FilterTernary as ao, AggregationConfig as ap, MultiAggregationConfig as aq, ValueConfiguration as ar, ElementGroupNode as as, ElementNode as at, FeatureNode as au, LayerGroupNode as av, LayerNode as aw, FeltBoundary as ax, FeltZoom as ay, LatLng as az, ElementGroup as b, GetElementGroupsConstraint as c, ElementChangeCallbackParams as d, ElementGroupChangeCallbackParams as e, ElementCreate as f, ElementUpdate as g, GetLayersConstraint as h, LayerChangeCallbackParams as i, LayerGroup as j, GetLayerGroupsConstraint as k, LayerGroupChangeCallbackParams as l, LegendItemIdentifier as m, LegendItem as n, LegendItemsConstraint as o, LegendItemChangeCallbackParams as p, LayerFilters as q, GetRenderedFeaturesConstraint as r, Feature as s, GetLayerCategoriesParams as t, GetLayerCategoriesGroup as u, GetLayerHistogramParams as v, GetLayerHistogramBin as w, GetLayerCalculationParams as x, MapDetails as y, EntityNode as z };