@geoscene/map-components 4.33.20 → 5.0.19

package/dist/index.d.ts

@@ -1,1431 +1,918 @@
-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
+ * Get a resolved path from where an asset can be loaded.
+ *
+ * @param suffix - The relative path for the asset.
  */
-export declare const settGeosceneAssetPath: (path: URL | string) => void;
+export function getAssetPath(suffix: string): string;
+
 /**
- * @deprecated Use `getAssetPath` instead
+ * Used to manually set the base path where package assets (like localization
+ * and icons) can be found.
+ *
+ * By default, the package assets are loaded from
+ * `https://js.geoscene.cn/<version>/<simplified-package-name>/`. We are hosting
+ * our assets on a CDN (Content Delivery Network) to ensure fast and reliable
+ * access. It is CORS-enabled, so you can load the assets from any domain. This
+ * is the recommended way to load the assets and avoid bundling them with your
+ * application.
+ *
+ * However, if you need to host the assets locally, you can copy them manually
+ * as part of your build process and use `setAssetPath` to customize where the
+ * browser will load the assets from.
+ *
+ * @param path - Relative or absolute path to the assets folder.
  */
-export declare const getGeosceneAssetPath: (suffix: string) => string;
+export function setAssetPath(path: URL | string): void;
+
+import type { GeosceneAreaMeasurement2d } from "./components/geoscene-area-measurement-2d/customElement.js";
+import type { GeosceneAreaMeasurement3d } from "./components/geoscene-area-measurement-3d/customElement.js";
+import type { GeosceneAttachments } from "./components/geoscene-attachments/customElement.js";
+import type { GeosceneBasemapGallery } from "./components/geoscene-basemap-gallery/customElement.js";
+import type { GeosceneBasemapLayerList } from "./components/geoscene-basemap-layer-list/customElement.js";
+import type { GeosceneBasemapToggle } from "./components/geoscene-basemap-toggle/customElement.js";
+import type { GeosceneBookmarks } from "./components/geoscene-bookmarks/customElement.js";
+import type { GeosceneBuildingExplorer } from "./components/geoscene-building-explorer/customElement.js";
+import type { GeosceneCatalogLayerList } from "./components/geoscene-catalog-layer-list/customElement.js";
+import type { GeosceneCompass } from "./components/geoscene-compass/customElement.js";
+import type { GeosceneCoordinateConversion } from "./components/geoscene-coordinate-conversion/customElement.js";
+import type { GeosceneDaylight } from "./components/geoscene-daylight/customElement.js";
+import type { GeosceneDirectionalPad } from "./components/geoscene-directional-pad/customElement.js";
+import type { GeosceneDirections } from "./components/geoscene-directions/customElement.js";
+import type { GeosceneDirectLineMeasurement3d } from "./components/geoscene-direct-line-measurement-3d/customElement.js";
+import type { GeosceneDistanceMeasurement2d } from "./components/geoscene-distance-measurement-2d/customElement.js";
+import type { GeosceneEditor } from "./components/geoscene-editor/customElement.js";
+import type { GeosceneElevationProfile } from "./components/geoscene-elevation-profile/customElement.js";
+import type { GeosceneExpand } from "./components/geoscene-expand/customElement.js";
+import type { GeosceneFeature } from "./components/geoscene-feature/customElement.js";
+import type { GeosceneFeatureForm } from "./components/geoscene-feature-form/customElement.js";
+import type { GeosceneFeatureTable } from "./components/geoscene-feature-table/customElement.js";
+import type { GeosceneFeatureTemplatesLegacy } from "./components/geoscene-feature-templates-legacy/customElement.js";
+import type { GeosceneFeatures } from "./components/geoscene-features/customElement.js";
+import type { GeosceneFloorFilter } from "./components/geoscene-floor-filter/customElement.js";
+import type { GeosceneFullscreen } from "./components/geoscene-fullscreen/customElement.js";
+import type { GeosceneGridControls } from "./components/geoscene-grid-controls/customElement.js";
+import type { GeosceneHistogramRangeSlider } from "./components/geoscene-histogram-range-slider/customElement.js";
+import type { GeosceneHome } from "./components/geoscene-home/customElement.js";
+import type { GeosceneLayerList } from "./components/geoscene-layer-list/customElement.js";
+import type { GeosceneLegend } from "./components/geoscene-legend/customElement.js";
+import type { GeosceneLineOfSight } from "./components/geoscene-line-of-sight/customElement.js";
+import type { GeosceneLinkChart } from "./components/geoscene-link-chart/customElement.js";
+import type { GeosceneLinkChartLayoutSwitcher } from "./components/geoscene-link-chart-layout-switcher/customElement.js";
+import type { GeosceneLinkChartNonspatialVisibilityToggle } from "./components/geoscene-link-chart-nonspatial-visibility-toggle/customElement.js";
+import type { GeosceneLocate } from "./components/geoscene-locate/customElement.js";
+import type { GeosceneMap } from "./components/geoscene-map/customElement.js";
+import type { GeosceneMeasurement } from "./components/geoscene-measurement/customElement.js";
+import type { GeosceneNavigationToggle } from "./components/geoscene-navigation-toggle/customElement.js";
+import type { GeosceneOrientedImageryViewer } from "./components/geoscene-oriented-imagery-viewer/customElement.js";
+import type { GeoscenePaste } from "./components/geoscene-paste/customElement.js";
+import type { GeosceneClipboard } from "./components/geoscene-clipboard/customElement.js";
+import type { GeosceneFeatureImage } from "./components/geoscene-feature-image/customElement.js";
+import type { GeosceneFeatureTitle } from "./components/geoscene-feature-title/customElement.js";
+import type { GeosceneMultiFeatureForm } from "./components/geoscene-multi-feature-form/customElement.js";
+import type { GeoscenePopup } from "./components/geoscene-popup/customElement.js";
+import type { GeoscenePresentation } from "./components/geoscene-presentation/customElement.js";
+import type { GeoscenePrint } from "./components/geoscene-print/customElement.js";
+import type { GeosceneReverseGeocodeList } from "./components/geoscene-reverse-geocode-list/customElement.js";
+import type { GeosceneScaleBar } from "./components/geoscene-scale-bar/customElement.js";
+import type { GeosceneScaleRangeSlider } from "./components/geoscene-scale-range-slider/customElement.js";
+import type { GeosceneScene } from "./components/geoscene-scene/customElement.js";
+import type { GeosceneSearch } from "./components/geoscene-search/customElement.js";
+import type { GeosceneSearchResultRenderer } from "./components/geoscene-search-result-renderer/customElement.js";
+import type { GeosceneShadowCast } from "./components/geoscene-shadow-cast/customElement.js";
+import type { GeosceneSketch } from "./components/geoscene-sketch/customElement.js";
+import type { GeosceneSlice } from "./components/geoscene-slice/customElement.js";
+import type { GeosceneSliderBinaryColorSizeLegacy } from "./components/geoscene-slider-binary-color-size-legacy/customElement.js";
+import type { GeosceneSliderClassedColorLegacy } from "./components/geoscene-slider-classed-color-legacy/customElement.js";
+import type { GeosceneSliderClassedSizeLegacy } from "./components/geoscene-slider-classed-size-legacy/customElement.js";
+import type { GeosceneSliderColorLegacy } from "./components/geoscene-slider-color-legacy/customElement.js";
+import type { GeosceneSliderColorSizeLegacy } from "./components/geoscene-slider-color-size-legacy/customElement.js";
+import type { GeosceneSliderHeatmapLegacy } from "./components/geoscene-slider-heatmap-legacy/customElement.js";
+import type { GeosceneSliderOpacityLegacy } from "./components/geoscene-slider-opacity-legacy/customElement.js";
+import type { GeosceneSliderSizeLegacy } from "./components/geoscene-slider-size-legacy/customElement.js";
+import type { GeosceneSnappingControls } from "./components/geoscene-snapping-controls/customElement.js";
+import type { GeosceneColorSelect } from "./components/geoscene-color-select/customElement.js";
+import type { GeosceneTimeOfDaySlider } from "./components/geoscene-time-of-day-slider/customElement.js";
+import type { GeosceneWebGlError } from "./components/geoscene-webgl-error/customElement.js";
+import type { GeosceneSwipe } from "./components/geoscene-swipe/customElement.js";
+import type { GeosceneTableList } from "./components/geoscene-table-list/customElement.js";
+import type { GeosceneTimeSlider } from "./components/geoscene-time-slider/customElement.js";
+import type { GeosceneTimeZoneLabel } from "./components/geoscene-time-zone-label/customElement.js";
+import type { GeosceneTrack } from "./components/geoscene-track/customElement.js";
+import type { GeosceneUtilityNetworkAssociations } from "./components/geoscene-utility-network-associations/customElement.js";
+import type { GeosceneUtilityNetworkTrace } from "./components/geoscene-utility-network-trace/customElement.js";
+import type { GeosceneUtilityNetworkTraceAnalysis } from "./components/geoscene-utility-network-trace-analysis/customElement.js";
+import type { GeosceneUtilityNetworkAggregatedGeometry } from "./components/geoscene-utility-network-aggregated-geometry/customElement.js";
+import type { GeosceneUtilityNetworkSubnetworkInfo } from "./components/geoscene-utility-network-subnetwork-info/customElement.js";
+import type { GeosceneUtilityNetworkTraceInputs } from "./components/geoscene-utility-network-trace-inputs/customElement.js";
+import type { GeosceneUtilityNetworkTraceLocation } from "./components/geoscene-utility-network-trace-location/customElement.js";
+import type { GeosceneUtilityNetworkTraceLocationList } from "./components/geoscene-utility-network-trace-location-list/customElement.js";
+import type { GeosceneUtilityNetworkTraceResults } from "./components/geoscene-utility-network-trace-results/customElement.js";
+import type { GeosceneUtilityNetworkValidateTopology } from "./components/geoscene-utility-network-validate-topology/customElement.js";
+import type { GeosceneValuePickerLegacy } from "./components/geoscene-value-picker-legacy/customElement.js";
+import type { GeosceneVersionManagement } from "./components/geoscene-version-management/customElement.js";
+import type { GeosceneVideo } from "./components/geoscene-video/customElement.js";
+import type { GeosceneVideoPlayer } from "./components/geoscene-video-player/customElement.js";
+import type { GeosceneVolumeMeasurement } from "./components/geoscene-volume-measurement/customElement.js";
+import type { GeosceneWeather } from "./components/geoscene-weather/customElement.js";
+import type { GeosceneZoom } from "./components/geoscene-zoom/customElement.js";
 
