@arcgis/map-components 5.0.0-next.8 → 5.0.0-next.80

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

@@ -7,12 +7,13 @@ 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 { LayerView2DFor } from '@arcgis/core/views/2d/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" | "layers" | "presentation" | "tables" | "widgets" | "applicationProperties" | "authoringApp" | "authoringAppVersion" | "bookmarks" | "floorInfo" | "geotriggersInfo" | "initialViewProperties" | "portalItem" | "thumbnailUrl" | "utilityNetworks">, "basemap" | "ground" | "layers" | "presentation" | "tables" | "widgets" | "applicationProperties" | "authoringApp" | "authoringAppVersion" | "bookmarks" | "floorInfo" | "geotriggersInfo" | "initialViewProperties" | "portalItem" | "thumbnailUrl" | "utilityNetworks" | ("declaredClass" | "destroyed" | "initialized" | "addHandles" | "hasHandles" | "removeHandles" | "set" | "watch")> & {
     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" | "container" | "animation" | "displayFilterEnabled">, "ui" | ("destroyed" | "initialized" | "declaredClass" | "set" | "watch" | "addHandles" | "removeHandles" | "hasHandles") | "breakpoints" | "heightBreakpoint" | "popupEnabled" | "widthBreakpoint" | "container" | "animation" | "displayFilterEnabled" | "animationsEnabled"> & {
+declare const useMapView: (component: LitElement & Omit<Pick<MapView, "rotation" | "center" | "analyses" | "map" | "aria" | "attributionMode" | "background" | "basemapView" | "constraints" | "extent" | "fatalError" | "floors" | "graphics" | "highlights" | "highlightOptions" | "navigation" | "padding" | "popup" | "resizeAlign" | "scale" | "spatialReference" | "spatialReferenceLocked" | "theme" | "timeExtent" | "timeZone" | "viewpoint" | "zoom" | "animation" | "animationsEnabled" | "attributionVisible" | "breakpoints" | "container" | "displayFilterEnabled" | "heightBreakpoint" | "popupEnabled" | "ui" | "widthBreakpoint">, "animation" | "animationsEnabled" | "attributionVisible" | "breakpoints" | "container" | "displayFilterEnabled" | "heightBreakpoint" | "popupEnabled" | "ui" | "widthBreakpoint" | ("declaredClass" | "destroyed" | "initialized" | "addHandles" | "hasHandles" | "removeHandles" | "set" | "watch")> & {
     autoDestroyDisabled: boolean;
     destroy: () => Promise<void>;
 }) => MapView;
