/// <reference types="../index.d.ts" />
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 type { HTMLProps } from 'react';
import type { EventHandler } from "@arcgis/lumina"; 

interface ReactCalciteAccordion extends Partial<Pick<Accordion, 'appearance' | 'iconPosition' | 'iconType' | 'scale' | 'selectionMode'>>, HTMLProps<HTMLCalciteAccordionElement> {
}

interface ReactCalciteAccordionItem extends Partial<Pick<AccordionItem, 'description' | 'expanded' | 'heading' | 'iconEnd' | 'iconFlipRtl' | 'iconStart'>>, HTMLProps<HTMLCalciteAccordionItemElement> {
}

interface ReactCalciteAction extends Required<Pick<Action, 'text'>>, Partial<Pick<Action, 'active' | 'alignment' | 'appearance' | 'compact' | 'disabled' | 'icon' | 'iconFlipRtl' | 'indicator' | 'label' | 'loading' | 'messageOverrides' | 'scale' | 'textEnabled'>>, HTMLProps<HTMLCalciteActionElement> {
}

interface ReactCalciteActionBar extends Partial<Pick<ActionBar, 'actionsEndGroupLabel' | 'expandDisabled' | 'expanded' | 'floating' | 'layout' | 'messageOverrides' | 'overflowActionsDisabled' | 'overlayPositioning' | 'position' | 'scale'>>, HTMLProps<HTMLCalciteActionBarElement> {
  oncalciteActionBarToggle?: EventHandler<HTMLCalciteActionBarElement["calciteActionBarToggle"]>;
}

interface ReactCalciteActionGroup extends Partial<Pick<ActionGroup, 'columns' | 'expanded' | 'label' | 'layout' | 'menuFlipPlacements' | 'menuOpen' | 'menuPlacement' | 'messageOverrides' | 'overlayPositioning' | 'scale'>>, HTMLProps<HTMLCalciteActionGroupElement> {
}

interface ReactCalciteActionMenu extends Required<Pick<ActionMenu, 'label'>>, Partial<Pick<ActionMenu, 'appearance' | 'expanded' | 'flipPlacements' | 'open' | 'overlayPositioning' | 'placement' | 'scale'>>, HTMLProps<HTMLCalciteActionMenuElement> {
  oncalciteActionMenuOpen?: EventHandler<HTMLCalciteActionMenuElement["calciteActionMenuOpen"]>;
}

interface ReactCalciteActionPad extends Partial<Pick<ActionPad, 'actionsEndGroupLabel' | 'expandDisabled' | 'expanded' | 'layout' | 'messageOverrides' | 'overlayPositioning' | 'position' | 'scale'>>, HTMLProps<HTMLCalciteActionPadElement> {
  oncalciteActionPadToggle?: EventHandler<HTMLCalciteActionPadElement["calciteActionPadToggle"]>;
}

interface ReactCalciteAlert extends Required<Pick<Alert, 'label'>>, Partial<Pick<Alert, 'autoClose' | 'autoCloseDuration' | 'icon' | 'iconFlipRtl' | 'kind' | 'messageOverrides' | 'numberingSystem' | 'open' | 'placement' | 'queue' | 'scale'>>, HTMLProps<HTMLCalciteAlertElement> {
  oncalciteAlertBeforeClose?: EventHandler<HTMLCalciteAlertElement["calciteAlertBeforeClose"]>;
  oncalciteAlertBeforeOpen?: EventHandler<HTMLCalciteAlertElement["calciteAlertBeforeOpen"]>;
  oncalciteAlertClose?: EventHandler<HTMLCalciteAlertElement["calciteAlertClose"]>;
  oncalciteAlertOpen?: EventHandler<HTMLCalciteAlertElement["calciteAlertOpen"]>;
}

interface ReactCalciteAutocomplete extends Partial<Pick<Autocomplete, 'alignment' | 'autocomplete' | 'disabled' | 'flipPlacements' | 'form' | 'icon' | 'iconFlipRtl' | 'inputValue' | 'label' | 'loading' | 'maxLength' | 'messageOverrides' | 'minLength' | 'name' | 'open' | 'overlayPositioning' | 'pattern' | 'placeholder' | 'placement' | 'prefixText' | 'readOnly' | 'required' | 'scale' | 'status' | 'suffixText' | 'validationIcon' | 'validationMessage' | 'value'>>, HTMLProps<HTMLCalciteAutocompleteElement> {
  oncalciteAutocompleteBeforeClose?: EventHandler<HTMLCalciteAutocompleteElement["calciteAutocompleteBeforeClose"]>;
  oncalciteAutocompleteBeforeOpen?: EventHandler<HTMLCalciteAutocompleteElement["calciteAutocompleteBeforeOpen"]>;
  oncalciteAutocompleteChange?: EventHandler<HTMLCalciteAutocompleteElement["calciteAutocompleteChange"]>;
  oncalciteAutocompleteClose?: EventHandler<HTMLCalciteAutocompleteElement["calciteAutocompleteClose"]>;
  oncalciteAutocompleteOpen?: EventHandler<HTMLCalciteAutocompleteElement["calciteAutocompleteOpen"]>;
  oncalciteAutocompleteTextChange?: EventHandler<HTMLCalciteAutocompleteElement["calciteAutocompleteTextChange"]>;
  oncalciteAutocompleteTextInput?: EventHandler<HTMLCalciteAutocompleteElement["calciteAutocompleteTextInput"]>;
}

interface ReactCalciteAutocompleteItem extends Required<Pick<AutocompleteItem, 'heading'>>, Partial<Pick<AutocompleteItem, 'description' | 'disabled' | 'iconEnd' | 'iconFlipRtl' | 'iconStart' | 'label' | 'value'>>, HTMLProps<HTMLCalciteAutocompleteItemElement> {
}

interface ReactCalciteAutocompleteItemGroup extends Required<Pick<AutocompleteItemGroup, 'heading'>>, Partial<Pick<AutocompleteItemGroup, 'label'>>, HTMLProps<HTMLCalciteAutocompleteItemGroupElement> {
}

interface ReactCalciteAvatar extends Partial<Pick<Avatar, 'fullName' | 'label' | 'scale' | 'thumbnail' | 'userId' | 'username'>>, HTMLProps<HTMLCalciteAvatarElement> {
}

interface ReactCalciteBlock extends Partial<Pick<Block, 'collapsible' | 'description' | 'disabled' | 'dragDisabled' | 'dragHandle' | 'expanded' | 'heading' | 'headingLevel' | 'iconEnd' | 'iconFlipRtl' | 'iconStart' | 'label' | 'loading' | 'menuFlipPlacements' | 'menuPlacement' | 'messageOverrides' | 'open' | 'overlayPositioning' | 'sortHandleOpen' | 'status'>>, HTMLProps<HTMLCalciteBlockElement> {
  oncalciteBlockBeforeClose?: EventHandler<HTMLCalciteBlockElement["calciteBlockBeforeClose"]>;
  oncalciteBlockBeforeOpen?: EventHandler<HTMLCalciteBlockElement["calciteBlockBeforeOpen"]>;
  oncalciteBlockClose?: EventHandler<HTMLCalciteBlockElement["calciteBlockClose"]>;
  oncalciteBlockOpen?: EventHandler<HTMLCalciteBlockElement["calciteBlockOpen"]>;
  oncalciteBlockSortHandleBeforeClose?: EventHandler<HTMLCalciteBlockElement["calciteBlockSortHandleBeforeClose"]>;
  oncalciteBlockSortHandleBeforeOpen?: EventHandler<HTMLCalciteBlockElement["calciteBlockSortHandleBeforeOpen"]>;
  oncalciteBlockSortHandleClose?: EventHandler<HTMLCalciteBlockElement["calciteBlockSortHandleClose"]>;
  oncalciteBlockSortHandleOpen?: EventHandler<HTMLCalciteBlockElement["calciteBlockSortHandleOpen"]>;
  oncalciteBlockToggle?: EventHandler<HTMLCalciteBlockElement["calciteBlockToggle"]>;
}

interface ReactCalciteBlockGroup extends Required<Pick<BlockGroup, 'label'>>, Partial<Pick<BlockGroup, 'canPull' | 'canPut' | 'disabled' | 'dragEnabled' | 'group' | 'loading'>>, HTMLProps<HTMLCalciteBlockGroupElement> {
  oncalciteBlockGroupDragEnd?: EventHandler<HTMLCalciteBlockGroupElement["calciteBlockGroupDragEnd"]>;
  oncalciteBlockGroupDragStart?: EventHandler<HTMLCalciteBlockGroupElement["calciteBlockGroupDragStart"]>;
  oncalciteBlockGroupMoveHalt?: EventHandler<HTMLCalciteBlockGroupElement["calciteBlockGroupMoveHalt"]>;
  oncalciteBlockGroupOrderChange?: EventHandler<HTMLCalciteBlockGroupElement["calciteBlockGroupOrderChange"]>;
}

interface ReactCalciteBlockSection extends Partial<Pick<BlockSection, 'expanded' | 'iconEnd' | 'iconFlipRtl' | 'iconStart' | 'messageOverrides' | 'open' | 'status' | 'text' | 'toggleDisplay'>>, HTMLProps<HTMLCalciteBlockSectionElement> {
  oncalciteBlockSectionToggle?: EventHandler<HTMLCalciteBlockSectionElement["calciteBlockSectionToggle"]>;
}

interface ReactCalciteButton extends Partial<Pick<Button, 'alignment' | 'appearance' | 'disabled' | 'download' | 'form' | 'href' | 'iconEnd' | 'iconFlipRtl' | 'iconStart' | 'kind' | 'label' | 'loading' | 'messageOverrides' | 'name' | 'rel' | 'round' | 'scale' | 'splitChild' | 'target' | 'type' | 'width'>>, HTMLProps<HTMLCalciteButtonElement> {
}