+export { ToEvents, TargetedEvent } from "@geoscene/lumina";
 
 export interface GeosceneAreaMeasurement2dCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneAreaMeasurement2dElement;
-  currentTarget: HTMLGeosceneAreaMeasurement2dElement;
+  target: GeosceneAreaMeasurement2d;
+  currentTarget: GeosceneAreaMeasurement2d;
 }
 export interface GeosceneAreaMeasurement3dCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneAreaMeasurement3dElement;
-  currentTarget: HTMLGeosceneAreaMeasurement3dElement;
+  target: GeosceneAreaMeasurement3d;
+  currentTarget: GeosceneAreaMeasurement3d;
 }
 export interface GeosceneAttachmentsCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneAttachmentsElement;
-  currentTarget: HTMLGeosceneAttachmentsElement;
+  target: GeosceneAttachments;
+  currentTarget: GeosceneAttachments;
 }
 export interface GeosceneBasemapGalleryCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneBasemapGalleryElement;
-  currentTarget: HTMLGeosceneBasemapGalleryElement;
+  target: GeosceneBasemapGallery;
+  currentTarget: GeosceneBasemapGallery;
 }
 export interface GeosceneBasemapLayerListCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneBasemapLayerListElement;
-  currentTarget: HTMLGeosceneBasemapLayerListElement;
+  target: GeosceneBasemapLayerList;
+  currentTarget: GeosceneBasemapLayerList;
 }
 export interface GeosceneBasemapToggleCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneBasemapToggleElement;
-  currentTarget: HTMLGeosceneBasemapToggleElement;
+  target: GeosceneBasemapToggle;
+  currentTarget: GeosceneBasemapToggle;
 }
 export interface GeosceneBookmarksCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneBookmarksElement;
-  currentTarget: HTMLGeosceneBookmarksElement;
+  target: GeosceneBookmarks;
+  currentTarget: GeosceneBookmarks;
 }
 export interface GeosceneBuildingExplorerCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneBuildingExplorerElement;
-  currentTarget: HTMLGeosceneBuildingExplorerElement;
+  target: GeosceneBuildingExplorer;
+  currentTarget: GeosceneBuildingExplorer;
 }
 export interface GeosceneCatalogLayerListCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneCatalogLayerListElement;
-  currentTarget: HTMLGeosceneCatalogLayerListElement;
+  target: GeosceneCatalogLayerList;
+  currentTarget: GeosceneCatalogLayerList;
 }
 export interface GeosceneCompassCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneCompassElement;
-  currentTarget: HTMLGeosceneCompassElement;
+  target: GeosceneCompass;
+  currentTarget: GeosceneCompass;
 }
 export interface GeosceneCoordinateConversionCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneCoordinateConversionElement;
-  currentTarget: HTMLGeosceneCoordinateConversionElement;
+  target: GeosceneCoordinateConversion;
+  currentTarget: GeosceneCoordinateConversion;
 }
 export interface GeosceneDaylightCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneDaylightElement;
-  currentTarget: HTMLGeosceneDaylightElement;
+  target: GeosceneDaylight;
+  currentTarget: GeosceneDaylight;
 }
 export interface GeosceneDirectionalPadCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneDirectionalPadElement;
-  currentTarget: HTMLGeosceneDirectionalPadElement;
+  target: GeosceneDirectionalPad;
+  currentTarget: GeosceneDirectionalPad;
 }
 export interface GeosceneDirectionsCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneDirectionsElement;
-  currentTarget: HTMLGeosceneDirectionsElement;
+  target: GeosceneDirections;
+  currentTarget: GeosceneDirections;
 }
 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;
+  target: GeosceneDirectLineMeasurement3d;
+  currentTarget: GeosceneDirectLineMeasurement3d;
 }
 export interface GeosceneDistanceMeasurement2dCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneDistanceMeasurement2dElement;
