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

package/dist/{types-B241Rd9q.d.ts → controller-C5gGWnaM.d.ts}

@@ -4137,6 +4137,315 @@ interface ElementGroupChangeCallbackParams {
     elementGroup: ElementGroup | null;
 }
 
+/**
+ * The Elements controller allows you to get information about the elements on the
+ * map, and make changes to their visibility.
+ *
+ * @group Controller
+ * @public
+ */
+interface ElementsController {
+    /**
+     * Get a single element from the map by its id.
+     *
+     * @example
+     * ```typescript
+     * const element = await felt.getElement("element-1");
+     * ```
+     * @returns The requested element.
+     */
+    getElement(
+    /**
+     * The id of the element you want to get.
+     */
+    id: string): Promise<Element | null>;
+    /**
+     * Get the geometry of an element in GeoJSON geometry format.
+     *
+     * For most element types, the geometry returned is based on the `coordinates`
+     * property of the element, with some differences:
+     *
+     * - For Circle elements, the geometry is a Polygon drawn from the `center` and
+     * `radius` properties.
+     *
+     * - Path elements become MultiLineString geometries.
+     *
+     * - Marker elements return a MultiLineString of the path traced by the user
+     * as they drew the marker. Note that this is not the polygon formed by filled-in
+     * "pen" stroke, which doesn't exactly follow the path traced by the user as it
+     * is smoothed and interpolated to create a continuous line.
+     *
+     * - Text, Note and Image elements do not return geometry, so will return `null`.
+     *
+     *
+     * @example
+     * ```typescript
+     * const geometry = await felt.getElementGeometry("element-1");
+     * console.log(geometry?.type, geometry?.coordinates);
+     * ```
+     */
+    getElementGeometry(
+    /**
+     * The id of the element you want to get the geometry of.
+     */
+    id: string): Promise<GeoJsonGeometry | null>;
+    /**
+     * Gets elements from the map, according to the constraints supplied. If no
+     * constraints are supplied, all elements will be returned.
+     *
+     * @remarks The elements 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 elements = await felt.getElements();
+     * ```
+     * @returns All elements on the map.
+     */
+    getElements(
+    /**
+     * The constraints to apply to the elements returned from the map.
+     */
+    constraint?: GetElementsConstraint): Promise<Array<Element | null>>;
+    /**
+     * Get an element group from the map by its id.
+     *
+     * @example
+     * ```typescript
+     * const elementGroup = await felt.getElementGroup("element-group-1");
+     * ```
+     * @returns The requested element group.
+     */
+    getElementGroup(id: string): Promise<ElementGroup | null>;
+    /**
+     * Gets element groups from the map, according to the filters supplied. If no
+     * constraints are supplied, all element groups will be returned in rendering order.
+     *
+     * @example
+     * ```typescript
+     * const elementGroups = await felt.getElementGroups({ ids: ["element-group-1", "element-group-2"] });
+     * ```
+     * @returns The requested element groups.
+     */
+    getElementGroups(
+    /**
+     * The constraints to apply to the element groups returned from the map.
+     */
+    constraint?: GetElementGroupsConstraint): Promise<Array<ElementGroup | null>>;
+    /**
+     * Hide or show element groups with the given ids.
+     *
+     * @example
+     * ```typescript
+     * felt.setElementGroupVisibility({ show: ["element-group-1", "element-group-2"], hide: ["element-group-3"] });
+     * ```
+     */
+    setElementGroupVisibility(visibility: SetVisibilityRequest): Promise<void>;
+    /**
+     * Adds a listener for when an element is created.
+     *
+     * @returns A function to unsubscribe from the listener
+     *
+     * @event
+     * @example
+     * ```typescript
+     * const unsubscribe = felt.onElementCreate({
+     *   handler: (element) => console.log(element.id),
+     * });
+     *
+     * // later on...
+     * unsubscribe();
+     * ```
+     */
+    onElementCreate(args: {
+        /**
+         * The handler that is called when an element is created.
+         *
+         * This will fire when elements are created programatically, or when the
+         * user starts creating an element with a drawing tool.
+         *
+         * When the user creates an element with a drawing tool, it can begin in
+         * an invalid state, such as if you've just placed a single point in a polygon.
+         *
+         * You can use the `isBeingCreated` property to determine if the element is
+         * still being created by a drawing tool.
+         *
+         * If you want to know when the element is finished being created, you can
+         * use the {@link ElementsController.onElementCreateEnd | `onElementCreateEnd`} listener.
+         *
+         * @param change - An object describing the change that occurred.
+         */
+        handler: (change: ElementChangeCallbackParams) => void;
+    }): VoidFunction;
+    /**
+     * Listens for when a new element is finished being created by a drawing tool.
+     *
+     * This differs from the {@link ElementsController.onElementCreate | `onElementCreate`} listener, which fires whenever an
+     * element is first created. This fires when the user finishes creating an element
+     * which could be after a series of interactions.
+     *
+     * For example, when creating a polygon, the user places a series of points then
+     * finishes by pressing Enter or Escape. Or when creating a Place element, they
+     * add the marker, type a label, then finally deselect the element.
+     *
+     * @returns A function to unsubscribe from the listener
+     *
+     * @event
+     * @example
+     * ```typescript
+     * const unsubscribe = felt.onToolCreatedElement({
+     *   handler: (params) => console.log(params),
+     * });
+     *
+     * // later on...
+     * unsubscribe();
+     * ```
+     */
+    onElementCreateEnd(args: {
+        /**
+         * The handler to call whenever this event fires.
+         *
+         * @param params - An object containing the element that was created.
+         */
+        handler: (params: {
+            element: Element;
+        }) => void;
+    }): VoidFunction;
+    /**
+     * Adds a listener for when an element changes.
+     *
+     * This will fire when an element is being edited, either on the map by the user
+     * or programatically.
+     *
+     * Like the {@link ElementsController.onElementCreate | `onElementCreate`} listener, this will fire when an element is
+     * still being created by a drawing tool.
+     *
+     * You can check the {@link ElementChangeCallbackParams.isBeingCreated | `isBeingCreated`} property to determine if the element is
+     * still being created by a drawing tool.
+     *
+     * @returns A function to unsubscribe from the listener
+     *
+     * @event
+     * @example
+     * ```typescript
+     * const unsubscribe = felt.onElementChange({
+     *   options: { id: "element-1" },
+     *   handler: ({element}) => console.log(element.id),
+     * });
+     *
+     * // later on...
+     * unsubscribe();
+     * ```
+     */
+    onElementChange(args: {
+        options: {
+            /**
+             * The id of the element to listen for changes to.
+             */
+            id: string;
+        };
+        /**
+         * The handler that is called when the element changes.
+         */
+        handler: (
+        /**
+         * An object describing the change that occurred.
+         */
+        change: ElementChangeCallbackParams) => void;
+    }): VoidFunction;
+    /**
+     * Adds a listener for when an element is deleted.
+     *
+     * @returns A function to unsubscribe from the listener
+     *
+     * @event
+     * @example
+     * ```typescript
+     * const unsubscribe = felt.onElementDelete({
+     *   options: { id: "element-1" },
+     *   handler: () => console.log("element-1 deleted"),
+     * });
+     *
+     * // later on...
+     * unsubscribe();
+     * ```
+     */
+    onElementDelete(args: {
+        options: {
+            /**
+             * The id of the element to listen for deletions of.
+             */
+            id: string;
+        };
+        /**
+         * The handler that is called when the element is deleted.
+         */
+        handler: () => void;
+    }): VoidFunction;
+    /**
+     * Adds a listener for when an element group changes.
+     *
+     * @returns A function to unsubscribe from the listener
+     *
+     * @event
+     * @example
+     * ```typescript
+     * const unsubscribe = felt.onElementGroupChange({
+     *   options: { id: "element-group-1" },
+     *   handler: elementGroup => console.log(elementGroup.id),
+     * });
+     *
+     * // later on...
+     * unsubscribe();
+     * ```
+     */
+    onElementGroupChange(args: {
+        options: {
+            id: string;
+        };
+        handler: (change: ElementGroupChangeCallbackParams) => void;
+    }): VoidFunction;
+    /**
+     * Create a new element on the map.
+     *
+     * @example
+     * ```typescript
+     * const element = await felt.createElement({ type: "Place", coordinates: [10, 10] });
+     * ```
+     */
+    createElement(element: ElementCreate): Promise<Element>;
+    /**
+     * Update an element on the map.
+     *
+     * @example
+     * ```typescript
+     * // Update a place element's coordinates
+     * await felt.updateElement({
+     *   id: "element-1",
+     *   coordinates: [10, 20]
+     * });
+     *
+     * // Update a polygon's style
+     * await felt.updateElement({
+     *   id: "element-2",
+     *   color: "#ABC123",
+     *   fillOpacity: 0.5
+     * });
+     * ```
+     */
+    updateElement(element: ElementUpdate): Promise<Element>;
+    /**
+     * Delete an element from the map.
+     *
+     * @example
+     * ```typescript
+     * await felt.deleteElement("element-1");
+     * ```
+     */
+    deleteElement(id: string): Promise<void>;
+}
+
 /**
  * A LayerFeature is a single geographical item in a layer.
  *
@@ -5443,6 +5752,34 @@ interface LayerFilters {
  * @group Filters
  */
 type GeometryFilter = FeltBoundary | PolygonGeometry | MultiPolygonGeometry | LngLatTuple[];