interface ReactCalciteCard extends Partial<Pick<Card, 'disabled' | 'label' | 'loading' | 'messageOverrides' | 'selectable' | 'selected' | 'thumbnailPosition'>>, HTMLProps<HTMLCalciteCardElement> {
  oncalciteCardSelect?: EventHandler<HTMLCalciteCardElement["calciteCardSelect"]>;
}

interface ReactCalciteCardGroup extends Required<Pick<CardGroup, 'label'>>, Partial<Pick<CardGroup, 'disabled' | 'selectionMode'>>, HTMLProps<HTMLCalciteCardGroupElement> {
  oncalciteCardGroupSelect?: EventHandler<HTMLCalciteCardGroupElement["calciteCardGroupSelect"]>;
}

interface ReactCalciteCarousel extends Required<Pick<Carousel, 'label'>>, Partial<Pick<Carousel, 'arrowType' | 'autoplay' | 'autoplayDuration' | 'controlOverlay' | 'disabled' | 'messageOverrides'>>, HTMLProps<HTMLCalciteCarouselElement> {
  oncalciteCarouselChange?: EventHandler<HTMLCalciteCarouselElement["calciteCarouselChange"]>;
  oncalciteCarouselPause?: EventHandler<HTMLCalciteCarouselElement["calciteCarouselPause"]>;
  oncalciteCarouselPlay?: EventHandler<HTMLCalciteCarouselElement["calciteCarouselPlay"]>;
  oncalciteCarouselResume?: EventHandler<HTMLCalciteCarouselElement["calciteCarouselResume"]>;
  oncalciteCarouselStop?: EventHandler<HTMLCalciteCarouselElement["calciteCarouselStop"]>;
}

interface ReactCalciteCarouselItem extends Required<Pick<CarouselItem, 'label'>>, Partial<Pick<CarouselItem, 'selected'>>, HTMLProps<HTMLCalciteCarouselItemElement> {
}

interface ReactCalciteCheckbox extends Partial<Pick<Checkbox, 'checked' | 'disabled' | 'form' | 'indeterminate' | 'label' | 'name' | 'required' | 'scale' | 'status' | 'value'>>, HTMLProps<HTMLCalciteCheckboxElement> {
  oncalciteCheckboxChange?: EventHandler<HTMLCalciteCheckboxElement["calciteCheckboxChange"]>;
}

interface ReactCalciteChip extends Required<Pick<Chip, 'label'>>, Partial<Pick<Chip, 'appearance' | 'closable' | 'closed' | 'closeOnDelete' | 'disabled' | 'icon' | 'iconFlipRtl' | 'kind' | 'messageOverrides' | 'scale' | 'selected' | 'value'>>, HTMLProps<HTMLCalciteChipElement> {
  oncalciteChipClose?: EventHandler<HTMLCalciteChipElement["calciteChipClose"]>;
  oncalciteChipSelect?: EventHandler<HTMLCalciteChipElement["calciteChipSelect"]>;
}

interface ReactCalciteChipGroup extends Required<Pick<ChipGroup, 'label'>>, Partial<Pick<ChipGroup, 'disabled' | 'scale' | 'selectionMode'>>, HTMLProps<HTMLCalciteChipGroupElement> {
  oncalciteChipGroupSelect?: EventHandler<HTMLCalciteChipGroupElement["calciteChipGroupSelect"]>;
}

interface ReactCalciteColorPicker extends Partial<Pick<ColorPicker, 'allowEmpty' | 'alphaChannel' | 'channelsDisabled' | 'clearable' | 'disabled' | 'format' | 'hexDisabled' | 'messageOverrides' | 'numberingSystem' | 'savedDisabled' | 'scale' | 'storageId' | 'value'>>, HTMLProps<HTMLCalciteColorPickerElement> {
  oncalciteColorPickerChange?: EventHandler<HTMLCalciteColorPickerElement["calciteColorPickerChange"]>;
  oncalciteColorPickerInput?: EventHandler<HTMLCalciteColorPickerElement["calciteColorPickerInput"]>;
}

interface ReactCalciteColorPickerHexInput extends Partial<Pick<ColorPickerHexInput, 'allowEmpty' | 'alphaChannel' | 'hexLabel' | 'numberingSystem' | 'scale' | 'value'>>, HTMLProps<HTMLCalciteColorPickerHexInputElement> {
  oncalciteColorPickerHexInputChange?: EventHandler<HTMLCalciteColorPickerHexInputElement["calciteColorPickerHexInputChange"]>;
}

interface ReactCalciteColorPickerSwatch extends Partial<Pick<ColorPickerSwatch, 'active' | 'color' | 'scale'>>, HTMLProps<HTMLCalciteColorPickerSwatchElement> {
}

interface ReactCalciteCombobox extends Required<Pick<Combobox, 'label'>>, Partial<Pick<Combobox, 'allowCustomValues' | 'clearDisabled' | 'disabled' | 'filterProps' | 'filterText' | 'flipPlacements' | 'form' | 'maxItems' | 'messageOverrides' | 'name' | 'open' | 'overlayPositioning' | 'placeholder' | 'placeholderIcon' | 'placeholderIconFlipRtl' | 'readOnly' | 'required' | 'scale' | 'selectAllEnabled' | 'selectionDisplay' | 'selectionMode' | 'status' | 'validationIcon' | 'validationMessage' | 'value'>>, HTMLProps<HTMLCalciteComboboxElement> {
  oncalciteComboboxBeforeClose?: EventHandler<HTMLCalciteComboboxElement["calciteComboboxBeforeClose"]>;
  oncalciteComboboxBeforeOpen?: EventHandler<HTMLCalciteComboboxElement["calciteComboboxBeforeOpen"]>;
  oncalciteComboboxChange?: EventHandler<HTMLCalciteComboboxElement["calciteComboboxChange"]>;
  oncalciteComboboxChipClose?: EventHandler<HTMLCalciteComboboxElement["calciteComboboxChipClose"]>;
  oncalciteComboboxClose?: EventHandler<HTMLCalciteComboboxElement["calciteComboboxClose"]>;
  oncalciteComboboxFilterChange?: EventHandler<HTMLCalciteComboboxElement["calciteComboboxFilterChange"]>;
  oncalciteComboboxOpen?: EventHandler<HTMLCalciteComboboxElement["calciteComboboxOpen"]>;
}

interface ReactCalciteComboboxItem extends Required<Pick<ComboboxItem, 'value'>>, Partial<Pick<ComboboxItem, 'active' | 'ancestors' | 'description' | 'disabled' | 'filterDisabled' | 'guid' | 'heading' | 'icon' | 'iconFlipRtl' | 'label' | 'metadata' | 'selected' | 'shortHeading' | 'textLabel'>>, HTMLProps<HTMLCalciteComboboxItemElement> {
  oncalciteComboboxItemChange?: EventHandler<HTMLCalciteComboboxItemElement["calciteComboboxItemChange"]>;
}

interface ReactCalciteComboboxItemGroup extends Required<Pick<ComboboxItemGroup, 'label'>>, Partial<Pick<ComboboxItemGroup, 'ancestors'>>, HTMLProps<HTMLCalciteComboboxItemGroupElement> {
}

interface ReactCalciteDatePicker extends Partial<Pick<DatePicker, 'activeDate' | 'activeRange' | 'headingLevel' | 'layout' | 'max' | 'maxAsDate' | 'messageOverrides' | 'min' | 'minAsDate' | 'monthStyle' | 'numberingSystem' | 'proximitySelectionDisabled' | 'range' | 'scale' | 'value' | 'valueAsDate'>>, HTMLProps<HTMLCalciteDatePickerElement> {
  oncalciteDatePickerChange?: EventHandler<HTMLCalciteDatePickerElement["calciteDatePickerChange"]>;
  oncalciteDatePickerRangeChange?: EventHandler<HTMLCalciteDatePickerElement["calciteDatePickerRangeChange"]>;
}

interface ReactCalciteDatePickerDay extends Required<Pick<DatePickerDay, 'day'>>, Partial<Pick<DatePickerDay, 'active' | 'currentMonth' | 'disabled' | 'endOfRange' | 'highlighted' | 'range' | 'rangeHover' | 'scale' | 'selected' | 'startOfRange' | 'value'>>, HTMLProps<HTMLCalciteDatePickerDayElement> {
}

interface ReactCalciteDatePickerMonth extends Partial<Pick<DatePickerMonth, 'activeDate' | 'endDate' | 'headingLevel' | 'hoverRange' | 'max' | 'min' | 'monthStyle' | 'range' | 'scale' | 'selectedDate' | 'startDate'>>, HTMLProps<HTMLCalciteDatePickerMonthElement> {
}

interface ReactCalciteDatePickerMonthHeader extends Partial<Pick<DatePickerMonthHeader, 'activeDate' | 'headingLevel' | 'localeData' | 'max' | 'min' | 'monthStyle' | 'scale' | 'selectedDate'>>, HTMLProps<HTMLCalciteDatePickerMonthHeaderElement> {
}

interface ReactCalciteDialog extends Partial<Pick<Dialog, 'beforeClose' | 'closeDisabled' | 'description' | 'dragEnabled' | 'escapeDisabled' | 'focusTrapDisabled' | 'focusTrapOptions' | 'heading' | 'headingLevel' | 'icon' | 'iconFlipRtl' | 'kind' | 'loading' | 'menuOpen' | 'messageOverrides' | 'modal' | 'open' | 'outsideCloseDisabled' | 'overlayPositioning' | 'placement' | 'resizable' | 'scale' | 'width' | 'widthScale'>>, HTMLProps<HTMLCalciteDialogElement> {
  oncalciteDialogBeforeClose?: EventHandler<HTMLCalciteDialogElement["calciteDialogBeforeClose"]>;
  oncalciteDialogBeforeOpen?: EventHandler<HTMLCalciteDialogElement["calciteDialogBeforeOpen"]>;
  oncalciteDialogClose?: EventHandler<HTMLCalciteDialogElement["calciteDialogClose"]>;
  oncalciteDialogOpen?: EventHandler<HTMLCalciteDialogElement["calciteDialogOpen"]>;
  oncalciteDialogScroll?: EventHandler<HTMLCalciteDialogElement["calciteDialogScroll"]>;
}

