@geoscene/map-components 4.33.20 → 5.0.19

package/dist/components/geoscene-map/customElement.d.ts

@@ -1,449 +1,1319 @@
-/// <reference types="@geoscene/core/interfaces.d.ts" />
-/// <reference types="../../index.d.ts" />
-import { Use } from '@geoscene/lumina/controllers';
-import { Nil } from '@arcgis/components-utils';
-import { default as MapView } from '@geoscene/core/views/MapView.js';
-import { default as WebMap } from '@geoscene/core/WebMap.js';
-import { PublicLitElement as LitElement, TargetedEvent } from '@geoscene/lumina';
+/// <reference path="../../index.d.ts" />
+import type MapView from "@geoscene/core/views/MapView.js";
+import type Collection from "@geoscene/core/core/Collection.js";
+import type Layer from "@geoscene/core/layers/Layer.js";
+import type Analysis from "@geoscene/core/analysis/Analysis.js";
+import type Point from "@geoscene/core/geometry/Point.js";
+import type Viewpoint from "@geoscene/core/Viewpoint.js";
+import type Ground from "@geoscene/core/Ground.js";
+import type GamepadSettings from "@geoscene/core/views/input/gamepad/GamepadSettings.js";
+import type Basemap from "@geoscene/core/Basemap.js";
+import type Map from "@geoscene/core/Map.js";
+import type LayerView from "@geoscene/core/views/layers/LayerView.js";
+import type ColorBackground from "@geoscene/core/webmap/background/ColorBackground.js";
+import type BasemapView from "@geoscene/core/views/BasemapView.js";
+import type MapViewConstraints from "@geoscene/core/views/2d/MapViewConstraints.js";
+import type Error from "@geoscene/core/core/Error.js";
+import type Graphic from "@geoscene/core/Graphic.js";
+import type HighlightOptions from "@geoscene/core/views/support/HighlightOptions.js";
+import type IPSInfo from "@geoscene/core/webdoc/IPSInfo.js";
+import type Magnifier from "@geoscene/core/views/Magnifier.js";
+import type Navigation from "@geoscene/core/views/navigation/Navigation.js";
+import type Popup from "@geoscene/core/widgets/Popup.js";
+import type SelectionManager from "@geoscene/core/views/SelectionManager.js";
+import type SpatialReference from "@geoscene/core/geometry/SpatialReference.js";
+import type Theme from "@geoscene/core/views/Theme.js";
+import type TimeExtent from "@geoscene/core/time/TimeExtent.js";
+import type Polygon from "@geoscene/core/geometry/Polygon.js";
+import type { PublicLitElement as LitElement } from "@geoscene/lumina";
+import type { LoadErrorSource } from "../types.js";
+import type { GeoscenePopup } from "../geoscene-popup/customElement.js";
+import type { LayerView2DFor, ResizeAlign } from "@geoscene/core/views/2d/types.js";
+import type { DoubleClickEvent, DoubleTapDragEvent, VerticalTwoFingerDragEvent, PointerUpEvent, PointerMoveEvent, PointerLeaveEvent, PointerEnterEvent, PointerDownEvent, ViewMouseWheelEvent, LayerViewDestroyEvent, LayerViewCreateErrorEvent, LayerViewCreateEvent, KeyUpEvent, KeyDownEvent, ImmediateDoubleClickEvent, ImmediateClickEvent, HoldEvent, DragEvent, ClickEvent } from "@geoscene/core/views/input/types.js";
+import type { AnalysisViewDestroyEvent, AnalysisViewCreateErrorEvent, AnalysisViewCreateEvent, ToScreenOptions2D, Screenshot, UserSettings, ViewHitTestResult, HitTestOptions, GoToOptions2D, GoToTarget2D } from "@geoscene/core/views/types.js";
+import type { AnalysisView2DUnion } from "@geoscene/core/views/2d/analysis/types.js";
+import type { ScreenPoint } from "@geoscene/core/core/types.js";
+import type { ViewPopupOpenOptions } from "@geoscene/core/views/PopupView.js";
+import type { ReadonlyCollection } from "@geoscene/core/core/Collection.js";
+import type { ViewPadding } from "@geoscene/core/views/ui/types.js";
 
-declare const useWebMap: (component: LitElement & Omit<Pick<WebMap, "basemap" | "focusAreas" | "ground" | "ipsInfo" | "layers" | "bookmarks" | "tables" | "presentation" | "widgets" | "applicationProperties" | "authoringApp" | "authoringAppVersion" | "floorInfo" | "geotriggersInfo" | "initialViewProperties" | "portalItem" | "thumbnailUrl" | "utilityNetworks">, "basemap" | "ground" | ("destroyed" | "initialized" | "declaredClass" | "set" | "watch" | "addHandles" | "removeHandles" | "hasHandles") | "layers" | "bookmarks" | "tables" | "presentation" | "widgets" | "applicationProperties" | "authoringApp" | "authoringAppVersion" | "floorInfo" | "geotriggersInfo" | "initialViewProperties" | "portalItem" | "thumbnailUrl" | "utilityNetworks"> & {
-    autoDestroyDisabled: boolean;
-    destroy: () => Promise<void>;
-}) => WebMap;
-declare const useMapView: (component: LitElement & Omit<Pick<MapView, "container" | "map" | "background" | "basemapView" | "center" | "constraints" | "extent" | "fatalError" | "graphics" | "highlights" | "navigation" | "padding" | "popup" | "resizeAlign" | "rotation" | "scale" | "spatialReference" | "theme" | "timeExtent" | "timeZone" | "viewpoint" | "zoom" | "floors" | "highlightOptions" | "breakpoints" | "heightBreakpoint" | "popupEnabled" | "spatialReferenceLocked" | "widthBreakpoint" | "ui" | "animation" | "displayFilterEnabled">, "container" | ("destroyed" | "initialized" | "declaredClass" | "set" | "watch" | "addHandles" | "removeHandles" | "hasHandles") | "breakpoints" | "heightBreakpoint" | "popupEnabled" | "spatialReferenceLocked" | "widthBreakpoint" | "ui" | "animation" | "displayFilterEnabled"> & {
-    autoDestroyDisabled: boolean;
-    destroy: () => Promise<void>;
-}) => MapView;
 /**
  * The GeoScene Map component is used to add 2D maps to web applications. For 3D maps, use the
- * [GeoScene Scene component](https://doc.geoscene.cn/javascript/4.33/references/map-components/geoscene-scene/).
+ * [geoscene-scene](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-scene/).
  *
- * The Map component creates a [MapView](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-views-MapView.html) and loads a WebMap from either [GeoScene Online](https://www.geosceneonline.cn/geoscene/webapps/home) or [GeoScene Enterprise portal](https://enterprise.geoscene.cn/en/portal/latest/administer/windows/what-is-portal-for-geoscene-.htm).
+ * #### Initializing the Map component
+ * The Map component creates a [MapView](https://doc.geoscene.cn/javascript/5.0/references/core/views/MapView/)
+ * and can be initialized in one of three ways:
+ *
+ * ##### 1. Using a WebMap
+ * Load a [WebMap](https://doc.geoscene.cn/javascript/5.0/references/core/WebMap/) from [GeoScene Online](https://www.geosceneonline.cn/geoscene/webapps/home)
+ * or an [GeoScene Enterprise portal](https://enterprise.geoscene.cn/en/portal/latest/administer/windows/what-is-portal-for-geoscene-.htm) by specifying the [itemId](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#itemId) attribute.
  *
  * ```html
  * <geoscene-map item-id="05e015c5f0314db9a487a9b46cb37eca"></geoscene-map>
  * ```
  *
- * Alternatively, the Map component can be initialized without a WebMap item.
+ * ##### 2. Setting Map component attributes directly
+ * Define the Map component using attributes like [basemap](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#basemap), [center](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#center), and [zoom](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#zoom) directly.
  *
  * ```html
- * <geoscene-map basemap="satellite" center="-154.88, 19.46" zoom="15"></geoscene-map>
+ * <geoscene-map basemap="tianditu-vector" center="-154.88, 19.46" zoom="15"></geoscene-map>
+ * ```
+ *
+ * ##### 3. Providing a Map instance
+ * Alternatively, you can provide your own [Map](https://doc.geoscene.cn/javascript/5.0/references/core/Map/) instance to the component.
+ * This allows full control over map configuration, including [basemap](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#basemap), operational [layers](https://doc.geoscene.cn/javascript/5.0/references/core/Map/#layers)
+ * and [spatialReference](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#spatialReference). See the [Select features by rectangle sample](https://doc.geoscene.cn/javascript/5.0/sample-code/highlight-features-by-geometry/)
+ * for an example of this approach in action.
+ *
+ * ```html
+ * <geoscene-map></geoscene-map>
+ * <script type="module">
+ *   const viewElement = document.querySelector("geoscene-map");
+ *
+ *   // set the basemap of the map to states feature layer
+ *   // add national parks feature layer and a polygon graphics layer
+ *   viewElement.map = new Map({
+ *     basemap: new Basemap({ baseLayers: [states] }),
+ *     layers: [nationalParksLayer, polygonGraphicsLayer]
+ *   });
+ *
+ *   // set the spatial reference of the map to NAD 1983 Albers contiguous USA
+ *   viewElement.spatialReference = { wkid: 102003 };
+ * </script>
  * ```
+ * #### Adding components and customizing the Map
  *
  * Other components can be added and connected to the Map component.
  *
  * ```html
  * <geoscene-map item-id="05e015c5f0314db9a487a9b46cb37eca">
- *  <geoscene-zoom position="top-left"></geoscene-zoom>
- *  <geoscene-legend position="bottom-left"></geoscene-legend>
+ *   <geoscene-zoom slot="top-left"></geoscene-zoom>
+ *   <geoscene-legend slot="bottom-left"></geoscene-legend>
  * </geoscene-map>
  * ```
  *
- * The Map component can be customized further using any of the [core API functionalities](https://doc.geoscene.cn/javascript/4.33/api-reference/) of the GeoScene Maps SDK for JavaScript.
+ * The Map component can be customized further using any of the [core API functionalities](https://doc.geoscene.cn/javascript/5.0/references/core/) of the GeoScene Maps SDK for JavaScript.
  *
  * ```js
  * const viewElement = document.querySelector("geoscene-map");
  * viewElement.addEventListener("geosceneViewReadyChange", () => {
- *  const layer = new GraphicsLayer({ title: "My Layer" });
- *  viewElement.map.add(layer);
+ *   const layer = new GraphicsLayer({ title: "My Layer" });
+ *   viewElement.map.add(layer);
  * });
  * ```
  *
  * See also:
- * - [SDK sample apps using the Map component](https://doc.geoscene.cn/javascript/4.33/sample-code/?tagged=geoscene-map)
- * - [Get started](https://doc.geoscene.cn/javascript/4.33/get-started/)
- * - [Programming patterns](https://doc.geoscene.cn/javascript/4.33/programming-patterns/)
+ * - [SDK sample apps using the Map component](https://doc.geoscene.cn/javascript/5.0/sample-code/?tagged=geoscene-map)
+ * - [Get started](https://doc.geoscene.cn/javascript/5.0/get-started/)
+ * - [Programming patterns](https://doc.geoscene.cn/javascript/5.0/programming-patterns/)
  *
- * [Read more...](https://doc.geoscene.cn/javascript/4.33/references/map-components/geoscene-map/)
+ * @cssproperty [--geoscene-layout-overlay-space-top] - _Since 4.34_ Specifies the top padding for the layout.
+ * @cssproperty [--geoscene-layout-overlay-space-bottom] - _Since 4.34_ Specifies the bottom padding for the layout.
+ * @cssproperty [--geoscene-layout-overlay-space-left] - _Since 4.34_ Specifies the left padding for the layout.
+ * @cssproperty [--geoscene-layout-overlay-space-right] - _Since 4.34_ Specifies the right padding for the layout.
+ * @cssproperty [--geoscene-view-color-focus] - _Since 5.0_ Specifies the focus outline color for the view.
+ * @slot  - Default slot for adding components to the map. User is responsible for positioning the content via CSS.
+ * @slot [top-left] - Slot for components positioned in the top-left corner.
+ * @slot [top-right] - Slot for components positioned in the top-right corner.
+ * @slot [bottom-left] - Slot for components positioned in the bottom-left corner.
+ * @slot [bottom-right] - Slot for components positioned in the bottom-right corner.
+ * @slot [top-start] - Slot for components positioned at the top-start (top-left in LTR, top-right in RTL).
+ * @slot [top-end] - Slot for components positioned at the top-end (top-right in LTR, top-left in RTL).
+ * @slot [bottom-start] - Slot for components positioned at the bottom-start (bottom-left in LTR, bottom-right in RTL).
+ * @slot [bottom-end] - Slot for components positioned at the bottom-end (bottom-right in LTR, bottom-left in RTL).
+ * @slot [popup] - Slot for the [geoscene-popup](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-popup/) component to open automatically on click. Only the Popup component can be placed in this slot.
+ * @since 4.28
  */