+/**
+ * All the different sources for boundaries for a layer, including their combined result.
+ *
+ * @group Filters
+ */
+interface LayerBoundaries {
+    /**
+     * Boundaries set by drawing spatial filters on the map.
+     *
+     * When there are multiple spatial filters, they are combined into a multi-polygon.
+     */
+    spatialFilters: MultiPolygonGeometry | null;
+    /**
+     * Boundaries that are set ephemerally by viewers in their own session.
+     *
+     * These are the filters that are set when the {@link LayersController.setLayerBoundary}
+     * method is called. There is no way to set these in the Felt UI - they can only be
+     * set using the SDK.
+     */
+    ephemeral: GeometryFilter | null;
+    /**
+     * The combined result of all the boundaries set on the layer.
+     *
+     * Each different source of boundary is intersected to produce the combined result.
+     *
+     */
+    combined: MultiPolygonGeometry | null;
+}
 
 declare const AggregateMethodSchema: z.ZodEnum<["avg", "max", "min", "sum", "median"]>;
 declare const AggregationConfigSchema: z.ZodObject<{
@@ -6531,6 +6868,90 @@ interface LayersController {
         };
         handler: (change: LayerFilters) => void;
     }): VoidFunction;
+    /**
+     * Get the spatial boundaries that are filtering a layer.
+     *
+     * @remarks
+     * The return type gives you the boundaries split up into the various sources
+     * that make up the overall boundary for a layer.
+     *
+     * The combined boundary is the intersection of the other sources of boundaries.
+     *
+     * @example
+     * ```typescript
+     * const boundaries = await felt.getLayerBoundaries("layer-1");
+     *
+     * console.log(boundaries?.combined);
+     * console.log(boundaries?.spatialFilters);
+     * console.log(boundaries?.ephemeral);
+     * ```
+     */
+    getLayerBoundaries(layerId: string): Promise<LayerBoundaries | null>;
+    /**
+     * Set the {@link LayerBoundaries.ephemeral | `ephemeral`} boundary for one or more layers.
+     *
+     * @example
+     * ```typescript
+     * await felt.setLayerBoundary({
+     *   layerIds: ["layer-1", "layer-2"],
+     *   boundary: { type: "MultiPolygon", coordinates: [[[100, 0], [101, 0], [101, 1], [100, 1], [100, 0]]] }
+     * });
+     * ```
+     */
+    setLayerBoundary(params: {
+        /**
+         * The ids of the layers to set the boundary for.
+         */
+        layerIds: Array<string>;
+        /**
+         * The boundary to set for the layer.
+         *
+         * Passing `null` clears the ephemeral boundary for the layer.
+         */
+        boundary: GeometryFilter | null;
+    }): Promise<void>;
+    /**
+     * Adds a listener for when a layer's spatial boundaries change.
+     *
+     * @returns A function to unsubscribe from the listener
+     *
+     * @remarks
+     * This event fires whenever any type of spatial boundary changes on the layer, including
+     * ephemeral boundaries set via the SDK or boundaries set through the Felt UI via
+     * Spatial filter components.
+     *
+     * @event
+     * @example
+     * ```typescript
+     * const unsubscribe = felt.onLayerBoundariesChange({
+     *   options: { layerId: "layer-1" },
+     *   handler: ({combined, ephemeral, spatialFilters}) => {
+     *     console.log("Layer boundaries updated:", {
+     *       combined,  // All boundaries combined
+     *       ephemeral, // Boundaries set via SDK
+     *       spatialFilters // Boundaries set via UI
+     *     });
+     *   },
+     * });
+     *
+     * // later on...
+     * unsubscribe();
+     * ```
+     */
+    onLayerBoundariesChange(params: {
+        options: {
+            /**
+             * The id of the layer to listen for boundary changes on.
+             */
+            layerId: string;
+        };
+        /**
+         * A function that is called when the boundaries change.
+         *
+         * @param boundaries - The new boundaries for the layer.
+         */
+        handler: (boundaries: LayerBoundaries | null) => void;
+    }): VoidFunction;
     /**
      * Get the features that are currently **rendered** on the map in the viewport.
      *
@@ -6860,9 +7281,67 @@ interface MapInteractionEvent {
 }
 
 /**
- * The details of a map.
+ * The Interactions controller allows you to observe interactions with the map
  *
- * @group Types
+ * @group Controller
+ * @public
+ */
+interface InteractionsController {
+    /**
+     * Allows you to be notified the user clicks on the map.
+     *
+     * @returns A function to unsubscribe from the listener
+     *
+     * @event
+     * @example
+     * ```typescript
+     * const unsubscribe = felt.onPointerClick({
+     *   handler: (event) => console.log(event.center, event.features),
+     * });
+     *
+     * // later on...
+     * unsubscribe();
+     * ```
+     */
+    onPointerClick(params: {
+        handler: (event: MapInteractionEvent) => void;
+    }): VoidFunction;
+    /**
+     * Allows you to be notified the user moves the mouse over the map.
+     *
+     * @returns A function to unsubscribe from the listener
+     *
+     * @event
+     * @example
+     * ```typescript
+     * // Track mouse movement and features under cursor
+     * const unsubscribe = felt.onPointerMove({
+     *   handler: (event) => {
+     *     console.log("Mouse position:", event.center);
+     *     console.log("Features under cursor:", event.features);
+     *   }
+     * });
+     *
+     * // later on...
+     * unsubscribe();
+     * ```
+     */
+    onPointerMove(
+    /**
+     * Params for the listener
+     */
+    params: {
+        /**
+         * The handler function
+         */
+        handler: (event: MapInteractionEvent) => void;
+    }): VoidFunction;
+}
+
+/**
+ * The details of a map.
+ *
+ * @group Types
  */
 type MapDetails = {
     /**
@@ -6879,6 +7358,27 @@ type MapDetails = {
     description: string | null;
 };
 
+/**
+ * @group Controller
+ * @public
+ */
+interface MiscController {
+    /**
+     * Gets the details of the map.
+     *
+     * @example
+     * ```typescript
+     * const details = await felt.getMapDetails();
+     * console.log({
+     *   id: details.id,
+     *   title: details.title,
+     *   description: details.description,
+     * });
+     * ```
+     */
+    getMapDetails(): Promise<MapDetails>;
+}
+
 /**
  * A reference to any kind of entity in the map.
  *
@@ -6996,6 +7496,107 @@ declare const FeatureSelectionSchema: z.ZodObject<{
     } | undefined;
 }>;
 
+/**
+ * The Selection controller allows you to listen for changes to the selection on the map.
+ *
+ * @group Controller
+ * @public
+ */
+interface SelectionController {
+    /**
+     * Gets the current selection as a list of entity identifiers.
+     *
+     * @example
+     * ```typescript
+     * const selection = await felt.getSelection();
+     * ```
+     */
+    getSelection(): Promise<EntityNode[]>;
+    /**
+     * Adds a listener for when the selection changes.
+     *
+     * @returns A function to unsubscribe from the listener
+     *
+     * @event
+     * @example
+     * ```typescript
+     * const unsubscribe = felt.onSelectionChange({
+     *   handler: ({selection}) => console.log(selection),
+     * });
+     *
+     * // later on...
+     * unsubscribe();
+     * ```
+     */
+    onSelectionChange(params: {
+        handler: (change: {
+            /**
+             * The new selection. In the case where there are multiple entities selected,
+             * the array describes the chronological and semeantic order of the selection.
+             *
+             * Entities of the same type that are selected later will appear later in the
+             * list, but there are cases where multiple entity types can be selected at once,
+             * such as elements and features. In this case, the order of the _types_ of entities
+             * tells you which are considered more semantically important.
+             *
+             * For example, if a feature and element are selected, the feature will be at the
+             * tail of the list because pressing Escape will deselect the feature first, then
+             * pressing Escape again will deselect the element.
+             */
+            selection: EntityNode[];
+        }) => void;
+    }): VoidFunction;
+    /**
+     * Selects a feature on a layer. This will show the feature's popup, modal or
+     * sidebar (if configured) and highlight the feature.
+     *
+     * @example
+     * ```typescript
+     * felt.selectFeature({
+     *   id: 123,
+     *   layerId: "my-layer",
+     *   showPopup: true,
+     *   fitViewport: { maxZoom: 15 },
+     * });
+     * ```
+     */
+    selectFeature(params: FeatureSelection): Promise<void>;
+    /**
+     * Clears the current selection. This clears the selection of
+     *
+     * @example
+     * ```typescript
+     *
+     * // Removes all features and elements from the selection
+     * felt.clearSelection();
+     *
+     * // Removes only features from the selection
+     * felt.clearSelection({ features: true });
+     *
+     * // Removes only elements from the selection
+     * felt.clearSelection({ elements: true });
+     * ```
+     *
+     * @default
+     * ```typescript
+     * { features: true, elements: true }
+     * ```
+     *
+     * @param params - The parameters to clear the selection. If this is not provided,
+     * both features and elements will be cleared.
+     */
+    clearSelection(params?: {
+        /**
+         * Whether to clear the features from the selection.
+         */
+        features?: boolean;
+        /**
+         * Whether to clear the elements from the selection.
+         */
+        elements?: boolean;
+    }): Promise<void>;
+}
+
 declare const ToolSchema: z.ZodEnum<["pin", "line", "route", "polygon", "circle", "marker", "highlighter", "text", "note", "link"]>;
 type ToolType = z.infer<typeof ToolSchema>;
 type ConfigurableToolType = keyof ToolSettingsMap;
@@ -7245,6 +7846,335 @@ type ToolSettingsMap = {
 type PlaceFrame = "frame-circle" | "frame-square" | null;
 type PlaceSymbol = "dot" | "square" | "diamond" | "triangle" | "x" | "plus" | "circle-line" | "circle-slash" | "star" | "heart" | "hexagon" | "octagon" | "pedestrian" | "bicycle" | "wheelchair" | "airport" | "car" | "bus" | "train" | "truck" | "ferry" | "sailboat" | "electric-service" | "gas-service" | "blood-clinic" | "badge" | "traffic-light" | "traffic-cone" | "road-sign-caution" | "person" | "restroom" | "house" | "work" | "letter" | "hotel" | "factory" | "hospital" | "religious-facility" | "school" | "government" | "university" | "bank" | "landmark" | "museum" | "clothing" | "shopping" | "store" | "bar" | "pub" | "cafe" | "food" | "park" | "amusement-park" | "camping-tent" | "cabin" | "picnic" | "water-refill" | "trailhead" | "guidepost" | "viewpoint" | "camera" | "us-football" | "football" | "tennis" | "binoculars" | "swimming" | "zap" | "battery-full" | "battery-half" | "battery-low" | "boom" | "radar" | "wind-turbine" | "solar-panel" | "antenna" | "telephone-pole" | "oil-well" | "oil-barrel" | "railroad-track" | "bridge" | "lighthouse" | "lock-closed" | "lock-open" | "wifi" | "trash" | "recycle" | "tree" | "flower" | "leaf" | "fire" | "mountain" | "snowy-mountain" | "volcano" | "island" | "wave" | "hot-springs" | "water" | "lake" | "ocean" | "animal" | "bird" | "duck" | "dog" | "fish" | "beach" | "wetland" | "sun" | "moon" | "cloud" | "partial-sun" | "rain" | "lightning" | "snowflake" | "wind" | "snow" | "fog" | "sleet" | "hurricane" | "warning" | "parking" | "info" | "circle-exclamation" | "circle-triangle" | "circle-x" | "circle-plus" | (`:${string}:` & {});
 
+/**
+ * The Tools controller allows you to let users draw elements on the map.
+ *
+ * @group Controller
+ * @public
+ */
+interface ToolsController {
+    /**
+     * Sets the tool to use for drawing elements on the map.
+     *
+     * @param tool - The tool to set.
+     *
+     * @example
+     * ```typescript
+     * // Set the tool to "marker"
+     * await felt.setTool("marker");
+     *
+     * // put down the tool
+     * await felt.setTool(null);
+     * ```
+     */
+    setTool(tool: ToolType | null): void;
+    /**
+     * Gets the current tool, if any is in use.
+     *
+     * @returns The current tool, or `null` if no tool is in use.
+     *
+     * @example
+     * ```typescript
+     * const tool = await felt.getTool(); // "marker", "polygon", etc.
+     * ```
+     */
+    getTool(): Promise<ToolType | null>;
+    /**
+     * Listens for changes to the current tool.
+     *
+     * @returns A function to unsubscribe from the listener
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = felt.onToolChange({
+     *   handler: tool => console.log(tool),
+     * });
+     *
+     * // later on...
+     * unsubscribe();
+     * ```
+     */
+    onToolChange(args: {
+        /**
+         * This callback is called with the current tool whenever the tool changes.
+         *
+         * @param tool - The current tool, or `null` if no tool is in use.
+         */
+        handler: (tool: ToolType | null) => void;
+    }): VoidFunction;
+    /**
+     * Sets the settings for the current tool.
+     *
+     * @example
+     * ```typescript
+     * // Set the settings for the marker tool
+     * await felt.setToolSettings({
+     *   tool: "marker",
+     *   color: "#FE17",
+     * });
+     * ```
+     *
+     * @param settings - The settings to set.
+     */
+    setToolSettings(settings: InputToolSettings): void;
+    /**
+     * Gets the settings for the chosen tool
+     *
+     * @example
+     * ```typescript
+     * const settings = await felt.getToolSettings("marker");
+     * ```
+     *
+     * @returns The settings for the chosen tool.
+     */
+    getToolSettings<T extends ConfigurableToolType>(tool: T): Promise<ToolSettingsMap[T]>;
+    /**
+     * Listens for changes to the settings on all tools.
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = felt.onToolSettingsChange({
+     *   handler: settings => console.log(settings),
+     * });
+     *
+     * // later on...
+     * unsubscribe();
+     * ```
+     * @returns A function to unsubscribe from the listener
+     */
+    onToolSettingsChange(args: {
+        handler: (settings: ToolSettingsChangeEvent) => void;
+    }): VoidFunction;
+}
+
+/**
+ * @public
+ */
+interface UiControlsOptions extends zInfer<typeof UiControlsOptionsSchema> {
+}
+/**
+ * @internal
+ * @ignore
+ */
+declare const UiControlsOptionsSchema: z.ZodObject<{
+    /**
+     * Whether or not the legend is shown.
+     *
+     * @defaultValue true
+     */
+    showLegend: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * When co-operative gestures are enabled, the pan and zoom gestures are
+     * adjusted to work better when the map is embedded in another page.
+     *
+     * @remarks
+     * On mobile devices, enabling co-operative gestures will allow the user to
+     * pan past the embedded map with a single finger drag. To pan the map, they
+     * must use two fingers.
+     *
+     * On desktop devices, enabling co-operative gestures allows the user to
+     * scroll past the embedded map using their scroll wheel or trackpad. To
+     * zoom the map, they must hold the Ctrl (Windows) or Command key (Mac) while
+     * scrolling.
+     *
+     * @defaultValue true
+     */
+    cooperativeGestures: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * Whether or not the full screen button is shown in an embedded map.
+     *
+     * @remarks
+     * When clicked, this will open the map in a new tab or window.
+     *
+     * @defaultValue true
+     */
+    fullScreenButton: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * Whether or not the geolocation button is shown in an embedded map.
+     *
+     * @remarks
+     * The geolocation feature will plot your position on the map. If you
+     * click the button again, it will start tracking your position.
+     *
+     * @defaultValue false
+     */
+    geolocation: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * Whether or not the zoom controls are shown in an embedded map.
+     *
+     * @remarks
+     * This does not affect whether or not the map can be zoomed, just
+     * the display of the zoom controls in the bottom right corner of the map.
+     *
+     * @defaultValue true
+     */
+    zoomControls: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * Whether or not the scale bar is shown in an embedded map.
+     *
+     * @defaultValue true
+     */
+    scaleBar: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    showLegend?: boolean | undefined;
+    cooperativeGestures?: boolean | undefined;
+    fullScreenButton?: boolean | undefined;
+    geolocation?: boolean | undefined;
+    zoomControls?: boolean | undefined;
+    scaleBar?: boolean | undefined;
+}, {
+    showLegend?: boolean | undefined;
+    cooperativeGestures?: boolean | undefined;
+    fullScreenButton?: boolean | undefined;
+    geolocation?: boolean | undefined;
+    zoomControls?: boolean | undefined;
+    scaleBar?: boolean | undefined;
+}>;
+/**
+ * The options for which parts of the Felt UI can be shown when interacting with
+ * features and elements on the map.
+ *
+ * Switching these off can be useful if you add your own click, selection or hover
+ * handlers for features and elements.
+ *
+ * @public
+ */
+interface UiOnMapInteractionsOptions extends zInfer<typeof UiOnMapInteractionsOptionsSchema> {
+}
+/**
+ * @internal
+ * @ignore
+ */
+declare const UiOnMapInteractionsOptionsSchema: z.ZodObject<{
+    /**
+     * Set this to `false` to prevent the panel that shows information about a selected
+     * feature from being shown.
+     */
+    featureSelectPanel: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * Set this to `false` to prevent the panel that shows information about a hovered
+     * feature from being shown.
+     */
+    featureHoverPanel: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * Set this to `false` to prevent the panel that shows information about a selected
+     * element from being shown.
+     */
+    elementSelectPanel: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * Set this to `false` to prevent clicking on a map link element from opening that link
+     * in a new tab or window.
+     */
+    linkClickOpen: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * Set this to `false` to prevent clicking on an image element from opening the image
+     * in a lightbox.
+     */
+    imageLightboxOpen: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    featureSelectPanel?: boolean | undefined;
+    featureHoverPanel?: boolean | undefined;
+    elementSelectPanel?: boolean | undefined;
+    linkClickOpen?: boolean | undefined;
+    imageLightboxOpen?: boolean | undefined;
+}, {
+    featureSelectPanel?: boolean | undefined;
+    featureHoverPanel?: boolean | undefined;
+    elementSelectPanel?: boolean | undefined;
+    linkClickOpen?: boolean | undefined;
+    imageLightboxOpen?: boolean | undefined;
+}>;
+
+/**
+ * The UI controller allows you to control various aspects of the Felt UI in your embedded map.
+ *
+ * This includes enabling/disabling UI controls, managing on-map interactions, and controlling
+ * the visibility of UI components like the data table.
+ *
+ * @group Controller
+ * @public
+ */
+interface UiController {
+    /**
+     * Updates the UI controls on the embedded map.
+     *
+     * @example
+     * ```typescript
+     * // Show some UI controls
+     * await felt.updateUiControls({
+     *   showLegend: true,
+     *   fullScreenButton: true,
+     * });
+     *
+     * // Disable some UI options
+     * await felt.updateUiControls({
+     *   cooperativeGestures: false,
+     *   geolocation: false,
+     * });
+     * ```
+     *
+     * @param controls - The controls to update.
+     */
+    updateUiControls(controls: UiControlsOptions): void;
+    /**
+     * Control the on-map UI shown when interacting with features and elements.
+     *
+     * If you add your own click, selection or hover handlers you may want to disable
+     * various parts of the Felt UI. This method allows you to control the visibility of
+     * various parts of the UI that might otherwise be shown when people click or hover
+     * on things.
+     *
+     * This does not affect selection. That means that selectable features and elements
+     * will still be selected when clicked.
+     *
+     * @example
+     * ```typescript
+     * // Disable UI when hovering or selecting features
+     * await felt.setOnMapInteractionsUi({
+     *   featureSelectPanel: false,
+     *   featureHoverPanel: false,
+     * });
+     * ```
+     */
+    setOnMapInteractionsUi(options: UiOnMapInteractionsOptions): void;
+    /**
+     * Shows a data table view for the specified layer, optionally sorted by a given attribute.
+     *
+     * @example
+     * ```typescript
+     * // Show data table with default sorting
+     * await felt.showLayerDataTable({
+     *   layerId: "layer-1",
+     * });
+     *
+     * // Show data table sorted by height in descending order
+     * await felt.showLayerDataTable({
+     *   layerId: "layer-1",
+     *   sorting: {
+     *     attribute: "height",
+     *     direction: "desc",
+     *   },
+     * });
+     *
+     * // Show the data table pane with no table visible
+     * await felt.showLayerDataTable();
+     * ```
+     */
+    showLayerDataTable(params?: {
+        layerId: string;
+        sorting?: SortConfig;
+    }): Promise<void>;
+    /**
+     * Hides the data table.
+     *
+     * @example
+     * ```typescript
+     * await felt.hideLayerDataTable();
+     * ```
+     */
+    hideLayerDataTable(): Promise<void>;
+}
+
 /**
  * The input type for setting the viewport to a particular center and zoom.
  *
@@ -7392,4 +8322,195 @@ declare const ViewportFitBoundsParamsSchema: z.ZodObject<{
     bounds: [number, number, number, number];
 }>;
 
-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 };
+/**
+ * The viewport controller allows you to control the viewport of the map.
+ *
+ * You can get the current viewport, move the viewport, and be notified when
+ * the viewport changes.
+ *
+ * @group Controller
+ * @public
+ */
+interface ViewportController {
+    /**
+     * Gets the current state of the viewport.
+     *
+     * @example
+     * ```typescript
+     * // Get current viewport state
+     * const viewport = await felt.getViewport();
+     * console.log({
+     *   center: viewport.center,
+     *   zoom: viewport.zoom,
+     * });
+     * ```
+     */
+    getViewport(): Promise<ViewportState>;
+    /**
+     * Moves the map to the specified location.
+     *
+     * @example
+     * ```typescript
+     * felt.setViewport({
+     *   center: { latitude: 0, longitude: 0 },
+     *   zoom: 10,
+     * });
+     * ```
+     */
+    setViewport(viewport: SetViewportCenterZoomParams): void;
+    /**
+     * Gets the current state of the viewport constraints.
+     *
+     * @example
+     * ```typescript
+     * // Get current viewport constraints
+     * const constraints = await felt.getViewportConstraints();
+     * if (constraints) {
+     *   console.log({
+     *     bounds: constraints.bounds,
+     *     minZoom: constraints.minZoom,
+     *     maxZoom: constraints.maxZoom
+     *   });
+     * } else {
+     *   console.log("No viewport constraints set");
+     * }
+     * ```
+     */
+    getViewportConstraints(): Promise<ViewportConstraints | null>;
+    /**
+     * Constrains the map viewport so it stays inside certain bounds and/or certain zoom levels.
+     *
+     * @example
+     * ```typescript
+     * felt.setViewportConstraints({
+     *   bounds: [-122.5372532, 37.6652478, -122.1927016, 37.881707],
+     *   minZoom: 1,
+     *   maxZoom: 23,
+     * });
+     * ```
+     *
+     * @example
+     * every constraint is optional
+     * ```typescript
+     * felt.setViewportConstraints({
+     *   bounds: [-122.5372532, 37.6652478, -122.1927016, 37.881707],
+     * });
+     * ```
+     *
+     * @example
+     * if a constraint is null, it will be removed but keeping the others
+     * ```typescript
+     * felt.setViewportConstraints({ bounds: null });
+     * ```
+     *
+     * @example
+     * if method receives null, it will remove the constraints
+     * ```typescript
+     * felt.setViewportConstraints(null);
+     * ```
+     */
+    setViewportConstraints(constraints: Partial<ViewportConstraints> | null): void;
+    /**
+     * Fits the map to the specified bounds.
+     *
+     * @example
+     * ```typescript
+     * const west = -122.4194;
+     * const south = 37.7749;
+     * const east = -122.4194;
+     * const north = 37.7749;
+     * felt.fitViewportToBounds({ bounds: [west, south, east, north] });
+     * ```
+     */
+    fitViewportToBounds(bounds: ViewportFitBoundsParams): void;
+    /**
+     * Adds a listener for when the viewport changes.
+     *
+     * @returns A function to unsubscribe from the listener
+     *
+     * @event
+     * @example
+     * ```typescript
+     * const unsubscribe = felt.onViewportMove({
+     *   handler: viewport => console.log(viewport.center.latitude),
+     * });
+     *
+     * // later on...
+     * unsubscribe();
+     * ```
+     */
+    onViewportMove(args: {
+        /**
+         * This callback is called with the current viewport state whenever
+         * the viewport changes.
+         *
+         * @param viewport - The current viewport state.
+         */
+        handler: (viewport: ViewportState) => void;
+    }): VoidFunction;
+    /**
+     * Adds a listener for when the viewport move ends, which is when the user
+     * stops dragging or zooming the map, animations have finished, or inertial
+     * dragging ends.
+     *
+     * @returns A function to unsubscribe from the listener
+     *
+     * @event
+     * @example
+     * ```typescript
+     * const unsubscribe = felt.onViewportMoveEnd({
+     *   handler: viewport => console.log(viewport.center.latitude),
+     * });
+     *
+     * // later on...
+     * unsubscribe();
+     * ```
+     */
+    onViewportMoveEnd(args: {
+        handler: (viewport: ViewportState) => void;
+    }): VoidFunction;
+    /**
+     * Adds a listener for when the map is idle, which is defined as:
+     * - No transitions are in progress
+     * - The user is not interacting with the map, e.g. by panning or zooming
+     * - All tiles for the current viewport have been loaded
+     * - Any fade transitions (e.g. for labels) have completed
+     *
+     * @returns A function to unsubscribe from the listener
+     *
+     * @event
+     * @example
+     * ```typescript
+     * const unsubscribe = felt.onMapIdle({ handler: () => console.log("map is idle") });
+     *
+     * // later on...
+     * unsubscribe();
+     * ```
+     */
+    onMapIdle(args: {
+        handler: () => void;
+    }): VoidFunction;
+}
+
+/**
+ * This is the main interface for interacting with a Felt map.
+ *
+ * This interface is composed of the various controllers, each having a
+ * different area of responsibility.
+ *
+ * All the methods are listed here, but each controller is documented on its
+ * own to make it easier to find related methods and events.
+ *
+ * @group Controller
+ * @public
+ */
+interface FeltController extends ViewportController, UiController, LayersController, ElementsController, SelectionController, InteractionsController, ToolsController, InteractionsController, MiscController {
+    /**
+     * The iframe element containing the Felt map, if it is an embedded map.
+     *
+     * @readonly
+     */
+    iframe: HTMLIFrameElement | null;
+}
+
+export type { LayerChangeCallbackParams as $, TextElementUpdate as A, ElementsController as B, CircleElementCreate as C, MapInteractionEvent as D, Element as E, FeltController as F, GetElementGroupsConstraint as G, HighlighterElementCreate as H, ImageElementCreate as I, InteractionsController as J, CreateLayersFromGeoJsonParams as K, LinkElementRead as L, MarkerElementCreate as M, NoteElementCreate as N, DataOnlyLayer as O, PathElementCreate as P, FeltTiledVectorSource as Q, GeoJsonDataVectorSource as R, GeoJsonFileVectorSource as S, TextElementCreate as T, UiControlsOptions as U, ViewportCenterZoom as V, GeoJsonUrlVectorSource as W, GetLayerGroupsConstraint as X, GetLayersConstraint as Y, GetRenderedFeaturesConstraint as Z, Layer as _, CircleElementRead as a, SetVisibilityRequest as a$, LayerCommon as a0, LayerGroup as a1, LayerGroupChangeCallbackParams as a2, LayerProcessingStatus as a3, LegendItem as a4, LegendItemChangeCallbackParams as a5, LegendItemIdentifier as a6, LegendItemsConstraint as a7, RasterBand as a8, RasterLayer as a9, GetLayerHistogramParams as aA, MultiAggregationConfig as aB, ValueConfiguration as aC, LayersController as aD, MapDetails as aE, MiscController as aF, ElementGroupNode as aG, ElementNode as aH, EntityNode as aI, FeatureNode as aJ, FeatureSelection as aK, LayerGroupNode as aL, LayerNode as aM, SelectionController as aN, FeltBoundary as aO, FeltZoom as aP, GeoJsonFeature as aQ, GeoJsonGeometry as aR, GeoJsonProperties as aS, LatLng as aT, LineStringGeometry as aU, LngLatTuple as aV, MultiLineStringGeometry as aW, MultiPointGeometry as aX, MultiPolygonGeometry as aY, PointGeometry as aZ, PolygonGeometry as a_, RasterLayerSource as aa, UpdateLayerParams as ab, VectorLayer as ac, LayerFeature as ad, RasterValue as ae, LayerSchema as af, LayerSchemaAttribute as ag, LayerSchemaBooleanAttribute as ah, LayerSchemaCommonAttribute as ai, LayerSchemaDateAttribute as aj, LayerSchemaDateTimeAttribute as ak, LayerSchemaNumericAttribute as al, LayerSchemaTextAttribute as am, FilterExpression as an, FilterLogicGate as ao, FilterTernary as ap, Filters as aq, GeometryFilter as ar, LayerBoundaries as as, LayerFilters as at, AggregationConfig as au, AggregationMethod as av, GetLayerCalculationParams as aw, GetLayerCategoriesGroup as ax, GetLayerCategoriesParams as ay, GetLayerHistogramBin as az, CircleElementUpdate as b, SortConfig as b0, SortDirection as b1, CircleToolSettings as b2, ConfigurableToolType as b3, HighlighterToolSettings as b4, InputToolSettings 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, ToolSettingsChangeEvent as bf, ToolSettingsMap as bg, ToolType as bh, ToolsController as bi, UiOnMapInteractionsOptions as bj, UiController as bk, SetViewportCenterZoomParams as bl, ViewportConstraints as bm, ViewportFitBoundsParams as bn, ViewportState as bo, ViewportController as bp, UnwrapPromise as bq, UnionToIntersection as br, PromiseOrNot as bs, ElementChangeCallbackParams as c, ElementCreate as d, ElementGroup as e, ElementGroupChangeCallbackParams as f, ElementUpdate as g, GetElementsConstraint as h, HighlighterElementRead as i, HighlighterElementUpdate as j, ImageElementRead as k, ImageElementUpdate as l, MarkerElementRead as m, MarkerElementUpdate as n, NoteElementRead as o, NoteElementUpdate as p, PathElementRead as q, PathElementUpdate as r, PlaceElementCreate as s, PlaceElementRead as t, PlaceElementUpdate as u, PolygonElementCreate as v, PolygonElementRead as w, PolygonElementUpdate as x, TextElementRead as y, zInfer as z };