@esri/calcite-components/dist/index.d.ts

Web Components for Esri's Calcite Design System.

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