interface ReactCalciteDropdown extends Partial<Pick<Dropdown, 'closeOnSelectDisabled' | 'disabled' | 'flipPlacements' | 'maxItems' | 'offsetDistance' | 'offsetSkidding' | 'open' | 'overlayPositioning' | 'placement' | 'scale' | 'type' | 'width' | 'widthScale'>>, HTMLProps<HTMLCalciteDropdownElement> {
  oncalciteDropdownBeforeClose?: EventHandler<HTMLCalciteDropdownElement["calciteDropdownBeforeClose"]>;
  oncalciteDropdownBeforeOpen?: EventHandler<HTMLCalciteDropdownElement["calciteDropdownBeforeOpen"]>;
  oncalciteDropdownClose?: EventHandler<HTMLCalciteDropdownElement["calciteDropdownClose"]>;
  oncalciteDropdownOpen?: EventHandler<HTMLCalciteDropdownElement["calciteDropdownOpen"]>;
  oncalciteDropdownSelect?: EventHandler<HTMLCalciteDropdownElement["calciteDropdownSelect"]>;
}

interface ReactCalciteDropdownGroup extends Partial<Pick<DropdownGroup, 'groupTitle' | 'position' | 'selectionMode'>>, HTMLProps<HTMLCalciteDropdownGroupElement> {
}

interface ReactCalciteDropdownItem extends Partial<Pick<DropdownItem, 'disabled' | 'href' | 'iconEnd' | 'iconFlipRtl' | 'iconStart' | 'label' | 'rel' | 'selected' | 'target'>>, HTMLProps<HTMLCalciteDropdownItemElement> {
  oncalciteDropdownItemSelect?: EventHandler<HTMLCalciteDropdownItemElement["calciteDropdownItemSelect"]>;
}

interface ReactCalciteFab extends Partial<Pick<Fab, 'appearance' | 'disabled' | 'icon' | 'iconFlipRtl' | 'kind' | 'label' | 'loading' | 'scale' | 'text' | 'textEnabled'>>, HTMLProps<HTMLCalciteFabElement> {
}

interface ReactCalciteFilter extends Partial<Pick<Filter, 'disabled' | 'filterProps' | 'items' | 'label' | 'messageOverrides' | 'placeholder' | 'scale' | 'value'>>, HTMLProps<HTMLCalciteFilterElement> {
  oncalciteFilterChange?: EventHandler<HTMLCalciteFilterElement["calciteFilterChange"]>;
}

interface ReactCalciteFlow extends HTMLProps<HTMLCalciteFlowElement> {
}

interface ReactCalciteFlowItem extends Partial<Pick<FlowItem, 'beforeBack' | 'beforeClose' | 'closable' | 'closed' | 'collapsed' | 'collapsible' | 'description' | 'disabled' | 'heading' | 'headingLevel' | 'icon' | 'iconFlipRtl' | 'loading' | 'menuOpen' | 'messageOverrides' | 'overlayPositioning' | 'scale' | 'selected' | 'showBackButton'>>, HTMLProps<HTMLCalciteFlowItemElement> {
  oncalciteFlowItemBack?: EventHandler<HTMLCalciteFlowItemElement["calciteFlowItemBack"]>;
  oncalciteFlowItemClose?: EventHandler<HTMLCalciteFlowItemElement["calciteFlowItemClose"]>;
  oncalciteFlowItemScroll?: EventHandler<HTMLCalciteFlowItemElement["calciteFlowItemScroll"]>;
  oncalciteFlowItemToggle?: EventHandler<HTMLCalciteFlowItemElement["calciteFlowItemToggle"]>;
}

interface ReactCalciteGraph extends Required<Pick<Graph, 'max' | 'min'>>, Partial<Pick<Graph, 'colorStops' | 'data' | 'highlightMax' | 'highlightMin'>>, HTMLProps<HTMLCalciteGraphElement> {
}

interface ReactCalciteHandle extends Partial<Pick<Handle, 'disabled' | 'dragHandle' | 'messageOverrides' | 'selected'>>, HTMLProps<HTMLCalciteHandleElement> {
  oncalciteHandleChange?: EventHandler<HTMLCalciteHandleElement["calciteHandleChange"]>;
  oncalciteHandleNudge?: EventHandler<HTMLCalciteHandleElement["calciteHandleNudge"]>;
}

interface ReactCalciteIcon extends Partial<Pick<Icon, 'flipRtl' | 'icon' | 'preload' | 'scale' | 'textLabel'>>, HTMLProps<HTMLCalciteIconElement> {
}

interface ReactCalciteInlineEditable extends Partial<Pick<InlineEditable, 'afterConfirm' | 'controls' | 'disabled' | 'editingEnabled' | 'loading' | 'messageOverrides' | 'scale'>>, HTMLProps<HTMLCalciteInlineEditableElement> {
  oncalciteInlineEditableEditCancel?: EventHandler<HTMLCalciteInlineEditableElement["calciteInlineEditableEditCancel"]>;
  oncalciteInlineEditableEditConfirm?: EventHandler<HTMLCalciteInlineEditableElement["calciteInlineEditableEditConfirm"]>;
}

interface ReactCalciteInput extends Partial<Pick<Input, 'accept' | 'alignment' | 'autocomplete' | 'clearable' | 'disabled' | 'files' | 'form' | 'groupSeparator' | 'icon' | 'iconFlipRtl' | 'label' | 'loading' | 'max' | 'maxLength' | 'messageOverrides' | 'min' | 'minLength' | 'multiple' | 'name' | 'numberButtonType' | 'numberingSystem' | 'pattern' | 'placeholder' | 'prefixText' | 'readOnly' | 'required' | 'scale' | 'status' | 'step' | 'suffixText' | 'type' | 'validationIcon' | 'validationMessage' | 'value'>>, HTMLProps<HTMLCalciteInputElement> {
  oncalciteInputChange?: EventHandler<HTMLCalciteInputElement["calciteInputChange"]>;
  oncalciteInputInput?: EventHandler<HTMLCalciteInputElement["calciteInputInput"]>;
}

interface ReactCalciteInputDatePicker extends Partial<Pick<InputDatePicker, 'disabled' | 'flipPlacements' | 'focusTrapDisabled' | 'form' | 'headingLevel' | 'label' | 'layout' | 'max' | 'maxAsDate' | 'messageOverrides' | 'min' | 'minAsDate' | 'monthStyle' | 'name' | 'numberingSystem' | 'open' | 'overlayPositioning' | 'placement' | 'proximitySelectionDisabled' | 'range' | 'readOnly' | 'required' | 'scale' | 'status' | 'validationIcon' | 'validationMessage' | 'value' | 'valueAsDate'>>, HTMLProps<HTMLCalciteInputDatePickerElement> {
  oncalciteInputDatePickerBeforeClose?: EventHandler<HTMLCalciteInputDatePickerElement["calciteInputDatePickerBeforeClose"]>;
  oncalciteInputDatePickerBeforeOpen?: EventHandler<HTMLCalciteInputDatePickerElement["calciteInputDatePickerBeforeOpen"]>;
  oncalciteInputDatePickerChange?: EventHandler<HTMLCalciteInputDatePickerElement["calciteInputDatePickerChange"]>;
  oncalciteInputDatePickerClose?: EventHandler<HTMLCalciteInputDatePickerElement["calciteInputDatePickerClose"]>;
  oncalciteInputDatePickerOpen?: EventHandler<HTMLCalciteInputDatePickerElement["calciteInputDatePickerOpen"]>;
}

interface ReactCalciteInputMessage extends Partial<Pick<InputMessage, 'icon' | 'iconFlipRtl' | 'scale' | 'status'>>, HTMLProps<HTMLCalciteInputMessageElement> {
}

interface ReactCalciteInputNumber extends Partial<Pick<InputNumber, 'alignment' | 'autocomplete' | 'clearable' | 'disabled' | 'form' | 'groupSeparator' | 'icon' | 'iconFlipRtl' | 'integer' | 'label' | 'loading' | 'max' | 'maxLength' | 'messageOverrides' | 'min' | 'minLength' | 'name' | 'numberButtonType' | 'numberingSystem' | 'placeholder' | 'prefixText' | 'readOnly' | 'required' | 'scale' | 'status' | 'step' | 'suffixText' | 'validationIcon' | 'validationMessage' | 'value'>>, HTMLProps<HTMLCalciteInputNumberElement> {
  oncalciteInputNumberChange?: EventHandler<HTMLCalciteInputNumberElement["calciteInputNumberChange"]>;
  oncalciteInputNumberInput?: EventHandler<HTMLCalciteInputNumberElement["calciteInputNumberInput"]>;
}

interface ReactCalciteInputText extends Partial<Pick<InputText, 'alignment' | 'autocomplete' | 'clearable' | 'disabled' | 'form' | 'icon' | 'iconFlipRtl' | 'label' | 'loading' | 'maxLength' | 'messageOverrides' | 'minLength' | 'name' | 'pattern' | 'placeholder' | 'prefixText' | 'readOnly' | 'required' | 'scale' | 'status' | 'suffixText' | 'validationIcon' | 'validationMessage' | 'value'>>, HTMLProps<HTMLCalciteInputTextElement> {
  oncalciteInputTextChange?: EventHandler<HTMLCalciteInputTextElement["calciteInputTextChange"]>;
  oncalciteInputTextInput?: EventHandler<HTMLCalciteInputTextElement["calciteInputTextInput"]>;
}