-  currentTarget: HTMLGeosceneDistanceMeasurement2dElement;
+  target: GeosceneDistanceMeasurement2d;
+  currentTarget: GeosceneDistanceMeasurement2d;
 }
 export interface GeosceneEditorCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneEditorElement;
-  currentTarget: HTMLGeosceneEditorElement;
+  target: GeosceneEditor;
+  currentTarget: GeosceneEditor;
 }
 export interface GeosceneElevationProfileCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneElevationProfileElement;
-  currentTarget: HTMLGeosceneElevationProfileElement;
+  target: GeosceneElevationProfile;
+  currentTarget: GeosceneElevationProfile;
 }
 export interface GeosceneExpandCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneExpandElement;
-  currentTarget: HTMLGeosceneExpandElement;
+  target: GeosceneExpand;
+  currentTarget: GeosceneExpand;
 }
 export interface GeosceneFeatureCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneFeatureElement;
-  currentTarget: HTMLGeosceneFeatureElement;
+  target: GeosceneFeature;
+  currentTarget: GeosceneFeature;
 }
 export interface GeosceneFeatureFormCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneFeatureFormElement;
-  currentTarget: HTMLGeosceneFeatureFormElement;
+  target: GeosceneFeatureForm;
+  currentTarget: GeosceneFeatureForm;
 }
 export interface GeosceneFeatureTableCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneFeatureTableElement;
-  currentTarget: HTMLGeosceneFeatureTableElement;
+  target: GeosceneFeatureTable;
+  currentTarget: GeosceneFeatureTable;
 }
-export interface GeosceneFeatureTemplatesCustomEvent<T> extends CustomEvent<T> {
+export interface GeosceneFeatureTemplatesLegacyCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneFeatureTemplatesElement;
-  currentTarget: HTMLGeosceneFeatureTemplatesElement;
+  target: GeosceneFeatureTemplatesLegacy;
+  currentTarget: GeosceneFeatureTemplatesLegacy;
 }
 export interface GeosceneFeaturesCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneFeaturesElement;
-  currentTarget: HTMLGeosceneFeaturesElement;
+  target: GeosceneFeatures;
+  currentTarget: GeosceneFeatures;
 }
 export interface GeosceneFloorFilterCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneFloorFilterElement;
-  currentTarget: HTMLGeosceneFloorFilterElement;
+  target: GeosceneFloorFilter;
+  currentTarget: GeosceneFloorFilter;
 }
 export interface GeosceneFullscreenCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneFullscreenElement;
-  currentTarget: HTMLGeosceneFullscreenElement;
+  target: GeosceneFullscreen;
+  currentTarget: GeosceneFullscreen;
 }
 export interface GeosceneGridControlsCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneGridControlsElement;
-  currentTarget: HTMLGeosceneGridControlsElement;
+  target: GeosceneGridControls;
+  currentTarget: GeosceneGridControls;
 }
 export interface GeosceneHistogramRangeSliderCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneHistogramRangeSliderElement;
-  currentTarget: HTMLGeosceneHistogramRangeSliderElement;
+  target: GeosceneHistogramRangeSlider;
+  currentTarget: GeosceneHistogramRangeSlider;
 }
 export interface GeosceneHomeCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneHomeElement;
-  currentTarget: HTMLGeosceneHomeElement;
+  target: GeosceneHome;
+  currentTarget: GeosceneHome;
 }
 export interface GeosceneLayerListCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneLayerListElement;
-  currentTarget: HTMLGeosceneLayerListElement;
+  target: GeosceneLayerList;
+  currentTarget: GeosceneLayerList;
 }
 export interface GeosceneLegendCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneLegendElement;
-  currentTarget: HTMLGeosceneLegendElement;
+  target: GeosceneLegend;
+  currentTarget: GeosceneLegend;
 }
 export interface GeosceneLineOfSightCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneLineOfSightElement;
-  currentTarget: HTMLGeosceneLineOfSightElement;
+  target: GeosceneLineOfSight;
+  currentTarget: GeosceneLineOfSight;
 }
 export interface GeosceneLinkChartCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneLinkChartElement;
-  currentTarget: HTMLGeosceneLinkChartElement;
+  target: GeosceneLinkChart;
+  currentTarget: GeosceneLinkChart;
 }
 export interface GeosceneLinkChartLayoutSwitcherCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneLinkChartLayoutSwitcherElement;
-  currentTarget: HTMLGeosceneLinkChartLayoutSwitcherElement;
+  target: GeosceneLinkChartLayoutSwitcher;
+  currentTarget: GeosceneLinkChartLayoutSwitcher;
+}
+export interface GeosceneLinkChartNonspatialVisibilityToggleCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: GeosceneLinkChartNonspatialVisibilityToggle;
+  currentTarget: GeosceneLinkChartNonspatialVisibilityToggle;
 }
 export interface GeosceneLocateCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneLocateElement;
-  currentTarget: HTMLGeosceneLocateElement;
+  target: GeosceneLocate;
+  currentTarget: GeosceneLocate;
 }
 export interface GeosceneMapCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneMapElement;
-  currentTarget: HTMLGeosceneMapElement;
+  target: GeosceneMap;
+  currentTarget: GeosceneMap;
 }
 export interface GeosceneMeasurementCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneMeasurementElement;
-  currentTarget: HTMLGeosceneMeasurementElement;
+  target: GeosceneMeasurement;
+  currentTarget: GeosceneMeasurement;
 }
 export interface GeosceneNavigationToggleCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneNavigationToggleElement;
-  currentTarget: HTMLGeosceneNavigationToggleElement;
+  target: GeosceneNavigationToggle;
+  currentTarget: GeosceneNavigationToggle;
 }
 export interface GeosceneOrientedImageryViewerCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneOrientedImageryViewerElement;
-  currentTarget: HTMLGeosceneOrientedImageryViewerElement;
+  target: GeosceneOrientedImageryViewer;
+  currentTarget: GeosceneOrientedImageryViewer;
 }
-export interface GeoscenePlacementCustomEvent<T> extends CustomEvent<T> {
+export interface GeoscenePasteCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeoscenePlacementElement;
-  currentTarget: HTMLGeoscenePlacementElement;
+  target: GeoscenePaste;
+  currentTarget: GeoscenePaste;
+}
+export interface GeosceneClipboardCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: GeosceneClipboard;
+  currentTarget: GeosceneClipboard;
+}
+export interface GeosceneMultiFeatureFormCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: GeosceneMultiFeatureForm;
+  currentTarget: GeosceneMultiFeatureForm;
+}
+export interface GeoscenePopupCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: GeoscenePopup;
+  currentTarget: GeoscenePopup;
+}
+export interface GeoscenePresentationCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: GeoscenePresentation;
+  currentTarget: GeoscenePresentation;
 }
 export interface GeoscenePrintCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeoscenePrintElement;
-  currentTarget: HTMLGeoscenePrintElement;
+  target: GeoscenePrint;
+  currentTarget: GeoscenePrint;
+}
+export interface GeosceneReverseGeocodeListCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: GeosceneReverseGeocodeList;
+  currentTarget: GeosceneReverseGeocodeList;
 }
 export interface GeosceneScaleBarCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneScaleBarElement;
-  currentTarget: HTMLGeosceneScaleBarElement;
+  target: GeosceneScaleBar;
+  currentTarget: GeosceneScaleBar;
 }
 export interface GeosceneScaleRangeSliderCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneScaleRangeSliderElement;
