@feltmaps/js-sdk 1.5.1 → 1.6.0-next.0

package/dist/{types-CnYUajGG.d.cts → types-B241Rd9q.d.cts}

@@ -13,6 +13,7 @@ type PromiseOrNot<T> = T | Promise<T>;
 type zInfer<T extends {
     shape: ZodRawShape;
 }> = objectOutputType<T["shape"], ZodTypeAny, "strip">;
+type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
 
 /**
  * Represents a point in world coordinates.
@@ -4146,6 +4147,8 @@ interface ElementGroupChangeCallbackParams {
  *
  * The geometry can be obtained via the {@link FeltController.getGeoJsonFeature}
  * method, which returns a {@link GeoJsonFeature} object.
+ *
+ * @group Features
  */
 interface LayerFeature {
     /**
@@ -4159,7 +4162,7 @@ interface LayerFeature {
     /**
      * The type of geometry of the feature.
      *
-     * @remarks Because LayerFeatures are read from tiled features, it's
+     * @remarks Because LayerFeatures can be read from tiled features, it's
      * possible that this `geometryType` won't match the `geometry.type` of the
      * {@link GeoJsonFeature} returned by {@link FeltController.getGeoJsonFeature}.
      *
@@ -4169,6 +4172,14 @@ interface LayerFeature {
      * As a result, you should treat this property as being indicative only.
      */
     geometryType: GeoJsonGeometry["type"] | (string & {});
+    /**
+     * The bounding box of the feature.
+     *
+     * @remarks Because LayerFeatures can be read from tiled features and considering
+     * that feature geometry can go through multiple tiles, it's possible that this
+     * is not the complete bounding box of the feature.
+     */
+    bbox: FeltBoundary | undefined;
     /**
      * The properties of the feature, as a bag of attributes.
      */
@@ -4177,9 +4188,9 @@ interface LayerFeature {
 /**
  * A raster pixel value for a specific layer.
  *
- * @interface
+ * @group Features
  */
-type RasterValue = {
+interface RasterValue {
     /**
      * The value of the pixel.
      */
@@ -4201,7 +4212,7 @@ type RasterValue = {
         b: number;
         a: number;
     };
-};
+}
 
 /**
  * This describes the processing status of a layer.
@@ -5190,6 +5201,11 @@ declare const CreateLayersFromGeoJsonSchema: z.ZodObject<{
         Line?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
     } | undefined;
 }>;
+/**
+ * The parameters for the {@link LayersController.createLayersFromGeoJson} method.
+ *
+ * @group Layers
+ */
 interface CreateLayersFromGeoJsonParams extends Omit<zInfer<typeof CreateLayersFromGeoJsonSchema>, "source" | "geometryStyles"> {
     /**
      * The source of the GeoJSON data.
@@ -5415,6 +5431,18 @@ interface LayerFilters {
      */
     combined: Filters;
 }
+/**
+ * The common type for filtering data by a spatial boundary.
+ *
+ * This can be either:
+ * - `FeltBoundary`: a [w, s, e, n] bounding box
+ * - `PolygonGeometry`: a GeoJSON Polygon geometry
+ * - `MultiPolygonGeometry`: a GeoJSON MultiPolygon geometry
+ * - `LngLatTuple[]`: a list of coordinates describing a single ring of a polygon
+ *
+ * @group Filters
+ */
+type GeometryFilter = FeltBoundary | PolygonGeometry | MultiPolygonGeometry | LngLatTuple[];
 
 declare const AggregateMethodSchema: z.ZodEnum<["avg", "max", "min", "sum", "median"]>;
 declare const AggregationConfigSchema: z.ZodObject<{
@@ -5451,6 +5479,8 @@ declare const MutliAggregationConfigSchema: z.ZodObject<{
 }>;
 /**
  * Defines how to aggregate a value across features in a layer.
+ *
+ * @group Stats
  */
 interface AggregationConfig extends zInfer<typeof AggregationConfigSchema> {
     /**
@@ -5460,11 +5490,15 @@ interface AggregationConfig extends zInfer<typeof AggregationConfigSchema> {
 }
 /**
  * The method to use for the aggregation.
+ *
+ * @group Stats
  */
 type AggregationMethod = z.infer<typeof AggregateMethodSchema>;
 /**
  * Defines how to aggregate a value across features in a layer with multiple aggregations
  * returned at once.
+ *
+ * @group Stats
  */
 interface MultiAggregationConfig<T extends AggregationMethod | "count"> extends zInfer<typeof MutliAggregationConfigSchema> {
     methods: T[];
@@ -5476,16 +5510,6 @@ interface MultiAggregationConfig<T extends AggregationMethod | "count"> extends
      */
     attribute?: string;
 }
-/**
- * The common type for filtering data by a spatial boundary.
- *
- * This can be either:
- * - `FeltBoundary`: a [w, s, e, n] bounding box
- * - `PolygonGeometry`: a GeoJSON Polygon geometry
- * - `MultiPolygonGeometry`: a GeoJSON MultiPolygon geometry
- * - `LngLatTuple[]`: a list of coordinates describing a single ring of a polygon
- */
-type GeometryFilter = FeltBoundary | PolygonGeometry | MultiPolygonGeometry | LngLatTuple[];
 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">;
@@ -5557,6 +5581,8 @@ declare const ValueConfigurationSchema: z.ZodObject<{
  * and `filters` properties.
  *
  * It can also be used to specify how to aggregate the values via the `aggregation` property.
+ *
+ * @group Stats
  */
 interface ValueConfiguration extends zInfer<typeof ValueConfigurationSchema> {
     /**
@@ -5730,6 +5756,8 @@ declare const GetLayerCategoriesParamsSchema: z.ZodObject<{
 /**
  * The parameters for getting categories from a layer, passed to
  * the {@link LayersController.getCategoryData} method.
+ *
+ * @group Stats
  */
 interface GetLayerCategoriesParams extends zInfer<typeof GetLayerCategoriesParamsSchema> {
     /**
@@ -5777,6 +5805,8 @@ declare const GetLayerCategoriesGroupSchema: z.ZodObject<{
 }>;
 /**
  * A single category from the response from the {@link LayersController.getCategoryData} method.
+ *
+ * @group Stats
  */
 interface GetLayerCategoriesGroup extends zInfer<typeof GetLayerCategoriesGroupSchema> {
 }
@@ -5967,6 +5997,8 @@ declare const GetLayerHistogramParamsSchema: z.ZodObject<{
 /**
  * The params used to request a histogram of values from a layer, passed to
  * the {@link LayersController.getHistogramData} method.
+ *
+ * @group Stats
  */
 interface GetLayerHistogramParams extends zInfer<typeof GetLayerHistogramParamsSchema> {
     /**
@@ -6002,6 +6034,8 @@ declare const GetLayerHistogramBinSchema: z.ZodObject<{
 }>;
 /**
  * One bin from the response from the {@link LayersController.getHistogramData} method.
+ *
+ * @group Stats
  */
 interface GetLayerHistogramBin extends zInfer<typeof GetLayerHistogramBinSchema> {
 }
@@ -6078,6 +6112,8 @@ declare const GetLayerCalculationParamsSchema: z.ZodObject<{
 /**
  * The parameters for calculating a single aggregate value for a layer, passed to
  * the {@link LayersController.getAggregates} method.
+ *
+ * @group Stats
  */
 interface GetLayerCalculationParams<T extends AggregationMethod | "count"> extends z.infer<typeof GetLayerCalculationParamsSchema> {
     /**
@@ -6096,6 +6132,708 @@ interface GetLayerCalculationParams<T extends AggregationMethod | "count"> exten
     aggregation: MultiAggregationConfig<T>;
 }
 
+/**
+ * The Layers controller allows you to get information about the layers on the
+ * map, and make changes to their visibility.
+ *
+ * Layers can be organised into groups, and their groups can also have their
+ * visibility toggled.
+ *
+ * @group Controller
+ * @public
+ */
+interface LayersController {
+    /**
+     * Get a single layer from the map by its id.
+     *
+     * @example
+     * ```typescript
+     * const layer = await felt.getLayer("layer-1");
+     * ```
+     * @returns The requested layer.
+     */
+    getLayer(
+    /**
+     * The id of the layer you want to get.
+     */
+    id: string): Promise<Layer | null>;
+    /**
+     * Gets layers from the map, according to the constraints supplied. If no
+     * constraints are supplied, all layers will be returned.
+     *
+     * @remarks The layers in the map, ordered by the order specified in Felt. This is not
+     * necessarily the order that they are drawn in, as Felt draws points above
+     * lines and lines above polygons, for instance.
+     *
+     * @example
+     * ```typescript
+     * const layers = await felt.getLayers();
+     * ```
+     * @returns All layers on the map.
+     */
+    getLayers(
+    /**
+     * The constraints to apply to the layers returned from the map.
+     */
+    constraint?: GetLayersConstraint): Promise<Array<Layer | null>>;
+    /**
+     * Hide or show layers with the given ids.
+     *
+     * @example
+     * ```typescript
+     * felt.setLayerVisibility({ show: ["layer-1", "layer-2"], hide: ["layer-3"] });
+     * ```
+     */
+    setLayerVisibility(visibility: SetVisibilityRequest): Promise<void>;
+    /**
+     * Set the style for a layer using FSL, the Felt Style Language.
+     *
+     * Changes are only for this session, and not persisted. This is useful to make
+     * temporary changes to a layer's style, such as to highlight a particular layer
+     * or feature.
+     *
+     * See the [FSL documentation](https://developers.felt.com/felt-style-language) for details
+     * on how to read and write styles.
+     *
+     * If the style you set is invalid, you will receive an error explaining the problem
+     * in the rejected promise value.
+     *
+     * @example
+     * ```typescript
+     * // first get the current style
+     * const oldStyle = (await felt.getLayer("layer-1")).style;
+     *
+     * felt.setLayerStyle({ id: "layer-1", style: {
+     *   ...oldStyle,
+     *   paint: {
+     *     ...oldStyle.paint,
+     *     color: "red",
+     *   },
+     * } });
+     * ```
+     */
+    setLayerStyle(params: {
+        /**
+         * The id of the layer to set the style for.
+         */
+        id: string;
+        /**
+         * The style to set for the layer.
+         */
+        style: object;
+    }): Promise<void>;
+    /**
+     * Hide or show layers with the given ids from the legend.
+     *
+     * @example
+     * ```typescript
+     * felt.setLayerLegendVisibility({ show: ["layer-1", "layer-2"], hide: ["layer-3"] });
+     * ```
+     */
+    setLayerLegendVisibility(params: SetVisibilityRequest): Promise<void>;
+    /**
+     * Adds a listener for when a layer changes.
+     *
+     * @returns A function to unsubscribe from the listener
+     *
+     * @event
+     * @example
+     * ```typescript
+     * const unsubscribe = felt.onLayerChange({
+     *   options: { id: "layer-1" },
+     *   handler: ({layer}) => console.log(layer.bounds),
+     * });
+     *
+     * // later on...
+     * unsubscribe();
+     * ```
+     */
+    onLayerChange(args: {
+        options: {
+            /**
+             * The id of the layer to listen for changes to.
+             */
+            id: string;
+        };
+        /**
+         * The handler that is called when the layer changes.
+         */
+        handler: (
+        /**
+         * An object describing the change that occurred.
+         */
+        change: LayerChangeCallbackParams) => void;
+    }): VoidFunction;
+    /**
+     * Adds layers to the map from file or URL sources.
+     *
+     * @remarks This allows you to add temporary layers to the map that don't depend on
+     * any processing by Felt. This is useful for viewing data from external sources or
+     * remote files.
+     *
+     * @returns The layer groups that were created.
+     *
+     * @example
+     * ```typescript
+     * const layerFromFile = await felt.createLayersFromGeoJson({
+     *   source: {
+     *     type: "geoJsonFile",
+     *     file: someFile,
+     *   },
+     *   name: "Parcels",
+     * });
+     *
+     * const layerFromUrl = await felt.createLayersFromGeoJson({
+     *   source: {
+     *     sourceType: "geoJsonUrl",
+     *     url: "https://example.com/parcels.geojson",
+     *   },
+     *   name: "Parcels",
+     * ```
+     */
+    createLayersFromGeoJson(params: CreateLayersFromGeoJsonParams): Promise<{
+        /**
+         * The layer group that was created containing the created layers.
+         */
+        layerGroup: LayerGroup;
+        /**
+         * The layers that were created from the source.
+         */
+        layers: Array<Layer>;
+    } | null>;
+    /**
+     * Update a layer by passing a subset of the layer's properties.
+     *
+     * Note that not all properties can be updated, so check the {@link UpdateLayerParams}
+     * type to see which properties can be updated.
+     *
+     * @example
+     * ```typescript
+     * await felt.updateLayer({
+     *   id: "layer-1",
+     *   name: "My Layer",
+     *   caption: "A description of the layer",
+     * });
+     * ```
+     */
+    updateLayer(params: UpdateLayerParams): Promise<Layer>;
+    /**
+     * Delete a layer from the map by its id.
+     *
+     * @remarks This only works for layers created via the SDK `createLayersFromGeoJson` method, not layers added via the Felt UI.
+     *
+     * @example
+     * ```typescript
+     * await felt.deleteLayer("layer-1");
+     * ```
+     */
+    deleteLayer(id: string): Promise<void>;
+    /**
+     * Get a layer group from the map by its id.
+     *
+     * @example
+     * ```typescript
+     * const layerGroup = await felt.getLayerGroup("layer-group-1");
+     * ```
+     * @returns The requested layer group.
+     */
+    getLayerGroup(id: string): Promise<LayerGroup | null>;
+    /**
+     * Gets layer groups from the map, according to the constraints supplied. If no
+     * constraints are supplied, all layer groups will be returned in rendering order.
+     *
+     * @example
+     * ```typescript
+     * const layerGroups = await felt.getLayerGroups({ ids: ["layer-group-1", "layer-group-2"] });
+     * ```
+     * @returns The requested layer groups.
+     */
+    getLayerGroups(
+    /**
+     * The constraints to apply to the layer groups returned from the map.
+     */
+    constraint?: GetLayerGroupsConstraint): Promise<Array<LayerGroup | null>>;
+    /**
+     * Hide or show layer groups with the given ids.
+     *
+     * @example
+     * ```typescript
+     * felt.setLayerGroupVisibility({ show: ["layer-group-1", "layer-group-2"], hide: ["layer-group-3"] });
+     * ```
+     */
+    setLayerGroupVisibility(visibility: SetVisibilityRequest): Promise<void>;
+    /**
+     * Hide or show layer groups with the given ids from the legend.
+     *
+     * @example
+     * ```typescript
+     * felt.setLayerGroupLegendVisibility({ show: ["layer-1", "layer-2"], hide: ["layer-3"] });
+     * ```
+     */
+    setLayerGroupLegendVisibility(params: SetVisibilityRequest): Promise<void>;
+    /**
+     * Adds a listener for when a layer group changes.
+     *
+     * @returns A function to unsubscribe from the listener
+     *
+     * @event
+     * @example
+     * ```typescript
+     * const unsubscribe = felt.onLayerGroupChange({
+     *   options: { id: "layer-group-1" },
+     *   handler: ({layerGroup}) => console.log(layerGroup.id),
+     * });
+     *
+     * // later on...
+     * unsubscribe();
+     * ```
+     */
+    onLayerGroupChange(args: {
+        options: {
+            id: string;
+        };
+        handler: (change: LayerGroupChangeCallbackParams) => void;
+    }): VoidFunction;
+    /**
+     * Allows you to get the state of a single legend item.
+     *
+     * @example
+     * ```typescript
+     * const legendItem = await felt.getLegendItem({
+     *   id: "legend-item-1",
+     *   layerId: "layer-1",
+     * })
+     * ```
+     */
+    getLegendItem(id: LegendItemIdentifier): Promise<LegendItem | null>;
+    /**
+     * Allows you to obtain the state of several legend items, by passing in
+     * constraints describing which legend items you want.
+     *
+     * If you do not pass any constraints, you will receive all legend items.
+     *
+     * @example
+     * ```typescript
+     * const legendItems = await felt.getLegendItems({layerId: "layer-1"});
+     * ```
+     */
+    getLegendItems(constraint?: LegendItemsConstraint): Promise<Array<LegendItem | null>>;
+    /**
+     * Hide or show legend items with the given identifiers.
+     *
+     * @example
+     * ```typescript
+     * felt.setLegendItemVisibility({
+     *   show: [{layerId: "layer-group-1", id: "item-1-0"}],
+     *   hide: [{layerId: "layer-group-2", id: "item-2-0"}],
+     * })
+     * ```
+     */
+    setLegendItemVisibility(visibility: {
+        show?: Array<LegendItemIdentifier>;
+        hide?: Array<LegendItemIdentifier>;
+    }): Promise<void>;
+    /**
+     * Adds a listener for when a legend item changes.
+     *
+     * @returns A function to unsubscribe from the listener
+     *
+     * @event
+     * @example
+     * ```typescript
+     * const unsubscribe = felt.onLegendItemChange({
+     *   options: { layerId: "layer-1", id: "item-1-0" },
+     *   handler: ({legendItem}) => console.log(legendItem.visible),
+     * });
+     *
+     * // later on...
+     * unsubscribe();
+     * ```
+     */
+    onLegendItemChange(args: {
+        options: LegendItemIdentifier;
+        handler: (change: LegendItemChangeCallbackParams) => void;
+    }): VoidFunction;
+    /**
+     * Get the filters for a layer.
+     *
+     * @remarks
+     * The return type gives you the filters split up into the various sources
+     * that make up the overall filters for a layer.
+     *
+     * @example
+     * ```typescript
+     * const filters = await felt.getLayerFilters("layer-1");
+     * console.log(filters.combined, filters.style, filters.ephemeral, filters.components);
+     * ```
+     */
+    getLayerFilters(layerId: string): Promise<LayerFilters | null>;
+    /**
+     * Sets the **ephemeral** filters for a layer.
+     *
+     * @example
+     * ```typescript
+     * await felt.setLayerFilters({
+     *   layerId: "layer-1",
+     *   filters: ["AREA", "gt", 30_000],
+     * });
+     * ```
+     */
+    setLayerFilters(params: {
+        /**
+         * The layer that you want to set the filters for.
+         */
+        layerId: string;
+        /**
+         * The filters to set for the layer. This will replace any ephemeral filters
+         * that are currently set for the layer.
+         */
+        filters: Filters;
+        /**
+         * A note to display on the layer legend when this filter is applied. When the
+         * note is shown, a reset button will also be shown, allowing the user to clear
+         * the filter.
+         */
+        note?: string;
+    }): Promise<void>;
+    /**
+     * Adds a listener for when a layer's filters change.
+     *
+     * @returns A function to unsubscribe from the listener
+     *
+     * @remarks
+     * This event fires whenever any type of filter changes on the layer, including
+     * ephemeral filters set via the SDK, style-based filters, or filters set through
+     * the Felt UI via Components.
+     *
+     * @event
+     * @example
+     * ```typescript
+     * const unsubscribe = felt.onLayerFiltersChange({
+     *   options: { layerId: "layer-1" },
+     *   handler: ({combined, ephemeral, style, components}) => {
+     *     console.log("Layer filters updated:", {
+     *       combined,  // All filters combined
+     *       ephemeral, // Filters set via SDK
+     *       style,     // Filters from layer style
+     *       components // Filters from UI components
+     *     });
+     *   },
+     * });
+     *
+     * // later on...
+     * unsubscribe();
+     * ```
+     */
+    onLayerFiltersChange(params: {
+        options: {
+            layerId: string;
+        };
+        handler: (change: LayerFilters) => void;
+    }): VoidFunction;
+    /**
+     * Get the features that are currently **rendered** on the map in the viewport.
+     *
+     * Note that this is explicitly about the features that are rendered, which isn't
+     * necessarily a complete list of all the features in the viewport. This is because
+     * of the way features are tiled: at low zoom levels or high feature densities, many
+     * features are omitted from what is rendered on the screen.
+     *
+     * @example
+     * ```typescript
+     * const features = await felt.getRenderedFeatures();
+     * ```
+     */
+    getRenderedFeatures(
+    /**
+     * The constraints to apply to the features returned from the map.
+     */
+    params?: GetRenderedFeaturesConstraint): Promise<Array<LayerFeature>>;
+    /**
+     * Get a feature from the map by its ID and layer ID.
+     *
+     * The response is a {@link LayerFeature} object, which does not include the
+     * geometry of the feature.
+     *
+     * You may want to use this when you don't need the geometry of a feature,
+     * but you know the ID of the feature you need.
+     *
+     * @example
+     * ```typescript
+     * const feature = await felt.getFeature({ layerId: "layer-1", id: 123 });
+     * ```
+     */
+    getFeature(params: {
+        id: string | number;
+        layerId: string;
+    }): Promise<LayerFeature | null>;
+    /**
+     * Get a list of layer features.
+     *
+     * @remarks This list is paginated in sets of 20 features for each page. In order to paginate
+     * between pages, the response includes `previousPage` and `nextPage` that are tokens
+     * that should be sent in the `pagination` params for requesting sibling pages.
+     *
+     * Text search is case-insensitive and looks for matches across all feature properties.
+     *
+     * @returns
+     * The response is an object which contains:
+     *   - `features`: list of {@link LayerFeature} objects, which does not include
+     * the geometry of the feature but it does include its bounding box.
+     *   - `count`: the total number of features that match the query.
+     *   - `previousPage` & `nextPage`: The tokens to pass in the `pagination` param
+     * to navigate between pages.
+     *
+     * @example
+     * ```typescript
+     * const page1Response = await felt.getFeatures({
+     *   layerId: "layer-1",
+     *   search: "abc123",
+     *   pagination: undefined,
+     * });
+     *
+     * // Note that the search term here matches the one for the first page.
+     * if (page1Response.nextPage) {
+     *   const page2Response = await felt.getFeatures({
+     *     layerId: "layer-1",
+     *     search: "abc123",
+     *     pagination: page1Response.nextPage,
+     *   });
+     * }
+     * ```
+     */
+    getFeatures(params: {
+        /**
+         * The ID of the layer to get features from.
+         */
+        layerId: string;
+        /**
+         * Filters to be applied. These filters will merge with layer's own filters.
+         */
+        filters?: Filters;
+        /**
+         * Attribute to sort by.
+         */
+        sorting?: SortConfig;
+        /**
+         * The spatial boundary to be applied.
+         */
+        boundary?: GeometryFilter;
+        /**
+         * Search term to search by.
+         *
+         * Search is case-insensitive and looks for matches across all feature properties.
+         */
+        search?: string;
+        /**
+         * Pagination token. It comes from either the `previousPage` or `nextPage`
+         * properties of the previous response.
+         */
+        pagination?: string | null;
+    }): Promise<{
+        /**
+         * The list of features returned from the query.
+         */
+        features: LayerFeature[];
+        /**
+         * The total number of features that match the query.
+         */
+        count: number;
+        /**
+         * The pagination token to get the previous page of features.
+         */
+        previousPage: string | null;
+        /**
+         * The pagination token to get the next page of features.
+         */
+        nextPage: string | null;
+    }>;
+    /**
+     * Get a feature in GeoJSON format from the map by its ID and layer ID.
+     *
+     * The response is a GeoJSON Feature object with the complete geometry of the
+     * feature. Note that for some _very_ large geometries, the response may take a
+     * long time to return, and may return a very large object.
+     *
+     * @example
+     * ```typescript
+     * const feature = await felt.getGeoJsonFeature({ layerId: "layer-1", id: 123 });
+     * ```
+     */
+    getGeoJsonFeature(params: {
+        id: string | number;
+        layerId: string;
+    }): Promise<GeoJsonFeature | null>;
+    /**
+     * Gets values from a layer grouped by a given attribute.
+     *
+     * @remarks
+     * Groups features in your layer by unique values in the specified attribute and calculates
+     * a value for each group. By default, this value is the count of features in each group.
+     *
+     * You can apply filters in two ways:
+     * 1. At the top level (using `boundary` and `filters`), which affects both what categories
+     *    are included and how values are calculated
+     * 2. In the `values` configuration, which only affects the values but keeps all categories
+     *
+     * This two-level filtering is particularly useful when you want to compare subsets of data
+     * while maintaining consistent categories. For example, you might want to show the distribution
+     * of all building types in a city, but only count buildings built after 2000 in each category.
+     *
+     * @example
+     * ```typescript
+     * // Basic grouping: Count of buildings by type
+     * const buildingsByType = await felt.getCategoryData({
+     *   layerId: "buildings",
+     *   attribute: "type"
+     * });
+     *
+     * // Filtered grouping: Only count buildings in downtown
+     * const downtownBuildingsByType = await felt.getCategoryData({
+     *   layerId: "buildings",
+     *   attribute: "type",
+     *   boundary: [-122.43, 47.60, -122.33, 47.62]  // downtown boundary
+     * });
+     *
+     * // Advanced: Show all building types, but only sum floor area of recent buildings
+     * const recentBuildingAreaByType = await felt.getCategoryData({
+     *   layerId: "buildings",
+     *   attribute: "type",
+     *   values: {
+     *     filters: ["year_built", "gte", 2000],
+     *     aggregation: {
+     *       method: "sum",
+     *       attribute: "floor_area"
+     *     }
+     *   }
+     * });
+     *
+     * // Compare residential density across neighborhoods while only counting recent buildings
+     * const newBuildingDensityByNeighborhood = await felt.getCategoryData({
+     *   layerId: "buildings",
+     *   attribute: "neighborhood",
+     *   values: {
+     *     filters: ["year_built", "gte", 2000],
+     *     aggregation: {
+     *       method: "avg",
+     *       attribute: "units_per_acre"
+     *     }
+     *   }
+     * });
+     * ```
+     */
+    getCategoryData(params: GetLayerCategoriesParams): Promise<Array<GetLayerCategoriesGroup>>;
+    /**
+     * Gets a histogram of values from a layer for a given attribute.
+     *
+     * @remarks
+     * Creates bins (ranges) for numeric data and counts how many features fall into each bin,
+     * or returns aggregated values for each bin.
+     *
+     * You can control how the bins are created using the `steps` parameter, choosing from
+     * several methods like equal intervals, quantiles, or natural breaks (Jenks), or passing
+     * in the step values directly if you know how you want to bin the data.
+     *
+     * Like getCategoryData, you can apply filters in two ways:
+     * 1. At the top level (using `boundary` and `filters`), which affects both how the bins
+     *    are calculated and what features are counted in each bin
+     * 2. In the `values` configuration, which only affects what gets counted but keeps the
+     *    bin ranges the same
+     *
+     * This is particularly useful when you want to compare distributions while keeping
+     * consistent bin ranges. For example, you might want to compare the distribution of
+     * building heights in different years while using the same height ranges.
+     *
+     * @example
+     * ```typescript
+     * // Basic histogram: Building heights in 5 natural break bins
+     * const buildingHeights = await felt.getHistogramData({
+     *   layerId: "buildings",
+     *   attribute: "height",
+     *   steps: { type: "jenks", count: 5 }
+     * });
+     *
+     * // Compare old vs new buildings using the same height ranges
+     * const oldBuildingHeights = await felt.getHistogramData({
+     *   layerId: "buildings",
+     *   attribute: "height",
+     *   steps: [0, 20, 50, 100, 200, 500],
+     *   values: {
+     *     filters: ["year_built", "lt", 1950]
+     *   }
+     * });
+     *
+     * const newBuildingHeights = await felt.getHistogramData({
+     *   layerId: "buildings",
+     *   attribute: "height",
+     *   steps: [0, 20, 50, 100, 200, 500],  // Same ranges as above
+     *   values: {
+     *     filters: ["year_built", "gte", 1950]
+     *   }
+     * });
+     * ```
+     */
+    getHistogramData(params: GetLayerHistogramParams): Promise<Array<GetLayerHistogramBin>>;
+    /**
+     * Calculates a single aggregate value for a layer based on the provided configuration.
+     *
+     * @remarks
+     * Performs statistical calculations on your data, like counting features or computing
+     * averages, sums, etc. You can focus your calculation on specific areas or subsets
+     * of your data using boundaries and filters.
+     *
+     * When no aggregation is specified, it counts features. When an aggregation is provided,
+     * it performs that calculation (average, sum, etc.) on the specified attribute.
+     *
+     * @example
+     * ```typescript
+     * // Count all residential buildings
+     * const residentialCount = await felt.getAggregates({
+     *   layerId: "buildings",
+     *   filters: ["type", "eq", "residential"]
+     * });
+     *
+     * // Calculate average home value in a specific neighborhood
+     * const avgHomeValue = await felt.getAggregates({
+     *   layerId: "buildings",
+     *   boundary: [-122.43, 47.60, -122.33, 47.62],  // neighborhood boundary
+     *   aggregation: {
+     *     method: "avg",
+     *     attribute: "assessed_value"
+     *   }
+     * });
+     *
+     * // Find the maximum building height for buildings built after 2000
+     * const maxNewBuildingHeight = await felt.getAggregates({
+     *   layerId: "buildings",
+     *   filters: ["year_built", "gte", 2000],
+     *   aggregation: {
+     *     method: "max",
+     *     attribute: "height"
+     *   }
+     * });
+     * ```
+     */
+    getAggregates<T extends AggregationMethod | "count">(params: GetLayerCalculationParams<T>): Promise<Record<T, number | null>>;
+    /**
+     * Get the schema for a layer.
+     *
+     * @remarks
+     * The schema describes the structure of the data in a layer, including the attributes
+     * that are available on the features in the layer.
+     *
+     * This can be useful to build generic UIs that need to know the structure of the data in
+     * a layer, such as a dropdown to choose an attribute.
+     *
+     * @example
+     * ```typescript
+     * const schema = await felt.getLayerSchema("layer-1");
+     * const attributeIds = schema.attributes.map((attr) => attr.id);
+     * ```
+     */
+    getLayerSchema(layerId: string): Promise<LayerSchema>;
+}
+
 /**
  * The event object passed to the interaction listeners.
  */
@@ -6654,4 +7392,4 @@ declare const ViewportFitBoundsParamsSchema: z.ZodObject<{
     bounds: [number, number, number, number];
 }>;
 
-export type { HighlighterElementCreate as $, AggregationMethod as A, MapDetails as B, CreateLayersFromGeoJsonParams as C, EntityNode as D, Element as E, Filters as F, GeoJsonGeometry as G, FeatureSelection as H, InputToolSettings as I, ConfigurableToolType as J, ToolSettingsMap as K, Layer as L, MapInteractionEvent as M, ToolSettingsChangeEvent as N, zInfer as O, SortConfig as P, SetViewportCenterZoomParams as Q, ViewportConstraints as R, SetVisibilityRequest as S, ToolType as T, UpdateLayerParams as U, ViewportState as V, ViewportFitBoundsParams as W, ViewportCenterZoom as X, CircleElementCreate as Y, CircleElementRead as Z, CircleElementUpdate as _, GetElementsConstraint as a, MultiPolygonGeometry as a$, HighlighterElementRead as a0, HighlighterElementUpdate as a1, ImageElementCreate as a2, ImageElementRead as a3, ImageElementUpdate as a4, LinkElementRead as a5, MarkerElementCreate as a6, MarkerElementRead as a7, MarkerElementUpdate as a8, NoteElementCreate as a9, LayerSchemaAttribute as aA, LayerSchemaBooleanAttribute as aB, LayerSchemaCommonAttribute as aC, LayerSchemaDateAttribute as aD, LayerSchemaDateTimeAttribute as aE, LayerSchemaNumericAttribute as aF, LayerSchemaTextAttribute as aG, FilterExpression as aH, FilterLogicGate as aI, FilterTernary as aJ, AggregationConfig as aK, GeometryFilter as aL, MultiAggregationConfig as aM, ValueConfiguration as aN, ElementGroupNode as aO, ElementNode as aP, FeatureNode as aQ, LayerGroupNode as aR, LayerNode as aS, FeltBoundary as aT, FeltZoom as aU, GeoJsonProperties as aV, LatLng as aW, LineStringGeometry as aX, LngLatTuple as aY, MultiLineStringGeometry as aZ, MultiPointGeometry as a_, NoteElementRead as aa, NoteElementUpdate as ab, PathElementCreate as ac, PathElementRead as ad, PathElementUpdate as ae, PlaceElementCreate as af, PlaceElementRead as ag, PlaceElementUpdate as ah, PolygonElementCreate as ai, PolygonElementRead as aj, PolygonElementUpdate as ak, TextElementCreate as al, TextElementRead as am, TextElementUpdate as an, DataOnlyLayer as ao, FeltTiledVectorSource as ap, GeoJsonDataVectorSource as aq, GeoJsonFileVectorSource as ar, GeoJsonUrlVectorSource as as, LayerCommon as at, LayerProcessingStatus as au, RasterBand as av, RasterLayer as aw, RasterLayerSource as ax, RasterValue as ay, VectorLayer as az, ElementGroup as b, PointGeometry as b0, PolygonGeometry as b1, SortDirection as b2, CircleToolSettings as b3, HighlighterToolSettings as b4, LineToolSettings as b5, MarkerToolSettings as b6, NoteToolSettings as b7, PinToolSettings as b8, PlaceFrame as b9, PlaceSymbol as ba, PolygonToolSettings as bb, RouteToolSettings as bc, TextToolSettings as bd, UnionToIntersection as be, PromiseOrNot as bf, 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, LayerFeature as s, GeoJsonFeature as t, GetLayerCategoriesParams as u, GetLayerCategoriesGroup as v, GetLayerHistogramParams as w, GetLayerHistogramBin as x, GetLayerCalculationParams as y, LayerSchema as z };
+export type { TextElementRead as $, MarkerElementCreate as A, MarkerElementRead as B, ConfigurableToolType as C, MarkerElementUpdate as D, Element as E, FeatureSelection as F, GeoJsonGeometry as G, HighlighterElementCreate as H, InputToolSettings as I, NoteElementRead as J, NoteElementUpdate as K, LayersController as L, MapInteractionEvent as M, NoteElementCreate as N, PathElementRead as O, PathElementCreate as P, PathElementUpdate as Q, PlaceElementCreate as R, SetVisibilityRequest as S, ToolType as T, PlaceElementRead as U, ViewportState as V, PlaceElementUpdate as W, PolygonElementCreate as X, PolygonElementRead as Y, PolygonElementUpdate as Z, TextElementCreate as _, GetElementsConstraint as a, MultiPointGeometry as a$, TextElementUpdate as a0, CreateLayersFromGeoJsonParams as a1, DataOnlyLayer as a2, FeltTiledVectorSource as a3, GeoJsonDataVectorSource as a4, GeoJsonFileVectorSource as a5, GeoJsonUrlVectorSource as a6, GetLayerGroupsConstraint as a7, GetLayersConstraint as a8, GetRenderedFeaturesConstraint as a9, FilterLogicGate as aA, FilterTernary as aB, Filters as aC, GeometryFilter as aD, LayerFilters as aE, AggregationConfig as aF, AggregationMethod as aG, GetLayerCalculationParams as aH, GetLayerCategoriesGroup as aI, GetLayerCategoriesParams as aJ, GetLayerHistogramBin as aK, GetLayerHistogramParams as aL, MultiAggregationConfig as aM, ValueConfiguration as aN, ElementGroupNode as aO, ElementNode as aP, FeatureNode as aQ, LayerGroupNode as aR, LayerNode as aS, FeltBoundary as aT, FeltZoom as aU, GeoJsonFeature as aV, GeoJsonProperties as aW, LatLng as aX, LineStringGeometry as aY, LngLatTuple as aZ, MultiLineStringGeometry as a_, Layer as aa, LayerChangeCallbackParams as ab, LayerCommon as ac, LayerGroup as ad, LayerGroupChangeCallbackParams as ae, LayerProcessingStatus as af, LegendItem as ag, LegendItemChangeCallbackParams as ah, LegendItemIdentifier as ai, LegendItemsConstraint as aj, RasterBand as ak, RasterLayer as al, RasterLayerSource as am, UpdateLayerParams as an, VectorLayer as ao, LayerFeature as ap, RasterValue as aq, LayerSchema as ar, LayerSchemaAttribute as as, LayerSchemaBooleanAttribute as at, LayerSchemaCommonAttribute as au, LayerSchemaDateAttribute as av, LayerSchemaDateTimeAttribute as aw, LayerSchemaNumericAttribute as ax, LayerSchemaTextAttribute as ay, FilterExpression as az, ElementGroup as b, MultiPolygonGeometry as b0, PointGeometry as b1, PolygonGeometry as b2, SortDirection as b3, CircleToolSettings as b4, HighlighterToolSettings as b5, LineToolSettings as b6, MarkerToolSettings as b7, NoteToolSettings as b8, PinToolSettings as b9, PlaceFrame as ba, PlaceSymbol as bb, PolygonToolSettings as bc, RouteToolSettings as bd, TextToolSettings as be, UnwrapPromise as bf, UnionToIntersection as bg, PromiseOrNot as bh, GetElementGroupsConstraint as c, ElementChangeCallbackParams as d, ElementGroupChangeCallbackParams as e, ElementCreate as f, ElementUpdate as g, MapDetails as h, EntityNode as i, ToolSettingsMap as j, ToolSettingsChangeEvent as k, SortConfig as l, SetViewportCenterZoomParams as m, ViewportConstraints as n, ViewportFitBoundsParams as o, ViewportCenterZoom as p, CircleElementCreate as q, CircleElementRead as r, CircleElementUpdate as s, HighlighterElementRead as t, HighlighterElementUpdate as u, ImageElementCreate as v, ImageElementRead as w, ImageElementUpdate as x, LinkElementRead as y, zInfer as z };