interface ReactCalciteInputTimePicker extends Partial<Pick<InputTimePicker, 'disabled' | 'focusTrapDisabled' | 'form' | 'hourFormat' | 'max' | 'messageOverrides' | 'min' | 'name' | 'numberingSystem' | 'open' | 'overlayPositioning' | 'placement' | 'readOnly' | 'required' | 'scale' | 'status' | 'step' | 'validationIcon' | 'validationMessage' | 'value'>>, HTMLProps<HTMLCalciteInputTimePickerElement> {
  oncalciteInputTimePickerBeforeClose?: EventHandler<HTMLCalciteInputTimePickerElement["calciteInputTimePickerBeforeClose"]>;
  oncalciteInputTimePickerBeforeOpen?: EventHandler<HTMLCalciteInputTimePickerElement["calciteInputTimePickerBeforeOpen"]>;
  oncalciteInputTimePickerChange?: EventHandler<HTMLCalciteInputTimePickerElement["calciteInputTimePickerChange"]>;
  oncalciteInputTimePickerClose?: EventHandler<HTMLCalciteInputTimePickerElement["calciteInputTimePickerClose"]>;
  oncalciteInputTimePickerOpen?: EventHandler<HTMLCalciteInputTimePickerElement["calciteInputTimePickerOpen"]>;
}

interface ReactCalciteInputTimeZone extends Partial<Pick<InputTimeZone, 'clearable' | 'disabled' | 'form' | 'maxItems' | 'messageOverrides' | 'mode' | 'name' | 'offsetStyle' | 'open' | 'overlayPositioning' | 'readOnly' | 'referenceDate' | 'scale' | 'status' | 'validationIcon' | 'validationMessage' | 'value'>>, HTMLProps<HTMLCalciteInputTimeZoneElement> {
  oncalciteInputTimeZoneBeforeClose?: EventHandler<HTMLCalciteInputTimeZoneElement["calciteInputTimeZoneBeforeClose"]>;
  oncalciteInputTimeZoneBeforeOpen?: EventHandler<HTMLCalciteInputTimeZoneElement["calciteInputTimeZoneBeforeOpen"]>;
  oncalciteInputTimeZoneChange?: EventHandler<HTMLCalciteInputTimeZoneElement["calciteInputTimeZoneChange"]>;
  oncalciteInputTimeZoneClose?: EventHandler<HTMLCalciteInputTimeZoneElement["calciteInputTimeZoneClose"]>;
  oncalciteInputTimeZoneOpen?: EventHandler<HTMLCalciteInputTimeZoneElement["calciteInputTimeZoneOpen"]>;
}

interface ReactCalciteLabel extends Partial<Pick<Label, 'alignment' | 'for' | 'layout' | 'scale'>>, HTMLProps<HTMLCalciteLabelElement> {
}

interface ReactCalciteLink extends Partial<Pick<Link, 'disabled' | 'download' | 'href' | 'iconEnd' | 'iconFlipRtl' | 'iconStart' | 'rel' | 'target'>>, HTMLProps<HTMLCalciteLinkElement> {
}

interface ReactCalciteList extends Required<Pick<List, 'label'>>, Partial<Pick<List, 'canPull' | 'canPut' | 'disabled' | 'displayMode' | 'dragEnabled' | 'filterEnabled' | 'filterLabel' | 'filterPlaceholder' | 'filterPredicate' | 'filterProps' | 'filterText' | 'group' | 'interactionMode' | 'loading' | 'messageOverrides' | 'numberingSystem' | 'scale' | 'selectionAppearance' | 'selectionMode'>>, HTMLProps<HTMLCalciteListElement> {
  oncalciteListChange?: EventHandler<HTMLCalciteListElement["calciteListChange"]>;
  oncalciteListDragEnd?: EventHandler<HTMLCalciteListElement["calciteListDragEnd"]>;
  oncalciteListDragStart?: EventHandler<HTMLCalciteListElement["calciteListDragStart"]>;
  oncalciteListFilter?: EventHandler<HTMLCalciteListElement["calciteListFilter"]>;
  oncalciteListMoveHalt?: EventHandler<HTMLCalciteListElement["calciteListMoveHalt"]>;
  oncalciteListOrderChange?: EventHandler<HTMLCalciteListElement["calciteListOrderChange"]>;
}

interface ReactCalciteListItem extends Partial<Pick<ListItem, 'closable' | 'closed' | 'description' | 'disabled' | 'dragDisabled' | 'expanded' | 'iconEnd' | 'iconFlipRtl' | 'iconStart' | 'label' | 'messageOverrides' | 'metadata' | 'open' | 'scale' | 'selected' | 'sortHandleOpen' | 'unavailable' | 'value'>>, HTMLProps<HTMLCalciteListItemElement> {
  oncalciteListItemClose?: EventHandler<HTMLCalciteListItemElement["calciteListItemClose"]>;
  oncalciteListItemSelect?: EventHandler<HTMLCalciteListItemElement["calciteListItemSelect"]>;
  oncalciteListItemSortHandleBeforeClose?: EventHandler<HTMLCalciteListItemElement["calciteListItemSortHandleBeforeClose"]>;
  oncalciteListItemSortHandleBeforeOpen?: EventHandler<HTMLCalciteListItemElement["calciteListItemSortHandleBeforeOpen"]>;
  oncalciteListItemSortHandleClose?: EventHandler<HTMLCalciteListItemElement["calciteListItemSortHandleClose"]>;
  oncalciteListItemSortHandleOpen?: EventHandler<HTMLCalciteListItemElement["calciteListItemSortHandleOpen"]>;
  oncalciteListItemToggle?: EventHandler<HTMLCalciteListItemElement["calciteListItemToggle"]>;
}

interface ReactCalciteListItemGroup extends Partial<Pick<ListItemGroup, 'disabled' | 'heading' | 'scale'>>, HTMLProps<HTMLCalciteListItemGroupElement> {
}

interface ReactCalciteLoader extends Required<Pick<Loader, 'label'>>, Partial<Pick<Loader, 'inline' | 'scale' | 'text' | 'type' | 'value'>>, HTMLProps<HTMLCalciteLoaderElement> {
}

interface ReactCalciteMenu extends Required<Pick<Menu, 'label'>>, Partial<Pick<Menu, 'layout' | 'messageOverrides'>>, HTMLProps<HTMLCalciteMenuElement> {
}

interface ReactCalciteMenuItem extends Required<Pick<MenuItem, 'label'>>, Partial<Pick<MenuItem, 'active' | 'breadcrumb' | 'href' | 'iconEnd' | 'iconFlipRtl' | 'iconStart' | 'messageOverrides' | 'open' | 'rel' | 'target' | 'text'>>, HTMLProps<HTMLCalciteMenuItemElement> {
  oncalciteMenuItemSelect?: EventHandler<HTMLCalciteMenuItemElement["calciteMenuItemSelect"]>;
}

interface ReactCalciteMeter extends Required<Pick<Meter, 'label'>>, Partial<Pick<Meter, 'appearance' | 'disabled' | 'fillType' | 'form' | 'groupSeparator' | 'high' | 'low' | 'max' | 'min' | 'name' | 'numberingSystem' | 'rangeLabels' | 'rangeLabelType' | 'scale' | 'unitLabel' | 'value' | 'valueLabel' | 'valueLabelType'>>, HTMLProps<HTMLCalciteMeterElement> {
}

interface ReactCalciteModal extends Partial<Pick<Modal, 'beforeClose' | 'closeButtonDisabled' | 'docked' | 'escapeDisabled' | 'focusTrapDisabled' | 'focusTrapOptions' | 'fullscreen' | 'kind' | 'messageOverrides' | 'open' | 'outsideCloseDisabled' | 'scale' | 'widthScale'>>, HTMLProps<HTMLCalciteModalElement> {
  oncalciteModalBeforeClose?: EventHandler<HTMLCalciteModalElement["calciteModalBeforeClose"]>;
  oncalciteModalBeforeOpen?: EventHandler<HTMLCalciteModalElement["calciteModalBeforeOpen"]>;
  oncalciteModalClose?: EventHandler<HTMLCalciteModalElement["calciteModalClose"]>;
  oncalciteModalOpen?: EventHandler<HTMLCalciteModalElement["calciteModalOpen"]>;
}

interface ReactCalciteNavigation extends Partial<Pick<Navigation, 'label' | 'navigationAction'>>, HTMLProps<HTMLCalciteNavigationElement> {
  oncalciteNavigationActionSelect?: EventHandler<HTMLCalciteNavigationElement["calciteNavigationActionSelect"]>;
}

interface ReactCalciteNavigationLogo extends Partial<Pick<NavigationLogo, 'active' | 'description' | 'heading' | 'headingLevel' | 'href' | 'icon' | 'iconFlipRtl' | 'label' | 'rel' | 'target' | 'thumbnail'>>, HTMLProps<HTMLCalciteNavigationLogoElement> {
}

interface ReactCalciteNavigationUser extends Partial<Pick<NavigationUser, 'active' | 'fullName' | 'label' | 'textDisabled' | 'thumbnail' | 'userId' | 'username'>>, HTMLProps<HTMLCalciteNavigationUserElement> {
}

interface ReactCalciteNotice extends Partial<Pick<Notice, 'closable' | 'icon' | 'iconFlipRtl' | 'kind' | 'messageOverrides' | 'open' | 'scale' | 'width'>>, HTMLProps<HTMLCalciteNoticeElement> {
  oncalciteNoticeBeforeClose?: EventHandler<HTMLCalciteNoticeElement["calciteNoticeBeforeClose"]>;
  oncalciteNoticeBeforeOpen?: EventHandler<HTMLCalciteNoticeElement["calciteNoticeBeforeOpen"]>;
  oncalciteNoticeClose?: EventHandler<HTMLCalciteNoticeElement["calciteNoticeClose"]>;
  oncalciteNoticeOpen?: EventHandler<HTMLCalciteNoticeElement["calciteNoticeOpen"]>;
}

interface ReactCalciteOption extends Partial<Pick<Option, 'disabled' | 'label' | 'selected' | 'value'>>, HTMLProps<HTMLCalciteOptionElement> {
}

