@paperless/core 0.1.0-alpha.99 → 1.3.0

package/dist/types/components.d.ts

@@ -6,11 +6,33 @@
  */
 import { HTMLStencilElement, JSXBase } from "./stencil-public-runtime";
 import { IconFlipOptions, IconVariant } from "./components/atoms/icon/icon.component";
-import { RotateOptions, TextSizeOptions } from "./utils/types";
-import { Placement, PositioningStrategy } from "@popperjs/core";
+import { RotateOptions, TextSizeOptions } from "./types/tailwind";
+import { Placement, Strategy } from "@floating-ui/dom";
 import { IconFlipOptions as IconFlipOptions1, IconVariant as IconVariant1 } from "./components/atoms/icon/icon.component";
 import { IllustrationVariant } from "./components/atoms/illustration/illustration.component";
+import { RotateOptions as RotateOptions1, TableDefinitionData, TableDefinitionTemplateFunc } from "./types";
 import { Observable } from "rxjs";
+import { templateFunc } from "./components/molecules/page-size-select/page-size-select.component";
+import { QuickFilter, RowClickEvent, TableColumnSizes } from "./types/table";
+import { templateFunc as templateFunc1 } from "./components/organisms/table/table.component";
+import { IconVariant as IconVariant2 } 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";
+export { IconFlipOptions, IconVariant } from "./components/atoms/icon/icon.component";
+export { RotateOptions, TextSizeOptions } from "./types/tailwind";
+export { Placement, Strategy } from "@floating-ui/dom";
+export { IconFlipOptions as IconFlipOptions1, IconVariant as IconVariant1 } from "./components/atoms/icon/icon.component";
+export { IllustrationVariant } from "./components/atoms/illustration/illustration.component";
+export { RotateOptions as RotateOptions1, TableDefinitionData, TableDefinitionTemplateFunc } from "./types";
+export { Observable } from "rxjs";
+export { templateFunc } from "./components/molecules/page-size-select/page-size-select.component";
+export { QuickFilter, RowClickEvent, TableColumnSizes } from "./types/table";
+export { templateFunc as templateFunc1 } from "./components/organisms/table/table.component";
+export { IconVariant as IconVariant2 } 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 namespace Components {
     interface PAccordion {
         /**
@@ -30,6 +52,24 @@ export namespace Components {
          */
         "openable": boolean;
     }
+    interface PAttachment {
+        /**
+          * Wether the attachment is downloading
+         */
+        "downloading": boolean;
+        /**
+          * The error to show
+         */
+        "error": string;
+        /**
+          * Wether the attachment is uploading/loading
+         */
+        "loading": boolean;
+        /**
+          * The variant of the button
+         */
+        "mode": 'read' | 'write';
+    }
     interface PAvatar {
         /**
           * The default image to show on errors
@@ -38,7 +78,7 @@ export namespace Components {
         /**
           * The size of the avatar
          */
-        "size": 'small' | 'medium' | 'large';
+        "size": 'small' | 'medium' | 'large' | 'xlarge';
         /**
           * The image used for the avatar
          */
@@ -54,11 +94,33 @@ export namespace Components {
          */
         "extra": number;
     }
+    interface PBackdrop {
+        /**
+          * Wether to apply blur on the background of the backdrop
+         */
+        "applyBlur": boolean;
+        /**
+          * Wether the backdrop is closing
+         */
+        "closing": boolean;
+        /**
+          * Wether we should scroll lock the body
+         */
+        "scrollLock": boolean;
+        /**
+          * The variant of the backdrop
+         */
+        "variant": 'modal' | 'drawer';
+    }
     interface PButton {
         /**
           * Wether to show a chevron or not
          */
         "chevron": boolean | 'up' | 'down';
+        /**
+          * Chevron position
+         */
+        "chevronPosition": 'start' | 'end';
         /**
           * Wether the button is disabled
          */
@@ -107,10 +169,40 @@ export namespace Components {
           * The variant of the button
          */
         "variant": 'primary' | 'secondary' | 'text';
+    }
+    interface PCalendar {
+        /**
+          * Wether to disable the weekends
+         */
+        "disableWeekends": boolean;
+        /**
+          * Disabled dates
+         */
+        "disabledDates"?: Array<Date | 'string'> | string;
+        /**
+          * Max date
+         */
+        "maxDate": Date | 'string';
+        /**
+          * Min date
+         */
+        "minDate": Date | 'string';
+        /**
+          * The mode of the datepicker
+         */
+        "mode": 'year' | 'month' | 'day';
+        /**
+          * Wether to automatically preselect today
+         */
+        "preselectToday": boolean;
+        /**
+          * The current value
+         */
+        "value"?: Date | 'string';
         /**
-          * The width of the button
+          * The variant of the button
          */
-        "width": 'auto' | 'full';
+        "variant": 'default' | 'embedded';
     }
     interface PCardBody {
         /**
@@ -139,6 +231,10 @@ export namespace Components {
         "header": string;
     }
     interface PContentSlider {
+        /**
+          * Wether to disable auto centering the content
+         */
+        "disableAutoCenter": boolean;
         /**
           * Wether to disable dragging the content
          */
@@ -162,9 +258,143 @@ export namespace Components {
          */
         "variant": 'info' | 'negative' | 'positive' | 'unbiased';
     }
+    interface PDatepicker {
+        /**
+          * Wether to disable the weekends
+         */
+        "disableWeekends": boolean;
+        /**
+          * Wether the input group is disabled used by the datepicker
+         */
+        "disabled": boolean;
+        /**
+          * Disabled dates
+         */
+        "disabledDates"?: Array<Date | 'string'> | string;
+        /**
+          * The helper of the input group used by the datepicker
+         */
+        "error": string;
+        /**
+          * The display & parse format to use
+         */
+        "format": string;
+        /**
+          * The helper of the input group used by the datepicker
+         */
+        "helper": string;
+        /**
+          * The label of the input group used by the datepicker
+         */
+        "label": string;
+        /**
+          * Max date
+         */
+        "maxDate"?: Date | 'string';
+        /**
+          * Min date
+         */
+        "minDate"?: Date | 'string';
+        /**
+          * The mode of the datepicker
+         */
+        "mode": 'year' | 'month' | 'day';
+        /**
+          * The placeholder of the input
+         */
+        "placeholder": string;
+        /**
+          * The prefix of the input group used by the datepicker
+         */
+        "prefix": string;
+        /**
+          * Wethter to automatically preselect today
+         */
+        "preselectToday": boolean;
+        /**
+          * Wether the field is required
+         */
+        "required": boolean;
+        /**
+          * The size of the input group used by the datepicker
+         */
+        "size": 'small' | 'medium';
+        /**
+          * The current value
+         */
+        "value": Date | null | undefined;
+    }
     interface PDivider {
     }
+    interface PDrawer {
+        /**
+          * Wether to apply blur to the backdrop
+         */
+        "applyBlur": boolean;
+        /**
+          * Wether to hide the drawer when the backdrop is clicked
+         */
+        "backdropClickClose": boolean;
+        /**
+          * Wether the drawer can be closed
+         */
+        "canClose": boolean;
+        /**
+          * The Header of the drawer
+         */
+        "header"?: string;
+        /**
+          * Wether we should scroll lock the body
+         */
+        "scrollLock": boolean;
+        /**
+          * Wether to show the drawer or not
+         */
+        "show": boolean;
+        /**
+          * Wether to show the close on mobile in the header
+         */
+        "showClose": boolean;
+    }
+    interface PDrawerBody {
+        /**
+          * The variant of the modal body
+         */
+        "variant": 'default' | 'table';
+    }
+    interface PDrawerContainer {
+        /**
+          * Wether the container is closing
+         */
+        "closing": boolean;
+    }
+    interface PDrawerHeader {
+        /**
+          * Wether to show the close button on mobile
+         */
+        "showClose": boolean;
+    }
     interface PDropdown {
+        /**
+          * Wether to apply the full width
+         */
+        "applyFullWidth": boolean;
+        /**
+          * Wether to apply the max width
+         */
+        "applyMaxWidth": boolean;
+        /**
+          * Wether to automatically calculate the width of the menu based on the trigger
+         */
+        "calculateWidth": boolean;
+        /**
+          * Chevron direction
+         */
+        "chevronDirection": 'up' | 'down';
+        /**
+          * Chevron position
+         */
+        "chevronPosition": 'start' | 'end';
         /**
           * Wether to automatically close the dropdown menu after clicking inside
          */
@@ -184,15 +414,27 @@ export namespace Components {
         /**
           * The strategy of the popover placement
          */
-        "strategy": PositioningStrategy;
+        "strategy": Strategy;
     }
     interface PDropdownMenuContainer {
+        /**
+          * Wether the container should all available space
+         */
+        "fullWidth": boolean;
+        /**
+          * Wether the container applies it's max width
+         */
+        "maxWidth": boolean;
     }
     interface PDropdownMenuItem {
         /**
           * Wether the dropdown menu item is active
          */
         "active": boolean;
+        /**
+          * Wether to enable the hover state
+         */
+        "enableHover": boolean;
         /**
           * Icon of the navigation item
          */
@@ -208,7 +450,7 @@ export namespace Components {
         /**
           * Wether to flip the icon horizontally or vertically
          */
-        "flip": IconFlipOptions;
+        "flip": IconFlipOptions1;
         /**
           * Wether to rotate the icon x degrees
          */
@@ -220,7 +462,7 @@ export namespace Components {
         /**
           * The icon the be displayed
          */
-        "variant": IconVariant;
+        "variant": IconVariant1;
     }
     interface PIllustration {
         /**
@@ -246,6 +488,16 @@ export namespace Components {
          */
         "variant": 'info' | 'negative' | 'positive' | 'unbiased';
     }
+    interface PInputError {
+        /**
+          * The error to show
+         */
+        "error": string;
+        /**
+          * Wether to force show the tooltip
+         */
+        "forceShowTooltip": boolean;
+    }
     interface PInputGroup {
         /**
           * Wether the input group is disabled
@@ -255,6 +507,10 @@ export namespace Components {
           * The helper of the input group
          */
         "error": string;
+        /**
+          * The method to use when focusing the input
+         */
+        "focusMethod": 'focus' | 'click';
         /**
           * Wether the input group is focused
          */
@@ -264,13 +520,17 @@ export namespace Components {
          */
         "helper": string;
         /**
-          * Icon of the navigation item
+          * Icon of the input group
          */
         "icon": IconVariant;
         /**
           * Icon flip
          */
         "iconFlip": IconFlipOptions;
+        /**
+          * Icon position
+         */
+        "iconPosition": 'start' | 'end';
         /**
           * Icon rotate
          */
@@ -283,16 +543,61 @@ export namespace Components {
           * 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
+         */
+        "behavior": | 'icon'
+        | 'circle'
+        | 'combination'
+        | 'text'
+        | 'icon-only';
+        /**
+          * Icon to show on the label
+         */
+        "icon": IconVariant;
+        /**
+          * Icon flip
+         */
+        "iconFlip": IconFlipOptions;
+        /**
+          * Icon rotate
+         */
+        "iconRotate": RotateOptions1;
+        /**
+          * Wether to keep the content on mobile
+         */
+        "keepMobileContent": boolean;
+        /**
+          * The size of the label
+         */
+        "size": 'small' | 'default';
+        /**
+          * Variant of the label
+         */
+        "variant": | 'positive'
+        | 'unbiased'
+        | 'negative'
+        | 'info';
+    }
     interface PLayout {
         /**
           * Variant of the layout
          */
-        "variant": 'default' | 'login';
+        "variant": 'default' | 'login' | 'office' | 'office-minimal';
     }
     interface PLoader {
         /**
@@ -314,21 +619,37 @@ export namespace Components {
         /**
           * Variant of loader
          */
-        "variant": 'inline' | 'full-width' | 'full-screen' | 'modal';
+        "variant": | 'inline'
+        | 'full-width'
+        | 'full-screen'
+        | 'modal'
+        | 'ghost';
     }
     interface PModal {
+        /**
+          * Wether to apply blur to the backdrop
+         */
+        "applyBlur": boolean;
+        /**
+          * Wether to hide the modal when the backdrop is clicked
+         */
+        "backdropClickClose": boolean;
         /**
           * The Header of the modal
          */
-        "header": string;
+        "header"?: string;
+        /**
+          * Wether we should scroll lock the body
+         */
+        "scrollLock": boolean;
         /**
           * Wether to show the modal or not
          */
         "show": boolean;
         /**
-          * Wether to show the close on mobile in the header
+          * Wether to show the close button in the header
          */
-        "showMobileClose": boolean;
+        "showClose": boolean;
         /**
           * Wether to show the footer on mobile
          */
@@ -342,31 +663,33 @@ export namespace Components {
          */
         "variant": 'default' | 'table';
     }
-    interface PModalBackdrop {
-    }
     interface PModalBody {
+        /**
+          * Wether the modal body should be rounded at the bottom
+         */
+        "rounded": boolean;
         /**
           * The variant of the modal body
          */
         "variant": 'default' | 'table';
     }
     interface PModalContainer {
+        /**
+          * Wether the container is closing
+         */
+        "closing": boolean;
         /**
           * The size of the modal container
          */
         "size": 'sm' | 'md' | 'lg' | 'xl';
     }
     interface PModalFooter {
-        /**
-          * Wether to show the footer on mobile
-         */
-        "hideOnMobile": boolean;
     }
     interface PModalHeader {
         /**
           * Wether to show the close button on mobile
          */
-        "showMobileClose": boolean;
+        "showClose": boolean;
     }
     interface PNavbar {
         /**
@@ -400,7 +723,41 @@ export namespace Components {
          */
         "target": string;
     }
+    interface PPageSizeSelect {
+        /**
+          * The size of the button
+         */
+        "buttonSize": 'small' | 'medium';
+        /**
+          * The template for the data view
+         */
+        "buttonTemplate": templateFunc;
+        /**
+          * Chevron position
+         */
+        "chevronPosition": 'start' | 'end';
+        /**
+          * Wether to hide when there is only 1 page available
+         */
+        "hidden": boolean;
+        /**
+          * The template for the data view
+         */
+        "itemTemplate": templateFunc;
+        /**
+          * The current page
+         */
+        "size": number;
+        /**
+          * The available sizes
+         */
+        "sizeOptions": number[];
+    }
     interface PPagination {
+        /**
+          * Wether to hide when there is only 1 page available
+         */
+        "hideOnSinglePage": boolean;
         /**
           * The current page
          */
@@ -450,290 +807,852 @@ export namespace Components {
          */
         "iconRotate": RotateOptions;
     }
-    interface PSliderIndicator {
+    interface PSelect {
         /**
-          * Wether the slider indicator is active
+          * Wether the input uses async filtering
          */
-        "active": boolean;
-    }
-    interface PStatus {
+        "asyncFilter": boolean;
         /**
-          * Icon to show on the status
+          * Wether to automatically select the first item
          */
-        "icon": IconVariant;
+        "autoSelectFirst": boolean;
         /**
-          * Icon flip
+          * The placeholder of the input when auto completing
          */
-        "iconFlip": IconFlipOptions;
+        "autocompletePlaceholder": string;
         /**
-          * Icon rotate
+          * Wether the input group is disabled used by the select
          */
-        "iconRotate": RotateOptions;
+        "disabled": boolean;
         /**
-          * The variant of the status
+          * The key of the object to display
          */
-        "variant": 'default' | 'positive' | 'unbiased' | 'negative';
-    }
-    interface PStepper {
+        "displayKey": string;
         /**
-          * The currently active step
+          * Wether to enable autocomplete
          */
-        "activeStep": number;
+        "enableAutocomplete": boolean;
         /**
-          * The direction of the stepper
+          * The helper of the input group used by the select
          */
-        "direction": 'horizontal' | 'vertical';
-    }
-    interface PStepperItem {
+        "error": string;
         /**
-          * Wether the step is active
+          * The helper of the input group used by the select
          */
-        "active": boolean;
+        "helper": string;
         /**
-          * The alignment of the step content
+          * Icon of the select box
          */
-        "align": 'start' | 'center' | 'end';
+        "icon": IconVariant;
         /**
-          * The direction of the stepper step
+          * The key to identify an object
          */
-        "direction": 'horizontal' | 'vertical';
+        "identifierKey": string;
         /**
-          * Wether the step is finished
+          * The items to show in the dropdown
          */
-        "finished": boolean;
-    }
-    interface PStepperLine {
+        "items": string | any[];
         /**
-          * Wether the line is active
+          * Wether to keep the query or not
          */
-        "active": boolean;
+        "keepQuery": boolean;
         /**
-          * The direction of the stepper line
+          * The label of the input group used by the select
          */
-        "direction": 'horizontal' | 'vertical';
-    }
-    interface PTabGroup {
-    }
-    interface PTabItem {
+        "label": string;
         /**
-          * Wether the tab item is active
+          * Wether to show loading items
          */
-        "active": boolean;
-    }
-    interface PTag {
+        "loading": boolean;
         /**
-          * Wether to add the circle or not
+          * The maximum amount of items to display
          */
-        "circle": boolean;
+        "maxDisplayedItems": number;
         /**
-          * Variant of the tag
+          * The placeholder of the input
          */
-        "variant": | 'positive'
-        | 'unbiased'
-        | 'negative'
-        | 'info';
-    }
-    interface PTooltip {
+        "placeholder": string;
         /**
-          * Wether to someone can manually close the popover
+          * The prefix of the input group used by the select
          */
-        "canManuallyClose": boolean;
+        "prefix": string;
         /**
-          * The placement of the popover
+          * The current query
          */
-        "placement": Placement;
+        "query": string;
         /**
-          * The content of the popover
+          * The key of the object to display
          */
-        "popover": any;
+        "queryKey"?: string;
         /**
-          * Wether to show the popover
+          * Wether the field is required
          */
-        "show": boolean;
+        "required": boolean;
         /**
-          * The strategy of the popover placement
+          * Wether to show the chevron or not
          */
-        "strategy": PositioningStrategy;
+        "showChevron": boolean;
         /**
-          * The variant of the popover
+          * The size of the input group used by the select
          */
-        "variant": 'hover' | 'click' | 'error';
-    }
-}
-export interface PAccordionCustomEvent<T> extends CustomEvent<T> {
-    detail: T;
-    target: HTMLPAccordionElement;
-}
-export interface PButtonCustomEvent<T> extends CustomEvent<T> {
-    detail: T;
-    target: HTMLPButtonElement;
-}
-export interface PDropdownCustomEvent<T> extends CustomEvent<T> {
-    detail: T;
-    target: HTMLPDropdownElement;
-}
-export interface PModalCustomEvent<T> extends CustomEvent<T> {
-    detail: T;
-    target: HTMLPModalElement;
-}
-export interface PModalHeaderCustomEvent<T> extends CustomEvent<T> {
-    detail: T;
-    target: HTMLPModalHeaderElement;
-}
-export interface PPaginationCustomEvent<T> extends CustomEvent<T> {
-    detail: T;
-    target: HTMLPPaginationElement;
-}
-export interface PTooltipCustomEvent<T> extends CustomEvent<T> {
-    detail: T;
-    target: HTMLPTooltipElement;
-}
-declare global {
-    interface HTMLPAccordionElement extends Components.PAccordion, HTMLStencilElement {
+        "size": 'small' | 'medium';
+        /**
+          * The current value
+         */
+        "value": any;
+        /**
+          * The key of the object to return
+         */
+        "valueKey": string;
     }
-    var HTMLPAccordionElement: {
-        prototype: HTMLPAccordionElement;
-        new (): HTMLPAccordionElement;
-    };
-    interface HTMLPAvatarElement extends Components.PAvatar, HTMLStencilElement {
+    interface PSliderIndicator {
+        /**
+          * Wether the slider indicator is active
+         */
+        "active": boolean;
     }
-    var HTMLPAvatarElement: {
-        prototype: HTMLPAvatarElement;
-        new (): HTMLPAvatarElement;
-    };
-    interface HTMLPAvatarGroupElement extends Components.PAvatarGroup, HTMLStencilElement {
+    interface PStatus {
+        /**
+          * Icon to show on the status
+         */
+        "icon": IconVariant;
+        /**
+          * Icon flip
+         */
+        "iconFlip": IconFlipOptions;
+        /**
+          * Icon rotate
+         */
+        "iconRotate": RotateOptions;
+        /**
+          * The variant of the status
+         */
+        "variant": 'default' | 'positive' | 'unbiased' | 'negative';
     }
-    var HTMLPAvatarGroupElement: {
-        prototype: HTMLPAvatarGroupElement;
-        new (): HTMLPAvatarGroupElement;
-    };
-    interface HTMLPButtonElement extends Components.PButton, HTMLStencilElement {
+    interface PStepper {
+        /**
+          * The currently active step
+         */
+        "activeStep": number;
+        /**
+          * The position of the content in case of vertical direction
+         */
+        "contentPosition": 'start' | 'end';
+        /**
+          * The direction of the stepper
+         */
+        "direction": 'horizontal' | 'vertical';
     }
-    var HTMLPButtonElement: {
-        prototype: HTMLPButtonElement;
-        new (): HTMLPButtonElement;
-    };
-    interface HTMLPCardBodyElement extends Components.PCardBody, HTMLStencilElement {
+    interface PStepperItem {
+        /**
+          * Wether the step is active
+         */
+        "active": boolean;
+        /**
+          * The alignment of the step content
+         */
+        "align": 'start' | 'center' | 'end';
+        /**
+          * The position of the content in case of vertical direction
+         */
+        "contentPosition": 'start' | 'end';
+        /**
+          * The direction of the stepper step
+         */
+        "direction": 'horizontal' | 'vertical';
+        /**
+          * Wether the step is finished
+         */
+        "finished": boolean;
     }
-    var HTMLPCardBodyElement: {
-        prototype: HTMLPCardBodyElement;
-        new (): HTMLPCardBodyElement;
-    };
-    interface HTMLPCardContainerElement extends Components.PCardContainer, HTMLStencilElement {
+    interface PStepperLine {
+        /**
+          * Wether the line is active
+         */
+        "active": boolean;
+        /**
+          * The direction of the stepper line
+         */
+        "direction": 'horizontal' | 'vertical';
     }
-    var HTMLPCardContainerElement: {
-        prototype: HTMLPCardContainerElement;
-        new (): HTMLPCardContainerElement;
-    };
-    interface HTMLPCardHeaderElement extends Components.PCardHeader, HTMLStencilElement {
+    interface PTabGroup {
     }
-    var HTMLPCardHeaderElement: {
-        prototype: HTMLPCardHeaderElement;
-        new (): HTMLPCardHeaderElement;
-    };
-    interface HTMLPContentSliderElement extends Components.PContentSlider, HTMLStencilElement {
+    interface PTabItem {
+        /**
+          * Wether the tab item is active
+         */
+        "active": boolean;
     }
-    var HTMLPContentSliderElement: {
-        prototype: HTMLPContentSliderElement;
-        new (): HTMLPContentSliderElement;
-    };
-    interface HTMLPCounterElement extends Components.PCounter, HTMLStencilElement {
+    interface PTable {
+        /**
+          * Active quick filter identifier
+         */
+        "activeQuickFilterIdentifier": string;
+        /**
+          * The amount of loading rows to show
+         */
+        "amountOfLoadingRows": number;
+        /**
+          * A key to determine if a row can be selected
+         */
+        "canSelectKey": string;
+        /**
+          * The edit button icon
+         */
+        "editButtonIcon": IconVariant2;
+        /**
+          * Wether the edit button is loading
+         */
+        "editButtonLoading": boolean;
+        /**
+          * The template for the edit button text
+         */
+        "editButtonTemplate": buttonTemplateFunc;
+        /**
+          * The edit button text if changed
+         */
+        "editButtonText": string;
+        "emptyStateAction": templateFunc1;
+        "emptyStateContent": templateFunc1;
+        "emptyStateFilteredContent": templateFunc1;
+        "emptyStateFilteredHeader": templateFunc1;
+        "emptyStateHeader": templateFunc1;
+        /**
+          * Wether to show the edit button
+         */
+        "enableEdit": boolean;
+        /**
+          * Wether to enable empty state action
+         */
+        "enableEmptyStateAction": boolean;
+        /**
+          * Wether to enable export
+         */
+        "enableExport": boolean;
+        /**
+          * Wether to show the filter button
+         */
+        "enableFilter": boolean;
+        /**
+          * Wether to show the header
+         */
+        "enableFooter": boolean;
+        /**
+          * Wether to show the header
+         */
+        "enableHeader": boolean;
+        /**
+          * Wether to enable page size select
+         */
+        "enablePageSize": boolean;
+        /**
+          * Wether to enable pagination
+         */
+        "enablePagination": boolean;
+        /**
+          * Wether to enable row clicking
+         */
+        "enableRowClick": boolean;
+        /**
+          * Wether to enable selection
+         */
+        "enableRowSelection": boolean;
+        /**
+          * Wether to show the search input
+         */
+        "enableSearch": boolean;
+        /**
+          * The template for the filter button text
+         */
+        "filterButtonTemplate": templateFunc1;
+        /**
+          * Wether the footer should show loading state
+         */
+        "footerLoading": boolean;
+        /**
+          * Wether the header should show loading state
+         */
+        "headerLoading": boolean;
+        /**
+          * Wether to hide when there is only 1 page available
+         */
+        "hideOnSinglePage": boolean;
+        /**
+          * The items to be fed to the table
+         */
+        "items": string;
+        /**
+          * Wether data is loading
+         */
+        "loading": boolean;
+        /**
+          * The current page
+         */
+        "page": number;
+        /**
+          * The amount of items per page
+         */
+        "pageSize": number;
+        /**
+          * The options for the page size
+         */
+        "pageSizeOptions": number[];
+        /**
+          * The query to show in the search bar
+         */
+        "query": string;
+        /**
+          * Quick filters to show
+         */
+        "quickFilters": QuickFilter[];
+        /**
+          * The amount of filters being selected
+         */
+        "selectedFiltersAmount": number;
+        /**
+          * The current selection of items
+         */
+        "selectedRows": any[];
+        /**
+          * The key to determine if a row is selected
+         */
+        "selectionKey": string;
+        /**
+          * The total amount of items
+         */
+        "total": number;
     }
-    var HTMLPCounterElement: {
-        prototype: HTMLPCounterElement;
-        new (): HTMLPCounterElement;
-    };
-    interface HTMLPDividerElement extends Components.PDivider, HTMLStencilElement {
+    interface PTableCell {
+        /**
+          * The checkbox to show
+         */
+        "checkbox": any;
+        /**
+          * The definition of the table column
+         */
+        "definition"?: TableColumn;
+        /**
+          * The index of the column
+         */
+        "index": number;
+        /**
+          * The item in question
+         */
+        "item": any;
+        /**
+          * The index of the row
+         */
+        "rowIndex": number;
+        /**
+          * The template to show
+         */
+        "template": TableDefinitionTemplateFunc;
+        /**
+          * The value of the column
+         */
+        "value": any;
+        /**
+          * The variant of the column
+         */
+        "variant": 'default' | 'loading' | 'header';
     }
-    var HTMLPDividerElement: {
-        prototype: HTMLPDividerElement;
-        new (): HTMLPDividerElement;
-    };
-    interface HTMLPDropdownElement extends Components.PDropdown, HTMLStencilElement {
+    interface PTableColumn {
+        /**
+          * The alignment of the column
+         */
+        "align": 'start' | 'center' | 'end';
+        /**
+          * Wether the column should have a checkbox
+         */
+        "hasCheckbox": boolean;
+        /**
+          * Wether the column is the last in the row
+         */
+        "isLast": boolean;
+        /**
+          * The name of the column
+         */
+        "name": string;
+        /**
+          * The path of the value of the item you want to display
+         */
+        "path": string;
+        /**
+          * The sizes of the column
+         */
+        "sizes": | 'auto'
+        | 'hidden'
+        | 'full'
+        | number
+        | TableColumnSizes;
+        /**
+          * The type of the column
+         */
+        "type": 'td' | 'th';
+        /**
+          * Wether the column should use the slot
+         */
+        "useSlot": boolean;
     }
-    var HTMLPDropdownElement: {
-        prototype: HTMLPDropdownElement;
-        new (): HTMLPDropdownElement;
-    };
-    interface HTMLPDropdownMenuContainerElement extends Components.PDropdownMenuContainer, HTMLStencilElement {
+    interface PTableContainer {
     }
-    var HTMLPDropdownMenuContainerElement: {
-        prototype: HTMLPDropdownMenuContainerElement;
-        new (): HTMLPDropdownMenuContainerElement;
-    };
-    interface HTMLPDropdownMenuItemElement extends Components.PDropdownMenuItem, HTMLStencilElement {
+    interface PTableFooter {
+        /**
+          * Wether to enable export
+         */
+        "enableExport": boolean;
+        /**
+          * Wether to enable page size select
+         */
+        "enablePageSize": boolean;
+        /**
+          * Wether to enable pagination
+         */
+        "enablePagination": boolean;
+        /**
+          * Wether to hide when there is only 1 page available
+         */
+        "hideOnSinglePage": boolean;
+        /**
+          * Wether we want to show loading state
+         */
+        "loading": boolean;
+        /**
+          * The current page
+         */
+        "page": number;
+        /**
+          * The amount of items per page
+         */
+        "pageSize": number;
+        /**
+          * The options for the page size
+         */
+        "pageSizeOptions": number[];
+        /**
+          * The total amount of items
+         */
+        "total": number;
     }
-    var HTMLPDropdownMenuItemElement: {
-        prototype: HTMLPDropdownMenuItemElement;
-        new (): HTMLPDropdownMenuItemElement;
-    };
-    interface HTMLPHelperElement extends Components.PHelper, HTMLStencilElement {
+    interface PTableHeader {
+        /**
+          * Active quick filter identifier
+         */
+        "activeQuickFilterIdentifier": string;
+        /**
+          * Wether to enable the edit button
+         */
+        "canEdit": boolean;
+        /**
+          * The template for the edit button text
+         */
+        "editButtonTemplate": buttonTemplateFunc1;
+        /**
+          * The edit button icon
+         */
+        "editIcon": IconVariant2;
+        /**
+          * Wether the edit button is loading
+         */
+        "editLoading": boolean;
+        /**
+          * The edit button text if changed
+         */
+        "editText": string;
+        /**
+          * Wether to show the edit button
+         */
+        "enableEdit": boolean;
+        /**
+          * Wether to show the filter button
+         */
+        "enableFilter": boolean;
+        /**
+          * Wether to show the search input
+         */
+        "enableSearch": boolean;
+        /**
+          * The template for the filter button text
+         */
+        "filterButtonTemplate": templateFunc2;
+        /**
+          * The amount of items that are selected
+         */
+        "itemsSelectedAmount": number;
+        /**
+          * Wether we want to show loading state
+         */
+        "loading": boolean;
+        /**
+          * The query to show in the search bar
+         */
+        "query": string;
+        /**
+          * Quick filters to show
+         */
+        "quickFilters": QuickFilter[];
+        /**
+          * The amount of filters being selected
+         */
+        "selectedFiltersAmount": number;
     }
-    var HTMLPHelperElement: {
-        prototype: HTMLPHelperElement;
-        new (): HTMLPHelperElement;
-    };
-    interface HTMLPIconElement extends Components.PIcon, HTMLStencilElement {
+    interface PTableRow {
+        /**
+          * Enable hover
+         */
+        "enableHover": boolean;
+        /**
+          * Variant of the header
+         */
+        "variant": 'default' | 'header';
     }
-    var HTMLPIconElement: {
-        prototype: HTMLPIconElement;
-        new (): HTMLPIconElement;
-    };
-    interface HTMLPIllustrationElement extends Components.PIllustration, HTMLStencilElement {
+    interface PToast {
+        /**
+          * Icon to show on the button
+         */
+        "actionIcon": IconVariant;
+        /**
+          * Icon flip
+         */
+        "actionIconFlip": IconFlipOptions;
+        /**
+          * Icon rotate
+         */
+        "actionIconRotate": RotateOptions1;
+        /**
+          * The content of the toast
+         */
+        "content"?: string;
+        /**
+          * Wether to enable the close button
+         */
+        "enableAction": boolean;
+        /**
+          * The header of the toast
+         */
+        "header"?: string;
+        /**
+          * The variant of the toast
+         */
+        "variant": 'positive' | 'unbiased' | 'negative';
     }
-    var HTMLPIllustrationElement: {
-        prototype: HTMLPIllustrationElement;
-        new (): HTMLPIllustrationElement;
-    };
-    interface HTMLPInfoPanelElement extends Components.PInfoPanel, HTMLStencilElement {
+    interface PToastContainer {
+        /**
+          * The placement of the container
+         */
+        "placement": 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end';
     }
-    var HTMLPInfoPanelElement: {
-        prototype: HTMLPInfoPanelElement;
-        new (): HTMLPInfoPanelElement;
-    };
-    interface HTMLPInputGroupElement extends Components.PInputGroup, HTMLStencilElement {
+    interface PTooltip {
+        /**
+          * Wether to someone can manually close the popover
+         */
+        "canManuallyClose": boolean;
+        /**
+          * Wether the tooltip can be shown by user input
+         */
+        "enableUserInput": boolean;
+        /**
+          * The placement of the popover
+         */
+        "placement": Placement;
+        /**
+          * The content of the popover
+         */
+        "popover": any;
+        /**
+          * Wether to show the popover
+         */
+        "show": boolean;
+        /**
+          * The strategy of the popover placement
+         */
+        "strategy": Strategy;
+        /**
+          * The variant of the popover
+         */
+        "variant": 'hover' | 'click' | 'error' | 'error-element';
     }
-    var HTMLPInputGroupElement: {
-        prototype: HTMLPInputGroupElement;
-        new (): HTMLPInputGroupElement;
+}
+export interface PAccordionCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLPAccordionElement;
+}
+export interface PAttachmentCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLPAttachmentElement;
+}
+export interface PBackdropCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLPBackdropElement;
+}
+export interface PButtonCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLPButtonElement;
+}
+export interface PCalendarCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLPCalendarElement;
+}
+export interface PDatepickerCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLPDatepickerElement;
+}
+export interface PDrawerCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLPDrawerElement;
+}
+export interface PDrawerHeaderCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLPDrawerHeaderElement;
+}
+export interface PDropdownCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLPDropdownElement;
+}
+export interface PModalCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLPModalElement;
+}
+export interface PModalHeaderCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLPModalHeaderElement;
+}
+export interface PPageSizeSelectCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLPPageSizeSelectElement;
+}
+export interface PPaginationCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLPPaginationElement;
+}
+export interface PSelectCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLPSelectElement;
+}
+export interface PTableCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLPTableElement;
+}
+export interface PTableColumnCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLPTableColumnElement;
+}
+export interface PTableFooterCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLPTableFooterElement;
+}
+export interface PTableHeaderCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLPTableHeaderElement;
+}
+export interface PToastCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLPToastElement;
+}
+export interface PTooltipCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLPTooltipElement;
+}
+declare global {
+    interface HTMLPAccordionElement extends Components.PAccordion, HTMLStencilElement {
+    }
+    var HTMLPAccordionElement: {
+        prototype: HTMLPAccordionElement;
+        new (): HTMLPAccordionElement;
     };
-    interface HTMLPLayoutElement extends Components.PLayout, HTMLStencilElement {
+    interface HTMLPAttachmentElement extends Components.PAttachment, HTMLStencilElement {
     }
-    var HTMLPLayoutElement: {
-        prototype: HTMLPLayoutElement;
-        new (): HTMLPLayoutElement;
+    var HTMLPAttachmentElement: {
+        prototype: HTMLPAttachmentElement;
+        new (): HTMLPAttachmentElement;
     };
-    interface HTMLPLoaderElement extends Components.PLoader, HTMLStencilElement {
+    interface HTMLPAvatarElement extends Components.PAvatar, HTMLStencilElement {
     }
-    var HTMLPLoaderElement: {
-        prototype: HTMLPLoaderElement;
-        new (): HTMLPLoaderElement;
+    var HTMLPAvatarElement: {
+        prototype: HTMLPAvatarElement;
+        new (): HTMLPAvatarElement;
     };
-    interface HTMLPModalElement extends Components.PModal, HTMLStencilElement {
+    interface HTMLPAvatarGroupElement extends Components.PAvatarGroup, HTMLStencilElement {
     }
-    var HTMLPModalElement: {
-        prototype: HTMLPModalElement;
-        new (): HTMLPModalElement;
+    var HTMLPAvatarGroupElement: {
+        prototype: HTMLPAvatarGroupElement;
+        new (): HTMLPAvatarGroupElement;
     };
-    interface HTMLPModalBackdropElement extends Components.PModalBackdrop, HTMLStencilElement {
+    interface HTMLPBackdropElement extends Components.PBackdrop, HTMLStencilElement {
     }
-    var HTMLPModalBackdropElement: {
-        prototype: HTMLPModalBackdropElement;
-        new (): HTMLPModalBackdropElement;
+    var HTMLPBackdropElement: {
+        prototype: HTMLPBackdropElement;
+        new (): HTMLPBackdropElement;
     };
-    interface HTMLPModalBodyElement extends Components.PModalBody, HTMLStencilElement {
+    interface HTMLPButtonElement extends Components.PButton, HTMLStencilElement {
     }
-    var HTMLPModalBodyElement: {
-        prototype: HTMLPModalBodyElement;
-        new (): HTMLPModalBodyElement;
+    var HTMLPButtonElement: {
+        prototype: HTMLPButtonElement;
+        new (): HTMLPButtonElement;
     };
-    interface HTMLPModalContainerElement extends Components.PModalContainer, HTMLStencilElement {
+    interface HTMLPCalendarElement extends Components.PCalendar, HTMLStencilElement {
     }
-    var HTMLPModalContainerElement: {
-        prototype: HTMLPModalContainerElement;
-        new (): HTMLPModalContainerElement;
+    var HTMLPCalendarElement: {
+        prototype: HTMLPCalendarElement;
+        new (): HTMLPCalendarElement;
     };
-    interface HTMLPModalFooterElement extends Components.PModalFooter, HTMLStencilElement {
+    interface HTMLPCardBodyElement extends Components.PCardBody, HTMLStencilElement {
+    }
+    var HTMLPCardBodyElement: {
+        prototype: HTMLPCardBodyElement;
+        new (): HTMLPCardBodyElement;
+    };
+    interface HTMLPCardContainerElement extends Components.PCardContainer, HTMLStencilElement {
+    }
+    var HTMLPCardContainerElement: {
+        prototype: HTMLPCardContainerElement;
+        new (): HTMLPCardContainerElement;
+    };
+    interface HTMLPCardHeaderElement extends Components.PCardHeader, HTMLStencilElement {
+    }
+    var HTMLPCardHeaderElement: {
+        prototype: HTMLPCardHeaderElement;
+        new (): HTMLPCardHeaderElement;
+    };
+    interface HTMLPContentSliderElement extends Components.PContentSlider, HTMLStencilElement {
+    }
+    var HTMLPContentSliderElement: {
+        prototype: HTMLPContentSliderElement;
+        new (): HTMLPContentSliderElement;
+    };
+    interface HTMLPCounterElement extends Components.PCounter, HTMLStencilElement {
+    }
+    var HTMLPCounterElement: {
+        prototype: HTMLPCounterElement;
+        new (): HTMLPCounterElement;
+    };
+    interface HTMLPDatepickerElement extends Components.PDatepicker, HTMLStencilElement {
+    }
+    var HTMLPDatepickerElement: {
+        prototype: HTMLPDatepickerElement;
+        new (): HTMLPDatepickerElement;
+    };
+    interface HTMLPDividerElement extends Components.PDivider, HTMLStencilElement {
+    }
+    var HTMLPDividerElement: {
+        prototype: HTMLPDividerElement;
+        new (): HTMLPDividerElement;
+    };
+    interface HTMLPDrawerElement extends Components.PDrawer, HTMLStencilElement {
+    }
+    var HTMLPDrawerElement: {
+        prototype: HTMLPDrawerElement;
+        new (): HTMLPDrawerElement;
+    };
+    interface HTMLPDrawerBodyElement extends Components.PDrawerBody, HTMLStencilElement {
+    }
+    var HTMLPDrawerBodyElement: {
+        prototype: HTMLPDrawerBodyElement;
+        new (): HTMLPDrawerBodyElement;
+    };
+    interface HTMLPDrawerContainerElement extends Components.PDrawerContainer, HTMLStencilElement {
+    }
+    var HTMLPDrawerContainerElement: {
+        prototype: HTMLPDrawerContainerElement;
+        new (): HTMLPDrawerContainerElement;
+    };
+    interface HTMLPDrawerHeaderElement extends Components.PDrawerHeader, HTMLStencilElement {
+    }
+    var HTMLPDrawerHeaderElement: {
+        prototype: HTMLPDrawerHeaderElement;
+        new (): HTMLPDrawerHeaderElement;
+    };
+    interface HTMLPDropdownElement extends Components.PDropdown, HTMLStencilElement {
+    }
+    var HTMLPDropdownElement: {
+        prototype: HTMLPDropdownElement;
+        new (): HTMLPDropdownElement;
+    };
+    interface HTMLPDropdownMenuContainerElement extends Components.PDropdownMenuContainer, HTMLStencilElement {
+    }
+    var HTMLPDropdownMenuContainerElement: {
+        prototype: HTMLPDropdownMenuContainerElement;
+        new (): HTMLPDropdownMenuContainerElement;
+    };
+    interface HTMLPDropdownMenuItemElement extends Components.PDropdownMenuItem, HTMLStencilElement {
+    }
+    var HTMLPDropdownMenuItemElement: {
+        prototype: HTMLPDropdownMenuItemElement;
+        new (): HTMLPDropdownMenuItemElement;
+    };
+    interface HTMLPHelperElement extends Components.PHelper, HTMLStencilElement {
+    }
+    var HTMLPHelperElement: {
+        prototype: HTMLPHelperElement;
+        new (): HTMLPHelperElement;
+    };
+    interface HTMLPIconElement extends Components.PIcon, HTMLStencilElement {
+    }
+    var HTMLPIconElement: {
+        prototype: HTMLPIconElement;
+        new (): HTMLPIconElement;
+    };
+    interface HTMLPIllustrationElement extends Components.PIllustration, HTMLStencilElement {
+    }
+    var HTMLPIllustrationElement: {
+        prototype: HTMLPIllustrationElement;
+        new (): HTMLPIllustrationElement;
+    };
+    interface HTMLPInfoPanelElement extends Components.PInfoPanel, HTMLStencilElement {
+    }
+    var HTMLPInfoPanelElement: {
+        prototype: HTMLPInfoPanelElement;
+        new (): HTMLPInfoPanelElement;
+    };
+    interface HTMLPInputErrorElement extends Components.PInputError, HTMLStencilElement {
+    }
+    var HTMLPInputErrorElement: {
+        prototype: HTMLPInputErrorElement;
+        new (): HTMLPInputErrorElement;
+    };
+    interface HTMLPInputGroupElement extends Components.PInputGroup, HTMLStencilElement {
+    }
+    var HTMLPInputGroupElement: {
+        prototype: HTMLPInputGroupElement;
+        new (): HTMLPInputGroupElement;
+    };
+    interface HTMLPLabelElement extends Components.PLabel, HTMLStencilElement {
+    }
+    var HTMLPLabelElement: {
+        prototype: HTMLPLabelElement;
+        new (): HTMLPLabelElement;
+    };
+    interface HTMLPLayoutElement extends Components.PLayout, HTMLStencilElement {
+    }
+    var HTMLPLayoutElement: {
+        prototype: HTMLPLayoutElement;
+        new (): HTMLPLayoutElement;
+    };
+    interface HTMLPLoaderElement extends Components.PLoader, HTMLStencilElement {
+    }
+    var HTMLPLoaderElement: {
+        prototype: HTMLPLoaderElement;
+        new (): HTMLPLoaderElement;
+    };
+    interface HTMLPModalElement extends Components.PModal, HTMLStencilElement {
+    }
+    var HTMLPModalElement: {
+        prototype: HTMLPModalElement;
+        new (): HTMLPModalElement;
+    };
+    interface HTMLPModalBodyElement extends Components.PModalBody, HTMLStencilElement {
+    }
+    var HTMLPModalBodyElement: {
+        prototype: HTMLPModalBodyElement;
+        new (): HTMLPModalBodyElement;
+    };
+    interface HTMLPModalContainerElement extends Components.PModalContainer, HTMLStencilElement {
+    }
+    var HTMLPModalContainerElement: {
+        prototype: HTMLPModalContainerElement;
+        new (): HTMLPModalContainerElement;
+    };
+    interface HTMLPModalFooterElement extends Components.PModalFooter, HTMLStencilElement {
     }
     var HTMLPModalFooterElement: {
         prototype: HTMLPModalFooterElement;
@@ -757,6 +1676,12 @@ declare global {
         prototype: HTMLPNavigationItemElement;
         new (): HTMLPNavigationItemElement;
     };
+    interface HTMLPPageSizeSelectElement extends Components.PPageSizeSelect, HTMLStencilElement {
+    }
+    var HTMLPPageSizeSelectElement: {
+        prototype: HTMLPPageSizeSelectElement;
+        new (): HTMLPPageSizeSelectElement;
+    };
     interface HTMLPPaginationElement extends Components.PPagination, HTMLStencilElement {
     }
     var HTMLPPaginationElement: {
@@ -787,6 +1712,12 @@ declare global {
         prototype: HTMLPSegmentItemElement;
         new (): HTMLPSegmentItemElement;
     };
+    interface HTMLPSelectElement extends Components.PSelect, HTMLStencilElement {
+    }
+    var HTMLPSelectElement: {
+        prototype: HTMLPSelectElement;
+        new (): HTMLPSelectElement;
+    };
     interface HTMLPSliderIndicatorElement extends Components.PSliderIndicator, HTMLStencilElement {
     }
     var HTMLPSliderIndicatorElement: {
@@ -829,11 +1760,59 @@ declare global {
         prototype: HTMLPTabItemElement;
         new (): HTMLPTabItemElement;
     };
-    interface HTMLPTagElement extends Components.PTag, HTMLStencilElement {
+    interface HTMLPTableElement extends Components.PTable, HTMLStencilElement {
+    }
+    var HTMLPTableElement: {
+        prototype: HTMLPTableElement;
+        new (): HTMLPTableElement;
+    };
+    interface HTMLPTableCellElement extends Components.PTableCell, HTMLStencilElement {
+    }
+    var HTMLPTableCellElement: {
+        prototype: HTMLPTableCellElement;
+        new (): HTMLPTableCellElement;
+    };
+    interface HTMLPTableColumnElement extends Components.PTableColumn, HTMLStencilElement {
+    }
+    var HTMLPTableColumnElement: {
+        prototype: HTMLPTableColumnElement;
+        new (): HTMLPTableColumnElement;
+    };
+    interface HTMLPTableContainerElement extends Components.PTableContainer, HTMLStencilElement {
+    }
+    var HTMLPTableContainerElement: {
+        prototype: HTMLPTableContainerElement;
+        new (): HTMLPTableContainerElement;
+    };
+    interface HTMLPTableFooterElement extends Components.PTableFooter, HTMLStencilElement {
+    }
+    var HTMLPTableFooterElement: {
+        prototype: HTMLPTableFooterElement;
+        new (): HTMLPTableFooterElement;
+    };
+    interface HTMLPTableHeaderElement extends Components.PTableHeader, HTMLStencilElement {
+    }
+    var HTMLPTableHeaderElement: {
+        prototype: HTMLPTableHeaderElement;
+        new (): HTMLPTableHeaderElement;
+    };
+    interface HTMLPTableRowElement extends Components.PTableRow, HTMLStencilElement {
     }
-    var HTMLPTagElement: {
-        prototype: HTMLPTagElement;
-        new (): HTMLPTagElement;
+    var HTMLPTableRowElement: {
+        prototype: HTMLPTableRowElement;
+        new (): HTMLPTableRowElement;
+    };
+    interface HTMLPToastElement extends Components.PToast, HTMLStencilElement {
+    }
+    var HTMLPToastElement: {
+        prototype: HTMLPToastElement;
+        new (): HTMLPToastElement;
+    };
+    interface HTMLPToastContainerElement extends Components.PToastContainer, HTMLStencilElement {
+    }
+    var HTMLPToastContainerElement: {
+        prototype: HTMLPToastContainerElement;
+        new (): HTMLPToastContainerElement;
     };
     interface HTMLPTooltipElement extends Components.PTooltip, HTMLStencilElement {
     }
@@ -843,15 +1822,23 @@ declare global {
     };
     interface HTMLElementTagNameMap {
         "p-accordion": HTMLPAccordionElement;
+        "p-attachment": HTMLPAttachmentElement;
         "p-avatar": HTMLPAvatarElement;
         "p-avatar-group": HTMLPAvatarGroupElement;
+        "p-backdrop": HTMLPBackdropElement;
         "p-button": HTMLPButtonElement;
+        "p-calendar": HTMLPCalendarElement;
         "p-card-body": HTMLPCardBodyElement;
         "p-card-container": HTMLPCardContainerElement;
         "p-card-header": HTMLPCardHeaderElement;
         "p-content-slider": HTMLPContentSliderElement;
         "p-counter": HTMLPCounterElement;
+        "p-datepicker": HTMLPDatepickerElement;
         "p-divider": HTMLPDividerElement;
+        "p-drawer": HTMLPDrawerElement;
+        "p-drawer-body": HTMLPDrawerBodyElement;
+        "p-drawer-container": HTMLPDrawerContainerElement;
+        "p-drawer-header": HTMLPDrawerHeaderElement;
         "p-dropdown": HTMLPDropdownElement;
         "p-dropdown-menu-container": HTMLPDropdownMenuContainerElement;
         "p-dropdown-menu-item": HTMLPDropdownMenuItemElement;
@@ -859,22 +1846,25 @@ declare global {
         "p-icon": HTMLPIconElement;
         "p-illustration": HTMLPIllustrationElement;
         "p-info-panel": HTMLPInfoPanelElement;
+        "p-input-error": HTMLPInputErrorElement;
         "p-input-group": HTMLPInputGroupElement;
+        "p-label": HTMLPLabelElement;
         "p-layout": HTMLPLayoutElement;
         "p-loader": HTMLPLoaderElement;
         "p-modal": HTMLPModalElement;
-        "p-modal-backdrop": HTMLPModalBackdropElement;
         "p-modal-body": HTMLPModalBodyElement;
         "p-modal-container": HTMLPModalContainerElement;
         "p-modal-footer": HTMLPModalFooterElement;
         "p-modal-header": HTMLPModalHeaderElement;
         "p-navbar": HTMLPNavbarElement;
         "p-navigation-item": HTMLPNavigationItemElement;
+        "p-page-size-select": HTMLPPageSizeSelectElement;
         "p-pagination": HTMLPPaginationElement;
         "p-pagination-item": HTMLPPaginationItemElement;
         "p-profile": HTMLPProfileElement;
         "p-segment-container": HTMLPSegmentContainerElement;
         "p-segment-item": HTMLPSegmentItemElement;
+        "p-select": HTMLPSelectElement;
         "p-slider-indicator": HTMLPSliderIndicatorElement;
         "p-status": HTMLPStatusElement;
         "p-stepper": HTMLPStepperElement;
@@ -882,72 +1872,848 @@ declare global {
         "p-stepper-line": HTMLPStepperLineElement;
         "p-tab-group": HTMLPTabGroupElement;
         "p-tab-item": HTMLPTabItemElement;
-        "p-tag": HTMLPTagElement;
+        "p-table": HTMLPTableElement;
+        "p-table-cell": HTMLPTableCellElement;
+        "p-table-column": HTMLPTableColumnElement;
+        "p-table-container": HTMLPTableContainerElement;
+        "p-table-footer": HTMLPTableFooterElement;
+        "p-table-header": HTMLPTableHeaderElement;
+        "p-table-row": HTMLPTableRowElement;
+        "p-toast": HTMLPToastElement;
+        "p-toast-container": HTMLPToastContainerElement;
         "p-tooltip": HTMLPTooltipElement;
     }
-}
-declare namespace LocalJSX {
-    interface PAccordion {
+}
+declare namespace LocalJSX {
+    interface PAccordion {
+        /**
+          * Wether the accordion can be closed
+         */
+        "closeable"?: boolean;
+        /**
+          * Header of the accordion
+         */
+        "header": string;
+        /**
+          * Open change event
+         */
+        "onIsOpen"?: (event: PAccordionCustomEvent<boolean>) => void;
+        /**
+          * Wether the accordion is open
+         */
+        "open"?: boolean;
+        /**
+          * Wether the accordion can be opened
+         */
+        "openable"?: boolean;
+    }
+    interface PAttachment {
+        /**
+          * Wether the attachment is downloading
+         */
+        "downloading"?: boolean;
+        /**
+          * The error to show
+         */
+        "error"?: string;
+        /**
+          * Wether the attachment is uploading/loading
+         */
+        "loading"?: boolean;
+        /**
+          * The variant of the button
+         */
+        "mode"?: 'read' | 'write';
+        /**
+          * Event when delete is pressed
+         */
+        "onDelete"?: (event: PAttachmentCustomEvent<any>) => void;
+        /**
+          * Event when download is pressed
+         */
+        "onDownload"?: (event: PAttachmentCustomEvent<any>) => void;
+    }
+    interface PAvatar {
+        /**
+          * The default image to show on errors
+         */
+        "defaultImage"?: string;
+        /**
+          * The size of the avatar
+         */
+        "size"?: 'small' | 'medium' | 'large' | 'xlarge';
+        /**
+          * The image used for the avatar
+         */
+        "src": string;
+        /**
+          * The variant of the avatar
+         */
+        "variant"?: 'user' | 'company';
+    }
+    interface PAvatarGroup {
+        /**
+          * The amount to show after the avatars
+         */
+        "extra"?: number;
+    }
+    interface PBackdrop {
+        /**
+          * Wether to apply blur on the background of the backdrop
+         */
+        "applyBlur"?: boolean;
+        /**
+          * Wether the backdrop is closing
+         */
+        "closing"?: boolean;
+        /**
+          * When the backdrop is clicked
+         */
+        "onClicked"?: (event: PBackdropCustomEvent<MouseEvent>) => void;
+        /**
+          * Wether we should scroll lock the body
+         */
+        "scrollLock"?: boolean;
+        /**
+          * The variant of the backdrop
+         */
+        "variant"?: 'modal' | 'drawer';
+    }
+    interface PButton {
+        /**
+          * Wether to show a chevron or not
+         */
+        "chevron"?: boolean | 'up' | 'down';
+        /**
+          * Chevron position
+         */
+        "chevronPosition"?: 'start' | 'end';
+        /**
+          * Wether the button is disabled
+         */
+        "disabled"?: boolean;
+        /**
+          * Href in case of "text" version
+         */
+        "href"?: string;
+        /**
+          * Icon to show on the button
+         */
+        "icon"?: IconVariant;
+        /**
+          * Icon flip
+         */
+        "iconFlip"?: IconFlipOptions;
+        /**
+          * Wether the button is icon only
+         */
+        "iconOnly"?: boolean;
+        /**
+          * Icon position
+         */
+        "iconPosition"?: 'start' | 'end';
+        /**
+          * Icon rotate
+         */
+        "iconRotate"?: RotateOptions;
+        /**
+          * Wether the button should inherit text styles
+         */
+        "inheritText"?: boolean;
+        /**
+          * Wether to show a loader or not
+         */
+        "loading"?: boolean;
+        /**
+          * Button click event
+         */
+        "onOnClick"?: (event: PButtonCustomEvent<MouseEvent>) => void;
+        /**
+          * The size of the button
+         */
+        "size"?: 'small' | 'medium';
+        /**
+          * Target in case of "text" version
+         */
+        "target"?: string;
+        /**
+          * The variant of the button
+         */
+        "variant"?: 'primary' | 'secondary' | 'text';
+    }
+    interface PCalendar {
+        /**
+          * Wether to disable the weekends
+         */
+        "disableWeekends"?: boolean;
+        /**
+          * Disabled dates
+         */
+        "disabledDates"?: Array<Date | 'string'> | string;
+        /**
+          * Max date
+         */
+        "maxDate"?: Date | 'string';
+        /**
+          * Min date
+         */
+        "minDate"?: Date | 'string';
+        /**
+          * The mode of the datepicker
+         */
+        "mode"?: 'year' | 'month' | 'day';
+        /**
+          * Event when the value changes
+         */
+        "onValueChange"?: (event: PCalendarCustomEvent<any>) => void;
+        /**
+          * Wether to automatically preselect today
+         */
+        "preselectToday"?: boolean;
+        /**
+          * The current value
+         */
+        "value"?: Date | 'string';
+        /**
+          * The variant of the button
+         */
+        "variant"?: 'default' | 'embedded';
+    }
+    interface PCardBody {
+        /**
+          * Wether the button should inherit text styles
+         */
+        "inheritText"?: boolean;
+    }
+    interface PCardContainer {
+        /**
+          * Wether the card should be hoverable
+         */
+        "hoverable"?: boolean;
+        /**
+          * Wether the card should have shadow
+         */
+        "shadow"?: boolean;
+    }
+    interface PCardHeader {
+        /**
+          * Enable the title arrow
+         */
+        "arrow"?: boolean;
+        /**
+          * Content of the card header
+         */
+        "header"?: string;
+    }
+    interface PContentSlider {
+        /**
+          * Wether to disable auto centering the content
+         */
+        "disableAutoCenter"?: boolean;
+        /**
+          * Wether to disable dragging the content
+         */
+        "disableDrag"?: boolean;
+        /**
+          * Wether to disable clicking the indicator scrolls content
+         */
+        "disableIndicatorClick"?: boolean;
+        /**
+          * Wether to hide the indicator on mobile
+         */
+        "hideMobileIndicator"?: boolean;
+    }
+    interface PCounter {
+        /**
+          * The size of the counter
+         */
+        "size"?: 'default' | 'mini';
+        /**
+          * The variant of the counter
+         */
+        "variant"?: 'info' | 'negative' | 'positive' | 'unbiased';
+    }
+    interface PDatepicker {
+        /**
+          * Wether to disable the weekends
+         */
+        "disableWeekends"?: boolean;
+        /**
+          * Wether the input group is disabled used by the datepicker
+         */
+        "disabled"?: boolean;
+        /**
+          * Disabled dates
+         */
+        "disabledDates"?: Array<Date | 'string'> | string;
+        /**
+          * The helper of the input group used by the datepicker
+         */
+        "error"?: string;
+        /**
+          * The display & parse format to use
+         */
+        "format"?: string;
+        /**
+          * The helper of the input group used by the datepicker
+         */
+        "helper"?: string;
+        /**
+          * The label of the input group used by the datepicker
+         */
+        "label"?: string;
+        /**
+          * Max date
+         */
+        "maxDate"?: Date | 'string';
+        /**
+          * Min date
+         */
+        "minDate"?: Date | 'string';
+        /**
+          * The mode of the datepicker
+         */
+        "mode"?: 'year' | 'month' | 'day';
+        /**
+          * Event when the value changes
+         */
+        "onValueChange"?: (event: PDatepickerCustomEvent<any>) => void;
+        /**
+          * The placeholder of the input
+         */
+        "placeholder"?: string;
+        /**
+          * The prefix of the input group used by the datepicker
+         */
+        "prefix"?: string;
+        /**
+          * Wethter to automatically preselect today
+         */
+        "preselectToday"?: boolean;
+        /**
+          * Wether the field is required
+         */
+        "required"?: boolean;
+        /**
+          * The size of the input group used by the datepicker
+         */
+        "size"?: 'small' | 'medium';
+        /**
+          * The current value
+         */
+        "value"?: Date | null | undefined;
+    }
+    interface PDivider {
+    }
+    interface PDrawer {
+        /**
+          * Wether to apply blur to the backdrop
+         */
+        "applyBlur"?: boolean;
+        /**
+          * Wether to hide the drawer when the backdrop is clicked
+         */
+        "backdropClickClose"?: boolean;
+        /**
+          * Wether the drawer can be closed
+         */
+        "canClose"?: boolean;
+        /**
+          * The Header of the drawer
+         */
+        "header"?: string;
+        /**
+          * Close click event
+         */
+        "onCloseClicked"?: (event: PDrawerCustomEvent<{
+        event: MouseEvent;
+        canClose: boolean;
+    }>) => void;
+        /**
+          * Closed event
+         */
+        "onClosed"?: (event: PDrawerCustomEvent<null>) => void;
+        /**
+          * Wether we should scroll lock the body
+         */
+        "scrollLock"?: boolean;
+        /**
+          * Wether to show the drawer or not
+         */
+        "show"?: boolean;
+        /**
+          * Wether to show the close on mobile in the header
+         */
+        "showClose"?: boolean;
+    }
+    interface PDrawerBody {
+        /**
+          * The variant of the modal body
+         */
+        "variant"?: 'default' | 'table';
+    }
+    interface PDrawerContainer {
+        /**
+          * Wether the container is closing
+         */
+        "closing"?: boolean;
+    }
+    interface PDrawerHeader {
+        /**
+          * Close click event
+         */
+        "onClose"?: (event: PDrawerHeaderCustomEvent<MouseEvent>) => void;
+        /**
+          * Wether to show the close button on mobile
+         */
+        "showClose"?: boolean;
+    }
+    interface PDropdown {
+        /**
+          * Wether to apply the full width
+         */
+        "applyFullWidth"?: boolean;
+        /**
+          * Wether to apply the max width
+         */
+        "applyMaxWidth"?: boolean;
+        /**
+          * Wether to automatically calculate the width of the menu based on the trigger
+         */
+        "calculateWidth"?: boolean;
+        /**
+          * Chevron direction
+         */
+        "chevronDirection"?: 'up' | 'down';
+        /**
+          * Chevron position
+         */
+        "chevronPosition"?: 'start' | 'end';
+        /**
+          * Wether to automatically close the dropdown menu after clicking inside
+         */
+        "disableTriggerClick"?: boolean;
+        /**
+          * Wether to automatically close the dropdown menu after clicking inside
+         */
+        "insideClick"?: boolean;
+        /**
+          * Open change event
+         */
+        "onIsOpen"?: (event: PDropdownCustomEvent<boolean>) => void;
+        /**
+          * The content of the dropdown menu
+         */
+        "placement"?: Placement;
+        /**
+          * Wether to show the dropdown menu
+         */
+        "show"?: boolean;
+        /**
+          * The strategy of the popover placement
+         */
+        "strategy"?: Strategy;
+    }
+    interface PDropdownMenuContainer {
+        /**
+          * Wether the container should all available space
+         */
+        "fullWidth"?: boolean;
+        /**
+          * Wether the container applies it's max width
+         */
+        "maxWidth"?: boolean;
+    }
+    interface PDropdownMenuItem {
+        /**
+          * Wether the dropdown menu item is active
+         */
+        "active"?: boolean;
+        /**
+          * Wether to enable the hover state
+         */
+        "enableHover"?: boolean;
+        /**
+          * Icon of the navigation item
+         */
+        "icon"?: IconVariant;
+    }
+    interface PHelper {
+        /**
+          * The placement of the helper popover
+         */
+        "placement"?: Placement;
+    }
+    interface PIcon {
+        /**
+          * Wether to flip the icon horizontally or vertically
+         */
+        "flip"?: IconFlipOptions1;
+        /**
+          * Wether to rotate the icon x degrees
+         */
+        "rotate"?: RotateOptions;
+        /**
+          * The size of the icon, using tailwind sizes
+         */
+        "size"?: TextSizeOptions;
+        /**
+          * The icon the be displayed
+         */
+        "variant": IconVariant1;
+    }
+    interface PIllustration {
+        /**
+          * The icon the be displayed
+         */
+        "variant": IllustrationVariant;
+    }
+    interface PInfoPanel {
+        /**
+          * Wether the panel can be closed
+         */
+        "closeable"?: boolean;
+        /**
+          * The content of the info panel
+         */
+        "content"?: string;
+        /**
+          * The header of the info panel
+         */
+        "header"?: string;
+        /**
+          * The variant of the info panel
+         */
+        "variant"?: 'info' | 'negative' | 'positive' | 'unbiased';
+    }
+    interface PInputError {
+        /**
+          * The error to show
+         */
+        "error"?: string;
+        /**
+          * Wether to force show the tooltip
+         */
+        "forceShowTooltip"?: boolean;
+    }
+    interface PInputGroup {
+        /**
+          * Wether the input group is disabled
+         */
+        "disabled"?: boolean;
+        /**
+          * The helper of the input group
+         */
+        "error"?: string;
+        /**
+          * The method to use when focusing the input
+         */
+        "focusMethod"?: 'focus' | 'click';
+        /**
+          * Wether the input group is focused
+         */
+        "focused"?: 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
+         */
+        "behavior"?: | 'icon'
+        | 'circle'
+        | 'combination'
+        | 'text'
+        | 'icon-only';
+        /**
+          * Icon to show on the label
+         */
+        "icon"?: IconVariant;
+        /**
+          * Icon flip
+         */
+        "iconFlip"?: IconFlipOptions;
+        /**
+          * Icon rotate
+         */
+        "iconRotate"?: RotateOptions1;
+        /**
+          * Wether to keep the content on mobile
+         */
+        "keepMobileContent"?: boolean;
+        /**
+          * The size of the label
+         */
+        "size"?: 'small' | 'default';
+        /**
+          * Variant of the label
+         */
+        "variant"?: | 'positive'
+        | 'unbiased'
+        | 'negative'
+        | 'info';
+    }
+    interface PLayout {
+        /**
+          * Variant of the layout
+         */
+        "variant"?: 'default' | 'login' | 'office' | 'office-minimal';
+    }
+    interface PLoader {
+        /**
+          * Color of the loader
+         */
+        "color"?: 'indigo' | 'white' | 'storm';
+        /**
+          * !NOT IMPLEMENTED! Modal description for modal variant
+         */
+        "modalDescription"?: string;
+        /**
+          * !NOT IMPLEMENTED! Modal title for modal variant
+         */
+        "modalTitle"?: string;
+        /**
+          * Wether to show or hide the loader
+         */
+        "show"?: boolean | Observable<boolean>;
+        /**
+          * Variant of loader
+         */
+        "variant"?: | 'inline'
+        | 'full-width'
+        | 'full-screen'
+        | 'modal'
+        | 'ghost';
+    }
+    interface PModal {
+        /**
+          * Wether to apply blur to the backdrop
+         */
+        "applyBlur"?: boolean;
+        /**
+          * Wether to hide the modal when the backdrop is clicked
+         */
+        "backdropClickClose"?: boolean;
+        /**
+          * The Header of the modal
+         */
+        "header"?: string;
+        /**
+          * Close click event
+         */
+        "onCloseClicked"?: (event: PModalCustomEvent<MouseEvent>) => void;
+        /**
+          * Closed event
+         */
+        "onClosed"?: (event: PModalCustomEvent<null>) => void;
+        /**
+          * Wether we should scroll lock the body
+         */
+        "scrollLock"?: boolean;
+        /**
+          * Wether to show the modal or not
+         */
+        "show"?: boolean;
+        /**
+          * Wether to show the close button in the header
+         */
+        "showClose"?: boolean;
+        /**
+          * Wether to show the footer on mobile
+         */
+        "showMobileFooter"?: boolean;
+        /**
+          * The size of the modal container
+         */
+        "size"?: 'sm' | 'md' | 'lg' | 'xl';
+        /**
+          * The variant of the modal body
+         */
+        "variant"?: 'default' | 'table';
+    }
+    interface PModalBody {
+        /**
+          * Wether the modal body should be rounded at the bottom
+         */
+        "rounded"?: boolean;
+        /**
+          * The variant of the modal body
+         */
+        "variant"?: 'default' | 'table';
+    }
+    interface PModalContainer {
+        /**
+          * Wether the container is closing
+         */
+        "closing"?: boolean;
+        /**
+          * The size of the modal container
+         */
+        "size"?: 'sm' | 'md' | 'lg' | 'xl';
+    }
+    interface PModalFooter {
+    }
+    interface PModalHeader {
+        /**
+          * Close click event
+         */
+        "onClose"?: (event: PModalHeaderCustomEvent<MouseEvent>) => void;
+        /**
+          * Wether to show the close button on mobile
+         */
+        "showClose"?: boolean;
+    }
+    interface PNavbar {
         /**
-          * Wether the accordion can be closed
+          * The text to display for the close button
          */
-        "closeable"?: boolean;
+        "closeText"?: string;
         /**
-          * Header of the accordion
+          * The text to display for the menu button & sidebar title
          */
-        "header": string;
+        "menuText"?: string;
+    }
+    interface PNavigationItem {
         /**
-          * Open change event
+          * Wether the navigation item is active
          */
-        "onIsOpen"?: (event: PAccordionCustomEvent<boolean>) => void;
+        "active"?: boolean;
         /**
-          * Wether the accordion is open
+          * Icon of the navigation item
          */
-        "open"?: boolean;
+        "counter"?: number | string;
         /**
-          * Wether the accordion can be opened
+          * The href of the navigation item
          */
-        "openable"?: boolean;
+        "href"?: string;
+        /**
+          * Icon of the navigation item
+         */
+        "icon"?: IconVariant;
+        /**
+          * The target of the navigation item
+         */
+        "target"?: string;
     }
-    interface PAvatar {
+    interface PPageSizeSelect {
         /**
-          * The default image to show on errors
+          * The size of the button
          */
-        "defaultImage"?: string;
+        "buttonSize"?: 'small' | 'medium';
         /**
-          * The size of the avatar
+          * The template for the data view
          */
-        "size"?: 'small' | 'medium' | 'large';
+        "buttonTemplate"?: templateFunc;
         /**
-          * The image used for the avatar
+          * Chevron position
          */
-        "src": string;
+        "chevronPosition"?: 'start' | 'end';
         /**
-          * The variant of the avatar
+          * Wether to hide when there is only 1 page available
          */
-        "variant"?: 'user' | 'company';
+        "hidden"?: boolean;
+        /**
+          * The template for the data view
+         */
+        "itemTemplate"?: templateFunc;
+        /**
+          * Event whenever the size changes
+         */
+        "onSizeChange"?: (event: PPageSizeSelectCustomEvent<number>) => void;
+        /**
+          * The current page
+         */
+        "size"?: number;
+        /**
+          * The available sizes
+         */
+        "sizeOptions"?: number[];
     }
-    interface PAvatarGroup {
+    interface PPagination {
         /**
-          * The amount to show after the avatars
+          * Wether to hide when there is only 1 page available
          */
-        "extra"?: number;
+        "hideOnSinglePage"?: boolean;
+        /**
+          * Event whenever the page changes
+         */
+        "onPageChange"?: (event: PPaginationCustomEvent<number>) => void;
+        /**
+          * The current page
+         */
+        "page"?: number;
+        /**
+          * The amount of items per page
+         */
+        "pageSize"?: number;
+        /**
+          * The total amount of items
+         */
+        "total": number;
     }
-    interface PButton {
+    interface PPaginationItem {
         /**
-          * Wether to show a chevron or not
+          * Wether the pagination item is active
          */
-        "chevron"?: boolean | 'up' | 'down';
+        "active"?: boolean;
+    }
+    interface PProfile {
         /**
-          * Wether the button is disabled
+          * The size of the profile avatar
          */
-        "disabled"?: boolean;
+        "size"?: 'small' | 'medium' | 'large';
         /**
-          * Href in case of "text" version
+          * The variant of the profile
          */
-        "href"?: string;
+        "variant"?: 'company' | 'user';
+    }
+    interface PSegmentContainer {
+    }
+    interface PSegmentItem {
         /**
-          * Icon to show on the button
+          * Wether the segment item is active
+         */
+        "active"?: boolean;
+        /**
+          * Icon to show on the segment item
          */
         "icon"?: IconVariant;
         /**
@@ -955,348 +2721,500 @@ declare namespace LocalJSX {
          */
         "iconFlip"?: IconFlipOptions;
         /**
-          * Wether the button is icon only
+          * Icon rotate
          */
-        "iconOnly"?: boolean;
+        "iconRotate"?: RotateOptions;
+    }
+    interface PSelect {
         /**
-          * Icon position
+          * Wether the input uses async filtering
          */
-        "iconPosition"?: 'start' | 'end';
+        "asyncFilter"?: boolean;
         /**
-          * Icon rotate
+          * Wether to automatically select the first item
          */
-        "iconRotate"?: RotateOptions;
+        "autoSelectFirst"?: boolean;
         /**
-          * Wether the button should inherit text styles
+          * The placeholder of the input when auto completing
          */
-        "inheritText"?: boolean;
+        "autocompletePlaceholder"?: string;
         /**
-          * Wether to show a loader or not
+          * Wether the input group is disabled used by the select
+         */
+        "disabled"?: boolean;
+        /**
+          * The key of the object to display
+         */
+        "displayKey"?: string;
+        /**
+          * Wether to enable autocomplete
+         */
+        "enableAutocomplete"?: boolean;
+        /**
+          * The helper of the input group used by the select
+         */
+        "error"?: string;
+        /**
+          * The helper of the input group used by the select
+         */
+        "helper"?: string;
+        /**
+          * Icon of the select box
+         */
+        "icon"?: IconVariant;
+        /**
+          * The key to identify an object
+         */
+        "identifierKey"?: string;
+        /**
+          * The items to show in the dropdown
+         */
+        "items"?: string | any[];
+        /**
+          * Wether to keep the query or not
+         */
+        "keepQuery"?: boolean;
+        /**
+          * The label of the input group used by the select
+         */
+        "label"?: string;
+        /**
+          * Wether to show loading items
          */
         "loading"?: boolean;
         /**
-          * Button click event
+          * The maximum amount of items to display
          */
-        "onOnClick"?: (event: PButtonCustomEvent<MouseEvent>) => void;
+        "maxDisplayedItems"?: number;
         /**
-          * The size of the button
+          * Event when the dropdown shows
+         */
+        "onDropdownShown"?: (event: PSelectCustomEvent<any>) => void;
+        /**
+          * Event when the query of the autocomplete changes
+         */
+        "onQueryChange"?: (event: PSelectCustomEvent<string>) => void;
+        /**
+          * Event when the value changes
+         */
+        "onValueChange"?: (event: PSelectCustomEvent<any>) => void;
+        /**
+          * The placeholder of the input
+         */
+        "placeholder"?: string;
+        /**
+          * The prefix of the input group used by the select
+         */
+        "prefix"?: string;
+        /**
+          * The current query
+         */
+        "query"?: string;
+        /**
+          * The key of the object to display
+         */
+        "queryKey"?: string;
+        /**
+          * Wether the field is required
+         */
+        "required"?: boolean;
+        /**
+          * Wether to show the chevron or not
+         */
+        "showChevron"?: boolean;
+        /**
+          * The size of the input group used by the select
          */
         "size"?: 'small' | 'medium';
         /**
-          * Target in case of "text" version
+          * The current value
          */
-        "target"?: string;
+        "value"?: any;
         /**
-          * The variant of the button
+          * The key of the object to return
          */
-        "variant"?: 'primary' | 'secondary' | 'text';
+        "valueKey"?: string;
+    }
+    interface PSliderIndicator {
         /**
-          * The width of the button
+          * Wether the slider indicator is active
          */
-        "width"?: 'auto' | 'full';
+        "active"?: boolean;
     }
-    interface PCardBody {
+    interface PStatus {
         /**
-          * Wether the button should inherit text styles
+          * Icon to show on the status
          */
-        "inheritText"?: boolean;
+        "icon"?: IconVariant;
+        /**
+          * Icon flip
+         */
+        "iconFlip"?: IconFlipOptions;
+        /**
+          * Icon rotate
+         */
+        "iconRotate"?: RotateOptions;
+        /**
+          * The variant of the status
+         */
+        "variant"?: 'default' | 'positive' | 'unbiased' | 'negative';
     }
-    interface PCardContainer {
+    interface PStepper {
         /**
-          * Wether the card should be hoverable
+          * The currently active step
          */
-        "hoverable"?: boolean;
+        "activeStep"?: number;
         /**
-          * Wether the card should have shadow
+          * The position of the content in case of vertical direction
          */
-        "shadow"?: boolean;
+        "contentPosition"?: 'start' | 'end';
+        /**
+          * The direction of the stepper
+         */
+        "direction"?: 'horizontal' | 'vertical';
     }
-    interface PCardHeader {
+    interface PStepperItem {
         /**
-          * Enable the title arrow
+          * Wether the step is active
          */
-        "arrow"?: boolean;
+        "active"?: boolean;
+        /**
+          * The alignment of the step content
+         */
+        "align"?: 'start' | 'center' | 'end';
+        /**
+          * The position of the content in case of vertical direction
+         */
+        "contentPosition"?: 'start' | 'end';
+        /**
+          * The direction of the stepper step
+         */
+        "direction"?: 'horizontal' | 'vertical';
+        /**
+          * Wether the step is finished
+         */
+        "finished"?: boolean;
+    }
+    interface PStepperLine {
+        /**
+          * Wether the line is active
+         */
+        "active"?: boolean;
+        /**
+          * The direction of the stepper line
+         */
+        "direction"?: 'horizontal' | 'vertical';
+    }
+    interface PTabGroup {
+    }
+    interface PTabItem {
+        /**
+          * Wether the tab item is active
+         */
+        "active"?: boolean;
+    }
+    interface PTable {
+        /**
+          * Active quick filter identifier
+         */
+        "activeQuickFilterIdentifier"?: string;
+        /**
+          * The amount of loading rows to show
+         */
+        "amountOfLoadingRows"?: number;
+        /**
+          * A key to determine if a row can be selected
+         */
+        "canSelectKey"?: string;
+        /**
+          * The edit button icon
+         */
+        "editButtonIcon"?: IconVariant2;
+        /**
+          * Wether the edit button is loading
+         */
+        "editButtonLoading"?: boolean;
+        /**
+          * The template for the edit button text
+         */
+        "editButtonTemplate"?: buttonTemplateFunc;
+        /**
+          * The edit button text if changed
+         */
+        "editButtonText"?: string;
+        "emptyStateAction"?: templateFunc1;
+        "emptyStateContent"?: templateFunc1;
+        "emptyStateFilteredContent"?: templateFunc1;
+        "emptyStateFilteredHeader"?: templateFunc1;
+        "emptyStateHeader"?: templateFunc1;
+        /**
+          * Wether to show the edit button
+         */
+        "enableEdit"?: boolean;
+        /**
+          * Wether to enable empty state action
+         */
+        "enableEmptyStateAction"?: boolean;
+        /**
+          * Wether to enable export
+         */
+        "enableExport"?: boolean;
+        /**
+          * Wether to show the filter button
+         */
+        "enableFilter"?: boolean;
         /**
-          * Content of the card header
+          * Wether to show the header
          */
-        "header"?: string;
-    }
-    interface PContentSlider {
+        "enableFooter"?: boolean;
         /**
-          * Wether to disable dragging the content
+          * Wether to show the header
          */
-        "disableDrag"?: boolean;
+        "enableHeader"?: boolean;
         /**
-          * Wether to disable clicking the indicator scrolls content
+          * Wether to enable page size select
          */
-        "disableIndicatorClick"?: boolean;
+        "enablePageSize"?: boolean;
         /**
-          * Wether to hide the indicator on mobile
+          * Wether to enable pagination
          */
-        "hideMobileIndicator"?: boolean;
-    }
-    interface PCounter {
+        "enablePagination"?: boolean;
         /**
-          * The size of the counter
+          * Wether to enable row clicking
          */
-        "size"?: 'default' | 'mini';
+        "enableRowClick"?: boolean;
         /**
-          * The variant of the counter
+          * Wether to enable selection
          */
-        "variant"?: 'info' | 'negative' | 'positive' | 'unbiased';
-    }
-    interface PDivider {
-    }
-    interface PDropdown {
+        "enableRowSelection"?: boolean;
         /**
-          * Wether to automatically close the dropdown menu after clicking inside
+          * Wether to show the search input
          */
-        "disableTriggerClick"?: boolean;
+        "enableSearch"?: boolean;
         /**
-          * Wether to automatically close the dropdown menu after clicking inside
+          * The template for the filter button text
          */
-        "insideClick"?: boolean;
+        "filterButtonTemplate"?: templateFunc1;
         /**
-          * Open change event
+          * Wether the footer should show loading state
          */
-        "onIsOpen"?: (event: PDropdownCustomEvent<boolean>) => void;
+        "footerLoading"?: boolean;
         /**
-          * The content of the dropdown menu
+          * Wether the header should show loading state
          */
-        "placement"?: Placement;
+        "headerLoading"?: boolean;
         /**
-          * Wether to show the dropdown menu
+          * Wether to hide when there is only 1 page available
          */
-        "show"?: boolean;
+        "hideOnSinglePage"?: boolean;
         /**
-          * The strategy of the popover placement
+          * The items to be fed to the table
          */
-        "strategy"?: PositioningStrategy;
-    }
-    interface PDropdownMenuContainer {
-    }
-    interface PDropdownMenuItem {
+        "items"?: string;
         /**
-          * Wether the dropdown menu item is active
+          * Wether data is loading
          */
-        "active"?: boolean;
+        "loading"?: boolean;
         /**
-          * Icon of the navigation item
+          * Event when the edit button is clicked
          */
-        "icon"?: IconVariant;
-    }
-    interface PHelper {
+        "onEdit"?: (event: PTableCustomEvent<null>) => void;
         /**
-          * The placement of the helper popover
+          * Event whenever the empty state is clicked
          */
-        "placement"?: Placement;
-    }
-    interface PIcon {
+        "onEmptyStateActionClick"?: (event: PTableCustomEvent<null>) => void;
         /**
-          * Wether to flip the icon horizontally or vertically
+          * Event whenever the page changes
          */
-        "flip"?: IconFlipOptions;
+        "onExport"?: (event: PTableCustomEvent<number>) => void;
         /**
-          * Wether to rotate the icon x degrees
+          * Event when the filter button is clicked
          */
-        "rotate"?: RotateOptions;
+        "onFilter"?: (event: PTableCustomEvent<null>) => void;
         /**
-          * The size of the icon, using tailwind sizes
+          * Event when the table has rendered
          */
-        "size"?: TextSizeOptions;
+        "onHasRendered"?: (event: PTableCustomEvent<number>) => void;
         /**
-          * The icon the be displayed
+          * Event whenever the page changes
          */
-        "variant": IconVariant;
-    }
-    interface PIllustration {
+        "onPageChange"?: (event: PTableCustomEvent<number>) => void;
         /**
-          * The icon the be displayed
+          * Event whenever the page changes
          */
-        "variant": IllustrationVariant;
-    }
-    interface PInfoPanel {
+        "onPageSizeChange"?: (event: PTableCustomEvent<number>) => void;
         /**
-          * Wether the panel can be closed
+          * Event when the query changes
          */
-        "closeable"?: boolean;
+        "onQueryChange"?: (event: PTableCustomEvent<string>) => void;
         /**
-          * The content of the info panel
+          * Event when one of the quick filters is clicked
          */
-        "content"?: string;
+        "onQuickFilter"?: (event: PTableCustomEvent<QuickFilter>) => void;
         /**
-          * The header of the info panel
+          * Event whenever a row is clicked
          */
-        "header"?: string;
+        "onRowClick"?: (event: PTableCustomEvent<RowClickEvent>) => void;
         /**
-          * The variant of the info panel
+          * Event whenever a row is deselected
          */
-        "variant"?: 'info' | 'negative' | 'positive' | 'unbiased';
-    }
-    interface PInputGroup {
+        "onRowDeselected"?: (event: PTableCustomEvent<any>) => void;
         /**
-          * Wether the input group is disabled
+          * Event whenever a row is selected
          */
-        "disabled"?: boolean;
+        "onRowSelected"?: (event: PTableCustomEvent<any>) => void;
         /**
-          * The helper of the input group
+          * Event whenever the current selection changes
          */
-        "error"?: string;
+        "onSelectedRowsChange"?: (event: PTableCustomEvent<any>) => void;
         /**
-          * Wether the input group is focused
+          * The current page
          */
-        "focused"?: boolean;
+        "page"?: number;
         /**
-          * The helper of the input group
+          * The amount of items per page
          */
-        "helper"?: string;
+        "pageSize"?: number;
         /**
-          * Icon of the navigation item
+          * The options for the page size
          */
-        "icon"?: IconVariant;
+        "pageSizeOptions"?: number[];
         /**
-          * Icon flip
+          * The query to show in the search bar
          */
-        "iconFlip"?: IconFlipOptions;
+        "query"?: string;
         /**
-          * Icon rotate
+          * Quick filters to show
          */
-        "iconRotate"?: RotateOptions;
+        "quickFilters"?: QuickFilter[];
         /**
-          * The label of the input group
+          * The amount of filters being selected
          */
-        "label"?: string;
+        "selectedFiltersAmount"?: number;
         /**
-          * The prefix of the input group
+          * The current selection of items
          */
-        "prefix"?: string;
+        "selectedRows"?: any[];
         /**
-          * The suffix of the input group
+          * The key to determine if a row is selected
          */
-        "suffix"?: string;
-    }
-    interface PLayout {
+        "selectionKey"?: string;
         /**
-          * Variant of the layout
+          * The total amount of items
          */
-        "variant"?: 'default' | 'login';
+        "total": number;
     }
-    interface PLoader {
+    interface PTableCell {
         /**
-          * Color of the loader
+          * The checkbox to show
          */
-        "color"?: 'indigo' | 'white' | 'storm';
+        "checkbox"?: any;
         /**
-          * !NOT IMPLEMENTED! Modal description for modal variant
+          * The definition of the table column
          */
-        "modalDescription"?: string;
+        "definition"?: TableColumn;
         /**
-          * !NOT IMPLEMENTED! Modal title for modal variant
+          * The index of the column
          */
-        "modalTitle"?: string;
+        "index"?: number;
         /**
-          * Wether to show or hide the loader
+          * The item in question
          */
-        "show"?: boolean | Observable<boolean>;
+        "item"?: any;
         /**
-          * Variant of loader
+          * The index of the row
          */
-        "variant"?: 'inline' | 'full-width' | 'full-screen' | 'modal';
-    }
-    interface PModal {
+        "rowIndex"?: number;
         /**
-          * The Header of the modal
+          * The template to show
          */
-        "header"?: string;
+        "template"?: TableDefinitionTemplateFunc;
         /**
-          * Close click event
+          * The value of the column
          */
-        "onClose"?: (event: PModalCustomEvent<MouseEvent>) => void;
+        "value"?: any;
         /**
-          * Wether to show the modal or not
+          * The variant of the column
          */
-        "show"?: boolean;
+        "variant"?: 'default' | 'loading' | 'header';
+    }
+    interface PTableColumn {
         /**
-          * Wether to show the close on mobile in the header
+          * The alignment of the column
          */
-        "showMobileClose"?: boolean;
+        "align"?: 'start' | 'center' | 'end';
         /**
-          * Wether to show the footer on mobile
+          * Wether the column should have a checkbox
          */
-        "showMobileFooter"?: boolean;
+        "hasCheckbox"?: boolean;
         /**
-          * The size of the modal container
+          * Wether the column is the last in the row
          */
-        "size"?: 'sm' | 'md' | 'lg' | 'xl';
+        "isLast"?: boolean;
         /**
-          * The variant of the modal body
+          * The name of the column
          */
-        "variant"?: 'default' | 'table';
-    }
-    interface PModalBackdrop {
-    }
-    interface PModalBody {
+        "name"?: string;
         /**
-          * The variant of the modal body
+          * Event to let the table know it has to re render
          */
-        "variant"?: 'default' | 'table';
-    }
-    interface PModalContainer {
+        "onTableDefinitionChanged"?: (event: PTableColumnCustomEvent<boolean>) => void;
         /**
-          * The size of the modal container
+          * The path of the value of the item you want to display
          */
-        "size"?: 'sm' | 'md' | 'lg' | 'xl';
-    }
-    interface PModalFooter {
+        "path"?: string;
         /**
-          * Wether to show the footer on mobile
+          * The sizes of the column
          */
-        "hideOnMobile"?: boolean;
-    }
-    interface PModalHeader {
+        "sizes"?: | 'auto'
+        | 'hidden'
+        | 'full'
+        | number
+        | TableColumnSizes;
         /**
-          * Close click event
+          * The type of the column
          */
-        "onClose"?: (event: PModalHeaderCustomEvent<MouseEvent>) => void;
+        "type"?: 'td' | 'th';
         /**
-          * Wether to show the close button on mobile
+          * Wether the column should use the slot
          */
-        "showMobileClose"?: boolean;
+        "useSlot"?: boolean;
     }
-    interface PNavbar {
+    interface PTableContainer {
+    }
+    interface PTableFooter {
         /**
-          * The text to display for the close button
+          * Wether to enable export
          */
-        "closeText"?: string;
+        "enableExport"?: boolean;
         /**
-          * The text to display for the menu button & sidebar title
+          * Wether to enable page size select
          */
-        "menuText"?: string;
-    }
-    interface PNavigationItem {
+        "enablePageSize"?: boolean;
         /**
-          * Wether the navigation item is active
+          * Wether to enable pagination
          */
-        "active"?: boolean;
+        "enablePagination"?: boolean;
         /**
-          * Icon of the navigation item
+          * Wether to hide when there is only 1 page available
          */
-        "counter"?: number | string;
+        "hideOnSinglePage"?: boolean;
         /**
-          * The href of the navigation item
+          * Wether we want to show loading state
          */
-        "href"?: string;
+        "loading"?: boolean;
         /**
-          * Icon of the navigation item
+          * Event whenever the page changes
          */
-        "icon"?: IconVariant;
+        "onExport"?: (event: PTableFooterCustomEvent<number>) => void;
         /**
-          * The target of the navigation item
+          * Event whenever the page changes
          */
-        "target"?: string;
-    }
-    interface PPagination {
-        "onPageChange"?: (event: PPaginationCustomEvent<number>) => void;
+        "onPageChange"?: (event: PTableFooterCustomEvent<number>) => void;
+        /**
+          * Event whenever the page changes
+         */
+        "onPageSizeChange"?: (event: PTableFooterCustomEvent<number>) => void;
         /**
           * The current page
          */
@@ -1305,135 +3223,152 @@ declare namespace LocalJSX {
           * The amount of items per page
          */
         "pageSize"?: number;
+        /**
+          * The options for the page size
+         */
+        "pageSizeOptions"?: number[];
         /**
           * The total amount of items
          */
         "total": number;
     }
-    interface PPaginationItem {
+    interface PTableHeader {
         /**
-          * Wether the pagination item is active
+          * Active quick filter identifier
          */
-        "active"?: boolean;
-    }
-    interface PProfile {
+        "activeQuickFilterIdentifier"?: string;
         /**
-          * The size of the profile avatar
+          * Wether to enable the edit button
          */
-        "size"?: 'small' | 'medium' | 'large';
+        "canEdit"?: boolean;
         /**
-          * The variant of the profile
+          * The template for the edit button text
          */
-        "variant"?: 'company' | 'user';
-    }
-    interface PSegmentContainer {
-    }
-    interface PSegmentItem {
+        "editButtonTemplate"?: buttonTemplateFunc1;
         /**
-          * Wether the segment item is active
+          * The edit button icon
          */
-        "active"?: boolean;
+        "editIcon"?: IconVariant2;
         /**
-          * Icon to show on the segment item
+          * Wether the edit button is loading
          */
-        "icon"?: IconVariant;
+        "editLoading"?: boolean;
         /**
-          * Icon flip
+          * The edit button text if changed
          */
-        "iconFlip"?: IconFlipOptions;
+        "editText"?: string;
         /**
-          * Icon rotate
+          * Wether to show the edit button
          */
-        "iconRotate"?: RotateOptions;
-    }
-    interface PSliderIndicator {
+        "enableEdit"?: boolean;
         /**
-          * Wether the slider indicator is active
+          * Wether to show the filter button
          */
-        "active"?: boolean;
-    }
-    interface PStatus {
+        "enableFilter"?: boolean;
         /**
-          * Icon to show on the status
+          * Wether to show the search input
          */
-        "icon"?: IconVariant;
+        "enableSearch"?: boolean;
         /**
-          * Icon flip
+          * The template for the filter button text
          */
-        "iconFlip"?: IconFlipOptions;
+        "filterButtonTemplate"?: templateFunc2;
         /**
-          * Icon rotate
+          * The amount of items that are selected
          */
-        "iconRotate"?: RotateOptions;
+        "itemsSelectedAmount"?: number;
         /**
-          * The variant of the status
+          * Wether we want to show loading state
          */
-        "variant"?: 'default' | 'positive' | 'unbiased' | 'negative';
-    }
-    interface PStepper {
+        "loading"?: boolean;
         /**
-          * The currently active step
+          * Event when the edit button is clicked
          */
-        "activeStep"?: number;
+        "onEdit"?: (event: PTableHeaderCustomEvent<null>) => void;
         /**
-          * The direction of the stepper
+          * Event when the filter button is clicked
          */
-        "direction"?: 'horizontal' | 'vertical';
-    }
-    interface PStepperItem {
+        "onFilter"?: (event: PTableHeaderCustomEvent<null>) => void;
         /**
-          * Wether the step is active
+          * Event when the query changes
          */
-        "active"?: boolean;
+        "onQueryChange"?: (event: PTableHeaderCustomEvent<string>) => void;
         /**
-          * The alignment of the step content
+          * Event when one of the quick filters is clicked
          */
-        "align"?: 'start' | 'center' | 'end';
+        "onQuickFilter"?: (event: PTableHeaderCustomEvent<QuickFilter>) => void;
         /**
-          * The direction of the stepper step
+          * The query to show in the search bar
          */
-        "direction"?: 'horizontal' | 'vertical';
+        "query"?: string;
         /**
-          * Wether the step is finished
+          * Quick filters to show
          */
-        "finished"?: boolean;
+        "quickFilters"?: QuickFilter[];
+        /**
+          * The amount of filters being selected
+         */
+        "selectedFiltersAmount"?: number;
     }
-    interface PStepperLine {
+    interface PTableRow {
         /**
-          * Wether the line is active
+          * Enable hover
          */
-        "active"?: boolean;
+        "enableHover"?: boolean;
         /**
-          * The direction of the stepper line
+          * Variant of the header
          */
-        "direction"?: 'horizontal' | 'vertical';
-    }
-    interface PTabGroup {
+        "variant"?: 'default' | 'header';
     }
-    interface PTabItem {
+    interface PToast {
         /**
-          * Wether the tab item is active
+          * Icon to show on the button
          */
-        "active"?: boolean;
-    }
-    interface PTag {
+        "actionIcon"?: IconVariant;
         /**
-          * Wether to add the circle or not
+          * Icon flip
          */
-        "circle"?: boolean;
+        "actionIconFlip"?: IconFlipOptions;
         /**
-          * Variant of the tag
+          * Icon rotate
          */
-        "variant"?: | 'positive'
-        | 'unbiased'
-        | 'negative'
-        | 'info';
+        "actionIconRotate"?: RotateOptions1;
+        /**
+          * The content of the toast
+         */
+        "content"?: string;
+        /**
+          * Wether to enable the close button
+         */
+        "enableAction"?: boolean;
+        /**
+          * The header of the toast
+         */
+        "header"?: string;
+        /**
+          * Button click event
+         */
+        "onAction"?: (event: PToastCustomEvent<MouseEvent>) => void;
+        /**
+          * The variant of the toast
+         */
+        "variant"?: 'positive' | 'unbiased' | 'negative';
+    }
+    interface PToastContainer {
+        /**
+          * The placement of the container
+         */
+        "placement"?: 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end';
     }
     interface PTooltip {
         /**
           * Wether to someone can manually close the popover
          */
         "canManuallyClose"?: boolean;
+        /**
+          * Wether the tooltip can be shown by user input
+         */
+        "enableUserInput"?: boolean;
         /**
           * Open change event
          */
@@ -1453,23 +3388,31 @@ declare namespace LocalJSX {
         /**
           * The strategy of the popover placement
          */
-        "strategy"?: PositioningStrategy;
+        "strategy"?: Strategy;
         /**
           * The variant of the popover
          */
-        "variant"?: 'hover' | 'click' | 'error';
+        "variant"?: 'hover' | 'click' | 'error' | 'error-element';
     }
     interface IntrinsicElements {
         "p-accordion": PAccordion;
+        "p-attachment": PAttachment;
         "p-avatar": PAvatar;
         "p-avatar-group": PAvatarGroup;
+        "p-backdrop": PBackdrop;
         "p-button": PButton;
+        "p-calendar": PCalendar;
         "p-card-body": PCardBody;
         "p-card-container": PCardContainer;
         "p-card-header": PCardHeader;
         "p-content-slider": PContentSlider;
         "p-counter": PCounter;
+        "p-datepicker": PDatepicker;
         "p-divider": PDivider;
+        "p-drawer": PDrawer;
+        "p-drawer-body": PDrawerBody;
+        "p-drawer-container": PDrawerContainer;
+        "p-drawer-header": PDrawerHeader;
         "p-dropdown": PDropdown;
         "p-dropdown-menu-container": PDropdownMenuContainer;
         "p-dropdown-menu-item": PDropdownMenuItem;
@@ -1477,22 +3420,25 @@ declare namespace LocalJSX {
         "p-icon": PIcon;
         "p-illustration": PIllustration;
         "p-info-panel": PInfoPanel;
+        "p-input-error": PInputError;
         "p-input-group": PInputGroup;
+        "p-label": PLabel;
         "p-layout": PLayout;
         "p-loader": PLoader;
         "p-modal": PModal;
-        "p-modal-backdrop": PModalBackdrop;
         "p-modal-body": PModalBody;
         "p-modal-container": PModalContainer;
         "p-modal-footer": PModalFooter;
         "p-modal-header": PModalHeader;
         "p-navbar": PNavbar;
         "p-navigation-item": PNavigationItem;
+        "p-page-size-select": PPageSizeSelect;
         "p-pagination": PPagination;
         "p-pagination-item": PPaginationItem;
         "p-profile": PProfile;
         "p-segment-container": PSegmentContainer;
         "p-segment-item": PSegmentItem;
+        "p-select": PSelect;
         "p-slider-indicator": PSliderIndicator;
         "p-status": PStatus;
         "p-stepper": PStepper;
@@ -1500,7 +3446,15 @@ declare namespace LocalJSX {
         "p-stepper-line": PStepperLine;
         "p-tab-group": PTabGroup;
         "p-tab-item": PTabItem;
-        "p-tag": PTag;
+        "p-table": PTable;
+        "p-table-cell": PTableCell;
+        "p-table-column": PTableColumn;
+        "p-table-container": PTableContainer;
+        "p-table-footer": PTableFooter;
+        "p-table-header": PTableHeader;
+        "p-table-row": PTableRow;
+        "p-toast": PToast;
+        "p-toast-container": PToastContainer;
         "p-tooltip": PTooltip;
     }
 }
@@ -1509,15 +3463,23 @@ declare module "@stencil/core" {
     export namespace JSX {
         interface IntrinsicElements {
             "p-accordion": LocalJSX.PAccordion & JSXBase.HTMLAttributes<HTMLPAccordionElement>;
+            "p-attachment": LocalJSX.PAttachment & JSXBase.HTMLAttributes<HTMLPAttachmentElement>;
             "p-avatar": LocalJSX.PAvatar & JSXBase.HTMLAttributes<HTMLPAvatarElement>;
             "p-avatar-group": LocalJSX.PAvatarGroup & JSXBase.HTMLAttributes<HTMLPAvatarGroupElement>;
+            "p-backdrop": LocalJSX.PBackdrop & JSXBase.HTMLAttributes<HTMLPBackdropElement>;
             "p-button": LocalJSX.PButton & JSXBase.HTMLAttributes<HTMLPButtonElement>;
+            "p-calendar": LocalJSX.PCalendar & JSXBase.HTMLAttributes<HTMLPCalendarElement>;
             "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-content-slider": LocalJSX.PContentSlider & JSXBase.HTMLAttributes<HTMLPContentSliderElement>;
             "p-counter": LocalJSX.PCounter & JSXBase.HTMLAttributes<HTMLPCounterElement>;
+            "p-datepicker": LocalJSX.PDatepicker & JSXBase.HTMLAttributes<HTMLPDatepickerElement>;
             "p-divider": LocalJSX.PDivider & JSXBase.HTMLAttributes<HTMLPDividerElement>;
+            "p-drawer": LocalJSX.PDrawer & JSXBase.HTMLAttributes<HTMLPDrawerElement>;
+            "p-drawer-body": LocalJSX.PDrawerBody & JSXBase.HTMLAttributes<HTMLPDrawerBodyElement>;
+            "p-drawer-container": LocalJSX.PDrawerContainer & JSXBase.HTMLAttributes<HTMLPDrawerContainerElement>;
+            "p-drawer-header": LocalJSX.PDrawerHeader & JSXBase.HTMLAttributes<HTMLPDrawerHeaderElement>;
             "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>;
@@ -1525,22 +3487,25 @@ declare module "@stencil/core" {
             "p-icon": LocalJSX.PIcon & JSXBase.HTMLAttributes<HTMLPIconElement>;
             "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>;
             "p-modal": LocalJSX.PModal & JSXBase.HTMLAttributes<HTMLPModalElement>;
-            "p-modal-backdrop": LocalJSX.PModalBackdrop & JSXBase.HTMLAttributes<HTMLPModalBackdropElement>;
             "p-modal-body": LocalJSX.PModalBody & JSXBase.HTMLAttributes<HTMLPModalBodyElement>;
             "p-modal-container": LocalJSX.PModalContainer & JSXBase.HTMLAttributes<HTMLPModalContainerElement>;
             "p-modal-footer": LocalJSX.PModalFooter & JSXBase.HTMLAttributes<HTMLPModalFooterElement>;
             "p-modal-header": LocalJSX.PModalHeader & JSXBase.HTMLAttributes<HTMLPModalHeaderElement>;
             "p-navbar": LocalJSX.PNavbar & JSXBase.HTMLAttributes<HTMLPNavbarElement>;
             "p-navigation-item": LocalJSX.PNavigationItem & JSXBase.HTMLAttributes<HTMLPNavigationItemElement>;
+            "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-profile": LocalJSX.PProfile & JSXBase.HTMLAttributes<HTMLPProfileElement>;
             "p-segment-container": LocalJSX.PSegmentContainer & JSXBase.HTMLAttributes<HTMLPSegmentContainerElement>;
             "p-segment-item": LocalJSX.PSegmentItem & JSXBase.HTMLAttributes<HTMLPSegmentItemElement>;
+            "p-select": LocalJSX.PSelect & JSXBase.HTMLAttributes<HTMLPSelectElement>;
             "p-slider-indicator": LocalJSX.PSliderIndicator & JSXBase.HTMLAttributes<HTMLPSliderIndicatorElement>;
             "p-status": LocalJSX.PStatus & JSXBase.HTMLAttributes<HTMLPStatusElement>;
             "p-stepper": LocalJSX.PStepper & JSXBase.HTMLAttributes<HTMLPStepperElement>;
@@ -1548,7 +3513,15 @@ declare module "@stencil/core" {
             "p-stepper-line": LocalJSX.PStepperLine & JSXBase.HTMLAttributes<HTMLPStepperLineElement>;
             "p-tab-group": LocalJSX.PTabGroup & JSXBase.HTMLAttributes<HTMLPTabGroupElement>;
             "p-tab-item": LocalJSX.PTabItem & JSXBase.HTMLAttributes<HTMLPTabItemElement>;
-            "p-tag": LocalJSX.PTag & JSXBase.HTMLAttributes<HTMLPTagElement>;
+            "p-table": LocalJSX.PTable & JSXBase.HTMLAttributes<HTMLPTableElement>;
+            "p-table-cell": LocalJSX.PTableCell & JSXBase.HTMLAttributes<HTMLPTableCellElement>;
+            "p-table-column": LocalJSX.PTableColumn & JSXBase.HTMLAttributes<HTMLPTableColumnElement>;
+            "p-table-container": LocalJSX.PTableContainer & JSXBase.HTMLAttributes<HTMLPTableContainerElement>;
+            "p-table-footer": LocalJSX.PTableFooter & JSXBase.HTMLAttributes<HTMLPTableFooterElement>;
+            "p-table-header": LocalJSX.PTableHeader & JSXBase.HTMLAttributes<HTMLPTableHeaderElement>;
+            "p-table-row": LocalJSX.PTableRow & JSXBase.HTMLAttributes<HTMLPTableRowElement>;
+            "p-toast": LocalJSX.PToast & JSXBase.HTMLAttributes<HTMLPToastElement>;
+            "p-toast-container": LocalJSX.PToastContainer & JSXBase.HTMLAttributes<HTMLPToastContainerElement>;
             "p-tooltip": LocalJSX.PTooltip & JSXBase.HTMLAttributes<HTMLPTooltipElement>;
         }
     }