-  currentTarget: HTMLGeosceneScaleRangeSliderElement;
+  target: GeosceneScaleRangeSlider;
+  currentTarget: GeosceneScaleRangeSlider;
 }
 export interface GeosceneSceneCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneSceneElement;
-  currentTarget: HTMLGeosceneSceneElement;
+  target: GeosceneScene;
+  currentTarget: GeosceneScene;
 }
 export interface GeosceneSearchCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneSearchElement;
-  currentTarget: HTMLGeosceneSearchElement;
+  target: GeosceneSearch;
+  currentTarget: GeosceneSearch;
 }
 export interface GeosceneSearchResultRendererCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneSearchResultRendererElement;
-  currentTarget: HTMLGeosceneSearchResultRendererElement;
+  target: GeosceneSearchResultRenderer;
+  currentTarget: GeosceneSearchResultRenderer;
 }
 export interface GeosceneShadowCastCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneShadowCastElement;
-  currentTarget: HTMLGeosceneShadowCastElement;
+  target: GeosceneShadowCast;
+  currentTarget: GeosceneShadowCast;
 }
 export interface GeosceneSketchCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneSketchElement;
-  currentTarget: HTMLGeosceneSketchElement;
+  target: GeosceneSketch;
+  currentTarget: GeosceneSketch;
 }
 export interface GeosceneSliceCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneSliceElement;
-  currentTarget: HTMLGeosceneSliceElement;
+  target: GeosceneSlice;
+  currentTarget: GeosceneSlice;
+}
+export interface GeosceneSliderBinaryColorSizeLegacyCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: GeosceneSliderBinaryColorSizeLegacy;
+  currentTarget: GeosceneSliderBinaryColorSizeLegacy;
+}
+export interface GeosceneSliderClassedColorLegacyCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: GeosceneSliderClassedColorLegacy;
+  currentTarget: GeosceneSliderClassedColorLegacy;
+}
+export interface GeosceneSliderClassedSizeLegacyCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: GeosceneSliderClassedSizeLegacy;
+  currentTarget: GeosceneSliderClassedSizeLegacy;
 }
-export interface GeosceneSliderCustomEvent<T> extends CustomEvent<T> {
+export interface GeosceneSliderColorLegacyCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneSliderElement;
-  currentTarget: HTMLGeosceneSliderElement;
+  target: GeosceneSliderColorLegacy;
+  currentTarget: GeosceneSliderColorLegacy;
+}
+export interface GeosceneSliderColorSizeLegacyCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: GeosceneSliderColorSizeLegacy;
+  currentTarget: GeosceneSliderColorSizeLegacy;
+}
+export interface GeosceneSliderHeatmapLegacyCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: GeosceneSliderHeatmapLegacy;
+  currentTarget: GeosceneSliderHeatmapLegacy;
+}
+export interface GeosceneSliderOpacityLegacyCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: GeosceneSliderOpacityLegacy;
+  currentTarget: GeosceneSliderOpacityLegacy;
+}
+export interface GeosceneSliderSizeLegacyCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: GeosceneSliderSizeLegacy;
+  currentTarget: GeosceneSliderSizeLegacy;
+}
+export interface GeosceneSnappingControlsCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: GeosceneSnappingControls;
+  currentTarget: GeosceneSnappingControls;
+}
+export interface GeosceneColorSelectCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: GeosceneColorSelect;
+  currentTarget: GeosceneColorSelect;
+}
+export interface GeosceneTimeOfDaySliderCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: GeosceneTimeOfDaySlider;
+  currentTarget: GeosceneTimeOfDaySlider;
 }
 export interface GeosceneSwipeCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneSwipeElement;
-  currentTarget: HTMLGeosceneSwipeElement;
+  target: GeosceneSwipe;
+  currentTarget: GeosceneSwipe;
 }
 export interface GeosceneTableListCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneTableListElement;
-  currentTarget: HTMLGeosceneTableListElement;
+  target: GeosceneTableList;
+  currentTarget: GeosceneTableList;
 }
 export interface GeosceneTimeSliderCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneTimeSliderElement;
-  currentTarget: HTMLGeosceneTimeSliderElement;
+  target: GeosceneTimeSlider;
+  currentTarget: GeosceneTimeSlider;
 }
 export interface GeosceneTimeZoneLabelCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneTimeZoneLabelElement;
-  currentTarget: HTMLGeosceneTimeZoneLabelElement;
+  target: GeosceneTimeZoneLabel;
+  currentTarget: GeosceneTimeZoneLabel;
 }
 export interface GeosceneTrackCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneTrackElement;
-  currentTarget: HTMLGeosceneTrackElement;
+  target: GeosceneTrack;
+  currentTarget: GeosceneTrack;
 }
 export interface GeosceneUtilityNetworkAssociationsCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneUtilityNetworkAssociationsElement;
-  currentTarget: HTMLGeosceneUtilityNetworkAssociationsElement;
+  target: GeosceneUtilityNetworkAssociations;
+  currentTarget: GeosceneUtilityNetworkAssociations;
 }
 export interface GeosceneUtilityNetworkTraceCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneUtilityNetworkTraceElement;
-  currentTarget: HTMLGeosceneUtilityNetworkTraceElement;
+  target: GeosceneUtilityNetworkTrace;
+  currentTarget: GeosceneUtilityNetworkTrace;
+}
+export interface GeosceneUtilityNetworkTraceAnalysisCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: GeosceneUtilityNetworkTraceAnalysis;
+  currentTarget: GeosceneUtilityNetworkTraceAnalysis;
+}
+export interface GeosceneUtilityNetworkAggregatedGeometryCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: GeosceneUtilityNetworkAggregatedGeometry;
+  currentTarget: GeosceneUtilityNetworkAggregatedGeometry;
+}
+export interface GeosceneUtilityNetworkTraceInputsCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: GeosceneUtilityNetworkTraceInputs;
+  currentTarget: GeosceneUtilityNetworkTraceInputs;
+}
+export interface GeosceneUtilityNetworkTraceLocationCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: GeosceneUtilityNetworkTraceLocation;
+  currentTarget: GeosceneUtilityNetworkTraceLocation;
+}
+export interface GeosceneUtilityNetworkTraceResultsCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: GeosceneUtilityNetworkTraceResults;
+  currentTarget: GeosceneUtilityNetworkTraceResults;
 }
 export interface GeosceneUtilityNetworkValidateTopologyCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneUtilityNetworkValidateTopologyElement;
-  currentTarget: HTMLGeosceneUtilityNetworkValidateTopologyElement;
+  target: GeosceneUtilityNetworkValidateTopology;
+  currentTarget: GeosceneUtilityNetworkValidateTopology;
 }
-export interface GeosceneValuePickerCustomEvent<T> extends CustomEvent<T> {
+export interface GeosceneValuePickerLegacyCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneValuePickerElement;
-  currentTarget: HTMLGeosceneValuePickerElement;
+  target: GeosceneValuePickerLegacy;
+  currentTarget: GeosceneValuePickerLegacy;
 }
 export interface GeosceneVersionManagementCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneVersionManagementElement;