interface ReactCalciteOptionGroup extends Required<Pick<OptionGroup, 'label'>>, Partial<Pick<OptionGroup, 'disabled'>>, HTMLProps<HTMLCalciteOptionGroupElement> {
}

interface ReactCalcitePagination extends Partial<Pick<Pagination, 'groupSeparator' | 'messageOverrides' | 'numberingSystem' | 'pageSize' | 'scale' | 'startItem' | 'totalItems'>>, HTMLProps<HTMLCalcitePaginationElement> {
  oncalcitePaginationChange?: EventHandler<HTMLCalcitePaginationElement["calcitePaginationChange"]>;
}

interface ReactCalcitePanel extends Partial<Pick<Panel, 'beforeClose' | 'closable' | 'closed' | 'collapsed' | 'collapsible' | 'description' | 'disabled' | 'heading' | 'headingLevel' | 'icon' | 'iconFlipRtl' | 'loading' | 'menuFlipPlacements' | 'menuOpen' | 'menuPlacement' | 'messageOverrides' | 'overlayPositioning' | 'scale'>>, HTMLProps<HTMLCalcitePanelElement> {
  oncalcitePanelClose?: EventHandler<HTMLCalcitePanelElement["calcitePanelClose"]>;
  oncalcitePanelScroll?: EventHandler<HTMLCalcitePanelElement["calcitePanelScroll"]>;
  oncalcitePanelToggle?: EventHandler<HTMLCalcitePanelElement["calcitePanelToggle"]>;
}

interface ReactCalcitePopover extends Required<Pick<Popover, 'label' | 'referenceElement'>>, Partial<Pick<Popover, 'autoClose' | 'closable' | 'flipDisabled' | 'flipPlacements' | 'focusTrapDisabled' | 'focusTrapOptions' | 'heading' | 'headingLevel' | 'messageOverrides' | 'offsetDistance' | 'offsetSkidding' | 'open' | 'overlayPositioning' | 'placement' | 'pointerDisabled' | 'scale' | 'triggerDisabled'>>, HTMLProps<HTMLCalcitePopoverElement> {
  oncalcitePopoverBeforeClose?: EventHandler<HTMLCalcitePopoverElement["calcitePopoverBeforeClose"]>;
  oncalcitePopoverBeforeOpen?: EventHandler<HTMLCalcitePopoverElement["calcitePopoverBeforeOpen"]>;
  oncalcitePopoverClose?: EventHandler<HTMLCalcitePopoverElement["calcitePopoverClose"]>;
  oncalcitePopoverOpen?: EventHandler<HTMLCalcitePopoverElement["calcitePopoverOpen"]>;
}

interface ReactCalciteProgress extends Partial<Pick<Progress, 'label' | 'reversed' | 'text' | 'type' | 'value'>>, HTMLProps<HTMLCalciteProgressElement> {
}

interface ReactCalciteRadioButton extends Required<Pick<RadioButton, 'value'>>, Partial<Pick<RadioButton, 'checked' | 'disabled' | 'form' | 'name' | 'required' | 'scale'>>, HTMLProps<HTMLCalciteRadioButtonElement> {
  oncalciteRadioButtonChange?: EventHandler<HTMLCalciteRadioButtonElement["calciteRadioButtonChange"]>;
}

interface ReactCalciteRadioButtonGroup extends Required<Pick<RadioButtonGroup, 'name'>>, Partial<Pick<RadioButtonGroup, 'disabled' | 'layout' | 'required' | 'scale' | 'status' | 'validationIcon' | 'validationMessage'>>, HTMLProps<HTMLCalciteRadioButtonGroupElement> {
  oncalciteRadioButtonGroupChange?: EventHandler<HTMLCalciteRadioButtonGroupElement["calciteRadioButtonGroupChange"]>;
}

interface ReactCalciteRating extends Partial<Pick<Rating, 'average' | 'count' | 'disabled' | 'form' | 'messageOverrides' | 'name' | 'readOnly' | 'scale' | 'showChip' | 'status' | 'validationIcon' | 'validationMessage' | 'value'>>, HTMLProps<HTMLCalciteRatingElement> {
  oncalciteRatingChange?: EventHandler<HTMLCalciteRatingElement["calciteRatingChange"]>;
}

interface ReactCalciteScrim extends Partial<Pick<Scrim, 'loading' | 'messageOverrides'>>, HTMLProps<HTMLCalciteScrimElement> {
}

interface ReactCalciteSegmentedControl extends Partial<Pick<SegmentedControl, 'appearance' | 'disabled' | 'form' | 'layout' | 'name' | 'required' | 'scale' | 'status' | 'validationIcon' | 'validationMessage' | 'value' | 'width'>>, HTMLProps<HTMLCalciteSegmentedControlElement> {
  oncalciteSegmentedControlChange?: EventHandler<HTMLCalciteSegmentedControlElement["calciteSegmentedControlChange"]>;
}

interface ReactCalciteSegmentedControlItem extends Partial<Pick<SegmentedControlItem, 'checked' | 'iconEnd' | 'iconFlipRtl' | 'iconStart' | 'value'>>, HTMLProps<HTMLCalciteSegmentedControlItemElement> {
}

interface ReactCalciteSelect extends Required<Pick<Select, 'label'>>, Partial<Pick<Select, 'disabled' | 'form' | 'name' | 'required' | 'scale' | 'status' | 'validationIcon' | 'validationMessage' | 'value' | 'width'>>, HTMLProps<HTMLCalciteSelectElement> {
  oncalciteSelectChange?: EventHandler<HTMLCalciteSelectElement["calciteSelectChange"]>;
}

interface ReactCalciteSheet extends Required<Pick<Sheet, 'label'>>, Partial<Pick<Sheet, 'beforeClose' | 'displayMode' | 'escapeDisabled' | 'focusTrapDisabled' | 'focusTrapOptions' | 'height' | 'heightScale' | 'messageOverrides' | 'open' | 'outsideCloseDisabled' | 'position' | 'resizable' | 'width' | 'widthScale'>>, HTMLProps<HTMLCalciteSheetElement> {
  oncalciteSheetBeforeClose?: EventHandler<HTMLCalciteSheetElement["calciteSheetBeforeClose"]>;
  oncalciteSheetBeforeOpen?: EventHandler<HTMLCalciteSheetElement["calciteSheetBeforeOpen"]>;
  oncalciteSheetClose?: EventHandler<HTMLCalciteSheetElement["calciteSheetClose"]>;
  oncalciteSheetOpen?: EventHandler<HTMLCalciteSheetElement["calciteSheetOpen"]>;
}

interface ReactCalciteShell extends Partial<Pick<Shell, 'contentBehind'>>, HTMLProps<HTMLCalciteShellElement> {
}

interface ReactCalciteShellCenterRow extends Partial<Pick<ShellCenterRow, 'detached' | 'heightScale' | 'position'>>, HTMLProps<HTMLCalciteShellCenterRowElement> {
}

interface ReactCalciteShellPanel extends Partial<Pick<ShellPanel, 'collapsed' | 'displayMode' | 'height' | 'heightScale' | 'layout' | 'messageOverrides' | 'position' | 'resizable' | 'width' | 'widthScale'>>, HTMLProps<HTMLCalciteShellPanelElement> {
}

interface ReactCalciteSlider extends Partial<Pick<Slider, 'disabled' | 'fillPlacement' | 'form' | 'groupSeparator' | 'hasHistogram' | 'histogram' | 'histogramStops' | 'labelFormatter' | 'labelHandles' | 'labelTicks' | 'max' | 'maxLabel' | 'maxValue' | 'min' | 'minLabel' | 'minValue' | 'mirrored' | 'name' | 'numberingSystem' | 'pageStep' | 'precise' | 'required' | 'scale' | 'snap' | 'status' | 'step' | 'ticks' | 'validationIcon' | 'validationMessage' | 'value'>>, HTMLProps<HTMLCalciteSliderElement> {
  oncalciteSliderChange?: EventHandler<HTMLCalciteSliderElement["calciteSliderChange"]>;
  oncalciteSliderInput?: EventHandler<HTMLCalciteSliderElement["calciteSliderInput"]>;
}

interface ReactCalciteSortHandle extends Partial<Pick<SortHandle, 'disabled' | 'flipPlacements' | 'label' | 'messageOverrides' | 'moveToItems' | 'open' | 'overlayPositioning' | 'placement' | 'scale' | 'setPosition' | 'setSize' | 'widthScale'>>, HTMLProps<HTMLCalciteSortHandleElement> {
  oncalciteSortHandleBeforeClose?: EventHandler<HTMLCalciteSortHandleElement["calciteSortHandleBeforeClose"]>;
  oncalciteSortHandleBeforeOpen?: EventHandler<HTMLCalciteSortHandleElement["calciteSortHandleBeforeOpen"]>;
  oncalciteSortHandleClose?: EventHandler<HTMLCalciteSortHandleElement["calciteSortHandleClose"]>;
  oncalciteSortHandleMove?: EventHandler<HTMLCalciteSortHandleElement["calciteSortHandleMove"]>;
  oncalciteSortHandleOpen?: EventHandler<HTMLCalciteSortHandleElement["calciteSortHandleOpen"]>;
  oncalciteSortHandleReorder?: EventHandler<HTMLCalciteSortHandleElement["calciteSortHandleReorder"]>;
}

interface ReactCalciteSortableList extends Partial<Pick<SortableList, 'canPull' | 'canPut' | 'disabled' | 'dragSelector' | 'group' | 'handleSelector' | 'layout' | 'loading'>>, HTMLProps<HTMLCalciteSortableListElement> {
  oncalciteListOrderChange?: EventHandler<HTMLCalciteSortableListElement["calciteListOrderChange"]>;
}

