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 { Modal } from "./components/calcite-modal";
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 { ShellCenterRow } from "./components/calcite-shell-center-row";
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 { 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 { TileSelect } from "./components/calcite-tile-select";
import type { TileSelectGroup } from "./components/calcite-tile-select-group";
import type { TimePicker } from "./components/calcite-time-picker";
import type { Tip } from "./components/calcite-tip";
import type { TipGroup } from "./components/calcite-tip-group";
import type { TipManager } from "./components/calcite-tip-manager";
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';
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';


export interface CalciteActionBarCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteActionBarElement;
  currentTarget: HTMLCalciteActionBarElement;
}
export interface CalciteActionMenuCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteActionMenuElement;
  currentTarget: HTMLCalciteActionMenuElement;
}
export interface CalciteActionPadCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteActionPadElement;
  currentTarget: HTMLCalciteActionPadElement;
}
export interface CalciteAlertCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteAlertElement;
  currentTarget: HTMLCalciteAlertElement;
}
export interface CalciteAutocompleteCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteAutocompleteElement;
  currentTarget: HTMLCalciteAutocompleteElement;
}
export interface CalciteBlockCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteBlockElement;
  currentTarget: HTMLCalciteBlockElement;
}
export interface CalciteBlockGroupCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteBlockGroupElement;
  currentTarget: HTMLCalciteBlockGroupElement;
}
export interface CalciteBlockSectionCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteBlockSectionElement;
  currentTarget: HTMLCalciteBlockSectionElement;
}
export interface CalciteCardCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteCardElement;
  currentTarget: HTMLCalciteCardElement;
}
export interface CalciteCardGroupCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteCardGroupElement;
  currentTarget: HTMLCalciteCardGroupElement;
}
export interface CalciteCarouselCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteCarouselElement;
  currentTarget: HTMLCalciteCarouselElement;
}
export interface CalciteCheckboxCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteCheckboxElement;
  currentTarget: HTMLCalciteCheckboxElement;
}
export interface CalciteChipCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteChipElement;
  currentTarget: HTMLCalciteChipElement;
}
export interface CalciteChipGroupCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteChipGroupElement;
  currentTarget: HTMLCalciteChipGroupElement;
}
export interface CalciteColorPickerCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteColorPickerElement;
  currentTarget: HTMLCalciteColorPickerElement;
}
export interface CalciteColorPickerHexInputCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteColorPickerHexInputElement;
  currentTarget: HTMLCalciteColorPickerHexInputElement;
}
export interface CalciteComboboxCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteComboboxElement;
  currentTarget: HTMLCalciteComboboxElement;
}
export interface CalciteComboboxItemCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteComboboxItemElement;
  currentTarget: HTMLCalciteComboboxItemElement;
}
export interface CalciteDatePickerCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteDatePickerElement;
  currentTarget: HTMLCalciteDatePickerElement;
}
export interface CalciteDialogCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteDialogElement;
  currentTarget: HTMLCalciteDialogElement;
}
export interface CalciteDropdownCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteDropdownElement;
  currentTarget: HTMLCalciteDropdownElement;
}
export interface CalciteDropdownItemCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteDropdownItemElement;
  currentTarget: HTMLCalciteDropdownItemElement;
}
export interface CalciteFilterCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteFilterElement;
  currentTarget: HTMLCalciteFilterElement;
}
export interface CalciteFlowItemCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteFlowItemElement;
  currentTarget: HTMLCalciteFlowItemElement;
}
export interface CalciteHandleCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteHandleElement;
  currentTarget: HTMLCalciteHandleElement;
}
export interface CalciteInlineEditableCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteInlineEditableElement;
  currentTarget: HTMLCalciteInlineEditableElement;
}
export interface CalciteInputCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteInputElement;
  currentTarget: HTMLCalciteInputElement;
}
export interface CalciteInputDatePickerCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteInputDatePickerElement;
  currentTarget: HTMLCalciteInputDatePickerElement;
}
export interface CalciteInputNumberCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteInputNumberElement;
  currentTarget: HTMLCalciteInputNumberElement;
}
export interface CalciteInputTextCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteInputTextElement;
  currentTarget: HTMLCalciteInputTextElement;
}
export interface CalciteInputTimePickerCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteInputTimePickerElement;
  currentTarget: HTMLCalciteInputTimePickerElement;
}
export interface CalciteInputTimeZoneCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteInputTimeZoneElement;
  currentTarget: HTMLCalciteInputTimeZoneElement;
}
export interface CalciteListCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteListElement;
  currentTarget: HTMLCalciteListElement;
}
export interface CalciteListItemCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteListItemElement;
  currentTarget: HTMLCalciteListItemElement;
}
export interface CalciteMenuItemCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteMenuItemElement;
  currentTarget: HTMLCalciteMenuItemElement;
}
export interface CalciteModalCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteModalElement;
  currentTarget: HTMLCalciteModalElement;
}
export interface CalciteNavigationCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteNavigationElement;
  currentTarget: HTMLCalciteNavigationElement;
}
export interface CalciteNoticeCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteNoticeElement;
  currentTarget: HTMLCalciteNoticeElement;
}
export interface CalcitePaginationCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalcitePaginationElement;
  currentTarget: HTMLCalcitePaginationElement;
}
export interface CalcitePanelCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalcitePanelElement;
  currentTarget: HTMLCalcitePanelElement;
}
export interface CalcitePopoverCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalcitePopoverElement;
  currentTarget: HTMLCalcitePopoverElement;
}
export interface CalciteRadioButtonCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteRadioButtonElement;
  currentTarget: HTMLCalciteRadioButtonElement;
}
export interface CalciteRadioButtonGroupCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteRadioButtonGroupElement;
  currentTarget: HTMLCalciteRadioButtonGroupElement;
}
export interface CalciteRatingCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteRatingElement;
  currentTarget: HTMLCalciteRatingElement;
}
export interface CalciteSegmentedControlCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteSegmentedControlElement;
  currentTarget: HTMLCalciteSegmentedControlElement;
}
export interface CalciteSelectCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteSelectElement;
  currentTarget: HTMLCalciteSelectElement;
}
export interface CalciteSheetCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteSheetElement;
  currentTarget: HTMLCalciteSheetElement;
}
export interface CalciteSliderCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteSliderElement;
  currentTarget: HTMLCalciteSliderElement;
}
export interface CalciteSortHandleCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteSortHandleElement;
  currentTarget: HTMLCalciteSortHandleElement;
}
export interface CalciteSortableListCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteSortableListElement;
  currentTarget: HTMLCalciteSortableListElement;
}
export interface CalciteSplitButtonCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteSplitButtonElement;
  currentTarget: HTMLCalciteSplitButtonElement;
}
export interface CalciteStepperCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteStepperElement;
  currentTarget: HTMLCalciteStepperElement;
}
export interface CalciteStepperItemCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteStepperItemElement;
  currentTarget: HTMLCalciteStepperItemElement;
}
export interface CalciteSwitchCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteSwitchElement;
  currentTarget: HTMLCalciteSwitchElement;
}
export interface CalciteTabNavCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteTabNavElement;
  currentTarget: HTMLCalciteTabNavElement;
}
export interface CalciteTabTitleCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteTabTitleElement;
  currentTarget: HTMLCalciteTabTitleElement;
}
export interface CalciteTableCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteTableElement;
  currentTarget: HTMLCalciteTableElement;
}
export interface CalciteTableRowCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteTableRowElement;
  currentTarget: HTMLCalciteTableRowElement;
}
export interface CalciteTextAreaCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteTextAreaElement;
  currentTarget: HTMLCalciteTextAreaElement;
}
export interface CalciteTileCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteTileElement;
  currentTarget: HTMLCalciteTileElement;
}
export interface CalciteTileGroupCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteTileGroupElement;
  currentTarget: HTMLCalciteTileGroupElement;
}
export interface CalciteTileSelectCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteTileSelectElement;
  currentTarget: HTMLCalciteTileSelectElement;
}
export interface CalciteTimePickerCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteTimePickerElement;
  currentTarget: HTMLCalciteTimePickerElement;
}
export interface CalciteTipCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteTipElement;
  currentTarget: HTMLCalciteTipElement;
}
export interface CalciteTipManagerCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteTipManagerElement;
  currentTarget: HTMLCalciteTipManagerElement;
}
export interface CalciteTooltipCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteTooltipElement;
  currentTarget: HTMLCalciteTooltipElement;
}
export interface CalciteTreeCustomEvent<T> extends CustomEvent<T> {
  detail: T;
  target: HTMLCalciteTreeElement;
  currentTarget: HTMLCalciteTreeElement;
}

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-modal": HTMLCalciteModalElement;
    "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-center-row": HTMLCalciteShellCenterRowElement;
    "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-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-tile-select": HTMLCalciteTileSelectElement;
    "calcite-tile-select-group": HTMLCalciteTileSelectGroupElement;
    "calcite-time-picker": HTMLCalciteTimePickerElement;
    "calcite-tip": HTMLCalciteTipElement;
    "calcite-tip-group": HTMLCalciteTipGroupElement;
    "calcite-tip-manager": HTMLCalciteTipManagerElement;
    "calcite-tooltip": HTMLCalciteTooltipElement;
    "calcite-tree": HTMLCalciteTreeElement;
    "calcite-tree-item": HTMLCalciteTreeItemElement;
  }

  interface HTMLCalciteAccordionElement extends Accordion {

  }
  interface HTMLCalciteAccordionItemElement extends AccordionItem {

  }
  interface HTMLCalciteActionElement extends Action {

  }
  interface HTMLCalciteActionBarElementEventMap {
    "calciteActionBarToggle": ActionBar["calciteActionBarToggle"]["detail"];
  }

  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 HTMLCalciteActionGroupElement extends ActionGroup {

  }
  interface HTMLCalciteActionMenuElementEventMap {
    "calciteActionMenuOpen": ActionMenu["calciteActionMenuOpen"]["detail"];
  }

  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 {
    "calciteActionPadToggle": ActionPad["calciteActionPadToggle"]["detail"];
  }

  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"];
  }

  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"];
  }

  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 HTMLCalciteAutocompleteItemElement extends AutocompleteItem {

  }
  interface HTMLCalciteAutocompleteItemGroupElement extends AutocompleteItemGroup {

  }
  interface HTMLCalciteAvatarElement extends Avatar {

  }
  interface HTMLCalciteBlockElementEventMap {
    "calciteBlockBeforeClose": Block["calciteBlockBeforeClose"]["detail"];
    "calciteBlockBeforeOpen": Block["calciteBlockBeforeOpen"]["detail"];
    "calciteBlockClose": Block["calciteBlockClose"]["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"];
  }

  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"];
  }

  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 {
    "calciteBlockSectionToggle": BlockSection["calciteBlockSectionToggle"]["detail"];
  }

  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 {

  }
  interface HTMLCalciteCardElementEventMap {
    "calciteCardSelect": Card["calciteCardSelect"]["detail"];
  }

  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"];
  }

  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"];
  }

  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 {

  }
  interface HTMLCalciteCheckboxElementEventMap {
    "calciteCheckboxChange": Checkbox["calciteCheckboxChange"]["detail"];
  }

  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"];
  }

  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"];
  }

  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"];
  }

  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"];
  }

  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 {

  }
  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"];
  }

  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"];
  }

  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 {

  }
  interface HTMLCalciteDatePickerElementEventMap {
    "calciteDatePickerChange": DatePicker["calciteDatePickerChange"]["detail"];
    "calciteDatePickerRangeChange": DatePicker["calciteDatePickerRangeChange"]["detail"];
  }

  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 {

  }
  interface HTMLCalciteDatePickerMonthElement extends DatePickerMonth {

  }
  interface HTMLCalciteDatePickerMonthHeaderElement extends DatePickerMonthHeader {

  }
  interface HTMLCalciteDialogElementEventMap {
    "calciteDialogBeforeClose": Dialog["calciteDialogBeforeClose"]["detail"];
    "calciteDialogBeforeOpen": Dialog["calciteDialogBeforeOpen"]["detail"];
    "calciteDialogClose": Dialog["calciteDialogClose"]["detail"];
    "calciteDialogOpen": Dialog["calciteDialogOpen"]["detail"];
    "calciteDialogScroll": Dialog["calciteDialogScroll"]["detail"];
  }

  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"];
  }

  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 {

  }
  interface HTMLCalciteDropdownItemElementEventMap {
    "calciteDropdownItemSelect": DropdownItem["calciteDropdownItemSelect"]["detail"];
  }

  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 {

  }
  interface HTMLCalciteFilterElementEventMap {
    "calciteFilterChange": Filter["calciteFilterChange"]["detail"];
  }

  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 {

  }
  interface HTMLCalciteFlowItemElementEventMap {
    "calciteFlowItemBack": FlowItem["calciteFlowItemBack"]["detail"];
    "calciteFlowItemClose": FlowItem["calciteFlowItemClose"]["detail"];
    "calciteFlowItemScroll": FlowItem["calciteFlowItemScroll"]["detail"];
    "calciteFlowItemToggle": FlowItem["calciteFlowItemToggle"]["detail"];
  }

  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 {

  }
  interface HTMLCalciteHandleElementEventMap {
    "calciteHandleChange": Handle["calciteHandleChange"]["detail"];
    "calciteHandleNudge": Handle["calciteHandleNudge"]["detail"];
  }

  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 {

  }
  interface HTMLCalciteInlineEditableElementEventMap {
    "calciteInlineEditableEditCancel": InlineEditable["calciteInlineEditableEditCancel"]["detail"];
    "calciteInlineEditableEditConfirm": InlineEditable["calciteInlineEditableEditConfirm"]["detail"];
  }

  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"];
  }

  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"];
  }

  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 {

  }
  interface HTMLCalciteInputNumberElementEventMap {
    "calciteInputNumberChange": InputNumber["calciteInputNumberChange"]["detail"];
    "calciteInputNumberInput": InputNumber["calciteInputNumberInput"]["detail"];
  }

  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"];
  }

  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"];
  }

  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"];
  }

  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 {

  }
  interface HTMLCalciteLinkElement extends Link {

  }
  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"];
    "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 HTMLCalciteModalElementEventMap {
    "calciteModalBeforeClose": Modal["calciteModalBeforeClose"]["detail"];
    "calciteModalBeforeOpen": Modal["calciteModalBeforeOpen"]["detail"];
    "calciteModalClose": Modal["calciteModalClose"]["detail"];
    "calciteModalOpen": Modal["calciteModalOpen"]["detail"];
  }

  interface HTMLCalciteModalElement extends Modal {
    addEventListener<K extends keyof HTMLCalciteModalElementEventMap>(type: K, listener: (this: HTMLCalciteModalElement, ev: CalciteModalCustomEvent<HTMLCalciteModalElementEventMap[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 HTMLCalciteModalElementEventMap>(type: K, listener: (this: HTMLCalciteModalElement, ev: CalciteModalCustomEvent<HTMLCalciteModalElementEventMap[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 HTMLCalciteNavigationElementEventMap {
    "calciteNavigationActionSelect": Navigation["calciteNavigationActionSelect"]["detail"];
  }

  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"];
  }

  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 {

  }
  interface HTMLCalciteOptionGroupElement extends OptionGroup {

  }
  interface HTMLCalcitePaginationElementEventMap {
    "calcitePaginationChange": Pagination["calcitePaginationChange"]["detail"];
  }

  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"];
    "calcitePanelScroll": Panel["calcitePanelScroll"]["detail"];
    "calcitePanelToggle": Panel["calcitePanelToggle"]["detail"];
  }

  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"];
  }

  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 {

  }
  interface HTMLCalciteRadioButtonElementEventMap {
    "calciteRadioButtonChange": RadioButton["calciteRadioButtonChange"]["detail"];
  }

  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"];
  }

  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"];
  }

  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 {

  }
  interface HTMLCalciteSegmentedControlElementEventMap {
    "calciteSegmentedControlChange": SegmentedControl["calciteSegmentedControlChange"]["detail"];
  }

  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 {

  }
  interface HTMLCalciteSelectElementEventMap {
    "calciteSelectChange": Select["calciteSelectChange"]["detail"];
  }

  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"];
  }

  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 {

  }
  interface HTMLCalciteShellCenterRowElement extends ShellCenterRow {

  }
  interface HTMLCalciteShellPanelElement extends ShellPanel {

  }
  interface HTMLCalciteSliderElementEventMap {
    "calciteSliderChange": Slider["calciteSliderChange"]["detail"];
    "calciteSliderInput": Slider["calciteSliderInput"]["detail"];
  }

  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 {
    "calciteSortHandleBeforeClose": SortHandle["calciteSortHandleBeforeClose"]["detail"];
    "calciteSortHandleBeforeOpen": SortHandle["calciteSortHandleBeforeOpen"]["detail"];
    "calciteSortHandleClose": SortHandle["calciteSortHandleClose"]["detail"];
    "calciteSortHandleMove": SortHandle["calciteSortHandleMove"]["detail"];
    "calciteSortHandleOpen": SortHandle["calciteSortHandleOpen"]["detail"];
    "calciteSortHandleReorder": SortHandle["calciteSortHandleReorder"]["detail"];
  }

  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"];
  }

  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"];
  }

  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 {

  }
  interface HTMLCalciteStepperElementEventMap {
    "calciteStepperChange": Stepper["calciteStepperChange"]["detail"];
    "calciteStepperItemChange": Stepper["calciteStepperItemChange"]["detail"];
  }

  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"];
  }

  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 HTMLCalciteSwitchElementEventMap {
    "calciteSwitchChange": Switch["calciteSwitchChange"]["detail"];
  }

  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 {

  }
  interface HTMLCalciteTabNavElementEventMap {
    "calciteTabChange": TabNav["calciteTabChange"]["detail"];
  }

  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"];
  }

  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"];
  }

  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 {

  }
  interface HTMLCalciteTableHeaderElement extends TableHeader {

  }
  interface HTMLCalciteTableRowElementEventMap {
    "calciteTableRowSelect": TableRow["calciteTableRowSelect"]["detail"];
  }

  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 {

  }
  interface HTMLCalciteTextAreaElementEventMap {
    "calciteTextAreaChange": TextArea["calciteTextAreaChange"]["detail"];
    "calciteTextAreaInput": TextArea["calciteTextAreaInput"]["detail"];
  }

  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"];
  }

  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"];
  }

  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 HTMLCalciteTileSelectElementEventMap {
    "calciteTileSelectChange": TileSelect["calciteTileSelectChange"]["detail"];
  }

  interface HTMLCalciteTileSelectElement extends TileSelect {
    addEventListener<K extends keyof HTMLCalciteTileSelectElementEventMap>(type: K, listener: (this: HTMLCalciteTileSelectElement, ev: CalciteTileSelectCustomEvent<HTMLCalciteTileSelectElementEventMap[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 HTMLCalciteTileSelectElementEventMap>(type: K, listener: (this: HTMLCalciteTileSelectElement, ev: CalciteTileSelectCustomEvent<HTMLCalciteTileSelectElementEventMap[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 HTMLCalciteTileSelectGroupElement extends TileSelectGroup {

  }
  interface HTMLCalciteTimePickerElementEventMap {
    "calciteTimePickerChange": TimePicker["calciteTimePickerChange"]["detail"];
  }

  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 HTMLCalciteTipElementEventMap {
    "calciteTipDismiss": Tip["calciteTipDismiss"]["detail"];
  }

  interface HTMLCalciteTipElement extends Tip {
    addEventListener<K extends keyof HTMLCalciteTipElementEventMap>(type: K, listener: (this: HTMLCalciteTipElement, ev: CalciteTipCustomEvent<HTMLCalciteTipElementEventMap[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 HTMLCalciteTipElementEventMap>(type: K, listener: (this: HTMLCalciteTipElement, ev: CalciteTipCustomEvent<HTMLCalciteTipElementEventMap[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 HTMLCalciteTipGroupElement extends TipGroup {

  }
  interface HTMLCalciteTipManagerElementEventMap {
    "calciteTipManagerClose": TipManager["calciteTipManagerClose"]["detail"];
  }

  interface HTMLCalciteTipManagerElement extends TipManager {
    addEventListener<K extends keyof HTMLCalciteTipManagerElementEventMap>(type: K, listener: (this: HTMLCalciteTipManagerElement, ev: CalciteTipManagerCustomEvent<HTMLCalciteTipManagerElementEventMap[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 HTMLCalciteTipManagerElementEventMap>(type: K, listener: (this: HTMLCalciteTipManagerElement, ev: CalciteTipManagerCustomEvent<HTMLCalciteTipManagerElementEventMap[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"];
  }

  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"];
  }

  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 HTMLCalciteTreeItemElement extends TreeItem {

  }
}