@esri/calcite-components 3.0.0-next.99 → 3.0.1

package/dist/types/react.d.ts

@@ -12,6 +12,7 @@ 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";
@@ -109,7 +110,8 @@ 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 { Ref, HTMLProps, EventHandler, SyntheticEvent } from 'react';
+import type { HTMLProps } from 'react';
+import type { EventHandler } from "@arcgis/lumina"; 
 
 interface ReactCalciteAccordion extends Partial<Pick<Accordion, 'appearance' | 'iconPosition' | 'iconType' | 'scale' | 'selectionMode'>>, HTMLProps<HTMLCalciteAccordionElement> {
 }
@@ -121,35 +123,35 @@ interface ReactCalciteAction extends Required<Pick<Action, 'text'>>, Partial<Pic
 }
 
 interface ReactCalciteActionBar extends Partial<Pick<ActionBar, 'actionsEndGroupLabel' | 'expandDisabled' | 'expanded' | 'layout' | 'messageOverrides' | 'overflowActionsDisabled' | 'overlayPositioning' | 'position' | 'scale'>>, HTMLProps<HTMLCalciteActionBarElement> {
-  oncalciteActionBarToggle?: EventHandler<SyntheticEvent<HTMLCalciteActionBarElement, HTMLCalciteActionBarElement["calciteActionBarToggle"]>>;
+  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<SyntheticEvent<HTMLCalciteActionMenuElement, HTMLCalciteActionMenuElement["calciteActionMenuOpen"]>>;
+  oncalciteActionMenuOpen?: EventHandler<HTMLCalciteActionMenuElement["calciteActionMenuOpen"]>;
 }
 
 interface ReactCalciteActionPad extends Partial<Pick<ActionPad, 'actionsEndGroupLabel' | 'expandDisabled' | 'expanded' | 'layout' | 'messageOverrides' | 'overlayPositioning' | 'position' | 'scale'>>, HTMLProps<HTMLCalciteActionPadElement> {
-  oncalciteActionPadToggle?: EventHandler<SyntheticEvent<HTMLCalciteActionPadElement, HTMLCalciteActionPadElement["calciteActionPadToggle"]>>;
+  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<SyntheticEvent<HTMLCalciteAlertElement, HTMLCalciteAlertElement["calciteAlertBeforeClose"]>>;
-  oncalciteAlertBeforeOpen?: EventHandler<SyntheticEvent<HTMLCalciteAlertElement, HTMLCalciteAlertElement["calciteAlertBeforeOpen"]>>;
-  oncalciteAlertClose?: EventHandler<SyntheticEvent<HTMLCalciteAlertElement, HTMLCalciteAlertElement["calciteAlertClose"]>>;
-  oncalciteAlertOpen?: EventHandler<SyntheticEvent<HTMLCalciteAlertElement, HTMLCalciteAlertElement["calciteAlertOpen"]>>;
+  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<SyntheticEvent<HTMLCalciteAutocompleteElement, HTMLCalciteAutocompleteElement["calciteAutocompleteBeforeClose"]>>;
-  oncalciteAutocompleteBeforeOpen?: EventHandler<SyntheticEvent<HTMLCalciteAutocompleteElement, HTMLCalciteAutocompleteElement["calciteAutocompleteBeforeOpen"]>>;
-  oncalciteAutocompleteChange?: EventHandler<SyntheticEvent<HTMLCalciteAutocompleteElement, HTMLCalciteAutocompleteElement["calciteAutocompleteChange"]>>;
-  oncalciteAutocompleteClose?: EventHandler<SyntheticEvent<HTMLCalciteAutocompleteElement, HTMLCalciteAutocompleteElement["calciteAutocompleteClose"]>>;
-  oncalciteAutocompleteOpen?: EventHandler<SyntheticEvent<HTMLCalciteAutocompleteElement, HTMLCalciteAutocompleteElement["calciteAutocompleteOpen"]>>;
-  oncalciteAutocompleteTextChange?: EventHandler<SyntheticEvent<HTMLCalciteAutocompleteElement, HTMLCalciteAutocompleteElement["calciteAutocompleteTextChange"]>>;
-  oncalciteAutocompleteTextInput?: EventHandler<SyntheticEvent<HTMLCalciteAutocompleteElement, HTMLCalciteAutocompleteElement["calciteAutocompleteTextInput"]>>;
+  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> {
@@ -161,85 +163,95 @@ interface ReactCalciteAutocompleteItemGroup extends Required<Pick<AutocompleteIt
 interface ReactCalciteAvatar extends Partial<Pick<Avatar, 'fullName' | 'label' | 'scale' | 'thumbnail' | 'userId' | 'username'>>, HTMLProps<HTMLCalciteAvatarElement> {
 }
 
-interface ReactCalciteBlock extends Partial<Pick<Block, 'collapsible' | 'description' | 'disabled' | 'dragHandle' | 'heading' | 'headingLevel' | 'iconEnd' | 'iconFlipRtl' | 'iconStart' | 'label' | 'loading' | 'menuFlipPlacements' | 'menuPlacement' | 'messageOverrides' | 'open' | 'overlayPositioning' | 'status'>>, HTMLProps<HTMLCalciteBlockElement> {
-  oncalciteBlockBeforeClose?: EventHandler<SyntheticEvent<HTMLCalciteBlockElement, HTMLCalciteBlockElement["calciteBlockBeforeClose"]>>;
-  oncalciteBlockBeforeOpen?: EventHandler<SyntheticEvent<HTMLCalciteBlockElement, HTMLCalciteBlockElement["calciteBlockBeforeOpen"]>>;
-  oncalciteBlockClose?: EventHandler<SyntheticEvent<HTMLCalciteBlockElement, HTMLCalciteBlockElement["calciteBlockClose"]>>;
-  oncalciteBlockOpen?: EventHandler<SyntheticEvent<HTMLCalciteBlockElement, HTMLCalciteBlockElement["calciteBlockOpen"]>>;
-  oncalciteBlockToggle?: EventHandler<SyntheticEvent<HTMLCalciteBlockElement, HTMLCalciteBlockElement["calciteBlockToggle"]>>;
+interface ReactCalciteBlock extends Partial<Pick<Block, 'collapsible' | 'description' | 'disabled' | 'dragDisabled' | 'dragHandle' | '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"]>;
+  oncalciteBlockGroupOrderChange?: EventHandler<HTMLCalciteBlockGroupElement["calciteBlockGroupOrderChange"]>;
 }
 
 interface ReactCalciteBlockSection extends Partial<Pick<BlockSection, 'iconEnd' | 'iconFlipRtl' | 'iconStart' | 'messageOverrides' | 'open' | 'status' | 'text' | 'toggleDisplay'>>, HTMLProps<HTMLCalciteBlockSectionElement> {
-  oncalciteBlockSectionToggle?: EventHandler<SyntheticEvent<HTMLCalciteBlockSectionElement, HTMLCalciteBlockSectionElement["calciteBlockSectionToggle"]>>;
+  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<SyntheticEvent<HTMLCalciteCardElement, HTMLCalciteCardElement["calciteCardSelect"]>>;
+  oncalciteCardSelect?: EventHandler<HTMLCalciteCardElement["calciteCardSelect"]>;
 }
 
 interface ReactCalciteCardGroup extends Required<Pick<CardGroup, 'label'>>, Partial<Pick<CardGroup, 'disabled' | 'selectionMode'>>, HTMLProps<HTMLCalciteCardGroupElement> {
-  oncalciteCardGroupSelect?: EventHandler<SyntheticEvent<HTMLCalciteCardGroupElement, HTMLCalciteCardGroupElement["calciteCardGroupSelect"]>>;
+  oncalciteCardGroupSelect?: EventHandler<HTMLCalciteCardGroupElement["calciteCardGroupSelect"]>;
 }
 
 interface ReactCalciteCarousel extends Required<Pick<Carousel, 'label'>>, Partial<Pick<Carousel, 'arrowType' | 'autoplay' | 'autoplayDuration' | 'controlOverlay' | 'disabled' | 'messageOverrides'>>, HTMLProps<HTMLCalciteCarouselElement> {
-  oncalciteCarouselChange?: EventHandler<SyntheticEvent<HTMLCalciteCarouselElement, HTMLCalciteCarouselElement["calciteCarouselChange"]>>;
-  oncalciteCarouselPause?: EventHandler<SyntheticEvent<HTMLCalciteCarouselElement, HTMLCalciteCarouselElement["calciteCarouselPause"]>>;
-  oncalciteCarouselPlay?: EventHandler<SyntheticEvent<HTMLCalciteCarouselElement, HTMLCalciteCarouselElement["calciteCarouselPlay"]>>;
-  oncalciteCarouselResume?: EventHandler<SyntheticEvent<HTMLCalciteCarouselElement, HTMLCalciteCarouselElement["calciteCarouselResume"]>>;
-  oncalciteCarouselStop?: EventHandler<SyntheticEvent<HTMLCalciteCarouselElement, HTMLCalciteCarouselElement["calciteCarouselStop"]>>;
+  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<SyntheticEvent<HTMLCalciteCheckboxElement, HTMLCalciteCheckboxElement["calciteCheckboxChange"]>>;
+  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<SyntheticEvent<HTMLCalciteChipElement, HTMLCalciteChipElement["calciteChipClose"]>>;
-  oncalciteChipSelect?: EventHandler<SyntheticEvent<HTMLCalciteChipElement, HTMLCalciteChipElement["calciteChipSelect"]>>;
+  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<SyntheticEvent<HTMLCalciteChipGroupElement, HTMLCalciteChipGroupElement["calciteChipGroupSelect"]>>;
+  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<SyntheticEvent<HTMLCalciteColorPickerElement, HTMLCalciteColorPickerElement["calciteColorPickerChange"]>>;
-  oncalciteColorPickerInput?: EventHandler<SyntheticEvent<HTMLCalciteColorPickerElement, HTMLCalciteColorPickerElement["calciteColorPickerInput"]>>;
+  oncalciteColorPickerChange?: EventHandler<HTMLCalciteColorPickerElement["calciteColorPickerChange"]>;
+  oncalciteColorPickerInput?: EventHandler<HTMLCalciteColorPickerElement["calciteColorPickerInput"]>;
 }
 
 interface ReactCalciteColorPickerHexInput extends Partial<Pick<ColorPickerHexInput, 'allowEmpty' | 'alphaChannel' | 'hexLabel' | 'numberingSystem' | 'scale' | 'value'>>, HTMLProps<HTMLCalciteColorPickerHexInputElement> {
-  oncalciteColorPickerHexInputChange?: EventHandler<SyntheticEvent<HTMLCalciteColorPickerHexInputElement, HTMLCalciteColorPickerHexInputElement["calciteColorPickerHexInputChange"]>>;
+  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' | 'selectionDisplay' | 'selectionMode' | 'status' | 'validationIcon' | 'validationMessage' | 'value'>>, HTMLProps<HTMLCalciteComboboxElement> {
-  oncalciteComboboxBeforeClose?: EventHandler<SyntheticEvent<HTMLCalciteComboboxElement, HTMLCalciteComboboxElement["calciteComboboxBeforeClose"]>>;
-  oncalciteComboboxBeforeOpen?: EventHandler<SyntheticEvent<HTMLCalciteComboboxElement, HTMLCalciteComboboxElement["calciteComboboxBeforeOpen"]>>;
-  oncalciteComboboxChange?: EventHandler<SyntheticEvent<HTMLCalciteComboboxElement, HTMLCalciteComboboxElement["calciteComboboxChange"]>>;
-  oncalciteComboboxChipClose?: EventHandler<SyntheticEvent<HTMLCalciteComboboxElement, HTMLCalciteComboboxElement["calciteComboboxChipClose"]>>;
-  oncalciteComboboxClose?: EventHandler<SyntheticEvent<HTMLCalciteComboboxElement, HTMLCalciteComboboxElement["calciteComboboxClose"]>>;
-  oncalciteComboboxFilterChange?: EventHandler<SyntheticEvent<HTMLCalciteComboboxElement, HTMLCalciteComboboxElement["calciteComboboxFilterChange"]>>;
-  oncalciteComboboxOpen?: EventHandler<SyntheticEvent<HTMLCalciteComboboxElement, HTMLCalciteComboboxElement["calciteComboboxOpen"]>>;
+  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<SyntheticEvent<HTMLCalciteComboboxItemElement, HTMLCalciteComboboxItemElement["calciteComboboxItemChange"]>>;
+  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<SyntheticEvent<HTMLCalciteDatePickerElement, HTMLCalciteDatePickerElement["calciteDatePickerChange"]>>;
-  oncalciteDatePickerRangeChange?: EventHandler<SyntheticEvent<HTMLCalciteDatePickerElement, HTMLCalciteDatePickerElement["calciteDatePickerRangeChange"]>>;
+  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> {
@@ -251,102 +263,102 @@ interface ReactCalciteDatePickerMonth extends Partial<Pick<DatePickerMonth, 'act
 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' | 'heading' | 'headingLevel' | 'kind' | 'loading' | 'menuOpen' | 'messageOverrides' | 'modal' | 'open' | 'outsideCloseDisabled' | 'overlayPositioning' | 'placement' | 'resizable' | 'scale' | 'width' | 'widthScale'>>, HTMLProps<HTMLCalciteDialogElement> {
-  oncalciteDialogBeforeClose?: EventHandler<SyntheticEvent<HTMLCalciteDialogElement, HTMLCalciteDialogElement["calciteDialogBeforeClose"]>>;
-  oncalciteDialogBeforeOpen?: EventHandler<SyntheticEvent<HTMLCalciteDialogElement, HTMLCalciteDialogElement["calciteDialogBeforeOpen"]>>;
-  oncalciteDialogClose?: EventHandler<SyntheticEvent<HTMLCalciteDialogElement, HTMLCalciteDialogElement["calciteDialogClose"]>>;
-  oncalciteDialogOpen?: EventHandler<SyntheticEvent<HTMLCalciteDialogElement, HTMLCalciteDialogElement["calciteDialogOpen"]>>;
-  oncalciteDialogScroll?: EventHandler<SyntheticEvent<HTMLCalciteDialogElement, HTMLCalciteDialogElement["calciteDialogScroll"]>>;
+interface ReactCalciteDialog extends Partial<Pick<Dialog, 'beforeClose' | 'closeDisabled' | 'description' | 'dragEnabled' | 'escapeDisabled' | 'focusTrapDisabled' | 'focusTrapOptions' | 'heading' | 'headingLevel' | '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' | 'open' | 'overlayPositioning' | 'placement' | 'scale' | 'type' | 'width' | 'widthScale'>>, HTMLProps<HTMLCalciteDropdownElement> {
-  oncalciteDropdownBeforeClose?: EventHandler<SyntheticEvent<HTMLCalciteDropdownElement, HTMLCalciteDropdownElement["calciteDropdownBeforeClose"]>>;
-  oncalciteDropdownBeforeOpen?: EventHandler<SyntheticEvent<HTMLCalciteDropdownElement, HTMLCalciteDropdownElement["calciteDropdownBeforeOpen"]>>;
-  oncalciteDropdownClose?: EventHandler<SyntheticEvent<HTMLCalciteDropdownElement, HTMLCalciteDropdownElement["calciteDropdownClose"]>>;
-  oncalciteDropdownOpen?: EventHandler<SyntheticEvent<HTMLCalciteDropdownElement, HTMLCalciteDropdownElement["calciteDropdownOpen"]>>;
-  oncalciteDropdownSelect?: EventHandler<SyntheticEvent<HTMLCalciteDropdownElement, HTMLCalciteDropdownElement["calciteDropdownSelect"]>>;
+  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' | 'selectionMode'>>, HTMLProps<HTMLCalciteDropdownGroupElement> {
 }
 
 interface ReactCalciteDropdownItem extends Partial<Pick<DropdownItem, 'disabled' | 'href' | 'iconEnd' | 'iconFlipRtl' | 'iconStart' | 'label' | 'rel' | 'selected' | 'target'>>, HTMLProps<HTMLCalciteDropdownItemElement> {
-  oncalciteDropdownItemSelect?: EventHandler<SyntheticEvent<HTMLCalciteDropdownItemElement, HTMLCalciteDropdownItemElement["calciteDropdownItemSelect"]>>;
+  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<SyntheticEvent<HTMLCalciteFilterElement, HTMLCalciteFilterElement["calciteFilterChange"]>>;
+  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' | 'loading' | 'menuOpen' | 'messageOverrides' | 'overlayPositioning' | 'scale' | 'selected' | 'showBackButton'>>, HTMLProps<HTMLCalciteFlowItemElement> {
-  oncalciteFlowItemBack?: EventHandler<SyntheticEvent<HTMLCalciteFlowItemElement, HTMLCalciteFlowItemElement["calciteFlowItemBack"]>>;
-  oncalciteFlowItemClose?: EventHandler<SyntheticEvent<HTMLCalciteFlowItemElement, HTMLCalciteFlowItemElement["calciteFlowItemClose"]>>;
-  oncalciteFlowItemScroll?: EventHandler<SyntheticEvent<HTMLCalciteFlowItemElement, HTMLCalciteFlowItemElement["calciteFlowItemScroll"]>>;
-  oncalciteFlowItemToggle?: EventHandler<SyntheticEvent<HTMLCalciteFlowItemElement, HTMLCalciteFlowItemElement["calciteFlowItemToggle"]>>;
+  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<SyntheticEvent<HTMLCalciteHandleElement, HTMLCalciteHandleElement["calciteHandleChange"]>>;
-  oncalciteHandleNudge?: EventHandler<SyntheticEvent<HTMLCalciteHandleElement, HTMLCalciteHandleElement["calciteHandleNudge"]>>;
+  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<SyntheticEvent<HTMLCalciteInlineEditableElement, HTMLCalciteInlineEditableElement["calciteInlineEditableEditCancel"]>>;
-  oncalciteInlineEditableEditConfirm?: EventHandler<SyntheticEvent<HTMLCalciteInlineEditableElement, HTMLCalciteInlineEditableElement["calciteInlineEditableEditConfirm"]>>;
+  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<SyntheticEvent<HTMLCalciteInputElement, HTMLCalciteInputElement["calciteInputChange"]>>;
-  oncalciteInputInput?: EventHandler<SyntheticEvent<HTMLCalciteInputElement, HTMLCalciteInputElement["calciteInputInput"]>>;
+  oncalciteInputChange?: EventHandler<HTMLCalciteInputElement["calciteInputChange"]>;
+  oncalciteInputInput?: EventHandler<HTMLCalciteInputElement["calciteInputInput"]>;
 }
 
 interface ReactCalciteInputDatePicker extends Partial<Pick<InputDatePicker, 'disabled' | 'flipPlacements' | 'focusTrapDisabled' | 'form' | 'headingLevel' | '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<SyntheticEvent<HTMLCalciteInputDatePickerElement, HTMLCalciteInputDatePickerElement["calciteInputDatePickerBeforeClose"]>>;
-  oncalciteInputDatePickerBeforeOpen?: EventHandler<SyntheticEvent<HTMLCalciteInputDatePickerElement, HTMLCalciteInputDatePickerElement["calciteInputDatePickerBeforeOpen"]>>;
-  oncalciteInputDatePickerChange?: EventHandler<SyntheticEvent<HTMLCalciteInputDatePickerElement, HTMLCalciteInputDatePickerElement["calciteInputDatePickerChange"]>>;
-  oncalciteInputDatePickerClose?: EventHandler<SyntheticEvent<HTMLCalciteInputDatePickerElement, HTMLCalciteInputDatePickerElement["calciteInputDatePickerClose"]>>;
-  oncalciteInputDatePickerOpen?: EventHandler<SyntheticEvent<HTMLCalciteInputDatePickerElement, HTMLCalciteInputDatePickerElement["calciteInputDatePickerOpen"]>>;
+  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<SyntheticEvent<HTMLCalciteInputNumberElement, HTMLCalciteInputNumberElement["calciteInputNumberChange"]>>;
-  oncalciteInputNumberInput?: EventHandler<SyntheticEvent<HTMLCalciteInputNumberElement, HTMLCalciteInputNumberElement["calciteInputNumberInput"]>>;
+  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<SyntheticEvent<HTMLCalciteInputTextElement, HTMLCalciteInputTextElement["calciteInputTextChange"]>>;
-  oncalciteInputTextInput?: EventHandler<SyntheticEvent<HTMLCalciteInputTextElement, HTMLCalciteInputTextElement["calciteInputTextInput"]>>;
+  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<SyntheticEvent<HTMLCalciteInputTimePickerElement, HTMLCalciteInputTimePickerElement["calciteInputTimePickerBeforeClose"]>>;
-  oncalciteInputTimePickerBeforeOpen?: EventHandler<SyntheticEvent<HTMLCalciteInputTimePickerElement, HTMLCalciteInputTimePickerElement["calciteInputTimePickerBeforeOpen"]>>;
-  oncalciteInputTimePickerChange?: EventHandler<SyntheticEvent<HTMLCalciteInputTimePickerElement, HTMLCalciteInputTimePickerElement["calciteInputTimePickerChange"]>>;
-  oncalciteInputTimePickerClose?: EventHandler<SyntheticEvent<HTMLCalciteInputTimePickerElement, HTMLCalciteInputTimePickerElement["calciteInputTimePickerClose"]>>;
-  oncalciteInputTimePickerOpen?: EventHandler<SyntheticEvent<HTMLCalciteInputTimePickerElement, HTMLCalciteInputTimePickerElement["calciteInputTimePickerOpen"]>>;
+  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<SyntheticEvent<HTMLCalciteInputTimeZoneElement, HTMLCalciteInputTimeZoneElement["calciteInputTimeZoneBeforeClose"]>>;
-  oncalciteInputTimeZoneBeforeOpen?: EventHandler<SyntheticEvent<HTMLCalciteInputTimeZoneElement, HTMLCalciteInputTimeZoneElement["calciteInputTimeZoneBeforeOpen"]>>;
-  oncalciteInputTimeZoneChange?: EventHandler<SyntheticEvent<HTMLCalciteInputTimeZoneElement, HTMLCalciteInputTimeZoneElement["calciteInputTimeZoneChange"]>>;
-  oncalciteInputTimeZoneClose?: EventHandler<SyntheticEvent<HTMLCalciteInputTimeZoneElement, HTMLCalciteInputTimeZoneElement["calciteInputTimeZoneClose"]>>;
-  oncalciteInputTimeZoneOpen?: EventHandler<SyntheticEvent<HTMLCalciteInputTimeZoneElement, HTMLCalciteInputTimeZoneElement["calciteInputTimeZoneOpen"]>>;
+  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> {
@@ -356,21 +368,21 @@ interface ReactCalciteLink extends Partial<Pick<Link, 'disabled' | 'download' |
 }
 
 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<SyntheticEvent<HTMLCalciteListElement, HTMLCalciteListElement["calciteListChange"]>>;
-  oncalciteListDragEnd?: EventHandler<SyntheticEvent<HTMLCalciteListElement, HTMLCalciteListElement["calciteListDragEnd"]>>;
-  oncalciteListDragStart?: EventHandler<SyntheticEvent<HTMLCalciteListElement, HTMLCalciteListElement["calciteListDragStart"]>>;
-  oncalciteListFilter?: EventHandler<SyntheticEvent<HTMLCalciteListElement, HTMLCalciteListElement["calciteListFilter"]>>;
-  oncalciteListOrderChange?: EventHandler<SyntheticEvent<HTMLCalciteListElement, HTMLCalciteListElement["calciteListOrderChange"]>>;
+  oncalciteListChange?: EventHandler<HTMLCalciteListElement["calciteListChange"]>;
+  oncalciteListDragEnd?: EventHandler<HTMLCalciteListElement["calciteListDragEnd"]>;
+  oncalciteListDragStart?: EventHandler<HTMLCalciteListElement["calciteListDragStart"]>;
+  oncalciteListFilter?: EventHandler<HTMLCalciteListElement["calciteListFilter"]>;
+  oncalciteListOrderChange?: EventHandler<HTMLCalciteListElement["calciteListOrderChange"]>;
 }
 
 interface ReactCalciteListItem extends Partial<Pick<ListItem, 'closable' | 'closed' | 'description' | 'disabled' | 'dragDisabled' | 'iconEnd' | 'iconFlipRtl' | 'iconStart' | 'label' | 'messageOverrides' | 'metadata' | 'open' | 'scale' | 'selected' | 'sortHandleOpen' | 'unavailable' | 'value'>>, HTMLProps<HTMLCalciteListItemElement> {
-  oncalciteListItemClose?: EventHandler<SyntheticEvent<HTMLCalciteListItemElement, HTMLCalciteListItemElement["calciteListItemClose"]>>;
-  oncalciteListItemSelect?: EventHandler<SyntheticEvent<HTMLCalciteListItemElement, HTMLCalciteListItemElement["calciteListItemSelect"]>>;
-  oncalciteListItemSortHandleBeforeClose?: EventHandler<SyntheticEvent<HTMLCalciteListItemElement, HTMLCalciteListItemElement["calciteListItemSortHandleBeforeClose"]>>;
-  oncalciteListItemSortHandleBeforeOpen?: EventHandler<SyntheticEvent<HTMLCalciteListItemElement, HTMLCalciteListItemElement["calciteListItemSortHandleBeforeOpen"]>>;
-  oncalciteListItemSortHandleClose?: EventHandler<SyntheticEvent<HTMLCalciteListItemElement, HTMLCalciteListItemElement["calciteListItemSortHandleClose"]>>;
-  oncalciteListItemSortHandleOpen?: EventHandler<SyntheticEvent<HTMLCalciteListItemElement, HTMLCalciteListItemElement["calciteListItemSortHandleOpen"]>>;
-  oncalciteListItemToggle?: EventHandler<SyntheticEvent<HTMLCalciteListItemElement, HTMLCalciteListItemElement["calciteListItemToggle"]>>;
+  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> {
@@ -383,21 +395,21 @@ interface ReactCalciteMenu extends Required<Pick<Menu, 'label'>>, Partial<Pick<M
 }
 
 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<SyntheticEvent<HTMLCalciteMenuItemElement, HTMLCalciteMenuItemElement["calciteMenuItemSelect"]>>;
+  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' | 'fullscreen' | 'kind' | 'messageOverrides' | 'open' | 'outsideCloseDisabled' | 'scale' | 'widthScale'>>, HTMLProps<HTMLCalciteModalElement> {
-  oncalciteModalBeforeClose?: EventHandler<SyntheticEvent<HTMLCalciteModalElement, HTMLCalciteModalElement["calciteModalBeforeClose"]>>;
-  oncalciteModalBeforeOpen?: EventHandler<SyntheticEvent<HTMLCalciteModalElement, HTMLCalciteModalElement["calciteModalBeforeOpen"]>>;
-  oncalciteModalClose?: EventHandler<SyntheticEvent<HTMLCalciteModalElement, HTMLCalciteModalElement["calciteModalClose"]>>;
-  oncalciteModalOpen?: EventHandler<SyntheticEvent<HTMLCalciteModalElement, HTMLCalciteModalElement["calciteModalOpen"]>>;
+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<SyntheticEvent<HTMLCalciteNavigationElement, HTMLCalciteNavigationElement["calciteNavigationActionSelect"]>>;
+  oncalciteNavigationActionSelect?: EventHandler<HTMLCalciteNavigationElement["calciteNavigationActionSelect"]>;
 }
 
 interface ReactCalciteNavigationLogo extends Partial<Pick<NavigationLogo, 'active' | 'description' | 'heading' | 'headingLevel' | 'href' | 'icon' | 'iconFlipRtl' | 'label' | 'rel' | 'target' | 'thumbnail'>>, HTMLProps<HTMLCalciteNavigationLogoElement> {
@@ -407,10 +419,10 @@ interface ReactCalciteNavigationUser extends Partial<Pick<NavigationUser, 'activ
 }
 
 interface ReactCalciteNotice extends Partial<Pick<Notice, 'closable' | 'icon' | 'iconFlipRtl' | 'kind' | 'messageOverrides' | 'open' | 'scale' | 'width'>>, HTMLProps<HTMLCalciteNoticeElement> {
-  oncalciteNoticeBeforeClose?: EventHandler<SyntheticEvent<HTMLCalciteNoticeElement, HTMLCalciteNoticeElement["calciteNoticeBeforeClose"]>>;
-  oncalciteNoticeBeforeOpen?: EventHandler<SyntheticEvent<HTMLCalciteNoticeElement, HTMLCalciteNoticeElement["calciteNoticeBeforeOpen"]>>;
-  oncalciteNoticeClose?: EventHandler<SyntheticEvent<HTMLCalciteNoticeElement, HTMLCalciteNoticeElement["calciteNoticeClose"]>>;
-  oncalciteNoticeOpen?: EventHandler<SyntheticEvent<HTMLCalciteNoticeElement, HTMLCalciteNoticeElement["calciteNoticeOpen"]>>;
+  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> {
@@ -420,56 +432,56 @@ interface ReactCalciteOptionGroup extends Required<Pick<OptionGroup, 'label'>>,
 }
 
 interface ReactCalcitePagination extends Partial<Pick<Pagination, 'groupSeparator' | 'messageOverrides' | 'numberingSystem' | 'pageSize' | 'scale' | 'startItem' | 'totalItems'>>, HTMLProps<HTMLCalcitePaginationElement> {
-  oncalcitePaginationChange?: EventHandler<SyntheticEvent<HTMLCalcitePaginationElement, HTMLCalcitePaginationElement["calcitePaginationChange"]>>;
+  oncalcitePaginationChange?: EventHandler<HTMLCalcitePaginationElement["calcitePaginationChange"]>;
 }
 
 interface ReactCalcitePanel extends Partial<Pick<Panel, 'beforeClose' | 'closable' | 'closed' | 'collapsed' | 'collapsible' | 'description' | 'disabled' | 'heading' | 'headingLevel' | 'loading' | 'menuFlipPlacements' | 'menuOpen' | 'menuPlacement' | 'messageOverrides' | 'overlayPositioning' | 'scale'>>, HTMLProps<HTMLCalcitePanelElement> {
-  oncalcitePanelClose?: EventHandler<SyntheticEvent<HTMLCalcitePanelElement, HTMLCalcitePanelElement["calcitePanelClose"]>>;
-  oncalcitePanelScroll?: EventHandler<SyntheticEvent<HTMLCalcitePanelElement, HTMLCalcitePanelElement["calcitePanelScroll"]>>;
-  oncalcitePanelToggle?: EventHandler<SyntheticEvent<HTMLCalcitePanelElement, HTMLCalcitePanelElement["calcitePanelToggle"]>>;
+  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' | 'heading' | 'headingLevel' | 'initialFocusTrapFocus' | 'messageOverrides' | 'offsetDistance' | 'offsetSkidding' | 'open' | 'overlayPositioning' | 'placement' | 'pointerDisabled' | 'scale' | 'triggerDisabled'>>, HTMLProps<HTMLCalcitePopoverElement> {
-  oncalcitePopoverBeforeClose?: EventHandler<SyntheticEvent<HTMLCalcitePopoverElement, HTMLCalcitePopoverElement["calcitePopoverBeforeClose"]>>;
-  oncalcitePopoverBeforeOpen?: EventHandler<SyntheticEvent<HTMLCalcitePopoverElement, HTMLCalcitePopoverElement["calcitePopoverBeforeOpen"]>>;
-  oncalcitePopoverClose?: EventHandler<SyntheticEvent<HTMLCalcitePopoverElement, HTMLCalcitePopoverElement["calcitePopoverClose"]>>;
-  oncalcitePopoverOpen?: EventHandler<SyntheticEvent<HTMLCalcitePopoverElement, HTMLCalcitePopoverElement["calcitePopoverOpen"]>>;
+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<SyntheticEvent<HTMLCalciteRadioButtonElement, HTMLCalciteRadioButtonElement["calciteRadioButtonChange"]>>;
+  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<SyntheticEvent<HTMLCalciteRadioButtonGroupElement, HTMLCalciteRadioButtonGroupElement["calciteRadioButtonGroupChange"]>>;
+  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<SyntheticEvent<HTMLCalciteRatingElement, HTMLCalciteRatingElement["calciteRatingChange"]>>;
+  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<SyntheticEvent<HTMLCalciteSegmentedControlElement, HTMLCalciteSegmentedControlElement["calciteSegmentedControlChange"]>>;
+  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<SyntheticEvent<HTMLCalciteSelectElement, HTMLCalciteSelectElement["calciteSelectChange"]>>;
+  oncalciteSelectChange?: EventHandler<HTMLCalciteSelectElement["calciteSelectChange"]>;
 }
 
-interface ReactCalciteSheet extends Required<Pick<Sheet, 'label'>>, Partial<Pick<Sheet, 'beforeClose' | 'displayMode' | 'escapeDisabled' | 'focusTrapDisabled' | 'height' | 'heightScale' | 'messageOverrides' | 'open' | 'outsideCloseDisabled' | 'position' | 'resizable' | 'width' | 'widthScale'>>, HTMLProps<HTMLCalciteSheetElement> {
-  oncalciteSheetBeforeClose?: EventHandler<SyntheticEvent<HTMLCalciteSheetElement, HTMLCalciteSheetElement["calciteSheetBeforeClose"]>>;
-  oncalciteSheetBeforeOpen?: EventHandler<SyntheticEvent<HTMLCalciteSheetElement, HTMLCalciteSheetElement["calciteSheetBeforeOpen"]>>;
-  oncalciteSheetClose?: EventHandler<SyntheticEvent<HTMLCalciteSheetElement, HTMLCalciteSheetElement["calciteSheetClose"]>>;
-  oncalciteSheetOpen?: EventHandler<SyntheticEvent<HTMLCalciteSheetElement, HTMLCalciteSheetElement["calciteSheetOpen"]>>;
+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> {
@@ -482,59 +494,59 @@ interface ReactCalciteShellPanel extends Partial<Pick<ShellPanel, 'collapsed' |
 }
 
 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<SyntheticEvent<HTMLCalciteSliderElement, HTMLCalciteSliderElement["calciteSliderChange"]>>;
-  oncalciteSliderInput?: EventHandler<SyntheticEvent<HTMLCalciteSliderElement, HTMLCalciteSliderElement["calciteSliderInput"]>>;
+  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<SyntheticEvent<HTMLCalciteSortHandleElement, HTMLCalciteSortHandleElement["calciteSortHandleBeforeClose"]>>;
-  oncalciteSortHandleBeforeOpen?: EventHandler<SyntheticEvent<HTMLCalciteSortHandleElement, HTMLCalciteSortHandleElement["calciteSortHandleBeforeOpen"]>>;
-  oncalciteSortHandleClose?: EventHandler<SyntheticEvent<HTMLCalciteSortHandleElement, HTMLCalciteSortHandleElement["calciteSortHandleClose"]>>;
-  oncalciteSortHandleMove?: EventHandler<SyntheticEvent<HTMLCalciteSortHandleElement, HTMLCalciteSortHandleElement["calciteSortHandleMove"]>>;
-  oncalciteSortHandleOpen?: EventHandler<SyntheticEvent<HTMLCalciteSortHandleElement, HTMLCalciteSortHandleElement["calciteSortHandleOpen"]>>;
-  oncalciteSortHandleReorder?: EventHandler<SyntheticEvent<HTMLCalciteSortHandleElement, HTMLCalciteSortHandleElement["calciteSortHandleReorder"]>>;
+  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<SyntheticEvent<HTMLCalciteSortableListElement, HTMLCalciteSortableListElement["calciteListOrderChange"]>>;
+  oncalciteListOrderChange?: EventHandler<HTMLCalciteSortableListElement["calciteListOrderChange"]>;
 }
 
 interface ReactCalciteSplitButton extends Partial<Pick<SplitButton, 'appearance' | 'disabled' | 'dropdownIconType' | 'dropdownLabel' | 'flipPlacements' | 'kind' | 'loading' | 'overlayPositioning' | 'placement' | 'primaryIconEnd' | 'primaryIconFlipRtl' | 'primaryIconStart' | 'primaryLabel' | 'primaryText' | 'scale' | 'width'>>, HTMLProps<HTMLCalciteSplitButtonElement> {
-  oncalciteSplitButtonPrimaryClick?: EventHandler<SyntheticEvent<HTMLCalciteSplitButtonElement, HTMLCalciteSplitButtonElement["calciteSplitButtonPrimaryClick"]>>;
-  oncalciteSplitButtonSecondaryClick?: EventHandler<SyntheticEvent<HTMLCalciteSplitButtonElement, HTMLCalciteSplitButtonElement["calciteSplitButtonSecondaryClick"]>>;
+  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<SyntheticEvent<HTMLCalciteStepperElement, HTMLCalciteStepperElement["calciteStepperChange"]>>;
-  oncalciteStepperItemChange?: EventHandler<SyntheticEvent<HTMLCalciteStepperElement, HTMLCalciteStepperElement["calciteStepperItemChange"]>>;
+  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<SyntheticEvent<HTMLCalciteStepperItemElement, HTMLCalciteStepperItemElement["calciteStepperItemSelect"]>>;
+  oncalciteStepperItemSelect?: EventHandler<HTMLCalciteStepperItemElement["calciteStepperItemSelect"]>;
 }
 
 interface ReactCalciteSwitch extends Partial<Pick<Switch, 'checked' | 'disabled' | 'form' | 'label' | 'name' | 'scale' | 'value'>>, HTMLProps<HTMLCalciteSwitchElement> {
-  oncalciteSwitchChange?: EventHandler<SyntheticEvent<HTMLCalciteSwitchElement, HTMLCalciteSwitchElement["calciteSwitchChange"]>>;
+  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<SyntheticEvent<HTMLCalciteTabNavElement, HTMLCalciteTabNavElement["calciteTabChange"]>>;
+  oncalciteTabChange?: EventHandler<HTMLCalciteTabNavElement["calciteTabChange"]>;
 }
 
 interface ReactCalciteTabTitle extends Partial<Pick<TabTitle, 'closable' | 'closed' | 'disabled' | 'iconEnd' | 'iconFlipRtl' | 'iconStart' | 'messageOverrides' | 'position' | 'selected' | 'tab'>>, HTMLProps<HTMLCalciteTabTitleElement> {
-  oncalciteTabsActivate?: EventHandler<SyntheticEvent<HTMLCalciteTabTitleElement, HTMLCalciteTabTitleElement["calciteTabsActivate"]>>;
-  oncalciteTabsClose?: EventHandler<SyntheticEvent<HTMLCalciteTabTitleElement, HTMLCalciteTabTitleElement["calciteTabsClose"]>>;
+  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<SyntheticEvent<HTMLCalciteTableElement, HTMLCalciteTableElement["calciteTablePageChange"]>>;
-  oncalciteTableSelect?: EventHandler<SyntheticEvent<HTMLCalciteTableElement, HTMLCalciteTableElement["calciteTableSelect"]>>;
+  oncalciteTablePageChange?: EventHandler<HTMLCalciteTableElement["calciteTablePageChange"]>;
+  oncalciteTableSelect?: EventHandler<HTMLCalciteTableElement["calciteTableSelect"]>;
 }
 
 interface ReactCalciteTableCell extends Partial<Pick<TableCell, 'alignment' | 'colSpan' | 'messageOverrides' | 'rowSpan'>>, HTMLProps<HTMLCalciteTableCellElement> {
@@ -544,56 +556,56 @@ interface ReactCalciteTableHeader extends Partial<Pick<TableHeader, 'alignment'
 }
 
 interface ReactCalciteTableRow extends Partial<Pick<TableRow, 'alignment' | 'disabled' | 'selected'>>, HTMLProps<HTMLCalciteTableRowElement> {
-  oncalciteTableRowSelect?: EventHandler<SyntheticEvent<HTMLCalciteTableRowElement, HTMLCalciteTableRowElement["calciteTableRowSelect"]>>;
+  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' | 'maxLength' | 'messageOverrides' | 'minLength' | 'name' | 'numberingSystem' | 'placeholder' | 'readOnly' | 'required' | 'resize' | 'rows' | 'scale' | 'status' | 'validationIcon' | 'validationMessage' | 'value' | 'wrap'>>, HTMLProps<HTMLCalciteTextAreaElement> {
-  oncalciteTextAreaChange?: EventHandler<SyntheticEvent<HTMLCalciteTextAreaElement, HTMLCalciteTextAreaElement["calciteTextAreaChange"]>>;
-  oncalciteTextAreaInput?: EventHandler<SyntheticEvent<HTMLCalciteTextAreaElement, HTMLCalciteTextAreaElement["calciteTextAreaInput"]>>;
+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<SyntheticEvent<HTMLCalciteTileElement, HTMLCalciteTileElement["calciteTileSelect"]>>;
+  oncalciteTileSelect?: EventHandler<HTMLCalciteTileElement["calciteTileSelect"]>;
 }
 
 interface ReactCalciteTileGroup extends Required<Pick<TileGroup, 'label'>>, Partial<Pick<TileGroup, 'alignment' | 'disabled' | 'layout' | 'scale' | 'selectionAppearance' | 'selectionMode'>>, HTMLProps<HTMLCalciteTileGroupElement> {
-  oncalciteTileGroupSelect?: EventHandler<SyntheticEvent<HTMLCalciteTileGroupElement, HTMLCalciteTileGroupElement["calciteTileGroupSelect"]>>;
+  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<SyntheticEvent<HTMLCalciteTileSelectElement, HTMLCalciteTileSelectElement["calciteTileSelectChange"]>>;
+  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<SyntheticEvent<HTMLCalciteTimePickerElement, HTMLCalciteTimePickerElement["calciteTimePickerChange"]>>;
+  oncalciteTimePickerChange?: EventHandler<HTMLCalciteTimePickerElement["calciteTimePickerChange"]>;
 }
 
 interface ReactCalciteTip extends Partial<Pick<Tip, 'closed' | 'closeDisabled' | 'heading' | 'headingLevel' | 'messageOverrides' | 'selected'>>, HTMLProps<HTMLCalciteTipElement> {
-  oncalciteTipDismiss?: EventHandler<SyntheticEvent<HTMLCalciteTipElement, HTMLCalciteTipElement["calciteTipDismiss"]>>;
+  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<SyntheticEvent<HTMLCalciteTipManagerElement, HTMLCalciteTipManagerElement["calciteTipManagerClose"]>>;
+  oncalciteTipManagerClose?: EventHandler<HTMLCalciteTipManagerElement["calciteTipManagerClose"]>;
 }
 
 interface ReactCalciteTooltip extends Partial<Pick<Tooltip, 'closeOnClick' | 'label' | 'offsetDistance' | 'offsetSkidding' | 'open' | 'overlayPositioning' | 'placement' | 'referenceElement'>>, HTMLProps<HTMLCalciteTooltipElement> {
-  oncalciteTooltipBeforeClose?: EventHandler<SyntheticEvent<HTMLCalciteTooltipElement, HTMLCalciteTooltipElement["calciteTooltipBeforeClose"]>>;
-  oncalciteTooltipBeforeOpen?: EventHandler<SyntheticEvent<HTMLCalciteTooltipElement, HTMLCalciteTooltipElement["calciteTooltipBeforeOpen"]>>;
-  oncalciteTooltipClose?: EventHandler<SyntheticEvent<HTMLCalciteTooltipElement, HTMLCalciteTooltipElement["calciteTooltipClose"]>>;
-  oncalciteTooltipOpen?: EventHandler<SyntheticEvent<HTMLCalciteTooltipElement, HTMLCalciteTooltipElement["calciteTooltipOpen"]>>;
+  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<SyntheticEvent<HTMLCalciteTreeElement, HTMLCalciteTreeElement["calciteTreeSelect"]>>;
+  oncalciteTreeSelect?: EventHandler<HTMLCalciteTreeElement["calciteTreeSelect"]>;
 }
 
 interface ReactCalciteTreeItem extends Partial<Pick<TreeItem, 'disabled' | 'expanded' | 'iconFlipRtl' | 'iconStart' | 'label' | 'selected'>>, HTMLProps<HTMLCalciteTreeItemElement> {
@@ -615,6 +627,7 @@ declare module "react" {
       "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;
@@ -731,6 +744,7 @@ declare module "react/jsx-runtime" {
       "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;
@@ -847,6 +861,7 @@ declare module "react/jsx-dev-runtime" {
       "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;