interface ReactCalciteSplitButton extends Partial<Pick<SplitButton, 'appearance' | 'disabled' | 'download' | 'dropdownIconType' | 'dropdownLabel' | 'flipPlacements' | 'href' | 'kind' | 'loading' | 'overlayPositioning' | 'placement' | 'primaryIconEnd' | 'primaryIconFlipRtl' | 'primaryIconStart' | 'primaryLabel' | 'primaryText' | 'rel' | 'scale' | 'target' | 'width'>>, HTMLProps<HTMLCalciteSplitButtonElement> {
  oncalciteSplitButtonPrimaryClick?: EventHandler<HTMLCalciteSplitButtonElement["calciteSplitButtonPrimaryClick"]>;
  oncalciteSplitButtonSecondaryClick?: EventHandler<HTMLCalciteSplitButtonElement["calciteSplitButtonSecondaryClick"]>;
}

interface ReactCalciteStack extends Partial<Pick<Stack, 'disabled'>>, HTMLProps<HTMLCalciteStackElement> {
}

interface ReactCalciteStepper extends Partial<Pick<Stepper, 'icon' | 'layout' | 'messageOverrides' | 'numbered' | 'numberingSystem' | 'scale'>>, HTMLProps<HTMLCalciteStepperElement> {
  oncalciteStepperChange?: EventHandler<HTMLCalciteStepperElement["calciteStepperChange"]>;
  oncalciteStepperItemChange?: EventHandler<HTMLCalciteStepperElement["calciteStepperItemChange"]>;
}

interface ReactCalciteStepperItem extends Partial<Pick<StepperItem, 'complete' | 'description' | 'disabled' | 'error' | 'heading' | 'iconFlipRtl' | 'messageOverrides' | 'selected'>>, HTMLProps<HTMLCalciteStepperItemElement> {
  oncalciteStepperItemSelect?: EventHandler<HTMLCalciteStepperItemElement["calciteStepperItemSelect"]>;
}

interface ReactCalciteSwitch extends Partial<Pick<Switch, 'checked' | 'disabled' | 'form' | 'label' | 'name' | 'scale' | 'value'>>, HTMLProps<HTMLCalciteSwitchElement> {
  oncalciteSwitchChange?: EventHandler<HTMLCalciteSwitchElement["calciteSwitchChange"]>;
}

interface ReactCalciteTab extends Partial<Pick<Tab, 'selected' | 'tab'>>, HTMLProps<HTMLCalciteTabElement> {
}

interface ReactCalciteTabNav extends Partial<Pick<TabNav, 'messageOverrides' | 'position' | 'storageId' | 'syncId'>>, HTMLProps<HTMLCalciteTabNavElement> {
  oncalciteTabChange?: EventHandler<HTMLCalciteTabNavElement["calciteTabChange"]>;
}

interface ReactCalciteTabTitle extends Partial<Pick<TabTitle, 'closable' | 'closed' | 'disabled' | 'iconEnd' | 'iconFlipRtl' | 'iconStart' | 'messageOverrides' | 'position' | 'selected' | 'tab'>>, HTMLProps<HTMLCalciteTabTitleElement> {
  oncalciteTabsActivate?: EventHandler<HTMLCalciteTabTitleElement["calciteTabsActivate"]>;
  oncalciteTabsClose?: EventHandler<HTMLCalciteTabTitleElement["calciteTabsClose"]>;
}

interface ReactCalciteTable extends Required<Pick<Table, 'caption'>>, Partial<Pick<Table, 'bordered' | 'groupSeparator' | 'interactionMode' | 'layout' | 'messageOverrides' | 'numbered' | 'numberingSystem' | 'pageSize' | 'scale' | 'selectionDisplay' | 'selectionMode' | 'striped'>>, HTMLProps<HTMLCalciteTableElement> {
  oncalciteTablePageChange?: EventHandler<HTMLCalciteTableElement["calciteTablePageChange"]>;
  oncalciteTableSelect?: EventHandler<HTMLCalciteTableElement["calciteTableSelect"]>;
}

interface ReactCalciteTableCell extends Partial<Pick<TableCell, 'alignment' | 'colSpan' | 'messageOverrides' | 'rowSpan'>>, HTMLProps<HTMLCalciteTableCellElement> {
}

interface ReactCalciteTableHeader extends Partial<Pick<TableHeader, 'alignment' | 'colSpan' | 'description' | 'heading' | 'messageOverrides' | 'rowSpan'>>, HTMLProps<HTMLCalciteTableHeaderElement> {
}

interface ReactCalciteTableRow extends Partial<Pick<TableRow, 'alignment' | 'disabled' | 'selected'>>, HTMLProps<HTMLCalciteTableRowElement> {
  oncalciteTableRowSelect?: EventHandler<HTMLCalciteTableRowElement["calciteTableRowSelect"]>;
}

interface ReactCalciteTabs extends Partial<Pick<Tabs, 'bordered' | 'layout' | 'position' | 'scale'>>, HTMLProps<HTMLCalciteTabsElement> {
}

interface ReactCalciteTextArea extends Partial<Pick<TextArea, 'columns' | 'disabled' | 'form' | 'groupSeparator' | 'label' | 'limitText' | 'maxLength' | 'messageOverrides' | 'minLength' | 'name' | 'numberingSystem' | 'placeholder' | 'readOnly' | 'required' | 'resize' | 'rows' | 'scale' | 'status' | 'validationIcon' | 'validationMessage' | 'value' | 'wrap'>>, HTMLProps<HTMLCalciteTextAreaElement> {
  oncalciteTextAreaChange?: EventHandler<HTMLCalciteTextAreaElement["calciteTextAreaChange"]>;
  oncalciteTextAreaInput?: EventHandler<HTMLCalciteTextAreaElement["calciteTextAreaInput"]>;
}

interface ReactCalciteTile extends Partial<Pick<Tile, 'active' | 'alignment' | 'description' | 'disabled' | 'embed' | 'heading' | 'href' | 'icon' | 'iconFlipRtl' | 'label' | 'scale' | 'selected'>>, HTMLProps<HTMLCalciteTileElement> {
  oncalciteTileSelect?: EventHandler<HTMLCalciteTileElement["calciteTileSelect"]>;
}

interface ReactCalciteTileGroup extends Required<Pick<TileGroup, 'label'>>, Partial<Pick<TileGroup, 'alignment' | 'disabled' | 'layout' | 'scale' | 'selectionAppearance' | 'selectionMode'>>, HTMLProps<HTMLCalciteTileGroupElement> {
  oncalciteTileGroupSelect?: EventHandler<HTMLCalciteTileGroupElement["calciteTileGroupSelect"]>;
}

interface ReactCalciteTileSelect extends Partial<Pick<TileSelect, 'checked' | 'description' | 'disabled' | 'heading' | 'icon' | 'iconFlipRtl' | 'inputAlignment' | 'inputEnabled' | 'name' | 'type' | 'value' | 'width'>>, HTMLProps<HTMLCalciteTileSelectElement> {
  oncalciteTileSelectChange?: EventHandler<HTMLCalciteTileSelectElement["calciteTileSelectChange"]>;
}

interface ReactCalciteTileSelectGroup extends Partial<Pick<TileSelectGroup, 'disabled' | 'layout'>>, HTMLProps<HTMLCalciteTileSelectGroupElement> {
}

interface ReactCalciteTimePicker extends Partial<Pick<TimePicker, 'hourFormat' | 'messageOverrides' | 'numberingSystem' | 'scale' | 'step' | 'value'>>, HTMLProps<HTMLCalciteTimePickerElement> {
  oncalciteTimePickerChange?: EventHandler<HTMLCalciteTimePickerElement["calciteTimePickerChange"]>;
}

interface ReactCalciteTip extends Partial<Pick<Tip, 'closed' | 'closeDisabled' | 'heading' | 'headingLevel' | 'messageOverrides' | 'selected'>>, HTMLProps<HTMLCalciteTipElement> {
  oncalciteTipDismiss?: EventHandler<HTMLCalciteTipElement["calciteTipDismiss"]>;
}

interface ReactCalciteTipGroup extends Partial<Pick<TipGroup, 'groupTitle'>>, HTMLProps<HTMLCalciteTipGroupElement> {
}

interface ReactCalciteTipManager extends Partial<Pick<TipManager, 'closed' | 'headingLevel' | 'messageOverrides'>>, HTMLProps<HTMLCalciteTipManagerElement> {
  oncalciteTipManagerClose?: EventHandler<HTMLCalciteTipManagerElement["calciteTipManagerClose"]>;
}

interface ReactCalciteTooltip extends Partial<Pick<Tooltip, 'closeOnClick' | 'label' | 'offsetDistance' | 'offsetSkidding' | 'open' | 'overlayPositioning' | 'placement' | 'referenceElement'>>, HTMLProps<HTMLCalciteTooltipElement> {
  oncalciteTooltipBeforeClose?: EventHandler<HTMLCalciteTooltipElement["calciteTooltipBeforeClose"]>;
  oncalciteTooltipBeforeOpen?: EventHandler<HTMLCalciteTooltipElement["calciteTooltipBeforeOpen"]>;
  oncalciteTooltipClose?: EventHandler<HTMLCalciteTooltipElement["calciteTooltipClose"]>;
  oncalciteTooltipOpen?: EventHandler<HTMLCalciteTooltipElement["calciteTooltipOpen"]>;
}

interface ReactCalciteTree extends Partial<Pick<Tree, 'lines' | 'scale' | 'selectionMode'>>, HTMLProps<HTMLCalciteTreeElement> {
  oncalciteTreeSelect?: EventHandler<HTMLCalciteTreeElement["calciteTreeSelect"]>;
}

interface ReactCalciteTreeItem extends Partial<Pick<TreeItem, 'disabled' | 'expanded' | 'iconFlipRtl' | 'iconStart' | 'label' | 'selected'>>, HTMLProps<HTMLCalciteTreeItemElement> {
}