@@ -20,18 +21,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 +90,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.
@@ -69,35 +100,54 @@ declare const useMapView: (component: LitElement & Omit<Pick<MapView, "rotation"
  * @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.
+ * @since 4.28
  */
 export declare class ArcgisMap extends LitElement {
     /**
-     * Fires when a Map, Scene, or Link Chart fails to load or if one of their sub-components fails to load (e.g., basemap, ground, layers).
+     * Fires when a ArcgisMap fails to load or if one of its dependencies fails to load (e.g., basemap, ground, layers).
      *
+     * @since 4.34
      * @see [loadErrorSources](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-map/#loadErrorSources)
      * @example
      * ```js
-     *       viewComponent.addEventListener("arcgisLoadError", () => {
-     *         console.log(viewComponent.loadErrorSources);
-     *       });
-     *      ```
+     * viewElement.addEventListener("arcgisLoadError", () => {
+     *   console.log(viewElement.loadErrorSources);
+     * });
+     * ```
      */
     readonly arcgisLoadError: TargetedEvent<this>;
     /**
-     * Fires if the map view encounters a content or rendering error.
+     * Fires if the view encounters a content or rendering error.
      *
+     * @since 4.34
      * @example
      * ```js
-     *       viewComponent.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. */
     readonly view: MapView;
     /**
-     * The ARIA information for the view.
+     * Indicates whether animations are disabled in the view. This includes animated symbols (animated
+     * [CIMSymbol](https://developers.arcgis.com/javascript/latest/api-reference/esri-symbols-CIMSymbol.html),
+     * [PictureMarkerSymbol](https://developers.arcgis.com/javascript/latest/api-reference/esri-symbols-PictureMarkerSymbol.html)
+     * from a GIF/animated PNG), animated renderers
+     * ([FlowRenderer](https://developers.arcgis.com/javascript/latest/api-reference/esri-rasterRenderers.html#FlowRenderer)),
+     * animated layers ([MediaLayer](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-MediaLayer.html),
+     * [VideoLayer](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-VideoLayer.html)), and
+     * animations triggered by view navigation (for example,
+     * [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.
+     *
+     * @default false
+     * @since 4.34
+     */
+    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
      */
@@ -106,14 +156,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>;
+    allLayerViews: import('@arcgis/core/core/Collection.js').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<__esri.Analysis>;
+    analyses: Collection<import('@arcgis/core/analysis/Analysis').default>;
+    /**
+     * The attribution items displayed in the view's attribution.
+     *
+     * @since 5.0
+     */
+    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: import('@arcgis/core/support/modeUtils').Mode | 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
@@ -127,9 +199,17 @@ export declare class ArcgisMap extends LitElement {
     /**
      * The background color of the Map component.
      *
-     * @default null
+     * @since 4.16
+     * @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
@@ -142,20 +222,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
@@ -166,14 +349,39 @@ 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.
+     *
+     * @since 4.19
      */
     floors: Collection<string>;
     /** Gamepad input specific configuration settings. */
@@ -191,30 +399,167 @@ 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/)
+     * @example
+     * // Adds a graphic to the View
+     * view.graphics.add(pointGraphic);
+     * @example
+     * // Removes a graphic from the View
+     * view.graphics.remove(pointGraphic);
+     */
+    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
      */
-    highlights: Collection<__esri.HighlightOptions>;
+    get hideAttribution(): boolean;
+    set hideAttribution(value: boolean);
     /**
-     * Options for configuring the highlight.
+     * 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
+     * @see [Sample: Highlight features by geometry](https://developers.arcgis.com/javascript/latest/sample-code/highlight-features-by-geometry/)
+     * @see [Sample: Highlight SceneLayer](https://developers.arcgis.com/javascript/latest/sample-code/highlight-scenelayer/)
+     * @see [Sample: Highlight point features](https://developers.arcgis.com/javascript/latest/sample-code/highlight-point-features/)
+     * @example
+     * // Use the default highlights collection to apply a highlight to features when you hover over them
      *
-     * @deprecated since version 4.32. Use the [highlights](#highlights) property instead.
+     * // 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);
      */
-    highlightOptions: __esri.HighlightOptions;
+    highlights: Collection<import('@arcgis/core/views/support/HighlightOptions').default>;
+    /**
+     * 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](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-View2D.html#highlights) property instead.
+     * @see [Sample: Highlight SceneLayer](https://developers.arcgis.com/javascript/latest/sample-code/highlight-scenelayer/)
+     * @see [Sample: Highlight point features](https://developers.arcgis.com/javascript/latest/sample-code/highlight-point-features/)
+     * @example
+     * const view = new MapView({
+     *   map: map,
+     *   highlightOptions: {
+     *     color: [255, 255, 0, 1],
+     *     haloOpacity: 0.9,
+     *     fillOpacity: 0.2
+     *   }
+     * });
+     */
+    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.
      *
@@ -226,38 +571,93 @@ 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<__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;
+    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
+     */
+    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/Padding').Padding;
     /**
      * 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).
+     * [Map#layers](https://developers.arcgis.com/javascript/latest/api-reference/esri-Map.html#layers) in the {@link views /PopupView#map}.
      *
-     * [Read more...](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-View2D.html#popup)
+     * 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 [View2D#openPopup()](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-View2D.html#openPopup) method is called,
+     * or when some widgets 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.
+     *
+     * @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.
+     * Controls whether the popup opens automatically when users click on the view.
      *
      * @default false
      */
@@ -275,8 +675,9 @@ 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;
+    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
@@ -284,13 +685,15 @@ 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/ViewStateManager').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;
+    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
@@ -300,6 +703,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;
     /**
@@ -309,21 +729,68 @@ 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.
+     *
+     * 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.
      *
      * @default null
+     * @name spatialReference
+     * @instance
+     * @type {module:esri/geometry/SpatialReference}
+     * @autocast
+     * @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;
     /**
@@ -337,28 +804,64 @@ export declare class ArcgisMap extends LitElement {
      *
      * @default true
      */
-    readonly suspended: boolean;
+    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"
+     * @since 4.28
+     * @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;
     /**
@@ -367,7 +870,7 @@ export declare class ArcgisMap extends LitElement {
      *
      * @default false
      */
-    readonly updating: boolean;
+    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
@@ -376,12 +879,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;
+    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.
@@ -394,13 +901,19 @@ export declare class ArcgisMap extends LitElement {
      */
     get zoom(): number;
     set zoom(newValue: number);
-    /** Any objects that encountered an error while loading the map, its basemap, ground, or any of the layers or tables in the map. You may inspect the errors by accessing each object's `loadError` property. */
+    /**
+     * 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
+     */
     loadErrorSources?: LoadErrorSource[];
     /**
      * @deprecated
      * 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>;
     /**
@@ -408,6 +921,8 @@ export declare class ArcgisMap extends LitElement {
      * 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>;
     /**
@@ -415,6 +930,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>;
     /**
@@ -422,24 +938,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>;
@@ -447,6 +1050,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
@@ -462,170 +1067,194 @@ 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)
+     *
+     * @param analysis
+     * @since 4.34
      */
     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)
-     */
-    whenLayerView(layer: __esri.PointCloudLayer): Promise<__esri.PointCloudLayerView>;
-    /**
-     * 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.StreamLayer): Promise<__esri.StreamLayerView>;
+    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)
-     */
-    whenLayerView(layer: __esri.WFSLayer): Promise<__esri.WFSLayerView>;
-    /**
-     * 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#event-analysis-view-create)
      *
-     * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#whenLayerView)
+     * @since 4.34
      */
-    whenLayerView(layer: __esri.OGCFeatureLayer): Promise<__esri.OGCFeatureLayerView>;
+    readonly arcgisViewAnalysisViewCreate: TargetedEvent<this, import('@arcgis/core/views/IView').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)
-     */
-    whenLayerView(layer: __esri.FeatureLayer): Promise<__esri.FeatureLayerView>;
-    /**
-     * 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#event-analysis-view-create-error)
      *
-     * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#whenLayerView)
+     * @since 4.34
      */
-    whenLayerView(layer: __esri.CSVLayer): Promise<__esri.CSVLayerView>;
+    readonly arcgisViewAnalysisViewCreateError: TargetedEvent<this, import('@arcgis/core/views/IView').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)
-     */
-    whenLayerView(layer: __esri.GeoJSONLayer): Promise<__esri.GeoJSONLayerView>;
-    /**
-     * 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#event-analysis-view-destroy)
      *
-     * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#whenLayerView)
+     * @since 4.34
      */
