@paperless/core 2.0.1-beta.2 → 2.0.1-beta.21

package/dist/types/components.d.ts

@@ -8,34 +8,40 @@ import { HTMLStencilElement, JSXBase } from "./stencil-public-runtime";
 import { IconFlipOptions, IconVariant } from "./components/atoms/icon/icon.component";
 import { RotateOptions, TextSizeOptions } from "./types/tailwind";
 import { Placement, Strategy } from "@floating-ui/dom";
+import { HTMLInputTypeAttribute } from "react";
+import { templateFunc } from "./components/molecules/field-container/field-container.component";
+import { templateFunc as templateFunc1 } from "./components/molecules/field-container/field-container.component";
 import { IbanIconVariant, RotateOptions as RotateOptions1, TableDefinitionData, TableDefinitionTemplateFunc } from "./types";
 import { IconFlipOptions as IconFlipOptions1, IconVariant as IconVariant1 } from "./components/atoms/icon/icon.component";
 import { IconDeprecatedVariant } from "./components/atoms/icon-deprecated/icon.component";
 import { IllustrationVariant } from "./components/atoms/illustration/illustration.component";
 import { Observable } from "rxjs";
-import { templateFunc } from "./components/molecules/page-size-select/page-size-select.component";
-import { amountSelectedTemplateFunc, templateFunc as templateFunc1 } from "./components/organisms/table/table.component";
+import { templateFunc as templateFunc2 } from "./components/molecules/page-size-select/page-size-select.component";
+import { amountSelectedTemplateFunc, templateFunc as templateFunc3 } from "./components/organisms/table/table.component";
 import { QuickFilter, RowClickEvent, TableColumnSizes } from "./types/table";
 import { IconFlipOptions as IconFlipOptions2, IconVariant as IconVariant2, RotateOptions as RotateOptions2 } from "./components";
 import { buttonTemplateFunc } from "./components/molecules/table-header/table-header.component";
 import { TableColumn } from "./components/helpers/table-column/table-column.component";
-import { buttonTemplateFunc as buttonTemplateFunc1, templateFunc as templateFunc2 } from "./components/molecules/table-header/table-header.component";
+import { buttonTemplateFunc as buttonTemplateFunc1, templateFunc as templateFunc4 } from "./components/molecules/table-header/table-header.component";
 import { TableRowActionFunc, TableRowActionShowFunc } from "./components/helpers/table-row-action/table-row-action.component";
 export { IconFlipOptions, IconVariant } from "./components/atoms/icon/icon.component";
 export { RotateOptions, TextSizeOptions } from "./types/tailwind";
 export { Placement, Strategy } from "@floating-ui/dom";
+export { HTMLInputTypeAttribute } from "react";
+export { templateFunc } from "./components/molecules/field-container/field-container.component";
+export { templateFunc as templateFunc1 } from "./components/molecules/field-container/field-container.component";
 export { IbanIconVariant, RotateOptions as RotateOptions1, TableDefinitionData, TableDefinitionTemplateFunc } from "./types";
 export { IconFlipOptions as IconFlipOptions1, IconVariant as IconVariant1 } from "./components/atoms/icon/icon.component";
 export { IconDeprecatedVariant } from "./components/atoms/icon-deprecated/icon.component";
 export { IllustrationVariant } from "./components/atoms/illustration/illustration.component";
 export { Observable } from "rxjs";
-export { templateFunc } from "./components/molecules/page-size-select/page-size-select.component";
-export { amountSelectedTemplateFunc, templateFunc as templateFunc1 } from "./components/organisms/table/table.component";
+export { templateFunc as templateFunc2 } from "./components/molecules/page-size-select/page-size-select.component";
+export { amountSelectedTemplateFunc, templateFunc as templateFunc3 } from "./components/organisms/table/table.component";
 export { QuickFilter, RowClickEvent, TableColumnSizes } from "./types/table";
 export { IconFlipOptions as IconFlipOptions2, IconVariant as IconVariant2, RotateOptions as RotateOptions2 } from "./components";
 export { buttonTemplateFunc } from "./components/molecules/table-header/table-header.component";
 export { TableColumn } from "./components/helpers/table-column/table-column.component";