declare module "react" {
  namespace JSX {
    interface IntrinsicElements {
      "calcite-accordion": ReactCalciteAccordion;
      "calcite-accordion-item": ReactCalciteAccordionItem;
      "calcite-action": ReactCalciteAction;
      "calcite-action-bar": ReactCalciteActionBar;
      "calcite-action-group": ReactCalciteActionGroup;
      "calcite-action-menu": ReactCalciteActionMenu;
      "calcite-action-pad": ReactCalciteActionPad;
      "calcite-alert": ReactCalciteAlert;
      "calcite-autocomplete": ReactCalciteAutocomplete;
      "calcite-autocomplete-item": ReactCalciteAutocompleteItem;
      "calcite-autocomplete-item-group": ReactCalciteAutocompleteItemGroup;
      "calcite-avatar": ReactCalciteAvatar;
      "calcite-block": ReactCalciteBlock;
      "calcite-block-group": ReactCalciteBlockGroup;
      "calcite-block-section": ReactCalciteBlockSection;
      "calcite-button": ReactCalciteButton;
      "calcite-card": ReactCalciteCard;
      "calcite-card-group": ReactCalciteCardGroup;
      "calcite-carousel": ReactCalciteCarousel;
      "calcite-carousel-item": ReactCalciteCarouselItem;
      "calcite-checkbox": ReactCalciteCheckbox;
      "calcite-chip": ReactCalciteChip;
      "calcite-chip-group": ReactCalciteChipGroup;
      "calcite-color-picker": ReactCalciteColorPicker;
      "calcite-color-picker-hex-input": ReactCalciteColorPickerHexInput;
      "calcite-color-picker-swatch": ReactCalciteColorPickerSwatch;
      "calcite-combobox": ReactCalciteCombobox;
      "calcite-combobox-item": ReactCalciteComboboxItem;
      "calcite-combobox-item-group": ReactCalciteComboboxItemGroup;
      "calcite-date-picker": ReactCalciteDatePicker;
      "calcite-date-picker-day": ReactCalciteDatePickerDay;
      "calcite-date-picker-month": ReactCalciteDatePickerMonth;
      "calcite-date-picker-month-header": ReactCalciteDatePickerMonthHeader;
      "calcite-dialog": ReactCalciteDialog;
      "calcite-dropdown": ReactCalciteDropdown;
      "calcite-dropdown-group": ReactCalciteDropdownGroup;
      "calcite-dropdown-item": ReactCalciteDropdownItem;
      "calcite-fab": ReactCalciteFab;
      "calcite-filter": ReactCalciteFilter;
      "calcite-flow": ReactCalciteFlow;
      "calcite-flow-item": ReactCalciteFlowItem;
      "calcite-graph": ReactCalciteGraph;
      "calcite-handle": ReactCalciteHandle;
      "calcite-icon": ReactCalciteIcon;
      "calcite-inline-editable": ReactCalciteInlineEditable;
      "calcite-input": ReactCalciteInput;
      "calcite-input-date-picker": ReactCalciteInputDatePicker;
      "calcite-input-message": ReactCalciteInputMessage;
      "calcite-input-number": ReactCalciteInputNumber;
      "calcite-input-text": ReactCalciteInputText;
      "calcite-input-time-picker": ReactCalciteInputTimePicker;
      "calcite-input-time-zone": ReactCalciteInputTimeZone;
      "calcite-label": ReactCalciteLabel;
      "calcite-link": ReactCalciteLink;
      "calcite-list": ReactCalciteList;
      "calcite-list-item": ReactCalciteListItem;
      "calcite-list-item-group": ReactCalciteListItemGroup;
      "calcite-loader": ReactCalciteLoader;
      "calcite-menu": ReactCalciteMenu;
      "calcite-menu-item": ReactCalciteMenuItem;
      "calcite-meter": ReactCalciteMeter;
      "calcite-modal": ReactCalciteModal;
      "calcite-navigation": ReactCalciteNavigation;
      "calcite-navigation-logo": ReactCalciteNavigationLogo;
      "calcite-navigation-user": ReactCalciteNavigationUser;
      "calcite-notice": ReactCalciteNotice;
      "calcite-option": ReactCalciteOption;
      "calcite-option-group": ReactCalciteOptionGroup;
      "calcite-pagination": ReactCalcitePagination;
      "calcite-panel": ReactCalcitePanel;
      "calcite-popover": ReactCalcitePopover;
      "calcite-progress": ReactCalciteProgress;
      "calcite-radio-button": ReactCalciteRadioButton;
      "calcite-radio-button-group": ReactCalciteRadioButtonGroup;
      "calcite-rating": ReactCalciteRating;
      "calcite-scrim": ReactCalciteScrim;
      "calcite-segmented-control": ReactCalciteSegmentedControl;
      "calcite-segmented-control-item": ReactCalciteSegmentedControlItem;
      "calcite-select": ReactCalciteSelect;
      "calcite-sheet": ReactCalciteSheet;
      "calcite-shell": ReactCalciteShell;
      "calcite-shell-center-row": ReactCalciteShellCenterRow;
      "calcite-shell-panel": ReactCalciteShellPanel;
      "calcite-slider": ReactCalciteSlider;
      "calcite-sort-handle": ReactCalciteSortHandle;
      "calcite-sortable-list": ReactCalciteSortableList;
      "calcite-split-button": ReactCalciteSplitButton;
      "calcite-stack": ReactCalciteStack;
      "calcite-stepper": ReactCalciteStepper;
      "calcite-stepper-item": ReactCalciteStepperItem;
      "calcite-switch": ReactCalciteSwitch;
      "calcite-tab": ReactCalciteTab;
      "calcite-tab-nav": ReactCalciteTabNav;
      "calcite-tab-title": ReactCalciteTabTitle;
      "calcite-table": ReactCalciteTable;
      "calcite-table-cell": ReactCalciteTableCell;
      "calcite-table-header": ReactCalciteTableHeader;
      "calcite-table-row": ReactCalciteTableRow;
      "calcite-tabs": ReactCalciteTabs;
      "calcite-text-area": ReactCalciteTextArea;
      "calcite-tile": ReactCalciteTile;
      "calcite-tile-group": ReactCalciteTileGroup;
      "calcite-tile-select": ReactCalciteTileSelect;
      "calcite-tile-select-group": ReactCalciteTileSelectGroup;
      "calcite-time-picker": ReactCalciteTimePicker;
      "calcite-tip": ReactCalciteTip;
      "calcite-tip-group": ReactCalciteTipGroup;
      "calcite-tip-manager": ReactCalciteTipManager;
      "calcite-tooltip": ReactCalciteTooltip;
      "calcite-tree": ReactCalciteTree;
      "calcite-tree-item": ReactCalciteTreeItem;
    }
  }
}
declare module "react/jsx-runtime" {
  namespace JSX {
    interface IntrinsicElements {
      "calcite-accordion": ReactCalciteAccordion;
      "calcite-accordion-item": ReactCalciteAccordionItem;
      "calcite-action": ReactCalciteAction;
      "calcite-action-bar": ReactCalciteActionBar;
      "calcite-action-group": ReactCalciteActionGroup;
      "calcite-action-menu": ReactCalciteActionMenu;
      "calcite-action-pad": ReactCalciteActionPad;
      "calcite-alert": ReactCalciteAlert;
      "calcite-autocomplete": ReactCalciteAutocomplete;
      "calcite-autocomplete-item": ReactCalciteAutocompleteItem;
      "calcite-autocomplete-item-group": ReactCalciteAutocompleteItemGroup;
      "calcite-avatar": ReactCalciteAvatar;
      "calcite-block": ReactCalciteBlock;
      "calcite-block-group": ReactCalciteBlockGroup;
      "calcite-block-section": ReactCalciteBlockSection;
      "calcite-button": ReactCalciteButton;
      "calcite-card": ReactCalciteCard;
      "calcite-card-group": ReactCalciteCardGroup;
      "calcite-carousel": ReactCalciteCarousel;
      "calcite-carousel-item": ReactCalciteCarouselItem;
      "calcite-checkbox": ReactCalciteCheckbox;
      "calcite-chip": ReactCalciteChip;
      "calcite-chip-group": ReactCalciteChipGroup;
      "calcite-color-picker": ReactCalciteColorPicker;
      "calcite-color-picker-hex-input": ReactCalciteColorPickerHexInput;
      "calcite-color-picker-swatch": ReactCalciteColorPickerSwatch;
      "calcite-combobox": ReactCalciteCombobox;
      "calcite-combobox-item": ReactCalciteComboboxItem;
      "calcite-combobox-item-group": ReactCalciteComboboxItemGroup;
      "calcite-date-picker": ReactCalciteDatePicker;
      "calcite-date-picker-day": ReactCalciteDatePickerDay;
      "calcite-date-picker-month": ReactCalciteDatePickerMonth;
      "calcite-date-picker-month-header": ReactCalciteDatePickerMonthHeader;
      "calcite-dialog": ReactCalciteDialog;
      "calcite-dropdown": ReactCalciteDropdown;
      "calcite-dropdown-group": ReactCalciteDropdownGroup;
      "calcite-dropdown-item": ReactCalciteDropdownItem;
      "calcite-fab": ReactCalciteFab;
      "calcite-filter": ReactCalciteFilter;
      "calcite-flow": ReactCalciteFlow;
      "calcite-flow-item": ReactCalciteFlowItem;
      "calcite-graph": ReactCalciteGraph;
      "calcite-handle": ReactCalciteHandle;
      "calcite-icon": ReactCalciteIcon;
      "calcite-inline-editable": ReactCalciteInlineEditable;
      "calcite-input": ReactCalciteInput;
      "calcite-input-date-picker": ReactCalciteInputDatePicker;
      "calcite-input-message": ReactCalciteInputMessage;
      "calcite-input-number": ReactCalciteInputNumber;
      "calcite-input-text": ReactCalciteInputText;
      "calcite-input-time-picker": ReactCalciteInputTimePicker;
      "calcite-input-time-zone": ReactCalciteInputTimeZone;
      "calcite-label": ReactCalciteLabel;
      "calcite-link": ReactCalciteLink;
      "calcite-list": ReactCalciteList;
      "calcite-list-item": ReactCalciteListItem;
      "calcite-list-item-group": ReactCalciteListItemGroup;
      "calcite-loader": ReactCalciteLoader;
      "calcite-menu": ReactCalciteMenu;
      "calcite-menu-item": ReactCalciteMenuItem;
      "calcite-meter": ReactCalciteMeter;
      "calcite-modal": ReactCalciteModal;
      "calcite-navigation": ReactCalciteNavigation;
      "calcite-navigation-logo": ReactCalciteNavigationLogo;
      "calcite-navigation-user": ReactCalciteNavigationUser;
      "calcite-notice": ReactCalciteNotice;
      "calcite-option": ReactCalciteOption;
      "calcite-option-group": ReactCalciteOptionGroup;
      "calcite-pagination": ReactCalcitePagination;
      "calcite-panel": ReactCalcitePanel;
      "calcite-popover": ReactCalcitePopover;
      "calcite-progress": ReactCalciteProgress;
      "calcite-radio-button": ReactCalciteRadioButton;
      "calcite-radio-button-group": ReactCalciteRadioButtonGroup;
      "calcite-rating": ReactCalciteRating;
      "calcite-scrim": ReactCalciteScrim;
      "calcite-segmented-control": ReactCalciteSegmentedControl;
      "calcite-segmented-control-item": ReactCalciteSegmentedControlItem;
      "calcite-select": ReactCalciteSelect;
      "calcite-sheet": ReactCalciteSheet;
      "calcite-shell": ReactCalciteShell;
      "calcite-shell-center-row": ReactCalciteShellCenterRow;
      "calcite-shell-panel": ReactCalciteShellPanel;
      "calcite-slider": ReactCalciteSlider;
      "calcite-sort-handle": ReactCalciteSortHandle;
      "calcite-sortable-list": ReactCalciteSortableList;
      "calcite-split-button": ReactCalciteSplitButton;
      "calcite-stack": ReactCalciteStack;
      "calcite-stepper": ReactCalciteStepper;
      "calcite-stepper-item": ReactCalciteStepperItem;
      "calcite-switch": ReactCalciteSwitch;
      "calcite-tab": ReactCalciteTab;
      "calcite-tab-nav": ReactCalciteTabNav;
      "calcite-tab-title": ReactCalciteTabTitle;
      "calcite-table": ReactCalciteTable;
      "calcite-table-cell": ReactCalciteTableCell;
      "calcite-table-header": ReactCalciteTableHeader;
      "calcite-table-row": ReactCalciteTableRow;
      "calcite-tabs": ReactCalciteTabs;
      "calcite-text-area": ReactCalciteTextArea;
      "calcite-tile": ReactCalciteTile;
      "calcite-tile-group": ReactCalciteTileGroup;
      "calcite-tile-select": ReactCalciteTileSelect;
      "calcite-tile-select-group": ReactCalciteTileSelectGroup;
      "calcite-time-picker": ReactCalciteTimePicker;
      "calcite-tip": ReactCalciteTip;
      "calcite-tip-group": ReactCalciteTipGroup;
      "calcite-tip-manager": ReactCalciteTipManager;
      "calcite-tooltip": ReactCalciteTooltip;
      "calcite-tree": ReactCalciteTree;
      "calcite-tree-item": ReactCalciteTreeItem;
    }
  }
}
declare module "react/jsx-dev-runtime" {
  namespace JSX {
    interface IntrinsicElements {
      "calcite-accordion": ReactCalciteAccordion;
      "calcite-accordion-item": ReactCalciteAccordionItem;
      "calcite-action": ReactCalciteAction;
      "calcite-action-bar": ReactCalciteActionBar;
      "calcite-action-group": ReactCalciteActionGroup;
      "calcite-action-menu": ReactCalciteActionMenu;
      "calcite-action-pad": ReactCalciteActionPad;
      "calcite-alert": ReactCalciteAlert;
      "calcite-autocomplete": ReactCalciteAutocomplete;
      "calcite-autocomplete-item": ReactCalciteAutocompleteItem;
      "calcite-autocomplete-item-group": ReactCalciteAutocompleteItemGroup;
      "calcite-avatar": ReactCalciteAvatar;
      "calcite-block": ReactCalciteBlock;
      "calcite-block-group": ReactCalciteBlockGroup;
      "calcite-block-section": ReactCalciteBlockSection;
      "calcite-button": ReactCalciteButton;
      "calcite-card": ReactCalciteCard;
      "calcite-card-group": ReactCalciteCardGroup;
      "calcite-carousel": ReactCalciteCarousel;
      "calcite-carousel-item": ReactCalciteCarouselItem;
      "calcite-checkbox": ReactCalciteCheckbox;
      "calcite-chip": ReactCalciteChip;
      "calcite-chip-group": ReactCalciteChipGroup;
      "calcite-color-picker": ReactCalciteColorPicker;
      "calcite-color-picker-hex-input": ReactCalciteColorPickerHexInput;
      "calcite-color-picker-swatch": ReactCalciteColorPickerSwatch;
      "calcite-combobox": ReactCalciteCombobox;
      "calcite-combobox-item": ReactCalciteComboboxItem;
      "calcite-combobox-item-group": ReactCalciteComboboxItemGroup;
      "calcite-date-picker": ReactCalciteDatePicker;
      "calcite-date-picker-day": ReactCalciteDatePickerDay;
      "calcite-date-picker-month": ReactCalciteDatePickerMonth;
      "calcite-date-picker-month-header": ReactCalciteDatePickerMonthHeader;
      "calcite-dialog": ReactCalciteDialog;
      "calcite-dropdown": ReactCalciteDropdown;
      "calcite-dropdown-group": ReactCalciteDropdownGroup;
      "calcite-dropdown-item": ReactCalciteDropdownItem;
      "calcite-fab": ReactCalciteFab;
      "calcite-filter": ReactCalciteFilter;
      "calcite-flow": ReactCalciteFlow;
      "calcite-flow-item": ReactCalciteFlowItem;
      "calcite-graph": ReactCalciteGraph;
      "calcite-handle": ReactCalciteHandle;
      "calcite-icon": ReactCalciteIcon;
      "calcite-inline-editable": ReactCalciteInlineEditable;
      "calcite-input": ReactCalciteInput;
      "calcite-input-date-picker": ReactCalciteInputDatePicker;
      "calcite-input-message": ReactCalciteInputMessage;
      "calcite-input-number": ReactCalciteInputNumber;
      "calcite-input-text": ReactCalciteInputText;
      "calcite-input-time-picker": ReactCalciteInputTimePicker;
      "calcite-input-time-zone": ReactCalciteInputTimeZone;
      "calcite-label": ReactCalciteLabel;
      "calcite-link": ReactCalciteLink;
      "calcite-list": ReactCalciteList;
      "calcite-list-item": ReactCalciteListItem;
      "calcite-list-item-group": ReactCalciteListItemGroup;
      "calcite-loader": ReactCalciteLoader;
      "calcite-menu": ReactCalciteMenu;
      "calcite-menu-item": ReactCalciteMenuItem;
      "calcite-meter": ReactCalciteMeter;
      "calcite-modal": ReactCalciteModal;
      "calcite-navigation": ReactCalciteNavigation;
      "calcite-navigation-logo": ReactCalciteNavigationLogo;
      "calcite-navigation-user": ReactCalciteNavigationUser;
      "calcite-notice": ReactCalciteNotice;
      "calcite-option": ReactCalciteOption;
      "calcite-option-group": ReactCalciteOptionGroup;
      "calcite-pagination": ReactCalcitePagination;
      "calcite-panel": ReactCalcitePanel;
      "calcite-popover": ReactCalcitePopover;
      "calcite-progress": ReactCalciteProgress;
      "calcite-radio-button": ReactCalciteRadioButton;
      "calcite-radio-button-group": ReactCalciteRadioButtonGroup;
      "calcite-rating": ReactCalciteRating;
      "calcite-scrim": ReactCalciteScrim;
      "calcite-segmented-control": ReactCalciteSegmentedControl;
      "calcite-segmented-control-item": ReactCalciteSegmentedControlItem;
      "calcite-select": ReactCalciteSelect;
      "calcite-sheet": ReactCalciteSheet;
      "calcite-shell": ReactCalciteShell;
      "calcite-shell-center-row": ReactCalciteShellCenterRow;
      "calcite-shell-panel": ReactCalciteShellPanel;
      "calcite-slider": ReactCalciteSlider;
      "calcite-sort-handle": ReactCalciteSortHandle;
      "calcite-sortable-list": ReactCalciteSortableList;
      "calcite-split-button": ReactCalciteSplitButton;
      "calcite-stack": ReactCalciteStack;
      "calcite-stepper": ReactCalciteStepper;
      "calcite-stepper-item": ReactCalciteStepperItem;
      "calcite-switch": ReactCalciteSwitch;
      "calcite-tab": ReactCalciteTab;
      "calcite-tab-nav": ReactCalciteTabNav;
      "calcite-tab-title": ReactCalciteTabTitle;
      "calcite-table": ReactCalciteTable;
      "calcite-table-cell": ReactCalciteTableCell;
      "calcite-table-header": ReactCalciteTableHeader;
      "calcite-table-row": ReactCalciteTableRow;
      "calcite-tabs": ReactCalciteTabs;
      "calcite-text-area": ReactCalciteTextArea;
      "calcite-tile": ReactCalciteTile;
      "calcite-tile-group": ReactCalciteTileGroup;
      "calcite-tile-select": ReactCalciteTileSelect;
      "calcite-tile-select-group": ReactCalciteTileSelectGroup;
      "calcite-time-picker": ReactCalciteTimePicker;
      "calcite-tip": ReactCalciteTip;
      "calcite-tip-group": ReactCalciteTipGroup;
      "calcite-tip-manager": ReactCalciteTipManager;
      "calcite-tooltip": ReactCalciteTooltip;
      "calcite-tree": ReactCalciteTree;
      "calcite-tree-item": ReactCalciteTreeItem;
    }
  }
}