-    whenLayerView(layer: __esri.GeoRSSLayer): Promise<__esri.GeoRSSLayerView>;
+    readonly arcgisViewAnalysisViewDestroy: TargetedEvent<this, import('@arcgis/core/views/IView').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.GraphicsLayer): Promise<__esri.GraphicsLayerView>;
+    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)
-     */
-    whenLayerView(layer: __esri.ImageryLayer): Promise<__esri.ImageryLayerView>;
-    /**
-     * Gets the LayerView created on the view for the given layer.
+     * @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;
      *
-     * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#whenLayerView)
+     *         getPolygonCentroid(stateBoundaryPolygon);
+     *       }
+     *     });
+     * });
+     * ```
      */
-    whenLayerView(layer: __esri.KMLLayer): Promise<__esri.KMLLayerView>;
+    readonly arcgisViewClick: TargetedEvent<this, import('@arcgis/core/views/input/IViewEvents').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, import('@arcgis/core/views/input/IViewEvents').DoubleClickEvent>;
+    /** Fires during a pointer drag on the view. */
+    readonly arcgisViewDrag: TargetedEvent<this, import('@arcgis/core/views/input/IViewEvents').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/IViewEvents').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.DimensionLayer): Promise<__esri.DimensionLayerView>;
+    readonly arcgisViewImmediateClick: TargetedEvent<this, import('@arcgis/core/views/input/IViewEvents').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.MediaLayer): Promise<__esri.MediaLayerView>;
+    readonly arcgisViewImmediateDoubleClick: TargetedEvent<this, import('@arcgis/core/views/input/IViewEvents').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)
-     */
-    whenLayerView(layer: __esri.ViewshedLayer): Promise<__esri.ViewshedLayerView>;
-    /**
-     * Gets the LayerView created on the view for the given layer.
+     * @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);
      *
-     * [Read more](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html#whenLayerView)
+     *   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/IViewEvents').KeyDownEvent>;
+    /** Fires after a keyboard key is released. */
+    readonly arcgisViewKeyUp: TargetedEvent<this, import('@arcgis/core/views/input/IViewEvents').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/IViewEvents').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/IViewEvents').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/IViewEvents').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/IViewEvents').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/IViewEvents').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/IViewEvents').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/IViewEvents').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/IViewEvents').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/IViewEvents').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>;
     private _map: __esri.Map;