-  currentTarget: HTMLGeosceneVersionManagementElement;
+  target: GeosceneVersionManagement;
+  currentTarget: GeosceneVersionManagement;
 }
 export interface GeosceneVideoCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneVideoElement;
-  currentTarget: HTMLGeosceneVideoElement;
+  target: GeosceneVideo;
+  currentTarget: GeosceneVideo;
 }
 export interface GeosceneVideoPlayerCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneVideoPlayerElement;
-  currentTarget: HTMLGeosceneVideoPlayerElement;
+  target: GeosceneVideoPlayer;
+  currentTarget: GeosceneVideoPlayer;
+}
+export interface GeosceneVolumeMeasurementCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: GeosceneVolumeMeasurement;
+  currentTarget: GeosceneVolumeMeasurement;
 }
 export interface GeosceneWeatherCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneWeatherElement;
-  currentTarget: HTMLGeosceneWeatherElement;
+  target: GeosceneWeather;
+  currentTarget: GeosceneWeather;
 }
 export interface GeosceneZoomCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLGeosceneZoomElement;
-  currentTarget: HTMLGeosceneZoomElement;
+  target: GeosceneZoom;
+  currentTarget: GeosceneZoom;
 }
 
-export { ToEvents, TargetedEvent } from "@geoscene/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;
-  }
+    "geoscene-area-measurement-2d": GeosceneAreaMeasurement2d;
+    "geoscene-area-measurement-3d": GeosceneAreaMeasurement3d;
+    "geoscene-attachments": GeosceneAttachments;
+    "geoscene-basemap-gallery": GeosceneBasemapGallery;
+    "geoscene-basemap-layer-list": GeosceneBasemapLayerList;
+    "geoscene-basemap-toggle": GeosceneBasemapToggle;
+    "geoscene-bookmarks": GeosceneBookmarks;
+    "geoscene-building-explorer": GeosceneBuildingExplorer;
+    "geoscene-catalog-layer-list": GeosceneCatalogLayerList;
+    "geoscene-compass": GeosceneCompass;
+    "geoscene-coordinate-conversion": GeosceneCoordinateConversion;
+    "geoscene-daylight": GeosceneDaylight;
+    "geoscene-directional-pad": GeosceneDirectionalPad;
+    "geoscene-directions": GeosceneDirections;
+    "geoscene-direct-line-measurement-3d": GeosceneDirectLineMeasurement3d;
+    "geoscene-distance-measurement-2d": GeosceneDistanceMeasurement2d;
+    "geoscene-editor": GeosceneEditor;
+    "geoscene-elevation-profile": GeosceneElevationProfile;
+    "geoscene-expand": GeosceneExpand;
+    "geoscene-feature": GeosceneFeature;
+    "geoscene-feature-form": GeosceneFeatureForm;
+    "geoscene-feature-table": GeosceneFeatureTable;
+    "geoscene-feature-templates-legacy": GeosceneFeatureTemplatesLegacy;
+    "geoscene-features": GeosceneFeatures;
+    "geoscene-floor-filter": GeosceneFloorFilter;
+    "geoscene-fullscreen": GeosceneFullscreen;
+    "geoscene-grid-controls": GeosceneGridControls;
+    "geoscene-histogram-range-slider": GeosceneHistogramRangeSlider;
+    "geoscene-home": GeosceneHome;
+    "geoscene-layer-list": GeosceneLayerList;
+    "geoscene-legend": GeosceneLegend;
+    "geoscene-line-of-sight": GeosceneLineOfSight;
+    "geoscene-link-chart": GeosceneLinkChart;
+    "geoscene-link-chart-layout-switcher": GeosceneLinkChartLayoutSwitcher;
+    "geoscene-link-chart-nonspatial-visibility-toggle": GeosceneLinkChartNonspatialVisibilityToggle;
+    "geoscene-locate": GeosceneLocate;
+    "geoscene-map": GeosceneMap;
+    "geoscene-measurement": GeosceneMeasurement;
+    "geoscene-navigation-toggle": GeosceneNavigationToggle;
+    "geoscene-oriented-imagery-viewer": GeosceneOrientedImageryViewer;
+    "geoscene-paste": GeoscenePaste;
+    "geoscene-clipboard": GeosceneClipboard;
+    "geoscene-feature-image": GeosceneFeatureImage;
+    "geoscene-feature-title": GeosceneFeatureTitle;
+    "geoscene-multi-feature-form": GeosceneMultiFeatureForm;
+    "geoscene-popup": GeoscenePopup;
+    "geoscene-presentation": GeoscenePresentation;
+    "geoscene-print": GeoscenePrint;
+    "geoscene-reverse-geocode-list": GeosceneReverseGeocodeList;
+    "geoscene-scale-bar": GeosceneScaleBar;
+    "geoscene-scale-range-slider": GeosceneScaleRangeSlider;
+    "geoscene-scene": GeosceneScene;
+    "geoscene-search": GeosceneSearch;
+    "geoscene-search-result-renderer": GeosceneSearchResultRenderer;
+    "geoscene-shadow-cast": GeosceneShadowCast;
+    "geoscene-sketch": GeosceneSketch;
+    "geoscene-slice": GeosceneSlice;
+    "geoscene-slider-binary-color-size-legacy": GeosceneSliderBinaryColorSizeLegacy;
+    "geoscene-slider-classed-color-legacy": GeosceneSliderClassedColorLegacy;
+    "geoscene-slider-classed-size-legacy": GeosceneSliderClassedSizeLegacy;
+    "geoscene-slider-color-legacy": GeosceneSliderColorLegacy;
+    "geoscene-slider-color-size-legacy": GeosceneSliderColorSizeLegacy;
+    "geoscene-slider-heatmap-legacy": GeosceneSliderHeatmapLegacy;
+    "geoscene-slider-opacity-legacy": GeosceneSliderOpacityLegacy;
+    "geoscene-slider-size-legacy": GeosceneSliderSizeLegacy;
+    "geoscene-snapping-controls": GeosceneSnappingControls;
+    "geoscene-color-select": GeosceneColorSelect;
+    "geoscene-time-of-day-slider": GeosceneTimeOfDaySlider;
+    "geoscene-webgl-error": GeosceneWebGlError;
+    "geoscene-swipe": GeosceneSwipe;
+    "geoscene-table-list": GeosceneTableList;
+    "geoscene-time-slider": GeosceneTimeSlider;
+    "geoscene-time-zone-label": GeosceneTimeZoneLabel;
+    "geoscene-track": GeosceneTrack;
+    "geoscene-utility-network-associations": GeosceneUtilityNetworkAssociations;
+    "geoscene-utility-network-trace": GeosceneUtilityNetworkTrace;
+    "geoscene-utility-network-trace-analysis": GeosceneUtilityNetworkTraceAnalysis;
+    "geoscene-utility-network-aggregated-geometry": GeosceneUtilityNetworkAggregatedGeometry;
+    "geoscene-utility-network-subnetwork-info": GeosceneUtilityNetworkSubnetworkInfo;
+    "geoscene-utility-network-trace-inputs": GeosceneUtilityNetworkTraceInputs;
+    "geoscene-utility-network-trace-location": GeosceneUtilityNetworkTraceLocation;
+    "geoscene-utility-network-trace-location-list": GeosceneUtilityNetworkTraceLocationList;
+    "geoscene-utility-network-trace-results": GeosceneUtilityNetworkTraceResults;
+    "geoscene-utility-network-validate-topology": GeosceneUtilityNetworkValidateTopology;
+    "geoscene-value-picker-legacy": GeosceneValuePickerLegacy;
+    "geoscene-version-management": GeosceneVersionManagement;
+    "geoscene-video": GeosceneVideo;
+    "geoscene-video-player": GeosceneVideoPlayer;
+    "geoscene-volume-measurement": GeosceneVolumeMeasurement;
+    "geoscene-weather": GeosceneWeather;
+    "geoscene-zoom": GeosceneZoom;
+
+  }
+
+  type HTMLGeosceneAreaMeasurement2dElementEventMap = GeosceneAreaMeasurement2d["@eventTypes"];
+  type HTMLGeosceneAreaMeasurement2dElement = GeosceneAreaMeasurement2d;
+
+  type HTMLGeosceneAreaMeasurement3dElementEventMap = GeosceneAreaMeasurement3d["@eventTypes"];
+  type HTMLGeosceneAreaMeasurement3dElement = GeosceneAreaMeasurement3d;
+
+  type HTMLGeosceneAttachmentsElementEventMap = GeosceneAttachments["@eventTypes"];
+  type HTMLGeosceneAttachmentsElement = GeosceneAttachments;
+
+  type HTMLGeosceneBasemapGalleryElementEventMap = GeosceneBasemapGallery["@eventTypes"];
+  type HTMLGeosceneBasemapGalleryElement = GeosceneBasemapGallery;
+
+  type HTMLGeosceneBasemapLayerListElementEventMap = GeosceneBasemapLayerList["@eventTypes"];
+  type HTMLGeosceneBasemapLayerListElement = GeosceneBasemapLayerList;
+
+  type HTMLGeosceneBasemapToggleElementEventMap = GeosceneBasemapToggle["@eventTypes"];
+  type HTMLGeosceneBasemapToggleElement = GeosceneBasemapToggle;
+
+  type HTMLGeosceneBookmarksElementEventMap = GeosceneBookmarks["@eventTypes"];
+  type HTMLGeosceneBookmarksElement = GeosceneBookmarks;
+
+  type HTMLGeosceneBuildingExplorerElementEventMap = GeosceneBuildingExplorer["@eventTypes"];
+  type HTMLGeosceneBuildingExplorerElement = GeosceneBuildingExplorer;
+
+  type HTMLGeosceneCatalogLayerListElementEventMap = GeosceneCatalogLayerList["@eventTypes"];
+  type HTMLGeosceneCatalogLayerListElement = GeosceneCatalogLayerList;
+
+  type HTMLGeosceneCompassElementEventMap = GeosceneCompass["@eventTypes"];
+  type HTMLGeosceneCompassElement = GeosceneCompass;
+
+  type HTMLGeosceneCoordinateConversionElementEventMap = GeosceneCoordinateConversion["@eventTypes"];
+  type HTMLGeosceneCoordinateConversionElement = GeosceneCoordinateConversion;
+
+  type HTMLGeosceneDaylightElementEventMap = GeosceneDaylight["@eventTypes"];
+  type HTMLGeosceneDaylightElement = GeosceneDaylight;
+
+  type HTMLGeosceneDirectionalPadElementEventMap = GeosceneDirectionalPad["@eventTypes"];
+  type HTMLGeosceneDirectionalPadElement = GeosceneDirectionalPad;
 
