@arcgis/map-components 5.0.0-next.13 → 5.0.0-next.130

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

@@ -7,12 +7,15 @@ import { Use } from '@arcgis/lumina/controllers';
 import { nil } from '@arcgis/toolkit/type';
 import { default as Collection } from '@arcgis/core/core/Collection.js';
 import { LoadErrorSource } from '../../controllers/useArcgisLoadError';
+import { ArcgisPopup } from '../arcgis-popup/customElement.js';
+import { LayerView2DFor } from '@arcgis/core/views/2d/types';
+import { DoubleClickEvent, DoubleTapDragEvent, VerticalTwoFingerDragEvent } from '@arcgis/core/views/input/types';
 
-declare const useWebMap: (component: LitElement & Omit<Pick<WebMap, "basemap" | "focusAreas" | "ground" | "ipsInfo" | "layers" | "presentation" | "tables" | "widgets" | "applicationProperties" | "authoringApp" | "authoringAppVersion" | "bookmarks" | "floorInfo" | "geotriggersInfo" | "initialViewProperties" | "portalItem" | "thumbnailUrl" | "utilityNetworks">, "basemap" | "ground" | ("destroyed" | "initialized" | "declaredClass" | "set" | "watch" | "addHandles" | "removeHandles" | "hasHandles") | "layers" | "presentation" | "tables" | "widgets" | "applicationProperties" | "authoringApp" | "authoringAppVersion" | "bookmarks" | "floorInfo" | "geotriggersInfo" | "initialViewProperties" | "portalItem" | "thumbnailUrl" | "utilityNetworks"> & {
+declare const useWebMap: (component: LitElement & Omit<Pick<WebMap, "basemap" | "focusAreas" | "ground" | "ipsInfo" | "bookmarks" | "layers" | "utilityNetworks" | "presentation" | "tables" | "widgets" | "floorInfo" | "applicationProperties" | "authoringApp" | "authoringAppVersion" | "initialViewProperties" | "portalItem" | "thumbnailUrl" | "geotriggersInfo">, "basemap" | "ground" | "bookmarks" | "layers" | "utilityNetworks" | "presentation" | "tables" | "widgets" | ("declaredClass" | "destroyed" | "initialized" | "addHandles" | "hasHandles" | "removeHandles" | "set" | "watch") | "floorInfo" | "applicationProperties" | "authoringApp" | "authoringAppVersion" | "initialViewProperties" | "portalItem" | "thumbnailUrl" | "geotriggersInfo"> & {
     autoDestroyDisabled: boolean;
     destroy: () => Promise<void>;
 }) => WebMap;
-declare const useMapView: (component: LitElement & Omit<Pick<MapView, "rotation" | "center" | "map" | "aria" | "analyses" | "background" | "basemapView" | "constraints" | "extent" | "fatalError" | "floors" | "graphics" | "highlights" | "highlightOptions" | "navigation" | "padding" | "popup" | "resizeAlign" | "scale" | "spatialReference" | "spatialReferenceLocked" | "theme" | "timeExtent" | "timeZone" | "viewpoint" | "zoom" | "ui" | "breakpoints" | "heightBreakpoint" | "popupEnabled" | "widthBreakpoint" | "animationsEnabled" | "container" | "animation" | "displayFilterEnabled">, "ui" | ("destroyed" | "initialized" | "declaredClass" | "set" | "watch" | "addHandles" | "removeHandles" | "hasHandles") | "breakpoints" | "heightBreakpoint" | "popupEnabled" | "widthBreakpoint" | "animationsEnabled" | "container" | "animation" | "displayFilterEnabled"> & {
+declare const useMapView: (component: LitElement & Omit<Pick<MapView, "rotation" | "center" | "analyses" | "map" | "spatialReference" | "timeZone" | "aria" | "attributionMode" | "basemapView" | "constraints" | "extent" | "fatalError" | "floors" | "graphics" | "highlights" | "highlightOptions" | "navigation" | "padding" | "popup" | "scale" | "theme" | "timeExtent" | "viewpoint" | "zoom" | "background" | "resizeAlign" | "spatialReferenceLocked" | "animation" | "container" | "ui" | "animationsEnabled" | "attributionVisible" | "displayFilterEnabled" | "popupEnabled" | "breakpoints" | "heightBreakpoint" | "widthBreakpoint">, "animation" | "container" | "ui" | ("declaredClass" | "destroyed" | "initialized" | "addHandles" | "hasHandles" | "removeHandles" | "set" | "watch") | "animationsEnabled" | "attributionVisible" | "displayFilterEnabled" | "popupEnabled" | "breakpoints" | "heightBreakpoint" | "widthBreakpoint"> & {
     autoDestroyDisabled: boolean;
     destroy: () => Promise<void>;
 }) => MapView;
@@ -20,18 +23,49 @@ declare const useMapView: (component: LitElement & Omit<Pick<MapView, "rotation"
  * The ArcGIS Map component is used to add 2D maps to web applications. For 3D maps, use the
  * [ArcGIS Scene component](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-scene/).
  *
- * The Map component creates a [MapView](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html) and loads a WebMap from either [ArcGIS Online](https://www.arcgis.com/home/index.html) or [ArcGIS Enterprise portal](https://enterprise.arcgis.com/en/portal/latest/administer/windows/what-is-portal-for-arcgis-.htm).
+ * #### Initializing the Map component
+ * The Map component creates a [MapView](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html)
+ * and can be initialized in one of three ways:
+ *
+ * ##### 1. Using a WebMap
+ * Load a [WebMap](https://developers.arcgis.com/javascript/latest/api-reference/esri-WebMap.html) from [ArcGIS Online](https://www.arcgis.com/home/index.html)
+ * or an [ArcGIS Enterprise portal](https://enterprise.arcgis.com/en/portal/latest/administer/windows/what-is-portal-for-arcgis-.htm) by specifying the [item-id](#itemId) attribute.
  *
  * ```html
  * <arcgis-map item-id="05e015c5f0314db9a487a9b46cb37eca"></arcgis-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](#basemap), [center](#center), and [zoom](#zoom) directly.
  *
  * ```html
  * <arcgis-map basemap="satellite" center="-154.88, 19.46" zoom="15"></arcgis-map>
  * ```
  *
+ * ##### 3. Providing a Map instance
+ * Alternatively, you can provide your own [Map](https://developers.arcgis.com/javascript/latest/api-reference/esri-Map.html) instance to the component.
+ * This allows full control over map configuration, including [basemap](#basemap), operational [layers](https://developers.arcgis.com/javascript/latest/api-reference/esri-Map.html#layers)
+ * and [spatial reference](#spatialReference). See the [Select features by rectangle sample](https://developers.arcgis.com/javascript/latest/sample-code/highlight-features-by-geometry/)
+ * for an example of this approach in action.
+ *
+ * ```html
+ * <arcgis-map></arcgis-map>
+ * <script type="module">
+ *  const viewElement = document.querySelector("arcgis-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
@@ -58,7 +92,6 @@ declare const useMapView: (component: LitElement & Omit<Pick<MapView, "rotation"
  *
  * [Read more...](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-map/)
  *
- * @since 4.28
  * @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.
@@ -68,7 +101,8 @@ declare const useMapView: (component: LitElement & Omit<Pick<MapView, "rotation"
  * @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 [Popup](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-popup/) component to open automatically on click. When using this slot, the [`popup-disabled`](#popupDisabled) attribute must be set to `true`. Only the Popup component can be placed in this slot.
+ * @slot [popup] - Slot for the [Popup](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-popup/) component to open automatically on click. Only the Popup component can be placed in this slot.
+ * @since 4.28
  */
 export declare class ArcgisMap extends LitElement {
     /**
@@ -78,10 +112,10 @@ export declare class ArcgisMap extends LitElement {
      * @see [loadErrorSources](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-map/#loadErrorSources)
      * @example
      * ```js
-     *       viewElement.addEventListener("arcgisLoadError", () => {
-     *         console.log(viewElement.loadErrorSources);
-     *       });
-     *      ```
+     * viewElement.addEventListener("arcgisLoadError", () => {
+     *   console.log(viewElement.loadErrorSources);
+     * });
+     * ```
      */
     readonly arcgisLoadError: TargetedEvent<this>;
     /**
@@ -90,10 +124,10 @@ export declare class ArcgisMap extends LitElement {
      * @since 4.34
      * @example
      * ```js
-     *       viewElement.addEventListener("arcgisViewReadyError", () => {
-     *         // handle error
-     *       });
-     *      ```
+     * viewElement.addEventListener("arcgisViewReadyError", () => {
+     *   // handle error
+     * });
+     * ```
      */
     readonly arcgisViewReadyError: TargetedEvent<this>;
     /** The [MapView](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html) instance created and managed by the component. Accessible once the component is fully loaded. */
@@ -110,12 +144,12 @@ export declare class ArcgisMap extends LitElement {
      * [goTo()](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#goTo)).
      * Setting this property to `true` disables all animations in the view.
      *
-     * @since 4.34
      * @default false
+     * @since 4.34
      */
     animationsDisabled: boolean;
     /**
-     * The ARIA information for the view.
+     * The ARIA attributes for the view container.
      *
      * @since 4.34
      */
@@ -124,14 +158,36 @@ export declare class ArcgisMap 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://developers.arcgis.com/javascript/latest/api-reference/esri-views-layers-LayerView.html)
      */
-    readonly allLayerViews: __esri.ReadonlyCollection<__esri.LayerView>;
+    readonly allLayerViews: import('@arcgis/core/core/Collection').ReadonlyCollection<import('@arcgis/core/views/layers/LayerView').default>;
     /**
      * A collection of analyses associated with the view.
      *
-     * [Read more...](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-View2D.html#analyses)
+     * @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);
+     */
+    analyses: Collection<import('@arcgis/core/analysis/Analysis').default>;
+    /**
+     * The attribution items displayed in the view's attribution.
+     *
+     * @since 5.0
      */
-    analyses: Collection<__esri.Analysis>;
+    get attributionItems(): __esri.MapView["attributionItems"];
+    /**
+     * The light or dark mode used to display the attribution.
+     * By default, the mode is inherited from the [Calcite's mode](https://developers.arcgis.com/calcite-design-system/core-concepts/#modes).
+     * You can override the value to style the attribution alongside the map or scene content.
+     *
+     * @since 5.0
+     */
+    attributionMode: "light" | "dark" | 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
@@ -145,9 +201,16 @@ export declare class ArcgisMap extends LitElement {
     /**
      * The background color of the Map component.
      *
-     * @default null
+     * @example
+     * let view = new MapView({
+     *   container: "viewDiv",
+     *   map: map,
+     *   background: { // autocasts new ColorBackground()
+     *     color: "magenta" // autocasts as new Color()
+     *   }
+     * });
      */
-    background: nullish | __esri.ColorBackground;
+    background: import('@arcgis/core/webmap/background/ColorBackground').default | 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
@@ -160,20 +223,123 @@ export declare class ArcgisMap extends LitElement {
      */
     basemap?: __esri.Basemap | string;
     /** Represents the view for a single basemap after it has been added to the map. */
-    basemapView: __esri.BasemapView;
+    basemapView: import('@arcgis/core/views/BasemapView').default<import('@arcgis/core/views/layers/LayerView').default>;
     /**
      * Represents the view's center point; when setting the center, you may pass a
-     * [Point](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Point.html) 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()](#goTo) method.
+     * [Point](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Point.html) 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()](#goTo) method.
+     *
+     * The returned [Point](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Point.html) 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://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Point.html#clone) method.
+     *
+     * **Notes**
+     *
+     * * If the spatial reference of `center` set in the constructor does not match the [spatialReference](#spatialReference) of the view, then the
+     * [projectOperator](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-projectOperator.html) will be loaded dynamically.
+     * * At runtime, the [projectOperator](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-projectOperator.html) must be
+     * [loaded](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-projectOperator.html#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://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-projectOperator.html#isLoaded)
+     * method. If it is not yet loaded, you can call [load()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-projectOperator.html#load) method.
+     *
+     * @example
+     * ```html
+     * <arcgis-map zoom="4" center="-98, 39"></arcgis-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("arcgis-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("arcgis-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("arcgis-map");
+     * viewElement.center = centerPoint;
+     * ```
      */
     get center(): __esri.MapView["center"];
     set center(newValue: __esri.MapView["center"] | nil | number[] | string);
-    /** Specifies constraints to scale, zoom, and rotation that may be applied to the map. */
-    constraints: __esri.View2DConstraints;
     /**
-     * Indicates whether a layer's `displayFilter` is honored when rendering layers in the view.
+     * Specifies constraints to scale, zoom, and rotation that may be applied to the map.
+     *
+     * @see [TileInfo#create()](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-support-TileInfo.html#create)
+     * @see [Zoom and LODs](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-View2D.html#mapview-lods)
+     * @example
+     * view.constraints = {
+     *   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 MapView scale 1:1 while generating additional LODs for the MapView.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;
+     *
+     * let view = new MapView({
+     *   container: "viewDiv",
+     *   map,
+     *   scale: 1,
+     *   center,
+     *   spatialReference,
+     *   constraints: {
+     *     lods: lods,
+     *     snapToZoom: false
+     *   }
+     * });
+     */
+    constraints: import('@arcgis/core/views/2d/MapViewConstraints').default;
+    /**
+     * 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
@@ -184,11 +350,34 @@ export declare class ArcgisMap extends LitElement {
      * Setting the extent immediately changes the view without animation. To animate
      * the view, see this component's [goTo()](#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](#spatialReference) of the view, then the
+     * [projectOperator](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-projectOperator.html) will be loaded dynamically.
+     * * At runtime, the [projectOperator](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-projectOperator.html)
+     * must be [loaded](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-projectOperator.html#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://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-projectOperator.html#isLoaded)
+     * method. If it is not yet loaded, you can call the [load](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-projectOperator.html#load) method.
      */
     get extent(): __esri.MapView["extent"];
     set extent(newValue: __esri.MapView["extent"]);
-    /** A rejected view indicates a fatal error making it unable to display. */
-    fatalError: nullish | __esri.Error;
+    /**
+     * A rejected view indicates a fatal error making it unable to display.
+     *
+     * @since 4.12
+     * @see [tryFatalErrorRecovery()](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-View.html#tryFatalErrorRecovery)
+     * @example
+     * reactiveUtils.when(
+     *   () => view.fatalError,
+     *   () => {
+     *     console.error("Fatal Error! View has lost its WebGL context. Attempting to recover...");
+     *     view.tryFatalErrorRecovery();
+     *   }
+     * );
+     */
+    fatalError: import('@arcgis/core/core/Error').default<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.
@@ -209,30 +398,157 @@ export declare class ArcgisMap extends LitElement {
      * // Removes a graphic from the View
      * graphics.remove(pointGraphic);
      * ```
+     * @see [Graphic](https://developers.arcgis.com/javascript/latest/api-reference/esri-Graphic.html)
+     * @see [GraphicsLayer](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-GraphicsLayer.html)
+     * @see [Intro to graphics](https://developers.arcgis.com/javascript/latest/sample-code/intro-graphics/)
+     */
+    graphics: Collection<import('@arcgis/core/Graphic').default>;
+    /**
+     * Specifies the surface properties for the map.
+     *
+     * @see [ElevationLayer](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-ElevationLayer.html)
+     * @see [Ground](https://developers.arcgis.com/javascript/latest/api-reference/esri-Ground.html)
+     * @example
+     * // Use the world elevation service
+     * const map = new Map({
+     *   basemap: "topo-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.arcgis.com/arcgis/rest/services/WorldElevation3D/Terrain3D/ImageServer"
+     * });
+     * const customElevation = new ElevationLayer({
+     *   url: "https://my.server.com/arcgis/rest/service/MyElevationService/ImageServer"
+     * });
+     * const map = new Map({
+     *   basemap: "topo-vector",
+     *   ground: new Ground({
+     *    layers: [ worldElevation, customElevation ]
+     *   })
+     * });
      */
-    graphics: Collection<__esri.Graphic>;
-    /** Specifies the surface properties for the map. */
     get ground(): typeof this._map.ground;
     set ground(value: __esri.Ground | string);
     /**
-     * The highlights property is a collection of [HighlightOptions](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-support-HighlightOptions.html) objects that
-     * allow you to visually emphasize specific features on the map. See [MapView.highlights](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#highlights) for more information.
+     * Indicates whether the attribution is hidden in the view.
+     *
+     * Esri requires that when you use an ArcGIS Online basemap in your app, the map must include Esri 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://developers.arcgis.com/terms/attribution/) documentation.
+     * For information on terms of use, see the [Terms of Use FAQ](https://developers.arcgis.com/terms/faq/).
+     *
+     * @default false
+     * @since 5.0
+     */
+    get hideAttribution(): boolean;
+    set hideAttribution(value: boolean);
+    /**
+     * Represents a collection of [HighlightOptions](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-support-HighlightOptions.html)
+     * 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://developers.arcgis.com/javascript/latest/api-reference/esri-views-support-HighlightOptions.html)
+     * 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://developers.arcgis.com/javascript/latest/api-reference/esri-views-support-HighlightOptions.html)
+     * object must be part of this collection in order to be applied to features.
+     *
+     * To highlight a feature, use the [highlight()](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-layers-FeatureLayerView.html#highlight)
+     * method on the relevant [LayerView](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-layers-LayerView.html) instance. To apply specific
+     * [HighlightOptions](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-support-HighlightOptions.html), include the
+     * [name](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-support-HighlightOptions.html#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://developers.arcgis.com/javascript/latest/sample-code/highlight-features-by-geometry/)
+     * @see [Sample: Highlight point features](https://developers.arcgis.com/javascript/latest/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);
      */
-    highlights: Collection<__esri.HighlightOptions>;
+    highlights: Collection<import('@arcgis/core/views/support/HighlightOptions').default>;
     /**
-     * Options for configuring the highlight.
+     * Options for configuring the highlight. Use the highlight method on the
+     * appropriate [LayerView](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-layers-LayerView.html) to highlight a feature.
      *
      * @deprecated since version 4.32. Use the [highlights](#highlights) property instead.
+     * @see [Sample: Highlight SceneLayer](https://developers.arcgis.com/javascript/latest/sample-code/highlight-scenelayer/)
+     * @example
+     * const view = new MapView({
+     *   map: map,
+     *   highlightOptions: {
+     *     color: [255, 255, 0, 1],
+     *     haloOpacity: 0.9,
+     *     fillOpacity: 0.2
+     *   }
+     * });
      */
-    highlightOptions: __esri.HighlightOptions;
+    highlightOptions: import('@arcgis/core/views/support/HighlightOptions').default;
     /**
      * 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. */
-    ipsInfo: nullish | __esri.IPSInfo;
+    /**
+     * Contains indoor positioning system information for the map.
+     *
+     * @since 4.31
+     */
+    ipsInfo: import('@arcgis/core/webdoc/IPSInfo').default | null | undefined;
     /**
      * The ID of a WebMap from ArcGIS Online or ArcGIS Enterprise portal.
      *
@@ -244,42 +560,110 @@ export declare class ArcgisMap extends LitElement {
      * A collection containing a hierarchical list of all the created
      * [LayerView](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-layers-LayerView.html)s of the
      * [operational layers](https://developers.arcgis.com/javascript/latest/api-reference/esri-Map.html#layers) in the map.
+     *
+     * @see [LayerView](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-layers-LayerView.html)
+     */
+    readonly layerViews: Collection<import('@arcgis/core/views/layers/LayerView').default>;
+    /**
+     * The magnifier allows for showing a portion of the view as a magnifier image on top of the view.
+     *
+     * @since 4.19
      */
-    readonly layerViews: Collection<__esri.LayerView>;
-    /** The magnifier allows for showing a portion of the view as a magnifier image on top of the view. */
-    readonly magnifier: __esri.Magnifier;
+    readonly magnifier: import('@arcgis/core/views/Magnifier').default;
     /** An instance of a [Map](https://developers.arcgis.com/javascript/latest/api-reference/esri-Map.html) object to display in the view. */
-    map: nullish | __esri.Map;
+    map: import('@arcgis/core/Map').default | 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. */
-    navigation: __esri.Navigation;
+    /**
+     * 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: "satellite"
+     *   }),
+     *   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,
+     *   }
+     * });
+     */
+    navigation: import('@arcgis/core/views/navigation/Navigation').default;
     /**
      * 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.
      *
-     * @see [Sample: Map padding](https://developers.arcgis.com/javascript/latest/sample-code/map-padding/)
      * @default {left: 0, top: 0, right: 0, bottom: 0}
+     * @see [Sample: Map padding](https://developers.arcgis.com/javascript/latest/sample-code/map-padding/)
      */
-    padding: __esri.ViewPadding;
+    padding: import('@arcgis/core/views/ui/types').ViewPadding;
     /**
      * A [Popup](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Popup.html) object that displays general content or attributes from
-     * [layers](https://developers.arcgis.com/javascript/latest/api-reference/esri-Map.html#layers) in the [map](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-View2D.html#map).
+     * [layers](https://developers.arcgis.com/javascript/latest/api-reference/esri-Map.html#layers) in the [map](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-View.html#map).
+     *
+     * By default, the `popup` property is an empty object that allows you to set the popup options.
+     * A [Popup](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Popup.html) instance is automatically created and assigned to the view's [popup](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-PopupView.html#popup)
+     * when the user clicks on the view and [popupEnabled](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-PopupView.html#popupEnabled) is `true`, when the [openPopup](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-PopupView.html#openPopup) method is called,
+     * or when some components need the popup, such as [Search](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Search.html). If [popup](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-PopupView.html#popup) is `null`, the popup instance will not be created.
      *
-     * [Read more...](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-View2D.html#popup)
+     * @see [popupEnabled](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-PopupView.html#popupEnabled)
+     * @see [openPopup()](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-PopupView.html#openPopup)
+     * @see [Loading the Popup](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Popup.html#loading-the-popup)
+     * @example
+     * // Set the view's popup to a new Popup instance.
+     * // The popup will show anytime a popup is called such as when selecting features or displaying a Search result.
+     * view.popup = new Popup();
+     * @example
+     * // Set the popup to a PopupOptions object with popup properties set such as the dock options.
+     * // The popup will show anytime a popup is called.
+     * view.popup = {
+     *  dockEnabled: true,
+     *  dockOptions: {
+     *    position: "top-left",
+     *    breakpoint: false
+     *  }
+     * };
+     * @example
+     * // Set the popup to null. This disables the popup so it will never show up.
+     * view.popup = null;
      */
-    popup: nullish | __esri.Popup;
+    popup: import('@arcgis/core/widgets/Popup').default | null | undefined;
     /**
-     * Controls whether the popup opens when users click on the view.
+     * A reference to the current [arcgis-popup](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-popup/).
+     *
+     * @since 5.0
+     */
+    get popupElement(): HTMLArcgisPopupElement | null;
+    /**
+     * Controls whether the popup opens automatically when users click on the view.
      *
      * @default false
      */
     popupDisabled: boolean;
+    /**
+     * Indicates whether the popup widget is disabled. When set to `true`, the Popup component will be used for popups instead of the widget.
+     *
+     * @default false
+     * @since 5.0
+     */
+    popupWidgetDisabled: boolean;
     /**
      * When `true`, this property indicates whether the [view](#view) has successfully satisfied all dependencies, signaling that the following conditions are met:
      *
@@ -293,6 +677,7 @@ export declare class ArcgisMap extends LitElement {
      * the callback defined in [viewOnReady()](#viewOnReady) where code can execute on a working view.
      *
      * @default false
+     * @see [when()](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-View.html#when)
      */
     readonly ready: boolean;
     /**
@@ -302,11 +687,13 @@ export declare class ArcgisMap extends LitElement {
      *
      * @default "center"
      */
-    resizeAlign: "center" | "top-left" | "top-right" | "bottom-left" | "bottom-right" | "left" | "right" | "top" | "bottom";
+    resizeAlign: import('@arcgis/core/views/2d/types').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
      */
     readonly resolution: number;
     /**
@@ -318,6 +705,23 @@ export declare class ArcgisMap extends LitElement {
      * 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
+     * };
      */
     rotation: number;
     /**
@@ -327,21 +731,63 @@ export declare class ArcgisMap extends LitElement {
     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.
+     * 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 [Basemap Gallery](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-basemap-gallery/)
+     * and [Basemap Toggle](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-basemap-toggle/) components.
+     * Set [spatialReferenceLocked](#spatialReferenceLocked) property to `true` to prevent users from changing the view's spatial reference at runtime.
      *
-     * @default null
+     * Prior to changing the spatial reference, check if the [projectOperator](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-projectOperator.html)
+     * is loaded by calling [projectOperator.isLoaded()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-projectOperator.html#isLoaded) method.
+     * If it is not yet loaded, call [projectOperator.load()](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-operators-projectOperator.html#load) method.
+     * If the `projectOperator` is not loaded, the view's [center](#center) will default to `[0, 0]` in the new spatial reference of the view and a console error will be thrown.
+     *
+     * **Notes**
+     *
+     * * [LayerViews](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-layers-LayerView.html) not compatible with the view's spatial reference
+     * are not displayed. In such case, the layer view's [suspended](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-layers-LayerView.html#suspended)
+     * property is `true` and [spatialReferenceSupported](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-layers-LayerView.html#spatialReferenceSupported)
+     * property is `false`.
+     * * When setting view's spatial reference, the [center](#center), [extent](#extent) or [viewpoint.targetGeometry](#viewpoint) properties are projected to the new spatial
+     * reference. The [scale](#scale) and [rotation](#rotation) properties are adjusted to keep the content of the map at the same size and orientation on screen.
+     * * To ensure [TileLayers](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-TileLayer.html) and
+     * [VectorTileLayers](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-VectorTileLayer.html)
+     * are displayed in a [basemap](#basemap) correctly, the spatialReference of the view must be set match their
+     * [tileInfo's](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-support-TileInfo.html) spatial reference.
+     * * Switching spatial reference with an [imageCoordinateSystem](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-SpatialReference.html#imageCoordinateSystem)
+     * is not supported.
+     *
+     * @see [spatialReferenceLocked](#spatialReferenceLocked)
+     * @example
+     * ```js
+     * const viewElement = document.querySelector("arcgis-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
+     *   });
+     * }
+     * ```
      */
-    spatialReference: __esri.SpatialReference;
+    spatialReference: import('@arcgis/core/geometry/SpatialReference').default;
     /**
      * Indicates if the map's [spatialReference](#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 [arcgis-basemap-gallery](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-basemap-gallery/) and [arcgis-basemap-toggle](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-basemap-toggle/) components and the map's spatialReference cannot be changed at runtime.
      *
-     * @since 4.34
      * @default false
+     * @since 4.34
      */
     spatialReferenceLocked: boolean;
     /**
@@ -353,30 +799,65 @@ export declare class ArcgisMap extends LitElement {
     /**
      * Indicates if the view is visible on the page.
      *
-     * @default true
+     * @default false
      */
     readonly suspended: boolean;
     /**
      * This property specifies the base colors used by some components to render graphics and labels.
      *
-     * @default null
+     * @since 4.28
+     * @see [Theme](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-Theme.html)
+     * @see [Sample - Color theming for interactive tools](https://developers.arcgis.com/javascript/latest/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]
+     * });
      */
-    theme: nullish | __esri.Theme;
+    theme: import('@arcgis/core/views/Theme').default | 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.
      *
-     * @default null
-     */
-    timeExtent: nullish | __esri.TimeExtent;
+     * @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")
+     *   }
+     * });
+     */
+    timeExtent: import('@arcgis/core/time/TimeExtent').default | 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"
+     * });
      */
     timeZone: string;
     /**
@@ -394,12 +875,16 @@ export declare class ArcgisMap extends LitElement {
     get viewpoint(): __esri.Viewpoint;
     set viewpoint(newValue: __esri.Viewpoint);
     /**
-     * The visibleArea represents the visible portion of a [map](https://developers.arcgis.com/javascript/latest/api-reference/esri-Map.html) within the view as
-     * an instance of a [Polygon](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Polygon.html).
+     * The visibleArea represents the visible portion of a [Map](https://developers.arcgis.com/javascript/latest/api-reference/esri-Map.html) within the view as
+     * an instance of a [Polygon](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Polygon.html). This is similar to the view
+     * [MapView#extent](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#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.
      *
-     * [Read more...](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-View2D.html#visibleArea)
+     * @since 4.31
+     * @see [MapView#extent](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#extent)
      */
-    readonly visibleArea: __esri.Polygon | nullish;
+    readonly visibleArea: import('@arcgis/core/geometry/Polygon').default | 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.
@@ -423,13 +908,17 @@ export declare class ArcgisMap extends LitElement {
      * since 4.33, use `element.map.add(layer)` instead.
      *
      * Adds a layer to the map layers collection.
+     * @param layer
+     * @param index
      */
-    addLayer(layer: __esri.Layer | Promise<any>, index?: number): Promise<void>;
+    addLayer(layer: __esri.Layer | PromiseLike<__esri.Layer>, 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.
+     * @param layers
+     * @param index
      */
     addLayers(layers: __esri.Layer[], index?: number): Promise<void>;
     /**
@@ -437,6 +926,7 @@ export declare class ArcgisMap extends LitElement {
      * since 4.33, use `element.map.tables.add(table)` instead.
      *
      * Adds a table to the map tables collection.
+     * @param table
      */
     addTable(table: __esri.FeatureLayer): Promise<void>;
     /**
@@ -444,24 +934,111 @@ export declare class ArcgisMap extends LitElement {
      * since 4.33, use `element.map.tables.addMany([table])` instead.
      *
      * Adds a table or array of tables to the map tables collection.
+     * @param tables
+     * @param index
      */
     addTables(tables: __esri.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. */
+    /**
+     * Sets the view to a given target.
+     *
+     * @param target
+     * @param options
+     */
     goTo(target: __esri.GoToTarget2D, options?: __esri.GoToOptions2D): Promise<unknown>;
-    /** Returns hit test results from each layer that intersects the specified screen coordinates. */
+    /**
+     * Returns [hit test results](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#HitTestResult)
+     * from each layer that intersects the specified screen coordinates. The results are
+     * organized as an array of objects containing different [result types](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#HitTestResult).
+     *
+     * The following layer types will return all [features](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#GraphicHit) if a hit is
+     * made on intersecting features: [FeatureLayer](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-FeatureLayer.html),
+     * [CatalogLayer](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-CatalogLayer.html),
+     * [CSVLayer](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-CSVLayer.html),
+     * [GeoJSONLayer](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-GeoJSONLayer.html),
+     * [GeoRSSLayer](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-GeoRSSLayer.html),
+     * [GraphicsLayer](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-GraphicsLayer.html),
+     * [KMLLayer](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-KMLLayer.html),
+     * [MapNotesLayer](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-MapNotesLayer.html),
+     * [OGCFeatureLayer](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-OGCFeatureLayer.html),
+     * [StreamLayer](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-StreamLayer.html),
+     * [SubtypeSublayer](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-support-SubtypeSublayer.html),
+     * [VectorTileLayer](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-VectorTileLayer.html), and
+     * [WFSLayer](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-WFSLayer.html).
+     *
+     * The [ParquetLayer](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-ParquetLayer.html) hit result returns only the topmost feature
+     * when the hit occurs on overlapping features in a ParquetLayer.
+     *
+     * The [VectorTileLayer](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-VectorTileLayer.html) hit test result contains an array of objects containing
+     * a [graphic](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#GraphicHit).
+     * The graphic returns attributes of a style layer. In addition, the graphic's [origin](https://developers.arcgis.com/javascript/latest/api-reference/esri-Graphic.html#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.arcgis.com/en/arcgis-online/reference/tile-layers.htm#ESRI_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://developers.arcgis.com/javascript/latest/api-reference/esri-layers-MediaLayer.html) hit test result contains all media elements if the hit is made on intersecting elements.
+     * The [RouteLayer](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-RouteLayer.html) hit test result contains all route elements if the hit is made on intersecting elements.
+     *
+     * If the [polygon](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Polygon.html) feature's symbol
+     * [style](https://developers.arcgis.com/javascript/latest/api-reference/esri-symbols-SimpleFillSymbol.html#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://developers.arcgis.com/javascript/latest/api-reference/esri-symbols-SimpleFillSymbol.html#color) to a transparent color instead.
+     *
+     * @param screenPoint
+     * @param options
+     * @example
+     * ```js
+     * viewElement.addEventListener("arcgisViewClick", (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("arcgisViewClick", 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: __esri.MapViewScreenPoint | MouseEvent, options?: __esri.MapViewHitTestOptions): Promise<__esri.HitTestResult>;
     /**
      * 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?: __esri.PopupViewOpenPopupOptions): Promise<void>;
-    /** Create a screenshot of the current view. */
+    /**
+     * Create a screenshot of the current view.
+     *
+     * @param options
+     */
     takeScreenshot(options?: __esri.MapViewTakeScreenshotOptions): Promise<__esri.Screenshot>;
+    /** @param screenPoint */
     toMap(screenPoint: __esri.MapViewScreenPoint | MouseEvent): __esri.Point;
+    /**
+     * @param point
+     * @param options
+     */
     toScreen(point: __esri.Point, options?: __esri.ToScreenOptions2D): __esri.MapViewScreenPoint | nullish;
     /** Call this method to clear any fatal errors resulting from a lost WebGL context. */
     tryFatalErrorRecovery(): Promise<void>;
@@ -469,6 +1046,8 @@ export declare class ArcgisMap extends LitElement {
      * `viewOnReady()` may be leveraged once an instance of the component and its underlying [view](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-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://developers.arcgis.com/javascript/latest/watch-for-changes/#waiting-for-components-or-views-to-be-ready)
      * @example
@@ -484,176 +1063,272 @@ export declare class ArcgisMap extends LitElement {
      * Gets the analysis view created for the given analysis object.
      *
      * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#whenAnalysisView)
-     */
-    whenAnalysisView(analysis: __esri.ElevationProfileAnalysis): Promise<__esri.ElevationProfileAnalysisView2D>;
-    /**
-     * Gets the LayerView created on the view for the given layer.
      *
-     * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#whenLayerView)
+     * @param analysis
+     * @since 4.34
      */
-    whenLayerView(layer: __esri.PointCloudLayer): Promise<__esri.PointCloudLayerView>;
+    whenAnalysisView(analysis: __esri.AreaMeasurementAnalysis): Promise<__esri.AreaMeasurementAnalysisView2D>;
     /**
-     * Gets the LayerView created on the view for the given layer.
+     * Gets the analysis view created for the given analysis object.
      *
-     * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#whenLayerView)
-     */
-    whenLayerView(layer: __esri.StreamLayer): Promise<__esri.StreamLayerView>;
-    /**
-     * Gets the LayerView created on the view for the given layer.
+     * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#whenAnalysisView)
      *
-     * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#whenLayerView)
+     * @param analysis
+     * @since 4.34
      */
-    whenLayerView(layer: __esri.WFSLayer): Promise<__esri.WFSLayerView>;
+    whenAnalysisView(analysis: __esri.DistanceMeasurementAnalysis): Promise<__esri.DistanceMeasurementAnalysisView2D>;
     /**
-     * Gets the LayerView created on the view for the given layer.
+     * Gets the analysis view created for the given analysis object.
      *
-     * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#whenLayerView)
-     */
-    whenLayerView(layer: __esri.OGCFeatureLayer): Promise<__esri.OGCFeatureLayerView>;
-    /**
-     * Gets the LayerView created on the view for the given layer.
+     * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#whenAnalysisView)
      *
-     * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#whenLayerView)
+     * @param analysis
+     * @since 4.34
      */
-    whenLayerView(layer: __esri.FeatureLayer): Promise<__esri.FeatureLayerView>;
+    whenAnalysisView(analysis: __esri.ElevationProfileAnalysis): Promise<__esri.ElevationProfileAnalysisView2D>;
     /**
      * Gets the LayerView created on the view for the given layer.
      *
      * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#whenLayerView)
+     *
+     * @param layer
      */
-    whenLayerView(layer: __esri.CSVLayer): Promise<__esri.CSVLayerView>;
+    whenLayerView<TLayer extends __esri.Layer>(layer: TLayer): Promise<LayerView2DFor<TLayer>>;
     /**
-     * Gets the LayerView created on the view for the given layer.
+     * Fires when the view for an analysis is created.
      *
-     * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#whenLayerView)
+     * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#event-analysis-view-create)
+     *
+     * @since 4.34
      */
-    whenLayerView(layer: __esri.GeoJSONLayer): Promise<__esri.GeoJSONLayerView>;
+    readonly arcgisViewAnalysisViewCreate: TargetedEvent<this, import('@arcgis/core/views/types').AnalysisViewCreateEvent>;
     /**
-     * Gets the LayerView created on the view for the given layer.
+     * Fires when an error occurs during the creation of an analysis view after an analysis is added to the view.
      *
-     * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#whenLayerView)
+     * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#event-analysis-view-create-error)
+     *
+     * @since 4.34
      */
-    whenLayerView(layer: __esri.GeoRSSLayer): Promise<__esri.GeoRSSLayerView>;
+    readonly arcgisViewAnalysisViewCreateError: TargetedEvent<this, import('@arcgis/core/views/types').AnalysisViewCreateErrorEvent>;
     /**
-     * Gets the LayerView created on the view for the given layer.
+     * Fires after an analysis view is destroyed.
      *
-     * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#whenLayerView)
+     * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#event-analysis-view-destroy)
+     *
+     * @since 4.34
      */
-    whenLayerView(layer: __esri.GraphicsLayer): Promise<__esri.GraphicsLayerView>;
+    readonly arcgisViewAnalysisViewDestroy: TargetedEvent<this, import('@arcgis/core/views/types').AnalysisViewDestroyEvent>;
     /**
-     * Gets the LayerView created on the view for the given layer.
+     * This event is triggered when view-related properties change, such as [zoom](#zoom), [scale](#scale), [center](#center), [rotation](#rotation), [extent](#extent),
+     * [viewpoint](#viewpoint), or [stationary](#stationary).
+     * It reflects user interactions (e.g. panning or zooming) or programmatic updates to the view.
      *
-     * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#whenLayerView)
+     * @example
+     * ```js
+     * // get the number of features in a layer view whenever the view becomes stationary
+     * viewElement.addEventListener("arcgisViewChange", 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
+     *   }
+     * });
+     * ```
      */
-    whenLayerView(layer: __esri.ImageryLayer): Promise<__esri.ImageryLayerView>;
+    readonly arcgisViewChange: TargetedEvent<this, void>;
     /**
-     * Gets the LayerView created on the view for the given layer.
+     * Fires after a user clicks on the view. This event emits slightly slower than an [arcgisViewImmediateClick](#arcgisViewImmediateClick)
+     * event to make sure that an [arcgisViewDoubleClick](#arcgisViewDoubleClick) event isn't triggered instead. The `arcgisViewImmediateClick`
+     * event can be used for responding to an `arcgisViewClick` event without delay.
      *
-     * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#whenLayerView)
+     * @example
+     * ```js
+     * // Listen for clicks on the view and perform a hit test on a feature layer
+     * viewElement.addEventListener("arcgisViewClick", (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);
+     *       }
+     *     });
+     * });
+     * ```
      */
-    whenLayerView(layer: __esri.KMLLayer): Promise<__esri.KMLLayerView>;
+    readonly arcgisViewClick: TargetedEvent<this, import('@arcgis/core/views/input/types').ClickEvent>;
     /**
-     * Gets the LayerView created on the view for the given layer.
+     * Fires after double-clicking on the view.
      *
-     * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#whenLayerView)
+     * @example
+     * ```js
+     * viewElement.addEventListener("arcgisViewDoubleClick", async (event) => {
+     *   // Prevent the default zoom-in behavior on double-click
+     *   event.detail.stopPropagation();
+     * });
+     * ```
      */
-    whenLayerView(layer: __esri.SceneLayer): Promise<__esri.SceneLayerView>;
+    readonly arcgisViewDoubleClick: TargetedEvent<this, DoubleClickEvent>;
     /**
-     * Gets the LayerView created on the view for the given layer.
+     * Fires while the pointer is drag following a double-tap gesture on the view.
      *
-     * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#whenLayerView)
+     * @since 5.0
+     * @example
+     * viewElement.addEventListener("double-tap-drag", (event) => {
+     *   // Display the distance moved from the drag origin.
+     *   console.log("x distance:", event.x, "y distance:", event.y);
+     * });
+     *
+     * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#event-double-tap-drag)
      */
-    whenLayerView(layer: __esri.DimensionLayer): Promise<__esri.DimensionLayerView>;
+    readonly arcgisViewDoubleTapDrag: TargetedEvent<this, DoubleTapDragEvent>;
+    /** Fires during a pointer drag on the view. */
+    readonly arcgisViewDrag: TargetedEvent<this, import('@arcgis/core/views/input/types').DragEvent>;
+    /** Fires after holding either a mouse button or a single finger on the view for a short amount of time. */
+    readonly arcgisViewHold: TargetedEvent<this, import('@arcgis/core/views/input/types').HoldEvent>;
     /**
-     * Gets the LayerView created on the view for the given layer.
+     * Fires right after a user clicks on the view. In contrast to the [arcgisViewClick](#arcgisViewClick) event, the `arcgisViewImmediateClick`
+     * is emitted as soon as the user clicks on the view, and is not inhibited by a [arcgisViewDoubleClick](#arcgisViewDoubleClick) event.
+     * This event is useful for interactive experiences that require feedback without delay.
      *
-     * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#whenLayerView)
+     * @example
+     * ```js
+     * viewElement.addEventListener("arcgisViewImmediateClick", async (event) => {
+     *   // Prevent the default zoom-in behavior on arcgisViewImmediateClick
+     *   event.detail.stopPropagation();
+     * });
+     * ```
      */
-    whenLayerView(layer: __esri.MediaLayer): Promise<__esri.MediaLayerView>;
+    readonly arcgisViewImmediateClick: TargetedEvent<this, import('@arcgis/core/views/input/types').ImmediateClickEvent>;
     /**
-     * Gets the LayerView created on the view for the given layer.
-     *
-     * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#whenLayerView)
+     * Fires after two consecutive [arcgisViewImmediateClick](#arcgisViewImmediateClick) events. In contrast to [arcgisViewDoubleClick](#arcgisViewDoubleClick),
+     * an `arcgisViewImmediateDoubleClick` cannot be prevented by use of `stopPropagation()` on the [arcgisViewImmediateClick](#arcgisViewImmediateClick)
+     * event and can therefore be used to react to double-clicking independently of usage of the [arcgisViewImmediateClick](#arcgisViewImmediateClick) event.
      */
-    whenLayerView(layer: __esri.ViewshedLayer): Promise<__esri.ViewshedLayerView>;
+    readonly arcgisViewImmediateDoubleClick: TargetedEvent<this, import('@arcgis/core/views/input/types').ImmediateDoubleClickEvent>;
     /**
-     * Gets the LayerView created on the view for the given layer.
+     * Fires after a keyboard key is pressed.
      *
-     * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#whenLayerView)
+     * @example
+     * ```js
+     * // Disable zooming with the keyboard
+     * // Stop event propagation when `+` and `-` keys are pressed.
+     * viewElement.addEventListener("arcgisViewKeyDown", function(event){
+     *   console.log("key-down", event);
+     *
+     *   const prohibitedKeys = ["+", "-"];
+     *   const keyPressed = event.detail.key;
+     *   if (prohibitedKeys.indexOf(keyPressed) !== -1) {
+     *     event.detail.stopPropagation();
+     *   }
+     * });
+     * ```
      */
-    whenLayerView(layer: __esri.LineOfSightLayer): Promise<__esri.LineOfSightLayerView>;
+    readonly arcgisViewKeyDown: TargetedEvent<this, import('@arcgis/core/views/input/types').KeyDownEvent>;
+    /** Fires after a keyboard key is released. */
+    readonly arcgisViewKeyUp: TargetedEvent<this, import('@arcgis/core/views/input/types').KeyUpEvent>;
     /**
-     * Gets the LayerView created on the view for the given layer.
-     *
-     * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#whenLayerView)
+     * Fires after each layer in the map has a corresponding
+     * [LayerView](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-layers-LayerView.html)
+     * created and rendered in the view.
      */
-    whenLayerView(layer: __esri.Layer): Promise<__esri.LayerView>;
+    readonly arcgisViewLayerviewCreate: TargetedEvent<this, import('@arcgis/core/views/input/types').LayerViewCreateEvent>;
     /**
-     * Fires when the view for an analysis is created.
-     *
-     * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#event-analysis-view-create)
+     * Fires when an error occurs during the creation of a [LayerView](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-layers-LayerView.html)
+     * after a layer has been added to the map.
      */
-    readonly arcgisViewAnalysisViewCreate: TargetedEvent<this, __esri.ViewAnalysisViewCreateEvent>;
+    readonly arcgisViewLayerviewCreateError: TargetedEvent<this, import('@arcgis/core/views/input/types').LayerViewCreateErrorEvent>;
     /**
-     * Fires when an error occurs during the creation of an analysis view after an analysis is added to the view.
-     *
-     * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#event-analysis-view-create-error)
+     * Fires after a [LayerView](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-layers-LayerView.html)
+     * is destroyed and is no longer rendered in the view.
      */
-    readonly arcgisViewAnalysisViewCreateError: TargetedEvent<this, __esri.ViewAnalysisViewCreateErrorEvent>;
+    readonly arcgisViewLayerviewDestroy: TargetedEvent<this, import('@arcgis/core/views/input/types').LayerViewDestroyEvent>;
     /**
-     * Fires after an analysis view is destroyed.
+     * Fires when a wheel button of a pointing device (typically a mouse) is scrolled on the view.
      *
-     * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#event-analysis-view-destroy)
+     * @example
+     * ```js
+     * viewElement.addEventListener("arcgisViewMouseWheel", async (event) => {
+     *   // Prevent the default zoom-in and zoom-out behavior on arcgisViewMouseWheel
+     *   event.detail.stopPropagation();
+     * });
+     * ```
      */
-    readonly arcgisViewAnalysisViewDestroy: TargetedEvent<this, __esri.ViewAnalysisViewDestroyEvent>;
+    readonly arcgisViewMouseWheel: TargetedEvent<this, import('@arcgis/core/views/input/types').ViewMouseWheelEvent>;
     /**
-     * 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.
+     * Fires after a mouse button is pressed, or a finger touches the display.
+     *
+     * @see [Sample: Access features with hitTest](https://developers.arcgis.com/javascript/latest/sample-code/map-component-hittest/)
      */
-    readonly arcgisViewChange: TargetedEvent<this, void>;
-    /** Fires after a user clicks on the view. */
-    readonly arcgisViewClick: TargetedEvent<this, __esri.ViewClickEvent>;
-    /** Fires after double-clicking on the view. */
-    readonly arcgisViewDoubleClick: TargetedEvent<this, __esri.ViewDoubleClickEvent>;
-    /** Fires during a pointer drag on the view. */
-    readonly arcgisViewDrag: TargetedEvent<this, __esri.ViewDragEvent>;
-    /** Fires during a pointer drag on the view. */
-    readonly arcgisViewHold: TargetedEvent<this, __esri.ViewHoldEvent>;
-    /** Fires right after a user clicks on the view. */
-    readonly arcgisViewImmediateClick: TargetedEvent<this, __esri.ViewImmediateClickEvent>;
-    /** Is emitted after two consecutive immediate-click events. */
-    readonly arcgisViewImmediateDoubleClick: TargetedEvent<this, __esri.ViewImmediateDoubleClickEvent>;
-    /** Fires after a keyboard key is pressed. */
-    readonly arcgisViewKeyDown: TargetedEvent<this, __esri.ViewKeyDownEvent>;
-    /** Fires after a keyboard key is pressed. */
-    readonly arcgisViewKeyUp: TargetedEvent<this, __esri.ViewKeyUpEvent>;
-    /** Fires after each layer in the map has a corresponding LayerView created and rendered in the view. */
-    readonly arcgisViewLayerviewCreate: TargetedEvent<this, __esri.ViewLayerviewCreateEvent>;
-    /** Fires when an error emits during the creation of a LayerView after a layer has been added to the map. */
-    readonly arcgisViewLayerviewCreateError: TargetedEvent<this, __esri.ViewLayerviewCreateErrorEvent>;
-    /** Fires after a LayerView is destroyed and is no longer rendered in the view. */
-    readonly arcgisViewLayerviewDestroy: TargetedEvent<this, __esri.ViewLayerviewDestroyEvent>;
-    /** Fires when a wheel button of a pointing device (typically a mouse) is scrolled on the view. */
-    readonly arcgisViewMouseWheel: TargetedEvent<this, __esri.ViewMouseWheelEvent>;
-    /** Fires after a mouse button is pressed, or a finger touches the display. */
-    readonly arcgisViewPointerDown: TargetedEvent<this, __esri.ViewPointerDownEvent>;
+    readonly arcgisViewPointerDown: TargetedEvent<this, import('@arcgis/core/views/input/types').PointerDownEvent>;
     /** Fires after a mouse cursor enters the view, or a display touch begins. */
-    readonly arcgisViewPointerEnter: TargetedEvent<this, __esri.ViewPointerEnterEvent>;
+    readonly arcgisViewPointerEnter: TargetedEvent<this, import('@arcgis/core/views/input/types').PointerEnterEvent>;
     /** Fires after a mouse cursor leaves the view, or a display touch ends. */
-    readonly arcgisViewPointerLeave: TargetedEvent<this, __esri.ViewPointerLeaveEvent>;
-    /** Fires after the mouse or a finger on the display moves. */
-    readonly arcgisViewPointerMove: TargetedEvent<this, __esri.ViewPointerMoveEvent>;
+    readonly arcgisViewPointerLeave: TargetedEvent<this, import('@arcgis/core/views/input/types').PointerLeaveEvent>;
+    /**
+     * Fires after the mouse or a finger on the display moves.
+     *
+     * @see [Sample: Access features with hitTest](https://developers.arcgis.com/javascript/latest/sample-code/map-component-hittest/)
+     */
+    readonly arcgisViewPointerMove: TargetedEvent<this, import('@arcgis/core/views/input/types').PointerMoveEvent>;
     /** Fires after a mouse button is released, or a display touch ends. */
-    readonly arcgisViewPointerUp: TargetedEvent<this, __esri.ViewPointerUpEvent>;
+    readonly arcgisViewPointerUp: TargetedEvent<this, import('@arcgis/core/views/input/types').PointerUpEvent>;
     /**
-     * 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.
+     * This event is for the `ready` property and is emitted when the view is ready.
+     * Fires also when the [map](#map) is updated.
      */
     readonly arcgisViewReadyChange: TargetedEvent<this, void>;
+    /**
+     * Fires while the two pointers are dragged on the view.
+     *
+     * @since 5.0
+     * @example
+     * viewElement.addEventListener("vertical-two-finger-drag", (event) => {
+     *   // Display the distance moved vertically from the drag origin.
+     *   console.log("y distance:", event.y);
+     * });
+     *
+     * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#event-vertical-two-finger-drag)
+     */
+    readonly arcgisViewVerticalTwoFingerDrag: TargetedEvent<this, VerticalTwoFingerDragEvent>;
     private _map: __esri.Map;
     readonly _setterTypes: {
         center?: __esri.MapView["center"] | nil | number[] | string;
         ground?: __esri.Ground | string;
     };
+    "@eventTypes": {
+        "arcgisLoadError": ArcgisMap["arcgisLoadError"]["detail"];
+        "arcgisViewAnalysisViewCreate": ArcgisMap["arcgisViewAnalysisViewCreate"]["detail"];
+        "arcgisViewAnalysisViewCreateError": ArcgisMap["arcgisViewAnalysisViewCreateError"]["detail"];
+        "arcgisViewAnalysisViewDestroy": ArcgisMap["arcgisViewAnalysisViewDestroy"]["detail"];
+        "arcgisViewChange": ArcgisMap["arcgisViewChange"]["detail"];
+        "arcgisViewClick": ArcgisMap["arcgisViewClick"]["detail"];
+        "arcgisViewDoubleClick": ArcgisMap["arcgisViewDoubleClick"]["detail"];
+        "arcgisViewDoubleTapDrag": ArcgisMap["arcgisViewDoubleTapDrag"]["detail"];
+        "arcgisViewDrag": ArcgisMap["arcgisViewDrag"]["detail"];
+        "arcgisViewHold": ArcgisMap["arcgisViewHold"]["detail"];
+        "arcgisViewImmediateClick": ArcgisMap["arcgisViewImmediateClick"]["detail"];
+        "arcgisViewImmediateDoubleClick": ArcgisMap["arcgisViewImmediateDoubleClick"]["detail"];
+        "arcgisViewKeyDown": ArcgisMap["arcgisViewKeyDown"]["detail"];
+        "arcgisViewKeyUp": ArcgisMap["arcgisViewKeyUp"]["detail"];
+        "arcgisViewLayerviewCreate": ArcgisMap["arcgisViewLayerviewCreate"]["detail"];
+        "arcgisViewLayerviewCreateError": ArcgisMap["arcgisViewLayerviewCreateError"]["detail"];
+        "arcgisViewLayerviewDestroy": ArcgisMap["arcgisViewLayerviewDestroy"]["detail"];
+        "arcgisViewMouseWheel": ArcgisMap["arcgisViewMouseWheel"]["detail"];
+        "arcgisViewPointerDown": ArcgisMap["arcgisViewPointerDown"]["detail"];
+        "arcgisViewPointerEnter": ArcgisMap["arcgisViewPointerEnter"]["detail"];
+        "arcgisViewPointerLeave": ArcgisMap["arcgisViewPointerLeave"]["detail"];
+        "arcgisViewPointerMove": ArcgisMap["arcgisViewPointerMove"]["detail"];
+        "arcgisViewPointerUp": ArcgisMap["arcgisViewPointerUp"]["detail"];
+        "arcgisViewReadyChange": ArcgisMap["arcgisViewReadyChange"]["detail"];
+        "arcgisViewReadyError": ArcgisMap["arcgisViewReadyError"]["detail"];
+        "arcgisViewVerticalTwoFingerDrag": ArcgisMap["arcgisViewVerticalTwoFingerDrag"]["detail"];
+    };
 }
 export {};