@geoscene/map-components 4.33.18

package/dist/index.d.ts

@@ -0,0 +1,1431 @@
+import type { GeosceneAreaMeasurement2d } from "./components/geoscene-area-measurement-2d";
+import type { GeosceneAreaMeasurement3d } from "./components/geoscene-area-measurement-3d";
+import type { GeosceneAttachments } from "./components/geoscene-attachments";
+import type { GeosceneBasemapGallery } from "./components/geoscene-basemap-gallery";
+import type { GeosceneBasemapLayerList } from "./components/geoscene-basemap-layer-list";
+import type { GeosceneBasemapToggle } from "./components/geoscene-basemap-toggle";
+import type { GeosceneBookmarks } from "./components/geoscene-bookmarks";
+import type { GeosceneBuildingExplorer } from "./components/geoscene-building-explorer";
+import type { GeosceneCatalogLayerList } from "./components/geoscene-catalog-layer-list";
+import type { GeosceneCompass } from "./components/geoscene-compass";
+import type { GeosceneCoordinateConversion } from "./components/geoscene-coordinate-conversion";
+import type { GeosceneDaylight } from "./components/geoscene-daylight";
+import type { GeosceneDirectionalPad } from "./components/geoscene-directional-pad";
+import type { GeosceneDirections } from "./components/geoscene-directions";
+import type { GeosceneDirectLineMeasurement3d } from "./components/geoscene-direct-line-measurement-3d";
+import type { DeprecatedGeosceneDirectLineMeasurement3d } from "./components/geoscene-direct-line-measurement-3d";
+import type { GeosceneDistanceMeasurement2d } from "./components/geoscene-distance-measurement-2d";
+import type { GeosceneEditor } from "./components/geoscene-editor";
+import type { GeosceneElevationProfile } from "./components/geoscene-elevation-profile";
+import type { GeosceneExpand } from "./components/geoscene-expand";
+import type { GeosceneFeature } from "./components/geoscene-feature";
+import type { GeosceneFeatureForm } from "./components/geoscene-feature-form";
+import type { GeosceneFeatureTable } from "./components/geoscene-feature-table";
+import type { GeosceneFeatureTemplates } from "./components/geoscene-feature-templates";
+import type { GeosceneFeatures } from "./components/geoscene-features";
+import type { GeosceneFloorFilter } from "./components/geoscene-floor-filter";
+import type { GeosceneFullscreen } from "./components/geoscene-fullscreen";
+import type { GeosceneGridControls } from "./components/geoscene-grid-controls";
+import type { GeosceneHistogramRangeSlider } from "./components/geoscene-histogram-range-slider";
+import type { GeosceneHome } from "./components/geoscene-home";
+import type { GeosceneLayerList } from "./components/geoscene-layer-list";
+import type { GeosceneLegend } from "./components/geoscene-legend";
+import type { GeosceneLineOfSight } from "./components/geoscene-line-of-sight";
+import type { GeosceneLinkChart } from "./components/geoscene-link-chart";
+import type { GeosceneLinkChartLayoutSwitcher } from "./components/geoscene-link-chart-layout-switcher";
+import type { GeosceneLocate } from "./components/geoscene-locate";
+import type { GeosceneMap } from "./components/geoscene-map";
+import type { GeosceneMeasurement } from "./components/geoscene-measurement";
+import type { GeosceneNavigationToggle } from "./components/geoscene-navigation-toggle";
+import type { GeosceneOrientedImageryViewer } from "./components/geoscene-oriented-imagery-viewer";
+import type { GeoscenePlacement } from "./components/geoscene-placement";
+import type { GeoscenePrint } from "./components/geoscene-print";
+import type { GeosceneScaleBar } from "./components/geoscene-scale-bar";
+import type { GeosceneScaleRangeSlider } from "./components/geoscene-scale-range-slider";
+import type { GeosceneScene } from "./components/geoscene-scene";
+import type { GeosceneSearch } from "./components/geoscene-search";
+import type { GeosceneSearchResultRenderer } from "./components/geoscene-search-result-renderer";
+import type { GeosceneShadowCast } from "./components/geoscene-shadow-cast";
+import type { GeosceneSketch } from "./components/geoscene-sketch";
+import type { GeosceneSlice } from "./components/geoscene-slice";
+import type { GeosceneSlider } from "./components/geoscene-slider";
+import type { GeosceneSwipe } from "./components/geoscene-swipe";
+import type { GeosceneTableList } from "./components/geoscene-table-list";
+import type { GeosceneTimeSlider } from "./components/geoscene-time-slider";
+import type { GeosceneTimeZoneLabel } from "./components/geoscene-time-zone-label";
+import type { GeosceneTrack } from "./components/geoscene-track";
+import type { GeosceneUtilityNetworkAssociations } from "./components/geoscene-utility-network-associations";
+import type { GeosceneUtilityNetworkTrace } from "./components/geoscene-utility-network-trace";
+import type { GeosceneUtilityNetworkValidateTopology } from "./components/geoscene-utility-network-validate-topology";
+import type { GeosceneValuePicker } from "./components/geoscene-value-picker";
+import type { GeosceneVersionManagement } from "./components/geoscene-version-management";
+import type { GeosceneVideo } from "./components/geoscene-video";
+import type { GeosceneVideoPlayer } from "./components/geoscene-video-player";
+import type { GeosceneWeather } from "./components/geoscene-weather";
+import type { GeosceneZoom } from "./components/geoscene-zoom";
+
+export { getAssetPath, setAssetPath } from './runtime';
+/**
+ * @deprecated Use `setAssetPath` instead
+ */
+export declare const settGeosceneAssetPath: (path: URL | string) => void;
+/**
+ * @deprecated Use `getAssetPath` instead
+ */
+export declare const getGeosceneAssetPath: (suffix: string) => string;
+
+
+export interface GeosceneAreaMeasurement2dCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneAreaMeasurement2dElement;
+  currentTarget: HTMLGeosceneAreaMeasurement2dElement;
+}
+export interface GeosceneAreaMeasurement3dCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneAreaMeasurement3dElement;
+  currentTarget: HTMLGeosceneAreaMeasurement3dElement;
+}
+export interface GeosceneAttachmentsCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneAttachmentsElement;
+  currentTarget: HTMLGeosceneAttachmentsElement;
+}
+export interface GeosceneBasemapGalleryCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneBasemapGalleryElement;
+  currentTarget: HTMLGeosceneBasemapGalleryElement;
+}
+export interface GeosceneBasemapLayerListCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneBasemapLayerListElement;
+  currentTarget: HTMLGeosceneBasemapLayerListElement;
+}
+export interface GeosceneBasemapToggleCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneBasemapToggleElement;
+  currentTarget: HTMLGeosceneBasemapToggleElement;
+}
+export interface GeosceneBookmarksCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneBookmarksElement;
+  currentTarget: HTMLGeosceneBookmarksElement;
+}
+export interface GeosceneBuildingExplorerCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneBuildingExplorerElement;
+  currentTarget: HTMLGeosceneBuildingExplorerElement;
+}
+export interface GeosceneCatalogLayerListCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneCatalogLayerListElement;
+  currentTarget: HTMLGeosceneCatalogLayerListElement;
+}
+export interface GeosceneCompassCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneCompassElement;
+  currentTarget: HTMLGeosceneCompassElement;
+}
+export interface GeosceneCoordinateConversionCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneCoordinateConversionElement;
+  currentTarget: HTMLGeosceneCoordinateConversionElement;
+}
+export interface GeosceneDaylightCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneDaylightElement;
+  currentTarget: HTMLGeosceneDaylightElement;
+}
+export interface GeosceneDirectionalPadCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneDirectionalPadElement;
+  currentTarget: HTMLGeosceneDirectionalPadElement;
+}
+export interface GeosceneDirectionsCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneDirectionsElement;
+  currentTarget: HTMLGeosceneDirectionsElement;
+}
+export interface GeosceneDirectLineMeasurement3dCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneDirectLineMeasurement3dElement;
+  currentTarget: HTMLGeosceneDirectLineMeasurement3dElement;
+}
+export interface GeosceneDirectlineMeasurement3dCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneDirectlineMeasurement3dElement;
+  currentTarget: HTMLGeosceneDirectlineMeasurement3dElement;
+}
+export interface GeosceneDistanceMeasurement2dCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneDistanceMeasurement2dElement;
+  currentTarget: HTMLGeosceneDistanceMeasurement2dElement;
+}
+export interface GeosceneEditorCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneEditorElement;
+  currentTarget: HTMLGeosceneEditorElement;
+}
+export interface GeosceneElevationProfileCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneElevationProfileElement;
+  currentTarget: HTMLGeosceneElevationProfileElement;
+}
+export interface GeosceneExpandCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneExpandElement;
+  currentTarget: HTMLGeosceneExpandElement;
+}
+export interface GeosceneFeatureCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneFeatureElement;
+  currentTarget: HTMLGeosceneFeatureElement;
+}
+export interface GeosceneFeatureFormCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneFeatureFormElement;
+  currentTarget: HTMLGeosceneFeatureFormElement;
+}
+export interface GeosceneFeatureTableCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneFeatureTableElement;
+  currentTarget: HTMLGeosceneFeatureTableElement;
+}
+export interface GeosceneFeatureTemplatesCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneFeatureTemplatesElement;
+  currentTarget: HTMLGeosceneFeatureTemplatesElement;
+}
+export interface GeosceneFeaturesCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneFeaturesElement;
+  currentTarget: HTMLGeosceneFeaturesElement;
+}
+export interface GeosceneFloorFilterCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneFloorFilterElement;
+  currentTarget: HTMLGeosceneFloorFilterElement;
+}
+export interface GeosceneFullscreenCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneFullscreenElement;
+  currentTarget: HTMLGeosceneFullscreenElement;
+}
+export interface GeosceneGridControlsCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneGridControlsElement;
+  currentTarget: HTMLGeosceneGridControlsElement;
+}
+export interface GeosceneHistogramRangeSliderCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneHistogramRangeSliderElement;
+  currentTarget: HTMLGeosceneHistogramRangeSliderElement;
+}
+export interface GeosceneHomeCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneHomeElement;
+  currentTarget: HTMLGeosceneHomeElement;
+}
+export interface GeosceneLayerListCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneLayerListElement;
+  currentTarget: HTMLGeosceneLayerListElement;
+}
+export interface GeosceneLegendCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneLegendElement;
+  currentTarget: HTMLGeosceneLegendElement;
+}
+export interface GeosceneLineOfSightCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneLineOfSightElement;
+  currentTarget: HTMLGeosceneLineOfSightElement;
+}
+export interface GeosceneLinkChartCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneLinkChartElement;
+  currentTarget: HTMLGeosceneLinkChartElement;
+}
+export interface GeosceneLinkChartLayoutSwitcherCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneLinkChartLayoutSwitcherElement;
+  currentTarget: HTMLGeosceneLinkChartLayoutSwitcherElement;
+}
+export interface GeosceneLocateCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneLocateElement;
+  currentTarget: HTMLGeosceneLocateElement;
+}
+export interface GeosceneMapCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneMapElement;
+  currentTarget: HTMLGeosceneMapElement;
+}
+export interface GeosceneMeasurementCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneMeasurementElement;
+  currentTarget: HTMLGeosceneMeasurementElement;
+}
+export interface GeosceneNavigationToggleCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneNavigationToggleElement;
+  currentTarget: HTMLGeosceneNavigationToggleElement;
+}
+export interface GeosceneOrientedImageryViewerCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneOrientedImageryViewerElement;
+  currentTarget: HTMLGeosceneOrientedImageryViewerElement;
+}
+export interface GeoscenePlacementCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeoscenePlacementElement;
+  currentTarget: HTMLGeoscenePlacementElement;
+}
+export interface GeoscenePrintCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeoscenePrintElement;
+  currentTarget: HTMLGeoscenePrintElement;
+}
+export interface GeosceneScaleBarCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneScaleBarElement;
+  currentTarget: HTMLGeosceneScaleBarElement;
+}
+export interface GeosceneScaleRangeSliderCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneScaleRangeSliderElement;
+  currentTarget: HTMLGeosceneScaleRangeSliderElement;
+}
+export interface GeosceneSceneCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneSceneElement;
+  currentTarget: HTMLGeosceneSceneElement;
+}
+export interface GeosceneSearchCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneSearchElement;
+  currentTarget: HTMLGeosceneSearchElement;
+}
+export interface GeosceneSearchResultRendererCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneSearchResultRendererElement;
+  currentTarget: HTMLGeosceneSearchResultRendererElement;
+}
+export interface GeosceneShadowCastCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneShadowCastElement;
+  currentTarget: HTMLGeosceneShadowCastElement;
+}
+export interface GeosceneSketchCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneSketchElement;
+  currentTarget: HTMLGeosceneSketchElement;
+}
+export interface GeosceneSliceCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneSliceElement;
+  currentTarget: HTMLGeosceneSliceElement;
+}
+export interface GeosceneSliderCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneSliderElement;
+  currentTarget: HTMLGeosceneSliderElement;
+}
+export interface GeosceneSwipeCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneSwipeElement;
+  currentTarget: HTMLGeosceneSwipeElement;
+}
+export interface GeosceneTableListCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneTableListElement;
+  currentTarget: HTMLGeosceneTableListElement;
+}
+export interface GeosceneTimeSliderCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneTimeSliderElement;
+  currentTarget: HTMLGeosceneTimeSliderElement;
+}
+export interface GeosceneTimeZoneLabelCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneTimeZoneLabelElement;
+  currentTarget: HTMLGeosceneTimeZoneLabelElement;
+}
+export interface GeosceneTrackCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneTrackElement;
+  currentTarget: HTMLGeosceneTrackElement;
+}
+export interface GeosceneUtilityNetworkAssociationsCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneUtilityNetworkAssociationsElement;
+  currentTarget: HTMLGeosceneUtilityNetworkAssociationsElement;
+}
+export interface GeosceneUtilityNetworkTraceCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneUtilityNetworkTraceElement;
+  currentTarget: HTMLGeosceneUtilityNetworkTraceElement;
+}
+export interface GeosceneUtilityNetworkValidateTopologyCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneUtilityNetworkValidateTopologyElement;
+  currentTarget: HTMLGeosceneUtilityNetworkValidateTopologyElement;
+}
+export interface GeosceneValuePickerCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneValuePickerElement;
+  currentTarget: HTMLGeosceneValuePickerElement;
+}
+export interface GeosceneVersionManagementCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneVersionManagementElement;
+  currentTarget: HTMLGeosceneVersionManagementElement;
+}
+export interface GeosceneVideoCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneVideoElement;
+  currentTarget: HTMLGeosceneVideoElement;
+}
+export interface GeosceneVideoPlayerCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneVideoPlayerElement;
+  currentTarget: HTMLGeosceneVideoPlayerElement;
+}
+export interface GeosceneWeatherCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneWeatherElement;
+  currentTarget: HTMLGeosceneWeatherElement;
+}
+export interface GeosceneZoomCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: HTMLGeosceneZoomElement;
+  currentTarget: HTMLGeosceneZoomElement;
+}
+
+export { ToEvents, TargetedEvent } from "@arcgis/lumina";
+
+declare global {
+  interface HTMLElementTagNameMap {
+    "geoscene-area-measurement-2d": HTMLGeosceneAreaMeasurement2dElement;
+    "geoscene-area-measurement-3d": HTMLGeosceneAreaMeasurement3dElement;
+    "geoscene-attachments": HTMLGeosceneAttachmentsElement;
+    "geoscene-basemap-gallery": HTMLGeosceneBasemapGalleryElement;
+    "geoscene-basemap-layer-list": HTMLGeosceneBasemapLayerListElement;
+    "geoscene-basemap-toggle": HTMLGeosceneBasemapToggleElement;
+    "geoscene-bookmarks": HTMLGeosceneBookmarksElement;
+    "geoscene-building-explorer": HTMLGeosceneBuildingExplorerElement;
+    "geoscene-catalog-layer-list": HTMLGeosceneCatalogLayerListElement;
+    "geoscene-compass": HTMLGeosceneCompassElement;
+    "geoscene-coordinate-conversion": HTMLGeosceneCoordinateConversionElement;
+    "geoscene-daylight": HTMLGeosceneDaylightElement;
+    "geoscene-directional-pad": HTMLGeosceneDirectionalPadElement;
+    "geoscene-directions": HTMLGeosceneDirectionsElement;
+    "geoscene-direct-line-measurement-3d": HTMLGeosceneDirectLineMeasurement3dElement;
+    "geoscene-directline-measurement-3d": HTMLGeosceneDirectlineMeasurement3dElement;
+    "geoscene-distance-measurement-2d": HTMLGeosceneDistanceMeasurement2dElement;
+    "geoscene-editor": HTMLGeosceneEditorElement;
+    "geoscene-elevation-profile": HTMLGeosceneElevationProfileElement;
+    "geoscene-expand": HTMLGeosceneExpandElement;
+    "geoscene-feature": HTMLGeosceneFeatureElement;
+    "geoscene-feature-form": HTMLGeosceneFeatureFormElement;
+    "geoscene-feature-table": HTMLGeosceneFeatureTableElement;
+    "geoscene-feature-templates": HTMLGeosceneFeatureTemplatesElement;
+    "geoscene-features": HTMLGeosceneFeaturesElement;
+    "geoscene-floor-filter": HTMLGeosceneFloorFilterElement;
+    "geoscene-fullscreen": HTMLGeosceneFullscreenElement;
+    "geoscene-grid-controls": HTMLGeosceneGridControlsElement;
+    "geoscene-histogram-range-slider": HTMLGeosceneHistogramRangeSliderElement;
+    "geoscene-home": HTMLGeosceneHomeElement;
+    "geoscene-layer-list": HTMLGeosceneLayerListElement;
+    "geoscene-legend": HTMLGeosceneLegendElement;
+    "geoscene-line-of-sight": HTMLGeosceneLineOfSightElement;
+    "geoscene-link-chart": HTMLGeosceneLinkChartElement;
+    "geoscene-link-chart-layout-switcher": HTMLGeosceneLinkChartLayoutSwitcherElement;
+    "geoscene-locate": HTMLGeosceneLocateElement;
+    "geoscene-map": HTMLGeosceneMapElement;
+    "geoscene-measurement": HTMLGeosceneMeasurementElement;
+    "geoscene-navigation-toggle": HTMLGeosceneNavigationToggleElement;
+    "geoscene-oriented-imagery-viewer": HTMLGeosceneOrientedImageryViewerElement;
+    "geoscene-placement": HTMLGeoscenePlacementElement;
+    "geoscene-print": HTMLGeoscenePrintElement;
+    "geoscene-scale-bar": HTMLGeosceneScaleBarElement;
+    "geoscene-scale-range-slider": HTMLGeosceneScaleRangeSliderElement;
+    "geoscene-scene": HTMLGeosceneSceneElement;
+    "geoscene-search": HTMLGeosceneSearchElement;
+    "geoscene-search-result-renderer": HTMLGeosceneSearchResultRendererElement;
+    "geoscene-shadow-cast": HTMLGeosceneShadowCastElement;
+    "geoscene-sketch": HTMLGeosceneSketchElement;
+    "geoscene-slice": HTMLGeosceneSliceElement;
+    "geoscene-slider": HTMLGeosceneSliderElement;
+    "geoscene-swipe": HTMLGeosceneSwipeElement;
+    "geoscene-table-list": HTMLGeosceneTableListElement;
+    "geoscene-time-slider": HTMLGeosceneTimeSliderElement;
+    "geoscene-time-zone-label": HTMLGeosceneTimeZoneLabelElement;
+    "geoscene-track": HTMLGeosceneTrackElement;
+    "geoscene-utility-network-associations": HTMLGeosceneUtilityNetworkAssociationsElement;
+    "geoscene-utility-network-trace": HTMLGeosceneUtilityNetworkTraceElement;
+    "geoscene-utility-network-validate-topology": HTMLGeosceneUtilityNetworkValidateTopologyElement;
+    "geoscene-value-picker": HTMLGeosceneValuePickerElement;
+    "geoscene-version-management": HTMLGeosceneVersionManagementElement;
+    "geoscene-video": HTMLGeosceneVideoElement;
+    "geoscene-video-player": HTMLGeosceneVideoPlayerElement;
+    "geoscene-weather": HTMLGeosceneWeatherElement;
+    "geoscene-zoom": HTMLGeosceneZoomElement;
+  }
+
+  interface HTMLGeosceneAreaMeasurement2dElementEventMap {
+    "geoscenePropertyChange": GeosceneAreaMeasurement2d["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneAreaMeasurement2d["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneAreaMeasurement2dElement extends GeosceneAreaMeasurement2d {
+    addEventListener<K extends keyof HTMLGeosceneAreaMeasurement2dElementEventMap>(type: K, listener: (this: HTMLGeosceneAreaMeasurement2dElement, ev: GeosceneAreaMeasurement2dCustomEvent<HTMLGeosceneAreaMeasurement2dElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneAreaMeasurement2dElementEventMap>(type: K, listener: (this: HTMLGeosceneAreaMeasurement2dElement, ev: GeosceneAreaMeasurement2dCustomEvent<HTMLGeosceneAreaMeasurement2dElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneAreaMeasurement3dElementEventMap {
+    "geoscenePropertyChange": GeosceneAreaMeasurement3d["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneAreaMeasurement3d["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneAreaMeasurement3dElement extends GeosceneAreaMeasurement3d {
+    addEventListener<K extends keyof HTMLGeosceneAreaMeasurement3dElementEventMap>(type: K, listener: (this: HTMLGeosceneAreaMeasurement3dElement, ev: GeosceneAreaMeasurement3dCustomEvent<HTMLGeosceneAreaMeasurement3dElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneAreaMeasurement3dElementEventMap>(type: K, listener: (this: HTMLGeosceneAreaMeasurement3dElement, ev: GeosceneAreaMeasurement3dCustomEvent<HTMLGeosceneAreaMeasurement3dElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneAttachmentsElementEventMap {
+    "geoscenePropertyChange": GeosceneAttachments["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneAttachments["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneAttachmentsElement extends GeosceneAttachments {
+    addEventListener<K extends keyof HTMLGeosceneAttachmentsElementEventMap>(type: K, listener: (this: HTMLGeosceneAttachmentsElement, ev: GeosceneAttachmentsCustomEvent<HTMLGeosceneAttachmentsElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneAttachmentsElementEventMap>(type: K, listener: (this: HTMLGeosceneAttachmentsElement, ev: GeosceneAttachmentsCustomEvent<HTMLGeosceneAttachmentsElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneBasemapGalleryElementEventMap {
+    "geoscenePropertyChange": GeosceneBasemapGallery["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneBasemapGallery["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneBasemapGalleryElement extends GeosceneBasemapGallery {
+    addEventListener<K extends keyof HTMLGeosceneBasemapGalleryElementEventMap>(type: K, listener: (this: HTMLGeosceneBasemapGalleryElement, ev: GeosceneBasemapGalleryCustomEvent<HTMLGeosceneBasemapGalleryElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneBasemapGalleryElementEventMap>(type: K, listener: (this: HTMLGeosceneBasemapGalleryElement, ev: GeosceneBasemapGalleryCustomEvent<HTMLGeosceneBasemapGalleryElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneBasemapLayerListElementEventMap {
+    "geosceneClose": GeosceneBasemapLayerList["geosceneClose"]["detail"];
+    "geoscenePropertyChange": GeosceneBasemapLayerList["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneBasemapLayerList["geosceneReady"]["detail"];
+    "geosceneTriggerAction": GeosceneBasemapLayerList["geosceneTriggerAction"]["detail"];
+  }
+
+  interface HTMLGeosceneBasemapLayerListElement extends GeosceneBasemapLayerList {
+    addEventListener<K extends keyof HTMLGeosceneBasemapLayerListElementEventMap>(type: K, listener: (this: HTMLGeosceneBasemapLayerListElement, ev: GeosceneBasemapLayerListCustomEvent<HTMLGeosceneBasemapLayerListElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneBasemapLayerListElementEventMap>(type: K, listener: (this: HTMLGeosceneBasemapLayerListElement, ev: GeosceneBasemapLayerListCustomEvent<HTMLGeosceneBasemapLayerListElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneBasemapToggleElementEventMap {
+    "geoscenePropertyChange": GeosceneBasemapToggle["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneBasemapToggle["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneBasemapToggleElement extends GeosceneBasemapToggle {
+    addEventListener<K extends keyof HTMLGeosceneBasemapToggleElementEventMap>(type: K, listener: (this: HTMLGeosceneBasemapToggleElement, ev: GeosceneBasemapToggleCustomEvent<HTMLGeosceneBasemapToggleElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneBasemapToggleElementEventMap>(type: K, listener: (this: HTMLGeosceneBasemapToggleElement, ev: GeosceneBasemapToggleCustomEvent<HTMLGeosceneBasemapToggleElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneBookmarksElementEventMap {
+    "geosceneClose": GeosceneBookmarks["geosceneClose"]["detail"];
+    "geosceneEdit": GeosceneBookmarks["geosceneEdit"]["detail"];
+    "geoscenePropertyChange": GeosceneBookmarks["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneBookmarks["geosceneReady"]["detail"];
+    "geosceneSelect": GeosceneBookmarks["geosceneSelect"]["detail"];
+  }
+
+  interface HTMLGeosceneBookmarksElement extends GeosceneBookmarks {
+    addEventListener<K extends keyof HTMLGeosceneBookmarksElementEventMap>(type: K, listener: (this: HTMLGeosceneBookmarksElement, ev: GeosceneBookmarksCustomEvent<HTMLGeosceneBookmarksElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneBookmarksElementEventMap>(type: K, listener: (this: HTMLGeosceneBookmarksElement, ev: GeosceneBookmarksCustomEvent<HTMLGeosceneBookmarksElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneBuildingExplorerElementEventMap {
+    "geoscenePropertyChange": GeosceneBuildingExplorer["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneBuildingExplorer["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneBuildingExplorerElement extends GeosceneBuildingExplorer {
+    addEventListener<K extends keyof HTMLGeosceneBuildingExplorerElementEventMap>(type: K, listener: (this: HTMLGeosceneBuildingExplorerElement, ev: GeosceneBuildingExplorerCustomEvent<HTMLGeosceneBuildingExplorerElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneBuildingExplorerElementEventMap>(type: K, listener: (this: HTMLGeosceneBuildingExplorerElement, ev: GeosceneBuildingExplorerCustomEvent<HTMLGeosceneBuildingExplorerElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneCatalogLayerListElementEventMap {
+    "geosceneClose": GeosceneCatalogLayerList["geosceneClose"]["detail"];
+    "geoscenePropertyChange": GeosceneCatalogLayerList["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneCatalogLayerList["geosceneReady"]["detail"];
+    "geosceneTriggerAction": GeosceneCatalogLayerList["geosceneTriggerAction"]["detail"];
+  }
+
+  interface HTMLGeosceneCatalogLayerListElement extends GeosceneCatalogLayerList {
+    addEventListener<K extends keyof HTMLGeosceneCatalogLayerListElementEventMap>(type: K, listener: (this: HTMLGeosceneCatalogLayerListElement, ev: GeosceneCatalogLayerListCustomEvent<HTMLGeosceneCatalogLayerListElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneCatalogLayerListElementEventMap>(type: K, listener: (this: HTMLGeosceneCatalogLayerListElement, ev: GeosceneCatalogLayerListCustomEvent<HTMLGeosceneCatalogLayerListElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneCompassElementEventMap {
+    "geoscenePropertyChange": GeosceneCompass["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneCompass["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneCompassElement extends GeosceneCompass {
+    addEventListener<K extends keyof HTMLGeosceneCompassElementEventMap>(type: K, listener: (this: HTMLGeosceneCompassElement, ev: GeosceneCompassCustomEvent<HTMLGeosceneCompassElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneCompassElementEventMap>(type: K, listener: (this: HTMLGeosceneCompassElement, ev: GeosceneCompassCustomEvent<HTMLGeosceneCompassElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneCoordinateConversionElementEventMap {
+    "geoscenePropertyChange": GeosceneCoordinateConversion["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneCoordinateConversion["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneCoordinateConversionElement extends GeosceneCoordinateConversion {
+    addEventListener<K extends keyof HTMLGeosceneCoordinateConversionElementEventMap>(type: K, listener: (this: HTMLGeosceneCoordinateConversionElement, ev: GeosceneCoordinateConversionCustomEvent<HTMLGeosceneCoordinateConversionElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneCoordinateConversionElementEventMap>(type: K, listener: (this: HTMLGeosceneCoordinateConversionElement, ev: GeosceneCoordinateConversionCustomEvent<HTMLGeosceneCoordinateConversionElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneDaylightElementEventMap {
+    "geosceneReady": GeosceneDaylight["geosceneReady"]["detail"];
+    "geosceneUserDateTimeChange": GeosceneDaylight["geosceneUserDateTimeChange"]["detail"];
+  }
+
+  interface HTMLGeosceneDaylightElement extends GeosceneDaylight {
+    addEventListener<K extends keyof HTMLGeosceneDaylightElementEventMap>(type: K, listener: (this: HTMLGeosceneDaylightElement, ev: GeosceneDaylightCustomEvent<HTMLGeosceneDaylightElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneDaylightElementEventMap>(type: K, listener: (this: HTMLGeosceneDaylightElement, ev: GeosceneDaylightCustomEvent<HTMLGeosceneDaylightElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneDirectionalPadElementEventMap {
+    "geoscenePropertyChange": GeosceneDirectionalPad["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneDirectionalPad["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneDirectionalPadElement extends GeosceneDirectionalPad {
+    addEventListener<K extends keyof HTMLGeosceneDirectionalPadElementEventMap>(type: K, listener: (this: HTMLGeosceneDirectionalPadElement, ev: GeosceneDirectionalPadCustomEvent<HTMLGeosceneDirectionalPadElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneDirectionalPadElementEventMap>(type: K, listener: (this: HTMLGeosceneDirectionalPadElement, ev: GeosceneDirectionalPadCustomEvent<HTMLGeosceneDirectionalPadElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneDirectionsElementEventMap {
+    "geoscenePropertyChange": GeosceneDirections["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneDirections["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneDirectionsElement extends GeosceneDirections {
+    addEventListener<K extends keyof HTMLGeosceneDirectionsElementEventMap>(type: K, listener: (this: HTMLGeosceneDirectionsElement, ev: GeosceneDirectionsCustomEvent<HTMLGeosceneDirectionsElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneDirectionsElementEventMap>(type: K, listener: (this: HTMLGeosceneDirectionsElement, ev: GeosceneDirectionsCustomEvent<HTMLGeosceneDirectionsElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneDirectLineMeasurement3dElementEventMap {
+    "geoscenePropertyChange": GeosceneDirectLineMeasurement3d["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneDirectLineMeasurement3d["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneDirectLineMeasurement3dElement extends GeosceneDirectLineMeasurement3d {
+    addEventListener<K extends keyof HTMLGeosceneDirectLineMeasurement3dElementEventMap>(type: K, listener: (this: HTMLGeosceneDirectLineMeasurement3dElement, ev: GeosceneDirectLineMeasurement3dCustomEvent<HTMLGeosceneDirectLineMeasurement3dElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneDirectLineMeasurement3dElementEventMap>(type: K, listener: (this: HTMLGeosceneDirectLineMeasurement3dElement, ev: GeosceneDirectLineMeasurement3dCustomEvent<HTMLGeosceneDirectLineMeasurement3dElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneDirectlineMeasurement3dElementEventMap {
+    "geoscenePropertyChange": DeprecatedGeosceneDirectLineMeasurement3d["geoscenePropertyChange"]["detail"];
+    "geosceneReady": DeprecatedGeosceneDirectLineMeasurement3d["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneDirectlineMeasurement3dElement extends DeprecatedGeosceneDirectLineMeasurement3d {
+    addEventListener<K extends keyof HTMLGeosceneDirectlineMeasurement3dElementEventMap>(type: K, listener: (this: HTMLGeosceneDirectlineMeasurement3dElement, ev: GeosceneDirectlineMeasurement3dCustomEvent<HTMLGeosceneDirectlineMeasurement3dElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneDirectlineMeasurement3dElementEventMap>(type: K, listener: (this: HTMLGeosceneDirectlineMeasurement3dElement, ev: GeosceneDirectlineMeasurement3dCustomEvent<HTMLGeosceneDirectlineMeasurement3dElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneDistanceMeasurement2dElementEventMap {
+    "geoscenePropertyChange": GeosceneDistanceMeasurement2d["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneDistanceMeasurement2d["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneDistanceMeasurement2dElement extends GeosceneDistanceMeasurement2d {
+    addEventListener<K extends keyof HTMLGeosceneDistanceMeasurement2dElementEventMap>(type: K, listener: (this: HTMLGeosceneDistanceMeasurement2dElement, ev: GeosceneDistanceMeasurement2dCustomEvent<HTMLGeosceneDistanceMeasurement2dElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneDistanceMeasurement2dElementEventMap>(type: K, listener: (this: HTMLGeosceneDistanceMeasurement2dElement, ev: GeosceneDistanceMeasurement2dCustomEvent<HTMLGeosceneDistanceMeasurement2dElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneEditorElementEventMap {
+    "geoscenePropertyChange": GeosceneEditor["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneEditor["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneEditorElement extends GeosceneEditor {
+    addEventListener<K extends keyof HTMLGeosceneEditorElementEventMap>(type: K, listener: (this: HTMLGeosceneEditorElement, ev: GeosceneEditorCustomEvent<HTMLGeosceneEditorElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneEditorElementEventMap>(type: K, listener: (this: HTMLGeosceneEditorElement, ev: GeosceneEditorCustomEvent<HTMLGeosceneEditorElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneElevationProfileElementEventMap {
+    "geoscenePropertyChange": GeosceneElevationProfile["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneElevationProfile["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneElevationProfileElement extends GeosceneElevationProfile {
+    addEventListener<K extends keyof HTMLGeosceneElevationProfileElementEventMap>(type: K, listener: (this: HTMLGeosceneElevationProfileElement, ev: GeosceneElevationProfileCustomEvent<HTMLGeosceneElevationProfileElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneElevationProfileElementEventMap>(type: K, listener: (this: HTMLGeosceneElevationProfileElement, ev: GeosceneElevationProfileCustomEvent<HTMLGeosceneElevationProfileElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneExpandElementEventMap {
+    "geosceneReady": GeosceneExpand["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneExpandElement extends GeosceneExpand {
+    addEventListener<K extends keyof HTMLGeosceneExpandElementEventMap>(type: K, listener: (this: HTMLGeosceneExpandElement, ev: GeosceneExpandCustomEvent<HTMLGeosceneExpandElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneExpandElementEventMap>(type: K, listener: (this: HTMLGeosceneExpandElement, ev: GeosceneExpandCustomEvent<HTMLGeosceneExpandElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneFeatureElementEventMap {
+    "geoscenePropertyChange": GeosceneFeature["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneFeature["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneFeatureElement extends GeosceneFeature {
+    addEventListener<K extends keyof HTMLGeosceneFeatureElementEventMap>(type: K, listener: (this: HTMLGeosceneFeatureElement, ev: GeosceneFeatureCustomEvent<HTMLGeosceneFeatureElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneFeatureElementEventMap>(type: K, listener: (this: HTMLGeosceneFeatureElement, ev: GeosceneFeatureCustomEvent<HTMLGeosceneFeatureElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneFeatureFormElementEventMap {
+    "geoscenePropertyChange": GeosceneFeatureForm["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneFeatureForm["geosceneReady"]["detail"];
+    "geosceneSubmit": GeosceneFeatureForm["geosceneSubmit"]["detail"];
+    "geosceneValueChange": GeosceneFeatureForm["geosceneValueChange"]["detail"];
+  }
+
+  interface HTMLGeosceneFeatureFormElement extends GeosceneFeatureForm {
+    addEventListener<K extends keyof HTMLGeosceneFeatureFormElementEventMap>(type: K, listener: (this: HTMLGeosceneFeatureFormElement, ev: GeosceneFeatureFormCustomEvent<HTMLGeosceneFeatureFormElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneFeatureFormElementEventMap>(type: K, listener: (this: HTMLGeosceneFeatureFormElement, ev: GeosceneFeatureFormCustomEvent<HTMLGeosceneFeatureFormElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneFeatureTableElementEventMap {
+    "geosceneCellClick": GeosceneFeatureTable["geosceneCellClick"]["detail"];
+    "geosceneCellKeydown": GeosceneFeatureTable["geosceneCellKeydown"]["detail"];
+    "geosceneCellPointerout": GeosceneFeatureTable["geosceneCellPointerout"]["detail"];
+    "geosceneCellPointerover": GeosceneFeatureTable["geosceneCellPointerover"]["detail"];
+    "geosceneColumnReorder": GeosceneFeatureTable["geosceneColumnReorder"]["detail"];
+    "geoscenePropertyChange": GeosceneFeatureTable["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneFeatureTable["geosceneReady"]["detail"];
+    "geosceneSelectionChange": GeosceneFeatureTable["geosceneSelectionChange"]["detail"];
+  }
+
+  interface HTMLGeosceneFeatureTableElement extends GeosceneFeatureTable {
+    addEventListener<K extends keyof HTMLGeosceneFeatureTableElementEventMap>(type: K, listener: (this: HTMLGeosceneFeatureTableElement, ev: GeosceneFeatureTableCustomEvent<HTMLGeosceneFeatureTableElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneFeatureTableElementEventMap>(type: K, listener: (this: HTMLGeosceneFeatureTableElement, ev: GeosceneFeatureTableCustomEvent<HTMLGeosceneFeatureTableElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneFeatureTemplatesElementEventMap {
+    "geoscenePropertyChange": GeosceneFeatureTemplates["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneFeatureTemplates["geosceneReady"]["detail"];
+    "geosceneSelect": GeosceneFeatureTemplates["geosceneSelect"]["detail"];
+  }
+
+  interface HTMLGeosceneFeatureTemplatesElement extends GeosceneFeatureTemplates {
+    addEventListener<K extends keyof HTMLGeosceneFeatureTemplatesElementEventMap>(type: K, listener: (this: HTMLGeosceneFeatureTemplatesElement, ev: GeosceneFeatureTemplatesCustomEvent<HTMLGeosceneFeatureTemplatesElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneFeatureTemplatesElementEventMap>(type: K, listener: (this: HTMLGeosceneFeatureTemplatesElement, ev: GeosceneFeatureTemplatesCustomEvent<HTMLGeosceneFeatureTemplatesElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneFeaturesElementEventMap {
+    "geosceneClose": GeosceneFeatures["geosceneClose"]["detail"];
+    "geoscenePropertyChange": GeosceneFeatures["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneFeatures["geosceneReady"]["detail"];
+    "geosceneTriggerAction": GeosceneFeatures["geosceneTriggerAction"]["detail"];
+  }
+
+  interface HTMLGeosceneFeaturesElement extends GeosceneFeatures {
+    addEventListener<K extends keyof HTMLGeosceneFeaturesElementEventMap>(type: K, listener: (this: HTMLGeosceneFeaturesElement, ev: GeosceneFeaturesCustomEvent<HTMLGeosceneFeaturesElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneFeaturesElementEventMap>(type: K, listener: (this: HTMLGeosceneFeaturesElement, ev: GeosceneFeaturesCustomEvent<HTMLGeosceneFeaturesElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneFloorFilterElementEventMap {
+    "geosceneReady": GeosceneFloorFilter["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneFloorFilterElement extends GeosceneFloorFilter {
+    addEventListener<K extends keyof HTMLGeosceneFloorFilterElementEventMap>(type: K, listener: (this: HTMLGeosceneFloorFilterElement, ev: GeosceneFloorFilterCustomEvent<HTMLGeosceneFloorFilterElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneFloorFilterElementEventMap>(type: K, listener: (this: HTMLGeosceneFloorFilterElement, ev: GeosceneFloorFilterCustomEvent<HTMLGeosceneFloorFilterElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneFullscreenElementEventMap {
+    "geoscenePropertyChange": GeosceneFullscreen["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneFullscreen["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneFullscreenElement extends GeosceneFullscreen {
+    addEventListener<K extends keyof HTMLGeosceneFullscreenElementEventMap>(type: K, listener: (this: HTMLGeosceneFullscreenElement, ev: GeosceneFullscreenCustomEvent<HTMLGeosceneFullscreenElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneFullscreenElementEventMap>(type: K, listener: (this: HTMLGeosceneFullscreenElement, ev: GeosceneFullscreenCustomEvent<HTMLGeosceneFullscreenElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneGridControlsElementEventMap {
+    "geoscenePropertyChange": GeosceneGridControls["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneGridControls["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneGridControlsElement extends GeosceneGridControls {
+    addEventListener<K extends keyof HTMLGeosceneGridControlsElementEventMap>(type: K, listener: (this: HTMLGeosceneGridControlsElement, ev: GeosceneGridControlsCustomEvent<HTMLGeosceneGridControlsElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneGridControlsElementEventMap>(type: K, listener: (this: HTMLGeosceneGridControlsElement, ev: GeosceneGridControlsCustomEvent<HTMLGeosceneGridControlsElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneHistogramRangeSliderElementEventMap {
+    "geoscenePropertyChange": GeosceneHistogramRangeSlider["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneHistogramRangeSlider["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneHistogramRangeSliderElement extends GeosceneHistogramRangeSlider {
+    addEventListener<K extends keyof HTMLGeosceneHistogramRangeSliderElementEventMap>(type: K, listener: (this: HTMLGeosceneHistogramRangeSliderElement, ev: GeosceneHistogramRangeSliderCustomEvent<HTMLGeosceneHistogramRangeSliderElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneHistogramRangeSliderElementEventMap>(type: K, listener: (this: HTMLGeosceneHistogramRangeSliderElement, ev: GeosceneHistogramRangeSliderCustomEvent<HTMLGeosceneHistogramRangeSliderElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneHomeElementEventMap {
+    "geosceneGo": GeosceneHome["geosceneGo"]["detail"];
+    "geoscenePropertyChange": GeosceneHome["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneHome["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneHomeElement extends GeosceneHome {
+    addEventListener<K extends keyof HTMLGeosceneHomeElementEventMap>(type: K, listener: (this: HTMLGeosceneHomeElement, ev: GeosceneHomeCustomEvent<HTMLGeosceneHomeElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneHomeElementEventMap>(type: K, listener: (this: HTMLGeosceneHomeElement, ev: GeosceneHomeCustomEvent<HTMLGeosceneHomeElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneLayerListElementEventMap {
+    "geosceneClose": GeosceneLayerList["geosceneClose"]["detail"];
+    "geoscenePropertyChange": GeosceneLayerList["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneLayerList["geosceneReady"]["detail"];
+    "geosceneTriggerAction": GeosceneLayerList["geosceneTriggerAction"]["detail"];
+  }
+
+  interface HTMLGeosceneLayerListElement extends GeosceneLayerList {
+    addEventListener<K extends keyof HTMLGeosceneLayerListElementEventMap>(type: K, listener: (this: HTMLGeosceneLayerListElement, ev: GeosceneLayerListCustomEvent<HTMLGeosceneLayerListElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneLayerListElementEventMap>(type: K, listener: (this: HTMLGeosceneLayerListElement, ev: GeosceneLayerListCustomEvent<HTMLGeosceneLayerListElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneLegendElementEventMap {
+    "geoscenePropertyChange": GeosceneLegend["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneLegend["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneLegendElement extends GeosceneLegend {
+    addEventListener<K extends keyof HTMLGeosceneLegendElementEventMap>(type: K, listener: (this: HTMLGeosceneLegendElement, ev: GeosceneLegendCustomEvent<HTMLGeosceneLegendElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneLegendElementEventMap>(type: K, listener: (this: HTMLGeosceneLegendElement, ev: GeosceneLegendCustomEvent<HTMLGeosceneLegendElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneLineOfSightElementEventMap {
+    "geoscenePropertyChange": GeosceneLineOfSight["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneLineOfSight["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneLineOfSightElement extends GeosceneLineOfSight {
+    addEventListener<K extends keyof HTMLGeosceneLineOfSightElementEventMap>(type: K, listener: (this: HTMLGeosceneLineOfSightElement, ev: GeosceneLineOfSightCustomEvent<HTMLGeosceneLineOfSightElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneLineOfSightElementEventMap>(type: K, listener: (this: HTMLGeosceneLineOfSightElement, ev: GeosceneLineOfSightCustomEvent<HTMLGeosceneLineOfSightElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneLinkChartElementEventMap {
+    "geosceneViewChange": GeosceneLinkChart["geosceneViewChange"]["detail"];
+    "geosceneViewClick": GeosceneLinkChart["geosceneViewClick"]["detail"];
+    "geosceneViewDoubleClick": GeosceneLinkChart["geosceneViewDoubleClick"]["detail"];
+    "geosceneViewDrag": GeosceneLinkChart["geosceneViewDrag"]["detail"];
+    "geosceneViewHold": GeosceneLinkChart["geosceneViewHold"]["detail"];
+    "geosceneViewImmediateClick": GeosceneLinkChart["geosceneViewImmediateClick"]["detail"];
+    "geosceneViewImmediateDoubleClick": GeosceneLinkChart["geosceneViewImmediateDoubleClick"]["detail"];
+    "geosceneViewKeyDown": GeosceneLinkChart["geosceneViewKeyDown"]["detail"];
+    "geosceneViewKeyUp": GeosceneLinkChart["geosceneViewKeyUp"]["detail"];
+    "geosceneViewLayerviewCreate": GeosceneLinkChart["geosceneViewLayerviewCreate"]["detail"];
+    "geosceneViewLayerviewCreateError": GeosceneLinkChart["geosceneViewLayerviewCreateError"]["detail"];
+    "geosceneViewLayerviewDestroy": GeosceneLinkChart["geosceneViewLayerviewDestroy"]["detail"];
+    "geosceneViewMouseWheel": GeosceneLinkChart["geosceneViewMouseWheel"]["detail"];
+    "geosceneViewPointerDown": GeosceneLinkChart["geosceneViewPointerDown"]["detail"];
+    "geosceneViewPointerEnter": GeosceneLinkChart["geosceneViewPointerEnter"]["detail"];
+    "geosceneViewPointerLeave": GeosceneLinkChart["geosceneViewPointerLeave"]["detail"];
+    "geosceneViewPointerMove": GeosceneLinkChart["geosceneViewPointerMove"]["detail"];
+    "geosceneViewPointerUp": GeosceneLinkChart["geosceneViewPointerUp"]["detail"];
+    "geosceneViewReadyChange": GeosceneLinkChart["geosceneViewReadyChange"]["detail"];
+  }
+
+  interface HTMLGeosceneLinkChartElement extends GeosceneLinkChart {
+    addEventListener<K extends keyof HTMLGeosceneLinkChartElementEventMap>(type: K, listener: (this: HTMLGeosceneLinkChartElement, ev: GeosceneLinkChartCustomEvent<HTMLGeosceneLinkChartElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneLinkChartElementEventMap>(type: K, listener: (this: HTMLGeosceneLinkChartElement, ev: GeosceneLinkChartCustomEvent<HTMLGeosceneLinkChartElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneLinkChartLayoutSwitcherElementEventMap {
+    "geoscenePropertyChange": GeosceneLinkChartLayoutSwitcher["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneLinkChartLayoutSwitcher["geosceneReady"]["detail"];
+    "geosceneSwitchLayout": GeosceneLinkChartLayoutSwitcher["geosceneSwitchLayout"]["detail"];
+  }
+
+  interface HTMLGeosceneLinkChartLayoutSwitcherElement extends GeosceneLinkChartLayoutSwitcher {
+    addEventListener<K extends keyof HTMLGeosceneLinkChartLayoutSwitcherElementEventMap>(type: K, listener: (this: HTMLGeosceneLinkChartLayoutSwitcherElement, ev: GeosceneLinkChartLayoutSwitcherCustomEvent<HTMLGeosceneLinkChartLayoutSwitcherElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneLinkChartLayoutSwitcherElementEventMap>(type: K, listener: (this: HTMLGeosceneLinkChartLayoutSwitcherElement, ev: GeosceneLinkChartLayoutSwitcherCustomEvent<HTMLGeosceneLinkChartLayoutSwitcherElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneLocateElementEventMap {
+    "geosceneError": GeosceneLocate["geosceneError"]["detail"];
+    "geoscenePropertyChange": GeosceneLocate["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneLocate["geosceneReady"]["detail"];
+    "geosceneSuccess": GeosceneLocate["geosceneSuccess"]["detail"];
+  }
+
+  interface HTMLGeosceneLocateElement extends GeosceneLocate {
+    addEventListener<K extends keyof HTMLGeosceneLocateElementEventMap>(type: K, listener: (this: HTMLGeosceneLocateElement, ev: GeosceneLocateCustomEvent<HTMLGeosceneLocateElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneLocateElementEventMap>(type: K, listener: (this: HTMLGeosceneLocateElement, ev: GeosceneLocateCustomEvent<HTMLGeosceneLocateElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneMapElementEventMap {
+    "geosceneViewChange": GeosceneMap["geosceneViewChange"]["detail"];
+    "geosceneViewClick": GeosceneMap["geosceneViewClick"]["detail"];
+    "geosceneViewDoubleClick": GeosceneMap["geosceneViewDoubleClick"]["detail"];
+    "geosceneViewDrag": GeosceneMap["geosceneViewDrag"]["detail"];
+    "geosceneViewHold": GeosceneMap["geosceneViewHold"]["detail"];
+    "geosceneViewImmediateClick": GeosceneMap["geosceneViewImmediateClick"]["detail"];
+    "geosceneViewImmediateDoubleClick": GeosceneMap["geosceneViewImmediateDoubleClick"]["detail"];
+    "geosceneViewKeyDown": GeosceneMap["geosceneViewKeyDown"]["detail"];
+    "geosceneViewKeyUp": GeosceneMap["geosceneViewKeyUp"]["detail"];
+    "geosceneViewLayerviewCreate": GeosceneMap["geosceneViewLayerviewCreate"]["detail"];
+    "geosceneViewLayerviewCreateError": GeosceneMap["geosceneViewLayerviewCreateError"]["detail"];
+    "geosceneViewLayerviewDestroy": GeosceneMap["geosceneViewLayerviewDestroy"]["detail"];
+    "geosceneViewMouseWheel": GeosceneMap["geosceneViewMouseWheel"]["detail"];
+    "geosceneViewPointerDown": GeosceneMap["geosceneViewPointerDown"]["detail"];
+    "geosceneViewPointerEnter": GeosceneMap["geosceneViewPointerEnter"]["detail"];
+    "geosceneViewPointerLeave": GeosceneMap["geosceneViewPointerLeave"]["detail"];
+    "geosceneViewPointerMove": GeosceneMap["geosceneViewPointerMove"]["detail"];
+    "geosceneViewPointerUp": GeosceneMap["geosceneViewPointerUp"]["detail"];
+    "geosceneViewReadyChange": GeosceneMap["geosceneViewReadyChange"]["detail"];
+  }
+
+  interface HTMLGeosceneMapElement extends GeosceneMap {
+    addEventListener<K extends keyof HTMLGeosceneMapElementEventMap>(type: K, listener: (this: HTMLGeosceneMapElement, ev: GeosceneMapCustomEvent<HTMLGeosceneMapElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneMapElementEventMap>(type: K, listener: (this: HTMLGeosceneMapElement, ev: GeosceneMapCustomEvent<HTMLGeosceneMapElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneMeasurementElementEventMap {
+    "geoscenePropertyChange": GeosceneMeasurement["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneMeasurement["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneMeasurementElement extends GeosceneMeasurement {
+    addEventListener<K extends keyof HTMLGeosceneMeasurementElementEventMap>(type: K, listener: (this: HTMLGeosceneMeasurementElement, ev: GeosceneMeasurementCustomEvent<HTMLGeosceneMeasurementElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneMeasurementElementEventMap>(type: K, listener: (this: HTMLGeosceneMeasurementElement, ev: GeosceneMeasurementCustomEvent<HTMLGeosceneMeasurementElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneNavigationToggleElementEventMap {
+    "geoscenePropertyChange": GeosceneNavigationToggle["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneNavigationToggle["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneNavigationToggleElement extends GeosceneNavigationToggle {
+    addEventListener<K extends keyof HTMLGeosceneNavigationToggleElementEventMap>(type: K, listener: (this: HTMLGeosceneNavigationToggleElement, ev: GeosceneNavigationToggleCustomEvent<HTMLGeosceneNavigationToggleElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneNavigationToggleElementEventMap>(type: K, listener: (this: HTMLGeosceneNavigationToggleElement, ev: GeosceneNavigationToggleCustomEvent<HTMLGeosceneNavigationToggleElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneOrientedImageryViewerElementEventMap {
+    "geoscenePropertyChange": GeosceneOrientedImageryViewer["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneOrientedImageryViewer["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneOrientedImageryViewerElement extends GeosceneOrientedImageryViewer {
+    addEventListener<K extends keyof HTMLGeosceneOrientedImageryViewerElementEventMap>(type: K, listener: (this: HTMLGeosceneOrientedImageryViewerElement, ev: GeosceneOrientedImageryViewerCustomEvent<HTMLGeosceneOrientedImageryViewerElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneOrientedImageryViewerElementEventMap>(type: K, listener: (this: HTMLGeosceneOrientedImageryViewerElement, ev: GeosceneOrientedImageryViewerCustomEvent<HTMLGeosceneOrientedImageryViewerElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeoscenePlacementElementEventMap {
+    "geosceneReady": GeoscenePlacement["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeoscenePlacementElement extends GeoscenePlacement {
+    addEventListener<K extends keyof HTMLGeoscenePlacementElementEventMap>(type: K, listener: (this: HTMLGeoscenePlacementElement, ev: GeoscenePlacementCustomEvent<HTMLGeoscenePlacementElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeoscenePlacementElementEventMap>(type: K, listener: (this: HTMLGeoscenePlacementElement, ev: GeoscenePlacementCustomEvent<HTMLGeoscenePlacementElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeoscenePrintElementEventMap {
+    "geosceneComplete": GeoscenePrint["geosceneComplete"]["detail"];
+    "geoscenePropertyChange": GeoscenePrint["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeoscenePrint["geosceneReady"]["detail"];
+    "geosceneSubmit": GeoscenePrint["geosceneSubmit"]["detail"];
+  }
+
+  interface HTMLGeoscenePrintElement extends GeoscenePrint {
+    addEventListener<K extends keyof HTMLGeoscenePrintElementEventMap>(type: K, listener: (this: HTMLGeoscenePrintElement, ev: GeoscenePrintCustomEvent<HTMLGeoscenePrintElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeoscenePrintElementEventMap>(type: K, listener: (this: HTMLGeoscenePrintElement, ev: GeoscenePrintCustomEvent<HTMLGeoscenePrintElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneScaleBarElementEventMap {
+    "geosceneReady": GeosceneScaleBar["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneScaleBarElement extends GeosceneScaleBar {
+    addEventListener<K extends keyof HTMLGeosceneScaleBarElementEventMap>(type: K, listener: (this: HTMLGeosceneScaleBarElement, ev: GeosceneScaleBarCustomEvent<HTMLGeosceneScaleBarElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneScaleBarElementEventMap>(type: K, listener: (this: HTMLGeosceneScaleBarElement, ev: GeosceneScaleBarCustomEvent<HTMLGeosceneScaleBarElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneScaleRangeSliderElementEventMap {
+    "geoscenePropertyChange": GeosceneScaleRangeSlider["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneScaleRangeSlider["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneScaleRangeSliderElement extends GeosceneScaleRangeSlider {
+    addEventListener<K extends keyof HTMLGeosceneScaleRangeSliderElementEventMap>(type: K, listener: (this: HTMLGeosceneScaleRangeSliderElement, ev: GeosceneScaleRangeSliderCustomEvent<HTMLGeosceneScaleRangeSliderElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneScaleRangeSliderElementEventMap>(type: K, listener: (this: HTMLGeosceneScaleRangeSliderElement, ev: GeosceneScaleRangeSliderCustomEvent<HTMLGeosceneScaleRangeSliderElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneSceneElementEventMap {
+    "geosceneViewAnalysisViewCreate": GeosceneScene["geosceneViewAnalysisViewCreate"]["detail"];
+    "geosceneViewAnalysisViewCreateError": GeosceneScene["geosceneViewAnalysisViewCreateError"]["detail"];
+    "geosceneViewAnalysisViewDestroy": GeosceneScene["geosceneViewAnalysisViewDestroy"]["detail"];
+    "geosceneViewChange": GeosceneScene["geosceneViewChange"]["detail"];
+    "geosceneViewClick": GeosceneScene["geosceneViewClick"]["detail"];
+    "geosceneViewDoubleClick": GeosceneScene["geosceneViewDoubleClick"]["detail"];
+    "geosceneViewDrag": GeosceneScene["geosceneViewDrag"]["detail"];
+    "geosceneViewHold": GeosceneScene["geosceneViewHold"]["detail"];
+    "geosceneViewImmediateClick": GeosceneScene["geosceneViewImmediateClick"]["detail"];
+    "geosceneViewImmediateDoubleClick": GeosceneScene["geosceneViewImmediateDoubleClick"]["detail"];
+    "geosceneViewKeyDown": GeosceneScene["geosceneViewKeyDown"]["detail"];
+    "geosceneViewKeyUp": GeosceneScene["geosceneViewKeyUp"]["detail"];
+    "geosceneViewLayerviewCreate": GeosceneScene["geosceneViewLayerviewCreate"]["detail"];
+    "geosceneViewLayerviewCreateError": GeosceneScene["geosceneViewLayerviewCreateError"]["detail"];
+    "geosceneViewLayerviewDestroy": GeosceneScene["geosceneViewLayerviewDestroy"]["detail"];
+    "geosceneViewMouseWheel": GeosceneScene["geosceneViewMouseWheel"]["detail"];
+    "geosceneViewPointerDown": GeosceneScene["geosceneViewPointerDown"]["detail"];
+    "geosceneViewPointerEnter": GeosceneScene["geosceneViewPointerEnter"]["detail"];
+    "geosceneViewPointerLeave": GeosceneScene["geosceneViewPointerLeave"]["detail"];
+    "geosceneViewPointerMove": GeosceneScene["geosceneViewPointerMove"]["detail"];
+    "geosceneViewPointerUp": GeosceneScene["geosceneViewPointerUp"]["detail"];
+    "geosceneViewReadyChange": GeosceneScene["geosceneViewReadyChange"]["detail"];
+  }
+
+  interface HTMLGeosceneSceneElement extends GeosceneScene {
+    addEventListener<K extends keyof HTMLGeosceneSceneElementEventMap>(type: K, listener: (this: HTMLGeosceneSceneElement, ev: GeosceneSceneCustomEvent<HTMLGeosceneSceneElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneSceneElementEventMap>(type: K, listener: (this: HTMLGeosceneSceneElement, ev: GeosceneSceneCustomEvent<HTMLGeosceneSceneElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneSearchElementEventMap {
+    "geoscenePropertyChange": GeosceneSearch["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneSearch["geosceneReady"]["detail"];
+    "geosceneSearchClear": GeosceneSearch["geosceneSearchClear"]["detail"];
+    "geosceneSearchComplete": GeosceneSearch["geosceneSearchComplete"]["detail"];
+    "geosceneSearchStart": GeosceneSearch["geosceneSearchStart"]["detail"];
+    "geosceneSelectResult": GeosceneSearch["geosceneSelectResult"]["detail"];
+    "geosceneSuggestComplete": GeosceneSearch["geosceneSuggestComplete"]["detail"];
+    "geosceneSuggestStart": GeosceneSearch["geosceneSuggestStart"]["detail"];
+  }
+
+  interface HTMLGeosceneSearchElement extends GeosceneSearch {
+    addEventListener<K extends keyof HTMLGeosceneSearchElementEventMap>(type: K, listener: (this: HTMLGeosceneSearchElement, ev: GeosceneSearchCustomEvent<HTMLGeosceneSearchElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneSearchElementEventMap>(type: K, listener: (this: HTMLGeosceneSearchElement, ev: GeosceneSearchCustomEvent<HTMLGeosceneSearchElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneSearchResultRendererElementEventMap {
+    "geosceneReady": GeosceneSearchResultRenderer["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneSearchResultRendererElement extends GeosceneSearchResultRenderer {
+    addEventListener<K extends keyof HTMLGeosceneSearchResultRendererElementEventMap>(type: K, listener: (this: HTMLGeosceneSearchResultRendererElement, ev: GeosceneSearchResultRendererCustomEvent<HTMLGeosceneSearchResultRendererElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneSearchResultRendererElementEventMap>(type: K, listener: (this: HTMLGeosceneSearchResultRendererElement, ev: GeosceneSearchResultRendererCustomEvent<HTMLGeosceneSearchResultRendererElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneShadowCastElementEventMap {
+    "geoscenePropertyChange": GeosceneShadowCast["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneShadowCast["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneShadowCastElement extends GeosceneShadowCast {
+    addEventListener<K extends keyof HTMLGeosceneShadowCastElementEventMap>(type: K, listener: (this: HTMLGeosceneShadowCastElement, ev: GeosceneShadowCastCustomEvent<HTMLGeosceneShadowCastElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneShadowCastElementEventMap>(type: K, listener: (this: HTMLGeosceneShadowCastElement, ev: GeosceneShadowCastCustomEvent<HTMLGeosceneShadowCastElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneSketchElementEventMap {
+    "geosceneCreate": GeosceneSketch["geosceneCreate"]["detail"];
+    "geosceneDelete": GeosceneSketch["geosceneDelete"]["detail"];
+    "geoscenePropertyChange": GeosceneSketch["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneSketch["geosceneReady"]["detail"];
+    "geosceneRedo": GeosceneSketch["geosceneRedo"]["detail"];
+    "geosceneUndo": GeosceneSketch["geosceneUndo"]["detail"];
+    "geosceneUpdate": GeosceneSketch["geosceneUpdate"]["detail"];
+  }
+
+  interface HTMLGeosceneSketchElement extends GeosceneSketch {
+    addEventListener<K extends keyof HTMLGeosceneSketchElementEventMap>(type: K, listener: (this: HTMLGeosceneSketchElement, ev: GeosceneSketchCustomEvent<HTMLGeosceneSketchElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneSketchElementEventMap>(type: K, listener: (this: HTMLGeosceneSketchElement, ev: GeosceneSketchCustomEvent<HTMLGeosceneSketchElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneSliceElementEventMap {
+    "geoscenePropertyChange": GeosceneSlice["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneSlice["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneSliceElement extends GeosceneSlice {
+    addEventListener<K extends keyof HTMLGeosceneSliceElementEventMap>(type: K, listener: (this: HTMLGeosceneSliceElement, ev: GeosceneSliceCustomEvent<HTMLGeosceneSliceElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneSliceElementEventMap>(type: K, listener: (this: HTMLGeosceneSliceElement, ev: GeosceneSliceCustomEvent<HTMLGeosceneSliceElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneSliderElementEventMap {
+    "geosceneMaxChange": GeosceneSlider["geosceneMaxChange"]["detail"];
+    "geosceneMaxClick": GeosceneSlider["geosceneMaxClick"]["detail"];
+    "geosceneMinChange": GeosceneSlider["geosceneMinChange"]["detail"];
+    "geosceneMinClick": GeosceneSlider["geosceneMinClick"]["detail"];
+    "geoscenePropertyChange": GeosceneSlider["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneSlider["geosceneReady"]["detail"];
+    "geosceneSegmentClick": GeosceneSlider["geosceneSegmentClick"]["detail"];
+    "geosceneSegmentDrag": GeosceneSlider["geosceneSegmentDrag"]["detail"];
+    "geosceneThumbChange": GeosceneSlider["geosceneThumbChange"]["detail"];
+    "geosceneThumbClick": GeosceneSlider["geosceneThumbClick"]["detail"];
+    "geosceneThumbDrag": GeosceneSlider["geosceneThumbDrag"]["detail"];
+    "geosceneTickClick": GeosceneSlider["geosceneTickClick"]["detail"];
+    "geosceneTrackClick": GeosceneSlider["geosceneTrackClick"]["detail"];
+  }
+
+  interface HTMLGeosceneSliderElement extends GeosceneSlider {
+    addEventListener<K extends keyof HTMLGeosceneSliderElementEventMap>(type: K, listener: (this: HTMLGeosceneSliderElement, ev: GeosceneSliderCustomEvent<HTMLGeosceneSliderElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneSliderElementEventMap>(type: K, listener: (this: HTMLGeosceneSliderElement, ev: GeosceneSliderCustomEvent<HTMLGeosceneSliderElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneSwipeElementEventMap {
+    "geoscenePropertyChange": GeosceneSwipe["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneSwipe["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneSwipeElement extends GeosceneSwipe {
+    addEventListener<K extends keyof HTMLGeosceneSwipeElementEventMap>(type: K, listener: (this: HTMLGeosceneSwipeElement, ev: GeosceneSwipeCustomEvent<HTMLGeosceneSwipeElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneSwipeElementEventMap>(type: K, listener: (this: HTMLGeosceneSwipeElement, ev: GeosceneSwipeCustomEvent<HTMLGeosceneSwipeElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneTableListElementEventMap {
+    "geosceneClose": GeosceneTableList["geosceneClose"]["detail"];
+    "geoscenePropertyChange": GeosceneTableList["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneTableList["geosceneReady"]["detail"];
+    "geosceneTriggerAction": GeosceneTableList["geosceneTriggerAction"]["detail"];
+  }
+
+  interface HTMLGeosceneTableListElement extends GeosceneTableList {
+    addEventListener<K extends keyof HTMLGeosceneTableListElementEventMap>(type: K, listener: (this: HTMLGeosceneTableListElement, ev: GeosceneTableListCustomEvent<HTMLGeosceneTableListElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneTableListElementEventMap>(type: K, listener: (this: HTMLGeosceneTableListElement, ev: GeosceneTableListCustomEvent<HTMLGeosceneTableListElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneTimeSliderElementEventMap {
+    "geoscenePropertyChange": GeosceneTimeSlider["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneTimeSlider["geosceneReady"]["detail"];
+    "geosceneTriggerAction": GeosceneTimeSlider["geosceneTriggerAction"]["detail"];
+  }
+
+  interface HTMLGeosceneTimeSliderElement extends GeosceneTimeSlider {
+    addEventListener<K extends keyof HTMLGeosceneTimeSliderElementEventMap>(type: K, listener: (this: HTMLGeosceneTimeSliderElement, ev: GeosceneTimeSliderCustomEvent<HTMLGeosceneTimeSliderElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneTimeSliderElementEventMap>(type: K, listener: (this: HTMLGeosceneTimeSliderElement, ev: GeosceneTimeSliderCustomEvent<HTMLGeosceneTimeSliderElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneTimeZoneLabelElementEventMap {
+    "geoscenePropertyChange": GeosceneTimeZoneLabel["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneTimeZoneLabel["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneTimeZoneLabelElement extends GeosceneTimeZoneLabel {
+    addEventListener<K extends keyof HTMLGeosceneTimeZoneLabelElementEventMap>(type: K, listener: (this: HTMLGeosceneTimeZoneLabelElement, ev: GeosceneTimeZoneLabelCustomEvent<HTMLGeosceneTimeZoneLabelElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneTimeZoneLabelElementEventMap>(type: K, listener: (this: HTMLGeosceneTimeZoneLabelElement, ev: GeosceneTimeZoneLabelCustomEvent<HTMLGeosceneTimeZoneLabelElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneTrackElementEventMap {
+    "geosceneComplete": GeosceneTrack["geosceneComplete"]["detail"];
+    "geosceneError": GeosceneTrack["geosceneError"]["detail"];
+    "geoscenePropertyChange": GeosceneTrack["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneTrack["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneTrackElement extends GeosceneTrack {
+    addEventListener<K extends keyof HTMLGeosceneTrackElementEventMap>(type: K, listener: (this: HTMLGeosceneTrackElement, ev: GeosceneTrackCustomEvent<HTMLGeosceneTrackElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneTrackElementEventMap>(type: K, listener: (this: HTMLGeosceneTrackElement, ev: GeosceneTrackCustomEvent<HTMLGeosceneTrackElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneUtilityNetworkAssociationsElementEventMap {
+    "geosceneReady": GeosceneUtilityNetworkAssociations["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneUtilityNetworkAssociationsElement extends GeosceneUtilityNetworkAssociations {
+    addEventListener<K extends keyof HTMLGeosceneUtilityNetworkAssociationsElementEventMap>(type: K, listener: (this: HTMLGeosceneUtilityNetworkAssociationsElement, ev: GeosceneUtilityNetworkAssociationsCustomEvent<HTMLGeosceneUtilityNetworkAssociationsElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneUtilityNetworkAssociationsElementEventMap>(type: K, listener: (this: HTMLGeosceneUtilityNetworkAssociationsElement, ev: GeosceneUtilityNetworkAssociationsCustomEvent<HTMLGeosceneUtilityNetworkAssociationsElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneUtilityNetworkTraceElementEventMap {
+    "geosceneAddFlag": GeosceneUtilityNetworkTrace["geosceneAddFlag"]["detail"];
+    "geosceneAddFlagComplete": GeosceneUtilityNetworkTrace["geosceneAddFlagComplete"]["detail"];
+    "geosceneAddFlagError": GeosceneUtilityNetworkTrace["geosceneAddFlagError"]["detail"];
+    "geosceneAddResultArea": GeosceneUtilityNetworkTrace["geosceneAddResultArea"]["detail"];
+    "geoscenePropertyChange": GeosceneUtilityNetworkTrace["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneUtilityNetworkTrace["geosceneReady"]["detail"];
+    "geosceneRemoveResultArea": GeosceneUtilityNetworkTrace["geosceneRemoveResultArea"]["detail"];
+  }
+
+  interface HTMLGeosceneUtilityNetworkTraceElement extends GeosceneUtilityNetworkTrace {
+    addEventListener<K extends keyof HTMLGeosceneUtilityNetworkTraceElementEventMap>(type: K, listener: (this: HTMLGeosceneUtilityNetworkTraceElement, ev: GeosceneUtilityNetworkTraceCustomEvent<HTMLGeosceneUtilityNetworkTraceElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneUtilityNetworkTraceElementEventMap>(type: K, listener: (this: HTMLGeosceneUtilityNetworkTraceElement, ev: GeosceneUtilityNetworkTraceCustomEvent<HTMLGeosceneUtilityNetworkTraceElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneUtilityNetworkValidateTopologyElementEventMap {
+    "geoscenePropertyChange": GeosceneUtilityNetworkValidateTopology["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneUtilityNetworkValidateTopology["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneUtilityNetworkValidateTopologyElement extends GeosceneUtilityNetworkValidateTopology {
+    addEventListener<K extends keyof HTMLGeosceneUtilityNetworkValidateTopologyElementEventMap>(type: K, listener: (this: HTMLGeosceneUtilityNetworkValidateTopologyElement, ev: GeosceneUtilityNetworkValidateTopologyCustomEvent<HTMLGeosceneUtilityNetworkValidateTopologyElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneUtilityNetworkValidateTopologyElementEventMap>(type: K, listener: (this: HTMLGeosceneUtilityNetworkValidateTopologyElement, ev: GeosceneUtilityNetworkValidateTopologyCustomEvent<HTMLGeosceneUtilityNetworkValidateTopologyElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneValuePickerElementEventMap {
+    "geosceneAnimate": GeosceneValuePicker["geosceneAnimate"]["detail"];
+    "geosceneNext": GeosceneValuePicker["geosceneNext"]["detail"];
+    "geoscenePause": GeosceneValuePicker["geoscenePause"]["detail"];
+    "geoscenePlay": GeosceneValuePicker["geoscenePlay"]["detail"];
+    "geoscenePrevious": GeosceneValuePicker["geoscenePrevious"]["detail"];
+    "geoscenePropertyChange": GeosceneValuePicker["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneValuePicker["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneValuePickerElement extends GeosceneValuePicker {
+    addEventListener<K extends keyof HTMLGeosceneValuePickerElementEventMap>(type: K, listener: (this: HTMLGeosceneValuePickerElement, ev: GeosceneValuePickerCustomEvent<HTMLGeosceneValuePickerElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneValuePickerElementEventMap>(type: K, listener: (this: HTMLGeosceneValuePickerElement, ev: GeosceneValuePickerCustomEvent<HTMLGeosceneValuePickerElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneVersionManagementElementEventMap {
+    "geosceneReady": GeosceneVersionManagement["geosceneReady"]["detail"];
+    "geosceneVersioningStateChanged": GeosceneVersionManagement["geosceneVersioningStateChanged"]["detail"];
+  }
+
+  interface HTMLGeosceneVersionManagementElement extends GeosceneVersionManagement {
+    addEventListener<K extends keyof HTMLGeosceneVersionManagementElementEventMap>(type: K, listener: (this: HTMLGeosceneVersionManagementElement, ev: GeosceneVersionManagementCustomEvent<HTMLGeosceneVersionManagementElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneVersionManagementElementEventMap>(type: K, listener: (this: HTMLGeosceneVersionManagementElement, ev: GeosceneVersionManagementCustomEvent<HTMLGeosceneVersionManagementElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneVideoElementEventMap {
+    "geosceneViewReadyChange": GeosceneVideo["geosceneViewReadyChange"]["detail"];
+  }
+
+  interface HTMLGeosceneVideoElement extends GeosceneVideo {
+    addEventListener<K extends keyof HTMLGeosceneVideoElementEventMap>(type: K, listener: (this: HTMLGeosceneVideoElement, ev: GeosceneVideoCustomEvent<HTMLGeosceneVideoElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneVideoElementEventMap>(type: K, listener: (this: HTMLGeosceneVideoElement, ev: GeosceneVideoCustomEvent<HTMLGeosceneVideoElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneVideoPlayerElementEventMap {
+    "geoscenePropertyChange": GeosceneVideoPlayer["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneVideoPlayer["geosceneReady"]["detail"];
+    "geosceneVideoReady": GeosceneVideoPlayer["geosceneVideoReady"]["detail"];
+  }
+
+  interface HTMLGeosceneVideoPlayerElement extends GeosceneVideoPlayer {
+    addEventListener<K extends keyof HTMLGeosceneVideoPlayerElementEventMap>(type: K, listener: (this: HTMLGeosceneVideoPlayerElement, ev: GeosceneVideoPlayerCustomEvent<HTMLGeosceneVideoPlayerElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneVideoPlayerElementEventMap>(type: K, listener: (this: HTMLGeosceneVideoPlayerElement, ev: GeosceneVideoPlayerCustomEvent<HTMLGeosceneVideoPlayerElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneWeatherElementEventMap {
+    "geoscenePropertyChange": GeosceneWeather["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneWeather["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneWeatherElement extends GeosceneWeather {
+    addEventListener<K extends keyof HTMLGeosceneWeatherElementEventMap>(type: K, listener: (this: HTMLGeosceneWeatherElement, ev: GeosceneWeatherCustomEvent<HTMLGeosceneWeatherElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneWeatherElementEventMap>(type: K, listener: (this: HTMLGeosceneWeatherElement, ev: GeosceneWeatherCustomEvent<HTMLGeosceneWeatherElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+  interface HTMLGeosceneZoomElementEventMap {
+    "geoscenePropertyChange": GeosceneZoom["geoscenePropertyChange"]["detail"];
+    "geosceneReady": GeosceneZoom["geosceneReady"]["detail"];
+  }
+
+  interface HTMLGeosceneZoomElement extends GeosceneZoom {
+    addEventListener<K extends keyof HTMLGeosceneZoomElementEventMap>(type: K, listener: (this: HTMLGeosceneZoomElement, ev: GeosceneZoomCustomEvent<HTMLGeosceneZoomElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLGeosceneZoomElementEventMap>(type: K, listener: (this: HTMLGeosceneZoomElement, ev: GeosceneZoomCustomEvent<HTMLGeosceneZoomElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+  }
+}