-  interface HTMLGeosceneAreaMeasurement2dElementEventMap {
-    "geoscenePropertyChange": GeosceneAreaMeasurement2d["geoscenePropertyChange"]["detail"];
-    "geosceneReady": GeosceneAreaMeasurement2d["geosceneReady"]["detail"];
-  }
+  type HTMLGeosceneDirectionsElementEventMap = GeosceneDirections["@eventTypes"];
+  type HTMLGeosceneDirectionsElement = GeosceneDirections;
 
-  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"];
-  }
+  type HTMLGeosceneDirectLineMeasurement3dElementEventMap = GeosceneDirectLineMeasurement3d["@eventTypes"];
+  type HTMLGeosceneDirectLineMeasurement3dElement = GeosceneDirectLineMeasurement3d;
 
-  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"];
-  }
+  type HTMLGeosceneDistanceMeasurement2dElementEventMap = GeosceneDistanceMeasurement2d["@eventTypes"];
+  type HTMLGeosceneDistanceMeasurement2dElement = GeosceneDistanceMeasurement2d;
 
-  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"];
-  }
+  type HTMLGeosceneEditorElementEventMap = GeosceneEditor["@eventTypes"];
+  type HTMLGeosceneEditorElement = GeosceneEditor;
 
-  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"];
-  }
+  type HTMLGeosceneElevationProfileElementEventMap = GeosceneElevationProfile["@eventTypes"];
+  type HTMLGeosceneElevationProfileElement = GeosceneElevationProfile;
 
-  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"];
-  }
+  type HTMLGeosceneExpandElementEventMap = GeosceneExpand["@eventTypes"];
+  type HTMLGeosceneExpandElement = GeosceneExpand;
 
-  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"];
-  }
+  type HTMLGeosceneFeatureElementEventMap = GeosceneFeature["@eventTypes"];
+  type HTMLGeosceneFeatureElement = GeosceneFeature;
 
-  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"];
-  }
+  type HTMLGeosceneFeatureFormElementEventMap = GeosceneFeatureForm["@eventTypes"];
+  type HTMLGeosceneFeatureFormElement = GeosceneFeatureForm;
 
-  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"];
-  }
+  type HTMLGeosceneFeatureTableElementEventMap = GeosceneFeatureTable["@eventTypes"];
+  type HTMLGeosceneFeatureTableElement = GeosceneFeatureTable;
 
-  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"];
-  }
+  type HTMLGeosceneFeatureTemplatesLegacyElementEventMap = GeosceneFeatureTemplatesLegacy["@eventTypes"];
+  type HTMLGeosceneFeatureTemplatesLegacyElement = GeosceneFeatureTemplatesLegacy;
 
-  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"];
-  }
+  type HTMLGeosceneFeaturesElementEventMap = GeosceneFeatures["@eventTypes"];
+  type HTMLGeosceneFeaturesElement = GeosceneFeatures;
 
-  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"];
-  }
+  type HTMLGeosceneFloorFilterElementEventMap = GeosceneFloorFilter["@eventTypes"];
+  type HTMLGeosceneFloorFilterElement = GeosceneFloorFilter;
 
-  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"];
-  }
+  type HTMLGeosceneFullscreenElementEventMap = GeosceneFullscreen["@eventTypes"];
+  type HTMLGeosceneFullscreenElement = GeosceneFullscreen;
 
-  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"];
-  }
+  type HTMLGeosceneGridControlsElementEventMap = GeosceneGridControls["@eventTypes"];
+  type HTMLGeosceneGridControlsElement = GeosceneGridControls;
 
-  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"];
-  }
+  type HTMLGeosceneHistogramRangeSliderElementEventMap = GeosceneHistogramRangeSlider["@eventTypes"];
+  type HTMLGeosceneHistogramRangeSliderElement = GeosceneHistogramRangeSlider;
 
-  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"];
-  }
+  type HTMLGeosceneHomeElementEventMap = GeosceneHome["@eventTypes"];
+  type HTMLGeosceneHomeElement = GeosceneHome;
 
