@feltmaps/js-sdk 1.6.0-next.1 → 1.6.0

package/dist/client.d.cts

@@ -1,1016 +1,7 @@
-import { E as Element, G as GeoJsonGeometry, a as GetElementsConstraint, b as ElementGroup, c as GetElementGroupsConstraint, S as SetVisibilityRequest, d as ElementChangeCallbackParams, e as ElementGroupChangeCallbackParams, f as ElementCreate, g as ElementUpdate, M as MapInteractionEvent, h as MapDetails, i as EntityNode, F as FeatureSelection, T as ToolType, I as InputToolSettings, C as ConfigurableToolType, j as ToolSettingsMap, k as ToolSettingsChangeEvent, z as zInfer, l as SortConfig, V as ViewportState, m as SetViewportCenterZoomParams, n as ViewportConstraints, o as ViewportFitBoundsParams, L as LayersController, p as ViewportCenterZoom } from './types-0PFYQhMS.cjs';
-export { aH as AggregationConfig, aI as AggregationMethod, q as CircleElementCreate, r as CircleElementRead, s as CircleElementUpdate, b6 as CircleToolSettings, a1 as CreateLayersFromGeoJsonParams, a2 as DataOnlyLayer, aQ as ElementGroupNode, aR as ElementNode, aS as FeatureNode, aV as FeltBoundary, a3 as FeltTiledVectorSource, aW as FeltZoom, az as FilterExpression, aA as FilterLogicGate, aB as FilterTernary, aC as Filters, a4 as GeoJsonDataVectorSource, aX as GeoJsonFeature, a5 as GeoJsonFileVectorSource, aY as GeoJsonProperties, a6 as GeoJsonUrlVectorSource, aD as GeometryFilter, aJ as GetLayerCalculationParams, aK as GetLayerCategoriesGroup, aL as GetLayerCategoriesParams, a7 as GetLayerGroupsConstraint, aM as GetLayerHistogramBin, aN as GetLayerHistogramParams, a8 as GetLayersConstraint, a9 as GetRenderedFeaturesConstraint, H as HighlighterElementCreate, t as HighlighterElementRead, u as HighlighterElementUpdate, b7 as HighlighterToolSettings, v as ImageElementCreate, w as ImageElementRead, x as ImageElementUpdate, aZ as LatLng, aa as Layer, aF as LayerBoundaries, aG as LayerBoundary, ab as LayerChangeCallbackParams, ac as LayerCommon, ap as LayerFeature, aE as LayerFilters, ad as LayerGroup, ae as LayerGroupChangeCallbackParams, aT as LayerGroupNode, aU as LayerNode, af as LayerProcessingStatus, ar as LayerSchema, as as LayerSchemaAttribute, at as LayerSchemaBooleanAttribute, au as LayerSchemaCommonAttribute, av as LayerSchemaDateAttribute, aw as LayerSchemaDateTimeAttribute, ax as LayerSchemaNumericAttribute, ay as LayerSchemaTextAttribute, ag as LegendItem, ah as LegendItemChangeCallbackParams, ai as LegendItemIdentifier, aj as LegendItemsConstraint, a_ as LineStringGeometry, b8 as LineToolSettings, y as LinkElementRead, a$ as LngLatTuple, A as MarkerElementCreate, B as MarkerElementRead, D as MarkerElementUpdate, b9 as MarkerToolSettings, aO as MultiAggregationConfig, b0 as MultiLineStringGeometry, b1 as MultiPointGeometry, b2 as MultiPolygonGeometry, N as NoteElementCreate, J as NoteElementRead, K as NoteElementUpdate, ba as NoteToolSettings, P as PathElementCreate, O as PathElementRead, Q as PathElementUpdate, bb as PinToolSettings, R as PlaceElementCreate, U as PlaceElementRead, W as PlaceElementUpdate, bc as PlaceFrame, bd as PlaceSymbol, b3 as PointGeometry, X as PolygonElementCreate, Y as PolygonElementRead, Z as PolygonElementUpdate, b4 as PolygonGeometry, be as PolygonToolSettings, ak as RasterBand, al as RasterLayer, am as RasterLayerSource, aq as RasterValue, bf as RouteToolSettings, b5 as SortDirection, _ as TextElementCreate, $ as TextElementRead, a0 as TextElementUpdate, bg as TextToolSettings, an as UpdateLayerParams, aP as ValueConfiguration, ao as VectorLayer } from './types-0PFYQhMS.cjs';
+import { z as zInfer, U as UiControlsOptions, V as ViewportCenterZoom, F as FeltController } from './controller-C5gGWnaM.cjs';
+export { au as AggregationConfig, av as AggregationMethod, C as CircleElementCreate, a as CircleElementRead, b as CircleElementUpdate, b2 as CircleToolSettings, b3 as ConfigurableToolType, K as CreateLayersFromGeoJsonParams, O as DataOnlyLayer, E as Element, c as ElementChangeCallbackParams, d as ElementCreate, e as ElementGroup, f as ElementGroupChangeCallbackParams, aG as ElementGroupNode, aH as ElementNode, g as ElementUpdate, B as ElementsController, aI as EntityNode, aJ as FeatureNode, aK as FeatureSelection, aO as FeltBoundary, Q as FeltTiledVectorSource, aP as FeltZoom, an as FilterExpression, ao as FilterLogicGate, ap as FilterTernary, aq as Filters, R as GeoJsonDataVectorSource, aQ as GeoJsonFeature, S as GeoJsonFileVectorSource, aR as GeoJsonGeometry, aS as GeoJsonProperties, W as GeoJsonUrlVectorSource, ar as GeometryFilter, G as GetElementGroupsConstraint, h as GetElementsConstraint, aw as GetLayerCalculationParams, ax as GetLayerCategoriesGroup, ay as GetLayerCategoriesParams, X as GetLayerGroupsConstraint, az as GetLayerHistogramBin, aA as GetLayerHistogramParams, Y as GetLayersConstraint, Z as GetRenderedFeaturesConstraint, H as HighlighterElementCreate, i as HighlighterElementRead, j as HighlighterElementUpdate, b4 as HighlighterToolSettings, I as ImageElementCreate, k as ImageElementRead, l as ImageElementUpdate, b5 as InputToolSettings, J as InteractionsController, aT as LatLng, _ as Layer, as as LayerBoundaries, $ as LayerChangeCallbackParams, a0 as LayerCommon, ad as LayerFeature, at as LayerFilters, a1 as LayerGroup, a2 as LayerGroupChangeCallbackParams, aL as LayerGroupNode, aM as LayerNode, a3 as LayerProcessingStatus, af as LayerSchema, ag as LayerSchemaAttribute, ah as LayerSchemaBooleanAttribute, ai as LayerSchemaCommonAttribute, aj as LayerSchemaDateAttribute, ak as LayerSchemaDateTimeAttribute, al as LayerSchemaNumericAttribute, am as LayerSchemaTextAttribute, aD as LayersController, a4 as LegendItem, a5 as LegendItemChangeCallbackParams, a6 as LegendItemIdentifier, a7 as LegendItemsConstraint, aU as LineStringGeometry, b6 as LineToolSettings, L as LinkElementRead, aV as LngLatTuple, aE as MapDetails, D as MapInteractionEvent, M as MarkerElementCreate, m as MarkerElementRead, n as MarkerElementUpdate, b7 as MarkerToolSettings, aF as MiscController, aB as MultiAggregationConfig, aW as MultiLineStringGeometry, aX as MultiPointGeometry, aY as MultiPolygonGeometry, N as NoteElementCreate, o as NoteElementRead, p as NoteElementUpdate, b8 as NoteToolSettings, bj as OnMapInteractionsOptions, P as PathElementCreate, q as PathElementRead, r as PathElementUpdate, b9 as PinToolSettings, s as PlaceElementCreate, t as PlaceElementRead, u as PlaceElementUpdate, ba as PlaceFrame, bb as PlaceSymbol, aZ as PointGeometry, v as PolygonElementCreate, w as PolygonElementRead, x as PolygonElementUpdate, a_ as PolygonGeometry, bc as PolygonToolSettings, a8 as RasterBand, a9 as RasterLayer, aa as RasterLayerSource, ae as RasterValue, bd as RouteToolSettings, aN as SelectionController, bl as SetViewportCenterZoomParams, a$ as SetVisibilityRequest, b0 as SortConfig, b1 as SortDirection, T as TextElementCreate, y as TextElementRead, A as TextElementUpdate, be as TextToolSettings, bf as ToolSettingsChangeEvent, bg as ToolSettingsMap, bh as ToolType, bi as ToolsController, bk as UiController, ab as UpdateLayerParams, aC as ValueConfiguration, ac as VectorLayer, bm as ViewportConstraints, bp as ViewportController, bn as ViewportFitBoundsParams, bo as ViewportState } from './controller-C5gGWnaM.cjs';
 import { z } from 'zod';
 
