@limetech/lime-elements 39.1.4 → 39.2.1

package/dist/types/components.d.ts

@@ -1748,6 +1748,7 @@ export namespace Components {
      * @exampleComponent limel-example-form-with-help
      * @exampleComponent limel-example-form-row-layout
      * @exampleComponent limel-example-builtin-field-types-form
+     * @exampleComponent limel-example-code-editor-form
      */
     interface LimelForm {
         /**
@@ -4996,6 +4997,7 @@ declare global {
      * @exampleComponent limel-example-form-with-help
      * @exampleComponent limel-example-form-row-layout
      * @exampleComponent limel-example-builtin-field-types-form
+     * @exampleComponent limel-example-code-editor-form
      */
     interface HTMLLimelFormElement extends Components.LimelForm, HTMLStencilElement {
         addEventListener<K extends keyof HTMLLimelFormElementEventMap>(type: K, listener: (this: HTMLLimelFormElement, ev: LimelFormCustomEvent<HTMLLimelFormElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
@@ -6242,6 +6244,8 @@ declare global {
     }
 }
 declare namespace LocalJSX {
+    type OneOf<K extends string, PropT, AttrT = PropT> = { [P in K]: PropT } & { [P in `attr:${K}` | `prop:${K}`]?: never } | { [P in `attr:${K}`]: AttrT } & { [P in K | `prop:${K}`]?: never } | { [P in `prop:${K}`]: PropT } & { [P in K | `attr:${K}`]?: never };
+
     /**
      * This component enhances the visual effects, when the `tiltFollowingTheCursor`
      * utility function from `3d-tilt-hover-effect.ts` is implemented in a component.
@@ -8028,6 +8032,7 @@ declare namespace LocalJSX {
      * @exampleComponent limel-example-form-with-help
      * @exampleComponent limel-example-form-row-layout
      * @exampleComponent limel-example-builtin-field-types-form
+     * @exampleComponent limel-example-code-editor-form
      */
     interface LimelForm {
         /**
@@ -10225,85 +10230,647 @@ declare namespace LocalJSX {
          */
         "maxlength"?: number;
     }
+
+    interface LimelActionBarAttributes {
+        "language": Languages;
+        "accessibleLabel": string;
+        "layout": 'fullWidth' | 'floating';
+        "collapsible": boolean;
+        "openDirection": OpenDirection;
+    }
+    interface LimelActionBarItemAttributes {
+        "isVisible": boolean;
+        "selected": boolean;
+    }
+    interface LimelActionBarOverflowMenuAttributes {
+        "openDirection": OpenDirection;
+    }
+    interface LimelAiAvatarAttributes {
+        "isThinking": boolean;
+        "language": Languages;
+    }
+    interface LimelBadgeAttributes {
+        "label": string;
+    }
+    interface LimelBannerAttributes {
+        "message": string;
+        "icon": string;
+    }
+    interface LimelBreadcrumbsAttributes {
+        "divider": string;
+    }
+    interface LimelButtonAttributes {
+        "label": string;
+        "primary": boolean;
+        "outlined": boolean;
+        "icon": string | Icon;
+        "disabled": boolean;
+        "loading": boolean;
+        "loadingFailed": boolean;
+    }
+    interface LimelButtonGroupAttributes {
+        "disabled": boolean;
+    }
+    interface LimelCalloutAttributes {
+        "heading": string;
+        "icon": string;
+        "type": CalloutType;
+        "language": Languages;
+    }
+    interface LimelCardAttributes {
+        "heading": string;
+        "subheading": string;
+        "icon": string | Icon;
+        "value": string;
+        "clickable": boolean;
+        "orientation": 'landscape' | 'portrait';
+    }
+    interface LimelChartAttributes {
+        "language": Languages;
+        "accessibleLabel": string;
+        "accessibleItemsLabel": string;
+        "accessibleValuesLabel": string;
+        "displayAxisLabels": boolean;
+        "displayItemText": boolean;
+        "displayItemValue": boolean;
+        "type": | 'area'
+        | 'bar'
+        | 'doughnut'
+        | 'line'
+        | 'nps'
+        | 'pie'
+        | 'ring'
+        | 'dot'
+        | 'stacked-bar';
+        "orientation": 'landscape' | 'portrait';
+        "maxValue": number;
+        "axisIncrement": number;
+        "loading": boolean;
+    }
+    interface LimelCheckboxAttributes {
+        "disabled": boolean;
+        "readonly": boolean;
+        "invalid": boolean;
+        "label": string;
+        "helperText": string;
+        "checked": boolean;
+        "indeterminate": boolean;
+        "required": boolean;
+    }
+    interface LimelChipAttributes {
+        "language": Languages;
+        "text": string;
+        "icon": string | Icon;
+        "badge": string;
+        "disabled": boolean;
+        "readonly": boolean;
+        "selected": boolean;
+        "invalid": boolean;
+        "removable": boolean;
+        "type": ChipType;
+        "loading": boolean;
+        "progress": number;
+        "identifier": string;
+        "size": 'small' | 'default';
+    }
+    interface LimelChipSetAttributes {
+        "type": 'choice' | 'filter' | 'input';
+        "label": string;
+        "helperText": string;
+        "disabled": boolean;
+        "readonly": boolean;
+        "invalid": boolean;
+        "inputType": 'search' | 'text';
+        "maxItems": number;
+        "required": boolean;
+        "searchLabel": string;
+        "emptyInputOnBlur": boolean;
+        "clearAllButton": boolean;
+        "leadingIcon": string;
+        "delimiter": string;
+        "autocomplete": string;
+        "language": Languages;
+    }
+    interface LimelCircularProgressAttributes {
+        "value": number;
+        "maxValue": number;
+        "prefix": string;
+        "suffix": string;
+        "displayPercentageColors": boolean;
+        "size": CircularProgressSize;
+    }
+    interface LimelCodeEditorAttributes {
+        "value": string;
+        "language": Language;
+        "readonly": boolean;
+        "disabled": boolean;
+        "invalid": boolean;
+        "required": boolean;
+        "label": string;
+        "helperText": string;
+        "lineNumbers": boolean;
+        "lineWrapping": boolean;
+        "fold": boolean;
+        "lint": boolean;
+        "colorScheme": ColorScheme;
+        "translationLanguage": Languages;
+        "showCopyButton": boolean;
+    }
+    interface LimelCollapsibleSectionAttributes {
+        "isOpen": boolean;
+        "header": string;
+        "icon": string | Icon;
+        "invalid": boolean;
+        "language": Languages;
+    }
+    interface LimelColorPickerAttributes {
+        "value": string;
+        "label": string;
+        "helperText": string;
+        "tooltipLabel": string;
+        "required": boolean;
+        "disabled": boolean;
+        "readonly": boolean;
+        "invalid": boolean;
+        "placeholder": string;
+        "manualInput": boolean;
+        "paletteColumnCount": number;
+    }
+    interface LimelColorPickerPaletteAttributes {
+        "value": string;
+        "label": string;
+        "helperText": string;
+        "placeholder": string;
+        "required": boolean;
+        "invalid": boolean;
+        "manualInput": boolean;
+        "columnCount": number;
+    }
+    interface LimelDatePickerAttributes {
+        "disabled": boolean;
+        "readonly": boolean;
+        "invalid": boolean;
+        "label": string;
+        "placeholder": string;
+        "helperText": string;
+        "required": boolean;
+        "type": DateType;
+        "format": string;
+        "language": Languages;
+    }
+    interface LimelDialogAttributes {
+        "heading": string | DialogHeading;
+        "fullscreen": boolean;
+        "open": boolean;
+    }
+    interface LimelDockAttributes {
+        "accessibleLabel": string;
+        "expanded": boolean;
+        "allowResize": boolean;
+        "mobileBreakPoint": number;
+    }
+    interface LimelDockButtonAttributes {
+        "expanded": boolean;
+        "useMobileLayout": boolean;
+    }
+    interface LimelDragHandleAttributes {
+        "dragDirection": 'vertical' | 'horizontal';
+        "tooltipOpenDirection": OpenDirection;
+        "language": Languages;
+    }
+    interface LimelDynamicLabelAttributes {
+        "value": string;
+    }
+    interface LimelEmailViewerAttributes {
+        "fallbackUrl": string;
+        "language": Languages;
+        "allowRemoteImages": boolean;
+    }
+    interface LimelFileAttributes {
+        "label": string;
+        "required": boolean;
+        "disabled": boolean;
+        "readonly": boolean;
+        "invalid": boolean;
+        "accept": string;
+        "language": Languages;
+    }
+    interface LimelFileDropzoneAttributes {
+        "accept": string;
+        "disabled": boolean;
+        "text": string;
+        "helperText": string;
+    }
+    interface LimelFileInputAttributes {
+        "accept": string;
+        "disabled": boolean;
+        "multiple": boolean;
+    }
+    interface LimelFileViewerAttributes {
+        "url": string;
+        "filename": string;
+        "alt": string;
+        "allowFullscreen": boolean;
+        "allowOpenInNewTab": boolean;
+        "allowDownload": boolean;
+        "language": Languages;
+        "officeViewer": OfficeViewer;
+    }
+    interface LimelFlatpickrAdapterAttributes {
+        "type": DateType;
+        "format": string;
+        "isOpen": boolean;
+        "language": Languages;
+    }
+    interface LimelFlexContainerAttributes {
+        "direction": FlexContainerDirection;
+        "justify": FlexContainerJustify;
+        "align": FlexContainerAlign;
+        "reverse": boolean;
+    }
+    interface LimelFormAttributes {
+        "disabled": boolean;
+    }
+    interface LimelHeaderAttributes {
+        "icon": string | Icon;
+        "heading": string;
+        "subheading": string;
+        "supportingText": string;
+        "subheadingDivider": string;
+    }
+    interface LimelHelpAttributes {
+        "value": string;
+        "trigger": string;
+        "openDirection": OpenDirection;
+    }
+    interface LimelHelpContentAttributes {
+        "value": string;
+    }
+    interface LimelHelperLineAttributes {
+        "helperText": string;
+        "length": number;
+        "maxLength": number;
+        "invalid": boolean;
+        "helperTextId": string;
+    }
+    interface LimelIconAttributes {
+        "size": IconSize;
+        "name": string;
+        "badge": boolean;
+    }
+    interface LimelIconButtonAttributes {
+        "icon": string | Icon;
+        "elevated": boolean;
+        "label": string;
+        "disabled": boolean;
+    }
+    interface LimelInfoTileAttributes {
+        "value": string;
+        "icon": string;
+        "label": string;
+        "prefix": string;
+        "suffix": string;
+        "disabled": boolean;
+        "badge": string;
+        "loading": boolean;
+    }
+    interface LimelInputFieldAttributes {
+        "disabled": boolean;
+        "readonly": boolean;
+        "invalid": boolean;
+        "label": string;
+        "placeholder": string;
+        "helperText": string;
+        "prefix": string;
+        "suffix": string;
+        "required": boolean;
+        "value": string;
+        "trailingIcon": string;
+        "leadingIcon": string;
+        "pattern": string;
+        "type": InputType;
+        "formatNumber": boolean;
+        "step": string;
+        "max": number;
+        "min": number;
+        "maxlength": number;
+        "minlength": number;
+        "showLink": boolean;
+        "locale": string;
+    }
+    interface LimelLinearProgressAttributes {
+        "language": Languages;
+        "value": number;
+        "indeterminate": boolean;
+        "accessibleLabel": string;
+    }
+    interface LimelListAttributes {
+        "badgeIcons": boolean;
+        "iconSize": IconSize;
+        "type": ListType;
+        "maxLinesSecondaryText": number;
+    }
+    interface LimelListItemAttributes {
+        "language": Languages;
+        "value": string;
+        "text": string;
+        "secondaryText": string;
+        "disabled": boolean;
+        "icon": string | ListItem['icon'];
+        "iconSize": IconSize;
+        "badgeIcon": boolean;
+        "selected": boolean;
+        "type": 'listitem' | 'menuitem' | 'option' | 'radio' | 'checkbox';
+    }
+    interface LimelMarkdownAttributes {
+        "value": string;
+        "lazyLoadImages": boolean;
+        "removeEmptyParagraphs": boolean;
+    }
+    interface LimelMenuAttributes {
+        "disabled": boolean;
+        "openDirection": OpenDirection;
+        "surfaceWidth": SurfaceWidth;
+        "open": boolean;
+        "badgeIcons": boolean;
+        "gridLayout": boolean;
+        "searchPlaceholder": string;
+        "emptyResultMessage": string;
+    }
+    interface LimelMenuItemMetaAttributes {
+        "commandText": string;
+        "badge": string;
+        "showChevron": boolean;
+    }
+    interface LimelMenuListAttributes {
+        "badgeIcons": boolean;
+        "iconSize": IconSize;
+    }
+    interface LimelMenuSurfaceAttributes {
+        "open": boolean;
+    }
+    interface LimelNotchedOutlineAttributes {
+        "required": boolean;
+        "readonly": boolean;
+        "invalid": boolean;
+        "disabled": boolean;
+        "label": string;
+        "labelId": string;
+        "hasValue": boolean;
+        "hasLeadingIcon": boolean;
+        "hasFloatingLabel": boolean;
+    }
+    interface LimelPickerAttributes {
+        "disabled": boolean;
+        "readonly": boolean;
+        "label": string;
+        "searchLabel": string;
+        "helperText": string;
+        "leadingIcon": string;
+        "emptyResultMessage": string;
+        "required": boolean;
+        "invalid": boolean;
+        "multiple": boolean;
+        "delimiter": string;
+        "actionPosition": ActionPosition;
+        "actionScrollBehavior": ActionScrollBehavior;
+        "badgeIcons": boolean;
+    }
+    interface LimelPopoverAttributes {
+        "open": boolean;
+        "openDirection": OpenDirection;
+    }
+    interface LimelPortalAttributes {
+        "openDirection": OpenDirection;
+        "position": 'fixed' | 'absolute';
+        "containerId": string;
+        "inheritParentWidth": boolean;
+        "visible": boolean;
+    }
+    interface LimelProfilePictureAttributes {
+        "language": Languages;
+        "label": string;
+        "icon": string | Icon;
+        "helperText": string;
+        "disabled": boolean;
+        "readonly": boolean;
+        "required": boolean;
+        "invalid": boolean;
+        "loading": boolean;
+        "value": string | FileInfo;
+        "imageFit": 'cover' | 'contain';
+        "accept": string;
+    }
+    interface LimelProgressFlowAttributes {
+        "disabled": boolean;
+        "readonly": boolean;
+    }
+    interface LimelProgressFlowItemAttributes {
+        "disabled": boolean;
+        "readonly": boolean;
+        "currentStep": boolean;
+    }
+    interface LimelProsemirrorAdapterAttributes {
+        "contentType": 'markdown' | 'html';
+        "value": string;
+        "language": Languages;
+        "disabled": boolean;
+        "ui": EditorUiType;
+    }
+    interface LimelRadioButtonAttributes {
+        "checked": boolean;
+        "disabled": boolean;
+        "id": string;
+        "label": string;
+    }
+    interface LimelRadioButtonGroupAttributes {
+        "disabled": boolean;
+        "badgeIcons": boolean;
+        "maxLinesSecondaryText": number;
+    }
+    interface LimelSelectAttributes {
+        "disabled": boolean;
+        "readonly": boolean;
+        "invalid": boolean;
+        "required": boolean;
+        "label": string;
+        "helperText": string;
+        "multiple": boolean;
+    }
+    interface LimelShortcutAttributes {
+        "icon": string;
+        "label": string;
+        "disabled": boolean;
+        "badge": string;
+    }
+    interface LimelSliderAttributes {
+        "disabled": boolean;
+        "readonly": boolean;
+        "factor": number;
+        "label": string;
+        "helperText": string;
+        "required": boolean;
+        "invalid": boolean;
+        "displaysPercentageColors": boolean;
+        "unit": string;
+        "value": number;
+        "valuemax": number;
+        "valuemin": number;
+        "step": number;
+    }
+    interface LimelSnackbarAttributes {
+        "open": boolean;
+        "message": string;
+        "timeout": number;
+        "actionText": string;
+        "dismissible": boolean;
+        "multiline": boolean;
+        "language": Languages;
+    }
+    interface LimelSpinnerAttributes {
+        "size": SpinnerSize;
+        "limeBranded": boolean;
+    }
+    interface LimelSplitButtonAttributes {
+        "label": string;
+        "primary": boolean;
+        "icon": string;
+        "disabled": boolean;
+        "loading": boolean;
+        "loadingFailed": boolean;
+    }
+    interface LimelSwitchAttributes {
+        "label": string;
+        "disabled": boolean;
+        "readonly": boolean;
+        "invalid": boolean;
+        "value": boolean;
+        "helperText": string;
+    }
+    interface LimelTableAttributes {
+        "mode": 'local' | 'remote';
+        "layout": Layout;
+        "pageSize": number;
+        "totalRows": number;
+        "movableColumns": boolean;
+        "sortableColumns": boolean;
+        "loading": boolean;
+        "page": number;
+        "emptyMessage": string;
+        "selectable": boolean;
+        "language": Languages;
+        "paginationLocation": 'top' | 'bottom';
+    }
+    interface LimelTextEditorAttributes {
+        "contentType": 'markdown' | 'html';
+        "language": Languages;
+        "disabled": boolean;
+        "readonly": boolean;
+        "helperText": string;
+        "placeholder": string;
+        "label": string;
+        "invalid": boolean;
+        "value": string;
+        "required": boolean;
+        "allowResize": boolean;
+        "ui": EditorUiType;
+    }
+    interface LimelTextEditorLinkMenuAttributes {
+        "language": Languages;
+        "isOpen": boolean;
+    }
+    interface LimelTooltipAttributes {
+        "elementId": string;
+        "label": string;
+        "helperLabel": string;
+        "maxlength": number;
+        "openDirection": OpenDirection;
+    }
+    interface LimelTooltipContentAttributes {
+        "label": string;
+        "helperLabel": string;
+        "maxlength": number;
+    }
+
     interface IntrinsicElements {
         "limel-3d-hover-effect-glow": Limel3dHoverEffectGlow;
-        "limel-action-bar": LimelActionBar;
-        "limel-action-bar-item": LimelActionBarItem;
-        "limel-action-bar-overflow-menu": LimelActionBarOverflowMenu;
-        "limel-ai-avatar": LimelAiAvatar;
-        "limel-badge": LimelBadge;
-        "limel-banner": LimelBanner;
-        "limel-breadcrumbs": LimelBreadcrumbs;
-        "limel-button": LimelButton;
-        "limel-button-group": LimelButtonGroup;
-        "limel-callout": LimelCallout;
-        "limel-card": LimelCard;
-        "limel-chart": LimelChart;
-        "limel-checkbox": LimelCheckbox;
-        "limel-chip": LimelChip;
-        "limel-chip-set": LimelChipSet;
-        "limel-circular-progress": LimelCircularProgress;
-        "limel-code-editor": LimelCodeEditor;
-        "limel-collapsible-section": LimelCollapsibleSection;
-        "limel-color-picker": LimelColorPicker;
-        "limel-color-picker-palette": LimelColorPickerPalette;
+        "limel-action-bar": Omit<LimelActionBar, keyof LimelActionBarAttributes> & { [K in keyof LimelActionBar & keyof LimelActionBarAttributes]?: LimelActionBar[K] } & { [K in keyof LimelActionBar & keyof LimelActionBarAttributes as `attr:${K}`]?: LimelActionBarAttributes[K] } & { [K in keyof LimelActionBar & keyof LimelActionBarAttributes as `prop:${K}`]?: LimelActionBar[K] };
+        "limel-action-bar-item": Omit<LimelActionBarItem, keyof LimelActionBarItemAttributes> & { [K in keyof LimelActionBarItem & keyof LimelActionBarItemAttributes]?: LimelActionBarItem[K] } & { [K in keyof LimelActionBarItem & keyof LimelActionBarItemAttributes as `attr:${K}`]?: LimelActionBarItemAttributes[K] } & { [K in keyof LimelActionBarItem & keyof LimelActionBarItemAttributes as `prop:${K}`]?: LimelActionBarItem[K] };
+        "limel-action-bar-overflow-menu": Omit<LimelActionBarOverflowMenu, keyof LimelActionBarOverflowMenuAttributes> & { [K in keyof LimelActionBarOverflowMenu & keyof LimelActionBarOverflowMenuAttributes]?: LimelActionBarOverflowMenu[K] } & { [K in keyof LimelActionBarOverflowMenu & keyof LimelActionBarOverflowMenuAttributes as `attr:${K}`]?: LimelActionBarOverflowMenuAttributes[K] } & { [K in keyof LimelActionBarOverflowMenu & keyof LimelActionBarOverflowMenuAttributes as `prop:${K}`]?: LimelActionBarOverflowMenu[K] };
+        "limel-ai-avatar": Omit<LimelAiAvatar, keyof LimelAiAvatarAttributes> & { [K in keyof LimelAiAvatar & keyof LimelAiAvatarAttributes]?: LimelAiAvatar[K] } & { [K in keyof LimelAiAvatar & keyof LimelAiAvatarAttributes as `attr:${K}`]?: LimelAiAvatarAttributes[K] } & { [K in keyof LimelAiAvatar & keyof LimelAiAvatarAttributes as `prop:${K}`]?: LimelAiAvatar[K] };
+        "limel-badge": Omit<LimelBadge, keyof LimelBadgeAttributes> & { [K in keyof LimelBadge & keyof LimelBadgeAttributes]?: LimelBadge[K] } & { [K in keyof LimelBadge & keyof LimelBadgeAttributes as `attr:${K}`]?: LimelBadgeAttributes[K] } & { [K in keyof LimelBadge & keyof LimelBadgeAttributes as `prop:${K}`]?: LimelBadge[K] };
+        "limel-banner": Omit<LimelBanner, keyof LimelBannerAttributes> & { [K in keyof LimelBanner & keyof LimelBannerAttributes]?: LimelBanner[K] } & { [K in keyof LimelBanner & keyof LimelBannerAttributes as `attr:${K}`]?: LimelBannerAttributes[K] } & { [K in keyof LimelBanner & keyof LimelBannerAttributes as `prop:${K}`]?: LimelBanner[K] };
+        "limel-breadcrumbs": Omit<LimelBreadcrumbs, keyof LimelBreadcrumbsAttributes> & { [K in keyof LimelBreadcrumbs & keyof LimelBreadcrumbsAttributes]?: LimelBreadcrumbs[K] } & { [K in keyof LimelBreadcrumbs & keyof LimelBreadcrumbsAttributes as `attr:${K}`]?: LimelBreadcrumbsAttributes[K] } & { [K in keyof LimelBreadcrumbs & keyof LimelBreadcrumbsAttributes as `prop:${K}`]?: LimelBreadcrumbs[K] };
+        "limel-button": Omit<LimelButton, keyof LimelButtonAttributes> & { [K in keyof LimelButton & keyof LimelButtonAttributes]?: LimelButton[K] } & { [K in keyof LimelButton & keyof LimelButtonAttributes as `attr:${K}`]?: LimelButtonAttributes[K] } & { [K in keyof LimelButton & keyof LimelButtonAttributes as `prop:${K}`]?: LimelButton[K] };
+        "limel-button-group": Omit<LimelButtonGroup, keyof LimelButtonGroupAttributes> & { [K in keyof LimelButtonGroup & keyof LimelButtonGroupAttributes]?: LimelButtonGroup[K] } & { [K in keyof LimelButtonGroup & keyof LimelButtonGroupAttributes as `attr:${K}`]?: LimelButtonGroupAttributes[K] } & { [K in keyof LimelButtonGroup & keyof LimelButtonGroupAttributes as `prop:${K}`]?: LimelButtonGroup[K] };
+        "limel-callout": Omit<LimelCallout, keyof LimelCalloutAttributes> & { [K in keyof LimelCallout & keyof LimelCalloutAttributes]?: LimelCallout[K] } & { [K in keyof LimelCallout & keyof LimelCalloutAttributes as `attr:${K}`]?: LimelCalloutAttributes[K] } & { [K in keyof LimelCallout & keyof LimelCalloutAttributes as `prop:${K}`]?: LimelCallout[K] };
+        "limel-card": Omit<LimelCard, keyof LimelCardAttributes> & { [K in keyof LimelCard & keyof LimelCardAttributes]?: LimelCard[K] } & { [K in keyof LimelCard & keyof LimelCardAttributes as `attr:${K}`]?: LimelCardAttributes[K] } & { [K in keyof LimelCard & keyof LimelCardAttributes as `prop:${K}`]?: LimelCard[K] };
+        "limel-chart": Omit<LimelChart, keyof LimelChartAttributes> & { [K in keyof LimelChart & keyof LimelChartAttributes]?: LimelChart[K] } & { [K in keyof LimelChart & keyof LimelChartAttributes as `attr:${K}`]?: LimelChartAttributes[K] } & { [K in keyof LimelChart & keyof LimelChartAttributes as `prop:${K}`]?: LimelChart[K] };
+        "limel-checkbox": Omit<LimelCheckbox, keyof LimelCheckboxAttributes> & { [K in keyof LimelCheckbox & keyof LimelCheckboxAttributes]?: LimelCheckbox[K] } & { [K in keyof LimelCheckbox & keyof LimelCheckboxAttributes as `attr:${K}`]?: LimelCheckboxAttributes[K] } & { [K in keyof LimelCheckbox & keyof LimelCheckboxAttributes as `prop:${K}`]?: LimelCheckbox[K] };
+        "limel-chip": Omit<LimelChip, keyof LimelChipAttributes> & { [K in keyof LimelChip & keyof LimelChipAttributes]?: LimelChip[K] } & { [K in keyof LimelChip & keyof LimelChipAttributes as `attr:${K}`]?: LimelChipAttributes[K] } & { [K in keyof LimelChip & keyof LimelChipAttributes as `prop:${K}`]?: LimelChip[K] };
+        "limel-chip-set": Omit<LimelChipSet, keyof LimelChipSetAttributes> & { [K in keyof LimelChipSet & keyof LimelChipSetAttributes]?: LimelChipSet[K] } & { [K in keyof LimelChipSet & keyof LimelChipSetAttributes as `attr:${K}`]?: LimelChipSetAttributes[K] } & { [K in keyof LimelChipSet & keyof LimelChipSetAttributes as `prop:${K}`]?: LimelChipSet[K] };
+        "limel-circular-progress": Omit<LimelCircularProgress, keyof LimelCircularProgressAttributes> & { [K in keyof LimelCircularProgress & keyof LimelCircularProgressAttributes]?: LimelCircularProgress[K] } & { [K in keyof LimelCircularProgress & keyof LimelCircularProgressAttributes as `attr:${K}`]?: LimelCircularProgressAttributes[K] } & { [K in keyof LimelCircularProgress & keyof LimelCircularProgressAttributes as `prop:${K}`]?: LimelCircularProgress[K] };
+        "limel-code-editor": Omit<LimelCodeEditor, keyof LimelCodeEditorAttributes> & { [K in keyof LimelCodeEditor & keyof LimelCodeEditorAttributes]?: LimelCodeEditor[K] } & { [K in keyof LimelCodeEditor & keyof LimelCodeEditorAttributes as `attr:${K}`]?: LimelCodeEditorAttributes[K] } & { [K in keyof LimelCodeEditor & keyof LimelCodeEditorAttributes as `prop:${K}`]?: LimelCodeEditor[K] };
+        "limel-collapsible-section": Omit<LimelCollapsibleSection, keyof LimelCollapsibleSectionAttributes> & { [K in keyof LimelCollapsibleSection & keyof LimelCollapsibleSectionAttributes]?: LimelCollapsibleSection[K] } & { [K in keyof LimelCollapsibleSection & keyof LimelCollapsibleSectionAttributes as `attr:${K}`]?: LimelCollapsibleSectionAttributes[K] } & { [K in keyof LimelCollapsibleSection & keyof LimelCollapsibleSectionAttributes as `prop:${K}`]?: LimelCollapsibleSection[K] };
+        "limel-color-picker": Omit<LimelColorPicker, keyof LimelColorPickerAttributes> & { [K in keyof LimelColorPicker & keyof LimelColorPickerAttributes]?: LimelColorPicker[K] } & { [K in keyof LimelColorPicker & keyof LimelColorPickerAttributes as `attr:${K}`]?: LimelColorPickerAttributes[K] } & { [K in keyof LimelColorPicker & keyof LimelColorPickerAttributes as `prop:${K}`]?: LimelColorPicker[K] };
+        "limel-color-picker-palette": Omit<LimelColorPickerPalette, keyof LimelColorPickerPaletteAttributes> & { [K in keyof LimelColorPickerPalette & keyof LimelColorPickerPaletteAttributes]?: LimelColorPickerPalette[K] } & { [K in keyof LimelColorPickerPalette & keyof LimelColorPickerPaletteAttributes as `attr:${K}`]?: LimelColorPickerPaletteAttributes[K] } & { [K in keyof LimelColorPickerPalette & keyof LimelColorPickerPaletteAttributes as `prop:${K}`]?: LimelColorPickerPalette[K] };
         "limel-config": LimelConfig;
-        "limel-date-picker": LimelDatePicker;
-        "limel-dialog": LimelDialog;
-        "limel-dock": LimelDock;
-        "limel-dock-button": LimelDockButton;
-        "limel-drag-handle": LimelDragHandle;
-        "limel-dynamic-label": LimelDynamicLabel;
-        "limel-email-viewer": LimelEmailViewer;
-        "limel-file": LimelFile;
-        "limel-file-dropzone": LimelFileDropzone;
-        "limel-file-input": LimelFileInput;
-        "limel-file-viewer": LimelFileViewer;
-        "limel-flatpickr-adapter": LimelFlatpickrAdapter;
-        "limel-flex-container": LimelFlexContainer;
-        "limel-form": LimelForm;
+        "limel-date-picker": Omit<LimelDatePicker, keyof LimelDatePickerAttributes> & { [K in keyof LimelDatePicker & keyof LimelDatePickerAttributes]?: LimelDatePicker[K] } & { [K in keyof LimelDatePicker & keyof LimelDatePickerAttributes as `attr:${K}`]?: LimelDatePickerAttributes[K] } & { [K in keyof LimelDatePicker & keyof LimelDatePickerAttributes as `prop:${K}`]?: LimelDatePicker[K] };
+        "limel-dialog": Omit<LimelDialog, keyof LimelDialogAttributes> & { [K in keyof LimelDialog & keyof LimelDialogAttributes]?: LimelDialog[K] } & { [K in keyof LimelDialog & keyof LimelDialogAttributes as `attr:${K}`]?: LimelDialogAttributes[K] } & { [K in keyof LimelDialog & keyof LimelDialogAttributes as `prop:${K}`]?: LimelDialog[K] };
+        "limel-dock": Omit<LimelDock, keyof LimelDockAttributes> & { [K in keyof LimelDock & keyof LimelDockAttributes]?: LimelDock[K] } & { [K in keyof LimelDock & keyof LimelDockAttributes as `attr:${K}`]?: LimelDockAttributes[K] } & { [K in keyof LimelDock & keyof LimelDockAttributes as `prop:${K}`]?: LimelDock[K] };
+        "limel-dock-button": Omit<LimelDockButton, keyof LimelDockButtonAttributes> & { [K in keyof LimelDockButton & keyof LimelDockButtonAttributes]?: LimelDockButton[K] } & { [K in keyof LimelDockButton & keyof LimelDockButtonAttributes as `attr:${K}`]?: LimelDockButtonAttributes[K] } & { [K in keyof LimelDockButton & keyof LimelDockButtonAttributes as `prop:${K}`]?: LimelDockButton[K] };
+        "limel-drag-handle": Omit<LimelDragHandle, keyof LimelDragHandleAttributes> & { [K in keyof LimelDragHandle & keyof LimelDragHandleAttributes]?: LimelDragHandle[K] } & { [K in keyof LimelDragHandle & keyof LimelDragHandleAttributes as `attr:${K}`]?: LimelDragHandleAttributes[K] } & { [K in keyof LimelDragHandle & keyof LimelDragHandleAttributes as `prop:${K}`]?: LimelDragHandle[K] };
+        "limel-dynamic-label": Omit<LimelDynamicLabel, keyof LimelDynamicLabelAttributes> & { [K in keyof LimelDynamicLabel & keyof LimelDynamicLabelAttributes]?: LimelDynamicLabel[K] } & { [K in keyof LimelDynamicLabel & keyof LimelDynamicLabelAttributes as `attr:${K}`]?: LimelDynamicLabelAttributes[K] } & { [K in keyof LimelDynamicLabel & keyof LimelDynamicLabelAttributes as `prop:${K}`]?: LimelDynamicLabel[K] };
+        "limel-email-viewer": Omit<LimelEmailViewer, keyof LimelEmailViewerAttributes> & { [K in keyof LimelEmailViewer & keyof LimelEmailViewerAttributes]?: LimelEmailViewer[K] } & { [K in keyof LimelEmailViewer & keyof LimelEmailViewerAttributes as `attr:${K}`]?: LimelEmailViewerAttributes[K] } & { [K in keyof LimelEmailViewer & keyof LimelEmailViewerAttributes as `prop:${K}`]?: LimelEmailViewer[K] };
+        "limel-file": Omit<LimelFile, keyof LimelFileAttributes> & { [K in keyof LimelFile & keyof LimelFileAttributes]?: LimelFile[K] } & { [K in keyof LimelFile & keyof LimelFileAttributes as `attr:${K}`]?: LimelFileAttributes[K] } & { [K in keyof LimelFile & keyof LimelFileAttributes as `prop:${K}`]?: LimelFile[K] };
+        "limel-file-dropzone": Omit<LimelFileDropzone, keyof LimelFileDropzoneAttributes> & { [K in keyof LimelFileDropzone & keyof LimelFileDropzoneAttributes]?: LimelFileDropzone[K] } & { [K in keyof LimelFileDropzone & keyof LimelFileDropzoneAttributes as `attr:${K}`]?: LimelFileDropzoneAttributes[K] } & { [K in keyof LimelFileDropzone & keyof LimelFileDropzoneAttributes as `prop:${K}`]?: LimelFileDropzone[K] };
+        "limel-file-input": Omit<LimelFileInput, keyof LimelFileInputAttributes> & { [K in keyof LimelFileInput & keyof LimelFileInputAttributes]?: LimelFileInput[K] } & { [K in keyof LimelFileInput & keyof LimelFileInputAttributes as `attr:${K}`]?: LimelFileInputAttributes[K] } & { [K in keyof LimelFileInput & keyof LimelFileInputAttributes as `prop:${K}`]?: LimelFileInput[K] };
+        "limel-file-viewer": Omit<LimelFileViewer, keyof LimelFileViewerAttributes> & { [K in keyof LimelFileViewer & keyof LimelFileViewerAttributes]?: LimelFileViewer[K] } & { [K in keyof LimelFileViewer & keyof LimelFileViewerAttributes as `attr:${K}`]?: LimelFileViewerAttributes[K] } & { [K in keyof LimelFileViewer & keyof LimelFileViewerAttributes as `prop:${K}`]?: LimelFileViewer[K] };
+        "limel-flatpickr-adapter": Omit<LimelFlatpickrAdapter, keyof LimelFlatpickrAdapterAttributes> & { [K in keyof LimelFlatpickrAdapter & keyof LimelFlatpickrAdapterAttributes]?: LimelFlatpickrAdapter[K] } & { [K in keyof LimelFlatpickrAdapter & keyof LimelFlatpickrAdapterAttributes as `attr:${K}`]?: LimelFlatpickrAdapterAttributes[K] } & { [K in keyof LimelFlatpickrAdapter & keyof LimelFlatpickrAdapterAttributes as `prop:${K}`]?: LimelFlatpickrAdapter[K] };
+        "limel-flex-container": Omit<LimelFlexContainer, keyof LimelFlexContainerAttributes> & { [K in keyof LimelFlexContainer & keyof LimelFlexContainerAttributes]?: LimelFlexContainer[K] } & { [K in keyof LimelFlexContainer & keyof LimelFlexContainerAttributes as `attr:${K}`]?: LimelFlexContainerAttributes[K] } & { [K in keyof LimelFlexContainer & keyof LimelFlexContainerAttributes as `prop:${K}`]?: LimelFlexContainer[K] };
+        "limel-form": Omit<LimelForm, keyof LimelFormAttributes> & { [K in keyof LimelForm & keyof LimelFormAttributes]?: LimelForm[K] } & { [K in keyof LimelForm & keyof LimelFormAttributes as `attr:${K}`]?: LimelFormAttributes[K] } & { [K in keyof LimelForm & keyof LimelFormAttributes as `prop:${K}`]?: LimelForm[K] };
         "limel-grid": LimelGrid;
-        "limel-header": LimelHeader;
-        "limel-help": LimelHelp;
-        "limel-help-content": LimelHelpContent;
-        "limel-helper-line": LimelHelperLine;
-        "limel-icon": LimelIcon;
-        "limel-icon-button": LimelIconButton;
-        "limel-info-tile": LimelInfoTile;
-        "limel-input-field": LimelInputField;
-        "limel-linear-progress": LimelLinearProgress;
-        "limel-list": LimelList;
-        "limel-list-item": LimelListItem;
-        "limel-markdown": LimelMarkdown;
-        "limel-menu": LimelMenu;
-        "limel-menu-item-meta": LimelMenuItemMeta;
-        "limel-menu-list": LimelMenuList;
-        "limel-menu-surface": LimelMenuSurface;
-        "limel-notched-outline": LimelNotchedOutline;
-        "limel-picker": LimelPicker;
-        "limel-popover": LimelPopover;
+        "limel-header": Omit<LimelHeader, keyof LimelHeaderAttributes> & { [K in keyof LimelHeader & keyof LimelHeaderAttributes]?: LimelHeader[K] } & { [K in keyof LimelHeader & keyof LimelHeaderAttributes as `attr:${K}`]?: LimelHeaderAttributes[K] } & { [K in keyof LimelHeader & keyof LimelHeaderAttributes as `prop:${K}`]?: LimelHeader[K] };
+        "limel-help": Omit<LimelHelp, keyof LimelHelpAttributes> & { [K in keyof LimelHelp & keyof LimelHelpAttributes]?: LimelHelp[K] } & { [K in keyof LimelHelp & keyof LimelHelpAttributes as `attr:${K}`]?: LimelHelpAttributes[K] } & { [K in keyof LimelHelp & keyof LimelHelpAttributes as `prop:${K}`]?: LimelHelp[K] };
+        "limel-help-content": Omit<LimelHelpContent, keyof LimelHelpContentAttributes> & { [K in keyof LimelHelpContent & keyof LimelHelpContentAttributes]?: LimelHelpContent[K] } & { [K in keyof LimelHelpContent & keyof LimelHelpContentAttributes as `attr:${K}`]?: LimelHelpContentAttributes[K] } & { [K in keyof LimelHelpContent & keyof LimelHelpContentAttributes as `prop:${K}`]?: LimelHelpContent[K] };
+        "limel-helper-line": Omit<LimelHelperLine, keyof LimelHelperLineAttributes> & { [K in keyof LimelHelperLine & keyof LimelHelperLineAttributes]?: LimelHelperLine[K] } & { [K in keyof LimelHelperLine & keyof LimelHelperLineAttributes as `attr:${K}`]?: LimelHelperLineAttributes[K] } & { [K in keyof LimelHelperLine & keyof LimelHelperLineAttributes as `prop:${K}`]?: LimelHelperLine[K] };
+        "limel-icon": Omit<LimelIcon, keyof LimelIconAttributes> & { [K in keyof LimelIcon & keyof LimelIconAttributes]?: LimelIcon[K] } & { [K in keyof LimelIcon & keyof LimelIconAttributes as `attr:${K}`]?: LimelIconAttributes[K] } & { [K in keyof LimelIcon & keyof LimelIconAttributes as `prop:${K}`]?: LimelIcon[K] };
+        "limel-icon-button": Omit<LimelIconButton, keyof LimelIconButtonAttributes> & { [K in keyof LimelIconButton & keyof LimelIconButtonAttributes]?: LimelIconButton[K] } & { [K in keyof LimelIconButton & keyof LimelIconButtonAttributes as `attr:${K}`]?: LimelIconButtonAttributes[K] } & { [K in keyof LimelIconButton & keyof LimelIconButtonAttributes as `prop:${K}`]?: LimelIconButton[K] };
+        "limel-info-tile": Omit<LimelInfoTile, keyof LimelInfoTileAttributes> & { [K in keyof LimelInfoTile & keyof LimelInfoTileAttributes]?: LimelInfoTile[K] } & { [K in keyof LimelInfoTile & keyof LimelInfoTileAttributes as `attr:${K}`]?: LimelInfoTileAttributes[K] } & { [K in keyof LimelInfoTile & keyof LimelInfoTileAttributes as `prop:${K}`]?: LimelInfoTile[K] };
+        "limel-input-field": Omit<LimelInputField, keyof LimelInputFieldAttributes> & { [K in keyof LimelInputField & keyof LimelInputFieldAttributes]?: LimelInputField[K] } & { [K in keyof LimelInputField & keyof LimelInputFieldAttributes as `attr:${K}`]?: LimelInputFieldAttributes[K] } & { [K in keyof LimelInputField & keyof LimelInputFieldAttributes as `prop:${K}`]?: LimelInputField[K] };
+        "limel-linear-progress": Omit<LimelLinearProgress, keyof LimelLinearProgressAttributes> & { [K in keyof LimelLinearProgress & keyof LimelLinearProgressAttributes]?: LimelLinearProgress[K] } & { [K in keyof LimelLinearProgress & keyof LimelLinearProgressAttributes as `attr:${K}`]?: LimelLinearProgressAttributes[K] } & { [K in keyof LimelLinearProgress & keyof LimelLinearProgressAttributes as `prop:${K}`]?: LimelLinearProgress[K] };
+        "limel-list": Omit<LimelList, keyof LimelListAttributes> & { [K in keyof LimelList & keyof LimelListAttributes]?: LimelList[K] } & { [K in keyof LimelList & keyof LimelListAttributes as `attr:${K}`]?: LimelListAttributes[K] } & { [K in keyof LimelList & keyof LimelListAttributes as `prop:${K}`]?: LimelList[K] };
+        "limel-list-item": Omit<LimelListItem, keyof LimelListItemAttributes> & { [K in keyof LimelListItem & keyof LimelListItemAttributes]?: LimelListItem[K] } & { [K in keyof LimelListItem & keyof LimelListItemAttributes as `attr:${K}`]?: LimelListItemAttributes[K] } & { [K in keyof LimelListItem & keyof LimelListItemAttributes as `prop:${K}`]?: LimelListItem[K] };
+        "limel-markdown": Omit<LimelMarkdown, keyof LimelMarkdownAttributes> & { [K in keyof LimelMarkdown & keyof LimelMarkdownAttributes]?: LimelMarkdown[K] } & { [K in keyof LimelMarkdown & keyof LimelMarkdownAttributes as `attr:${K}`]?: LimelMarkdownAttributes[K] } & { [K in keyof LimelMarkdown & keyof LimelMarkdownAttributes as `prop:${K}`]?: LimelMarkdown[K] };
+        "limel-menu": Omit<LimelMenu, keyof LimelMenuAttributes> & { [K in keyof LimelMenu & keyof LimelMenuAttributes]?: LimelMenu[K] } & { [K in keyof LimelMenu & keyof LimelMenuAttributes as `attr:${K}`]?: LimelMenuAttributes[K] } & { [K in keyof LimelMenu & keyof LimelMenuAttributes as `prop:${K}`]?: LimelMenu[K] };
+        "limel-menu-item-meta": Omit<LimelMenuItemMeta, keyof LimelMenuItemMetaAttributes> & { [K in keyof LimelMenuItemMeta & keyof LimelMenuItemMetaAttributes]?: LimelMenuItemMeta[K] } & { [K in keyof LimelMenuItemMeta & keyof LimelMenuItemMetaAttributes as `attr:${K}`]?: LimelMenuItemMetaAttributes[K] } & { [K in keyof LimelMenuItemMeta & keyof LimelMenuItemMetaAttributes as `prop:${K}`]?: LimelMenuItemMeta[K] };
+        "limel-menu-list": Omit<LimelMenuList, keyof LimelMenuListAttributes> & { [K in keyof LimelMenuList & keyof LimelMenuListAttributes]?: LimelMenuList[K] } & { [K in keyof LimelMenuList & keyof LimelMenuListAttributes as `attr:${K}`]?: LimelMenuListAttributes[K] } & { [K in keyof LimelMenuList & keyof LimelMenuListAttributes as `prop:${K}`]?: LimelMenuList[K] };
+        "limel-menu-surface": Omit<LimelMenuSurface, keyof LimelMenuSurfaceAttributes> & { [K in keyof LimelMenuSurface & keyof LimelMenuSurfaceAttributes]?: LimelMenuSurface[K] } & { [K in keyof LimelMenuSurface & keyof LimelMenuSurfaceAttributes as `attr:${K}`]?: LimelMenuSurfaceAttributes[K] } & { [K in keyof LimelMenuSurface & keyof LimelMenuSurfaceAttributes as `prop:${K}`]?: LimelMenuSurface[K] };
+        "limel-notched-outline": Omit<LimelNotchedOutline, keyof LimelNotchedOutlineAttributes> & { [K in keyof LimelNotchedOutline & keyof LimelNotchedOutlineAttributes]?: LimelNotchedOutline[K] } & { [K in keyof LimelNotchedOutline & keyof LimelNotchedOutlineAttributes as `attr:${K}`]?: LimelNotchedOutlineAttributes[K] } & { [K in keyof LimelNotchedOutline & keyof LimelNotchedOutlineAttributes as `prop:${K}`]?: LimelNotchedOutline[K] };
+        "limel-picker": Omit<LimelPicker, keyof LimelPickerAttributes> & { [K in keyof LimelPicker & keyof LimelPickerAttributes]?: LimelPicker[K] } & { [K in keyof LimelPicker & keyof LimelPickerAttributes as `attr:${K}`]?: LimelPickerAttributes[K] } & { [K in keyof LimelPicker & keyof LimelPickerAttributes as `prop:${K}`]?: LimelPicker[K] };
+        "limel-popover": Omit<LimelPopover, keyof LimelPopoverAttributes> & { [K in keyof LimelPopover & keyof LimelPopoverAttributes]?: LimelPopover[K] } & { [K in keyof LimelPopover & keyof LimelPopoverAttributes as `attr:${K}`]?: LimelPopoverAttributes[K] } & { [K in keyof LimelPopover & keyof LimelPopoverAttributes as `prop:${K}`]?: LimelPopover[K] };
         "limel-popover-surface": LimelPopoverSurface;
-        "limel-portal": LimelPortal;
-        "limel-profile-picture": LimelProfilePicture;
-        "limel-progress-flow": LimelProgressFlow;
-        "limel-progress-flow-item": LimelProgressFlowItem;
-        "limel-prosemirror-adapter": LimelProsemirrorAdapter;
-        "limel-radio-button": LimelRadioButton;
-        "limel-radio-button-group": LimelRadioButtonGroup;
-        "limel-select": LimelSelect;
-        "limel-shortcut": LimelShortcut;
-        "limel-slider": LimelSlider;
-        "limel-snackbar": LimelSnackbar;
-        "limel-spinner": LimelSpinner;
-        "limel-split-button": LimelSplitButton;
-        "limel-switch": LimelSwitch;
+        "limel-portal": Omit<LimelPortal, keyof LimelPortalAttributes> & { [K in keyof LimelPortal & keyof LimelPortalAttributes]?: LimelPortal[K] } & { [K in keyof LimelPortal & keyof LimelPortalAttributes as `attr:${K}`]?: LimelPortalAttributes[K] } & { [K in keyof LimelPortal & keyof LimelPortalAttributes as `prop:${K}`]?: LimelPortal[K] };
+        "limel-profile-picture": Omit<LimelProfilePicture, keyof LimelProfilePictureAttributes> & { [K in keyof LimelProfilePicture & keyof LimelProfilePictureAttributes]?: LimelProfilePicture[K] } & { [K in keyof LimelProfilePicture & keyof LimelProfilePictureAttributes as `attr:${K}`]?: LimelProfilePictureAttributes[K] } & { [K in keyof LimelProfilePicture & keyof LimelProfilePictureAttributes as `prop:${K}`]?: LimelProfilePicture[K] };
+        "limel-progress-flow": Omit<LimelProgressFlow, keyof LimelProgressFlowAttributes> & { [K in keyof LimelProgressFlow & keyof LimelProgressFlowAttributes]?: LimelProgressFlow[K] } & { [K in keyof LimelProgressFlow & keyof LimelProgressFlowAttributes as `attr:${K}`]?: LimelProgressFlowAttributes[K] } & { [K in keyof LimelProgressFlow & keyof LimelProgressFlowAttributes as `prop:${K}`]?: LimelProgressFlow[K] };
+        "limel-progress-flow-item": Omit<LimelProgressFlowItem, keyof LimelProgressFlowItemAttributes> & { [K in keyof LimelProgressFlowItem & keyof LimelProgressFlowItemAttributes]?: LimelProgressFlowItem[K] } & { [K in keyof LimelProgressFlowItem & keyof LimelProgressFlowItemAttributes as `attr:${K}`]?: LimelProgressFlowItemAttributes[K] } & { [K in keyof LimelProgressFlowItem & keyof LimelProgressFlowItemAttributes as `prop:${K}`]?: LimelProgressFlowItem[K] };
+        "limel-prosemirror-adapter": Omit<LimelProsemirrorAdapter, keyof LimelProsemirrorAdapterAttributes> & { [K in keyof LimelProsemirrorAdapter & keyof LimelProsemirrorAdapterAttributes]?: LimelProsemirrorAdapter[K] } & { [K in keyof LimelProsemirrorAdapter & keyof LimelProsemirrorAdapterAttributes as `attr:${K}`]?: LimelProsemirrorAdapterAttributes[K] } & { [K in keyof LimelProsemirrorAdapter & keyof LimelProsemirrorAdapterAttributes as `prop:${K}`]?: LimelProsemirrorAdapter[K] };
+        "limel-radio-button": Omit<LimelRadioButton, keyof LimelRadioButtonAttributes> & { [K in keyof LimelRadioButton & keyof LimelRadioButtonAttributes]?: LimelRadioButton[K] } & { [K in keyof LimelRadioButton & keyof LimelRadioButtonAttributes as `attr:${K}`]?: LimelRadioButtonAttributes[K] } & { [K in keyof LimelRadioButton & keyof LimelRadioButtonAttributes as `prop:${K}`]?: LimelRadioButton[K] } & OneOf<"id", LimelRadioButton["id"], LimelRadioButtonAttributes["id"]>;
+        "limel-radio-button-group": Omit<LimelRadioButtonGroup, keyof LimelRadioButtonGroupAttributes> & { [K in keyof LimelRadioButtonGroup & keyof LimelRadioButtonGroupAttributes]?: LimelRadioButtonGroup[K] } & { [K in keyof LimelRadioButtonGroup & keyof LimelRadioButtonGroupAttributes as `attr:${K}`]?: LimelRadioButtonGroupAttributes[K] } & { [K in keyof LimelRadioButtonGroup & keyof LimelRadioButtonGroupAttributes as `prop:${K}`]?: LimelRadioButtonGroup[K] };
+        "limel-select": Omit<LimelSelect, keyof LimelSelectAttributes> & { [K in keyof LimelSelect & keyof LimelSelectAttributes]?: LimelSelect[K] } & { [K in keyof LimelSelect & keyof LimelSelectAttributes as `attr:${K}`]?: LimelSelectAttributes[K] } & { [K in keyof LimelSelect & keyof LimelSelectAttributes as `prop:${K}`]?: LimelSelect[K] };
+        "limel-shortcut": Omit<LimelShortcut, keyof LimelShortcutAttributes> & { [K in keyof LimelShortcut & keyof LimelShortcutAttributes]?: LimelShortcut[K] } & { [K in keyof LimelShortcut & keyof LimelShortcutAttributes as `attr:${K}`]?: LimelShortcutAttributes[K] } & { [K in keyof LimelShortcut & keyof LimelShortcutAttributes as `prop:${K}`]?: LimelShortcut[K] };
+        "limel-slider": Omit<LimelSlider, keyof LimelSliderAttributes> & { [K in keyof LimelSlider & keyof LimelSliderAttributes]?: LimelSlider[K] } & { [K in keyof LimelSlider & keyof LimelSliderAttributes as `attr:${K}`]?: LimelSliderAttributes[K] } & { [K in keyof LimelSlider & keyof LimelSliderAttributes as `prop:${K}`]?: LimelSlider[K] };
+        "limel-snackbar": Omit<LimelSnackbar, keyof LimelSnackbarAttributes> & { [K in keyof LimelSnackbar & keyof LimelSnackbarAttributes]?: LimelSnackbar[K] } & { [K in keyof LimelSnackbar & keyof LimelSnackbarAttributes as `attr:${K}`]?: LimelSnackbarAttributes[K] } & { [K in keyof LimelSnackbar & keyof LimelSnackbarAttributes as `prop:${K}`]?: LimelSnackbar[K] };
+        "limel-spinner": Omit<LimelSpinner, keyof LimelSpinnerAttributes> & { [K in keyof LimelSpinner & keyof LimelSpinnerAttributes]?: LimelSpinner[K] } & { [K in keyof LimelSpinner & keyof LimelSpinnerAttributes as `attr:${K}`]?: LimelSpinnerAttributes[K] } & { [K in keyof LimelSpinner & keyof LimelSpinnerAttributes as `prop:${K}`]?: LimelSpinner[K] };
+        "limel-split-button": Omit<LimelSplitButton, keyof LimelSplitButtonAttributes> & { [K in keyof LimelSplitButton & keyof LimelSplitButtonAttributes]?: LimelSplitButton[K] } & { [K in keyof LimelSplitButton & keyof LimelSplitButtonAttributes as `attr:${K}`]?: LimelSplitButtonAttributes[K] } & { [K in keyof LimelSplitButton & keyof LimelSplitButtonAttributes as `prop:${K}`]?: LimelSplitButton[K] };
+        "limel-switch": Omit<LimelSwitch, keyof LimelSwitchAttributes> & { [K in keyof LimelSwitch & keyof LimelSwitchAttributes]?: LimelSwitch[K] } & { [K in keyof LimelSwitch & keyof LimelSwitchAttributes as `attr:${K}`]?: LimelSwitchAttributes[K] } & { [K in keyof LimelSwitch & keyof LimelSwitchAttributes as `prop:${K}`]?: LimelSwitch[K] };
         "limel-tab-bar": LimelTabBar;
         "limel-tab-panel": LimelTabPanel;
-        "limel-table": LimelTable;
-        "limel-text-editor": LimelTextEditor;
-        "limel-text-editor-link-menu": LimelTextEditorLinkMenu;
-        "limel-tooltip": LimelTooltip;
-        "limel-tooltip-content": LimelTooltipContent;
+        "limel-table": Omit<LimelTable, keyof LimelTableAttributes> & { [K in keyof LimelTable & keyof LimelTableAttributes]?: LimelTable[K] } & { [K in keyof LimelTable & keyof LimelTableAttributes as `attr:${K}`]?: LimelTableAttributes[K] } & { [K in keyof LimelTable & keyof LimelTableAttributes as `prop:${K}`]?: LimelTable[K] };
+        "limel-text-editor": Omit<LimelTextEditor, keyof LimelTextEditorAttributes> & { [K in keyof LimelTextEditor & keyof LimelTextEditorAttributes]?: LimelTextEditor[K] } & { [K in keyof LimelTextEditor & keyof LimelTextEditorAttributes as `attr:${K}`]?: LimelTextEditorAttributes[K] } & { [K in keyof LimelTextEditor & keyof LimelTextEditorAttributes as `prop:${K}`]?: LimelTextEditor[K] };
+        "limel-text-editor-link-menu": Omit<LimelTextEditorLinkMenu, keyof LimelTextEditorLinkMenuAttributes> & { [K in keyof LimelTextEditorLinkMenu & keyof LimelTextEditorLinkMenuAttributes]?: LimelTextEditorLinkMenu[K] } & { [K in keyof LimelTextEditorLinkMenu & keyof LimelTextEditorLinkMenuAttributes as `attr:${K}`]?: LimelTextEditorLinkMenuAttributes[K] } & { [K in keyof LimelTextEditorLinkMenu & keyof LimelTextEditorLinkMenuAttributes as `prop:${K}`]?: LimelTextEditorLinkMenu[K] };
+        "limel-tooltip": Omit<LimelTooltip, keyof LimelTooltipAttributes> & { [K in keyof LimelTooltip & keyof LimelTooltipAttributes]?: LimelTooltip[K] } & { [K in keyof LimelTooltip & keyof LimelTooltipAttributes as `attr:${K}`]?: LimelTooltipAttributes[K] } & { [K in keyof LimelTooltip & keyof LimelTooltipAttributes as `prop:${K}`]?: LimelTooltip[K] } & OneOf<"elementId", LimelTooltip["elementId"], LimelTooltipAttributes["elementId"]> & OneOf<"label", LimelTooltip["label"], LimelTooltipAttributes["label"]>;
+        "limel-tooltip-content": Omit<LimelTooltipContent, keyof LimelTooltipContentAttributes> & { [K in keyof LimelTooltipContent & keyof LimelTooltipContentAttributes]?: LimelTooltipContent[K] } & { [K in keyof LimelTooltipContent & keyof LimelTooltipContentAttributes as `attr:${K}`]?: LimelTooltipContentAttributes[K] } & { [K in keyof LimelTooltipContent & keyof LimelTooltipContentAttributes as `prop:${K}`]?: LimelTooltipContent[K] } & OneOf<"label", LimelTooltipContent["label"], LimelTooltipContentAttributes["label"]>;
     }
 }
 export { LocalJSX as JSX };
@@ -10321,7 +10888,7 @@ declare module "@stencil/core" {
              * affect parts of the styles of this 3D glow effect.
              * @private 
              */
-            "limel-3d-hover-effect-glow": LocalJSX.Limel3dHoverEffectGlow & JSXBase.HTMLAttributes<HTMLLimel3dHoverEffectGlowElement>;
+            "limel-3d-hover-effect-glow": LocalJSX.IntrinsicElements["limel-3d-hover-effect-glow"] & JSXBase.HTMLAttributes<HTMLLimel3dHoverEffectGlowElement>;
             /**
              * An action bar is a user interface element commonly found in software applications and websites.
              * It typically appears at the top of the screen or within a specific section
@@ -10346,15 +10913,15 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-action-bar-as-primary-component
              * @exampleComponent limel-example-action-bar-icon-title
              */
-            "limel-action-bar": LocalJSX.LimelActionBar & JSXBase.HTMLAttributes<HTMLLimelActionBarElement>;
+            "limel-action-bar": LocalJSX.IntrinsicElements["limel-action-bar"] & JSXBase.HTMLAttributes<HTMLLimelActionBarElement>;
             /**
              * @private 
              */
-            "limel-action-bar-item": LocalJSX.LimelActionBarItem & JSXBase.HTMLAttributes<HTMLLimelActionBarItemElement>;
+            "limel-action-bar-item": LocalJSX.IntrinsicElements["limel-action-bar-item"] & JSXBase.HTMLAttributes<HTMLLimelActionBarItemElement>;
             /**
              * @private 
              */
-            "limel-action-bar-overflow-menu": LocalJSX.LimelActionBarOverflowMenu & JSXBase.HTMLAttributes<HTMLLimelActionBarOverflowMenuElement>;
+            "limel-action-bar-overflow-menu": LocalJSX.IntrinsicElements["limel-action-bar-overflow-menu"] & JSXBase.HTMLAttributes<HTMLLimelActionBarOverflowMenuElement>;
             /**
              * This component displays an avatar, representing Lime AI assistants.
              * :::warning
@@ -10369,7 +10936,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-ai-avatar-white-background
              * @exampleComponent limel-example-ai-avatar-color-props
              */
-            "limel-ai-avatar": LocalJSX.LimelAiAvatar & JSXBase.HTMLAttributes<HTMLLimelAiAvatarElement>;
+            "limel-ai-avatar": LocalJSX.IntrinsicElements["limel-ai-avatar"] & JSXBase.HTMLAttributes<HTMLLimelAiAvatarElement>;
             /**
              * The Badge component can be used to display a notification badge,
              * optionally with a number or a text label.
@@ -10377,11 +10944,11 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-badge-number
              * @exampleComponent limel-example-badge-string
              */
-            "limel-badge": LocalJSX.LimelBadge & JSXBase.HTMLAttributes<HTMLLimelBadgeElement>;
+            "limel-badge": LocalJSX.IntrinsicElements["limel-badge"] & JSXBase.HTMLAttributes<HTMLLimelBadgeElement>;
             /**
              * @exampleComponent limel-example-banner
              */
-            "limel-banner": LocalJSX.LimelBanner & JSXBase.HTMLAttributes<HTMLLimelBannerElement>;
+            "limel-banner": LocalJSX.IntrinsicElements["limel-banner"] & JSXBase.HTMLAttributes<HTMLLimelBannerElement>;
             /**
              * A Breadcrumb consists of a list of distinct "places" that a user has gone through,
              * before ending up where they are right now, in a website or an application.
@@ -10404,7 +10971,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-breadcrumbs-icon-color
              * @exampleComponent limel-example-breadcrumbs-styling
              */
-            "limel-breadcrumbs": LocalJSX.LimelBreadcrumbs & JSXBase.HTMLAttributes<HTMLLimelBreadcrumbsElement>;
+            "limel-breadcrumbs": LocalJSX.IntrinsicElements["limel-breadcrumbs"] & JSXBase.HTMLAttributes<HTMLLimelBreadcrumbsElement>;
             /**
              * @exampleComponent limel-example-button-basic
              * @exampleComponent limel-example-button-primary
@@ -10418,7 +10985,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-button-colors
              * @exampleComponent limel-example-button-composite
              */
-            "limel-button": LocalJSX.LimelButton & JSXBase.HTMLAttributes<HTMLLimelButtonElement>;
+            "limel-button": LocalJSX.IntrinsicElements["limel-button"] & JSXBase.HTMLAttributes<HTMLLimelButtonElement>;
             /**
              * A button group control is a linear set of two or more buttons.
              * ## Usage
@@ -10448,7 +11015,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-button-group-badges
              * @exampleComponent limel-example-button-group-composite
              */
-            "limel-button-group": LocalJSX.LimelButtonGroup & JSXBase.HTMLAttributes<HTMLLimelButtonGroupElement>;
+            "limel-button-group": LocalJSX.IntrinsicElements["limel-button-group"] & JSXBase.HTMLAttributes<HTMLLimelButtonGroupElement>;
             /**
              * Callouts—also known as Admonitions—are useful for including supportive or
              * special content within a large piece of text, or even inside a user
@@ -10474,7 +11041,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-custom-type
              * @exampleComponent limel-example-callout-composite
              */
-            "limel-callout": LocalJSX.LimelCallout & JSXBase.HTMLAttributes<HTMLLimelCalloutElement>;
+            "limel-callout": LocalJSX.IntrinsicElements["limel-callout"] & JSXBase.HTMLAttributes<HTMLLimelCalloutElement>;
             /**
              * Card is a component that displays content about a single topic,
              * in a structured way. It can contain a header, and some supporting media such
@@ -10488,7 +11055,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-card-styling
              * @exampleComponent limel-example-card-scrollable-shadow
              */
-            "limel-card": LocalJSX.LimelCard & JSXBase.HTMLAttributes<HTMLLimelCardElement>;
+            "limel-card": LocalJSX.IntrinsicElements["limel-card"] & JSXBase.HTMLAttributes<HTMLLimelCardElement>;
             /**
              * A chart is a graphical representation of data, in which
              * visual symbols such as such bars, dots, lines, or slices, represent
@@ -10516,7 +11083,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-chart-creative-styling
              * @beta 
              */
-            "limel-chart": LocalJSX.LimelChart & JSXBase.HTMLAttributes<HTMLLimelChartElement>;
+            "limel-chart": LocalJSX.IntrinsicElements["limel-chart"] & JSXBase.HTMLAttributes<HTMLLimelChartElement>;
             /**
              * The Checkbox component is a classic and essential element in UI design that allows
              * users to make multiple selections from a predefined list of options. The Checkbox component is commonly used in forms and settings interfaces to enable users to
@@ -10537,7 +11104,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-checkbox-helper-text
              * @exampleComponent limel-example-checkbox-readonly
              */
-            "limel-checkbox": LocalJSX.LimelCheckbox & JSXBase.HTMLAttributes<HTMLLimelCheckboxElement>;
+            "limel-checkbox": LocalJSX.IntrinsicElements["limel-checkbox"] & JSXBase.HTMLAttributes<HTMLLimelCheckboxElement>;
             /**
              * Chips and buttons are both interactive elements in UI design,
              * but they serve different purposes and are used in different contexts.
@@ -10579,7 +11146,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-chip-readonly-border
              * @exampleComponent limel-example-chip-aria-role
              */
-            "limel-chip": LocalJSX.LimelChip & JSXBase.HTMLAttributes<HTMLLimelChipElement>;
+            "limel-chip": LocalJSX.IntrinsicElements["limel-chip"] & JSXBase.HTMLAttributes<HTMLLimelChipElement>;
             /**
              * :::note
              * **Regarding `click` and `interact` events:**
@@ -10618,7 +11185,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-chip-set-image
              * @exampleComponent limel-example-chip-set-composite
              */
-            "limel-chip-set": LocalJSX.LimelChipSet & JSXBase.HTMLAttributes<HTMLLimelChipSetElement>;
+            "limel-chip-set": LocalJSX.IntrinsicElements["limel-chip-set"] & JSXBase.HTMLAttributes<HTMLLimelChipSetElement>;
             /**
              * The circular progress component can be used to visualize the curent state of
              * a progress in a scale; for example percentage of completion of a task.
@@ -10639,7 +11206,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-circular-progress-css-variables
              * @exampleComponent limel-example-circular-progress-percentage-colors
              */
-            "limel-circular-progress": LocalJSX.LimelCircularProgress & JSXBase.HTMLAttributes<HTMLLimelCircularProgressElement>;
+            "limel-circular-progress": LocalJSX.IntrinsicElements["limel-circular-progress"] & JSXBase.HTMLAttributes<HTMLLimelCircularProgressElement>;
             /**
              * @exampleComponent limel-example-code-editor
              * @exampleComponent limel-example-code-editor-readonly-with-line-numbers
@@ -10647,7 +11214,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-code-editor-copy
              * @exampleComponent limel-example-code-editor-composite
              */
-            "limel-code-editor": LocalJSX.LimelCodeEditor & JSXBase.HTMLAttributes<HTMLLimelCodeEditorElement>;
+            "limel-code-editor": LocalJSX.IntrinsicElements["limel-code-editor"] & JSXBase.HTMLAttributes<HTMLLimelCodeEditorElement>;
             /**
              * A collapsible section can be used to group related content together
              * and hide the group when not needed.
@@ -10665,7 +11232,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-collapsible-section-icon
              * @exampleComponent limel-example-collapsible-section-css-props
              */
-            "limel-collapsible-section": LocalJSX.LimelCollapsibleSection & JSXBase.HTMLAttributes<HTMLLimelCollapsibleSectionElement>;
+            "limel-collapsible-section": LocalJSX.IntrinsicElements["limel-collapsible-section"] & JSXBase.HTMLAttributes<HTMLLimelCollapsibleSectionElement>;
             /**
              * This component enables you to select a swatch from out color palette, simply
              * by clicking on it. You can then copy the css variable name of the chosen color
@@ -10679,11 +11246,11 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-color-picker-manual-input
              * @exampleComponent limel-example-color-picker-composite
              */
-            "limel-color-picker": LocalJSX.LimelColorPicker & JSXBase.HTMLAttributes<HTMLLimelColorPickerElement>;
+            "limel-color-picker": LocalJSX.IntrinsicElements["limel-color-picker"] & JSXBase.HTMLAttributes<HTMLLimelColorPickerElement>;
             /**
              * @private 
              */
-            "limel-color-picker-palette": LocalJSX.LimelColorPickerPalette & JSXBase.HTMLAttributes<HTMLLimelColorPickerPaletteElement>;
+            "limel-color-picker-palette": LocalJSX.IntrinsicElements["limel-color-picker-palette"] & JSXBase.HTMLAttributes<HTMLLimelColorPickerPaletteElement>;
             /**
              * Component used to set global configuration for Lime Elements.
              * :::warning
@@ -10696,7 +11263,7 @@ declare module "@stencil/core" {
              * Then you _might_ need to use this component.
              * @private 
              */
-            "limel-config": LocalJSX.LimelConfig & JSXBase.HTMLAttributes<HTMLLimelConfigElement>;
+            "limel-config": LocalJSX.IntrinsicElements["limel-config"] & JSXBase.HTMLAttributes<HTMLLimelConfigElement>;
             /**
              * @exampleComponent limel-example-date-picker-datetime
              * @exampleComponent limel-example-date-picker-date
@@ -10710,7 +11277,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-date-picker-composite
              * @exampleComponent limel-example-date-picker-custom-formatter
              */
-            "limel-date-picker": LocalJSX.LimelDatePicker & JSXBase.HTMLAttributes<HTMLLimelDatePickerElement>;
+            "limel-date-picker": LocalJSX.IntrinsicElements["limel-date-picker"] & JSXBase.HTMLAttributes<HTMLLimelDatePickerElement>;
             /**
              * :::note
              * Regarding the `close` event: When putting other elements that emit `close`
@@ -10735,7 +11302,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-dialog-closing-actions
              * @exampleComponent limel-example-dialog-action-buttons
              */
-            "limel-dialog": LocalJSX.LimelDialog & JSXBase.HTMLAttributes<HTMLLimelDialogElement>;
+            "limel-dialog": LocalJSX.IntrinsicElements["limel-dialog"] & JSXBase.HTMLAttributes<HTMLLimelDialogElement>;
             /**
              * @exampleComponent limel-example-dock-basic
              * @exampleComponent limel-example-dock-custom-component
@@ -10744,11 +11311,11 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-dock-expanded
              * @exampleComponent limel-example-dock-colors-css
              */
-            "limel-dock": LocalJSX.LimelDock & JSXBase.HTMLAttributes<HTMLLimelDockElement>;
+            "limel-dock": LocalJSX.IntrinsicElements["limel-dock"] & JSXBase.HTMLAttributes<HTMLLimelDockElement>;
             /**
              * @private 
              */
-            "limel-dock-button": LocalJSX.LimelDockButton & JSXBase.HTMLAttributes<HTMLLimelDockButtonElement>;
+            "limel-dock-button": LocalJSX.IntrinsicElements["limel-dock-button"] & JSXBase.HTMLAttributes<HTMLLimelDockButtonElement>;
             /**
              * This component resembles a drag handle button, but is implemented
              * as a `private` component to allow for easier styling and future extensions.
@@ -10768,7 +11335,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-drag-handle-horizontal
              * @private 
              */
-            "limel-drag-handle": LocalJSX.LimelDragHandle & JSXBase.HTMLAttributes<HTMLLimelDragHandleElement>;
+            "limel-drag-handle": LocalJSX.IntrinsicElements["limel-drag-handle"] & JSXBase.HTMLAttributes<HTMLLimelDragHandleElement>;
             /**
              * This components displays a different label depending on the current given
              * value. A label can consist of a text and an optional icon. If no matching
@@ -10782,7 +11349,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-dynamic-label
              * @exampleComponent limel-example-dynamic-label-readonly-boolean
              */
-            "limel-dynamic-label": LocalJSX.LimelDynamicLabel & JSXBase.HTMLAttributes<HTMLLimelDynamicLabelElement>;
+            "limel-dynamic-label": LocalJSX.IntrinsicElements["limel-dynamic-label"] & JSXBase.HTMLAttributes<HTMLLimelDynamicLabelElement>;
             /**
              * This is a private component, used to render `.eml` files inside
              * `limel-file-viewer`.
@@ -10795,7 +11362,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-email-viewer-remote-image-policy
              * @private 
              */
-            "limel-email-viewer": LocalJSX.LimelEmailViewer & JSXBase.HTMLAttributes<HTMLLimelEmailViewerElement>;
+            "limel-email-viewer": LocalJSX.IntrinsicElements["limel-email-viewer"] & JSXBase.HTMLAttributes<HTMLLimelEmailViewerElement>;
             /**
              * This component lets end-users select a *single* file from their device
              * storage. Regardless of the user's device or operating system, this component
@@ -10824,7 +11391,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-file-accepted-types
              * @exampleComponent limel-example-file-composite
              */
-            "limel-file": LocalJSX.LimelFile & JSXBase.HTMLAttributes<HTMLLimelFileElement>;
+            "limel-file": LocalJSX.IntrinsicElements["limel-file"] & JSXBase.HTMLAttributes<HTMLLimelFileElement>;
             /**
              * This component enables you to seamlessly convert any region of the user interface into
              * a file dropzone area, just by wrapping it inside the `limel-file-dropzone`.
@@ -10838,7 +11405,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-file-dropzone-type-filtering
              * @private 
              */
-            "limel-file-dropzone": LocalJSX.LimelFileDropzone & JSXBase.HTMLAttributes<HTMLLimelFileDropzoneElement>;
+            "limel-file-dropzone": LocalJSX.IntrinsicElements["limel-file-dropzone"] & JSXBase.HTMLAttributes<HTMLLimelFileDropzoneElement>;
             /**
              * This component enables you to seamlessly transform any other clickable component that
              * generates a `click` event into a file input selector.
@@ -10852,7 +11419,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-file-input-type-filtering
              * @private 
              */
-            "limel-file-input": LocalJSX.LimelFileInput & JSXBase.HTMLAttributes<HTMLLimelFileInputElement>;
+            "limel-file-input": LocalJSX.IntrinsicElements["limel-file-input"] & JSXBase.HTMLAttributes<HTMLLimelFileInputElement>;
             /**
              * This is a smart component that automatically detects
              * the most common file types such as image, audio, video, and text,
@@ -10879,14 +11446,14 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-file-viewer-with-picker
              * @beta 
              */
-            "limel-file-viewer": LocalJSX.LimelFileViewer & JSXBase.HTMLAttributes<HTMLLimelFileViewerElement>;
+            "limel-file-viewer": LocalJSX.IntrinsicElements["limel-file-viewer"] & JSXBase.HTMLAttributes<HTMLLimelFileViewerElement>;
             /**
              * This component is internal and only supposed to be used by
              * the limel-date-picker. This component is needed in order for us
              * to render the flatpickr calendar in a portal.
              * @private 
              */
-            "limel-flatpickr-adapter": LocalJSX.LimelFlatpickrAdapter & JSXBase.HTMLAttributes<HTMLLimelFlatpickrAdapterElement>;
+            "limel-flatpickr-adapter": LocalJSX.IntrinsicElements["limel-flatpickr-adapter"] & JSXBase.HTMLAttributes<HTMLLimelFlatpickrAdapterElement>;
             /**
              * This component is deprecated and will be removed in a future version of
              * Lime Elements. Please use CSS for your flexible container needs 🙂
@@ -10894,7 +11461,7 @@ declare module "@stencil/core" {
              * @deprecated - Please use CSS instead https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Flexible_Box_Layout/Basic_Concepts_of_Flexbox
              * @private 
              */
-            "limel-flex-container": LocalJSX.LimelFlexContainer & JSXBase.HTMLAttributes<HTMLLimelFlexContainerElement>;
+            "limel-flex-container": LocalJSX.IntrinsicElements["limel-flex-container"] & JSXBase.HTMLAttributes<HTMLLimelFlexContainerElement>;
             /**
              * @exampleComponent limel-example-form
              * @exampleComponent limel-example-nested-form
@@ -10910,15 +11477,16 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-form-with-help
              * @exampleComponent limel-example-form-row-layout
              * @exampleComponent limel-example-builtin-field-types-form
+             * @exampleComponent limel-example-code-editor-form
              */
-            "limel-form": LocalJSX.LimelForm & JSXBase.HTMLAttributes<HTMLLimelFormElement>;
+            "limel-form": LocalJSX.IntrinsicElements["limel-form"] & JSXBase.HTMLAttributes<HTMLLimelFormElement>;
             /**
              * This component is deprecated and will be removed in a future version of
              * Lime Elements. Please use CSS for your flexible container needs 🙂
              * @deprecated Please use CSS instead https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_grid_layout
              * @private 
              */
-            "limel-grid": LocalJSX.LimelGrid & JSXBase.HTMLAttributes<HTMLLimelGridElement>;
+            "limel-grid": LocalJSX.IntrinsicElements["limel-grid"] & JSXBase.HTMLAttributes<HTMLLimelGridElement>;
             /**
              * A header is the top most visual element in a component, page, card, or a view.
              * ## Usage
@@ -10957,7 +11525,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-header-responsive
              * @exampleComponent limel-example-header-narrow
              */
-            "limel-header": LocalJSX.LimelHeader & JSXBase.HTMLAttributes<HTMLLimelHeaderElement>;
+            "limel-header": LocalJSX.IntrinsicElements["limel-header"] & JSXBase.HTMLAttributes<HTMLLimelHeaderElement>;
             /**
              * A good design is self-explanatory! However, sometimes concepts are
              * too complex to understand, no matter how well-designed a user interface is.
@@ -10976,7 +11544,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-open-direction
              * @exampleComponent limel-example-placement
              */
-            "limel-help": LocalJSX.LimelHelp & JSXBase.HTMLAttributes<HTMLLimelHelpElement>;
+            "limel-help": LocalJSX.IntrinsicElements["limel-help"] & JSXBase.HTMLAttributes<HTMLLimelHelpElement>;
             /**
              * Help content
              * This is scrollable content that is placed in the popover of the Help component.
@@ -10985,7 +11553,7 @@ declare module "@stencil/core" {
              * child component.
              * @private 
              */
-            "limel-help-content": LocalJSX.LimelHelpContent & JSXBase.HTMLAttributes<HTMLLimelHelpContentElement>;
+            "limel-help-content": LocalJSX.IntrinsicElements["limel-help-content"] & JSXBase.HTMLAttributes<HTMLLimelHelpContentElement>;
             /**
              * This is an internal and private component that many input fields
              * use to display a helper text, along with a character counter below the
@@ -11003,7 +11571,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-helper-line-animation
              * @private 
              */
-            "limel-helper-line": LocalJSX.LimelHelperLine & JSXBase.HTMLAttributes<HTMLLimelHelperLineElement>;
+            "limel-helper-line": LocalJSX.IntrinsicElements["limel-helper-line"] & JSXBase.HTMLAttributes<HTMLLimelHelperLineElement>;
             /**
              * :::important
              * To install your icon set correctly, please read the [documentation here](#/).
@@ -11014,7 +11582,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-icon-size
              * @exampleComponent limel-example-icon-color
              */
-            "limel-icon": LocalJSX.LimelIcon & JSXBase.HTMLAttributes<HTMLLimelIconElement>;
+            "limel-icon": LocalJSX.IntrinsicElements["limel-icon"] & JSXBase.HTMLAttributes<HTMLLimelIconElement>;
             /**
              * @exampleComponent limel-example-icon-button-basic
              * @exampleComponent limel-example-icon-button-disabled
@@ -11023,7 +11591,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-icon-button-icon
              * @exampleComponent limel-example-icon-button-composite
              */
-            "limel-icon-button": LocalJSX.LimelIconButton & JSXBase.HTMLAttributes<HTMLLimelIconButtonElement>;
+            "limel-icon-button": LocalJSX.IntrinsicElements["limel-icon-button"] & JSXBase.HTMLAttributes<HTMLLimelIconButtonElement>;
             /**
              * This component can be used on places such as a start page or a dashboard.
              * It offers features for visualizing aggregated data along with supplementary
@@ -11038,7 +11606,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-info-tile-primary-slot
              * @exampleComponent limel-example-info-tile-styling
              */
-            "limel-info-tile": LocalJSX.LimelInfoTile & JSXBase.HTMLAttributes<HTMLLimelInfoTileElement>;
+            "limel-info-tile": LocalJSX.IntrinsicElements["limel-info-tile"] & JSXBase.HTMLAttributes<HTMLLimelInfoTileElement>;
             /**
              * @exampleComponent limel-example-input-field-text
              * @exampleComponent limel-example-input-field-placeholder
@@ -11058,7 +11626,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-input-field-focus
              * @exampleComponent limel-example-input-field-selection
              */
-            "limel-input-field": LocalJSX.LimelInputField & JSXBase.HTMLAttributes<HTMLLimelInputFieldElement>;
+            "limel-input-field": LocalJSX.IntrinsicElements["limel-input-field"] & JSXBase.HTMLAttributes<HTMLLimelInputFieldElement>;
             /**
              * The linear progress component can be used to visualize the current state of a progress in a scale;
              * for example percentage of completion of a task.
@@ -11067,7 +11635,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-linear-progress-accessible-label
              * @exampleComponent limel-example-linear-progress-color
              */
-            "limel-linear-progress": LocalJSX.LimelLinearProgress & JSXBase.HTMLAttributes<HTMLLimelLinearProgressElement>;
+            "limel-linear-progress": LocalJSX.IntrinsicElements["limel-linear-progress"] & JSXBase.HTMLAttributes<HTMLLimelLinearProgressElement>;
             /**
              * @exampleComponent limel-example-list
              * @exampleComponent limel-example-list-secondary
@@ -11084,7 +11652,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-list-grid
              * @exampleComponent limel-example-list-primary-component
              */
-            "limel-list": LocalJSX.LimelList & JSXBase.HTMLAttributes<HTMLLimelListElement>;
+            "limel-list": LocalJSX.IntrinsicElements["limel-list"] & JSXBase.HTMLAttributes<HTMLLimelListElement>;
             /**
              * This components displays the list item.
              * This centralizes styles and functionality, and helps reduce redundant code
@@ -11118,7 +11686,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-list-item-command-text
              * @private 
              */
-            "limel-list-item": LocalJSX.LimelListItem & JSXBase.HTMLAttributes<HTMLLimelListItemElement>;
+            "limel-list-item": LocalJSX.IntrinsicElements["limel-list-item"] & JSXBase.HTMLAttributes<HTMLLimelListItemElement>;
             /**
              * The Markdown component receives markdown syntax
              * and renders it as HTML.
@@ -11138,7 +11706,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-markdown-remove-empty-paragraphs
              * @exampleComponent limel-example-markdown-composite
              */
-            "limel-markdown": LocalJSX.LimelMarkdown & JSXBase.HTMLAttributes<HTMLLimelMarkdownElement>;
+            "limel-markdown": LocalJSX.IntrinsicElements["limel-markdown"] & JSXBase.HTMLAttributes<HTMLLimelMarkdownElement>;
             /**
              * @exampleComponent limel-example-menu-basic
              * @exampleComponent limel-example-menu-disabled
@@ -11157,7 +11725,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-menu-searchable
              * @exampleComponent limel-example-menu-composite
              */
-            "limel-menu": LocalJSX.LimelMenu & JSXBase.HTMLAttributes<HTMLLimelMenuElement>;
+            "limel-menu": LocalJSX.IntrinsicElements["limel-menu"] & JSXBase.HTMLAttributes<HTMLLimelMenuElement>;
             /**
              * Meta content for menu list items
              * This sub-component is intended to be passed as `primaryComponent`
@@ -11166,15 +11734,15 @@ declare module "@stencil/core" {
              * features of menu list items.
              * @private 
              */
-            "limel-menu-item-meta": LocalJSX.LimelMenuItemMeta & JSXBase.HTMLAttributes<HTMLLimelMenuItemMetaElement>;
+            "limel-menu-item-meta": LocalJSX.IntrinsicElements["limel-menu-item-meta"] & JSXBase.HTMLAttributes<HTMLLimelMenuItemMetaElement>;
             /**
              * @private 
              */
-            "limel-menu-list": LocalJSX.LimelMenuList & JSXBase.HTMLAttributes<HTMLLimelMenuListElement>;
+            "limel-menu-list": LocalJSX.IntrinsicElements["limel-menu-list"] & JSXBase.HTMLAttributes<HTMLLimelMenuListElement>;
             /**
              * @private 
              */
-            "limel-menu-surface": LocalJSX.LimelMenuSurface & JSXBase.HTMLAttributes<HTMLLimelMenuSurfaceElement>;
+            "limel-menu-surface": LocalJSX.IntrinsicElements["limel-menu-surface"] & JSXBase.HTMLAttributes<HTMLLimelMenuSurfaceElement>;
             /**
              * This is a private component, used to render a notched outline
              * around all input elements that can have a floating label.
@@ -11190,7 +11758,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-notched-outline-basic
              * @private 
              */
-            "limel-notched-outline": LocalJSX.LimelNotchedOutline & JSXBase.HTMLAttributes<HTMLLimelNotchedOutlineElement>;
+            "limel-notched-outline": LocalJSX.IntrinsicElements["limel-notched-outline"] & JSXBase.HTMLAttributes<HTMLLimelNotchedOutlineElement>;
             /**
              * @exampleComponent limel-example-picker-basic
              * @exampleComponent limel-example-picker-multiple
@@ -11203,7 +11771,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-picker-static-actions
              * @exampleComponent limel-example-picker-composite
              */
-            "limel-picker": LocalJSX.LimelPicker & JSXBase.HTMLAttributes<HTMLLimelPickerElement>;
+            "limel-picker": LocalJSX.IntrinsicElements["limel-picker"] & JSXBase.HTMLAttributes<HTMLLimelPickerElement>;
             /**
              * A popover is an impermanent layer that is displayed on top of other content
              * when user taps an element that triggers the popover. This element can be
@@ -11238,11 +11806,11 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-popover-trigger-interaction
              * @exampleComponent limel-example-popover-styling
              */
-            "limel-popover": LocalJSX.LimelPopover & JSXBase.HTMLAttributes<HTMLLimelPopoverElement>;
+            "limel-popover": LocalJSX.IntrinsicElements["limel-popover"] & JSXBase.HTMLAttributes<HTMLLimelPopoverElement>;
             /**
              * @private 
              */
-            "limel-popover-surface": LocalJSX.LimelPopoverSurface & JSXBase.HTMLAttributes<HTMLLimelPopoverSurfaceElement>;
+            "limel-popover-surface": LocalJSX.IntrinsicElements["limel-popover-surface"] & JSXBase.HTMLAttributes<HTMLLimelPopoverSurfaceElement>;
             /**
              * The portal component provides a way to render children into a DOM node that
              * exist outside the DOM hierarchy of the parent component.
@@ -11276,7 +11844,7 @@ declare module "@stencil/core" {
              * @private 
              * @exampleComponent limel-example-portal-basic
              */
-            "limel-portal": LocalJSX.LimelPortal & JSXBase.HTMLAttributes<HTMLLimelPortalElement>;
+            "limel-portal": LocalJSX.IntrinsicElements["limel-portal"] & JSXBase.HTMLAttributes<HTMLLimelPortalElement>;
             /**
              * This component displays a profile picture, while allowing the user
              * to change it via a file input or drag-and-drop.
@@ -11295,7 +11863,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-profile-picture-styling
              * @beta 
              */
-            "limel-profile-picture": LocalJSX.LimelProfilePicture & JSXBase.HTMLAttributes<HTMLLimelProfilePictureElement>;
+            "limel-profile-picture": LocalJSX.IntrinsicElements["limel-profile-picture"] & JSXBase.HTMLAttributes<HTMLLimelProfilePictureElement>;
             /**
              * @exampleComponent limel-example-progress-flow-basic
              * @exampleComponent limel-example-progress-flow-secondary-text
@@ -11305,11 +11873,11 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-progress-flow-off-progress-steps
              * @exampleComponent limel-example-progress-flow-narrow
              */
-            "limel-progress-flow": LocalJSX.LimelProgressFlow & JSXBase.HTMLAttributes<HTMLLimelProgressFlowElement>;
+            "limel-progress-flow": LocalJSX.IntrinsicElements["limel-progress-flow"] & JSXBase.HTMLAttributes<HTMLLimelProgressFlowElement>;
             /**
              * @private 
              */
-            "limel-progress-flow-item": LocalJSX.LimelProgressFlowItem & JSXBase.HTMLAttributes<HTMLLimelProgressFlowItemElement>;
+            "limel-progress-flow-item": LocalJSX.IntrinsicElements["limel-progress-flow-item"] & JSXBase.HTMLAttributes<HTMLLimelProgressFlowItemElement>;
             /**
              * The ProseMirror adapter offers a rich text editing experience with markdown support.
              * [Read more...](https://prosemirror.net/)
@@ -11318,7 +11886,7 @@ declare module "@stencil/core" {
              * @beta 
              * @private 
              */
-            "limel-prosemirror-adapter": LocalJSX.LimelProsemirrorAdapter & JSXBase.HTMLAttributes<HTMLLimelProsemirrorAdapterElement>;
+            "limel-prosemirror-adapter": LocalJSX.IntrinsicElements["limel-prosemirror-adapter"] & JSXBase.HTMLAttributes<HTMLLimelProsemirrorAdapterElement>;
             /**
              * This is a low-level private component that renders individual radio button elements.
              * It's used internally by the list-item component to render radio buttons when
@@ -11341,7 +11909,7 @@ declare module "@stencil/core" {
              * component directly according to in their UI needs.
              * @private 
              */
-            "limel-radio-button": LocalJSX.LimelRadioButton & JSXBase.HTMLAttributes<HTMLLimelRadioButtonElement>;
+            "limel-radio-button": LocalJSX.IntrinsicElements["limel-radio-button"] & JSXBase.HTMLAttributes<HTMLLimelRadioButtonElement>;
             /**
              * The Radio Button component provides a convenient way to create a group of radio buttons
              * from an array of options. Radio buttons allow users to select a single option from
@@ -11356,7 +11924,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-radio-button-group-multiple-lines
              * @beta 
              */
-            "limel-radio-button-group": LocalJSX.LimelRadioButtonGroup & JSXBase.HTMLAttributes<HTMLLimelRadioButtonGroupElement>;
+            "limel-radio-button-group": LocalJSX.IntrinsicElements["limel-radio-button-group"] & JSXBase.HTMLAttributes<HTMLLimelRadioButtonGroupElement>;
             /**
              * @exampleComponent limel-example-select
              * @exampleComponent limel-example-select-with-icons
@@ -11369,7 +11937,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-select-change-options
              * @exampleComponent limel-example-select-dialog
              */
-            "limel-select": LocalJSX.LimelSelect & JSXBase.HTMLAttributes<HTMLLimelSelectElement>;
+            "limel-select": LocalJSX.IntrinsicElements["limel-select"] & JSXBase.HTMLAttributes<HTMLLimelSelectElement>;
             /**
              * This component can be used on places such as a start page or a dashboard.
              * Clicking on the component should navigate the user to a new screen,
@@ -11382,14 +11950,14 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-shortcut-styling
              * @exampleComponent limel-example-shortcut-with-click-handler
              */
-            "limel-shortcut": LocalJSX.LimelShortcut & JSXBase.HTMLAttributes<HTMLLimelShortcutElement>;
+            "limel-shortcut": LocalJSX.IntrinsicElements["limel-shortcut"] & JSXBase.HTMLAttributes<HTMLLimelShortcutElement>;
             /**
              * @exampleComponent limel-example-slider-basic
              * @exampleComponent limel-example-slider-multiplier
              * @exampleComponent limel-example-slider-multiplier-percentage-colors
              * @exampleComponent limel-example-slider-composite
              */
-            "limel-slider": LocalJSX.LimelSlider & JSXBase.HTMLAttributes<HTMLLimelSliderElement>;
+            "limel-slider": LocalJSX.IntrinsicElements["limel-slider"] & JSXBase.HTMLAttributes<HTMLLimelSliderElement>;
             /**
              * A Snackbar –also known as "Toast"– is used to inform the end user
              * about an action or a process in the system.
@@ -11415,13 +11983,13 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-snackbar-persistent
              * @exampleComponent limel-example-snackbar-persistent-non-dismissible
              */
-            "limel-snackbar": LocalJSX.LimelSnackbar & JSXBase.HTMLAttributes<HTMLLimelSnackbarElement>;
+            "limel-snackbar": LocalJSX.IntrinsicElements["limel-snackbar"] & JSXBase.HTMLAttributes<HTMLLimelSnackbarElement>;
             /**
              * @exampleComponent limel-example-spinner
              * @exampleComponent limel-example-spinner-color
              * @exampleComponent limel-example-spinner-size
              */
-            "limel-spinner": LocalJSX.LimelSpinner & JSXBase.HTMLAttributes<HTMLLimelSpinnerElement>;
+            "limel-spinner": LocalJSX.IntrinsicElements["limel-spinner"] & JSXBase.HTMLAttributes<HTMLLimelSpinnerElement>;
             /**
              * A split button is a button with two components:
              * a button and a side-menu attached to it.
@@ -11436,7 +12004,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-split-button-loading
              * @exampleComponent limel-example-split-button-repeat-default-command
              */
-            "limel-split-button": LocalJSX.LimelSplitButton & JSXBase.HTMLAttributes<HTMLLimelSplitButtonElement>;
+            "limel-split-button": LocalJSX.IntrinsicElements["limel-split-button"] & JSXBase.HTMLAttributes<HTMLLimelSplitButtonElement>;
             /**
              * The Switch component is a fundamental element in UI design that serves as a toggle switch
              * to control the state of a specific setting or option in an application or website.
@@ -11452,7 +12020,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-switch-helper-text
              * @exampleComponent limel-example-switch-readonly
              */
-            "limel-switch": LocalJSX.LimelSwitch & JSXBase.HTMLAttributes<HTMLLimelSwitchElement>;
+            "limel-switch": LocalJSX.IntrinsicElements["limel-switch"] & JSXBase.HTMLAttributes<HTMLLimelSwitchElement>;
             /**
              * Tabs are great to organize information hierarchically in the interface and divide it into distinct categories. Using tabs, you can create groups of content that are related and at the same level in the hierarchy.
              * :::warning
@@ -11472,7 +12040,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-tab-bar-with-dynamic-tab-width
              * @exampleComponent limel-example-tab-bar-with-equal-tab-width
              */
-            "limel-tab-bar": LocalJSX.LimelTabBar & JSXBase.HTMLAttributes<HTMLLimelTabBarElement>;
+            "limel-tab-bar": LocalJSX.IntrinsicElements["limel-tab-bar"] & JSXBase.HTMLAttributes<HTMLLimelTabBarElement>;
             /**
              * The `limel-tab-panel` component uses the `limel-tab-bar` component together
              * with custom slotted components and will display the content for the currently
@@ -11487,7 +12055,7 @@ declare module "@stencil/core" {
              * inside the actual tab, e.g. to change the icon, color or badge.
              * @exampleComponent limel-example-tab-panel
              */
-            "limel-tab-panel": LocalJSX.LimelTabPanel & JSXBase.HTMLAttributes<HTMLLimelTabPanelElement>;
+            "limel-tab-panel": LocalJSX.IntrinsicElements["limel-tab-panel"] & JSXBase.HTMLAttributes<HTMLLimelTabPanelElement>;
             /**
              * @exampleComponent limel-example-table
              * @exampleComponent limel-example-table-custom-components
@@ -11506,7 +12074,7 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-table-layout-low-density
              * @exampleComponent limel-example-table-interactive-rows
              */
-            "limel-table": LocalJSX.LimelTable & JSXBase.HTMLAttributes<HTMLLimelTableElement>;
+            "limel-table": LocalJSX.IntrinsicElements["limel-table"] & JSXBase.HTMLAttributes<HTMLLimelTableElement>;
             /**
              * A rich text editor that offers a rich text editing experience with markdown support,
              * in the sense that you can easily type markdown syntax and see the rendered
@@ -11529,14 +12097,14 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-text-editor-composite
              * @beta 
              */
-            "limel-text-editor": LocalJSX.LimelTextEditor & JSXBase.HTMLAttributes<HTMLLimelTextEditorElement>;
+            "limel-text-editor": LocalJSX.IntrinsicElements["limel-text-editor"] & JSXBase.HTMLAttributes<HTMLLimelTextEditorElement>;
             /**
              * This component is a menu for editing a link in the text editor.
              * It allows the user to input the text and url for the link.
              * @beta 
              * @private 
              */
-            "limel-text-editor-link-menu": LocalJSX.LimelTextEditorLinkMenu & JSXBase.HTMLAttributes<HTMLLimelTextEditorLinkMenuElement>;
+            "limel-text-editor-link-menu": LocalJSX.IntrinsicElements["limel-text-editor-link-menu"] & JSXBase.HTMLAttributes<HTMLLimelTextEditorLinkMenuElement>;
             /**
              * A tooltip can be used to display a descriptive text for any element.
              * The displayed content must be a brief and supplemental string of text,
@@ -11576,12 +12144,12 @@ declare module "@stencil/core" {
              * @exampleComponent limel-example-tooltip-max-character
              * @exampleComponent limel-example-tooltip-composite
              */
-            "limel-tooltip": LocalJSX.LimelTooltip & JSXBase.HTMLAttributes<HTMLLimelTooltipElement>;
+            "limel-tooltip": LocalJSX.IntrinsicElements["limel-tooltip"] & JSXBase.HTMLAttributes<HTMLLimelTooltipElement>;
             /**
              * This component is used internally by `limel-tooltip`.
              * @private 
              */
-            "limel-tooltip-content": LocalJSX.LimelTooltipContent & JSXBase.HTMLAttributes<HTMLLimelTooltipContentElement>;
+            "limel-tooltip-content": LocalJSX.IntrinsicElements["limel-tooltip-content"] & JSXBase.HTMLAttributes<HTMLLimelTooltipContentElement>;
         }
     }
 }