-  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"];
-  }
+  type HTMLGeosceneLayerListElementEventMap = GeosceneLayerList["@eventTypes"];
+  type HTMLGeosceneLayerListElement = GeosceneLayerList;
 
-  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"];
-  }
+  type HTMLGeosceneLegendElementEventMap = GeosceneLegend["@eventTypes"];
+  type HTMLGeosceneLegendElement = GeosceneLegend;
 
-  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"];
-  }
+  type HTMLGeosceneLineOfSightElementEventMap = GeosceneLineOfSight["@eventTypes"];
+  type HTMLGeosceneLineOfSightElement = GeosceneLineOfSight;
 
-  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"];
-  }
+  type HTMLGeosceneLinkChartElementEventMap = GeosceneLinkChart["@eventTypes"];
+  type HTMLGeosceneLinkChartElement = GeosceneLinkChart;
 
-  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"];
-  }
+  type HTMLGeosceneLinkChartLayoutSwitcherElementEventMap = GeosceneLinkChartLayoutSwitcher["@eventTypes"];
+  type HTMLGeosceneLinkChartLayoutSwitcherElement = GeosceneLinkChartLayoutSwitcher;
 
-  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"];
-  }
+  type HTMLGeosceneLinkChartNonspatialVisibilityToggleElementEventMap = GeosceneLinkChartNonspatialVisibilityToggle["@eventTypes"];
+  type HTMLGeosceneLinkChartNonspatialVisibilityToggleElement = GeosceneLinkChartNonspatialVisibilityToggle;
 
-  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"];
-  }
+  type HTMLGeosceneLocateElementEventMap = GeosceneLocate["@eventTypes"];
+  type HTMLGeosceneLocateElement = GeosceneLocate;
 
-  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"];
-  }
+  type HTMLGeosceneMapElementEventMap = GeosceneMap["@eventTypes"];
+  type HTMLGeosceneMapElement = GeosceneMap;
 
-  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"];
-  }
+  type HTMLGeosceneMeasurementElementEventMap = GeosceneMeasurement["@eventTypes"];
+  type HTMLGeosceneMeasurementElement = GeosceneMeasurement;
 
-  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"];
-  }
+  type HTMLGeosceneNavigationToggleElementEventMap = GeosceneNavigationToggle["@eventTypes"];
+  type HTMLGeosceneNavigationToggleElement = GeosceneNavigationToggle;
 
-  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"];
-  }
+  type HTMLGeosceneOrientedImageryViewerElementEventMap = GeosceneOrientedImageryViewer["@eventTypes"];
+  type HTMLGeosceneOrientedImageryViewerElement = GeosceneOrientedImageryViewer;
 
-  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"];
-  }
+  type HTMLGeoscenePasteElementEventMap = GeoscenePaste["@eventTypes"];
+  type HTMLGeoscenePasteElement = GeoscenePaste;
 
-  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"];
-  }
+  type HTMLGeosceneClipboardElementEventMap = GeosceneClipboard["@eventTypes"];
+  type HTMLGeosceneClipboardElement = GeosceneClipboard;
 
-  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"];
-  }
+  type HTMLGeosceneFeatureImageElement = GeosceneFeatureImage;
 
-  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"];
-  }
+  type HTMLGeosceneFeatureTitleElement = GeosceneFeatureTitle;
 
-  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"];
-  }
+  type HTMLGeosceneMultiFeatureFormElementEventMap = GeosceneMultiFeatureForm["@eventTypes"];
+  type HTMLGeosceneMultiFeatureFormElement = GeosceneMultiFeatureForm;
 
-  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"];
-  }
+  type HTMLGeoscenePopupElementEventMap = GeoscenePopup["@eventTypes"];
+  type HTMLGeoscenePopupElement = GeoscenePopup;
 
-  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"];
-  }
+  type HTMLGeoscenePresentationElementEventMap = GeoscenePresentation["@eventTypes"];
+  type HTMLGeoscenePresentationElement = GeoscenePresentation;
 
-  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"];
-  }
+  type HTMLGeoscenePrintElementEventMap = GeoscenePrint["@eventTypes"];
+  type HTMLGeoscenePrintElement = GeoscenePrint;
 
-  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"];
-  }
+  type HTMLGeosceneReverseGeocodeListElementEventMap = GeosceneReverseGeocodeList["@eventTypes"];
+  type HTMLGeosceneReverseGeocodeListElement = GeosceneReverseGeocodeList;
 
-  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"];
-  }
+  type HTMLGeosceneScaleBarElementEventMap = GeosceneScaleBar["@eventTypes"];
+  type HTMLGeosceneScaleBarElement = GeosceneScaleBar;
 
-  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"];
-  }
+  type HTMLGeosceneScaleRangeSliderElementEventMap = GeosceneScaleRangeSlider["@eventTypes"];
+  type HTMLGeosceneScaleRangeSliderElement = GeosceneScaleRangeSlider;
 
-  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"];
-  }
+  type HTMLGeosceneSceneElementEventMap = GeosceneScene["@eventTypes"];
+  type HTMLGeosceneSceneElement = GeosceneScene;
 
-  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"];
-  }
+  type HTMLGeosceneSearchElementEventMap = GeosceneSearch["@eventTypes"];
+  type HTMLGeosceneSearchElement = GeosceneSearch;
 
-  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"];
-  }
+  type HTMLGeosceneSearchResultRendererElementEventMap = GeosceneSearchResultRenderer["@eventTypes"];
+  type HTMLGeosceneSearchResultRendererElement = GeosceneSearchResultRenderer;
 
-  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"];
-  }
+  type HTMLGeosceneShadowCastElementEventMap = GeosceneShadowCast["@eventTypes"];
+  type HTMLGeosceneShadowCastElement = GeosceneShadowCast;
 
-  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"];
-  }
+  type HTMLGeosceneSketchElementEventMap = GeosceneSketch["@eventTypes"];
+  type HTMLGeosceneSketchElement = GeosceneSketch;
 
-  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"];
-  }
+  type HTMLGeosceneSliceElementEventMap = GeosceneSlice["@eventTypes"];
+  type HTMLGeosceneSliceElement = GeosceneSlice;
 
-  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"];
-  }
+  type HTMLGeosceneSliderBinaryColorSizeLegacyElementEventMap = GeosceneSliderBinaryColorSizeLegacy["@eventTypes"];
+  type HTMLGeosceneSliderBinaryColorSizeLegacyElement = GeosceneSliderBinaryColorSizeLegacy;
 
-  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"];
-  }
+  type HTMLGeosceneSliderClassedColorLegacyElementEventMap = GeosceneSliderClassedColorLegacy["@eventTypes"];
+  type HTMLGeosceneSliderClassedColorLegacyElement = GeosceneSliderClassedColorLegacy;
 
-  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"];
-  }
+  type HTMLGeosceneSliderClassedSizeLegacyElementEventMap = GeosceneSliderClassedSizeLegacy["@eventTypes"];
+  type HTMLGeosceneSliderClassedSizeLegacyElement = GeosceneSliderClassedSizeLegacy;
 