-/**
- * 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>;
-}
-
-/**
- * The Interactions controller allows you to observe interactions with the map
- *
- * @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;
-}
-
-/**
- * @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>;
-}
-
-/**
- * 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>;
-}
-
-/**
- * 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 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;
-}
-
 /**
  * @group Instantiation
  * @public
@@ -1174,4 +165,4 @@ declare const Felt: {
     connect(feltWindow: Pick<Window, "postMessage">): Promise<FeltController>;
 };
 
-export { ConfigurableToolType, Element, ElementChangeCallbackParams, ElementCreate, ElementGroup, ElementGroupChangeCallbackParams, ElementUpdate, type ElementsController, EntityNode, FeatureSelection, Felt, type FeltController, type FeltEmbedOptions, GeoJsonGeometry, GetElementGroupsConstraint, GetElementsConstraint, InputToolSettings, type InteractionsController, LayersController, MapDetails, MapInteractionEvent, type MiscController, type UiOnMapInteractionsOptions as OnMapInteractionsOptions, type SelectionController, SetViewportCenterZoomParams, SetVisibilityRequest, SortConfig, ToolSettingsChangeEvent, ToolSettingsMap, ToolType, type ToolsController, type UiController, type UiControlsOptions, ViewportCenterZoom, ViewportConstraints, type ViewportController, ViewportFitBoundsParams, ViewportState };
+export { Felt, FeltController, type FeltEmbedOptions, UiControlsOptions, ViewportCenterZoom };