-export declare class GeosceneMap extends LitElement {
-    /** The [MapView](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-views-MapView.html) instance created and manged by the component. Accessible once the component is fully loaded. */
-    readonly view: MapView;
-    /**
-     * Collection containing a flat list of all the created LayerViews
-     * related to the basemap, operational layers, and group layers in this view.
-     */
-    readonly allLayerViews: __geoscene.Collection<__geoscene.LayerView>;
-    /**
-     * If true, the component will not be destroyed automatically when it is
-     * disconnected from the document. This is useful when you want to move the
-     * component to a different place on the page, or temporarily hide it. If this
-     * is set, make sure to call the [destroy](https://doc.geoscene.cn/javascript/4.33/references/map-components/geoscene-map/#destroy) method when you are done to
-     * prevent memory leaks.
-     *
-     * @default false
-     */
-    autoDestroyDisabled: boolean;
-    /**
-     * The background color of the MapView. If the view's map changes, the view's `background` is reset to the map's background,
-     * even if the user set it previously.
-     *
-     * @default null
-     */
-    background: nullish | __geoscene.ColorBackground;
-    /**
-     * Specifies a basemap for the map. The basemap is a set of layers that give
-     * geographic context to the view and the other operational layers
-     * in the map.
-     * It can either be set using a basemap ID string ([see values](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-Map.html#basemap)),
-     * [Basemap](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-Basemap.html)
-     * or [BasemapStyle](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-support-BasemapStyle.html).
-     *
-     * [Read more](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-Map.html#basemap)
-     */
-    basemap?: __geoscene.Basemap | string;
-    /** Represents the view for a single basemap after it has been added to the map. */
-    basemapView: __geoscene.BasemapView;
-    /**
-     * Represents the view's center point; when setting the center, you may pass a
-     * geoscene/geometry/Point instance or a string representing
-     * a longitude/latitude pair (`"-100.4593, 36.9014"`).
-     * Setting the center immediately changes the current view.
-     * For animating the view, see this component's goTo() method.
-     */
-    get center(): __geoscene.MapView["center"];
-    set center(newValue: __geoscene.MapView["center"] | Nil | number[] | string);
-    /** Specifies constraints to scale, zoom, and rotation that may be applied to the MapView. */
-    constraints: __geoscene.View2DConstraints;
-    /**
-     * Indicates whether layer's displayFilter are honored when rendering layers in the view.
-     * If `false`, display filters are ignored and all features are rendered.
-     *
-     * @default false
-     */
-    displayFilterDisabled: boolean;
-    /**
-     * The extent represents the visible portion of a map within the view as an instance of geoscene/geometry/Extent.
-     * Setting the extent immediately changes the view without animation. To animate
-     * the view, see this component's goTo() method.
-     * When the view is rotated, the extent does not update to include the newly visible portions of the map.
-     */
-    get extent(): __geoscene.MapView["extent"];
-    set extent(newValue: __geoscene.MapView["extent"]);
-    /** A rejected view indicates a fatal error making it unable to display. */
-    fatalError: nullish | __geoscene.Error;
-    /**
-     * Applies a display filter on the view for a specific set of floor levels.
-     * It can filter the map display on floor-aware layers by zero or more level IDs.
-     */
-    floors: __geoscene.Collection<string>;
-    /** Gamepad input specific configuration settings. */
-    get gamepad(): __geoscene.GamepadSettings;
-    /**
-     * Allows for adding graphics directly to the default graphics in the View.
-     *
-     * @example
-     * ```js
-     * // Adds a graphic to the View
-     * graphics.add(pointGraphic);
-     * ```
-     * @example
-     * ```js
-     * // Removes a graphic from the View
-     * graphics.remove(pointGraphic);
-     * ```
-     */
-    graphics: __geoscene.Collection<__geoscene.Graphic>;
-    /** Specifies the surface properties for the map. */
-    get ground(): typeof this._map.ground;
-    set ground(value: __geoscene.Ground | string);
-    /**
-     * The highlights property is a collection of HighlightGroup objects that
-     * allow you to visually emphasize specific features on the map.
-     */
-    highlights: __geoscene.Collection<__geoscene.HighlightOptions>;
-    /**
-     * Options for configuring the highlight.
-     *
-     * @deprecated
-     * since 4.33, use [highlights](https://doc.geoscene.cn/javascript/4.33/references/map-components/geoscene-map/#highlights) instead.
-     *
-     * Options for configuring the highlight. Use the highlight method on the
-     * appropriate geoscene/views/layers/LayerView to highlight a feature.
-     * The layerView's `highlightOptions` will take precedence over the MapView's `highlightOptions` if both properties are set.
-     */
-    highlightOptions: __geoscene.HighlightOptions;
-    /**
-     * Indication whether the view is being interacted with (for example when panning or by an interactive tool).
-     *
-     * @default false
-     */
-    get interacting(): boolean;
-    /** Contains indoor positioning system information for the map. */
-    ipsInfo: nullish | __geoscene.IPSInfo;
-    /**
-     * The ID of a WebMap from GeoScene Online or GeoScene Enterprise portal.
-     *
-     * To configure the portal url you must set the [`portalUrl` property on `config`](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-config.html#portalUrl) before the Map component loads.
-     */
-    get itemId(): Nil | string;
-    set itemId(newValue: Nil | string);
-    /**
-     * A collection containing a hierarchical list of all the created
-     * geoscene/views/layers/LayerView LayerViews of the
-     * geoscene/Map#layers operational layers in the map.
-     */
-    readonly layerViews: __geoscene.Collection<__geoscene.LayerView>;
-    /** The magnifier allows for showing a portion of the view as a magnifier image on top of the view. */
-    readonly magnifier: __geoscene.Magnifier;
-    /** An instance of a geoscene/Map object to display in the view. */
-    map: __geoscene.Map | nullish;
-    /**
-     * Indication whether the view is being navigated (for example when panning).
-     *
-     * @default false
-     */
-    get navigating(): boolean;
-    /** Options to configure the navigation behavior of the View. */
-    navigation: __geoscene.Navigation;
-    /**
-     * Use the padding property to make the [center](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-views-MapView.html#center),
-     * and [extent](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-views-MapView.html#extent), etc.
-     *
-     * @default {left: 0, top: 0, right: 0, bottom: 0}
-     */
-    padding: __geoscene.ViewPadding;
-    /**
-     * A [Popup](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Popup.html) object that displays general content or attributes from
-     * [layers](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-Map.html#layers) in the [map](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-views-View2D.html#map).
-     *
-     * [Read more...](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-views-View2D.html#popup)
-     */
-    popup: nullish | __geoscene.Popup;
-    /**
-     * Controls whether the popup opens when users click on the view.
-     *
-     * @default false
-     */
-    popupDisabled: boolean;
-    /**
-     * When `true`, this property indicates whether the view successfully satisfied all dependencies,
-     * signaling that the following conditions are met.
-     *
-     * @default false
-     */
-    readonly ready: boolean;
-    /**
-     * Defines which anchor stays still while resizing the browser window. The default, `center`,
-     * ensures the view's center point remains constantly visible as the window size changes. The other
-     * options allow  the respective portion of the view to remain visible when the window's size is changed.
-     *
-     * @default "center"
-     */
-    resizeAlign: "center" | "bottom-left" | "bottom-right" | "top-left" | "top-right" | "left" | "right" | "top" | "bottom";
-    /**
-     * Represents the current value of one pixel in the unit of the view's spatialReference.
-     * The value of resolution is calculated by dividing the view's extent width
-     * by its width.
-     */
-    readonly resolution: number;
-    /**
-     * The clockwise rotation of due north in relation to the top of the view in degrees.
-     * The view may be rotated by directly setting
-     * the rotation or by using the following mouse event: `Right-click + Drag`.
-     * Map rotation may be disabled by setting the `rotationEnabled` property
-     * in [constraints](#constraints) to `false`. See the code snippet below for
-     * an example of this.
-     *
-     * @default 0
-     */
-    rotation: number;
-    /**
-     * Represents the map scale at the center of the view. Setting the scale immediately changes the view. For animating
-     * the view, see this component's goTo() method.
-     */
-    get scale(): number;
-    set scale(newValue: number);
-    /**
-     * The spatial reference of the view.
-     * This indicates the projected or geographic coordinate system used
-     * to locate geographic features in the map.
-     *
-     * @default null
-     */
-    spatialReference: __geoscene.SpatialReference;
-    /**
-     * Indication whether the view is animating, being navigated with or resizing.
-     *
-     * @default false
-     */
-    get stationary(): boolean;
-    /**
-     * Indicates if the view is visible on the page.
-     *
-     * @default true
-     */
-    readonly suspended: boolean;
-    /**
-     * This property specifies the base colors used by some widgets
-     * and components to render graphics and labels.
-     *
-     * @default null
-     */
-    theme: nullish | __geoscene.Theme;
-    /**
-     * The view's time extent. Time-aware layers display their temporal data that falls within
-     * the view's time extent. Setting the view's time extent is similar to setting the spatial
-     * extent because once the time extent is set, the
-     * view updates automatically to conform to the change.
-     *
-     * @default null
-     */
-    timeExtent: nullish | __geoscene.TimeExtent;
-    /**
-     * Defines the time zone of the view.
-     * The time zone property determines how dates and times are represented to the user,
-     * but the underlying data is unchanged.
-     *
-     * @default "system"
-     */
-    timeZone: string;
-    /**
-     * Indicates whether the view is being updated by additional data requests to the network,
-     * or by processing received data.
-     *
-     * @default false
-     */
-    readonly updating: boolean;
-    /**
-     * Represents the current view as a Viewpoint or point of observation on the view.
-     * Setting the viewpoint immediately changes the current view. For animating
-     * the view, see this component's goTo() method.
-     */
-    get viewpoint(): __geoscene.Viewpoint;
-    set viewpoint(newValue: __geoscene.Viewpoint);
-    /**
-     * The visibleArea represents the visible portion of a [map](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-Map.html) within the view as
-     * an instance of a [Polygon](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-geometry-Polygon.html).
-     *
-     * [Read more...](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-views-View2D.html#visibleArea)
-     */
-    readonly visibleArea: nullish | __geoscene.Polygon;
-    /**
-     * Represents the level of detail (LOD) at the center of the view.
-     * A zoom level (or scale) is a number that defines how large or small the contents of a map appear in a map view.
-     * Zoom level is a number usually between 0 (global view) and 23 (very detailed view) and is used as a shorthand for predetermined scale values.
-     * A value of -1 means the view has no LODs.
-     * When setting the zoom value, the MapView converts it to the corresponding scale, or interpolates it if the zoom is a fractional number.
-     * MapView can display maps with different projections at a full range of scales, and so use the scale property on this component rather than zoom level.
-     *
-     * Setting the zoom immediately changes the current view. For animating the view, see this component's goTo() method.
-     * Setting this property in conjunction with `center` is a convenient way to set the initial extent of the view.
-     */
-    get zoom(): number;
-    set zoom(newValue: number);
-    /**
-     * @deprecated
-     * since 4.33, use `element.map.add(layer)` instead.
-     *
-     * Adds a layer to the map layers collection.
-     */
-    addLayer(layer: __geoscene.Layer | Promise<any>, index?: number): Promise<void>;
-    /**
-     * @deprecated
-     * since 4.33, use `element.map.addMany([layer])` instead.
-     *
-     * Adds a layer or array of layers to the map layers collection.
-     */
-    addLayers(layers: __geoscene.Layer[], index?: number): Promise<void>;
-    /**
-     * @deprecated
-     * since 4.33, use `element.map.tables.add(table)` instead.
-     *
-     * Adds a table to the map tables collection.
-     */
-    addTable(table: __geoscene.FeatureLayer): Promise<void>;
-    /**
-     * @deprecated
-     * since 4.33, use `element.map.tables.addMany([table])` instead.
-     *
-     * Adds a table or array of tables to the map tables collection.
-     */
-    addTables(tables: __geoscene.FeatureLayer[], index?: number): Promise<void>;
-    /** Closes the popup. */
-    closePopup(): Promise<void>;
-    /** Destroys the view, and any associated resources, including its map, popup, and UI elements. */
-    destroy(): Promise<void>;
-    /** Sets the view to a given target. */
-    goTo(target: __geoscene.GoToTarget2D, options?: __geoscene.GoToOptions2D): Promise<unknown>;
-    /** Returns hit test results from each layer that intersects the specified screen coordinates. */
-    hitTest(screenPoint: __geoscene.MapViewScreenPoint | MouseEvent, options?: __geoscene.MapViewHitTestOptions): Promise<__geoscene.HitTestResult>;
-    /**
-     * Opens the popup at the given location with content defined either explicitly with content or driven
-     * from the PopupTemplate of input features.
-     */
-    openPopup(options?: __geoscene.PopupViewOpenPopupOptions): Promise<void>;
-    /** Create a screenshot of the current view. */
-    takeScreenshot(options?: __geoscene.MapViewTakeScreenshotOptions): Promise<__geoscene.Screenshot>;
-    toMap(screenPoint: __geoscene.MapViewScreenPoint | MouseEvent): __geoscene.Point;
-    toScreen(point: __geoscene.Point, options?: __geoscene.ToScreenOptions2D): __geoscene.MapViewScreenPoint | nullish;
-    /** Call this method to clear any fatal errors resulting from a lost WebGL context. */
-    tryFatalErrorRecovery(): Promise<void>;
-    /** Gets the LayerView created on the view for the given layer. */
-    whenLayerView(layer: __geoscene.Layer): Promise<__geoscene.LayerView>;
-    /**
-     * `viewOnReady()` may be leveraged once an instance of the component and its underlying [view](https://doc.geoscene.cn/javascript/4.33/references/map-components/geoscene-map/#view) is created and ready.
-     * This method takes two input parameters, a `callback` function and an `errback` function, and returns a promise. The `callback` executes when the promise resolves, and the `errback` executes if the promise is rejected.
-     *
-     * @since 4.33
-     * @see [Watch for changes - waiting for components or views to be ready](https://doc.geoscene.cn/javascript/4.33/watch-for-changes/#waiting-for-components-or-views-to-be-ready)
-     * @example
-     * ```js
-     * const viewElement = document.querySelector("geoscene-map");
-     * await viewElement.viewOnReady();
-     * // The view is now ready to be used.
-     * viewElement.map.add(new FeatureLayer({...}));
-     * ```
-     */
-    viewOnReady(callback?: () => void, errback?: (error: Error) => void): Promise<void>;
-    /**
-     * This event is for view related property changes: zoom, scale, center, rotation, extent, camera, viewpoint.
-     * This event will also emit if stationary toggles from true to false.
-     */
-    readonly geosceneViewChange: TargetedEvent<this, void>;
-    /** Fires after a user clicks on the view. */
-    readonly geosceneViewClick: TargetedEvent<this, __geoscene.ViewClickEvent>;
-    /** Fires after double-clicking on the view. */
-    readonly geosceneViewDoubleClick: TargetedEvent<this, __geoscene.ViewDoubleClickEvent>;
-    /** Fires during a pointer drag on the view. */
-    readonly geosceneViewDrag: TargetedEvent<this, __geoscene.ViewDragEvent>;
-    /** Fires during a pointer drag on the view. */
-    readonly geosceneViewHold: TargetedEvent<this, __geoscene.ViewHoldEvent>;
-    /** Fires right after a user clicks on the view. */
-    readonly geosceneViewImmediateClick: TargetedEvent<this, __geoscene.ViewImmediateClickEvent>;
-    /** Is emitted after two consecutive immediate-click events. */
-    readonly geosceneViewImmediateDoubleClick: TargetedEvent<this, __geoscene.ViewImmediateDoubleClickEvent>;
-    /** Fires after a keyboard key is pressed. */
-    readonly geosceneViewKeyDown: TargetedEvent<this, __geoscene.ViewKeyDownEvent>;
-    /** Fires after a keyboard key is pressed. */
-    readonly geosceneViewKeyUp: TargetedEvent<this, __geoscene.ViewKeyUpEvent>;
-    /** Fires after each layer in the map has a corresponding LayerView created and rendered in the view. */
-    readonly geosceneViewLayerviewCreate: TargetedEvent<this, __geoscene.ViewLayerviewCreateEvent>;
-    /** Fires when an error emits during the creation of a LayerView after a layer has been added to the map. */
-    readonly geosceneViewLayerviewCreateError: TargetedEvent<this, __geoscene.ViewLayerviewCreateErrorEvent>;
-    /** Fires after a LayerView is destroyed and is no longer rendered in the view. */
-    readonly geosceneViewLayerviewDestroy: TargetedEvent<this, __geoscene.ViewLayerviewDestroyEvent>;
-    /** Fires when a wheel button of a pointing device (typically a mouse) is scrolled on the view. */
-    readonly geosceneViewMouseWheel: TargetedEvent<this, __geoscene.ViewMouseWheelEvent>;
-    /** Fires after a mouse button is pressed, or a finger touches the display. */
-    readonly geosceneViewPointerDown: TargetedEvent<this, __geoscene.ViewPointerDownEvent>;
-    /** Fires after a mouse cursor enters the view, or a display touch begins. */
-    readonly geosceneViewPointerEnter: TargetedEvent<this, __geoscene.ViewPointerEnterEvent>;
-    /** Fires after a mouse cursor leaves the view, or a display touch ends. */
-    readonly geosceneViewPointerLeave: TargetedEvent<this, __geoscene.ViewPointerLeaveEvent>;
-    /** Fires after the mouse or a finger on the display moves. */
-    readonly geosceneViewPointerMove: TargetedEvent<this, __geoscene.ViewPointerMoveEvent>;
-    /** Fires after a mouse button is released, or a display touch ends. */
-    readonly geosceneViewPointerUp: TargetedEvent<this, __geoscene.ViewPointerUpEvent>;
-    /**
-     * This event is for the `ready` property and will be emitted when the view is ready.
-     * This event will also emit if the `map` property is changed.
-     */
-    readonly geosceneViewReadyChange: TargetedEvent<this, void>;
-    private _map: __geoscene.Map;
-    readonly _setterTypes: {
-        center?: __geoscene.MapView["center"] | Nil | number[] | string;
-        ground?: __geoscene.Ground | string;
-    };
-}
-export {};
+export abstract class GeosceneMap extends LitElement {
+  /**
+   * Collection containing a flat list of all the created LayerViews
+   * related to the basemap, operational layers, and group layers in this view.
+   *
+   * @see [LayerView](https://doc.geoscene.cn/javascript/5.0/references/core/views/layers/LayerView/)
+   */
+  get allLayerViews(): ReadonlyCollection<LayerView>;
+  /**
+   * A collection of analyses associated with the view.
+   *
+   * @since 4.34
+   * @example
+   * // Adds an analysis to the View
+   * view.analyses.add(elevationProfileAnalysis);
+   * @example
+   * // Removes an analysis from the View
+   * view.analyses.remove(elevationProfileAnalysis);
+   */
+  accessor analyses: Collection<Analysis>;
+  /**
+   * Indicates whether animations are disabled in the view. This includes animated symbols (animated
+   * [CIMSymbol](https://doc.geoscene.cn/javascript/5.0/references/core/symbols/CIMSymbol/),
+   * [PictureMarkerSymbol](https://doc.geoscene.cn/javascript/5.0/references/core/symbols/PictureMarkerSymbol/)
+   * from a GIF/animated PNG), animated renderers
+   * ([FlowRenderer](https://doc.geoscene.cn/javascript/5.0/references/core/rasterRenderers/#FlowRenderer)),
+   * animated layers ([MediaLayer](https://doc.geoscene.cn/javascript/5.0/references/core/layers/MediaLayer/),
+   * [VideoLayer](https://doc.geoscene.cn/javascript/5.0/references/core/layers/VideoLayer/)), and
+   * animations triggered by view navigation (for example,
+   * [goTo()](https://doc.geoscene.cn/javascript/5.0/references/core/views/MapView/#goTo)).
+   * Setting this property to `true` disables all animations in the view.
+   *
+   * @default false
+   * @since 4.34
+   */
+  accessor animationsDisabled: boolean;
+  /**
+   * The ARIA attributes for the view container. Provides accessibility information to assistive technologies such as screen readers. Supports the following properties: [`label`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Reference/Attributes/aria-label), [`description`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Reference/Attributes/aria-description), [`describedByElements`](https://developer.mozilla.org/en-US/docs/Web/API/Element/ariaDescribedByElements), and [`labelledByElements`](https://developer.mozilla.org/en-US/docs/Web/API/Element/ariaLabelledByElements).
+   *
+   * @since 4.34
+   */
+  accessor aria: MapView["aria"];
+  /**
+   * The attribution items displayed in the view's attribution.
+   *
+   * @since 5.0
+   */
+  get attributionItems(): MapView["attributionItems"];
+  /**
+   * The light or dark mode used to display the attribution.
+   * By default, the mode is inherited from the [Calcite's mode](https://doc.geoscene.cn/calcite-design-system/core-concepts/#modes).
+   * You can override the value to style the attribution alongside the map or scene content.
+   *
+   * @since 5.0
+   */
+  accessor attributionMode: "dark" | "light" | null | undefined;
+  /**
+   * If true, the component will not be destroyed automatically when it is
+   * disconnected from the document. This is useful when you want to move the
+   * component to a different place on the page, or temporarily hide it. If this
+   * is set, make sure to call the [destroy()](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#destroy) method when you are done to
+   * prevent memory leaks.
+   *
+   * @default false
+   */
+  accessor autoDestroyDisabled: boolean;
+  /**
+   * The background color of the Map component.
+   *
+   * @example
+   * let view = new MapView({
+   *   container: "viewDiv",
+   *   map: map,
+   *   background: { // autocasts new ColorBackground()
+   *     color: "magenta" // autocasts as new Color()
+   *   }
+   * });
+   */
+  accessor background: ColorBackground | null | undefined;
+  /**
+   * Specifies a basemap for the map. The basemap is a set of layers that give
+   * geographic context to the view and the other operational layers
+   * in the map.
+   * It can either be set using a basemap ID string ([see values](https://doc.geoscene.cn/javascript/5.0/references/core/Map/#basemap)),
+   * [Basemap](https://doc.geoscene.cn/javascript/5.0/references/core/Basemap/)
+   * or [BasemapStyle](https://doc.geoscene.cn/javascript/5.0/references/core/support/BasemapStyle/).
+   *
+   * [Read more](https://doc.geoscene.cn/javascript/5.0/references/core/Map/#basemap)
+   */
+  accessor basemap: Basemap | string | undefined;
+  /** Represents the view for a single basemap after it has been added to the map. */
+  accessor basemapView: BasemapView<LayerView>;
+  /**
+   * Indicates if the view component can zoom in.
+   *
+   * @default false
+   * @since 5.0
+   */
+  get canZoomIn(): boolean;
+  /**
+   * Indicates if the view component can zoom out.
+   *
+   * @default false
+   * @since 5.0
+   */
+  get canZoomOut(): boolean;
+  /**
+   * Represents the view's center point; when setting the center, you may pass a
+   * [Point](https://doc.geoscene.cn/javascript/5.0/references/core/geometry/Point/) instance, numbers representing
+   * a longitude/latitude pair (`[-100.4593, 36.9014]`), or a string attribute representing a longitude/latitude pair ("-100.4593, 36.9014").
+   * Setting the `center` immediately changes the current view. For animating the view, see this component's [goTo()](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#goTo) method.
+   *
+   * The returned [Point](https://doc.geoscene.cn/javascript/5.0/references/core/geometry/Point/) object is always
+   * in the spatial reference of the view and may be modified internally.
+   * To persist the returned object, create a clone using [clone()](https://doc.geoscene.cn/javascript/5.0/references/core/geometry/Point/#clone) method.
+   *
+   * **Notes**
+   *
+   * * If the spatial reference of `center` set in the constructor does not match the [spatialReference](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#spatialReference) of the view, then the
+   * [projectOperator](https://doc.geoscene.cn/javascript/5.0/references/core/geometry/operators/projectOperator/) will be loaded dynamically.
+   * * At runtime, the [projectOperator](https://doc.geoscene.cn/javascript/5.0/references/core/geometry/operators/projectOperator/) must be
+   * [loaded](https://doc.geoscene.cn/javascript/5.0/references/core/geometry/operators/projectOperator/#load) when
+   * setting the `center` to a spatial reference that doesn't match the view spatial reference. You can check if the projectOperator is
+   * loaded prior to setting the center by calling [isLoaded()](https://doc.geoscene.cn/javascript/5.0/references/core/geometry/operators/projectOperator/#isLoaded)
+   * method. If it is not yet loaded, you can call [load()](https://doc.geoscene.cn/javascript/5.0/references/core/geometry/operators/projectOperator/#load) method.
+   *
+   * @example
+   * ```html
+   * <geoscene-map zoom="4" center="-98, 39"></geoscene-map>
+   * ```
+   * @example
+   * ```js
+   * // Sets the initial center point of the map component to lon/lat coordinates
+   * // lon/lat will be projected to match the spatial reference of the view
+   * const viewElement = document.querySelector("geoscene-map");
+   * viewElement.center = [-98, 39]; // lon, lat
+   * ```
+   * @example
+   * ```js
+   * // Updates the view's center point to a pre-determined Point object
+   * let centerPoint = new Point({
+   *   x: 12804.24,
+   *   y: -1894032.09,
+   *   spatialReference: {
+   *     wkid: view.spatialReference  // wkid 2027
+   *   }
+   * });
+   * const viewElement = document.querySelector("geoscene-map");
+   * view.center = centerPoint;
+   * ```
+   * @example
+   * ```js
+   * // the point's spatialReference does not match the view's spatialReference
+   * // the projectOperator will be used to project the point to match
+   * // the view's spatialReference
+   * const centerPoint = new Point({
+   *   x: -8746995,
+   *   y: 4352308,
+   *   spatialReference: {
+   *     wkid: 8857
+   *   }
+   * });
+   * if (!projectOperator.isLoaded()) {
+   *   await projectOperator.load();
+   * }
+   * const viewElement = document.querySelector("geoscene-map");
+   * viewElement.center = centerPoint;
+   * ```
+   */
+  get center(): MapView["center"];
+  set center(value: MapView["center"] | null | undefined | number[] | string);
+  /**
+   * Specifies constraints to scale, zoom, and rotation that may be applied to the Map.
+   *
+   * @see [MapViewConstraints](https://doc.geoscene.cn/javascript/5.0/references/core/views/2d/MapViewConstraints/)
+   * @see [TileInfo#create()](https://doc.geoscene.cn/javascript/5.0/references/core/layers/support/TileInfo/#create)
+   * @see [Zoom and LODs](https://doc.geoscene.cn/javascript/5.0/references/core/views/View2D/#mapview-lods)
+   * @example
+   * view.constraints = new MapViewConstraints({
+   *   geometry: { // Constrain lateral movement to Lower Manhattan
+   *     type: "extent",
+   *     xmin: -74.020,
+   *     ymin:  40.700,
+   *     xmax: -73.971,
+   *     ymax:  40.73
+   *   },
+   *   minScale: 500000, // User cannot zoom out beyond a scale of 1:500,000
+   *   maxScale: 0, // User can overzoom tiles
+   *   rotationEnabled: false // Disables map rotation
+   * });
+   * @example
+   * // This snippet shows how to set the Map scale 1:1 while generating additional LODs for the constraints.
+   * const spatialReference = new SpatialReference({
+   *   wkid: 2154
+   * });
+   * const center = new Point({
+   *   x: 0,
+   *   y: 0,
+   *   spatialReference
+   * });
+   *
+   * // Create LODs from level 0 to 31
+   * const tileInfo = TileInfo.create({
+   *   spatialReference,
+   *   numLODs: 32
+   * });
+   * const lods = tileInfo.lods;
+   *
+   * const constraints = new MapViewConstraints({
+   *   snapToZoom: false,
+   *   lods
+   * });
+   *
+   * const geosceneMap = document.querySelector("geoscene-map");
+   * geosceneMap.spatialReference = spatialReference;
+   * geosceneMap.center = center;
+   * geosceneMap.scale = 1;
+   * geosceneMap.constraints = constraints;
+   */
+  accessor constraints: MapViewConstraints;
+  /**
+   * Indicates whether a layer's `displayFilterInfo` is honored when rendering layers in the view.
+   * If `false`, display filters are ignored and all features are rendered.
+   *
+   * @default false
+   */
+  accessor displayFilterDisabled: boolean;
+  /**
+   * The extent represents the visible portion of a map within the view as an instance of [Extent](https://doc.geoscene.cn/javascript/5.0/references/core/geometry/Extent/).
+   * Setting the extent immediately changes the view without animation. To animate
+   * the view, see this component's [goTo()](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#goTo) method.
+   * When the view is rotated, the extent does not update to include the newly visible portions of the map.
+   *
+   * **Notes**
+   *
+   * * If the spatial reference of `extent` set does not match the [spatialReference](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#spatialReference) of the view, then the
+   * [projectOperator](https://doc.geoscene.cn/javascript/5.0/references/core/geometry/operators/projectOperator/) will be loaded dynamically.
+   * * At runtime, the [projectOperator](https://doc.geoscene.cn/javascript/5.0/references/core/geometry/operators/projectOperator/)
+   * must be [loaded](https://doc.geoscene.cn/javascript/5.0/references/core/geometry/operators/projectOperator/#load) when
+   * setting the `extent` to a spatial reference that doesn't match the view spatial reference. You can check if the projectOperator is
+   * loaded prior to setting the extent by calling [isLoaded()](https://doc.geoscene.cn/javascript/5.0/references/core/geometry/operators/projectOperator/#isLoaded)
+   * method. If it is not yet loaded, you can call the [load](https://doc.geoscene.cn/javascript/5.0/references/core/geometry/operators/projectOperator/#load) method.
+   */
+  accessor extent: MapView["extent"];
+  /**
+   * A rejected view indicates a fatal error making it unable to display.
+   *
+   * @since 4.12
+   * @see [tryFatalErrorRecovery()](https://doc.geoscene.cn/javascript/5.0/references/core/views/View/#tryFatalErrorRecovery)
+   * @example
+   * reactiveUtils.when(
+   *   () => view.fatalError,
+   *   () => {
+   *     console.error("Fatal Error! View has lost its WebGL context. Attempting to recover...");
+   *     view.tryFatalErrorRecovery();
+   *   }
+   * );
+   */
+  accessor fatalError: Error<any> | null | undefined;
+  /**
+   * Applies a display filter on the view for a specific set of floor levels.
+   * It can filter the map display on floor-aware layers by zero or more level IDs.
+   */
+  accessor floors: Collection<string>;
+  /** Gamepad input specific configuration settings. */
+  get gamepad(): GamepadSettings;
+  /**
+   * Allows for adding graphics directly to the default graphics in the View.
+   *
+   * @example
+   * ```js
+   * // Adds a graphic to the View
+   * graphics.add(pointGraphic);
+   * ```
+   * @example
+   * ```js
+   * // Removes a graphic from the View
+   * graphics.remove(pointGraphic);
+   * ```
+   * @see [Graphic](https://doc.geoscene.cn/javascript/5.0/references/core/Graphic/)
+   * @see [GraphicsLayer](https://doc.geoscene.cn/javascript/5.0/references/core/layers/GraphicsLayer/)
+   * @see [Intro to graphics](https://doc.geoscene.cn/javascript/5.0/sample-code/intro-graphics/)
+   */
+  accessor graphics: Collection<Graphic>;
+  /**
+   * Specifies the surface properties for the map.
+   *
+   * @see [ElevationLayer](https://doc.geoscene.cn/javascript/5.0/references/core/layers/ElevationLayer/)
+   * @see [Ground](https://doc.geoscene.cn/javascript/5.0/references/core/Ground/)
+   * @example
+   * // Use the world elevation service
+   * const map = new Map({
+   *   basemap: "tianditu-vector",
+   *   ground: "world-elevation"
+   * });
+   * @example
+   * // Create a map with the world elevation layer overlaid by a custom elevation layer
+   * const worldElevation = new ElevationLayer({
+   *   url: "//elevation3d.geoscene.cn/geoscene/rest/services/WorldElevation3D/Terrain3D/ImageServer"
+   * });
+   * const customElevation = new ElevationLayer({
+   *   url: "https://my.server.com/geoscene/rest/service/MyElevationService/ImageServer"
+   * });
+   * const map = new Map({
+   *   basemap: "tianditu-vector",
+   *   ground: new Ground({
+   *    layers: [ worldElevation, customElevation ]
+   *   })
+   * });
+   */
+  get ground(): Ground;
+  set ground(value: Ground | string);
+  /**
+   * Indicates whether the attribution is hidden in the view.
+   *
+   * GeoScene requires that when you use a GeoScene Online basemap in your app, the map must include GeoScene attribution and you must be licensed to use the content.
+   * For detailed guidelines on working with attribution, please visit the official [attribution in your app](https://doc.geoscene.cn/terms/attribution/) documentation.
+   * For information on terms of use, see the [Terms of Use FAQ](https://doc.geoscene.cn/terms/faq/).
+   *
+   * @default false
+   * @since 5.0
+   */
+  accessor hideAttribution: boolean;
+  /**
+   * Represents a collection of [HighlightOptions](https://doc.geoscene.cn/javascript/5.0/references/core/views/support/HighlightOptions/)
+   * objects which can be used to highlight features throughout an application. Highlighting works by applying highlight options to one or
+   * more features. You can configure these options (such as color or opacity) to define how a feature will be visually
+   * emphasized.
+   *
+   * A maximum of six [HighlightOptions](https://doc.geoscene.cn/javascript/5.0/references/core/views/support/HighlightOptions/)
+   * objects are supported in the collection, and they can be added, removed, and reordered freely. Their order in the collection determines priority, with the last
+   * object having the highest priority. If you apply more than one highlight to a feature, the one that is last within
+   * the collection will be applied. The [HighlightOptions](https://doc.geoscene.cn/javascript/5.0/references/core/views/support/HighlightOptions/)
+   * object must be part of this collection in order to be applied to features.
+   *
+   * To highlight a feature, use the [highlight()](https://doc.geoscene.cn/javascript/5.0/references/core/views/layers/FeatureLayerView/#highlight)
+   * method on the relevant [LayerView](https://doc.geoscene.cn/javascript/5.0/references/core/views/layers/LayerView/) instance. To apply specific
+   * [HighlightOptions](https://doc.geoscene.cn/javascript/5.0/references/core/views/support/HighlightOptions/), include the
+   * [name](https://doc.geoscene.cn/javascript/5.0/references/core/views/support/HighlightOptions/#name) in the `highlight()` method's `options` parameter.
+   * If no `name` is provided, the feature will use the `default` highlight options.
+   *
+   * The table below shows the default highlight options in the View's highlights collection if the collection has not
+   * been modified:
+   *
+   * | Highlight options name | Description | Default settings |
+   * | ---------------------- | ----------- | ---------------- |
+   * | default                | The default highlight options. Used when `layerView.highlight()` is called without specifying any particular highlight options. | ` { name: "default", color: "cyan", haloOpacity: 1, fillOpacity: 0.25, shadowColor: "black", shadowOpacity: 0.4, shadowDifference: 0.2}` |
+   * | temporary              | The temporary highlight options, pre-configured for common use cases such as hovering over a feature in the view. | `{ name: "temporary", color: "yellow", haloOpacity: 1, fillOpacity: 0.25, shadowColor: "black", shadowOpacity: 0.4, shadowDifference: 0.2 }` |
+   *
+   * @see [Sample: Highlight features by geometry](https://doc.geoscene.cn/javascript/5.0/sample-code/highlight-features-by-geometry/)
+   * @see [Sample: Highlight point features](https://doc.geoscene.cn/javascript/5.0/sample-code/highlight-point-features/)
+   * @since 4.32
+   * @example
+   * // Use the default highlights collection to apply a highlight to features when you hover over them
+   *
+   * // A handler can be used to remove any previous highlight when applying a new one
+   * let hoverHighlight;
+   *
+   * view.on("pointer-move", (event) => {
+   *   // Search for the first feature in the featureLayer at the hovered location
+   *   view.hitTest(event, { include: featureLayer }).then((response) => {
+   *     if (response.results[0]) {
+   *        const graphic = response.results[0].graphic;
+   *        view.whenLayerView(graphic.layer).then((layerView) => {
+   *          // Remove any previous highlight, if it exists
+   *          hoverHighlight?.remove();
+   *          // Highlight the hit features with the temporary highlight options, which are pre-configured for this use case
+   *          hoverHighlight = layerView.highlight(graphic, { name: "temporary"});
+   *        });
+   *     }
+   *   });
+   * });
+   * @example
+   * // Override the default highlights collection
+   *
+   * const view = new MapView({
+   *   map: map,
+   *   container: "viewDiv",
+   *
+   *   // Set the highlight options to be used in the view
+   *   highlights: [
+   *     { name: "default", color: "orange" },
+   *     { name: "temporary", color: "magenta" },
+   *     { name: "table", color: "cyan", fillOpacity: 0.5, haloOpacity: 0}
+   *   ]
+   * });
+   * @example
+   * // Add highlight options to the collection after initialization
+   *
+   * const selectionHighlightOptions = {
+   *   name: "selection",
+   *   color: "#ff00ff", // bright fuchsia
+   *   haloOpacity: 0.8,
+   *   fillOpacity: 0.2
+   * };
+   *
+   * // Add the options to the highlights collection at the first position
+   * view.highlights.add(selectionGroup, 0);
+   */
+  accessor highlights: Collection<HighlightOptions>;
+  /**
+   * Indicates whether the view is being interacted with (for example, when panning or via an interactive tool).
+   *
+   * @default false
+   */
+  get interacting(): boolean;
+  /**
+   * Contains indoor positioning system information for the map.
+   *
+   * @since 4.31
+   */
+  accessor ipsInfo: IPSInfo | null | undefined;
+  /**
+   * The ID of a WebMap from GeoScene Online or GeoScene Enterprise portal.
+   *
+   * To configure the portal url you must set the [`portalUrl` property on `config`](https://doc.geoscene.cn/javascript/5.0/references/core/config/#portalUrl) before the Map component loads.
+   */
+  accessor itemId: null | undefined | string;
+  /**
+   * A collection containing a hierarchical list of all the created
+   * [LayerView](https://doc.geoscene.cn/javascript/5.0/references/core/views/layers/LayerView/)s of the
+   * [operational layers](https://doc.geoscene.cn/javascript/5.0/references/core/Map/#layers) in the map.
+   *
+   * @see [LayerView](https://doc.geoscene.cn/javascript/5.0/references/core/views/layers/LayerView/)
+   */
+  get layerViews(): Collection<LayerView>;
+  /**
+   * An array of objects that encountered an error while loading the component or any of its dependencies (e.g., basemap, ground, layers, tables). You may inspect the errors by accessing each object's `loadError` property.
+   *
+   * @since 4.34
+   */
+  accessor loadErrorSources: LoadErrorSource[] | undefined;
+  /**
+   * The magnifier allows for showing a portion of the view as a magnifier image on top of the view.
+   *
+   * @since 4.19
+   */
+  get magnifier(): Magnifier;
+  /** An instance of a [Map](https://doc.geoscene.cn/javascript/5.0/references/core/Map/) object to display in the view. */
+  accessor map: Map | null | undefined;
+  /**
+   * Indication whether the view is being navigated (for example when panning).
+   *
+   * @default false
+   */
+  get navigating(): boolean;
+  /**
+   * Options to configure the navigation behavior of the View.
+   *
+   * @since 4.9
+   * @example
+   * // Disable the gamepad usage, single touch panning, panning momentum and mouse wheel zooming.
+   * const view = new MapView({
+   *   container: "viewDiv",
+   *   map: new Map({
+   *     basemap: "tianditu-vector"
+   *   }),
+   *   center: [176.185, -37.643],
+   *   zoom: 13,
+   *   navigation: {
+   *     gamepad: {
+   *       enabled: false
+   *     },
+   *     actionMap: {
+   *       dragSecondary: "none", // Disable rotating the view with the right mouse button
+   *       mouseWheel: "none" // Disable zooming with the mouse wheel
+   *     },
+   *     browserTouchPanEnabled: false,
+   *     momentumEnabled: false,
+   *   }
+   * });
+   */
+  accessor navigation: Navigation;
+  /**
+   * Padding to make the map's center and extent work off a
+   * subsection of the full map. This is particularly useful when layering UI
+   * elements or semi-transparent content on top of portions of the map.
+   *
+   * @default {left: 0, top: 0, right: 0, bottom: 0}
+   * @see [Sample: Map padding](https://doc.geoscene.cn/javascript/5.0/sample-code/map-padding/)
+   */
+  accessor padding: ViewPadding;
+  /**
+   * A [Popup](https://doc.geoscene.cn/javascript/5.0/references/core/widgets/Popup/) widget object that displays general content or attributes from [layers](https://doc.geoscene.cn/javascript/5.0/references/core/Map/#layers) in the [map](https://doc.geoscene.cn/javascript/5.0/references/core/views/View/#map). Consider using the [popupElement](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#popupElement) (beta), which represents the Popup component, instead.
+   *
+   * By default, the `popup` property is an empty object that allows you to set the popup options. A [Popup](https://doc.geoscene.cn/javascript/5.0/references/core/widgets/Popup/) instance is automatically created and assigned to the view's [popup](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#popup) when the user clicks on the view and [popupEnabled](https://doc.geoscene.cn/javascript/5.0/references/core/views/PopupView/#popupEnabled) is `true`, when the [openPopup()](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#openPopup) method is called, or when some widgets need the popup, such as [Search](https://doc.geoscene.cn/javascript/5.0/references/core/widgets/Search/). If [popup](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#popup) is `null`, the popup instance will not be created.
+   *
+   * @see [popupElement](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#popupElement)
+   * @see [popupDisabled](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#popupDisabled)
+   * @see [openPopup()](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#openPopup)
+   */
+  accessor popup: Popup | null | undefined;
+  /**
+   * Indicates whether the [popup component](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#popupElement) (beta) is enabled  as the default popup. When set to `true`, the [popupElement](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#popupElement) property (representing the component) will be used for popups instead of the [popup](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#popup) property (representing the widget).
+   *
+   * **Note:** This is a beta feature and may change in future releases. At version 6.0, the Popup component will be used by default instead of the Popup widget and the `popup-component-enabled` attribute will no longer be necessary.
+   *
+   * @default false
+   * @beta
+   * @since 5.0
+   * @see [popupElement](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#popupElement)
+   * @example
+   * ```html
+   * <geoscene-map item-id="WEBMAP-ID" popup-component-enabled></geoscene-map>
+   * ```
+   */
+  accessor popupComponentEnabled: boolean;
+  /**
+   * Controls whether the default popup opens automatically when users click on the view. This controls both the [popupElement](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#popupElement) and [popup](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#popup) properties. When set to `true`, the popup will not open on click or when triggered programmatically.
+   *
+   * @default false
+   * @see [openPopup()](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#openPopup)
+   */
+  accessor popupDisabled: boolean;
+  /**
+   * A reference to the current [geoscene-popup](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-popup/) (beta). The [popupComponentEnabled](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#popupComponentEnabled) property must be set to `true` to use this property.
+   *
+   * **Note:** This is a beta feature and may change in future releases.
+   *
+   * @beta
+   * @since 5.0
+   * @see [popupComponentEnabled](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#popupComponentEnabled)
+   * @example
+   * ```html
+   * <geoscene-map item-id="WEBMAP-ID" popup-component-enabled></geoscene-map>
+   * <script type="module">
+   * const viewElement = document.querySelector("geoscene-map");
+   * await viewElement.viewOnReady();
+   * viewElement.popupElement.dockEnabled = true;
+   * viewElement.popupElement.dockOptions = {
+   *     buttonEnabled: false,
+   *     breakpoint: false,
+   *     position: "top-right",
+   * };
+   * </script>
+   * ```
+   */
+  get popupElement(): GeoscenePopup | null;
+  /**
+   * When `true`, this property indicates whether the [view](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#view) has successfully satisfied all dependencies, signaling that the following conditions are met:
+   *
+   * * The view has a [map](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#map). If [map](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#map)
+   * is a [WebMap](https://doc.geoscene.cn/javascript/5.0/references/core/WebMap/), then the map
+   * must be [loaded](https://doc.geoscene.cn/javascript/5.0/references/core/WebMap/#loaded).
+   * * The view has a [spatialReference](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#spatialReference), a [center](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#center), and a [scale](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#scale).
+   * These also can be inferred by setting an [extent](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#extent).
+   *
+   * When a view becomes ready it will resolve itself and invoke
+   * the callback defined in [viewOnReady()](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#viewOnReady) where code can execute on a working view.
+   *
+   * @default false
+   * @see [when()](https://doc.geoscene.cn/javascript/5.0/references/core/views/View/#when)
+   */
+  get ready(): boolean;
+  /**
+   * Defines which anchor stays still while resizing the browser window. The default, `center`,
+   * ensures the view's center point remains constantly visible as the window size changes. The other
+   * options allow  the respective portion of the view to remain visible when the window's size is changed.
+   *
+   * @default "center"
+   */
+  accessor resizeAlign: ResizeAlign;
+  /**
+   * Represents the current value of one pixel in the unit of the view's spatialReference.
+   * The value of resolution is calculated by dividing the view's extent width
+   * by its width.
+   *
+   * @since 4.9
+   */
+  get resolution(): number;
+  /**
+   * The clockwise rotation of due north in relation to the top of the view in degrees.
+   * The view may be rotated by directly setting
+   * the rotation or by using the following mouse event: `Right-click + Drag`.
+   * Map rotation may be disabled by setting the `rotationEnabled` property
+   * in [constraints](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#constraints) to `false`. See the code snippet below for
+   * an example of this.
+   *
+   * @default 0
+   * @example
+   * // Due north is rotated 90 degrees, pointing to the right side of the view
+   * view.rotation = 90;
+   * @example
+   * // Due north is rotated 180 degrees, pointing to the bottom of the view
+   * view.rotation = 180;
+   * @example
+   * // Due north is rotated 270 degrees, pointing to the left side of the view
+   * view.rotation = 270;
+   * @example
+   * // Due north is rotated 0 degrees, pointing to the top of the view (the default)
+   * view.rotation = 0; // 360 or multiple of 360 (e.g. 720) works here as well.
+   * @example
+   * // Disables map rotation
+   * view.constraints = {
+   *   rotationEnabled: false
+   * };
+   */
+  accessor rotation: number;
+  /**
+   * Represents the map scale at the center of the view. Setting the scale immediately changes the view. For animating
+   * the view, see this component's [goTo()](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#goTo) method.
+   */
+  accessor scale: number;
+  /**
+   * The default [SelectionManager](https://doc.geoscene.cn/javascript/5.0/references/core/views/SelectionManager/) for this view. Used to manage selections of features across layers.
+   *
+   * @since 5.0
+   * @beta
+   */
+  get selectionManager(): SelectionManager;
+  /**
+   * The spatial reference of the view. This indicates the projected or geographic coordinate system used to locate geographic features in the map.
+   * You can change the spatialReference of the view after it is initialized by either directly changing
+   * this property, or by changing the basemap from the [geoscene-basemap-gallery](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-basemap-gallery/)
+   * and [geoscene-basemap-toggle](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-basemap-toggle/) components.
+   * Set [spatialReferenceLocked](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#spatialReferenceLocked) property to `true` to prevent users from changing the view's spatial reference at runtime.
+   *
+   * Prior to changing the spatial reference, check if the [projectOperator](https://doc.geoscene.cn/javascript/5.0/references/core/geometry/operators/projectOperator/)
+   * is loaded by calling [projectOperator.isLoaded()](https://doc.geoscene.cn/javascript/5.0/references/core/geometry/operators/projectOperator/#isLoaded) method.
+   * If it is not yet loaded, call [projectOperator.load()](https://doc.geoscene.cn/javascript/5.0/references/core/geometry/operators/projectOperator/#load) method.
+   * If the `projectOperator` is not loaded, the view's [center](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#center) will default to `[0, 0]` in the new spatial reference of the view and a console error will be thrown.
+   *
+   * **Notes**
+   *
+   * * [LayerViews](https://doc.geoscene.cn/javascript/5.0/references/core/views/layers/LayerView/) not compatible with the view's spatial reference
+   * are not displayed. In such case, the layer view's [suspended](https://doc.geoscene.cn/javascript/5.0/references/core/views/layers/LayerView/#suspended)
+   * property is `true` and [spatialReferenceSupported](https://doc.geoscene.cn/javascript/5.0/references/core/views/layers/LayerView/#spatialReferenceSupported)
+   * property is `false`.
+   * * When setting view's spatial reference, the [center](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#center), [extent](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#extent) or [viewpoint](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#viewpoint) properties are projected to the new spatial
+   * reference. The [scale](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#scale) and [rotation](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#rotation) properties are adjusted to keep the content of the map at the same size and orientation on screen.
+   * * To ensure [TileLayers](https://doc.geoscene.cn/javascript/5.0/references/core/layers/TileLayer/) and
+   * [VectorTileLayers](https://doc.geoscene.cn/javascript/5.0/references/core/layers/VectorTileLayer/)
+   * are displayed in a [basemap](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#basemap) correctly, the spatialReference of the view must be set match their
+   * [tileInfo's](https://doc.geoscene.cn/javascript/5.0/references/core/layers/support/TileInfo/) spatial reference.
+   * * Switching spatial reference with an [imageCoordinateSystem](https://doc.geoscene.cn/javascript/5.0/references/core/geometry/SpatialReference/#imageCoordinateSystem)
+   * is not supported.
+   *
+   * @see [spatialReferenceLocked](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#spatialReferenceLocked)
+   * @example
+   * ```js
+   * const viewElement = document.querySelector("geoscene-map");
+   * // check if the projectOperator is loaded
+   * if (!projectOperator.isLoaded()) {
+   *   // load the projectOperator if it is not loaded
+   *   projectOperator.load().then(() => {
+   *    // change the spatial reference of the map component to equal earth projection
+   *     viewElement.spatialReference = new SpatialReference({
+   *       wkid: 54035 //equal earth projection
+   *     });
+   *   });
+   * } else {
+   *   // the projectOperator is already loaded.
+   *   // change the spatial reference of the view to equal earth projection
+   *   viewElement.spatialReference = new SpatialReference({
+   *     wkid: 54035 //equal earth projection
+   *   });
+   * }
+   * ```
+   */
+  accessor spatialReference: SpatialReference;
+  /**
+   * Indicates if the map's [spatialReference](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#spatialReference) can be changed after it is ready.
+   * The default is `false`, indicating the map's spatialReference can be changed at runtime.
+   * When true, basemaps with spatial references that do not match the map's spatial reference
+   * will be disabled in [geoscene-basemap-gallery](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-basemap-gallery/) and [geoscene-basemap-toggle](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-basemap-toggle/) components and the map's spatialReference cannot be changed at runtime.
+   *
+   * @default false
+   * @since 4.34
+   */
+  accessor spatialReferenceLocked: boolean;
+  /**
+   * Indication whether the view is animating, being navigated with or resizing.
+   *
+   * @default false
+   */
+  get stationary(): boolean;
+  /**
+   * Indicates if the view is visible on the page.
+   *
+   * @default false
+   */
+  get suspended(): boolean;
+  /**
+   * This property specifies the base colors used by some components to render graphics and labels.
+   *
+   * @since 4.28
+   * @see [Theme](https://doc.geoscene.cn/javascript/5.0/references/core/views/Theme/)
+   * @see [Sample - Color theming for interactive tools](https://doc.geoscene.cn/javascript/5.0/sample-code/view-theme/)
+   * @example
+   * // Update the theme to use purple graphics
+   * // and slightly transparent green text
+   * view.theme = new Theme({
+   *   accentColor: "purple",
+   *   textColor: [125, 255, 13, 0.9]
+   * });
+   */
+  accessor theme: Theme | null | undefined;
+  /**
+   * The view's time extent. Time-aware layers display their temporal data that falls within
+   * the view's time extent. Setting the view's time extent is similar to setting the spatial
+   * extent because once the time extent is set, the
+   * view updates automatically to conform to the change.
+   *
+   * @since 4.12
+   * @example
+   * // Create a csv layer from an online spreadsheet.
+   * let csvLayer = new CSVLayer({
+   *   url: "http://test.com/daily-magazines-sold-in-new-york.csv",
+   *   timeInfo: {
+   *     startField: "SaleDate" // The csv field contains date information.
+   *   }
+   * });
+   *
+   * // Create a mapview showing sales for the last week of March 2019 only.
+   * const view = new MapView({
+   *   map: map,
+   *   container: "viewDiv",
+   *   timeExtent: {
+   *     start: new Date("2019, 2, 24"),
+   *     end:   new Date("2019, 2, 31")
+   *   }
+   * });
+   */
+  accessor timeExtent: TimeExtent | null | undefined;
+  /**
+   * Defines the time zone of the view.
+   * The time zone property determines how dates and times are represented to the user,
+   * but the underlying data is unchanged.
+   *
+   * @default "system"
+   * @see [wikipedia - List of tz database time zones](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones)
+   * @example
+   * // Date and time will be displayed in Pacific/Auckland (NZ) time zone
+   * const view = new MapView({
+   *   map: map,
+   *   container: "viewDiv",
+   *   timeZone: "Pacific/Auckland"
+   * });
+   */
+  accessor timeZone: string;
+  /**
+   * Indicates whether the view is being updated by additional data requests to the network,
+   * or by processing received data.
+   *
+   * @default false
+   */
+  get updating(): boolean;
+  /** The [MapView](https://doc.geoscene.cn/javascript/5.0/references/core/views/MapView/) instance created and managed by the component. Accessible once the component is fully loaded. */
+  get view(): MapView;
+  /**
+   * Represents the current view as a Viewpoint or point of observation on the view.
+   * Setting the viewpoint immediately changes the current view. For animating
+   * the view, see this component's [goTo()](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#goTo) method.
+   */
+  accessor viewpoint: Viewpoint;
+  /**
+   * The visibleArea represents the visible portion of a [Map](https://doc.geoscene.cn/javascript/5.0/references/core/Map/) within the view as
+   * an instance of a [Polygon](https://doc.geoscene.cn/javascript/5.0/references/core/geometry/Polygon/). This is similar to the view
+   * [MapView#extent](https://doc.geoscene.cn/javascript/5.0/references/core/views/MapView/#extent) but is a more accurate representation of the visible area especially
+   * when the view is rotated. An example use of the visible area is to spatially filter visible features
+   * in a layer view query.
+   *
+   * @since 4.31
+   * @see [MapView#extent](https://doc.geoscene.cn/javascript/5.0/references/core/views/MapView/#extent)
+   */
+  get visibleArea(): Polygon | null | undefined;
+  /**
+   * Represents the level of detail (LOD) at the center of the map.
+   * A zoom level (or scale) is a number that defines how large or small the contents of a map appear in a Map component.
+   * Zoom level is a number usually between 0 (global view) and 23 (very detailed view) and is used as a shorthand for predetermined scale values.
+   * A value of -1 means the map has no LODs.
+   * When setting the zoom value, the component converts it to the corresponding scale, or interpolates it if the zoom is a fractional number.
+   *
+   * Setting the zoom immediately changes the current view. For animating the view, see this component's [goTo()](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#goTo) method.
+   * Setting this property in conjunction with `center` is a convenient way to set the initial extent of the view.
+   */
+  accessor zoom: number;
+  /** Closes the popup. */
+  closePopup(): Promise<void>;
+  /** Destroys the view, and any associated resources, including its map, popup, and UI elements. */
+  destroy(): Promise<void>;
+  /**
+   * Sets the view to a given target.
+   *
+   * @param target
+   * @param options
+   */
+  goTo(target: GoToTarget2D, options?: GoToOptions2D): Promise<unknown>;
+  /**
+   * Returns [hit test results](https://doc.geoscene.cn/javascript/5.0/references/core/views/MapView/#HitTestResult)
+   * from each layer that intersects the specified screen coordinates. The results are
+   * organized as an array of objects containing different [result types](https://doc.geoscene.cn/javascript/5.0/references/core/views/MapView/#HitTestResult).
+   *
+   * The following layer types will return all [features](https://doc.geoscene.cn/javascript/5.0/references/core/views/MapView/#GraphicHit) if a hit is
+   * made on intersecting features: [FeatureLayer](https://doc.geoscene.cn/javascript/5.0/references/core/layers/FeatureLayer/),
+   * [CatalogLayer](https://doc.geoscene.cn/javascript/5.0/references/core/layers/CatalogLayer/),
+   * [CSVLayer](https://doc.geoscene.cn/javascript/5.0/references/core/layers/CSVLayer/),
+   * [GeoJSONLayer](https://doc.geoscene.cn/javascript/5.0/references/core/layers/GeoJSONLayer/),
+   * [GeoRSSLayer](https://doc.geoscene.cn/javascript/5.0/references/core/layers/GeoRSSLayer/),
+   * [GraphicsLayer](https://doc.geoscene.cn/javascript/5.0/references/core/layers/GraphicsLayer/),
+   * [KMLLayer](https://doc.geoscene.cn/javascript/5.0/references/core/layers/KMLLayer/),
+   * [MapNotesLayer](https://doc.geoscene.cn/javascript/5.0/references/core/layers/MapNotesLayer/),
+   * [OGCFeatureLayer](https://doc.geoscene.cn/javascript/5.0/references/core/layers/OGCFeatureLayer/),
+   * [StreamLayer](https://doc.geoscene.cn/javascript/5.0/references/core/layers/StreamLayer/),
+   * [SubtypeSublayer](https://doc.geoscene.cn/javascript/5.0/references/core/layers/support/SubtypeSublayer/),
+   * [VectorTileLayer](https://doc.geoscene.cn/javascript/5.0/references/core/layers/VectorTileLayer/), and
+   * [WFSLayer](https://doc.geoscene.cn/javascript/5.0/references/core/layers/WFSLayer/).
+   *
+   * The [ParquetLayer](https://doc.geoscene.cn/javascript/5.0/references/core/layers/ParquetLayer/) hit result returns only the topmost feature
+   * when the hit occurs on overlapping features in a ParquetLayer.
+   *
+   * The [VectorTileLayer](https://doc.geoscene.cn/javascript/5.0/references/core/layers/VectorTileLayer/) hit test result contains an array of objects containing
+   * a [graphic](https://doc.geoscene.cn/javascript/5.0/references/core/views/MapView/#GraphicHit).
+   * The graphic returns attributes of a style layer. In addition, the graphic's [origin](https://doc.geoscene.cn/javascript/5.0/references/core/Graphic/#origin)
+   * contains the style layer's [id](https://maplibre.org/maplibre-style-spec/layers/#id) and layer index within the [vector tile style](https://doc.geoscene.cn/en/geoscene-online/reference/tile-layers.htm#GeoScene_SECTION1_8F68399EB47B48FF9EF46719FCC96978).
+   * Spatial information about the actual feature represented in the style layer is returned only if the style layer is a [symbol layer](https://maplibre.org/maplibre-style-spec/layers/#symbol).
+   * Otherwise, the graphic's geometry is `null`.
+   *
+   * The [MediaLayer](https://doc.geoscene.cn/javascript/5.0/references/core/layers/MediaLayer/) hit test result contains all media elements if the hit is made on intersecting elements.
+   * The [RouteLayer](https://doc.geoscene.cn/javascript/5.0/references/core/layers/RouteLayer/) hit test result contains all route elements if the hit is made on intersecting elements.
+   *
+   * If the [polygon](https://doc.geoscene.cn/javascript/5.0/references/core/geometry/Polygon/) feature's symbol
+   * [style](https://doc.geoscene.cn/javascript/5.0/references/core/symbols/SimpleFillSymbol/#style) is set to `none`, the hitTest method will not
+   * return results when the fill is clicked. However, it will return results when the outline is clicked. To get results when clicking the fill, set the
+   * [color](https://doc.geoscene.cn/javascript/5.0/references/core/symbols/SimpleFillSymbol/#color) to a transparent color instead.
+   *
+   * @param screenPoint
+   * @param options
+   * @example
+   * ```js
+   * viewElement.addEventListener("geosceneViewClick", (event) => {
+   *    viewElement.hitTest(event.detail).then((response) => {
+   *       const result = response.results[0];
+   *       if (result?.type === "graphic") {
+   *          const { longitude, latitude } = result.mapPoint;
+   *          console.log(`Hit graphic at (${longitude}, ${latitude})`, result.graphic);
+   *       } else {
+   *          console.log("Did not hit any graphic");
+   *       }
+   *    });
+   * });
+   * ```
+   * @example
+   * ```js
+   * // get screenpoint from view's click event
+   * viewElement.addEventListener("geosceneViewClick", async (event) => {
+   *   // Search for all media elements only on included mediaLayer at the clicked location
+   *   const response = await viewElement.hitTest(event.detail, {
+   *     include: {mediaLayer}
+   *   });
+   *   // if media elements are returned from the mediaLayer, do something with results
+   *   if (response.results.length){
+   *     // do something
+   *     console.log(response.results.length, "elements returned");
+   *   }
+   * });
+   * ```
+   */
+  hitTest(screenPoint: MouseEvent | ScreenPoint, options?: HitTestOptions): Promise<ViewHitTestResult>;
+  /**
+   * Opens the popup at the given location with content defined either explicitly with content or driven
+   * from the PopupTemplate of input features.
+   *
+   * @param options
+   */
+  openPopup(options?: ViewPopupOpenOptions): Promise<void>;
+  /**
+   * Create a screenshot of the current view.
+   *
+   * @param options
+   */
+  takeScreenshot(options?: UserSettings): Promise<Screenshot>;
+  /** @param screenPoint */
+  toMap(screenPoint: MouseEvent | ScreenPoint): Point;
+  /**
+   * @param point
+   * @param options
+   */
+  toScreen(point: Point, options?: ToScreenOptions2D): ScreenPoint | null | undefined;
+  /** Call this method to clear any fatal errors resulting from a lost WebGL context. */
+  tryFatalErrorRecovery(): Promise<void>;
+  /**
+   * `viewOnReady()` may be leveraged once an instance of the component and its underlying [view](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#view) is created and ready.
+   * This method takes two input parameters, a `callback` function and an `errback` function, and returns a promise. The `callback` executes when the promise resolves, and the `errback` executes if the promise is rejected.
+   *
+   * @param callback
+   * @param errback
+   * @since 4.33
+   * @see [Watch for changes - waiting for components or views to be ready](https://doc.geoscene.cn/javascript/5.0/watch-for-changes/#waiting-for-components-or-views-to-be-ready)
+   * @example
+   * ```js
+   * const viewElement = document.querySelector("geoscene-map");
+   * await viewElement.viewOnReady();
+   * // The view is now ready to be used.
+   * viewElement.map.add(new FeatureLayer({...}));
+   * ```
+   */
+  viewOnReady(callback?: () => void, errback?: (error: Error) => void): Promise<void>;
+  /**
+   * Gets the analysis view created for the given analysis object.
+   *
+   * [Read more](https://doc.geoscene.cn/javascript/5.0/references/core/views/MapView/#whenAnalysisView)
+   *
+   * @param analysis
+   * @since 4.34
+   */
+  whenAnalysisView(analysis: Analysis): Promise<AnalysisView2DUnion>;
+  /**
+   * Gets the LayerView created on the view for the given layer.
+   *
+   * [Read more](https://doc.geoscene.cn/javascript/5.0/references/core/views/MapView/#whenLayerView)
+   *
+   * @param layer
+   */
+  whenLayerView<TLayer extends Layer>(layer: TLayer): Promise<LayerView2DFor<TLayer>>;
+  /**
+   * Zooms in the view component by a factor of 2.
+   *
+   * @since 5.0
+   */
+  zoomIn(): Promise<void>;
+  /**
+   * Zooms out the view component by a factor of 2.
+   *
+   * @since 5.0
+   */
+  zoomOut(): Promise<void>;
+  "@setterTypes": {
+    center?: MapView["center"] | null | undefined | number[] | string;
+    ground?: Ground | string;
+  };
+  /**
+   * Fires when a geoscene-map fails to load or if one of its dependencies fails to load (e.g., basemap, ground, layers).
+   *
+   * @since 4.34
+   * @see [loadErrorSources](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#loadErrorSources)
+   * @example
+   * ```js
+   * viewElement.addEventListener("geosceneLoadError", () => {
+   *   console.log(viewElement.loadErrorSources);
+   * });
+   * ```
+   */
+  readonly geosceneLoadError: import("@geoscene/lumina").TargetedEvent<this, void>;
+  /**
+   * Fires when the view for an analysis is created.
+   *
+   * [Read more](https://doc.geoscene.cn/javascript/5.0/references/core/views/MapView/#event-analysis-view-create)
+   *
+   * @since 4.34
+   */
+  readonly geosceneViewAnalysisViewCreate: import("@geoscene/lumina").TargetedEvent<this, AnalysisViewCreateEvent>;
+  /**
+   * Fires when an error occurs during the creation of an analysis view after an analysis is added to the view.
+   *
+   * [Read more](https://doc.geoscene.cn/javascript/5.0/references/core/views/MapView/#event-analysis-view-create-error)
+   *
+   * @since 4.34
+   */
+  readonly geosceneViewAnalysisViewCreateError: import("@geoscene/lumina").TargetedEvent<this, AnalysisViewCreateErrorEvent>;
+  /**
+   * Fires after an analysis view is destroyed.
+   *
+   * [Read more](https://doc.geoscene.cn/javascript/5.0/references/core/views/MapView/#event-analysis-view-destroy)
+   *
+   * @since 4.34
+   */
+  readonly geosceneViewAnalysisViewDestroy: import("@geoscene/lumina").TargetedEvent<this, AnalysisViewDestroyEvent>;
+  /**
+   * This event is triggered when view-related properties change, such as [zoom](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#zoom), [scale](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#scale), [center](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#center), [rotation](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#rotation), [extent](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#extent),
+   * [viewpoint](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#viewpoint), or [stationary](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#stationary).
+   * It reflects user interactions (e.g. panning or zooming) or programmatic updates to the view.
+   *
+   * @example
+   * ```js
+   * // get the number of features in a layer view whenever the view becomes stationary
+   * viewElement.addEventListener("geosceneViewChange", async (event) =>{
+   *   if (viewElement.stationary) {
+   *     // Returns number of features available for drawing in a given layer view
+   *     const count = await layerView.queryFeatureCount({
+   *       geometry: viewElement.extent
+   *     });
+   *     // use the features count
+   *   }
+   * });
+   * ```
+   */
+  readonly geosceneViewChange: import("@geoscene/lumina").TargetedEvent<this, void>;
+  /**
+   * Fires after a user clicks on the view. This event emits slightly slower than an [@geosceneViewImmediateClick](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#event-geosceneViewImmediateClick)
+   * event to make sure that an [@geosceneViewDoubleClick](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#event-geosceneViewDoubleClick) event isn't triggered instead. The `geosceneViewImmediateClick`
+   * event can be used for responding to an `geosceneViewClick` event without delay.
+   *
+   * @example
+   * ```js
+   * // Listen for clicks on the view and perform a hit test on a feature layer
+   * viewElement.addEventListener("geosceneViewClick", (event) => {
+   *   // Return hit test results from the feature layer
+   *   // where it intersects the screen coordinates from the click event.
+   *   // The result is a polygon representing the state that was clicked.
+   *   viewElement.hitTest(event.detail).then((response) => {
+   *      if (response.results.length) {
+   *        const stateBoundaryPolygon = response.results.find((result) => {
+   *          return result.graphic.layer === stateBoundaryFeatureLayer;
+   *         }).graphic.geometry;
+   *
+   *         getPolygonCentroid(stateBoundaryPolygon);
+   *       }
+   *     });
+   * });
+   * ```
+   */
+  readonly geosceneViewClick: import("@geoscene/lumina").TargetedEvent<this, ClickEvent>;
+  /**
+   * Fires after double-clicking on the view.
+   *
+   * @example
+   * ```js
+   * viewElement.addEventListener("geosceneViewDoubleClick", async (event) => {
+   *   // Prevent the default zoom-in behavior on double-click
+   *   event.detail.stopPropagation();
+   * });
+   * ```
+   */
+  readonly geosceneViewDoubleClick: import("@geoscene/lumina").TargetedEvent<this, DoubleClickEvent>;
+  /**
+   * Fires while the pointer is dragged following a double-tap gesture on the view.
+   *
+   * [Read more](https://doc.geoscene.cn/javascript/5.0/references/core/views/MapView/#event-double-tap-drag)
+   *
+   * @since 5.0
+   * @example
+   * ```js
+   * viewElement.addEventListener("geosceneViewDoubleTapDrag", (event) => {
+   *   // Display the distance moved from the drag origin.
+   *   console.log("x distance:", event.detail.x, "y distance:", event.detail.y);
+   * });
+   * ```
+   */
+  readonly geosceneViewDoubleTapDrag: import("@geoscene/lumina").TargetedEvent<this, DoubleTapDragEvent>;
+  /** Fires during a pointer drag on the view. */
+  readonly geosceneViewDrag: import("@geoscene/lumina").TargetedEvent<this, DragEvent>;
+  /** Fires after holding either a mouse button or a single finger on the view for a short amount of time. */
+  readonly geosceneViewHold: import("@geoscene/lumina").TargetedEvent<this, HoldEvent>;
+  /**
+   * Fires right after a user clicks on the view. In contrast to the [@geosceneViewClick](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#event-geosceneViewClick) event, the `geosceneViewImmediateClick`
+   * is emitted as soon as the user clicks on the view, and is not inhibited by a [@geosceneViewDoubleClick](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#event-geosceneViewDoubleClick) event.
+   * This event is useful for interactive experiences that require feedback without delay.
+   *
+   * @example
+   * ```js
+   * viewElement.addEventListener("geosceneViewImmediateClick", async (event) => {
+   *   // Prevent the default zoom-in behavior on geosceneViewImmediateClick
+   *   event.detail.stopPropagation();
+   * });
+   * ```
+   */
+  readonly geosceneViewImmediateClick: import("@geoscene/lumina").TargetedEvent<this, ImmediateClickEvent>;
+  /**
+   * Fires after two consecutive [@geosceneViewImmediateClick](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#event-geosceneViewImmediateClick) events. In contrast to [@geosceneViewDoubleClick](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#event-geosceneViewDoubleClick),
+   * an `geosceneViewImmediateDoubleClick` cannot be prevented by use of `stopPropagation()` on the [@geosceneViewImmediateClick](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#event-geosceneViewImmediateClick)
+   * event and can therefore be used to react to double-clicking independently of usage of the [@geosceneViewImmediateClick](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#event-geosceneViewImmediateClick) event.
+   */
+  readonly geosceneViewImmediateDoubleClick: import("@geoscene/lumina").TargetedEvent<this, ImmediateDoubleClickEvent>;
+  /**
+   * Fires after a keyboard key is pressed.
+   *
+   * @example
+   * ```js
+   * // Disable zooming with the keyboard
+   * // Stop event propagation when `+` and `-` keys are pressed.
+   * viewElement.addEventListener("geosceneViewKeyDown", function(event){
+   *   console.log("key-down", event);
+   *
+   *   const prohibitedKeys = ["+", "-"];
+   *   const keyPressed = event.detail.key;
+   *   if (prohibitedKeys.indexOf(keyPressed) !== -1) {
+   *     event.detail.stopPropagation();
+   *   }
+   * });
+   * ```
+   */
+  readonly geosceneViewKeyDown: import("@geoscene/lumina").TargetedEvent<this, KeyDownEvent>;
+  /** Fires after a keyboard key is released. */
+  readonly geosceneViewKeyUp: import("@geoscene/lumina").TargetedEvent<this, KeyUpEvent>;
+  /**
+   * Fires after each layer in the map has a corresponding
+   * [LayerView](https://doc.geoscene.cn/javascript/5.0/references/core/views/layers/LayerView/)
+   * created and rendered in the view.
+   */
+  readonly geosceneViewLayerviewCreate: import("@geoscene/lumina").TargetedEvent<this, LayerViewCreateEvent>;
+  /**
+   * Fires when an error occurs during the creation of a [LayerView](https://doc.geoscene.cn/javascript/5.0/references/core/views/layers/LayerView/)
+   * after a layer has been added to the map.
+   */
+  readonly geosceneViewLayerviewCreateError: import("@geoscene/lumina").TargetedEvent<this, LayerViewCreateErrorEvent>;
+  /**
+   * Fires after a [LayerView](https://doc.geoscene.cn/javascript/5.0/references/core/views/layers/LayerView/)
+   * is destroyed and is no longer rendered in the view.
+   */
+  readonly geosceneViewLayerviewDestroy: import("@geoscene/lumina").TargetedEvent<this, LayerViewDestroyEvent>;
+  /**
+   * Fires when a wheel button of a pointing device (typically a mouse) is scrolled on the view.
+   *
+   * @example
+   * ```js
+   * viewElement.addEventListener("geosceneViewMouseWheel", async (event) => {
+   *   // Prevent the default zoom-in and zoom-out behavior on geosceneViewMouseWheel
+   *   event.detail.stopPropagation();
+   * });
+   * ```
+   */
+  readonly geosceneViewMouseWheel: import("@geoscene/lumina").TargetedEvent<this, ViewMouseWheelEvent>;
+  /**
+   * Fires after a mouse button is pressed, or a finger touches the display.
+   *
+   * @see [Sample: Access features with hitTest](https://doc.geoscene.cn/javascript/5.0/sample-code/map-component-hittest/)
+   */
+  readonly geosceneViewPointerDown: import("@geoscene/lumina").TargetedEvent<this, PointerDownEvent>;
+  /** Fires after a mouse cursor enters the view, or a display touch begins. */
+  readonly geosceneViewPointerEnter: import("@geoscene/lumina").TargetedEvent<this, PointerEnterEvent>;
+  /** Fires after a mouse cursor leaves the view, or a display touch ends. */
+  readonly geosceneViewPointerLeave: import("@geoscene/lumina").TargetedEvent<this, PointerLeaveEvent>;
+  /**
+   * Fires after the mouse or a finger on the display moves.
+   *
+   * @see [Sample: Access features with hitTest](https://doc.geoscene.cn/javascript/5.0/sample-code/map-component-hittest/)
+   */
+  readonly geosceneViewPointerMove: import("@geoscene/lumina").TargetedEvent<this, PointerMoveEvent>;
+  /** Fires after a mouse button is released, or a display touch ends. */
+  readonly geosceneViewPointerUp: import("@geoscene/lumina").TargetedEvent<this, PointerUpEvent>;
+  /**
+   * This event is for the `ready` property and is emitted when the view is ready.
+   * Fires also when the [map](https://doc.geoscene.cn/javascript/5.0/references/map-components/components/geoscene-map/#map) is updated.
+   */
+  readonly geosceneViewReadyChange: import("@geoscene/lumina").TargetedEvent<this, void>;
+  /**
+   * Fires if the view encounters a content or rendering error.
+   *
+   * @since 4.34
+   * @example
+   * ```js
+   * viewElement.addEventListener("geosceneViewReadyError", () => {
+   *   // handle error
+   * });
+   * ```
+   */
+  readonly geosceneViewReadyError: import("@geoscene/lumina").TargetedEvent<this, void>;
+  /**
+   * Fires while the two pointers are dragged vertically on the view.
+   *
+   * [Read more](https://doc.geoscene.cn/javascript/5.0/references/core/views/MapView/#event-vertical-two-finger-drag)
+   *
+   * @since 5.0
+   * @example
+   * ```js
+   * viewElement.addEventListener("geosceneViewVerticalTwoFingerDrag", (event) => {
+   *   // Display the distance moved vertically from the drag origin.
+   *   console.log("y distance:", event.detail.y);
+   * });
+   * ```
+   */
+  readonly geosceneViewVerticalTwoFingerDrag: import("@geoscene/lumina").TargetedEvent<this, VerticalTwoFingerDragEvent>;
+  readonly "@eventTypes": {
+    geosceneLoadError: GeosceneMap["geosceneLoadError"]["detail"];
+    geosceneViewAnalysisViewCreate: GeosceneMap["geosceneViewAnalysisViewCreate"]["detail"];
+    geosceneViewAnalysisViewCreateError: GeosceneMap["geosceneViewAnalysisViewCreateError"]["detail"];
+    geosceneViewAnalysisViewDestroy: GeosceneMap["geosceneViewAnalysisViewDestroy"]["detail"];
+    geosceneViewChange: GeosceneMap["geosceneViewChange"]["detail"];
+    geosceneViewClick: GeosceneMap["geosceneViewClick"]["detail"];
+    geosceneViewDoubleClick: GeosceneMap["geosceneViewDoubleClick"]["detail"];
+    geosceneViewDoubleTapDrag: GeosceneMap["geosceneViewDoubleTapDrag"]["detail"];
+    geosceneViewDrag: GeosceneMap["geosceneViewDrag"]["detail"];
+    geosceneViewHold: GeosceneMap["geosceneViewHold"]["detail"];
+    geosceneViewImmediateClick: GeosceneMap["geosceneViewImmediateClick"]["detail"];
+    geosceneViewImmediateDoubleClick: GeosceneMap["geosceneViewImmediateDoubleClick"]["detail"];
+    geosceneViewKeyDown: GeosceneMap["geosceneViewKeyDown"]["detail"];
+    geosceneViewKeyUp: GeosceneMap["geosceneViewKeyUp"]["detail"];
+    geosceneViewLayerviewCreate: GeosceneMap["geosceneViewLayerviewCreate"]["detail"];
+    geosceneViewLayerviewCreateError: GeosceneMap["geosceneViewLayerviewCreateError"]["detail"];
+    geosceneViewLayerviewDestroy: GeosceneMap["geosceneViewLayerviewDestroy"]["detail"];
+    geosceneViewMouseWheel: GeosceneMap["geosceneViewMouseWheel"]["detail"];
+    geosceneViewPointerDown: GeosceneMap["geosceneViewPointerDown"]["detail"];
+    geosceneViewPointerEnter: GeosceneMap["geosceneViewPointerEnter"]["detail"];
+    geosceneViewPointerLeave: GeosceneMap["geosceneViewPointerLeave"]["detail"];
+    geosceneViewPointerMove: GeosceneMap["geosceneViewPointerMove"]["detail"];
+    geosceneViewPointerUp: GeosceneMap["geosceneViewPointerUp"]["detail"];
+    geosceneViewReadyChange: GeosceneMap["geosceneViewReadyChange"]["detail"];
+    geosceneViewReadyError: GeosceneMap["geosceneViewReadyError"]["detail"];
+    geosceneViewVerticalTwoFingerDrag: GeosceneMap["geosceneViewVerticalTwoFingerDrag"]["detail"];
+  };
+}