-  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"];
-  }
+  type HTMLGeosceneSliderColorLegacyElementEventMap = GeosceneSliderColorLegacy["@eventTypes"];
+  type HTMLGeosceneSliderColorLegacyElement = GeosceneSliderColorLegacy;
 
-  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"];
-  }
+  type HTMLGeosceneSliderColorSizeLegacyElementEventMap = GeosceneSliderColorSizeLegacy["@eventTypes"];
+  type HTMLGeosceneSliderColorSizeLegacyElement = GeosceneSliderColorSizeLegacy;
 
-  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"];
-  }
+  type HTMLGeosceneSliderHeatmapLegacyElementEventMap = GeosceneSliderHeatmapLegacy["@eventTypes"];
+  type HTMLGeosceneSliderHeatmapLegacyElement = GeosceneSliderHeatmapLegacy;
 
-  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"];
-  }
+  type HTMLGeosceneSliderOpacityLegacyElementEventMap = GeosceneSliderOpacityLegacy["@eventTypes"];
+  type HTMLGeosceneSliderOpacityLegacyElement = GeosceneSliderOpacityLegacy;
 
-  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"];
-  }
+  type HTMLGeosceneSliderSizeLegacyElementEventMap = GeosceneSliderSizeLegacy["@eventTypes"];
+  type HTMLGeosceneSliderSizeLegacyElement = GeosceneSliderSizeLegacy;
 
-  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"];
-  }
+  type HTMLGeosceneSnappingControlsElementEventMap = GeosceneSnappingControls["@eventTypes"];
+  type HTMLGeosceneSnappingControlsElement = GeosceneSnappingControls;
 
-  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"];
-  }
+  type HTMLGeosceneColorSelectElementEventMap = GeosceneColorSelect["@eventTypes"];
+  type HTMLGeosceneColorSelectElement = GeosceneColorSelect;
 
-  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"];
-  }
+  type HTMLGeosceneTimeOfDaySliderElementEventMap = GeosceneTimeOfDaySlider["@eventTypes"];
+  type HTMLGeosceneTimeOfDaySliderElement = GeosceneTimeOfDaySlider;
 
-  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"];
-  }
+  type HTMLGeosceneWebglErrorElement = GeosceneWebGlError;
 
-  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"];
-  }
+  type HTMLGeosceneSwipeElementEventMap = GeosceneSwipe["@eventTypes"];
+  type HTMLGeosceneSwipeElement = GeosceneSwipe;
 
-  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"];
-  }
+  type HTMLGeosceneTableListElementEventMap = GeosceneTableList["@eventTypes"];
+  type HTMLGeosceneTableListElement = GeosceneTableList;
 
-  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"];
-  }
+  type HTMLGeosceneTimeSliderElementEventMap = GeosceneTimeSlider["@eventTypes"];
+  type HTMLGeosceneTimeSliderElement = GeosceneTimeSlider;
 
-  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"];
-  }
+  type HTMLGeosceneTimeZoneLabelElementEventMap = GeosceneTimeZoneLabel["@eventTypes"];
+  type HTMLGeosceneTimeZoneLabelElement = GeosceneTimeZoneLabel;
 
-  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"];
-  }
+  type HTMLGeosceneTrackElementEventMap = GeosceneTrack["@eventTypes"];
+  type HTMLGeosceneTrackElement = GeosceneTrack;
 
-  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"];
-  }
+  type HTMLGeosceneUtilityNetworkAssociationsElementEventMap = GeosceneUtilityNetworkAssociations["@eventTypes"];
+  type HTMLGeosceneUtilityNetworkAssociationsElement = GeosceneUtilityNetworkAssociations;
 
-  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"];
-  }
+  type HTMLGeosceneUtilityNetworkTraceElementEventMap = GeosceneUtilityNetworkTrace["@eventTypes"];
+  type HTMLGeosceneUtilityNetworkTraceElement = GeosceneUtilityNetworkTrace;
 
-  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"];
-  }
+  type HTMLGeosceneUtilityNetworkTraceAnalysisElementEventMap = GeosceneUtilityNetworkTraceAnalysis["@eventTypes"];
+  type HTMLGeosceneUtilityNetworkTraceAnalysisElement = GeosceneUtilityNetworkTraceAnalysis;
+
+  type HTMLGeosceneUtilityNetworkAggregatedGeometryElementEventMap = GeosceneUtilityNetworkAggregatedGeometry["@eventTypes"];
+  type HTMLGeosceneUtilityNetworkAggregatedGeometryElement = GeosceneUtilityNetworkAggregatedGeometry;
+
+  type HTMLGeosceneUtilityNetworkSubnetworkInfoElement = GeosceneUtilityNetworkSubnetworkInfo;
+
+  type HTMLGeosceneUtilityNetworkTraceInputsElementEventMap = GeosceneUtilityNetworkTraceInputs["@eventTypes"];
+  type HTMLGeosceneUtilityNetworkTraceInputsElement = GeosceneUtilityNetworkTraceInputs;
+
+  type HTMLGeosceneUtilityNetworkTraceLocationElementEventMap = GeosceneUtilityNetworkTraceLocation["@eventTypes"];
+  type HTMLGeosceneUtilityNetworkTraceLocationElement = GeosceneUtilityNetworkTraceLocation;
+
+  type HTMLGeosceneUtilityNetworkTraceLocationListElement = GeosceneUtilityNetworkTraceLocationList;
+
+  type HTMLGeosceneUtilityNetworkTraceResultsElementEventMap = GeosceneUtilityNetworkTraceResults["@eventTypes"];
+  type HTMLGeosceneUtilityNetworkTraceResultsElement = GeosceneUtilityNetworkTraceResults;
+
+  type HTMLGeosceneUtilityNetworkValidateTopologyElementEventMap = GeosceneUtilityNetworkValidateTopology["@eventTypes"];
+  type HTMLGeosceneUtilityNetworkValidateTopologyElement = GeosceneUtilityNetworkValidateTopology;
+
+  type HTMLGeosceneValuePickerLegacyElementEventMap = GeosceneValuePickerLegacy["@eventTypes"];
+  type HTMLGeosceneValuePickerLegacyElement = GeosceneValuePickerLegacy;
+
+  type HTMLGeosceneVersionManagementElementEventMap = GeosceneVersionManagement["@eventTypes"];
+  type HTMLGeosceneVersionManagementElement = GeosceneVersionManagement;
+
+  type HTMLGeosceneVideoElementEventMap = GeosceneVideo["@eventTypes"];
+  type HTMLGeosceneVideoElement = GeosceneVideo;
+
+  type HTMLGeosceneVideoPlayerElementEventMap = GeosceneVideoPlayer["@eventTypes"];
+  type HTMLGeosceneVideoPlayerElement = GeosceneVideoPlayer;
+
+  type HTMLGeosceneVolumeMeasurementElementEventMap = GeosceneVolumeMeasurement["@eventTypes"];
+  type HTMLGeosceneVolumeMeasurementElement = GeosceneVolumeMeasurement;
+
+  type HTMLGeosceneWeatherElementEventMap = GeosceneWeather["@eventTypes"];
+  type HTMLGeosceneWeatherElement = GeosceneWeather;
+
+  type HTMLGeosceneZoomElementEventMap = GeosceneZoom["@eventTypes"];
+  type HTMLGeosceneZoomElement = GeosceneZoom;
 
-  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;
-  }
 }