-export { buttonTemplateFunc as buttonTemplateFunc1, templateFunc as templateFunc2 } from "./components/molecules/table-header/table-header.component";
+export { buttonTemplateFunc as buttonTemplateFunc1, templateFunc as templateFunc4 } from "./components/molecules/table-header/table-header.component";
 export { TableRowActionFunc, TableRowActionShowFunc } from "./components/helpers/table-row-action/table-row-action.component";
 export namespace Components {
     interface PAccordion {
@@ -130,6 +136,10 @@ export namespace Components {
     interface PBadge {
     }
     interface PButton {
+        /**
+          * Wether to force an active state
+         */
+        "active": boolean;
         /**
           * The type of the button
          */
@@ -146,6 +156,10 @@ export namespace Components {
           * Chevron position
          */
         "chevronPosition": 'start' | 'end';
+        /**
+          * The class of the container passed by parent
+         */
+        "class": string;
         /**
           * Wether the button is disabled
          */
@@ -201,7 +215,11 @@ export namespace Components {
         /**
           * The variant of the button
          */
-        "variant": 'primary' | 'secondary' | 'transparent' | 'text';
+        "variant": | 'primary'
+		| 'secondary'
+		| 'transparent'
+		| 'text'
+		| 'dropdown';
     }
     interface PButtonGroup {
         /**
@@ -269,6 +287,36 @@ export namespace Components {
          */
         "header": string;
     }
+    interface PCheckbox {
+        /**
+          * Wether the checkbox is checked
+         */
+        "checked": boolean;
+        /**
+          * Wether the checkbox is disabled
+         */
+        "disabled": boolean;
+        /**
+          * The id of the checkbox button
+         */
+        "id": string;
+        /**
+          * Wether the checkbox is in indeterminate state
+         */
+        "indeterminate": boolean;
+        /**
+          * The name of the checkbox button
+         */
+        "name": string;
+        /**
+          * Wether the checkbox is required
+         */
+        "required": boolean;
+        /**
+          * The size of the checkbox
+         */
+        "size": 'sm' | 'base';
+    }
     interface PContentSlider {
         /**
           * Wether to disable auto centering the content
@@ -379,7 +427,7 @@ export namespace Components {
         /**
           * The size of the input group used by the datepicker
          */
-        "size": 'small' | 'medium';
+        "size": 'sm' | 'base';
         /**
           * The strategy of the dropdown placement
          */
@@ -500,6 +548,10 @@ export namespace Components {
           * The strategy of the dropdown placement
          */
         "strategy": Strategy;
+        /**
+          * Wether to use a portal for the dropdown container
+         */
+        "usePortal": boolean;
     }
     interface PDropdownMenuContainer {
         /**
@@ -528,6 +580,10 @@ export namespace Components {
           * Wether the dropdown menu item is active
          */
         "active": boolean;
+        /**
+          * Wether the dropdown menu item has a checkbox
+         */
+        "checkbox": boolean;
         /**
           * Wether the item is disabled
          */
@@ -547,7 +603,127 @@ export namespace Components {
         /**
           * The variant of the item
          */
-        "variant": 'default' | 'checkbox';
+        "variant": 'default' | 'negative';
+    }
+    interface PField {
+        /**
+          * Wether the input group is disabled
+         */
+        "disabled": boolean;
+        /**
+          * The error to display
+         */
+        "error": string;
+        /**
+          * The placement of the error popover
+         */
+        "errorPlacement": Placement;
+        /**
+          * The method to use when focusing the input
+         */
+        "focusMethod": 'focus' | 'click';
+        /**
+          * Wether the input group is focused
+         */
+        "focused": boolean;
+        /**
+          * Force show the error tooltip
+         */
+        "forceShowTooltip": boolean;
+        /**
+          * The helper of the input group
+         */
+        "helper": string;
+        /**
+          * Icon of the input group
+         */
+        "icon": IconVariant;
+        /**
+          * Icon flip
+         */
+        "iconFlip": IconFlipOptions;
+        /**
+          * Icon position
+         */
+        "iconPosition": 'start' | 'end';
+        /**
+          * Icon rotate
+         */
+        "iconRotate": RotateOptions;
+        /**
+          * The label of the input group
+         */
+        "label": string;
+        /**
+          * The template for the optional text
+         */
+        "optionalTemplate": templateFunc;
+        /**
+          * The placeholder of the input
+         */
+        "placeholder": string;
+        /**
+          * The prefix of the input group
+         */
+        "prefix": string;
+        /**
+          * The size of the input group
+         */
+        "properties": any | string;
+        /**
+          * Wether the field is required
+         */
+        "required": boolean;
+        /**
+          * Wether to select all text on focus
+         */
+        "selectAllOnFocus": boolean;
+        /**
+          * The size of the input group
+         */
+        "size": 'sm' | 'base';
+        /**
+          * The suffix of the input group
+         */
+        "suffix": string;
+        /**
+          * The type of the input group
+         */
+        "type": HTMLInputTypeAttribute | 'textarea' | 'slot';
+        /**
+          * The value of the input
+         */
+        "value": string;
+    }
+    interface PFieldContainer {
+        /**
+          * The helper of the input group
+         */
+        "error": string | HTMLSlotElement;
+        /**
+          * The placement of the error popover
+         */
+        "errorPlacement": Placement;
+        /**
+          * Force show the error tooltip
+         */
+        "forceShowTooltip": boolean;
+        /**
+          * The helper of the input group
+         */
+        "helper": string | HTMLSlotElement;
+        /**
+          * The label of the input group
+         */
+        "label": string | HTMLSlotElement;
+        /**
+          * The template for the optional text
+         */
+        "optionalTemplate": templateFunc1;
+        /**
+          * Wether the field is required
+         */
+        "required": boolean;
     }
     interface PFloatingMenuContainer {
         /**
@@ -655,72 +831,6 @@ export namespace Components {
          */
         "forceShowTooltip": boolean;
     }
-    interface PInputGroup {
-        /**
-          * Wether the input group is disabled
-         */
-        "disabled": boolean;
-        /**
-          * The helper of the input group
-         */
-        "error": string;
-        /**
-          * The error variant to use
-         */
-        "errorVariant": 'auto' | 'suffix' | 'element';
-        /**
-          * The method to use when focusing the input
-         */
-        "focusMethod": 'focus' | 'click';
-        /**
-          * Wether the input group is focused
-         */
-        "focused": boolean;
-        /**
-          * Force show the error tooltip
-         */
-        "forceShowTooltip": boolean;
-        /**
-          * The helper of the input group
-         */
-        "helper": string;
-        /**
-          * Icon of the input group
-         */
-        "icon": IconVariant;
-        /**
-          * Icon flip
-         */
-        "iconFlip": IconFlipOptions;
-        /**
-          * Icon position
-         */
-        "iconPosition": 'start' | 'end';
-        /**
-          * Icon rotate
-         */
-        "iconRotate": RotateOptions;
-        /**
-          * The label of the input group
-         */
-        "label": string;
-        /**
-          * The prefix of the input group
-         */
-        "prefix": string;
-        /**
-          * Wether the field is required
-         */
-        "required": boolean;
-        /**
-          * The size of the input group
-         */
-        "size": 'small' | 'medium';
-        /**
-          * The suffix of the input group
-         */
-        "suffix": string;
-    }
     interface PLabel {
         /**
           * Define the behavior of the label
@@ -790,11 +900,7 @@ export namespace Components {
         /**
           * Variant of loader
          */
-        "variant": | 'inline'
-		| 'full-width'
-		| 'full-screen'
-		| 'modal'
-		| 'ghost';
+        "variant": 'inline' | 'full-width' | 'full-screen' | 'modal' | 'ghost';
     }
     interface PModal {
         /**
@@ -875,10 +981,6 @@ export namespace Components {
         "showClose": boolean;
     }
     interface PNavbar {
-        /**
-          * The text to display for the menu button & sidebar title
-         */
-        "menuText": string;
     }
     interface PNavigationItem {
         /**
@@ -889,6 +991,10 @@ export namespace Components {
           * The element to use for the navigation item
          */
         "as": string;
+        /**
+          * The class of the container passed by parent
+         */
+        "class": string;
         /**
           * Icon of the navigation item
          */
@@ -901,11 +1007,21 @@ export namespace Components {
           * Icon of the navigation item
          */
         "icon": IconVariant;
+        /**
+          * Wether the navigation item is loading
+         */
+        "loading": boolean;
         /**
           * The target of the navigation item
          */
         "target": string;
     }
+    interface PNavigationSection {
+        /**
+          * The header of the section
+         */
+        "header": string;
+    }
     interface PNavigationTitle {
     }
     interface PPageSizeSelect {
@@ -916,7 +1032,7 @@ export namespace Components {
         /**
           * The template for the data view
          */
-        "buttonTemplate": templateFunc;
+        "buttonTemplate": templateFunc2;
         /**
           * Chevron position
          */
@@ -928,7 +1044,7 @@ export namespace Components {
         /**
           * The template for the data view
          */
-        "itemTemplate": templateFunc;
+        "itemTemplate": templateFunc2;
         /**
           * The current page
          */
@@ -962,22 +1078,43 @@ export namespace Components {
          */
         "active": boolean;
     }
+    interface PPortal {
+    }
     interface PProfile {
         /**
           * The position of the dropdown
          */
         "dropdownLocation": 'top-end' | 'bottom-end';
+    }
+    interface PRadio {
         /**
-          * The size of the profile avatar
+          * Wether the radio is checked
          */
-        "size": | 'xs'
-		| 'sm'
-		| 'base'
-		| 'lg'
-		| 'xl'
-		| '2xl'
-		| '3xl'
-		| '4xl';
+        "checked": boolean;
+        /**
+          * Wether the radio is disabled
+         */
+        "disabled": boolean;
+        /**
+          * The id of the radio button
+         */
+        "id": string;
+        /**
+          * The name of the radio button
+         */
+        "name": string;
+        /**
+          * Wether the radio is required
+         */
+        "required": boolean;
+        /**
+          * The size of the radio
+         */
+        "size": 'sm' | 'base';
+        /**
+          * The value of the radio button
+         */
+        "value": string;
     }
     interface PSegmentContainer {
     }
@@ -1151,7 +1288,7 @@ export namespace Components {
         /**
           * The size of the input group used by the select
          */
-        "size": 'small' | 'medium';
+        "size": 'sm' | 'base';
         /**
           * The current value
          */
@@ -1272,11 +1409,11 @@ export namespace Components {
           * A key to determine if a row can be selected
          */
         "canSelectKey": string;
-        "emptyStateAction": templateFunc1;
-        "emptyStateContent": templateFunc1;
-        "emptyStateFilteredContent": templateFunc1;
-        "emptyStateFilteredHeader": templateFunc1;
-        "emptyStateHeader": templateFunc1;
+        "emptyStateAction": templateFunc3;
+        "emptyStateContent": templateFunc3;
+        "emptyStateFilteredContent": templateFunc3;
+        "emptyStateFilteredHeader": templateFunc3;
+        "emptyStateHeader": templateFunc3;
         /**
           * Wether to show the action button
          */
@@ -1332,7 +1469,7 @@ export namespace Components {
         /**
           * The template for the filter button text
          */
-        "filterButtonTemplate": templateFunc1;
+        "filterButtonTemplate": templateFunc3;
         /**
           * The template for amount selected item in the floating menu
          */
@@ -1565,7 +1702,7 @@ export namespace Components {
         /**
           * The template for the filter button text
          */
-        "filterButtonTemplate": templateFunc2;
+        "filterButtonTemplate": templateFunc4;
         /**
           * The amount of items that are selected
          */
@@ -1675,6 +1812,36 @@ export namespace Components {
          */
         "placement": 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end';
     }
+    interface PToggle {
+        /**
+          * Wether the checkbox is checked
+         */
+        "checked": boolean;
+        /**
+          * Wether the checkbox is disabled
+         */
+        "disabled": boolean;
+        /**
+          * The id of the checkbox button
+         */
+        "id": string;
+        /**
+          * Wether the checkbox is in indeterminate state
+         */
+        "indeterminate": boolean;
+        /**
+          * The name of the checkbox button
+         */
+        "name": string;
+        /**
+          * Wether the checkbox is required
+         */
+        "required": boolean;
+        /**
+          * The size of the checkbox
+         */
+        "size": 'sm' | 'base';
+    }
     interface PTooltip {
         /**
           * Wether to someone can manually close the popover
@@ -1704,10 +1871,14 @@ export namespace Components {
           * The strategy of the popover placement
          */
         "strategy": Strategy;
+        /**
+          * Wether to use a portal for the tooltip
+         */
+        "usePortal": boolean;
         /**
           * The variant of the popover
          */
-        "variant": 'hover' | 'click' | 'error' | 'error-element';
+        "variant": 'hover' | 'click' | 'error';
     }
 }
 export interface PAccordionCustomEvent<T> extends CustomEvent<T> {
@@ -1730,6 +1901,10 @@ export interface PCalendarCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLPCalendarElement;
 }
+export interface PCheckboxCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLPCheckboxElement;
+}
 export interface PCropperCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLPCropperElement;
@@ -1750,6 +1925,14 @@ export interface PDropdownCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLPDropdownElement;
 }
+export interface PFieldCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLPFieldElement;
+}
+export interface PFieldContainerCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLPFieldContainerElement;
+}
 export interface PInfoPanelCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLPInfoPanelElement;
@@ -1770,6 +1953,10 @@ export interface PPaginationCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLPPaginationElement;
 }
+export interface PRadioCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLPRadioElement;
+}
 export interface PSelectCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLPSelectElement;
@@ -1794,18 +1981,45 @@ export interface PToastCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLPToastElement;
 }
+export interface PToggleCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLPToggleElement;
+}
 export interface PTooltipCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLPTooltipElement;
 }
 declare global {
+    interface HTMLPAccordionElementEventMap {
+        "isOpen": boolean;
+    }
     interface HTMLPAccordionElement extends Components.PAccordion, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLPAccordionElementEventMap>(type: K, listener: (this: HTMLPAccordionElement, ev: PAccordionCustomEvent<HTMLPAccordionElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLPAccordionElementEventMap>(type: K, listener: (this: HTMLPAccordionElement, ev: PAccordionCustomEvent<HTMLPAccordionElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     }
     var HTMLPAccordionElement: {
         prototype: HTMLPAccordionElement;
         new (): HTMLPAccordionElement;
     };
+    interface HTMLPAttachmentElementEventMap {
+        "download": any;
+        "delete": any;
+    }
     interface HTMLPAttachmentElement extends Components.PAttachment, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLPAttachmentElementEventMap>(type: K, listener: (this: HTMLPAttachmentElement, ev: PAttachmentCustomEvent<HTMLPAttachmentElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLPAttachmentElementEventMap>(type: K, listener: (this: HTMLPAttachmentElement, ev: PAttachmentCustomEvent<HTMLPAttachmentElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     }
     var HTMLPAttachmentElement: {
         prototype: HTMLPAttachmentElement;
@@ -1823,7 +2037,18 @@ declare global {
         prototype: HTMLPAvatarGroupElement;
         new (): HTMLPAvatarGroupElement;
     };
+    interface HTMLPBackdropElementEventMap {
+        "clicked": MouseEvent;
+    }
     interface HTMLPBackdropElement extends Components.PBackdrop, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLPBackdropElementEventMap>(type: K, listener: (this: HTMLPBackdropElement, ev: PBackdropCustomEvent<HTMLPBackdropElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLPBackdropElementEventMap>(type: K, listener: (this: HTMLPBackdropElement, ev: PBackdropCustomEvent<HTMLPBackdropElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     }
     var HTMLPBackdropElement: {
         prototype: HTMLPBackdropElement;
@@ -1835,7 +2060,18 @@ declare global {
         prototype: HTMLPBadgeElement;
         new (): HTMLPBadgeElement;
     };
+    interface HTMLPButtonElementEventMap {
+        "onClick": MouseEvent;
+    }
     interface HTMLPButtonElement extends Components.PButton, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLPButtonElementEventMap>(type: K, listener: (this: HTMLPButtonElement, ev: PButtonCustomEvent<HTMLPButtonElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLPButtonElementEventMap>(type: K, listener: (this: HTMLPButtonElement, ev: PButtonCustomEvent<HTMLPButtonElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     }
     var HTMLPButtonElement: {
         prototype: HTMLPButtonElement;
@@ -1847,7 +2083,18 @@ declare global {
         prototype: HTMLPButtonGroupElement;
         new (): HTMLPButtonGroupElement;
     };
+    interface HTMLPCalendarElementEventMap {
+        "valueChange": any;
+    }
     interface HTMLPCalendarElement extends Components.PCalendar, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLPCalendarElementEventMap>(type: K, listener: (this: HTMLPCalendarElement, ev: PCalendarCustomEvent<HTMLPCalendarElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLPCalendarElementEventMap>(type: K, listener: (this: HTMLPCalendarElement, ev: PCalendarCustomEvent<HTMLPCalendarElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     }
     var HTMLPCalendarElement: {
         prototype: HTMLPCalendarElement;
@@ -1871,6 +2118,24 @@ declare global {
         prototype: HTMLPCardHeaderElement;
         new (): HTMLPCardHeaderElement;
     };
+    interface HTMLPCheckboxElementEventMap {
+        "checkedChange": boolean;
+        "indeterminateChange": boolean;
+    }
+    interface HTMLPCheckboxElement extends Components.PCheckbox, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLPCheckboxElementEventMap>(type: K, listener: (this: HTMLPCheckboxElement, ev: PCheckboxCustomEvent<HTMLPCheckboxElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLPCheckboxElementEventMap>(type: K, listener: (this: HTMLPCheckboxElement, ev: PCheckboxCustomEvent<HTMLPCheckboxElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLPCheckboxElement: {
+        prototype: HTMLPCheckboxElement;
+        new (): HTMLPCheckboxElement;
+    };
     interface HTMLPContentSliderElement extends Components.PContentSlider, HTMLStencilElement {
     }
     var HTMLPContentSliderElement: {
@@ -1883,13 +2148,35 @@ declare global {
         prototype: HTMLPCounterElement;
         new (): HTMLPCounterElement;
     };
+    interface HTMLPCropperElementEventMap {
+        "valueChange": any;
+    }
     interface HTMLPCropperElement extends Components.PCropper, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLPCropperElementEventMap>(type: K, listener: (this: HTMLPCropperElement, ev: PCropperCustomEvent<HTMLPCropperElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLPCropperElementEventMap>(type: K, listener: (this: HTMLPCropperElement, ev: PCropperCustomEvent<HTMLPCropperElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     }
     var HTMLPCropperElement: {
         prototype: HTMLPCropperElement;
         new (): HTMLPCropperElement;
     };
+    interface HTMLPDatepickerElementEventMap {
+        "valueChange": any;
+    }
     interface HTMLPDatepickerElement extends Components.PDatepicker, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLPDatepickerElementEventMap>(type: K, listener: (this: HTMLPDatepickerElement, ev: PDatepickerCustomEvent<HTMLPDatepickerElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLPDatepickerElementEventMap>(type: K, listener: (this: HTMLPDatepickerElement, ev: PDatepickerCustomEvent<HTMLPDatepickerElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     }
     var HTMLPDatepickerElement: {
         prototype: HTMLPDatepickerElement;
@@ -1901,7 +2188,23 @@ declare global {
         prototype: HTMLPDividerElement;
         new (): HTMLPDividerElement;
     };
+    interface HTMLPDrawerElementEventMap {
+        "closeClicked": {
+		event: MouseEvent;
+		canClose: boolean;
+    source: 'unknown' | 'backdrop' | 'close' | 'event'
+	};
+        "closed": null;
+    }
     interface HTMLPDrawerElement extends Components.PDrawer, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLPDrawerElementEventMap>(type: K, listener: (this: HTMLPDrawerElement, ev: PDrawerCustomEvent<HTMLPDrawerElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLPDrawerElementEventMap>(type: K, listener: (this: HTMLPDrawerElement, ev: PDrawerCustomEvent<HTMLPDrawerElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     }
     var HTMLPDrawerElement: {
         prototype: HTMLPDrawerElement;
@@ -1919,13 +2222,35 @@ declare global {
         prototype: HTMLPDrawerContainerElement;
         new (): HTMLPDrawerContainerElement;
     };
+    interface HTMLPDrawerHeaderElementEventMap {
+        "close": MouseEvent;
+    }
     interface HTMLPDrawerHeaderElement extends Components.PDrawerHeader, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLPDrawerHeaderElementEventMap>(type: K, listener: (this: HTMLPDrawerHeaderElement, ev: PDrawerHeaderCustomEvent<HTMLPDrawerHeaderElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLPDrawerHeaderElementEventMap>(type: K, listener: (this: HTMLPDrawerHeaderElement, ev: PDrawerHeaderCustomEvent<HTMLPDrawerHeaderElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     }
     var HTMLPDrawerHeaderElement: {
         prototype: HTMLPDrawerHeaderElement;
         new (): HTMLPDrawerHeaderElement;
     };
+    interface HTMLPDropdownElementEventMap {
+        "isOpen": boolean;
+    }
     interface HTMLPDropdownElement extends Components.PDropdown, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLPDropdownElementEventMap>(type: K, listener: (this: HTMLPDropdownElement, ev: PDropdownCustomEvent<HTMLPDropdownElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLPDropdownElementEventMap>(type: K, listener: (this: HTMLPDropdownElement, ev: PDropdownCustomEvent<HTMLPDropdownElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     }
     var HTMLPDropdownElement: {
         prototype: HTMLPDropdownElement;
@@ -1943,6 +2268,41 @@ declare global {
         prototype: HTMLPDropdownMenuItemElement;
         new (): HTMLPDropdownMenuItemElement;
     };
+    interface HTMLPFieldElementEventMap {
+        "valueChange": string;
+        "inputRefChange": HTMLInputElement | HTMLTextAreaElement;
+    }
+    interface HTMLPFieldElement extends Components.PField, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLPFieldElementEventMap>(type: K, listener: (this: HTMLPFieldElement, ev: PFieldCustomEvent<HTMLPFieldElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLPFieldElementEventMap>(type: K, listener: (this: HTMLPFieldElement, ev: PFieldCustomEvent<HTMLPFieldElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLPFieldElement: {
+        prototype: HTMLPFieldElement;
+        new (): HTMLPFieldElement;
+    };
+    interface HTMLPFieldContainerElementEventMap {
+        "focus": void;
+    }
+    interface HTMLPFieldContainerElement extends Components.PFieldContainer, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLPFieldContainerElementEventMap>(type: K, listener: (this: HTMLPFieldContainerElement, ev: PFieldContainerCustomEvent<HTMLPFieldContainerElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLPFieldContainerElementEventMap>(type: K, listener: (this: HTMLPFieldContainerElement, ev: PFieldContainerCustomEvent<HTMLPFieldContainerElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLPFieldContainerElement: {
+        prototype: HTMLPFieldContainerElement;
+        new (): HTMLPFieldContainerElement;
+    };
     interface HTMLPFloatingMenuContainerElement extends Components.PFloatingMenuContainer, HTMLStencilElement {
     }
     var HTMLPFloatingMenuContainerElement: {
@@ -1985,7 +2345,18 @@ declare global {
         prototype: HTMLPIllustrationElement;
         new (): HTMLPIllustrationElement;
     };
+    interface HTMLPInfoPanelElementEventMap {
+        "closed": void;
+    }
     interface HTMLPInfoPanelElement extends Components.PInfoPanel, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLPInfoPanelElementEventMap>(type: K, listener: (this: HTMLPInfoPanelElement, ev: PInfoPanelCustomEvent<HTMLPInfoPanelElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLPInfoPanelElementEventMap>(type: K, listener: (this: HTMLPInfoPanelElement, ev: PInfoPanelCustomEvent<HTMLPInfoPanelElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     }
     var HTMLPInfoPanelElement: {
         prototype: HTMLPInfoPanelElement;
@@ -1997,12 +2368,6 @@ declare global {
         prototype: HTMLPInputErrorElement;
         new (): HTMLPInputErrorElement;
     };
-    interface HTMLPInputGroupElement extends Components.PInputGroup, HTMLStencilElement {
-    }
-    var HTMLPInputGroupElement: {
-        prototype: HTMLPInputGroupElement;
-        new (): HTMLPInputGroupElement;
-    };
     interface HTMLPLabelElement extends Components.PLabel, HTMLStencilElement {
     }
     var HTMLPLabelElement: {
@@ -2021,7 +2386,19 @@ declare global {
         prototype: HTMLPLoaderElement;
         new (): HTMLPLoaderElement;
     };
+    interface HTMLPModalElementEventMap {
+        "closeClicked": MouseEvent;
+        "closed": string;
+    }
     interface HTMLPModalElement extends Components.PModal, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLPModalElementEventMap>(type: K, listener: (this: HTMLPModalElement, ev: PModalCustomEvent<HTMLPModalElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLPModalElementEventMap>(type: K, listener: (this: HTMLPModalElement, ev: PModalCustomEvent<HTMLPModalElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     }
     var HTMLPModalElement: {
         prototype: HTMLPModalElement;
@@ -2045,7 +2422,18 @@ declare global {
         prototype: HTMLPModalFooterElement;
         new (): HTMLPModalFooterElement;
     };
+    interface HTMLPModalHeaderElementEventMap {
+        "close": MouseEvent;
+    }
     interface HTMLPModalHeaderElement extends Components.PModalHeader, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLPModalHeaderElementEventMap>(type: K, listener: (this: HTMLPModalHeaderElement, ev: PModalHeaderCustomEvent<HTMLPModalHeaderElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLPModalHeaderElementEventMap>(type: K, listener: (this: HTMLPModalHeaderElement, ev: PModalHeaderCustomEvent<HTMLPModalHeaderElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     }
     var HTMLPModalHeaderElement: {
         prototype: HTMLPModalHeaderElement;
@@ -2063,19 +2451,47 @@ declare global {
         prototype: HTMLPNavigationItemElement;
         new (): HTMLPNavigationItemElement;
     };
+    interface HTMLPNavigationSectionElement extends Components.PNavigationSection, HTMLStencilElement {
+    }
+    var HTMLPNavigationSectionElement: {
+        prototype: HTMLPNavigationSectionElement;
+        new (): HTMLPNavigationSectionElement;
+    };
     interface HTMLPNavigationTitleElement extends Components.PNavigationTitle, HTMLStencilElement {
     }
     var HTMLPNavigationTitleElement: {
         prototype: HTMLPNavigationTitleElement;
         new (): HTMLPNavigationTitleElement;
     };
+    interface HTMLPPageSizeSelectElementEventMap {
+        "sizeChange": number;
+    }
     interface HTMLPPageSizeSelectElement extends Components.PPageSizeSelect, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLPPageSizeSelectElementEventMap>(type: K, listener: (this: HTMLPPageSizeSelectElement, ev: PPageSizeSelectCustomEvent<HTMLPPageSizeSelectElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLPPageSizeSelectElementEventMap>(type: K, listener: (this: HTMLPPageSizeSelectElement, ev: PPageSizeSelectCustomEvent<HTMLPPageSizeSelectElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     }
     var HTMLPPageSizeSelectElement: {
         prototype: HTMLPPageSizeSelectElement;
         new (): HTMLPPageSizeSelectElement;
     };
+    interface HTMLPPaginationElementEventMap {
+        "pageChange": number;
+    }
     interface HTMLPPaginationElement extends Components.PPagination, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLPPaginationElementEventMap>(type: K, listener: (this: HTMLPPaginationElement, ev: PPaginationCustomEvent<HTMLPPaginationElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLPPaginationElementEventMap>(type: K, listener: (this: HTMLPPaginationElement, ev: PPaginationCustomEvent<HTMLPPaginationElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     }
     var HTMLPPaginationElement: {
         prototype: HTMLPPaginationElement;
@@ -2087,12 +2503,35 @@ declare global {
         prototype: HTMLPPaginationItemElement;
         new (): HTMLPPaginationItemElement;
     };
+    interface HTMLPPortalElement extends Components.PPortal, HTMLStencilElement {
+    }
+    var HTMLPPortalElement: {
+        prototype: HTMLPPortalElement;
+        new (): HTMLPPortalElement;
+    };
     interface HTMLPProfileElement extends Components.PProfile, HTMLStencilElement {
     }
     var HTMLPProfileElement: {
         prototype: HTMLPProfileElement;
         new (): HTMLPProfileElement;
     };
+    interface HTMLPRadioElementEventMap {
+        "checkedChange": boolean;
+    }
+    interface HTMLPRadioElement extends Components.PRadio, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLPRadioElementEventMap>(type: K, listener: (this: HTMLPRadioElement, ev: PRadioCustomEvent<HTMLPRadioElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLPRadioElementEventMap>(type: K, listener: (this: HTMLPRadioElement, ev: PRadioCustomEvent<HTMLPRadioElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLPRadioElement: {
+        prototype: HTMLPRadioElement;
+        new (): HTMLPRadioElement;
+    };
     interface HTMLPSegmentContainerElement extends Components.PSegmentContainer, HTMLStencilElement {
     }
     var HTMLPSegmentContainerElement: {
@@ -2105,7 +2544,22 @@ declare global {
         prototype: HTMLPSegmentItemElement;
         new (): HTMLPSegmentItemElement;
     };
+    interface HTMLPSelectElementEventMap {
+        "queryChange": string;
+        "valueChange": any;
+        "selectAllChange": any;
+        "dropdownShown": any;
+        "add": any;
+    }
     interface HTMLPSelectElement extends Components.PSelect, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLPSelectElementEventMap>(type: K, listener: (this: HTMLPSelectElement, ev: PSelectCustomEvent<HTMLPSelectElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLPSelectElementEventMap>(type: K, listener: (this: HTMLPSelectElement, ev: PSelectCustomEvent<HTMLPSelectElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     }
     var HTMLPSelectElement: {
         prototype: HTMLPSelectElement;
@@ -2153,7 +2607,30 @@ declare global {
         prototype: HTMLPTabItemElement;
         new (): HTMLPTabItemElement;
     };
+    interface HTMLPTableElementEventMap {
+        "selectedRowsChange": any;
+        "rowClick": RowClickEvent;
+        "rowSelected": any;
+        "rowDeselected": any;
+        "hasRendered": number;
+        "quickFilter": QuickFilter;
+        "queryChange": string;
+        "filter": null;
+        "action": null;
+        "pageChange": number;
+        "pageSizeChange": number;
+        "export": number;
+        "emptyStateActionClick": null;
+    }
     interface HTMLPTableElement extends Components.PTable, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLPTableElementEventMap>(type: K, listener: (this: HTMLPTableElement, ev: PTableCustomEvent<HTMLPTableElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLPTableElementEventMap>(type: K, listener: (this: HTMLPTableElement, ev: PTableCustomEvent<HTMLPTableElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     }
     var HTMLPTableElement: {
         prototype: HTMLPTableElement;
@@ -2165,7 +2642,18 @@ declare global {
         prototype: HTMLPTableCellElement;
         new (): HTMLPTableCellElement;
     };
+    interface HTMLPTableColumnElementEventMap {
+        "tableDefinitionChanged": boolean;
+    }
     interface HTMLPTableColumnElement extends Components.PTableColumn, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLPTableColumnElementEventMap>(type: K, listener: (this: HTMLPTableColumnElement, ev: PTableColumnCustomEvent<HTMLPTableColumnElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLPTableColumnElementEventMap>(type: K, listener: (this: HTMLPTableColumnElement, ev: PTableColumnCustomEvent<HTMLPTableColumnElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     }
     var HTMLPTableColumnElement: {
         prototype: HTMLPTableColumnElement;
@@ -2177,13 +2665,40 @@ declare global {
         prototype: HTMLPTableContainerElement;
         new (): HTMLPTableContainerElement;
     };
+    interface HTMLPTableFooterElementEventMap {
+        "pageChange": number;
+        "pageSizeChange": number;
+        "export": number;
+    }
     interface HTMLPTableFooterElement extends Components.PTableFooter, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLPTableFooterElementEventMap>(type: K, listener: (this: HTMLPTableFooterElement, ev: PTableFooterCustomEvent<HTMLPTableFooterElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLPTableFooterElementEventMap>(type: K, listener: (this: HTMLPTableFooterElement, ev: PTableFooterCustomEvent<HTMLPTableFooterElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     }
     var HTMLPTableFooterElement: {
         prototype: HTMLPTableFooterElement;
         new (): HTMLPTableFooterElement;
     };
+    interface HTMLPTableHeaderElementEventMap {
+        "quickFilter": QuickFilter;
+        "queryChange": string;
+        "filter": null;
+        "action": null;
+    }
     interface HTMLPTableHeaderElement extends Components.PTableHeader, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLPTableHeaderElementEventMap>(type: K, listener: (this: HTMLPTableHeaderElement, ev: PTableHeaderCustomEvent<HTMLPTableHeaderElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLPTableHeaderElementEventMap>(type: K, listener: (this: HTMLPTableHeaderElement, ev: PTableHeaderCustomEvent<HTMLPTableHeaderElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     }
     var HTMLPTableHeaderElement: {
         prototype: HTMLPTableHeaderElement;
@@ -2201,7 +2716,18 @@ declare global {
         prototype: HTMLPTableRowActionElement;
         new (): HTMLPTableRowActionElement;
     };
+    interface HTMLPToastElementEventMap {
+        "action": MouseEvent;
+    }
     interface HTMLPToastElement extends Components.PToast, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLPToastElementEventMap>(type: K, listener: (this: HTMLPToastElement, ev: PToastCustomEvent<HTMLPToastElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLPToastElementEventMap>(type: K, listener: (this: HTMLPToastElement, ev: PToastCustomEvent<HTMLPToastElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     }
     var HTMLPToastElement: {
         prototype: HTMLPToastElement;
@@ -2213,7 +2739,36 @@ declare global {
         prototype: HTMLPToastContainerElement;
         new (): HTMLPToastContainerElement;
     };
+    interface HTMLPToggleElementEventMap {
+        "checkedChange": boolean;
+        "indeterminateChange": boolean;
+    }
+    interface HTMLPToggleElement extends Components.PToggle, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLPToggleElementEventMap>(type: K, listener: (this: HTMLPToggleElement, ev: PToggleCustomEvent<HTMLPToggleElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLPToggleElementEventMap>(type: K, listener: (this: HTMLPToggleElement, ev: PToggleCustomEvent<HTMLPToggleElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLPToggleElement: {
+        prototype: HTMLPToggleElement;
+        new (): HTMLPToggleElement;
+    };
+    interface HTMLPTooltipElementEventMap {
+        "isOpen": boolean;
+    }
     interface HTMLPTooltipElement extends Components.PTooltip, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLPTooltipElementEventMap>(type: K, listener: (this: HTMLPTooltipElement, ev: PTooltipCustomEvent<HTMLPTooltipElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLPTooltipElementEventMap>(type: K, listener: (this: HTMLPTooltipElement, ev: PTooltipCustomEvent<HTMLPTooltipElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     }
     var HTMLPTooltipElement: {
         prototype: HTMLPTooltipElement;
@@ -2232,6 +2787,7 @@ declare global {
         "p-card-body": HTMLPCardBodyElement;
         "p-card-container": HTMLPCardContainerElement;
         "p-card-header": HTMLPCardHeaderElement;
+        "p-checkbox": HTMLPCheckboxElement;
         "p-content-slider": HTMLPContentSliderElement;
         "p-counter": HTMLPCounterElement;
         "p-cropper": HTMLPCropperElement;
@@ -2244,6 +2800,8 @@ declare global {
         "p-dropdown": HTMLPDropdownElement;
         "p-dropdown-menu-container": HTMLPDropdownMenuContainerElement;
         "p-dropdown-menu-item": HTMLPDropdownMenuItemElement;
+        "p-field": HTMLPFieldElement;
+        "p-field-container": HTMLPFieldContainerElement;
         "p-floating-menu-container": HTMLPFloatingMenuContainerElement;
         "p-floating-menu-item": HTMLPFloatingMenuItemElement;
         "p-helper": HTMLPHelperElement;
@@ -2253,7 +2811,6 @@ declare global {
         "p-illustration": HTMLPIllustrationElement;
         "p-info-panel": HTMLPInfoPanelElement;
         "p-input-error": HTMLPInputErrorElement;
-        "p-input-group": HTMLPInputGroupElement;
         "p-label": HTMLPLabelElement;
         "p-layout": HTMLPLayoutElement;
         "p-loader": HTMLPLoaderElement;
@@ -2264,11 +2821,14 @@ declare global {
         "p-modal-header": HTMLPModalHeaderElement;
         "p-navbar": HTMLPNavbarElement;
         "p-navigation-item": HTMLPNavigationItemElement;
+        "p-navigation-section": HTMLPNavigationSectionElement;
         "p-navigation-title": HTMLPNavigationTitleElement;
         "p-page-size-select": HTMLPPageSizeSelectElement;
         "p-pagination": HTMLPPaginationElement;
         "p-pagination-item": HTMLPPaginationItemElement;
+        "p-portal": HTMLPPortalElement;
         "p-profile": HTMLPProfileElement;
+        "p-radio": HTMLPRadioElement;
         "p-segment-container": HTMLPSegmentContainerElement;
         "p-segment-item": HTMLPSegmentItemElement;
         "p-select": HTMLPSelectElement;
@@ -2289,6 +2849,7 @@ declare global {
         "p-table-row-action": HTMLPTableRowActionElement;
         "p-toast": HTMLPToastElement;
         "p-toast-container": HTMLPToastContainerElement;
+        "p-toggle": HTMLPToggleElement;
         "p-tooltip": HTMLPTooltipElement;
     }
 }
@@ -2401,6 +2962,10 @@ declare namespace LocalJSX {
     interface PBadge {
     }
     interface PButton {
+        /**
+          * Wether to force an active state
+         */
+        "active"?: boolean;
         /**
           * The type of the button
          */
@@ -2417,6 +2982,10 @@ declare namespace LocalJSX {
           * Chevron position
          */
         "chevronPosition"?: 'start' | 'end';
+        /**
+          * The class of the container passed by parent
+         */
+        "class"?: string;
         /**
           * Wether the button is disabled
          */
@@ -2476,7 +3045,11 @@ declare namespace LocalJSX {
         /**
           * The variant of the button
          */
-        "variant"?: 'primary' | 'secondary' | 'transparent' | 'text';
+        "variant"?: | 'primary'
+		| 'secondary'
+		| 'transparent'
+		| 'text'
+		| 'dropdown';
     }
     interface PButtonGroup {
         /**
@@ -2548,6 +3121,44 @@ declare namespace LocalJSX {
          */
         "header"?: string;
     }
+    interface PCheckbox {
+        /**
+          * Wether the checkbox is checked
+         */
+        "checked"?: boolean;
+        /**
+          * Wether the checkbox is disabled
+         */
+        "disabled"?: boolean;
+        /**
+          * The id of the checkbox button
+         */
+        "id"?: string;
+        /**
+          * Wether the checkbox is in indeterminate state
+         */
+        "indeterminate"?: boolean;
+        /**
+          * The name of the checkbox button
+         */
+        "name"?: string;
+        /**
+          * Event whenever the checked changes
+         */
+        "onCheckedChange"?: (event: PCheckboxCustomEvent<boolean>) => void;
+        /**
+          * Event whenever the indeterminate changes
+         */
+        "onIndeterminateChange"?: (event: PCheckboxCustomEvent<boolean>) => void;
+        /**
+          * Wether the checkbox is required
+         */
+        "required"?: boolean;
+        /**
+          * The size of the checkbox
+         */
+        "size"?: 'sm' | 'base';
+    }
     interface PContentSlider {
         /**
           * Wether to disable auto centering the content
@@ -2666,7 +3277,7 @@ declare namespace LocalJSX {
         /**
           * The size of the input group used by the datepicker
          */
-        "size"?: 'small' | 'medium';
+        "size"?: 'sm' | 'base';
         /**
           * The strategy of the dropdown placement
          */
@@ -2807,6 +3418,10 @@ declare namespace LocalJSX {
           * The strategy of the dropdown placement
          */
         "strategy"?: Strategy;
+        /**
+          * Wether to use a portal for the dropdown container
+         */
+        "usePortal"?: boolean;
     }
     interface PDropdownMenuContainer {
         /**
@@ -2835,6 +3450,10 @@ declare namespace LocalJSX {
           * Wether the dropdown menu item is active
          */
         "active"?: boolean;
+        /**
+          * Wether the dropdown menu item has a checkbox
+         */
+        "checkbox"?: boolean;
         /**
           * Wether the item is disabled
          */
@@ -2854,7 +3473,136 @@ declare namespace LocalJSX {
         /**
           * The variant of the item
          */
-        "variant"?: 'default' | 'checkbox';
+        "variant"?: 'default' | 'negative';
+    }
+    interface PField {
+        /**
+          * Wether the input group is disabled
+         */
+        "disabled"?: boolean;
+        /**
+          * The error to display
+         */
+        "error"?: string;
+        /**
+          * The placement of the error popover
+         */
+        "errorPlacement"?: Placement;
+        /**
+          * The method to use when focusing the input
+         */
+        "focusMethod"?: 'focus' | 'click';
+        /**
+          * Wether the input group is focused
+         */
+        "focused"?: boolean;
+        /**
+          * Force show the error tooltip
+         */
+        "forceShowTooltip"?: boolean;
+        /**
+          * The helper of the input group
+         */
+        "helper"?: string;
+        /**
+          * Icon of the input group
+         */
+        "icon"?: IconVariant;
+        /**
+          * Icon flip
+         */
+        "iconFlip"?: IconFlipOptions;
+        /**
+          * Icon position
+         */
+        "iconPosition"?: 'start' | 'end';
+        /**
+          * Icon rotate
+         */
+        "iconRotate"?: RotateOptions;
+        /**
+          * The label of the input group
+         */
+        "label"?: string;
+        /**
+          * Event whenever the input ref changes
+         */
+        "onInputRefChange"?: (event: PFieldCustomEvent<HTMLInputElement | HTMLTextAreaElement>) => void;
+        /**
+          * Event whenever the value changes
+         */
+        "onValueChange"?: (event: PFieldCustomEvent<string>) => void;
+        /**
+          * The template for the optional text
+         */
+        "optionalTemplate"?: templateFunc;
+        /**
+          * The placeholder of the input
+         */
+        "placeholder"?: string;
+        /**
+          * The prefix of the input group
+         */
+        "prefix"?: string;
+        /**
+          * The size of the input group
+         */
+        "properties"?: any | string;
+        /**
+          * Wether the field is required
+         */
+        "required"?: boolean;
+        /**
+          * Wether to select all text on focus
+         */
+        "selectAllOnFocus"?: boolean;
+        /**
+          * The size of the input group
+         */
+        "size"?: 'sm' | 'base';
+        /**
+          * The suffix of the input group
+         */
+        "suffix"?: string;
+        /**
+          * The type of the input group
+         */
+        "type"?: HTMLInputTypeAttribute | 'textarea' | 'slot';
+        /**
+          * The value of the input
+         */
+        "value"?: string;
+    }
+    interface PFieldContainer {
+        /**
+          * The helper of the input group
+         */
+        "error"?: string | HTMLSlotElement;
+        /**
+          * The placement of the error popover
+         */
+        "errorPlacement"?: Placement;
+        /**
+          * Force show the error tooltip
+         */
+        "forceShowTooltip"?: boolean;
+        /**
+          * The helper of the input group
+         */
+        "helper"?: string | HTMLSlotElement;
+        /**
+          * The label of the input group
+         */
+        "label"?: string | HTMLSlotElement;
+        "onFocus"?: (event: PFieldContainerCustomEvent<void>) => void;
+        /**
+          * The template for the optional text
+         */
+        "optionalTemplate"?: templateFunc1;
+        /**
+          * Wether the field is required
+         */
+        "required"?: boolean;
     }
     interface PFloatingMenuContainer {
         /**
@@ -2966,72 +3714,6 @@ declare namespace LocalJSX {
          */
         "forceShowTooltip"?: boolean;
     }
-    interface PInputGroup {
-        /**
-          * Wether the input group is disabled
-         */
-        "disabled"?: boolean;
-        /**
-          * The helper of the input group
-         */
-        "error"?: string;
-        /**
-          * The error variant to use
-         */
-        "errorVariant"?: 'auto' | 'suffix' | 'element';
-        /**
-          * The method to use when focusing the input
-         */
-        "focusMethod"?: 'focus' | 'click';
-        /**
-          * Wether the input group is focused
-         */
-        "focused"?: boolean;
-        /**
-          * Force show the error tooltip
-         */
-        "forceShowTooltip"?: boolean;
-        /**
-          * The helper of the input group
-         */
-        "helper"?: string;
-        /**
-          * Icon of the input group
-         */
-        "icon"?: IconVariant;
-        /**
-          * Icon flip
-         */
-        "iconFlip"?: IconFlipOptions;
-        /**
-          * Icon position
-         */
-        "iconPosition"?: 'start' | 'end';
-        /**
-          * Icon rotate
-         */
-        "iconRotate"?: RotateOptions;
-        /**
-          * The label of the input group
-         */
-        "label"?: string;
-        /**
-          * The prefix of the input group
-         */
-        "prefix"?: string;
-        /**
-          * Wether the field is required
-         */
-        "required"?: boolean;
-        /**
-          * The size of the input group
-         */
-        "size"?: 'small' | 'medium';
-        /**
-          * The suffix of the input group
-         */
-        "suffix"?: string;
-    }
     interface PLabel {
         /**
           * Define the behavior of the label
@@ -3101,11 +3783,7 @@ declare namespace LocalJSX {
         /**
           * Variant of loader
          */
-        "variant"?: | 'inline'
-		| 'full-width'
-		| 'full-screen'
-		| 'modal'
-		| 'ghost';
+        "variant"?: 'inline' | 'full-width' | 'full-screen' | 'modal' | 'ghost';
     }
     interface PModal {
         /**
@@ -3198,10 +3876,6 @@ declare namespace LocalJSX {
         "showClose"?: boolean;
     }
     interface PNavbar {
-        /**
-          * The text to display for the menu button & sidebar title
-         */
-        "menuText"?: string;
     }
     interface PNavigationItem {
         /**
@@ -3212,6 +3886,10 @@ declare namespace LocalJSX {
           * The element to use for the navigation item
          */
         "as"?: string;
+        /**
+          * The class of the container passed by parent
+         */
+        "class"?: string;
         /**
           * Icon of the navigation item
          */
@@ -3224,11 +3902,21 @@ declare namespace LocalJSX {
           * Icon of the navigation item
          */
         "icon": IconVariant;
+        /**
+          * Wether the navigation item is loading
+         */
+        "loading"?: boolean;
         /**
           * The target of the navigation item
          */
         "target"?: string;
     }
+    interface PNavigationSection {
+        /**
+          * The header of the section
+         */
+        "header"?: string;
+    }
     interface PNavigationTitle {
     }
     interface PPageSizeSelect {
@@ -3239,7 +3927,7 @@ declare namespace LocalJSX {
         /**
           * The template for the data view
          */
-        "buttonTemplate"?: templateFunc;
+        "buttonTemplate"?: templateFunc2;
         /**
           * Chevron position
          */
@@ -3251,7 +3939,7 @@ declare namespace LocalJSX {
         /**
           * The template for the data view
          */
-        "itemTemplate"?: templateFunc;
+        "itemTemplate"?: templateFunc2;
         /**
           * Event whenever the size changes
          */
@@ -3293,22 +3981,47 @@ declare namespace LocalJSX {
          */
         "active"?: boolean;
     }
+    interface PPortal {
+    }
     interface PProfile {
         /**
           * The position of the dropdown
          */
         "dropdownLocation"?: 'top-end' | 'bottom-end';
+    }
+    interface PRadio {
         /**
-          * The size of the profile avatar
+          * Wether the radio is checked
          */
-        "size"?: | 'xs'
-		| 'sm'
-		| 'base'
-		| 'lg'
-		| 'xl'
-		| '2xl'
-		| '3xl'
-		| '4xl';
+        "checked"?: boolean;
+        /**
+          * Wether the radio is disabled
+         */
+        "disabled"?: boolean;
+        /**
+          * The id of the radio button
+         */
+        "id"?: string;
+        /**
+          * The name of the radio button
+         */
+        "name"?: string;
+        /**
+          * Event whenever the checked changes
+         */
+        "onCheckedChange"?: (event: PRadioCustomEvent<boolean>) => void;
+        /**
+          * Wether the radio is required
+         */
+        "required"?: boolean;
+        /**
+          * The size of the radio
+         */
+        "size"?: 'sm' | 'base';
+        /**
+          * The value of the radio button
+         */
+        "value"?: string;
     }
     interface PSegmentContainer {
     }
@@ -3502,7 +4215,7 @@ declare namespace LocalJSX {
         /**
           * The size of the input group used by the select
          */
-        "size"?: 'small' | 'medium';
+        "size"?: 'sm' | 'base';
         /**
           * The current value
          */
@@ -3623,11 +4336,11 @@ declare namespace LocalJSX {
           * A key to determine if a row can be selected
          */
         "canSelectKey"?: string;
-        "emptyStateAction"?: templateFunc1;
-        "emptyStateContent"?: templateFunc1;
-        "emptyStateFilteredContent"?: templateFunc1;
-        "emptyStateFilteredHeader"?: templateFunc1;
-        "emptyStateHeader"?: templateFunc1;
+        "emptyStateAction"?: templateFunc3;
+        "emptyStateContent"?: templateFunc3;
+        "emptyStateFilteredContent"?: templateFunc3;
+        "emptyStateFilteredHeader"?: templateFunc3;
+        "emptyStateHeader"?: templateFunc3;
         /**
           * Wether to show the action button
          */
@@ -3683,7 +4396,7 @@ declare namespace LocalJSX {
         /**
           * The template for the filter button text
          */
-        "filterButtonTemplate"?: templateFunc1;
+        "filterButtonTemplate"?: templateFunc3;
         /**
           * The template for amount selected item in the floating menu
          */
@@ -3984,7 +4697,7 @@ declare namespace LocalJSX {
         /**
           * The template for the filter button text
          */
-        "filterButtonTemplate"?: templateFunc2;
+        "filterButtonTemplate"?: templateFunc4;
         /**
           * The amount of items that are selected
          */
@@ -4114,6 +4827,44 @@ declare namespace LocalJSX {
          */
         "placement"?: 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end';
     }
+    interface PToggle {
+        /**
+          * Wether the checkbox is checked
+         */
+        "checked"?: boolean;
+        /**
+          * Wether the checkbox is disabled
+         */
+        "disabled"?: boolean;
+        /**
+          * The id of the checkbox button
+         */
+        "id"?: string;
+        /**
+          * Wether the checkbox is in indeterminate state
+         */
+        "indeterminate"?: boolean;
+        /**
+          * The name of the checkbox button
+         */
+        "name"?: string;
+        /**
+          * Event whenever the checked changes
+         */
+        "onCheckedChange"?: (event: PToggleCustomEvent<boolean>) => void;
+        /**
+          * Event whenever the indeterminate changes
+         */
+        "onIndeterminateChange"?: (event: PToggleCustomEvent<boolean>) => void;
+        /**
+          * Wether the checkbox is required
+         */
+        "required"?: boolean;
+        /**
+          * The size of the checkbox
+         */
+        "size"?: 'sm' | 'base';
+    }
     interface PTooltip {
         /**
           * Wether to someone can manually close the popover
@@ -4147,10 +4898,14 @@ declare namespace LocalJSX {
           * The strategy of the popover placement
          */
         "strategy"?: Strategy;
+        /**
+          * Wether to use a portal for the tooltip
+         */
+        "usePortal"?: boolean;
         /**
           * The variant of the popover
          */
-        "variant"?: 'hover' | 'click' | 'error' | 'error-element';
+        "variant"?: 'hover' | 'click' | 'error';
     }
     interface IntrinsicElements {
         "p-accordion": PAccordion;
@@ -4165,6 +4920,7 @@ declare namespace LocalJSX {
         "p-card-body": PCardBody;
         "p-card-container": PCardContainer;
         "p-card-header": PCardHeader;
+        "p-checkbox": PCheckbox;
         "p-content-slider": PContentSlider;
         "p-counter": PCounter;
         "p-cropper": PCropper;
@@ -4177,6 +4933,8 @@ declare namespace LocalJSX {
         "p-dropdown": PDropdown;
         "p-dropdown-menu-container": PDropdownMenuContainer;
         "p-dropdown-menu-item": PDropdownMenuItem;
+        "p-field": PField;
+        "p-field-container": PFieldContainer;
         "p-floating-menu-container": PFloatingMenuContainer;
         "p-floating-menu-item": PFloatingMenuItem;
         "p-helper": PHelper;
@@ -4186,7 +4944,6 @@ declare namespace LocalJSX {
         "p-illustration": PIllustration;
         "p-info-panel": PInfoPanel;
         "p-input-error": PInputError;
-        "p-input-group": PInputGroup;
         "p-label": PLabel;
         "p-layout": PLayout;
         "p-loader": PLoader;
@@ -4197,11 +4954,14 @@ declare namespace LocalJSX {
         "p-modal-header": PModalHeader;
         "p-navbar": PNavbar;
         "p-navigation-item": PNavigationItem;
+        "p-navigation-section": PNavigationSection;
         "p-navigation-title": PNavigationTitle;
         "p-page-size-select": PPageSizeSelect;
         "p-pagination": PPagination;
         "p-pagination-item": PPaginationItem;
+        "p-portal": PPortal;
         "p-profile": PProfile;
+        "p-radio": PRadio;
         "p-segment-container": PSegmentContainer;
         "p-segment-item": PSegmentItem;
         "p-select": PSelect;
@@ -4222,6 +4982,7 @@ declare namespace LocalJSX {
         "p-table-row-action": PTableRowAction;
         "p-toast": PToast;
         "p-toast-container": PToastContainer;
+        "p-toggle": PToggle;
         "p-tooltip": PTooltip;
     }
 }
@@ -4241,6 +5002,7 @@ declare module "@stencil/core" {
             "p-card-body": LocalJSX.PCardBody & JSXBase.HTMLAttributes<HTMLPCardBodyElement>;
             "p-card-container": LocalJSX.PCardContainer & JSXBase.HTMLAttributes<HTMLPCardContainerElement>;
             "p-card-header": LocalJSX.PCardHeader & JSXBase.HTMLAttributes<HTMLPCardHeaderElement>;
+            "p-checkbox": LocalJSX.PCheckbox & JSXBase.HTMLAttributes<HTMLPCheckboxElement>;
             "p-content-slider": LocalJSX.PContentSlider & JSXBase.HTMLAttributes<HTMLPContentSliderElement>;
             "p-counter": LocalJSX.PCounter & JSXBase.HTMLAttributes<HTMLPCounterElement>;
             "p-cropper": LocalJSX.PCropper & JSXBase.HTMLAttributes<HTMLPCropperElement>;
@@ -4253,6 +5015,8 @@ declare module "@stencil/core" {
             "p-dropdown": LocalJSX.PDropdown & JSXBase.HTMLAttributes<HTMLPDropdownElement>;
             "p-dropdown-menu-container": LocalJSX.PDropdownMenuContainer & JSXBase.HTMLAttributes<HTMLPDropdownMenuContainerElement>;
             "p-dropdown-menu-item": LocalJSX.PDropdownMenuItem & JSXBase.HTMLAttributes<HTMLPDropdownMenuItemElement>;
+            "p-field": LocalJSX.PField & JSXBase.HTMLAttributes<HTMLPFieldElement>;
+            "p-field-container": LocalJSX.PFieldContainer & JSXBase.HTMLAttributes<HTMLPFieldContainerElement>;
             "p-floating-menu-container": LocalJSX.PFloatingMenuContainer & JSXBase.HTMLAttributes<HTMLPFloatingMenuContainerElement>;
             "p-floating-menu-item": LocalJSX.PFloatingMenuItem & JSXBase.HTMLAttributes<HTMLPFloatingMenuItemElement>;
             "p-helper": LocalJSX.PHelper & JSXBase.HTMLAttributes<HTMLPHelperElement>;
@@ -4262,7 +5026,6 @@ declare module "@stencil/core" {
             "p-illustration": LocalJSX.PIllustration & JSXBase.HTMLAttributes<HTMLPIllustrationElement>;
             "p-info-panel": LocalJSX.PInfoPanel & JSXBase.HTMLAttributes<HTMLPInfoPanelElement>;
             "p-input-error": LocalJSX.PInputError & JSXBase.HTMLAttributes<HTMLPInputErrorElement>;
-            "p-input-group": LocalJSX.PInputGroup & JSXBase.HTMLAttributes<HTMLPInputGroupElement>;
             "p-label": LocalJSX.PLabel & JSXBase.HTMLAttributes<HTMLPLabelElement>;
             "p-layout": LocalJSX.PLayout & JSXBase.HTMLAttributes<HTMLPLayoutElement>;
             "p-loader": LocalJSX.PLoader & JSXBase.HTMLAttributes<HTMLPLoaderElement>;
@@ -4273,11 +5036,14 @@ declare module "@stencil/core" {
             "p-modal-header": LocalJSX.PModalHeader & JSXBase.HTMLAttributes<HTMLPModalHeaderElement>;
             "p-navbar": LocalJSX.PNavbar & JSXBase.HTMLAttributes<HTMLPNavbarElement>;
             "p-navigation-item": LocalJSX.PNavigationItem & JSXBase.HTMLAttributes<HTMLPNavigationItemElement>;
+            "p-navigation-section": LocalJSX.PNavigationSection & JSXBase.HTMLAttributes<HTMLPNavigationSectionElement>;
             "p-navigation-title": LocalJSX.PNavigationTitle & JSXBase.HTMLAttributes<HTMLPNavigationTitleElement>;
             "p-page-size-select": LocalJSX.PPageSizeSelect & JSXBase.HTMLAttributes<HTMLPPageSizeSelectElement>;
             "p-pagination": LocalJSX.PPagination & JSXBase.HTMLAttributes<HTMLPPaginationElement>;
             "p-pagination-item": LocalJSX.PPaginationItem & JSXBase.HTMLAttributes<HTMLPPaginationItemElement>;
+            "p-portal": LocalJSX.PPortal & JSXBase.HTMLAttributes<HTMLPPortalElement>;
             "p-profile": LocalJSX.PProfile & JSXBase.HTMLAttributes<HTMLPProfileElement>;
+            "p-radio": LocalJSX.PRadio & JSXBase.HTMLAttributes<HTMLPRadioElement>;
             "p-segment-container": LocalJSX.PSegmentContainer & JSXBase.HTMLAttributes<HTMLPSegmentContainerElement>;
             "p-segment-item": LocalJSX.PSegmentItem & JSXBase.HTMLAttributes<HTMLPSegmentItemElement>;
             "p-select": LocalJSX.PSelect & JSXBase.HTMLAttributes<HTMLPSelectElement>;
@@ -4298,6 +5064,7 @@ declare module "@stencil/core" {
             "p-table-row-action": LocalJSX.PTableRowAction & JSXBase.HTMLAttributes<HTMLPTableRowActionElement>;
             "p-toast": LocalJSX.PToast & JSXBase.HTMLAttributes<HTMLPToastElement>;
             "p-toast-container": LocalJSX.PToastContainer & JSXBase.HTMLAttributes<HTMLPToastContainerElement>;
+            "p-toggle": LocalJSX.PToggle & JSXBase.HTMLAttributes<HTMLPToggleElement>;
             "p-tooltip": LocalJSX.PTooltip & JSXBase.HTMLAttributes<HTMLPTooltipElement>;
         }
     }