@esri/calcite-components 5.0.0-next.8 → 5.0.0-next.80

package/dist/index.d.ts

@@ -1,1649 +1,899 @@
-import type { Accordion } from "./components/calcite-accordion";
-import type { AccordionItem } from "./components/calcite-accordion-item";
-import type { Action } from "./components/calcite-action";
-import type { ActionBar } from "./components/calcite-action-bar";
-import type { ActionGroup } from "./components/calcite-action-group";
-import type { ActionMenu } from "./components/calcite-action-menu";
-import type { ActionPad } from "./components/calcite-action-pad";
-import type { Alert } from "./components/calcite-alert";
-import type { Autocomplete } from "./components/calcite-autocomplete";
-import type { AutocompleteItem } from "./components/calcite-autocomplete-item";
-import type { AutocompleteItemGroup } from "./components/calcite-autocomplete-item-group";
-import type { Avatar } from "./components/calcite-avatar";
-import type { Block } from "./components/calcite-block";
-import type { BlockGroup } from "./components/calcite-block-group";
-import type { BlockSection } from "./components/calcite-block-section";
-import type { Button } from "./components/calcite-button";
-import type { Card } from "./components/calcite-card";
-import type { CardGroup } from "./components/calcite-card-group";
-import type { Carousel } from "./components/calcite-carousel";
-import type { CarouselItem } from "./components/calcite-carousel-item";
-import type { Checkbox } from "./components/calcite-checkbox";
-import type { Chip } from "./components/calcite-chip";
-import type { ChipGroup } from "./components/calcite-chip-group";
-import type { ColorPicker } from "./components/calcite-color-picker";
-import type { ColorPickerHexInput } from "./components/calcite-color-picker-hex-input";
-import type { ColorPickerSwatch } from "./components/calcite-color-picker-swatch";
-import type { Combobox } from "./components/calcite-combobox";
-import type { ComboboxItem } from "./components/calcite-combobox-item";
-import type { ComboboxItemGroup } from "./components/calcite-combobox-item-group";
-import type { DatePicker } from "./components/calcite-date-picker";
-import type { DatePickerDay } from "./components/calcite-date-picker-day";
-import type { DatePickerMonth } from "./components/calcite-date-picker-month";
-import type { DatePickerMonthHeader } from "./components/calcite-date-picker-month-header";
-import type { Dialog } from "./components/calcite-dialog";
-import type { Dropdown } from "./components/calcite-dropdown";
-import type { DropdownGroup } from "./components/calcite-dropdown-group";
-import type { DropdownItem } from "./components/calcite-dropdown-item";
-import type { Fab } from "./components/calcite-fab";
-import type { Filter } from "./components/calcite-filter";
-import type { Flow } from "./components/calcite-flow";
-import type { FlowItem } from "./components/calcite-flow-item";
-import type { Graph } from "./components/calcite-graph";
-import type { Handle } from "./components/calcite-handle";
-import type { Icon } from "./components/calcite-icon";
-import type { InlineEditable } from "./components/calcite-inline-editable";
-import type { Input } from "./components/calcite-input";
-import type { InputDatePicker } from "./components/calcite-input-date-picker";
-import type { InputMessage } from "./components/calcite-input-message";
-import type { InputNumber } from "./components/calcite-input-number";
-import type { InputText } from "./components/calcite-input-text";
-import type { InputTimePicker } from "./components/calcite-input-time-picker";
-import type { InputTimeZone } from "./components/calcite-input-time-zone";
-import type { Label } from "./components/calcite-label";
-import type { Link } from "./components/calcite-link";
-import type { List } from "./components/calcite-list";
-import type { ListItem } from "./components/calcite-list-item";
-import type { ListItemGroup } from "./components/calcite-list-item-group";
-import type { Loader } from "./components/calcite-loader";
-import type { Menu } from "./components/calcite-menu";
-import type { MenuItem } from "./components/calcite-menu-item";
-import type { Meter } from "./components/calcite-meter";
-import type { Navigation } from "./components/calcite-navigation";
-import type { NavigationLogo } from "./components/calcite-navigation-logo";
-import type { NavigationUser } from "./components/calcite-navigation-user";
-import type { Notice } from "./components/calcite-notice";
-import type { Option } from "./components/calcite-option";
-import type { OptionGroup } from "./components/calcite-option-group";
-import type { Pagination } from "./components/calcite-pagination";
-import type { Panel } from "./components/calcite-panel";
-import type { Popover } from "./components/calcite-popover";
-import type { Progress } from "./components/calcite-progress";
-import type { RadioButton } from "./components/calcite-radio-button";
-import type { RadioButtonGroup } from "./components/calcite-radio-button-group";
-import type { Rating } from "./components/calcite-rating";
-import type { Scrim } from "./components/calcite-scrim";
-import type { SegmentedControl } from "./components/calcite-segmented-control";
-import type { SegmentedControlItem } from "./components/calcite-segmented-control-item";
-import type { Select } from "./components/calcite-select";
-import type { Sheet } from "./components/calcite-sheet";
-import type { Shell } from "./components/calcite-shell";
-import type { ShellPanel } from "./components/calcite-shell-panel";
-import type { Slider } from "./components/calcite-slider";
-import type { SortHandle } from "./components/calcite-sort-handle";
-import type { SortableList } from "./components/calcite-sortable-list";
-import type { SplitButton } from "./components/calcite-split-button";
-import type { Stack } from "./components/calcite-stack";
-import type { Stepper } from "./components/calcite-stepper";
-import type { StepperItem } from "./components/calcite-stepper-item";
-import type { Swatch } from "./components/calcite-swatch";
-import type { SwatchGroup } from "./components/calcite-swatch-group";
-import type { Switch } from "./components/calcite-switch";
-import type { Tab } from "./components/calcite-tab";
-import type { TabNav } from "./components/calcite-tab-nav";
-import type { TabTitle } from "./components/calcite-tab-title";
-import type { Table } from "./components/calcite-table";
-import type { TableCell } from "./components/calcite-table-cell";
-import type { TableHeader } from "./components/calcite-table-header";
-import type { TableRow } from "./components/calcite-table-row";
-import type { Tabs } from "./components/calcite-tabs";
-import type { TextArea } from "./components/calcite-text-area";
-import type { Tile } from "./components/calcite-tile";
-import type { TileGroup } from "./components/calcite-tile-group";
-import type { TimePicker } from "./components/calcite-time-picker";
-import type { Tooltip } from "./components/calcite-tooltip";
-import type { Tree } from "./components/calcite-tree";
-import type { TreeItem } from "./components/calcite-tree-item";
-
-import { Runtime } from '@arcgis/lumina';
+
+
+/** @public */
 declare module "csstype" {
-    interface Properties {
-        [index: `--calcite-${string}`]: any;
-    }
-}
-/** @internal */
-export declare let assetPathChanged: boolean;
-export declare const setAssetPath: Runtime["setAssetPath"];
-export { getAssetPath } from './runtime';
+  interface Properties {
+    [index: `--calcite-${string}`]: any;
+  }
+}
+
+/**
+ * @default false
+ * @internal
+ */
+export const assetPathChanged: boolean;
+
+/**
+ * Get a resolved path from where an asset can be loaded.
+ *
+ * @param suffix - The relative path for the asset.
+ */
+export function getAssetPath(suffix: string): string;
+
+/**
+ * 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.arcgis.com/<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 function setAssetPath(path: URL | string): void;
+
+import type { Accordion } from "./components/calcite-accordion/customElement.js";
+import type { AccordionItem } from "./components/calcite-accordion-item/customElement.js";
+import type { Action } from "./components/calcite-action/customElement.js";
+import type { ActionBar } from "./components/calcite-action-bar/customElement.js";
+import type { ActionGroup } from "./components/calcite-action-group/customElement.js";
+import type { ActionMenu } from "./components/calcite-action-menu/customElement.js";
+import type { ActionPad } from "./components/calcite-action-pad/customElement.js";
+import type { Alert } from "./components/calcite-alert/customElement.js";
+import type { Autocomplete } from "./components/calcite-autocomplete/customElement.js";
+import type { AutocompleteItem } from "./components/calcite-autocomplete-item/customElement.js";
+import type { AutocompleteItemGroup } from "./components/calcite-autocomplete-item-group/customElement.js";
+import type { Avatar } from "./components/calcite-avatar/customElement.js";
+import type { Block } from "./components/calcite-block/customElement.js";
+import type { BlockGroup } from "./components/calcite-block-group/customElement.js";
+import type { BlockSection } from "./components/calcite-block-section/customElement.js";
+import type { Button } from "./components/calcite-button/customElement.js";
+import type { Card } from "./components/calcite-card/customElement.js";
+import type { CardGroup } from "./components/calcite-card-group/customElement.js";
+import type { Carousel } from "./components/calcite-carousel/customElement.js";
+import type { CarouselItem } from "./components/calcite-carousel-item/customElement.js";
+import type { Checkbox } from "./components/calcite-checkbox/customElement.js";
+import type { Chip } from "./components/calcite-chip/customElement.js";
+import type { ChipGroup } from "./components/calcite-chip-group/customElement.js";
+import type { ColorPicker } from "./components/calcite-color-picker/customElement.js";
+import type { ColorPickerHexInput } from "./components/calcite-color-picker-hex-input/customElement.js";
+import type { ColorPickerSwatch } from "./components/calcite-color-picker-swatch/customElement.js";
+import type { Combobox } from "./components/calcite-combobox/customElement.js";
+import type { ComboboxItem } from "./components/calcite-combobox-item/customElement.js";
+import type { ComboboxItemGroup } from "./components/calcite-combobox-item-group/customElement.js";
+import type { DatePicker } from "./components/calcite-date-picker/customElement.js";
+import type { DatePickerDay } from "./components/calcite-date-picker-day/customElement.js";
+import type { DatePickerMonth } from "./components/calcite-date-picker-month/customElement.js";
+import type { Dialog } from "./components/calcite-dialog/customElement.js";
+import type { Dropdown } from "./components/calcite-dropdown/customElement.js";
+import type { DropdownGroup } from "./components/calcite-dropdown-group/customElement.js";
+import type { DropdownItem } from "./components/calcite-dropdown-item/customElement.js";
+import type { Fab } from "./components/calcite-fab/customElement.js";
+import type { Filter } from "./components/calcite-filter/customElement.js";
+import type { Flow } from "./components/calcite-flow/customElement.js";
+import type { FlowItem } from "./components/calcite-flow-item/customElement.js";
+import type { Graph } from "./components/calcite-graph/customElement.js";
+import type { Handle } from "./components/calcite-handle/customElement.js";
+import type { Icon } from "./components/calcite-icon/customElement.js";
+import type { InlineEditable } from "./components/calcite-inline-editable/customElement.js";
+import type { Input } from "./components/calcite-input/customElement.js";
+import type { InputDatePicker } from "./components/calcite-input-date-picker/customElement.js";
+import type { InputMessage } from "./components/calcite-input-message/customElement.js";
+import type { InputNumber } from "./components/calcite-input-number/customElement.js";
+import type { InputText } from "./components/calcite-input-text/customElement.js";
+import type { InputTimePicker } from "./components/calcite-input-time-picker/customElement.js";
+import type { InputTimeZone } from "./components/calcite-input-time-zone/customElement.js";
+import type { Label } from "./components/calcite-label/customElement.js";
+import type { Link } from "./components/calcite-link/customElement.js";
+import type { List } from "./components/calcite-list/customElement.js";
+import type { ListItem } from "./components/calcite-list-item/customElement.js";
+import type { ListItemGroup } from "./components/calcite-list-item-group/customElement.js";
+import type { Loader } from "./components/calcite-loader/customElement.js";
+import type { Menu } from "./components/calcite-menu/customElement.js";
+import type { MenuItem } from "./components/calcite-menu-item/customElement.js";
+import type { Meter } from "./components/calcite-meter/customElement.js";
+import type { Navigation } from "./components/calcite-navigation/customElement.js";
+import type { NavigationLogo } from "./components/calcite-navigation-logo/customElement.js";
+import type { NavigationUser } from "./components/calcite-navigation-user/customElement.js";
+import type { Notice } from "./components/calcite-notice/customElement.js";
+import type { Option } from "./components/calcite-option/customElement.js";
+import type { OptionGroup } from "./components/calcite-option-group/customElement.js";
+import type { Pagination } from "./components/calcite-pagination/customElement.js";
+import type { Panel } from "./components/calcite-panel/customElement.js";
+import type { Popover } from "./components/calcite-popover/customElement.js";
+import type { Progress } from "./components/calcite-progress/customElement.js";
+import type { RadioButton } from "./components/calcite-radio-button/customElement.js";
+import type { RadioButtonGroup } from "./components/calcite-radio-button-group/customElement.js";
+import type { Rating } from "./components/calcite-rating/customElement.js";
+import type { Scrim } from "./components/calcite-scrim/customElement.js";
+import type { SegmentedControl } from "./components/calcite-segmented-control/customElement.js";
+import type { SegmentedControlItem } from "./components/calcite-segmented-control-item/customElement.js";
+import type { Select } from "./components/calcite-select/customElement.js";
+import type { Sheet } from "./components/calcite-sheet/customElement.js";
+import type { Shell } from "./components/calcite-shell/customElement.js";
+import type { ShellPanel } from "./components/calcite-shell-panel/customElement.js";
+import type { Slider } from "./components/calcite-slider/customElement.js";
+import type { SortHandle } from "./components/calcite-sort-handle/customElement.js";
+import type { SortableList } from "./components/calcite-sortable-list/customElement.js";
+import type { SplitButton } from "./components/calcite-split-button/customElement.js";
+import type { Stack } from "./components/calcite-stack/customElement.js";
+import type { Stepper } from "./components/calcite-stepper/customElement.js";
+import type { StepperItem } from "./components/calcite-stepper-item/customElement.js";
+import type { Swatch } from "./components/calcite-swatch/customElement.js";
+import type { SwatchGroup } from "./components/calcite-swatch-group/customElement.js";
+import type { Switch } from "./components/calcite-switch/customElement.js";
+import type { Tab } from "./components/calcite-tab/customElement.js";
+import type { TabNav } from "./components/calcite-tab-nav/customElement.js";
+import type { TabTitle } from "./components/calcite-tab-title/customElement.js";
+import type { Table } from "./components/calcite-table/customElement.js";
+import type { TableCell } from "./components/calcite-table-cell/customElement.js";
+import type { TableHeader } from "./components/calcite-table-header/customElement.js";
+import type { TableRow } from "./components/calcite-table-row/customElement.js";
+import type { Tabs } from "./components/calcite-tabs/customElement.js";
+import type { TextArea } from "./components/calcite-text-area/customElement.js";
+import type { Tile } from "./components/calcite-tile/customElement.js";
+import type { TileGroup } from "./components/calcite-tile-group/customElement.js";
+import type { TimePicker } from "./components/calcite-time-picker/customElement.js";
+import type { Tooltip } from "./components/calcite-tooltip/customElement.js";
+import type { Tree } from "./components/calcite-tree/customElement.js";
+import type { TreeItem } from "./components/calcite-tree-item/customElement.js";
 
+export { ToEvents, TargetedEvent } from "@arcgis/lumina";
 
 export interface CalciteAccordionItemCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteAccordionItemElement;
-  currentTarget: HTMLCalciteAccordionItemElement;
+  target: AccordionItem;
+  currentTarget: AccordionItem;
+}
+export interface CalciteActionCustomEvent<T> extends CustomEvent<T> {
+  detail: T;
+  target: Action;
+  currentTarget: Action;
 }
 export interface CalciteActionBarCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteActionBarElement;
-  currentTarget: HTMLCalciteActionBarElement;
+  target: ActionBar;
+  currentTarget: ActionBar;
 }
 export interface CalciteActionGroupCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteActionGroupElement;
-  currentTarget: HTMLCalciteActionGroupElement;
+  target: ActionGroup;
+  currentTarget: ActionGroup;
 }
 export interface CalciteActionMenuCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteActionMenuElement;
-  currentTarget: HTMLCalciteActionMenuElement;
+  target: ActionMenu;
+  currentTarget: ActionMenu;
 }
 export interface CalciteActionPadCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteActionPadElement;
-  currentTarget: HTMLCalciteActionPadElement;
+  target: ActionPad;
+  currentTarget: ActionPad;
 }
 export interface CalciteAlertCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteAlertElement;
-  currentTarget: HTMLCalciteAlertElement;
+  target: Alert;
+  currentTarget: Alert;
 }
 export interface CalciteAutocompleteCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteAutocompleteElement;
-  currentTarget: HTMLCalciteAutocompleteElement;
+  target: Autocomplete;
+  currentTarget: Autocomplete;
 }
 export interface CalciteAutocompleteItemCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteAutocompleteItemElement;
-  currentTarget: HTMLCalciteAutocompleteItemElement;
+  target: AutocompleteItem;
+  currentTarget: AutocompleteItem;
 }
 export interface CalciteBlockCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteBlockElement;
-  currentTarget: HTMLCalciteBlockElement;
+  target: Block;
+  currentTarget: Block;
 }
 export interface CalciteBlockGroupCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteBlockGroupElement;
-  currentTarget: HTMLCalciteBlockGroupElement;
+  target: BlockGroup;
+  currentTarget: BlockGroup;
 }
 export interface CalciteBlockSectionCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteBlockSectionElement;
-  currentTarget: HTMLCalciteBlockSectionElement;
+  target: BlockSection;
+  currentTarget: BlockSection;
 }
 export interface CalciteCardCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteCardElement;
-  currentTarget: HTMLCalciteCardElement;
+  target: Card;
+  currentTarget: Card;
 }
 export interface CalciteCardGroupCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteCardGroupElement;
-  currentTarget: HTMLCalciteCardGroupElement;
+  target: CardGroup;
+  currentTarget: CardGroup;
 }
 export interface CalciteCarouselCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteCarouselElement;
-  currentTarget: HTMLCalciteCarouselElement;
+  target: Carousel;
+  currentTarget: Carousel;
 }
 export interface CalciteCheckboxCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteCheckboxElement;
-  currentTarget: HTMLCalciteCheckboxElement;
+  target: Checkbox;
+  currentTarget: Checkbox;
 }
 export interface CalciteChipCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteChipElement;
-  currentTarget: HTMLCalciteChipElement;
+  target: Chip;
+  currentTarget: Chip;
 }
 export interface CalciteChipGroupCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteChipGroupElement;
-  currentTarget: HTMLCalciteChipGroupElement;
+  target: ChipGroup;
+  currentTarget: ChipGroup;
 }
 export interface CalciteColorPickerCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteColorPickerElement;
-  currentTarget: HTMLCalciteColorPickerElement;
+  target: ColorPicker;
+  currentTarget: ColorPicker;
 }
 export interface CalciteColorPickerHexInputCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteColorPickerHexInputElement;
-  currentTarget: HTMLCalciteColorPickerHexInputElement;
+  target: ColorPickerHexInput;
+  currentTarget: ColorPickerHexInput;
 }
 export interface CalciteComboboxCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteComboboxElement;
-  currentTarget: HTMLCalciteComboboxElement;
+  target: Combobox;
+  currentTarget: Combobox;
 }
 export interface CalciteComboboxItemCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteComboboxItemElement;
-  currentTarget: HTMLCalciteComboboxItemElement;
+  target: ComboboxItem;
+  currentTarget: ComboboxItem;
 }
 export interface CalciteDatePickerCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteDatePickerElement;
-  currentTarget: HTMLCalciteDatePickerElement;
+  target: DatePicker;
+  currentTarget: DatePicker;
 }
 export interface CalciteDialogCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteDialogElement;
-  currentTarget: HTMLCalciteDialogElement;
+  target: Dialog;
+  currentTarget: Dialog;
 }
 export interface CalciteDropdownCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteDropdownElement;
-  currentTarget: HTMLCalciteDropdownElement;
+  target: Dropdown;
+  currentTarget: Dropdown;
 }
 export interface CalciteDropdownItemCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteDropdownItemElement;
-  currentTarget: HTMLCalciteDropdownItemElement;
+  target: DropdownItem;
+  currentTarget: DropdownItem;
 }
 export interface CalciteFilterCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteFilterElement;
-  currentTarget: HTMLCalciteFilterElement;
+  target: Filter;
+  currentTarget: Filter;
 }
 export interface CalciteFlowItemCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteFlowItemElement;
-  currentTarget: HTMLCalciteFlowItemElement;
+  target: FlowItem;
+  currentTarget: FlowItem;
 }
 export interface CalciteHandleCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteHandleElement;
-  currentTarget: HTMLCalciteHandleElement;
+  target: Handle;
+  currentTarget: Handle;
 }
 export interface CalciteInlineEditableCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteInlineEditableElement;
-  currentTarget: HTMLCalciteInlineEditableElement;
+  target: InlineEditable;
+  currentTarget: InlineEditable;
 }
 export interface CalciteInputCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteInputElement;
-  currentTarget: HTMLCalciteInputElement;
+  target: Input;
+  currentTarget: Input;
 }
 export interface CalciteInputDatePickerCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteInputDatePickerElement;
-  currentTarget: HTMLCalciteInputDatePickerElement;
+  target: InputDatePicker;
+  currentTarget: InputDatePicker;
 }
 export interface CalciteInputNumberCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteInputNumberElement;
-  currentTarget: HTMLCalciteInputNumberElement;
+  target: InputNumber;
+  currentTarget: InputNumber;
 }
 export interface CalciteInputTextCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteInputTextElement;
-  currentTarget: HTMLCalciteInputTextElement;
+  target: InputText;
+  currentTarget: InputText;
 }
 export interface CalciteInputTimePickerCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteInputTimePickerElement;
-  currentTarget: HTMLCalciteInputTimePickerElement;
+  target: InputTimePicker;
+  currentTarget: InputTimePicker;
 }
 export interface CalciteInputTimeZoneCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteInputTimeZoneElement;
-  currentTarget: HTMLCalciteInputTimeZoneElement;
+  target: InputTimeZone;
+  currentTarget: InputTimeZone;
 }
 export interface CalciteListCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteListElement;
-  currentTarget: HTMLCalciteListElement;
+  target: List;
+  currentTarget: List;
 }
 export interface CalciteListItemCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteListItemElement;
-  currentTarget: HTMLCalciteListItemElement;
+  target: ListItem;
+  currentTarget: ListItem;
 }
 export interface CalciteMenuItemCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteMenuItemElement;
-  currentTarget: HTMLCalciteMenuItemElement;
+  target: MenuItem;
+  currentTarget: MenuItem;
 }
 export interface CalciteNavigationCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteNavigationElement;
-  currentTarget: HTMLCalciteNavigationElement;
+  target: Navigation;
+  currentTarget: Navigation;
 }
 export interface CalciteNoticeCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteNoticeElement;
-  currentTarget: HTMLCalciteNoticeElement;
+  target: Notice;
+  currentTarget: Notice;
 }
 export interface CalcitePaginationCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalcitePaginationElement;
-  currentTarget: HTMLCalcitePaginationElement;
+  target: Pagination;
+  currentTarget: Pagination;
 }
 export interface CalcitePanelCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalcitePanelElement;
-  currentTarget: HTMLCalcitePanelElement;
+  target: Panel;
+  currentTarget: Panel;
 }
 export interface CalcitePopoverCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalcitePopoverElement;
-  currentTarget: HTMLCalcitePopoverElement;
+  target: Popover;
+  currentTarget: Popover;
 }
 export interface CalciteRadioButtonCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteRadioButtonElement;
-  currentTarget: HTMLCalciteRadioButtonElement;
+  target: RadioButton;
+  currentTarget: RadioButton;
 }
 export interface CalciteRadioButtonGroupCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteRadioButtonGroupElement;
-  currentTarget: HTMLCalciteRadioButtonGroupElement;
+  target: RadioButtonGroup;
+  currentTarget: RadioButtonGroup;
 }
 export interface CalciteRatingCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteRatingElement;
-  currentTarget: HTMLCalciteRatingElement;
+  target: Rating;
+  currentTarget: Rating;
 }
 export interface CalciteSegmentedControlCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteSegmentedControlElement;
-  currentTarget: HTMLCalciteSegmentedControlElement;
+  target: SegmentedControl;
+  currentTarget: SegmentedControl;
 }
 export interface CalciteSelectCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteSelectElement;
-  currentTarget: HTMLCalciteSelectElement;
+  target: Select;
+  currentTarget: Select;
 }
 export interface CalciteSheetCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteSheetElement;
-  currentTarget: HTMLCalciteSheetElement;
+  target: Sheet;
+  currentTarget: Sheet;
 }
 export interface CalciteShellPanelCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteShellPanelElement;
-  currentTarget: HTMLCalciteShellPanelElement;
+  target: ShellPanel;
+  currentTarget: ShellPanel;
 }
 export interface CalciteSliderCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteSliderElement;
-  currentTarget: HTMLCalciteSliderElement;
+  target: Slider;
+  currentTarget: Slider;
 }
 export interface CalciteSortHandleCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteSortHandleElement;
-  currentTarget: HTMLCalciteSortHandleElement;
+  target: SortHandle;
+  currentTarget: SortHandle;
 }
 export interface CalciteSortableListCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteSortableListElement;
-  currentTarget: HTMLCalciteSortableListElement;
+  target: SortableList;
+  currentTarget: SortableList;
 }
 export interface CalciteSplitButtonCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteSplitButtonElement;
-  currentTarget: HTMLCalciteSplitButtonElement;
+  target: SplitButton;
+  currentTarget: SplitButton;
 }
 export interface CalciteStepperCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteStepperElement;
-  currentTarget: HTMLCalciteStepperElement;
+  target: Stepper;
+  currentTarget: Stepper;
 }
 export interface CalciteStepperItemCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteStepperItemElement;
-  currentTarget: HTMLCalciteStepperItemElement;
+  target: StepperItem;
+  currentTarget: StepperItem;
 }
 export interface CalciteSwatchCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteSwatchElement;
-  currentTarget: HTMLCalciteSwatchElement;
+  target: Swatch;
+  currentTarget: Swatch;
 }
 export interface CalciteSwatchGroupCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteSwatchGroupElement;
-  currentTarget: HTMLCalciteSwatchGroupElement;
+  target: SwatchGroup;
+  currentTarget: SwatchGroup;
 }
 export interface CalciteSwitchCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteSwitchElement;
-  currentTarget: HTMLCalciteSwitchElement;
+  target: Switch;
+  currentTarget: Switch;
 }
 export interface CalciteTabNavCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteTabNavElement;
-  currentTarget: HTMLCalciteTabNavElement;
+  target: TabNav;
+  currentTarget: TabNav;
 }
 export interface CalciteTabTitleCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteTabTitleElement;
-  currentTarget: HTMLCalciteTabTitleElement;
+  target: TabTitle;
+  currentTarget: TabTitle;
 }
 export interface CalciteTableCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteTableElement;
-  currentTarget: HTMLCalciteTableElement;
+  target: Table;
+  currentTarget: Table;
 }
 export interface CalciteTableRowCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteTableRowElement;
-  currentTarget: HTMLCalciteTableRowElement;
+  target: TableRow;
+  currentTarget: TableRow;
 }
 export interface CalciteTextAreaCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteTextAreaElement;
-  currentTarget: HTMLCalciteTextAreaElement;
+  target: TextArea;
+  currentTarget: TextArea;
 }
 export interface CalciteTileCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteTileElement;
-  currentTarget: HTMLCalciteTileElement;
+  target: Tile;
+  currentTarget: Tile;
 }
 export interface CalciteTileGroupCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteTileGroupElement;
-  currentTarget: HTMLCalciteTileGroupElement;
+  target: TileGroup;
+  currentTarget: TileGroup;
 }
 export interface CalciteTimePickerCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteTimePickerElement;
-  currentTarget: HTMLCalciteTimePickerElement;
+  target: TimePicker;
+  currentTarget: TimePicker;
 }
 export interface CalciteTooltipCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteTooltipElement;
-  currentTarget: HTMLCalciteTooltipElement;
+  target: Tooltip;
+  currentTarget: Tooltip;
 }
 export interface CalciteTreeCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteTreeElement;
-  currentTarget: HTMLCalciteTreeElement;
+  target: Tree;
+  currentTarget: Tree;
 }
 export interface CalciteTreeItemCustomEvent<T> extends CustomEvent<T> {
   detail: T;
-  target: HTMLCalciteTreeItemElement;
-  currentTarget: HTMLCalciteTreeItemElement;
+  target: TreeItem;
+  currentTarget: TreeItem;
 }
 
-export { ToEvents, TargetedEvent } from "@arcgis/lumina";
 
 declare global {
   interface HTMLElementTagNameMap {
-    "calcite-accordion": HTMLCalciteAccordionElement;
-    "calcite-accordion-item": HTMLCalciteAccordionItemElement;
-    "calcite-action": HTMLCalciteActionElement;
-    "calcite-action-bar": HTMLCalciteActionBarElement;
-    "calcite-action-group": HTMLCalciteActionGroupElement;
-    "calcite-action-menu": HTMLCalciteActionMenuElement;
-    "calcite-action-pad": HTMLCalciteActionPadElement;
-    "calcite-alert": HTMLCalciteAlertElement;
-    "calcite-autocomplete": HTMLCalciteAutocompleteElement;
-    "calcite-autocomplete-item": HTMLCalciteAutocompleteItemElement;
-    "calcite-autocomplete-item-group": HTMLCalciteAutocompleteItemGroupElement;
-    "calcite-avatar": HTMLCalciteAvatarElement;
-    "calcite-block": HTMLCalciteBlockElement;
-    "calcite-block-group": HTMLCalciteBlockGroupElement;
-    "calcite-block-section": HTMLCalciteBlockSectionElement;
-    "calcite-button": HTMLCalciteButtonElement;
-    "calcite-card": HTMLCalciteCardElement;
-    "calcite-card-group": HTMLCalciteCardGroupElement;
-    "calcite-carousel": HTMLCalciteCarouselElement;
-    "calcite-carousel-item": HTMLCalciteCarouselItemElement;
-    "calcite-checkbox": HTMLCalciteCheckboxElement;
-    "calcite-chip": HTMLCalciteChipElement;
-    "calcite-chip-group": HTMLCalciteChipGroupElement;
-    "calcite-color-picker": HTMLCalciteColorPickerElement;
-    "calcite-color-picker-hex-input": HTMLCalciteColorPickerHexInputElement;
-    "calcite-color-picker-swatch": HTMLCalciteColorPickerSwatchElement;
-    "calcite-combobox": HTMLCalciteComboboxElement;
-    "calcite-combobox-item": HTMLCalciteComboboxItemElement;
-    "calcite-combobox-item-group": HTMLCalciteComboboxItemGroupElement;
-    "calcite-date-picker": HTMLCalciteDatePickerElement;
-    "calcite-date-picker-day": HTMLCalciteDatePickerDayElement;
-    "calcite-date-picker-month": HTMLCalciteDatePickerMonthElement;
-    "calcite-date-picker-month-header": HTMLCalciteDatePickerMonthHeaderElement;
-    "calcite-dialog": HTMLCalciteDialogElement;
-    "calcite-dropdown": HTMLCalciteDropdownElement;
-    "calcite-dropdown-group": HTMLCalciteDropdownGroupElement;
-    "calcite-dropdown-item": HTMLCalciteDropdownItemElement;
-    "calcite-fab": HTMLCalciteFabElement;
-    "calcite-filter": HTMLCalciteFilterElement;
-    "calcite-flow": HTMLCalciteFlowElement;
-    "calcite-flow-item": HTMLCalciteFlowItemElement;
-    "calcite-graph": HTMLCalciteGraphElement;
-    "calcite-handle": HTMLCalciteHandleElement;
-    "calcite-icon": HTMLCalciteIconElement;
-    "calcite-inline-editable": HTMLCalciteInlineEditableElement;
-    "calcite-input": HTMLCalciteInputElement;
-    "calcite-input-date-picker": HTMLCalciteInputDatePickerElement;
-    "calcite-input-message": HTMLCalciteInputMessageElement;
-    "calcite-input-number": HTMLCalciteInputNumberElement;
-    "calcite-input-text": HTMLCalciteInputTextElement;
-    "calcite-input-time-picker": HTMLCalciteInputTimePickerElement;
-    "calcite-input-time-zone": HTMLCalciteInputTimeZoneElement;
-    "calcite-label": HTMLCalciteLabelElement;
-    "calcite-link": HTMLCalciteLinkElement;
-    "calcite-list": HTMLCalciteListElement;
-    "calcite-list-item": HTMLCalciteListItemElement;
-    "calcite-list-item-group": HTMLCalciteListItemGroupElement;
-    "calcite-loader": HTMLCalciteLoaderElement;
-    "calcite-menu": HTMLCalciteMenuElement;
-    "calcite-menu-item": HTMLCalciteMenuItemElement;
-    "calcite-meter": HTMLCalciteMeterElement;
-    "calcite-navigation": HTMLCalciteNavigationElement;
-    "calcite-navigation-logo": HTMLCalciteNavigationLogoElement;
-    "calcite-navigation-user": HTMLCalciteNavigationUserElement;
-    "calcite-notice": HTMLCalciteNoticeElement;
-    "calcite-option": HTMLCalciteOptionElement;
-    "calcite-option-group": HTMLCalciteOptionGroupElement;
-    "calcite-pagination": HTMLCalcitePaginationElement;
-    "calcite-panel": HTMLCalcitePanelElement;
-    "calcite-popover": HTMLCalcitePopoverElement;
-    "calcite-progress": HTMLCalciteProgressElement;
-    "calcite-radio-button": HTMLCalciteRadioButtonElement;
-    "calcite-radio-button-group": HTMLCalciteRadioButtonGroupElement;
-    "calcite-rating": HTMLCalciteRatingElement;
-    "calcite-scrim": HTMLCalciteScrimElement;
-    "calcite-segmented-control": HTMLCalciteSegmentedControlElement;
-    "calcite-segmented-control-item": HTMLCalciteSegmentedControlItemElement;
-    "calcite-select": HTMLCalciteSelectElement;
-    "calcite-sheet": HTMLCalciteSheetElement;
-    "calcite-shell": HTMLCalciteShellElement;
-    "calcite-shell-panel": HTMLCalciteShellPanelElement;
-    "calcite-slider": HTMLCalciteSliderElement;
-    "calcite-sort-handle": HTMLCalciteSortHandleElement;
-    "calcite-sortable-list": HTMLCalciteSortableListElement;
-    "calcite-split-button": HTMLCalciteSplitButtonElement;
-    "calcite-stack": HTMLCalciteStackElement;
-    "calcite-stepper": HTMLCalciteStepperElement;
-    "calcite-stepper-item": HTMLCalciteStepperItemElement;
-    "calcite-swatch": HTMLCalciteSwatchElement;
-    "calcite-swatch-group": HTMLCalciteSwatchGroupElement;
-    "calcite-switch": HTMLCalciteSwitchElement;
-    "calcite-tab": HTMLCalciteTabElement;
-    "calcite-tab-nav": HTMLCalciteTabNavElement;
-    "calcite-tab-title": HTMLCalciteTabTitleElement;
-    "calcite-table": HTMLCalciteTableElement;
-    "calcite-table-cell": HTMLCalciteTableCellElement;
-    "calcite-table-header": HTMLCalciteTableHeaderElement;
-    "calcite-table-row": HTMLCalciteTableRowElement;
-    "calcite-tabs": HTMLCalciteTabsElement;
-    "calcite-text-area": HTMLCalciteTextAreaElement;
-    "calcite-tile": HTMLCalciteTileElement;
-    "calcite-tile-group": HTMLCalciteTileGroupElement;
-    "calcite-time-picker": HTMLCalciteTimePickerElement;
-    "calcite-tooltip": HTMLCalciteTooltipElement;
-    "calcite-tree": HTMLCalciteTreeElement;
-    "calcite-tree-item": HTMLCalciteTreeItemElement;
-  }
+    "calcite-accordion": Accordion;
+    "calcite-accordion-item": AccordionItem;
+    "calcite-action": Action;
+    "calcite-action-bar": ActionBar;
+    "calcite-action-group": ActionGroup;
+    "calcite-action-menu": ActionMenu;
+    "calcite-action-pad": ActionPad;
+    "calcite-alert": Alert;
+    "calcite-autocomplete": Autocomplete;
+    "calcite-autocomplete-item": AutocompleteItem;
+    "calcite-autocomplete-item-group": AutocompleteItemGroup;
+    "calcite-avatar": Avatar;
+    "calcite-block": Block;
+    "calcite-block-group": BlockGroup;
+    "calcite-block-section": BlockSection;
+    "calcite-button": Button;
+    "calcite-card": Card;
+    "calcite-card-group": CardGroup;
+    "calcite-carousel": Carousel;
+    "calcite-carousel-item": CarouselItem;
+    "calcite-checkbox": Checkbox;
+    "calcite-chip": Chip;
+    "calcite-chip-group": ChipGroup;
+    "calcite-color-picker": ColorPicker;
+    "calcite-color-picker-hex-input": ColorPickerHexInput;
+    "calcite-color-picker-swatch": ColorPickerSwatch;
+    "calcite-combobox": Combobox;
+    "calcite-combobox-item": ComboboxItem;
+    "calcite-combobox-item-group": ComboboxItemGroup;
+    "calcite-date-picker": DatePicker;
+    "calcite-date-picker-day": DatePickerDay;
+    "calcite-date-picker-month": DatePickerMonth;
+    "calcite-dialog": Dialog;
+    "calcite-dropdown": Dropdown;
+    "calcite-dropdown-group": DropdownGroup;
+    "calcite-dropdown-item": DropdownItem;
+    "calcite-fab": Fab;
+    "calcite-filter": Filter;
+    "calcite-flow": Flow;
+    "calcite-flow-item": FlowItem;
+    "calcite-graph": Graph;
+    "calcite-handle": Handle;
+    "calcite-icon": Icon;
+    "calcite-inline-editable": InlineEditable;
+    "calcite-input": Input;
+    "calcite-input-date-picker": InputDatePicker;
+    "calcite-input-message": InputMessage;
+    "calcite-input-number": InputNumber;
+    "calcite-input-text": InputText;
+    "calcite-input-time-picker": InputTimePicker;
+    "calcite-input-time-zone": InputTimeZone;
+    "calcite-label": Label;
+    "calcite-link": Link;
+    "calcite-list": List;
+    "calcite-list-item": ListItem;
+    "calcite-list-item-group": ListItemGroup;
+    "calcite-loader": Loader;
+    "calcite-menu": Menu;
+    "calcite-menu-item": MenuItem;
+    "calcite-meter": Meter;
+    "calcite-navigation": Navigation;
+    "calcite-navigation-logo": NavigationLogo;
+    "calcite-navigation-user": NavigationUser;
+    "calcite-notice": Notice;
+    "calcite-option": Option;
+    "calcite-option-group": OptionGroup;
+    "calcite-pagination": Pagination;
+    "calcite-panel": Panel;
+    "calcite-popover": Popover;
+    "calcite-progress": Progress;
+    "calcite-radio-button": RadioButton;
+    "calcite-radio-button-group": RadioButtonGroup;
+    "calcite-rating": Rating;
+    "calcite-scrim": Scrim;
+    "calcite-segmented-control": SegmentedControl;
+    "calcite-segmented-control-item": SegmentedControlItem;
+    "calcite-select": Select;
+    "calcite-sheet": Sheet;
+    "calcite-shell": Shell;
+    "calcite-shell-panel": ShellPanel;
+    "calcite-slider": Slider;
+    "calcite-sort-handle": SortHandle;
+    "calcite-sortable-list": SortableList;
+    "calcite-split-button": SplitButton;
+    "calcite-stack": Stack;
+    "calcite-stepper": Stepper;
+    "calcite-stepper-item": StepperItem;
+    "calcite-swatch": Swatch;
+    "calcite-swatch-group": SwatchGroup;
+    "calcite-switch": Switch;
+    "calcite-tab": Tab;
+    "calcite-tab-nav": TabNav;
+    "calcite-tab-title": TabTitle;
+    "calcite-table": Table;
+    "calcite-table-cell": TableCell;
+    "calcite-table-header": TableHeader;
+    "calcite-table-row": TableRow;
+    "calcite-tabs": Tabs;
+    "calcite-text-area": TextArea;
+    "calcite-tile": Tile;
+    "calcite-tile-group": TileGroup;
+    "calcite-time-picker": TimePicker;
+    "calcite-tooltip": Tooltip;
+    "calcite-tree": Tree;
+    "calcite-tree-item": TreeItem;
+
+  }
+
+  type HTMLCalciteAccordionElement = Accordion;
+
+  type HTMLCalciteAccordionItemElementEventMap = AccordionItem["@eventTypes"];
+  type HTMLCalciteAccordionItemElement = AccordionItem;
+
+  type HTMLCalciteActionElementEventMap = Action["@eventTypes"];
+  type HTMLCalciteActionElement = Action;
+
+  type HTMLCalciteActionBarElementEventMap = ActionBar["@eventTypes"];
+  type HTMLCalciteActionBarElement = ActionBar;
+
+  type HTMLCalciteActionGroupElementEventMap = ActionGroup["@eventTypes"];
+  type HTMLCalciteActionGroupElement = ActionGroup;
+
+  type HTMLCalciteActionMenuElementEventMap = ActionMenu["@eventTypes"];
+  type HTMLCalciteActionMenuElement = ActionMenu;
+
+  type HTMLCalciteActionPadElementEventMap = ActionPad["@eventTypes"];
+  type HTMLCalciteActionPadElement = ActionPad;
+
+  type HTMLCalciteAlertElementEventMap = Alert["@eventTypes"];
+  type HTMLCalciteAlertElement = Alert;
+
+  type HTMLCalciteAutocompleteElementEventMap = Autocomplete["@eventTypes"];
+  type HTMLCalciteAutocompleteElement = Autocomplete;
 
-  interface HTMLCalciteAccordionElement extends Accordion {
+  type HTMLCalciteAutocompleteItemElementEventMap = AutocompleteItem["@eventTypes"];
+  type HTMLCalciteAutocompleteItemElement = AutocompleteItem;
 
-  }
-  interface HTMLCalciteAccordionItemElementEventMap {
-    "calciteAccordionItemCollapse": AccordionItem["calciteAccordionItemCollapse"]["detail"];
-    "calciteAccordionItemExpand": AccordionItem["calciteAccordionItemExpand"]["detail"];
-  }
+  type HTMLCalciteAutocompleteItemGroupElement = AutocompleteItemGroup;
 
-  interface HTMLCalciteAccordionItemElement extends AccordionItem {
-    addEventListener<K extends keyof HTMLCalciteAccordionItemElementEventMap>(type: K, listener: (this: HTMLCalciteAccordionItemElement, ev: CalciteAccordionItemCustomEvent<HTMLCalciteAccordionItemElementEventMap[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 HTMLCalciteAccordionItemElementEventMap>(type: K, listener: (this: HTMLCalciteAccordionItemElement, ev: CalciteAccordionItemCustomEvent<HTMLCalciteAccordionItemElementEventMap[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 HTMLCalciteActionElement extends Action {
+  type HTMLCalciteAvatarElement = Avatar;
 
-  }
-  interface HTMLCalciteActionBarElementEventMap {
-    "calciteActionBarCollapse": ActionBar["calciteActionBarCollapse"]["detail"];
-    "calciteActionBarExpand": ActionBar["calciteActionBarExpand"]["detail"];
-    "calciteActionBarToggle": ActionBar["calciteActionBarToggle"]["detail"];
-  }
+  type HTMLCalciteBlockElementEventMap = Block["@eventTypes"];
+  type HTMLCalciteBlockElement = Block;
 
-  interface HTMLCalciteActionBarElement extends ActionBar {
-    addEventListener<K extends keyof HTMLCalciteActionBarElementEventMap>(type: K, listener: (this: HTMLCalciteActionBarElement, ev: CalciteActionBarCustomEvent<HTMLCalciteActionBarElementEventMap[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 HTMLCalciteActionBarElementEventMap>(type: K, listener: (this: HTMLCalciteActionBarElement, ev: CalciteActionBarCustomEvent<HTMLCalciteActionBarElementEventMap[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 HTMLCalciteActionGroupElementEventMap {
-    "calciteActionGroupCollapse": ActionGroup["calciteActionGroupCollapse"]["detail"];
-    "calciteActionGroupExpand": ActionGroup["calciteActionGroupExpand"]["detail"];
-  }
+  type HTMLCalciteBlockGroupElementEventMap = BlockGroup["@eventTypes"];
+  type HTMLCalciteBlockGroupElement = BlockGroup;
 
-  interface HTMLCalciteActionGroupElement extends ActionGroup {
-    addEventListener<K extends keyof HTMLCalciteActionGroupElementEventMap>(type: K, listener: (this: HTMLCalciteActionGroupElement, ev: CalciteActionGroupCustomEvent<HTMLCalciteActionGroupElementEventMap[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 HTMLCalciteActionGroupElementEventMap>(type: K, listener: (this: HTMLCalciteActionGroupElement, ev: CalciteActionGroupCustomEvent<HTMLCalciteActionGroupElementEventMap[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 HTMLCalciteActionMenuElementEventMap {
-    "calciteActionMenuCollapse": ActionMenu["calciteActionMenuCollapse"]["detail"];
-    "calciteActionMenuExpand": ActionMenu["calciteActionMenuExpand"]["detail"];
-    "calciteActionMenuOpen": ActionMenu["calciteActionMenuOpen"]["detail"];
-  }
+  type HTMLCalciteBlockSectionElementEventMap = BlockSection["@eventTypes"];
+  type HTMLCalciteBlockSectionElement = BlockSection;
 
-  interface HTMLCalciteActionMenuElement extends ActionMenu {
-    addEventListener<K extends keyof HTMLCalciteActionMenuElementEventMap>(type: K, listener: (this: HTMLCalciteActionMenuElement, ev: CalciteActionMenuCustomEvent<HTMLCalciteActionMenuElementEventMap[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 HTMLCalciteActionMenuElementEventMap>(type: K, listener: (this: HTMLCalciteActionMenuElement, ev: CalciteActionMenuCustomEvent<HTMLCalciteActionMenuElementEventMap[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 HTMLCalciteActionPadElementEventMap {
-    "calciteActionPadCollapse": ActionPad["calciteActionPadCollapse"]["detail"];
-    "calciteActionPadExpand": ActionPad["calciteActionPadExpand"]["detail"];
-    "calciteActionPadToggle": ActionPad["calciteActionPadToggle"]["detail"];
-  }
+  type HTMLCalciteButtonElement = Button;
 
-  interface HTMLCalciteActionPadElement extends ActionPad {
-    addEventListener<K extends keyof HTMLCalciteActionPadElementEventMap>(type: K, listener: (this: HTMLCalciteActionPadElement, ev: CalciteActionPadCustomEvent<HTMLCalciteActionPadElementEventMap[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 HTMLCalciteActionPadElementEventMap>(type: K, listener: (this: HTMLCalciteActionPadElement, ev: CalciteActionPadCustomEvent<HTMLCalciteActionPadElementEventMap[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 HTMLCalciteAlertElementEventMap {
-    "calciteAlertBeforeClose": Alert["calciteAlertBeforeClose"]["detail"];
-    "calciteAlertBeforeOpen": Alert["calciteAlertBeforeOpen"]["detail"];
-    "calciteAlertClose": Alert["calciteAlertClose"]["detail"];
-    "calciteAlertOpen": Alert["calciteAlertOpen"]["detail"];
-  }
+  type HTMLCalciteCardElementEventMap = Card["@eventTypes"];
+  type HTMLCalciteCardElement = Card;
 
-  interface HTMLCalciteAlertElement extends Alert {
-    addEventListener<K extends keyof HTMLCalciteAlertElementEventMap>(type: K, listener: (this: HTMLCalciteAlertElement, ev: CalciteAlertCustomEvent<HTMLCalciteAlertElementEventMap[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 HTMLCalciteAlertElementEventMap>(type: K, listener: (this: HTMLCalciteAlertElement, ev: CalciteAlertCustomEvent<HTMLCalciteAlertElementEventMap[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 HTMLCalciteAutocompleteElementEventMap {
-    "calciteAutocompleteBeforeClose": Autocomplete["calciteAutocompleteBeforeClose"]["detail"];
-    "calciteAutocompleteBeforeOpen": Autocomplete["calciteAutocompleteBeforeOpen"]["detail"];
-    "calciteAutocompleteChange": Autocomplete["calciteAutocompleteChange"]["detail"];
-    "calciteAutocompleteClose": Autocomplete["calciteAutocompleteClose"]["detail"];
-    "calciteAutocompleteOpen": Autocomplete["calciteAutocompleteOpen"]["detail"];
-    "calciteAutocompleteTextChange": Autocomplete["calciteAutocompleteTextChange"]["detail"];
-    "calciteAutocompleteTextInput": Autocomplete["calciteAutocompleteTextInput"]["detail"];
-  }
+  type HTMLCalciteCardGroupElementEventMap = CardGroup["@eventTypes"];
+  type HTMLCalciteCardGroupElement = CardGroup;
 
-  interface HTMLCalciteAutocompleteElement extends Autocomplete {
-    addEventListener<K extends keyof HTMLCalciteAutocompleteElementEventMap>(type: K, listener: (this: HTMLCalciteAutocompleteElement, ev: CalciteAutocompleteCustomEvent<HTMLCalciteAutocompleteElementEventMap[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 HTMLCalciteAutocompleteElementEventMap>(type: K, listener: (this: HTMLCalciteAutocompleteElement, ev: CalciteAutocompleteCustomEvent<HTMLCalciteAutocompleteElementEventMap[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 HTMLCalciteAutocompleteItemElementEventMap {
-    "calciteAutocompleteItemSelect": AutocompleteItem["calciteAutocompleteItemSelect"]["detail"];
-  }
+  type HTMLCalciteCarouselElementEventMap = Carousel["@eventTypes"];
+  type HTMLCalciteCarouselElement = Carousel;
 
-  interface HTMLCalciteAutocompleteItemElement extends AutocompleteItem {
-    addEventListener<K extends keyof HTMLCalciteAutocompleteItemElementEventMap>(type: K, listener: (this: HTMLCalciteAutocompleteItemElement, ev: CalciteAutocompleteItemCustomEvent<HTMLCalciteAutocompleteItemElementEventMap[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 HTMLCalciteAutocompleteItemElementEventMap>(type: K, listener: (this: HTMLCalciteAutocompleteItemElement, ev: CalciteAutocompleteItemCustomEvent<HTMLCalciteAutocompleteItemElementEventMap[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 HTMLCalciteAutocompleteItemGroupElement extends AutocompleteItemGroup {
+  type HTMLCalciteCarouselItemElement = CarouselItem;
 
-  }
-  interface HTMLCalciteAvatarElement extends Avatar {
+  type HTMLCalciteCheckboxElementEventMap = Checkbox["@eventTypes"];
+  type HTMLCalciteCheckboxElement = Checkbox;
 
-  }
-  interface HTMLCalciteBlockElementEventMap {
-    "calciteBlockBeforeClose": Block["calciteBlockBeforeClose"]["detail"];
-    "calciteBlockBeforeOpen": Block["calciteBlockBeforeOpen"]["detail"];
-    "calciteBlockClose": Block["calciteBlockClose"]["detail"];
-    "calciteBlockCollapse": Block["calciteBlockCollapse"]["detail"];
-    "calciteBlockExpand": Block["calciteBlockExpand"]["detail"];
-    "calciteBlockOpen": Block["calciteBlockOpen"]["detail"];
-    "calciteBlockSortHandleBeforeClose": Block["calciteBlockSortHandleBeforeClose"]["detail"];
-    "calciteBlockSortHandleBeforeOpen": Block["calciteBlockSortHandleBeforeOpen"]["detail"];
-    "calciteBlockSortHandleClose": Block["calciteBlockSortHandleClose"]["detail"];
-    "calciteBlockSortHandleOpen": Block["calciteBlockSortHandleOpen"]["detail"];
-    "calciteBlockToggle": Block["calciteBlockToggle"]["detail"];
-  }
+  type HTMLCalciteChipElementEventMap = Chip["@eventTypes"];
+  type HTMLCalciteChipElement = Chip;
 
-  interface HTMLCalciteBlockElement extends Block {
-    addEventListener<K extends keyof HTMLCalciteBlockElementEventMap>(type: K, listener: (this: HTMLCalciteBlockElement, ev: CalciteBlockCustomEvent<HTMLCalciteBlockElementEventMap[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 HTMLCalciteBlockElementEventMap>(type: K, listener: (this: HTMLCalciteBlockElement, ev: CalciteBlockCustomEvent<HTMLCalciteBlockElementEventMap[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 HTMLCalciteBlockGroupElementEventMap {
-    "calciteBlockGroupDragEnd": BlockGroup["calciteBlockGroupDragEnd"]["detail"];
-    "calciteBlockGroupDragStart": BlockGroup["calciteBlockGroupDragStart"]["detail"];
-    "calciteBlockGroupMoveHalt": BlockGroup["calciteBlockGroupMoveHalt"]["detail"];
-    "calciteBlockGroupOrderChange": BlockGroup["calciteBlockGroupOrderChange"]["detail"];
-  }
+  type HTMLCalciteChipGroupElementEventMap = ChipGroup["@eventTypes"];
+  type HTMLCalciteChipGroupElement = ChipGroup;
 
-  interface HTMLCalciteBlockGroupElement extends BlockGroup {
-    addEventListener<K extends keyof HTMLCalciteBlockGroupElementEventMap>(type: K, listener: (this: HTMLCalciteBlockGroupElement, ev: CalciteBlockGroupCustomEvent<HTMLCalciteBlockGroupElementEventMap[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 HTMLCalciteBlockGroupElementEventMap>(type: K, listener: (this: HTMLCalciteBlockGroupElement, ev: CalciteBlockGroupCustomEvent<HTMLCalciteBlockGroupElementEventMap[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 HTMLCalciteBlockSectionElementEventMap {
-    "calciteBlockSectionCollapse": BlockSection["calciteBlockSectionCollapse"]["detail"];
-    "calciteBlockSectionExpand": BlockSection["calciteBlockSectionExpand"]["detail"];
-    "calciteBlockSectionToggle": BlockSection["calciteBlockSectionToggle"]["detail"];
-  }
+  type HTMLCalciteColorPickerElementEventMap = ColorPicker["@eventTypes"];
+  type HTMLCalciteColorPickerElement = ColorPicker;
 
-  interface HTMLCalciteBlockSectionElement extends BlockSection {
-    addEventListener<K extends keyof HTMLCalciteBlockSectionElementEventMap>(type: K, listener: (this: HTMLCalciteBlockSectionElement, ev: CalciteBlockSectionCustomEvent<HTMLCalciteBlockSectionElementEventMap[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 HTMLCalciteBlockSectionElementEventMap>(type: K, listener: (this: HTMLCalciteBlockSectionElement, ev: CalciteBlockSectionCustomEvent<HTMLCalciteBlockSectionElementEventMap[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 HTMLCalciteButtonElement extends Button {
+  type HTMLCalciteColorPickerHexInputElementEventMap = ColorPickerHexInput["@eventTypes"];
+  type HTMLCalciteColorPickerHexInputElement = ColorPickerHexInput;
 
-  }
-  interface HTMLCalciteCardElementEventMap {
-    "calciteCardSelect": Card["calciteCardSelect"]["detail"];
-  }
+  type HTMLCalciteColorPickerSwatchElement = ColorPickerSwatch;
 
-  interface HTMLCalciteCardElement extends Card {
-    addEventListener<K extends keyof HTMLCalciteCardElementEventMap>(type: K, listener: (this: HTMLCalciteCardElement, ev: CalciteCardCustomEvent<HTMLCalciteCardElementEventMap[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 HTMLCalciteCardElementEventMap>(type: K, listener: (this: HTMLCalciteCardElement, ev: CalciteCardCustomEvent<HTMLCalciteCardElementEventMap[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 HTMLCalciteCardGroupElementEventMap {
-    "calciteCardGroupSelect": CardGroup["calciteCardGroupSelect"]["detail"];
-  }
+  type HTMLCalciteComboboxElementEventMap = Combobox["@eventTypes"];
+  type HTMLCalciteComboboxElement = Combobox;
 
-  interface HTMLCalciteCardGroupElement extends CardGroup {
-    addEventListener<K extends keyof HTMLCalciteCardGroupElementEventMap>(type: K, listener: (this: HTMLCalciteCardGroupElement, ev: CalciteCardGroupCustomEvent<HTMLCalciteCardGroupElementEventMap[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 HTMLCalciteCardGroupElementEventMap>(type: K, listener: (this: HTMLCalciteCardGroupElement, ev: CalciteCardGroupCustomEvent<HTMLCalciteCardGroupElementEventMap[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 HTMLCalciteCarouselElementEventMap {
-    "calciteCarouselChange": Carousel["calciteCarouselChange"]["detail"];
-    "calciteCarouselPause": Carousel["calciteCarouselPause"]["detail"];
-    "calciteCarouselPlay": Carousel["calciteCarouselPlay"]["detail"];
-    "calciteCarouselResume": Carousel["calciteCarouselResume"]["detail"];
-    "calciteCarouselStop": Carousel["calciteCarouselStop"]["detail"];
-  }
+  type HTMLCalciteComboboxItemElementEventMap = ComboboxItem["@eventTypes"];
+  type HTMLCalciteComboboxItemElement = ComboboxItem;
 
-  interface HTMLCalciteCarouselElement extends Carousel {
-    addEventListener<K extends keyof HTMLCalciteCarouselElementEventMap>(type: K, listener: (this: HTMLCalciteCarouselElement, ev: CalciteCarouselCustomEvent<HTMLCalciteCarouselElementEventMap[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 HTMLCalciteCarouselElementEventMap>(type: K, listener: (this: HTMLCalciteCarouselElement, ev: CalciteCarouselCustomEvent<HTMLCalciteCarouselElementEventMap[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 HTMLCalciteCarouselItemElement extends CarouselItem {
+  type HTMLCalciteComboboxItemGroupElement = ComboboxItemGroup;
 
-  }
-  interface HTMLCalciteCheckboxElementEventMap {
-    "calciteCheckboxChange": Checkbox["calciteCheckboxChange"]["detail"];
-  }
+  type HTMLCalciteDatePickerElementEventMap = DatePicker["@eventTypes"];
+  type HTMLCalciteDatePickerElement = DatePicker;
 
-  interface HTMLCalciteCheckboxElement extends Checkbox {
-    addEventListener<K extends keyof HTMLCalciteCheckboxElementEventMap>(type: K, listener: (this: HTMLCalciteCheckboxElement, ev: CalciteCheckboxCustomEvent<HTMLCalciteCheckboxElementEventMap[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 HTMLCalciteCheckboxElementEventMap>(type: K, listener: (this: HTMLCalciteCheckboxElement, ev: CalciteCheckboxCustomEvent<HTMLCalciteCheckboxElementEventMap[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 HTMLCalciteChipElementEventMap {
-    "calciteChipClose": Chip["calciteChipClose"]["detail"];
-    "calciteChipSelect": Chip["calciteChipSelect"]["detail"];
-  }
+  type HTMLCalciteDatePickerDayElement = DatePickerDay;
 
-  interface HTMLCalciteChipElement extends Chip {
-    addEventListener<K extends keyof HTMLCalciteChipElementEventMap>(type: K, listener: (this: HTMLCalciteChipElement, ev: CalciteChipCustomEvent<HTMLCalciteChipElementEventMap[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 HTMLCalciteChipElementEventMap>(type: K, listener: (this: HTMLCalciteChipElement, ev: CalciteChipCustomEvent<HTMLCalciteChipElementEventMap[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 HTMLCalciteChipGroupElementEventMap {
-    "calciteChipGroupSelect": ChipGroup["calciteChipGroupSelect"]["detail"];
-  }
+  type HTMLCalciteDatePickerMonthElement = DatePickerMonth;
 
-  interface HTMLCalciteChipGroupElement extends ChipGroup {
-    addEventListener<K extends keyof HTMLCalciteChipGroupElementEventMap>(type: K, listener: (this: HTMLCalciteChipGroupElement, ev: CalciteChipGroupCustomEvent<HTMLCalciteChipGroupElementEventMap[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 HTMLCalciteChipGroupElementEventMap>(type: K, listener: (this: HTMLCalciteChipGroupElement, ev: CalciteChipGroupCustomEvent<HTMLCalciteChipGroupElementEventMap[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 HTMLCalciteColorPickerElementEventMap {
-    "calciteColorPickerChange": ColorPicker["calciteColorPickerChange"]["detail"];
-    "calciteColorPickerInput": ColorPicker["calciteColorPickerInput"]["detail"];
-  }
+  type HTMLCalciteDialogElementEventMap = Dialog["@eventTypes"];
+  type HTMLCalciteDialogElement = Dialog;
 
-  interface HTMLCalciteColorPickerElement extends ColorPicker {
-    addEventListener<K extends keyof HTMLCalciteColorPickerElementEventMap>(type: K, listener: (this: HTMLCalciteColorPickerElement, ev: CalciteColorPickerCustomEvent<HTMLCalciteColorPickerElementEventMap[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 HTMLCalciteColorPickerElementEventMap>(type: K, listener: (this: HTMLCalciteColorPickerElement, ev: CalciteColorPickerCustomEvent<HTMLCalciteColorPickerElementEventMap[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 HTMLCalciteColorPickerHexInputElementEventMap {
-    "calciteColorPickerHexInputChange": ColorPickerHexInput["calciteColorPickerHexInputChange"]["detail"];
-  }
+  type HTMLCalciteDropdownElementEventMap = Dropdown["@eventTypes"];
+  type HTMLCalciteDropdownElement = Dropdown;
 
-  interface HTMLCalciteColorPickerHexInputElement extends ColorPickerHexInput {
-    addEventListener<K extends keyof HTMLCalciteColorPickerHexInputElementEventMap>(type: K, listener: (this: HTMLCalciteColorPickerHexInputElement, ev: CalciteColorPickerHexInputCustomEvent<HTMLCalciteColorPickerHexInputElementEventMap[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 HTMLCalciteColorPickerHexInputElementEventMap>(type: K, listener: (this: HTMLCalciteColorPickerHexInputElement, ev: CalciteColorPickerHexInputCustomEvent<HTMLCalciteColorPickerHexInputElementEventMap[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 HTMLCalciteColorPickerSwatchElement extends ColorPickerSwatch {
+  type HTMLCalciteDropdownGroupElement = DropdownGroup;
 
-  }
-  interface HTMLCalciteComboboxElementEventMap {
-    "calciteComboboxBeforeClose": Combobox["calciteComboboxBeforeClose"]["detail"];
-    "calciteComboboxBeforeOpen": Combobox["calciteComboboxBeforeOpen"]["detail"];
-    "calciteComboboxChange": Combobox["calciteComboboxChange"]["detail"];
-    "calciteComboboxChipClose": Combobox["calciteComboboxChipClose"]["detail"];
-    "calciteComboboxClose": Combobox["calciteComboboxClose"]["detail"];
-    "calciteComboboxFilterChange": Combobox["calciteComboboxFilterChange"]["detail"];
-    "calciteComboboxOpen": Combobox["calciteComboboxOpen"]["detail"];
-  }
+  type HTMLCalciteDropdownItemElementEventMap = DropdownItem["@eventTypes"];
+  type HTMLCalciteDropdownItemElement = DropdownItem;
 
-  interface HTMLCalciteComboboxElement extends Combobox {
-    addEventListener<K extends keyof HTMLCalciteComboboxElementEventMap>(type: K, listener: (this: HTMLCalciteComboboxElement, ev: CalciteComboboxCustomEvent<HTMLCalciteComboboxElementEventMap[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 HTMLCalciteComboboxElementEventMap>(type: K, listener: (this: HTMLCalciteComboboxElement, ev: CalciteComboboxCustomEvent<HTMLCalciteComboboxElementEventMap[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 HTMLCalciteComboboxItemElementEventMap {
-    "calciteComboboxItemChange": ComboboxItem["calciteComboboxItemChange"]["detail"];
-  }
+  type HTMLCalciteFabElement = Fab;
 
-  interface HTMLCalciteComboboxItemElement extends ComboboxItem {
-    addEventListener<K extends keyof HTMLCalciteComboboxItemElementEventMap>(type: K, listener: (this: HTMLCalciteComboboxItemElement, ev: CalciteComboboxItemCustomEvent<HTMLCalciteComboboxItemElementEventMap[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 HTMLCalciteComboboxItemElementEventMap>(type: K, listener: (this: HTMLCalciteComboboxItemElement, ev: CalciteComboboxItemCustomEvent<HTMLCalciteComboboxItemElementEventMap[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 HTMLCalciteComboboxItemGroupElement extends ComboboxItemGroup {
+  type HTMLCalciteFilterElementEventMap = Filter["@eventTypes"];
+  type HTMLCalciteFilterElement = Filter;
 
-  }
-  interface HTMLCalciteDatePickerElementEventMap {
-    "calciteDatePickerChange": DatePicker["calciteDatePickerChange"]["detail"];
-    "calciteDatePickerRangeChange": DatePicker["calciteDatePickerRangeChange"]["detail"];
-  }
+  type HTMLCalciteFlowElement = Flow;
 
-  interface HTMLCalciteDatePickerElement extends DatePicker {
-    addEventListener<K extends keyof HTMLCalciteDatePickerElementEventMap>(type: K, listener: (this: HTMLCalciteDatePickerElement, ev: CalciteDatePickerCustomEvent<HTMLCalciteDatePickerElementEventMap[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 HTMLCalciteDatePickerElementEventMap>(type: K, listener: (this: HTMLCalciteDatePickerElement, ev: CalciteDatePickerCustomEvent<HTMLCalciteDatePickerElementEventMap[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 HTMLCalciteDatePickerDayElement extends DatePickerDay {
+  type HTMLCalciteFlowItemElementEventMap = FlowItem["@eventTypes"];
+  type HTMLCalciteFlowItemElement = FlowItem;
 
-  }
-  interface HTMLCalciteDatePickerMonthElement extends DatePickerMonth {
+  type HTMLCalciteGraphElement = Graph;
 
-  }
-  interface HTMLCalciteDatePickerMonthHeaderElement extends DatePickerMonthHeader {
+  type HTMLCalciteHandleElementEventMap = Handle["@eventTypes"];
+  type HTMLCalciteHandleElement = Handle;
 
-  }
-  interface HTMLCalciteDialogElementEventMap {
-    "calciteDialogBeforeClose": Dialog["calciteDialogBeforeClose"]["detail"];
-    "calciteDialogBeforeOpen": Dialog["calciteDialogBeforeOpen"]["detail"];
-    "calciteDialogClose": Dialog["calciteDialogClose"]["detail"];
-    "calciteDialogOpen": Dialog["calciteDialogOpen"]["detail"];
-    "calciteDialogScroll": Dialog["calciteDialogScroll"]["detail"];
-  }
+  type HTMLCalciteIconElement = Icon;
 
-  interface HTMLCalciteDialogElement extends Dialog {
-    addEventListener<K extends keyof HTMLCalciteDialogElementEventMap>(type: K, listener: (this: HTMLCalciteDialogElement, ev: CalciteDialogCustomEvent<HTMLCalciteDialogElementEventMap[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 HTMLCalciteDialogElementEventMap>(type: K, listener: (this: HTMLCalciteDialogElement, ev: CalciteDialogCustomEvent<HTMLCalciteDialogElementEventMap[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 HTMLCalciteDropdownElementEventMap {
-    "calciteDropdownBeforeClose": Dropdown["calciteDropdownBeforeClose"]["detail"];
-    "calciteDropdownBeforeOpen": Dropdown["calciteDropdownBeforeOpen"]["detail"];
-    "calciteDropdownClose": Dropdown["calciteDropdownClose"]["detail"];
-    "calciteDropdownOpen": Dropdown["calciteDropdownOpen"]["detail"];
-    "calciteDropdownSelect": Dropdown["calciteDropdownSelect"]["detail"];
-  }
+  type HTMLCalciteInlineEditableElementEventMap = InlineEditable["@eventTypes"];
+  type HTMLCalciteInlineEditableElement = InlineEditable;
 
-  interface HTMLCalciteDropdownElement extends Dropdown {
-    addEventListener<K extends keyof HTMLCalciteDropdownElementEventMap>(type: K, listener: (this: HTMLCalciteDropdownElement, ev: CalciteDropdownCustomEvent<HTMLCalciteDropdownElementEventMap[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 HTMLCalciteDropdownElementEventMap>(type: K, listener: (this: HTMLCalciteDropdownElement, ev: CalciteDropdownCustomEvent<HTMLCalciteDropdownElementEventMap[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 HTMLCalciteDropdownGroupElement extends DropdownGroup {
+  type HTMLCalciteInputElementEventMap = Input["@eventTypes"];
+  type HTMLCalciteInputElement = Input;
 
-  }
-  interface HTMLCalciteDropdownItemElementEventMap {
-    "calciteDropdownItemSelect": DropdownItem["calciteDropdownItemSelect"]["detail"];
-  }
+  type HTMLCalciteInputDatePickerElementEventMap = InputDatePicker["@eventTypes"];
+  type HTMLCalciteInputDatePickerElement = InputDatePicker;
 
-  interface HTMLCalciteDropdownItemElement extends DropdownItem {
-    addEventListener<K extends keyof HTMLCalciteDropdownItemElementEventMap>(type: K, listener: (this: HTMLCalciteDropdownItemElement, ev: CalciteDropdownItemCustomEvent<HTMLCalciteDropdownItemElementEventMap[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 HTMLCalciteDropdownItemElementEventMap>(type: K, listener: (this: HTMLCalciteDropdownItemElement, ev: CalciteDropdownItemCustomEvent<HTMLCalciteDropdownItemElementEventMap[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 HTMLCalciteFabElement extends Fab {
+  type HTMLCalciteInputMessageElement = InputMessage;
 
-  }
-  interface HTMLCalciteFilterElementEventMap {
-    "calciteFilterChange": Filter["calciteFilterChange"]["detail"];
-  }
+  type HTMLCalciteInputNumberElementEventMap = InputNumber["@eventTypes"];
+  type HTMLCalciteInputNumberElement = InputNumber;
 
-  interface HTMLCalciteFilterElement extends Filter {
-    addEventListener<K extends keyof HTMLCalciteFilterElementEventMap>(type: K, listener: (this: HTMLCalciteFilterElement, ev: CalciteFilterCustomEvent<HTMLCalciteFilterElementEventMap[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 HTMLCalciteFilterElementEventMap>(type: K, listener: (this: HTMLCalciteFilterElement, ev: CalciteFilterCustomEvent<HTMLCalciteFilterElementEventMap[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 HTMLCalciteFlowElement extends Flow {
+  type HTMLCalciteInputTextElementEventMap = InputText["@eventTypes"];
+  type HTMLCalciteInputTextElement = InputText;
 
-  }
-  interface HTMLCalciteFlowItemElementEventMap {
-    "calciteFlowItemBack": FlowItem["calciteFlowItemBack"]["detail"];
-    "calciteFlowItemClose": FlowItem["calciteFlowItemClose"]["detail"];
-    "calciteFlowItemCollapse": FlowItem["calciteFlowItemCollapse"]["detail"];
-    "calciteFlowItemExpand": FlowItem["calciteFlowItemExpand"]["detail"];
-    "calciteFlowItemScroll": FlowItem["calciteFlowItemScroll"]["detail"];
-    "calciteFlowItemToggle": FlowItem["calciteFlowItemToggle"]["detail"];
-  }
+  type HTMLCalciteInputTimePickerElementEventMap = InputTimePicker["@eventTypes"];
+  type HTMLCalciteInputTimePickerElement = InputTimePicker;
 
-  interface HTMLCalciteFlowItemElement extends FlowItem {
-    addEventListener<K extends keyof HTMLCalciteFlowItemElementEventMap>(type: K, listener: (this: HTMLCalciteFlowItemElement, ev: CalciteFlowItemCustomEvent<HTMLCalciteFlowItemElementEventMap[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 HTMLCalciteFlowItemElementEventMap>(type: K, listener: (this: HTMLCalciteFlowItemElement, ev: CalciteFlowItemCustomEvent<HTMLCalciteFlowItemElementEventMap[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 HTMLCalciteGraphElement extends Graph {
+  type HTMLCalciteInputTimeZoneElementEventMap = InputTimeZone["@eventTypes"];
+  type HTMLCalciteInputTimeZoneElement = InputTimeZone;
 
-  }
-  interface HTMLCalciteHandleElementEventMap {
-    "calciteHandleChange": Handle["calciteHandleChange"]["detail"];
-    "calciteHandleNudge": Handle["calciteHandleNudge"]["detail"];
-  }
+  type HTMLCalciteLabelElement = Label;
 
-  interface HTMLCalciteHandleElement extends Handle {
-    addEventListener<K extends keyof HTMLCalciteHandleElementEventMap>(type: K, listener: (this: HTMLCalciteHandleElement, ev: CalciteHandleCustomEvent<HTMLCalciteHandleElementEventMap[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 HTMLCalciteHandleElementEventMap>(type: K, listener: (this: HTMLCalciteHandleElement, ev: CalciteHandleCustomEvent<HTMLCalciteHandleElementEventMap[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 HTMLCalciteIconElement extends Icon {
+  type HTMLCalciteLinkElement = Link;
 
-  }
-  interface HTMLCalciteInlineEditableElementEventMap {
-    "calciteInlineEditableEditCancel": InlineEditable["calciteInlineEditableEditCancel"]["detail"];
-    "calciteInlineEditableEditConfirm": InlineEditable["calciteInlineEditableEditConfirm"]["detail"];
-  }
+  type HTMLCalciteListElementEventMap = List["@eventTypes"];
+  type HTMLCalciteListElement = List;
 
-  interface HTMLCalciteInlineEditableElement extends InlineEditable {
-    addEventListener<K extends keyof HTMLCalciteInlineEditableElementEventMap>(type: K, listener: (this: HTMLCalciteInlineEditableElement, ev: CalciteInlineEditableCustomEvent<HTMLCalciteInlineEditableElementEventMap[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 HTMLCalciteInlineEditableElementEventMap>(type: K, listener: (this: HTMLCalciteInlineEditableElement, ev: CalciteInlineEditableCustomEvent<HTMLCalciteInlineEditableElementEventMap[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 HTMLCalciteInputElementEventMap {
-    "calciteInputChange": Input["calciteInputChange"]["detail"];
-    "calciteInputInput": Input["calciteInputInput"]["detail"];
-  }
+  type HTMLCalciteListItemElementEventMap = ListItem["@eventTypes"];
+  type HTMLCalciteListItemElement = ListItem;
 
-  interface HTMLCalciteInputElement extends Input {
-    addEventListener<K extends keyof HTMLCalciteInputElementEventMap>(type: K, listener: (this: HTMLCalciteInputElement, ev: CalciteInputCustomEvent<HTMLCalciteInputElementEventMap[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 HTMLCalciteInputElementEventMap>(type: K, listener: (this: HTMLCalciteInputElement, ev: CalciteInputCustomEvent<HTMLCalciteInputElementEventMap[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 HTMLCalciteInputDatePickerElementEventMap {
-    "calciteInputDatePickerBeforeClose": InputDatePicker["calciteInputDatePickerBeforeClose"]["detail"];
-    "calciteInputDatePickerBeforeOpen": InputDatePicker["calciteInputDatePickerBeforeOpen"]["detail"];
-    "calciteInputDatePickerChange": InputDatePicker["calciteInputDatePickerChange"]["detail"];
-    "calciteInputDatePickerClose": InputDatePicker["calciteInputDatePickerClose"]["detail"];
-    "calciteInputDatePickerOpen": InputDatePicker["calciteInputDatePickerOpen"]["detail"];
-  }
+  type HTMLCalciteListItemGroupElement = ListItemGroup;
 
-  interface HTMLCalciteInputDatePickerElement extends InputDatePicker {
-    addEventListener<K extends keyof HTMLCalciteInputDatePickerElementEventMap>(type: K, listener: (this: HTMLCalciteInputDatePickerElement, ev: CalciteInputDatePickerCustomEvent<HTMLCalciteInputDatePickerElementEventMap[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 HTMLCalciteInputDatePickerElementEventMap>(type: K, listener: (this: HTMLCalciteInputDatePickerElement, ev: CalciteInputDatePickerCustomEvent<HTMLCalciteInputDatePickerElementEventMap[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 HTMLCalciteInputMessageElement extends InputMessage {
+  type HTMLCalciteLoaderElement = Loader;
 
-  }
-  interface HTMLCalciteInputNumberElementEventMap {
-    "calciteInputNumberChange": InputNumber["calciteInputNumberChange"]["detail"];
-    "calciteInputNumberInput": InputNumber["calciteInputNumberInput"]["detail"];
-  }
+  type HTMLCalciteMenuElement = Menu;
 
-  interface HTMLCalciteInputNumberElement extends InputNumber {
-    addEventListener<K extends keyof HTMLCalciteInputNumberElementEventMap>(type: K, listener: (this: HTMLCalciteInputNumberElement, ev: CalciteInputNumberCustomEvent<HTMLCalciteInputNumberElementEventMap[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 HTMLCalciteInputNumberElementEventMap>(type: K, listener: (this: HTMLCalciteInputNumberElement, ev: CalciteInputNumberCustomEvent<HTMLCalciteInputNumberElementEventMap[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 HTMLCalciteInputTextElementEventMap {
-    "calciteInputTextChange": InputText["calciteInputTextChange"]["detail"];
-    "calciteInputTextInput": InputText["calciteInputTextInput"]["detail"];
-  }
+  type HTMLCalciteMenuItemElementEventMap = MenuItem["@eventTypes"];
+  type HTMLCalciteMenuItemElement = MenuItem;
 
-  interface HTMLCalciteInputTextElement extends InputText {
-    addEventListener<K extends keyof HTMLCalciteInputTextElementEventMap>(type: K, listener: (this: HTMLCalciteInputTextElement, ev: CalciteInputTextCustomEvent<HTMLCalciteInputTextElementEventMap[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 HTMLCalciteInputTextElementEventMap>(type: K, listener: (this: HTMLCalciteInputTextElement, ev: CalciteInputTextCustomEvent<HTMLCalciteInputTextElementEventMap[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 HTMLCalciteInputTimePickerElementEventMap {
-    "calciteInputTimePickerBeforeClose": InputTimePicker["calciteInputTimePickerBeforeClose"]["detail"];
-    "calciteInputTimePickerBeforeOpen": InputTimePicker["calciteInputTimePickerBeforeOpen"]["detail"];
-    "calciteInputTimePickerChange": InputTimePicker["calciteInputTimePickerChange"]["detail"];
-    "calciteInputTimePickerClose": InputTimePicker["calciteInputTimePickerClose"]["detail"];
-    "calciteInputTimePickerOpen": InputTimePicker["calciteInputTimePickerOpen"]["detail"];
-  }
+  type HTMLCalciteMeterElement = Meter;
 
-  interface HTMLCalciteInputTimePickerElement extends InputTimePicker {
-    addEventListener<K extends keyof HTMLCalciteInputTimePickerElementEventMap>(type: K, listener: (this: HTMLCalciteInputTimePickerElement, ev: CalciteInputTimePickerCustomEvent<HTMLCalciteInputTimePickerElementEventMap[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 HTMLCalciteInputTimePickerElementEventMap>(type: K, listener: (this: HTMLCalciteInputTimePickerElement, ev: CalciteInputTimePickerCustomEvent<HTMLCalciteInputTimePickerElementEventMap[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 HTMLCalciteInputTimeZoneElementEventMap {
-    "calciteInputTimeZoneBeforeClose": InputTimeZone["calciteInputTimeZoneBeforeClose"]["detail"];
-    "calciteInputTimeZoneBeforeOpen": InputTimeZone["calciteInputTimeZoneBeforeOpen"]["detail"];
-    "calciteInputTimeZoneChange": InputTimeZone["calciteInputTimeZoneChange"]["detail"];
-    "calciteInputTimeZoneClose": InputTimeZone["calciteInputTimeZoneClose"]["detail"];
-    "calciteInputTimeZoneOpen": InputTimeZone["calciteInputTimeZoneOpen"]["detail"];
-  }
+  type HTMLCalciteNavigationElementEventMap = Navigation["@eventTypes"];
+  type HTMLCalciteNavigationElement = Navigation;
 
-  interface HTMLCalciteInputTimeZoneElement extends InputTimeZone {
-    addEventListener<K extends keyof HTMLCalciteInputTimeZoneElementEventMap>(type: K, listener: (this: HTMLCalciteInputTimeZoneElement, ev: CalciteInputTimeZoneCustomEvent<HTMLCalciteInputTimeZoneElementEventMap[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 HTMLCalciteInputTimeZoneElementEventMap>(type: K, listener: (this: HTMLCalciteInputTimeZoneElement, ev: CalciteInputTimeZoneCustomEvent<HTMLCalciteInputTimeZoneElementEventMap[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 HTMLCalciteLabelElement extends Label {
+  type HTMLCalciteNavigationLogoElement = NavigationLogo;
 
-  }
-  interface HTMLCalciteLinkElement extends Link {
+  type HTMLCalciteNavigationUserElement = NavigationUser;
 
-  }
-  interface HTMLCalciteListElementEventMap {
-    "calciteListChange": List["calciteListChange"]["detail"];
-    "calciteListDragEnd": List["calciteListDragEnd"]["detail"];
-    "calciteListDragStart": List["calciteListDragStart"]["detail"];
-    "calciteListFilter": List["calciteListFilter"]["detail"];
-    "calciteListMoveHalt": List["calciteListMoveHalt"]["detail"];
-    "calciteListOrderChange": List["calciteListOrderChange"]["detail"];
-  }
-
-  interface HTMLCalciteListElement extends List {
-    addEventListener<K extends keyof HTMLCalciteListElementEventMap>(type: K, listener: (this: HTMLCalciteListElement, ev: CalciteListCustomEvent<HTMLCalciteListElementEventMap[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 HTMLCalciteListElementEventMap>(type: K, listener: (this: HTMLCalciteListElement, ev: CalciteListCustomEvent<HTMLCalciteListElementEventMap[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 HTMLCalciteListItemElementEventMap {
-    "calciteListItemClose": ListItem["calciteListItemClose"]["detail"];
-    "calciteListItemCollapse": ListItem["calciteListItemCollapse"]["detail"];
-    "calciteListItemExpand": ListItem["calciteListItemExpand"]["detail"];
-    "calciteListItemSelect": ListItem["calciteListItemSelect"]["detail"];
-    "calciteListItemSortHandleBeforeClose": ListItem["calciteListItemSortHandleBeforeClose"]["detail"];
-    "calciteListItemSortHandleBeforeOpen": ListItem["calciteListItemSortHandleBeforeOpen"]["detail"];
-    "calciteListItemSortHandleClose": ListItem["calciteListItemSortHandleClose"]["detail"];
-    "calciteListItemSortHandleOpen": ListItem["calciteListItemSortHandleOpen"]["detail"];
-    "calciteListItemToggle": ListItem["calciteListItemToggle"]["detail"];
-  }
-
-  interface HTMLCalciteListItemElement extends ListItem {
-    addEventListener<K extends keyof HTMLCalciteListItemElementEventMap>(type: K, listener: (this: HTMLCalciteListItemElement, ev: CalciteListItemCustomEvent<HTMLCalciteListItemElementEventMap[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 HTMLCalciteListItemElementEventMap>(type: K, listener: (this: HTMLCalciteListItemElement, ev: CalciteListItemCustomEvent<HTMLCalciteListItemElementEventMap[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 HTMLCalciteListItemGroupElement extends ListItemGroup {
-
-  }
-  interface HTMLCalciteLoaderElement extends Loader {
-
-  }
-  interface HTMLCalciteMenuElement extends Menu {
-
-  }
-  interface HTMLCalciteMenuItemElementEventMap {
-    "calciteMenuItemSelect": MenuItem["calciteMenuItemSelect"]["detail"];
-  }
-
-  interface HTMLCalciteMenuItemElement extends MenuItem {
-    addEventListener<K extends keyof HTMLCalciteMenuItemElementEventMap>(type: K, listener: (this: HTMLCalciteMenuItemElement, ev: CalciteMenuItemCustomEvent<HTMLCalciteMenuItemElementEventMap[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 HTMLCalciteMenuItemElementEventMap>(type: K, listener: (this: HTMLCalciteMenuItemElement, ev: CalciteMenuItemCustomEvent<HTMLCalciteMenuItemElementEventMap[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 HTMLCalciteMeterElement extends Meter {
-
-  }
-  interface HTMLCalciteNavigationElementEventMap {
-    "calciteNavigationActionSelect": Navigation["calciteNavigationActionSelect"]["detail"];
-  }
+  type HTMLCalciteNoticeElementEventMap = Notice["@eventTypes"];
+  type HTMLCalciteNoticeElement = Notice;
 
-  interface HTMLCalciteNavigationElement extends Navigation {
-    addEventListener<K extends keyof HTMLCalciteNavigationElementEventMap>(type: K, listener: (this: HTMLCalciteNavigationElement, ev: CalciteNavigationCustomEvent<HTMLCalciteNavigationElementEventMap[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 HTMLCalciteNavigationElementEventMap>(type: K, listener: (this: HTMLCalciteNavigationElement, ev: CalciteNavigationCustomEvent<HTMLCalciteNavigationElementEventMap[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 HTMLCalciteNavigationLogoElement extends NavigationLogo {
-
-  }
-  interface HTMLCalciteNavigationUserElement extends NavigationUser {
-
-  }
-  interface HTMLCalciteNoticeElementEventMap {
-    "calciteNoticeBeforeClose": Notice["calciteNoticeBeforeClose"]["detail"];
-    "calciteNoticeBeforeOpen": Notice["calciteNoticeBeforeOpen"]["detail"];
-    "calciteNoticeClose": Notice["calciteNoticeClose"]["detail"];
-    "calciteNoticeOpen": Notice["calciteNoticeOpen"]["detail"];
-  }
+  type HTMLCalciteOptionElement = Option;
 
-  interface HTMLCalciteNoticeElement extends Notice {
-    addEventListener<K extends keyof HTMLCalciteNoticeElementEventMap>(type: K, listener: (this: HTMLCalciteNoticeElement, ev: CalciteNoticeCustomEvent<HTMLCalciteNoticeElementEventMap[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 HTMLCalciteNoticeElementEventMap>(type: K, listener: (this: HTMLCalciteNoticeElement, ev: CalciteNoticeCustomEvent<HTMLCalciteNoticeElementEventMap[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 HTMLCalciteOptionElement extends Option {
+  type HTMLCalciteOptionGroupElement = OptionGroup;
 
-  }
-  interface HTMLCalciteOptionGroupElement extends OptionGroup {
+  type HTMLCalcitePaginationElementEventMap = Pagination["@eventTypes"];
+  type HTMLCalcitePaginationElement = Pagination;
 
-  }
-  interface HTMLCalcitePaginationElementEventMap {
-    "calcitePaginationChange": Pagination["calcitePaginationChange"]["detail"];
-  }
+  type HTMLCalcitePanelElementEventMap = Panel["@eventTypes"];
+  type HTMLCalcitePanelElement = Panel;
 
-  interface HTMLCalcitePaginationElement extends Pagination {
-    addEventListener<K extends keyof HTMLCalcitePaginationElementEventMap>(type: K, listener: (this: HTMLCalcitePaginationElement, ev: CalcitePaginationCustomEvent<HTMLCalcitePaginationElementEventMap[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 HTMLCalcitePaginationElementEventMap>(type: K, listener: (this: HTMLCalcitePaginationElement, ev: CalcitePaginationCustomEvent<HTMLCalcitePaginationElementEventMap[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 HTMLCalcitePanelElementEventMap {
-    "calcitePanelClose": Panel["calcitePanelClose"]["detail"];
-    "calcitePanelCollapse": Panel["calcitePanelCollapse"]["detail"];
-    "calcitePanelExpand": Panel["calcitePanelExpand"]["detail"];
-    "calcitePanelScroll": Panel["calcitePanelScroll"]["detail"];
-    "calcitePanelToggle": Panel["calcitePanelToggle"]["detail"];
-  }
+  type HTMLCalcitePopoverElementEventMap = Popover["@eventTypes"];
+  type HTMLCalcitePopoverElement = Popover;
 
-  interface HTMLCalcitePanelElement extends Panel {
-    addEventListener<K extends keyof HTMLCalcitePanelElementEventMap>(type: K, listener: (this: HTMLCalcitePanelElement, ev: CalcitePanelCustomEvent<HTMLCalcitePanelElementEventMap[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 HTMLCalcitePanelElementEventMap>(type: K, listener: (this: HTMLCalcitePanelElement, ev: CalcitePanelCustomEvent<HTMLCalcitePanelElementEventMap[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 HTMLCalcitePopoverElementEventMap {
-    "calcitePopoverBeforeClose": Popover["calcitePopoverBeforeClose"]["detail"];
-    "calcitePopoverBeforeOpen": Popover["calcitePopoverBeforeOpen"]["detail"];
-    "calcitePopoverClose": Popover["calcitePopoverClose"]["detail"];
-    "calcitePopoverOpen": Popover["calcitePopoverOpen"]["detail"];
-  }
+  type HTMLCalciteProgressElement = Progress;
 
-  interface HTMLCalcitePopoverElement extends Popover {
-    addEventListener<K extends keyof HTMLCalcitePopoverElementEventMap>(type: K, listener: (this: HTMLCalcitePopoverElement, ev: CalcitePopoverCustomEvent<HTMLCalcitePopoverElementEventMap[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 HTMLCalcitePopoverElementEventMap>(type: K, listener: (this: HTMLCalcitePopoverElement, ev: CalcitePopoverCustomEvent<HTMLCalcitePopoverElementEventMap[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 HTMLCalciteProgressElement extends Progress {
+  type HTMLCalciteRadioButtonElementEventMap = RadioButton["@eventTypes"];
+  type HTMLCalciteRadioButtonElement = RadioButton;
 
-  }
-  interface HTMLCalciteRadioButtonElementEventMap {
-    "calciteRadioButtonChange": RadioButton["calciteRadioButtonChange"]["detail"];
-  }
+  type HTMLCalciteRadioButtonGroupElementEventMap = RadioButtonGroup["@eventTypes"];
+  type HTMLCalciteRadioButtonGroupElement = RadioButtonGroup;
 
-  interface HTMLCalciteRadioButtonElement extends RadioButton {
-    addEventListener<K extends keyof HTMLCalciteRadioButtonElementEventMap>(type: K, listener: (this: HTMLCalciteRadioButtonElement, ev: CalciteRadioButtonCustomEvent<HTMLCalciteRadioButtonElementEventMap[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 HTMLCalciteRadioButtonElementEventMap>(type: K, listener: (this: HTMLCalciteRadioButtonElement, ev: CalciteRadioButtonCustomEvent<HTMLCalciteRadioButtonElementEventMap[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 HTMLCalciteRadioButtonGroupElementEventMap {
-    "calciteRadioButtonGroupChange": RadioButtonGroup["calciteRadioButtonGroupChange"]["detail"];
-  }
+  type HTMLCalciteRatingElementEventMap = Rating["@eventTypes"];
+  type HTMLCalciteRatingElement = Rating;
 
-  interface HTMLCalciteRadioButtonGroupElement extends RadioButtonGroup {
-    addEventListener<K extends keyof HTMLCalciteRadioButtonGroupElementEventMap>(type: K, listener: (this: HTMLCalciteRadioButtonGroupElement, ev: CalciteRadioButtonGroupCustomEvent<HTMLCalciteRadioButtonGroupElementEventMap[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 HTMLCalciteRadioButtonGroupElementEventMap>(type: K, listener: (this: HTMLCalciteRadioButtonGroupElement, ev: CalciteRadioButtonGroupCustomEvent<HTMLCalciteRadioButtonGroupElementEventMap[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 HTMLCalciteRatingElementEventMap {
-    "calciteRatingChange": Rating["calciteRatingChange"]["detail"];
-  }
+  type HTMLCalciteScrimElement = Scrim;
 
-  interface HTMLCalciteRatingElement extends Rating {
-    addEventListener<K extends keyof HTMLCalciteRatingElementEventMap>(type: K, listener: (this: HTMLCalciteRatingElement, ev: CalciteRatingCustomEvent<HTMLCalciteRatingElementEventMap[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 HTMLCalciteRatingElementEventMap>(type: K, listener: (this: HTMLCalciteRatingElement, ev: CalciteRatingCustomEvent<HTMLCalciteRatingElementEventMap[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 HTMLCalciteScrimElement extends Scrim {
+  type HTMLCalciteSegmentedControlElementEventMap = SegmentedControl["@eventTypes"];
+  type HTMLCalciteSegmentedControlElement = SegmentedControl;
 
-  }
-  interface HTMLCalciteSegmentedControlElementEventMap {
-    "calciteSegmentedControlChange": SegmentedControl["calciteSegmentedControlChange"]["detail"];
-  }
+  type HTMLCalciteSegmentedControlItemElement = SegmentedControlItem;
 
-  interface HTMLCalciteSegmentedControlElement extends SegmentedControl {
-    addEventListener<K extends keyof HTMLCalciteSegmentedControlElementEventMap>(type: K, listener: (this: HTMLCalciteSegmentedControlElement, ev: CalciteSegmentedControlCustomEvent<HTMLCalciteSegmentedControlElementEventMap[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 HTMLCalciteSegmentedControlElementEventMap>(type: K, listener: (this: HTMLCalciteSegmentedControlElement, ev: CalciteSegmentedControlCustomEvent<HTMLCalciteSegmentedControlElementEventMap[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 HTMLCalciteSegmentedControlItemElement extends SegmentedControlItem {
+  type HTMLCalciteSelectElementEventMap = Select["@eventTypes"];
+  type HTMLCalciteSelectElement = Select;
 
-  }
-  interface HTMLCalciteSelectElementEventMap {
-    "calciteSelectChange": Select["calciteSelectChange"]["detail"];
-  }
+  type HTMLCalciteSheetElementEventMap = Sheet["@eventTypes"];
+  type HTMLCalciteSheetElement = Sheet;
 
-  interface HTMLCalciteSelectElement extends Select {
-    addEventListener<K extends keyof HTMLCalciteSelectElementEventMap>(type: K, listener: (this: HTMLCalciteSelectElement, ev: CalciteSelectCustomEvent<HTMLCalciteSelectElementEventMap[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 HTMLCalciteSelectElementEventMap>(type: K, listener: (this: HTMLCalciteSelectElement, ev: CalciteSelectCustomEvent<HTMLCalciteSelectElementEventMap[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 HTMLCalciteSheetElementEventMap {
-    "calciteSheetBeforeClose": Sheet["calciteSheetBeforeClose"]["detail"];
-    "calciteSheetBeforeOpen": Sheet["calciteSheetBeforeOpen"]["detail"];
-    "calciteSheetClose": Sheet["calciteSheetClose"]["detail"];
-    "calciteSheetOpen": Sheet["calciteSheetOpen"]["detail"];
-  }
+  type HTMLCalciteShellElement = Shell;
 
-  interface HTMLCalciteSheetElement extends Sheet {
-    addEventListener<K extends keyof HTMLCalciteSheetElementEventMap>(type: K, listener: (this: HTMLCalciteSheetElement, ev: CalciteSheetCustomEvent<HTMLCalciteSheetElementEventMap[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 HTMLCalciteSheetElementEventMap>(type: K, listener: (this: HTMLCalciteSheetElement, ev: CalciteSheetCustomEvent<HTMLCalciteSheetElementEventMap[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 HTMLCalciteShellElement extends Shell {
+  type HTMLCalciteShellPanelElementEventMap = ShellPanel["@eventTypes"];
+  type HTMLCalciteShellPanelElement = ShellPanel;
 
-  }
-  interface HTMLCalciteShellPanelElementEventMap {
-    "calciteShellPanelCollapse": ShellPanel["calciteShellPanelCollapse"]["detail"];
-    "calciteShellPanelExpand": ShellPanel["calciteShellPanelExpand"]["detail"];
-  }
+  type HTMLCalciteSliderElementEventMap = Slider["@eventTypes"];
+  type HTMLCalciteSliderElement = Slider;
 
-  interface HTMLCalciteShellPanelElement extends ShellPanel {
-    addEventListener<K extends keyof HTMLCalciteShellPanelElementEventMap>(type: K, listener: (this: HTMLCalciteShellPanelElement, ev: CalciteShellPanelCustomEvent<HTMLCalciteShellPanelElementEventMap[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 HTMLCalciteShellPanelElementEventMap>(type: K, listener: (this: HTMLCalciteShellPanelElement, ev: CalciteShellPanelCustomEvent<HTMLCalciteShellPanelElementEventMap[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 HTMLCalciteSliderElementEventMap {
-    "calciteSliderChange": Slider["calciteSliderChange"]["detail"];
-    "calciteSliderInput": Slider["calciteSliderInput"]["detail"];
-  }
+  type HTMLCalciteSortHandleElementEventMap = SortHandle["@eventTypes"];
+  type HTMLCalciteSortHandleElement = SortHandle;
 
-  interface HTMLCalciteSliderElement extends Slider {
-    addEventListener<K extends keyof HTMLCalciteSliderElementEventMap>(type: K, listener: (this: HTMLCalciteSliderElement, ev: CalciteSliderCustomEvent<HTMLCalciteSliderElementEventMap[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 HTMLCalciteSliderElementEventMap>(type: K, listener: (this: HTMLCalciteSliderElement, ev: CalciteSliderCustomEvent<HTMLCalciteSliderElementEventMap[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 HTMLCalciteSortHandleElementEventMap {
-    "calciteSortHandleAdd": SortHandle["calciteSortHandleAdd"]["detail"];
-    "calciteSortHandleBeforeClose": SortHandle["calciteSortHandleBeforeClose"]["detail"];
-    "calciteSortHandleBeforeOpen": SortHandle["calciteSortHandleBeforeOpen"]["detail"];
-    "calciteSortHandleClose": SortHandle["calciteSortHandleClose"]["detail"];
-    "calciteSortHandleMove": SortHandle["calciteSortHandleMove"]["detail"];
-    "calciteSortHandleOpen": SortHandle["calciteSortHandleOpen"]["detail"];
-    "calciteSortHandleReorder": SortHandle["calciteSortHandleReorder"]["detail"];
-  }
+  type HTMLCalciteSortableListElementEventMap = SortableList["@eventTypes"];
+  type HTMLCalciteSortableListElement = SortableList;
 
-  interface HTMLCalciteSortHandleElement extends SortHandle {
-    addEventListener<K extends keyof HTMLCalciteSortHandleElementEventMap>(type: K, listener: (this: HTMLCalciteSortHandleElement, ev: CalciteSortHandleCustomEvent<HTMLCalciteSortHandleElementEventMap[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 HTMLCalciteSortHandleElementEventMap>(type: K, listener: (this: HTMLCalciteSortHandleElement, ev: CalciteSortHandleCustomEvent<HTMLCalciteSortHandleElementEventMap[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 HTMLCalciteSortableListElementEventMap {
-    "calciteListOrderChange": SortableList["calciteListOrderChange"]["detail"];
-  }
+  type HTMLCalciteSplitButtonElementEventMap = SplitButton["@eventTypes"];
+  type HTMLCalciteSplitButtonElement = SplitButton;
 
-  interface HTMLCalciteSortableListElement extends SortableList {
-    addEventListener<K extends keyof HTMLCalciteSortableListElementEventMap>(type: K, listener: (this: HTMLCalciteSortableListElement, ev: CalciteSortableListCustomEvent<HTMLCalciteSortableListElementEventMap[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 HTMLCalciteSortableListElementEventMap>(type: K, listener: (this: HTMLCalciteSortableListElement, ev: CalciteSortableListCustomEvent<HTMLCalciteSortableListElementEventMap[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 HTMLCalciteSplitButtonElementEventMap {
-    "calciteSplitButtonPrimaryClick": SplitButton["calciteSplitButtonPrimaryClick"]["detail"];
-    "calciteSplitButtonSecondaryClick": SplitButton["calciteSplitButtonSecondaryClick"]["detail"];
-  }
+  type HTMLCalciteStackElement = Stack;
 
-  interface HTMLCalciteSplitButtonElement extends SplitButton {
-    addEventListener<K extends keyof HTMLCalciteSplitButtonElementEventMap>(type: K, listener: (this: HTMLCalciteSplitButtonElement, ev: CalciteSplitButtonCustomEvent<HTMLCalciteSplitButtonElementEventMap[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 HTMLCalciteSplitButtonElementEventMap>(type: K, listener: (this: HTMLCalciteSplitButtonElement, ev: CalciteSplitButtonCustomEvent<HTMLCalciteSplitButtonElementEventMap[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 HTMLCalciteStackElement extends Stack {
+  type HTMLCalciteStepperElementEventMap = Stepper["@eventTypes"];
+  type HTMLCalciteStepperElement = Stepper;
 
-  }
-  interface HTMLCalciteStepperElementEventMap {
-    "calciteStepperChange": Stepper["calciteStepperChange"]["detail"];
-  }
+  type HTMLCalciteStepperItemElementEventMap = StepperItem["@eventTypes"];
+  type HTMLCalciteStepperItemElement = StepperItem;
 
-  interface HTMLCalciteStepperElement extends Stepper {
-    addEventListener<K extends keyof HTMLCalciteStepperElementEventMap>(type: K, listener: (this: HTMLCalciteStepperElement, ev: CalciteStepperCustomEvent<HTMLCalciteStepperElementEventMap[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 HTMLCalciteStepperElementEventMap>(type: K, listener: (this: HTMLCalciteStepperElement, ev: CalciteStepperCustomEvent<HTMLCalciteStepperElementEventMap[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 HTMLCalciteStepperItemElementEventMap {
-    "calciteStepperItemSelect": StepperItem["calciteStepperItemSelect"]["detail"];
-  }
+  type HTMLCalciteSwatchElementEventMap = Swatch["@eventTypes"];
+  type HTMLCalciteSwatchElement = Swatch;
 
-  interface HTMLCalciteStepperItemElement extends StepperItem {
-    addEventListener<K extends keyof HTMLCalciteStepperItemElementEventMap>(type: K, listener: (this: HTMLCalciteStepperItemElement, ev: CalciteStepperItemCustomEvent<HTMLCalciteStepperItemElementEventMap[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 HTMLCalciteStepperItemElementEventMap>(type: K, listener: (this: HTMLCalciteStepperItemElement, ev: CalciteStepperItemCustomEvent<HTMLCalciteStepperItemElementEventMap[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 HTMLCalciteSwatchElementEventMap {
-    "calciteSwatchSelect": Swatch["calciteSwatchSelect"]["detail"];
-  }
+  type HTMLCalciteSwatchGroupElementEventMap = SwatchGroup["@eventTypes"];
+  type HTMLCalciteSwatchGroupElement = SwatchGroup;
 
-  interface HTMLCalciteSwatchElement extends Swatch {
-    addEventListener<K extends keyof HTMLCalciteSwatchElementEventMap>(type: K, listener: (this: HTMLCalciteSwatchElement, ev: CalciteSwatchCustomEvent<HTMLCalciteSwatchElementEventMap[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 HTMLCalciteSwatchElementEventMap>(type: K, listener: (this: HTMLCalciteSwatchElement, ev: CalciteSwatchCustomEvent<HTMLCalciteSwatchElementEventMap[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 HTMLCalciteSwatchGroupElementEventMap {
-    "calciteSwatchGroupSelect": SwatchGroup["calciteSwatchGroupSelect"]["detail"];
-  }
+  type HTMLCalciteSwitchElementEventMap = Switch["@eventTypes"];
+  type HTMLCalciteSwitchElement = Switch;
 
-  interface HTMLCalciteSwatchGroupElement extends SwatchGroup {
-    addEventListener<K extends keyof HTMLCalciteSwatchGroupElementEventMap>(type: K, listener: (this: HTMLCalciteSwatchGroupElement, ev: CalciteSwatchGroupCustomEvent<HTMLCalciteSwatchGroupElementEventMap[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 HTMLCalciteSwatchGroupElementEventMap>(type: K, listener: (this: HTMLCalciteSwatchGroupElement, ev: CalciteSwatchGroupCustomEvent<HTMLCalciteSwatchGroupElementEventMap[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 HTMLCalciteSwitchElementEventMap {
-    "calciteSwitchChange": Switch["calciteSwitchChange"]["detail"];
-  }
+  type HTMLCalciteTabElement = Tab;
 
-  interface HTMLCalciteSwitchElement extends Switch {
-    addEventListener<K extends keyof HTMLCalciteSwitchElementEventMap>(type: K, listener: (this: HTMLCalciteSwitchElement, ev: CalciteSwitchCustomEvent<HTMLCalciteSwitchElementEventMap[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 HTMLCalciteSwitchElementEventMap>(type: K, listener: (this: HTMLCalciteSwitchElement, ev: CalciteSwitchCustomEvent<HTMLCalciteSwitchElementEventMap[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 HTMLCalciteTabElement extends Tab {
+  type HTMLCalciteTabNavElementEventMap = TabNav["@eventTypes"];
+  type HTMLCalciteTabNavElement = TabNav;
 
-  }
-  interface HTMLCalciteTabNavElementEventMap {
-    "calciteTabChange": TabNav["calciteTabChange"]["detail"];
-  }
+  type HTMLCalciteTabTitleElementEventMap = TabTitle["@eventTypes"];
+  type HTMLCalciteTabTitleElement = TabTitle;
 
-  interface HTMLCalciteTabNavElement extends TabNav {
-    addEventListener<K extends keyof HTMLCalciteTabNavElementEventMap>(type: K, listener: (this: HTMLCalciteTabNavElement, ev: CalciteTabNavCustomEvent<HTMLCalciteTabNavElementEventMap[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 HTMLCalciteTabNavElementEventMap>(type: K, listener: (this: HTMLCalciteTabNavElement, ev: CalciteTabNavCustomEvent<HTMLCalciteTabNavElementEventMap[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 HTMLCalciteTabTitleElementEventMap {
-    "calciteTabsActivate": TabTitle["calciteTabsActivate"]["detail"];
-    "calciteTabsClose": TabTitle["calciteTabsClose"]["detail"];
-  }
+  type HTMLCalciteTableElementEventMap = Table["@eventTypes"];
+  type HTMLCalciteTableElement = Table;
 
-  interface HTMLCalciteTabTitleElement extends TabTitle {
-    addEventListener<K extends keyof HTMLCalciteTabTitleElementEventMap>(type: K, listener: (this: HTMLCalciteTabTitleElement, ev: CalciteTabTitleCustomEvent<HTMLCalciteTabTitleElementEventMap[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 HTMLCalciteTabTitleElementEventMap>(type: K, listener: (this: HTMLCalciteTabTitleElement, ev: CalciteTabTitleCustomEvent<HTMLCalciteTabTitleElementEventMap[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 HTMLCalciteTableElementEventMap {
-    "calciteTablePageChange": Table["calciteTablePageChange"]["detail"];
-    "calciteTableSelect": Table["calciteTableSelect"]["detail"];
-  }
+  type HTMLCalciteTableCellElement = TableCell;
 
-  interface HTMLCalciteTableElement extends Table {
-    addEventListener<K extends keyof HTMLCalciteTableElementEventMap>(type: K, listener: (this: HTMLCalciteTableElement, ev: CalciteTableCustomEvent<HTMLCalciteTableElementEventMap[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 HTMLCalciteTableElementEventMap>(type: K, listener: (this: HTMLCalciteTableElement, ev: CalciteTableCustomEvent<HTMLCalciteTableElementEventMap[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 HTMLCalciteTableCellElement extends TableCell {
+  type HTMLCalciteTableHeaderElement = TableHeader;
 
-  }
-  interface HTMLCalciteTableHeaderElement extends TableHeader {
+  type HTMLCalciteTableRowElementEventMap = TableRow["@eventTypes"];
+  type HTMLCalciteTableRowElement = TableRow;
 
-  }
-  interface HTMLCalciteTableRowElementEventMap {
-    "calciteTableRowSelect": TableRow["calciteTableRowSelect"]["detail"];
-  }
+  type HTMLCalciteTabsElement = Tabs;
 
-  interface HTMLCalciteTableRowElement extends TableRow {
-    addEventListener<K extends keyof HTMLCalciteTableRowElementEventMap>(type: K, listener: (this: HTMLCalciteTableRowElement, ev: CalciteTableRowCustomEvent<HTMLCalciteTableRowElementEventMap[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 HTMLCalciteTableRowElementEventMap>(type: K, listener: (this: HTMLCalciteTableRowElement, ev: CalciteTableRowCustomEvent<HTMLCalciteTableRowElementEventMap[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 HTMLCalciteTabsElement extends Tabs {
+  type HTMLCalciteTextAreaElementEventMap = TextArea["@eventTypes"];
+  type HTMLCalciteTextAreaElement = TextArea;
 
-  }
-  interface HTMLCalciteTextAreaElementEventMap {
-    "calciteTextAreaChange": TextArea["calciteTextAreaChange"]["detail"];
-    "calciteTextAreaInput": TextArea["calciteTextAreaInput"]["detail"];
-  }
+  type HTMLCalciteTileElementEventMap = Tile["@eventTypes"];
+  type HTMLCalciteTileElement = Tile;
 
-  interface HTMLCalciteTextAreaElement extends TextArea {
-    addEventListener<K extends keyof HTMLCalciteTextAreaElementEventMap>(type: K, listener: (this: HTMLCalciteTextAreaElement, ev: CalciteTextAreaCustomEvent<HTMLCalciteTextAreaElementEventMap[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 HTMLCalciteTextAreaElementEventMap>(type: K, listener: (this: HTMLCalciteTextAreaElement, ev: CalciteTextAreaCustomEvent<HTMLCalciteTextAreaElementEventMap[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 HTMLCalciteTileElementEventMap {
-    "calciteTileSelect": Tile["calciteTileSelect"]["detail"];
-  }
+  type HTMLCalciteTileGroupElementEventMap = TileGroup["@eventTypes"];
+  type HTMLCalciteTileGroupElement = TileGroup;
 
-  interface HTMLCalciteTileElement extends Tile {
-    addEventListener<K extends keyof HTMLCalciteTileElementEventMap>(type: K, listener: (this: HTMLCalciteTileElement, ev: CalciteTileCustomEvent<HTMLCalciteTileElementEventMap[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 HTMLCalciteTileElementEventMap>(type: K, listener: (this: HTMLCalciteTileElement, ev: CalciteTileCustomEvent<HTMLCalciteTileElementEventMap[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 HTMLCalciteTileGroupElementEventMap {
-    "calciteTileGroupSelect": TileGroup["calciteTileGroupSelect"]["detail"];
-  }
+  type HTMLCalciteTimePickerElementEventMap = TimePicker["@eventTypes"];
+  type HTMLCalciteTimePickerElement = TimePicker;
 
-  interface HTMLCalciteTileGroupElement extends TileGroup {
-    addEventListener<K extends keyof HTMLCalciteTileGroupElementEventMap>(type: K, listener: (this: HTMLCalciteTileGroupElement, ev: CalciteTileGroupCustomEvent<HTMLCalciteTileGroupElementEventMap[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 HTMLCalciteTileGroupElementEventMap>(type: K, listener: (this: HTMLCalciteTileGroupElement, ev: CalciteTileGroupCustomEvent<HTMLCalciteTileGroupElementEventMap[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 HTMLCalciteTimePickerElementEventMap {
-    "calciteTimePickerChange": TimePicker["calciteTimePickerChange"]["detail"];
-  }
+  type HTMLCalciteTooltipElementEventMap = Tooltip["@eventTypes"];
+  type HTMLCalciteTooltipElement = Tooltip;
 
-  interface HTMLCalciteTimePickerElement extends TimePicker {
-    addEventListener<K extends keyof HTMLCalciteTimePickerElementEventMap>(type: K, listener: (this: HTMLCalciteTimePickerElement, ev: CalciteTimePickerCustomEvent<HTMLCalciteTimePickerElementEventMap[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 HTMLCalciteTimePickerElementEventMap>(type: K, listener: (this: HTMLCalciteTimePickerElement, ev: CalciteTimePickerCustomEvent<HTMLCalciteTimePickerElementEventMap[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 HTMLCalciteTooltipElementEventMap {
-    "calciteTooltipBeforeClose": Tooltip["calciteTooltipBeforeClose"]["detail"];
-    "calciteTooltipBeforeOpen": Tooltip["calciteTooltipBeforeOpen"]["detail"];
-    "calciteTooltipClose": Tooltip["calciteTooltipClose"]["detail"];
-    "calciteTooltipOpen": Tooltip["calciteTooltipOpen"]["detail"];
-  }
+  type HTMLCalciteTreeElementEventMap = Tree["@eventTypes"];
+  type HTMLCalciteTreeElement = Tree;
 
-  interface HTMLCalciteTooltipElement extends Tooltip {
-    addEventListener<K extends keyof HTMLCalciteTooltipElementEventMap>(type: K, listener: (this: HTMLCalciteTooltipElement, ev: CalciteTooltipCustomEvent<HTMLCalciteTooltipElementEventMap[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 HTMLCalciteTooltipElementEventMap>(type: K, listener: (this: HTMLCalciteTooltipElement, ev: CalciteTooltipCustomEvent<HTMLCalciteTooltipElementEventMap[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 HTMLCalciteTreeElementEventMap {
-    "calciteTreeSelect": Tree["calciteTreeSelect"]["detail"];
-  }
+  type HTMLCalciteTreeItemElementEventMap = TreeItem["@eventTypes"];
+  type HTMLCalciteTreeItemElement = TreeItem;
 
-  interface HTMLCalciteTreeElement extends Tree {
-    addEventListener<K extends keyof HTMLCalciteTreeElementEventMap>(type: K, listener: (this: HTMLCalciteTreeElement, ev: CalciteTreeCustomEvent<HTMLCalciteTreeElementEventMap[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 HTMLCalciteTreeElementEventMap>(type: K, listener: (this: HTMLCalciteTreeElement, ev: CalciteTreeCustomEvent<HTMLCalciteTreeElementEventMap[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 HTMLCalciteTreeItemElementEventMap {
-    "calciteTreeItemCollapse": TreeItem["calciteTreeItemCollapse"]["detail"];
-    "calciteTreeItemExpand": TreeItem["calciteTreeItemExpand"]["detail"];
-    "calciteTreeItemSelect": TreeItem["calciteTreeItemSelect"]["detail"];
-  }
 
-  interface HTMLCalciteTreeItemElement extends TreeItem {
-    addEventListener<K extends keyof HTMLCalciteTreeItemElementEventMap>(type: K, listener: (this: HTMLCalciteTreeItemElement, ev: CalciteTreeItemCustomEvent<HTMLCalciteTreeItemElementEventMap[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 HTMLCalciteTreeItemElementEventMap>(type: K, listener: (this: HTMLCalciteTreeItemElement, ev: CalciteTreeItemCustomEvent<HTMLCalciteTreeItemElementEventMap[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;
-  }
 }