smoothly 1.0.0-alpha.21 → 1.0.0-alpha.211

package/dist/types/components.d.ts

@@ -5,17 +5,26 @@
  * It contains typing information for all components that exist in this project.
  */
 import { HTMLStencilElement, JSXBase } from "./stencil-public-runtime";
+import { SmoothlyAccordion } from "./components/accordion";
 import { address } from "./components/address-display";
 import { address as address1 } from "./components/address-display/index";
-import { Color, Fill, Message, Notice, Option, Trigger } from "./model";
-import { CountryCode, Currency, Date, DateRange, DateTime } from "isoly";
-import { Direction, Type } from "tidily";
-import { Criteria } from "selectively";
-import { Data } from "./components/form/Data";
+import { Color, Data, Fill, Icon, Message, Notice, Option, Trigger } from "./model";
+import { FunctionalComponent, JSX } from "./stencil-public-runtime";
+import { Button } from "./components/Button";
+import { CountryCode, Currency, Date, DateRange, DateTime, isoly } from "isoly";
+import { tidily, Type } from "tidily";
+import { selectively } from "selectively";
+import { Filter } from "./components/filter/Filter";
+import { Looks } from "./components/input/Looks";
+import { Editable } from "./components/input/Editable";
 import { GoogleFont } from "./model/GoogleFont";
-import { Selected } from "./components/radio-button/Selected";
+import { Selectable } from "./components/input/radio/Selected";
+import { Controls } from "./components/picker/menu";
+import { Controls as Controls1 } from "./components/picker/menu/index";
+import { Slot } from "./components/picker/slot-elements/index";
 export namespace Components {
     interface SmoothlyAccordion {
+        "removeItem": (el: HTMLSmoothlyAccordionItemElement) => Promise<void>;
         "value"?: string;
     }
     interface SmoothlyAccordionItem {
@@ -37,20 +46,26 @@ export namespace Components {
     }
     interface SmoothlyApp {
         "color": Color;
+        "home"?: string;
         "label": string;
         "menuOpen": boolean;
+        "selectRoom": (path: string) => Promise<void>;
     }
     interface SmoothlyAppDemo {
         "baseUrl": string;
     }
     interface SmoothlyAppRoom {
-        "icon"?: string;
+        "content"?: JSX.Element | FunctionalComponent;
+        "disabled": boolean;
+        "getContent": () => Promise<HTMLElement | undefined>;
+        "icon"?: Icon;
         "label"?: string;
         "path": string | URLPattern;
         "selected"?: boolean;
+        "setSelected": (selected: boolean, options?: { history?: boolean; }) => Promise<void>;
         "to"?: string;
     }
-    interface SmoothlyBacktotop {
+    interface SmoothlyBackToTop {
         "bottom": string;
         "opacity": string;
         "right": string;
@@ -63,12 +78,22 @@ export namespace Components {
     interface SmoothlyButton {
         "color"?: Color;
         "disabled": boolean;
-        "download"?: boolean;
         "expand"?: "block" | "full";
         "fill"?: Fill;
         "link"?: string;
         "shape"?: "rounded";
         "size": "small" | "large" | "icon" | "flexible";
+        "type": Button.Properties["type"];
+    }
+    interface SmoothlyButtonConfirm {
+        "color"?: Color;
+        "disabled": boolean;
+        "doubleClickTime": number;
+        "expand"?: "block" | "full";
+        "fill"?: Fill;
+        "name": string;
+        "shape"?: "rounded";
+        "size": "small" | "large" | "icon" | "flexible";
         "type": "link" | "button";
     }
     interface SmoothlyButtonDemo {
@@ -84,11 +109,13 @@ export namespace Components {
     }
     interface SmoothlyCheckbox {
         "checked": boolean;
+        "clear": () => Promise<void>;
         "disabled": boolean;
         "intermediate": boolean;
         "name": string;
         "size": "tiny" | "small" | "medium" | "large";
         "toggle": () => Promise<void>;
+        "unavailable": boolean;
         "value": any;
     }
     interface SmoothlyColor {
@@ -127,36 +154,44 @@ export namespace Components {
     interface SmoothlyDisplayDemo {
     }
     interface SmoothlyFilter {
-        "clear": (event: MouseEvent) => Promise<void>;
-        "criteria": Record<string, Criteria>;
-        "inputValue": Criteria;
-        "placeholder": string | undefined;
     }
-    interface SmoothlyFilterInput {
-        "autocomplete": boolean;
+    interface SmoothlyFilterField {
         "clear": () => Promise<void>;
-        "comparison": "equals" | "less" | "greater" | "starts" | "ends" | "includes";
-        "currency"?: Currency;
-        "disabled": boolean;
-        "maxLength": number;
-        "minLength": number;
-        "name": string;
-        "pattern"?: RegExp;
-        "placeholder"?: string;
-        "readonly": boolean;
-        "required": boolean;
-        "showLabel": boolean;
-        "type": string;
-        "value": string;
+        "criteria": selectively.Criteria;
+    }
+    interface SmoothlyFilterInput {
+        "placeholder": string;
+        "property": string;
+    }
+    interface SmoothlyFilterPicker {
+        "label": string;
+        "multiple": boolean;
+        "property": string;
+    }
+    interface SmoothlyFilterToggle {
+        "active": boolean;
+        "flip": boolean;
+        "icon": Icon;
+        "not": boolean;
+        "properties": Record<string, string>;
+        "toolTip": string;
     }
     interface SmoothlyForm {
         "action"?: string;
+        "changed": boolean;
         "clear": () => Promise<void>;
-        "looks": "plain" | "grid" | "border" | "line";
+        "color"?: Color;
+        "edit": (editable: boolean) => Promise<void>;
+        "listen": (property: "changed", listener: (parent: Editable) => Promise<void>) => Promise<void>;
+        "looks": Looks;
         "method"?: "GET" | "POST";
         "name"?: string;
+        "prevent": boolean;
         "processing": boolean;
+        "readonly": boolean;
+        "reset": () => Promise<void>;
         "submit": () => Promise<void>;
+        "value": Readonly<Data>;
     }
     interface SmoothlyFrame {
         "name": string;
@@ -170,7 +205,7 @@ export namespace Components {
     interface SmoothlyIcon {
         "color": Color;
         "fill": Fill;
-        "name"?: string;
+        "name": Icon | "empty";
         "size": "tiny" | "small" | "medium" | "large";
         "toolTip"?: string;
     }
@@ -178,102 +213,219 @@ export namespace Components {
     }
     interface SmoothlyInput {
         "autocomplete": boolean;
+        "changed": boolean;
         "clear": () => Promise<void>;
-        "currency"?: Currency;
+        "color"?: Color;
+        "currency"?: isoly.Currency;
+        "delay": number;
         "disabled": boolean;
+        "edit": (editable: boolean) => Promise<void>;
         "getFormData": (name: string) => Promise<Record<string, any>>;
-        "maxLength": number;
-        "minLength": number;
+        "listen": (property: "changed", listener: (parent: Editable) => Promise<void>) => Promise<void>;
+        "looks": Looks;
         "name": string;
-        "pattern": RegExp | undefined;
         "placeholder": string | undefined;
         "readonly": boolean;
         "required": boolean;
+        "reset": () => Promise<void>;
         "setKeepFocusOnReRender": (keepFocus: boolean) => Promise<void>;
-        "setSelectionRange": (start: number, end: number, direction?: Direction) => Promise<void>;
+        "setSelectionRange": (start: number, end: number, direction?: tidily.Direction) => Promise<void>;
         "showLabel": boolean;
-        "type": string;
+        "type": tidily.Type;
         "value": any;
     }
+    interface SmoothlyInputCheckbox {
+        "checked": boolean;
+        "clear": () => Promise<void>;
+        "disabled": boolean;
+        "looks": Looks;
+        "name": string;
+        "value": Data[string];
+    }
+    interface SmoothlyInputClear {
+        "color"?: Color;
+        "disabled": boolean;
+        "display": boolean;
+        "expand"?: "block" | "full";
+        "fill"?: Fill;
+        "shape"?: "rounded";
+        "size": "small" | "large" | "icon" | "flexible";
+        "type": "form" | "input";
+    }
+    interface SmoothlyInputColor {
+        "clear": () => Promise<void>;
+        "looks": Looks;
+        "name": string;
+        "value": string | undefined;
+    }
     interface SmoothlyInputDate {
+        "clear": () => Promise<void>;
+        "color"?: Color;
         "disabled": boolean;
+        "looks": Looks;
         "max": Date;
         "min": Date;
         "name": string;
         "open": boolean;
+        "showLabel": boolean;
         "value"?: Date;
     }
     interface SmoothlyInputDateRange {
-        "end"?: Date;
+        "clear": () => Promise<void>;
+        "color"?: Color;
+        "end"?: isoly.Date;
         "labelEnd": string;
         "labelStart": string;
-        "max": Date;
-        "min": Date;
+        "looks": Looks;
+        "max": isoly.Date;
+        "min": isoly.Date;
+        "name": string;
         "open": boolean;
         "showLabel": boolean;
-        "start"?: Date;
-        "value"?: Date;
+        "start"?: isoly.Date;
+        "value"?: isoly.Date;
     }
     interface SmoothlyInputDemo {
     }
+    interface SmoothlyInputEdit {
+        "color"?: Color;
+        "disabled": boolean;
+        "display": boolean;
+        "expand"?: "block" | "full";
+        "fill"?: Fill;
+        "shape"?: "rounded";
+        "size": "flexible" | "small" | "large" | "icon";
+        "type": "link" | "button";
+    }
+    interface SmoothlyInputFile {
+        "accept"?: string;
+        "camera": "front" | "back";
+        "clear": () => Promise<void>;
+        "color"?: Color;
+        "looks": Looks;
+        "name": string;
+        "placeholder": string | undefined;
+        "showLabel": boolean;
+        "value"?: File;
+    }
     interface SmoothlyInputMonth {
         "value"?: Date;
     }
+    interface SmoothlyInputRadio {
+        "changed": boolean;
+        "clear": () => Promise<void>;
+        "clearable"?: boolean;
+        "edit": (editable: boolean) => Promise<void>;
+        "listen": (property: "changed", listener: (parent: Editable) => Promise<void>) => Promise<void>;
+        "looks": Looks;
+        "name": string;
+        "readonly": boolean;
+        "reset": () => Promise<void>;
+        "value": any;
+    }
+    interface SmoothlyInputRadioItem {
+        "looks": Looks;
+        "name": string;
+        "selected": boolean;
+        "value": any;
+    }
+    interface SmoothlyInputRange {
+        "clear": () => Promise<void>;
+        "labelText"?: string;
+        "looks": Looks;
+        "max": number;
+        "min": number;
+        "name": string;
+        "outputSide": "right" | "left";
+        "step": number | "any";
+        "value": number | undefined;
+    }
+    interface SmoothlyInputReset {
+        "color"?: Color;
+        "disabled": boolean;
+        "display": boolean;
+        "expand"?: "block" | "full";
+        "fill"?: Fill;
+        "shape"?: "rounded";
+        "size": "small" | "large" | "icon" | "flexible";
+        "type": "form" | "input";
+    }
+    interface SmoothlyInputSelect {
+        "color"?: Color;
+        "initialPrompt"?: string;
+        "initialValue"?: unknown;
+        "looks": Looks;
+        "menuHeight"?: `${number}${"items" | "rem" | "px" | "vh"}`;
+        "name": string;
+        "reset": () => Promise<void>;
+        "showSelected"?: boolean;
+        "type"?: "icon";
+    }
+    interface SmoothlyInputSubmit {
+        "color"?: Color;
+        "disabled": boolean;
+        "display": boolean;
+        "expand"?: "block" | "full";
+        "fill"?: Fill;
+        "shape"?: "rounded";
+        "size": "flexible" | "small" | "large" | "icon";
+        "type": "link" | "button";
+    }
     interface SmoothlyItem {
         "filter": (filter: string) => Promise<boolean>;
         "marked": boolean;
         "selected": boolean;
         "value": any;
     }
-    interface SmoothlyMenuOptions {
-        "emptyMenuLabel": string;
-        "filterOptions": (keyword: string, excludeValues?: string[]) => Promise<void>;
-        "getHighlighted": () => Promise<Option | undefined>;
-        "maxMenuHeight": "inherit";
-        "moveHighlight": (step: number) => Promise<void>;
-        "mutable": boolean;
-        "newOptionLabel": string;
-        "optionStyle": any;
-        "options": Option[];
-        "order": boolean;
-        "resetHighlightOnOptionsChange": boolean;
-        "setHighlight": (newIndex: number | string, scrollToHighlight?: boolean) => Promise<void>;
-        "toggle": boolean;
+    interface SmoothlyLabel {
+        "description": string;
+        "hue": number;
+        "shape": "rectangle" | "rounded";
+    }
+    interface SmoothlyLazy {
+        "content"?: JSX.Element | FunctionalComponent;
+        "show": boolean;
+    }
+    interface SmoothlyLoadMore {
+        "multiple": boolean;
+        "name": string;
+        "offset": string;
     }
     interface SmoothlyNotification {
+        "closable": boolean;
+        "icon": boolean;
         "notice": Notice;
     }
     interface SmoothlyNotifier {
     }
-    interface SmoothlyOption {
-        "aliases": string;
-        "checkbox": boolean;
-        "checked": boolean;
-        "dataHighlight": boolean;
-        "divider"?: boolean;
+    interface SmoothlyPicker {
+        "clear": () => Promise<void>;
+        "looks": Looks;
+        "multiple": boolean;
+        "mutable": boolean;
         "name": string;
-        "new"?: boolean;
-        "toggle": boolean;
-        "value": string;
+        "open": boolean;
+        "readonly": boolean;
+        "validator"?: (value: string) => boolean | { result: boolean; notice: Notice };
     }
-    interface SmoothlyPicker {
-        "disabled": boolean;
-        "emptyMenuLabel": string;
-        "label": string;
-        "labelSetting": "hide" | "default";
-        "maxHeight": string;
-        "maxMenuHeight": string;
+    interface SmoothlyPickerDemo {
+    }
+    interface SmoothlyPickerMenu {
+        "looks": Looks;
         "multiple": boolean;
         "mutable": boolean;
-        "newOptionLabel": string;
-        "optionStyle": any;
-        "options": (Option & { checked?: boolean })[];
+        "open": boolean;
         "readonly": boolean;
-        "selectAllName": string;
-        "selectNoneName": string;
-        "selectionName": string;
-        "selections": Option[];
-        "valueValidator": (value: any) => [boolean, Notice | undefined];
+        "validator"?: (value: string) => boolean | { result: boolean; notice: Notice };
+    }
+    interface SmoothlyPickerOption {
+        "clickHandler": () => Promise<void>;
+        "position": number;
+        "required": boolean;
+        "search": string[];
+        "selected": boolean;
+        "value": any;
+        "visible": boolean;
     }
     interface SmoothlyPopup {
         "direction": "up" | "down";
@@ -282,39 +434,10 @@ export namespace Components {
     interface SmoothlyQuiet {
         "color": string;
     }
-    interface SmoothlyRadio {
-        "checked": boolean;
-        "name": string;
-        "tabIndex": number;
-        "value": string;
-    }
-    interface SmoothlyRadioButton {
-        "decoration": "button" | "radio";
-        "deselectable"?: boolean;
-        "name"?: string;
-        "value"?: any;
-    }
-    interface SmoothlyRadioButtonItem {
-        "color"?: Color;
-        "selected": boolean;
-        "value": any;
-    }
-    interface SmoothlyRadioGroup {
-        "orientation"?: "horizontal" | "vertical";
-    }
     interface SmoothlyReorder {
     }
-    interface SmoothlySelect {
-        "background"?: string;
-        "identifier": string;
-        "value": string;
-    }
     interface SmoothlySelectDemo {
     }
-    interface SmoothlySelector {
-        "initialPrompt"?: string;
-        "reset": () => Promise<void>;
-    }
     interface SmoothlySkeleton {
         "align": "left" | "center" | "right";
         "color": string;
@@ -323,6 +446,13 @@ export namespace Components {
         "width": string;
         "widths": string[];
     }
+    interface SmoothlySlotElements {
+        "clone": boolean;
+        "nodes"?: Node | Node[];
+    }
+    interface SmoothlySlottedElements {
+        "clone": boolean;
+    }
     interface SmoothlySpinner {
         "active": boolean;
         "size": "small" | "medium" | "large";
@@ -332,13 +462,15 @@ export namespace Components {
         "disabled": boolean;
         "expand"?: "block" | "full";
         "fill"?: Fill;
+        "prevent": boolean;
         "shape"?: "rounded";
-        "size": "small" | "large" | "icon";
+        "size": "flexible" | "small" | "large" | "icon";
         "type": "link" | "button";
     }
     interface SmoothlySummary {
         "color": Color;
         "fill": Fill;
+        "open": boolean;
         "size": "tiny" | "small" | "medium" | "large";
     }
     interface SmoothlySvg {
@@ -354,6 +486,8 @@ export namespace Components {
     }
     interface SmoothlyTable {
         "align": "middle" | "bottom" | "top";
+        "color"?: Color;
+        "open": boolean;
         "root": boolean;
     }
     interface SmoothlyTableCell {
@@ -363,17 +497,32 @@ export namespace Components {
     interface SmoothlyTableDemoFiltered {
     }
     interface SmoothlyTableExpandableCell {
-        "align": "left" | "center" | "right";
         "open": boolean;
     }
     interface SmoothlyTableExpandableRow {
-        "align": "left" | "center" | "right";
         "open": boolean;
     }
+    interface SmoothlyTableFooter {
+    }
     interface SmoothlyTableHeader {
         "name": string;
     }
     interface SmoothlyTableRow {
+        "open": boolean;
+    }
+    interface SmoothlyTableTesting {
+    }
+    interface SmoothlyThemeColor {
+        "color": Color;
+    }
+    interface SmoothlyThemeColorVariant {
+        "color": Color;
+        "variant": "shade" | "tint" | "color";
+    }
+    interface SmoothlyThemeColors {
+    }
+    interface SmoothlyThemePicker {
+        "element": string;
     }
     interface SmoothlyToggle {
         "disabled": boolean;
@@ -383,11 +532,12 @@ export namespace Components {
         "value"?: any;
     }
     interface SmoothlyToggleSwitch {
+        "checkmark": boolean;
+        "color": Color;
         "disabled": boolean;
-        "name": string;
+        "fill": Fill;
         "selected": boolean;
         "size": "small" | "default" | "large";
-        "value"?: any;
     }
     interface SmoothlyTrigger {
         "color": Color | undefined;
@@ -424,6 +574,10 @@ export interface SmoothlyBurgerCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLSmoothlyBurgerElement;
 }
+export interface SmoothlyButtonConfirmCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSmoothlyButtonConfirmElement;
+}
 export interface SmoothlyCalendarCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLSmoothlyCalendarElement;
@@ -440,10 +594,22 @@ export interface SmoothlyFilterCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLSmoothlyFilterElement;
 }
+export interface SmoothlyFilterFieldCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSmoothlyFilterFieldElement;
+}
 export interface SmoothlyFilterInputCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLSmoothlyFilterInputElement;
 }
+export interface SmoothlyFilterPickerCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSmoothlyFilterPickerElement;
+}
+export interface SmoothlyFilterToggleCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSmoothlyFilterToggleElement;
+}
 export interface SmoothlyFormCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLSmoothlyFormElement;
@@ -456,6 +622,18 @@ export interface SmoothlyInputCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLSmoothlyInputElement;
 }
+export interface SmoothlyInputCheckboxCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSmoothlyInputCheckboxElement;
+}
+export interface SmoothlyInputClearCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSmoothlyInputClearElement;
+}
+export interface SmoothlyInputColorCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSmoothlyInputColorElement;
+}
 export interface SmoothlyInputDateCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLSmoothlyInputDateElement;
@@ -464,62 +642,90 @@ export interface SmoothlyInputDateRangeCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLSmoothlyInputDateRangeElement;
 }
+export interface SmoothlyInputEditCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSmoothlyInputEditElement;
+}
+export interface SmoothlyInputFileCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSmoothlyInputFileElement;
+}
 export interface SmoothlyInputMonthCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLSmoothlyInputMonthElement;
 }
+export interface SmoothlyInputRadioCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSmoothlyInputRadioElement;
+}
+export interface SmoothlyInputRadioItemCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSmoothlyInputRadioItemElement;
+}
+export interface SmoothlyInputRangeCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSmoothlyInputRangeElement;
+}
+export interface SmoothlyInputResetCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSmoothlyInputResetElement;
+}
+export interface SmoothlyInputSelectCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSmoothlyInputSelectElement;
+}
+export interface SmoothlyInputSubmitCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSmoothlyInputSubmitElement;
+}
 export interface SmoothlyItemCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLSmoothlyItemElement;
 }
-export interface SmoothlyMenuOptionsCustomEvent<T> extends CustomEvent<T> {
+export interface SmoothlyLoadMoreCustomEvent<T> extends CustomEvent<T> {
     detail: T;
-    target: HTMLSmoothlyMenuOptionsElement;
+    target: HTMLSmoothlyLoadMoreElement;
 }
 export interface SmoothlyNotificationCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLSmoothlyNotificationElement;
 }
-export interface SmoothlyOptionCustomEvent<T> extends CustomEvent<T> {
-    detail: T;
-    target: HTMLSmoothlyOptionElement;
-}
 export interface SmoothlyPickerCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLSmoothlyPickerElement;
 }
-export interface SmoothlyPopupCustomEvent<T> extends CustomEvent<T> {
-    detail: T;
-    target: HTMLSmoothlyPopupElement;
-}
-export interface SmoothlyRadioCustomEvent<T> extends CustomEvent<T> {
+export interface SmoothlyPickerMenuCustomEvent<T> extends CustomEvent<T> {
     detail: T;
-    target: HTMLSmoothlyRadioElement;
+    target: HTMLSmoothlyPickerMenuElement;
 }
-export interface SmoothlyRadioButtonCustomEvent<T> extends CustomEvent<T> {
+export interface SmoothlyPickerOptionCustomEvent<T> extends CustomEvent<T> {
     detail: T;
-    target: HTMLSmoothlyRadioButtonElement;
+    target: HTMLSmoothlyPickerOptionElement;
 }
-export interface SmoothlyRadioButtonItemCustomEvent<T> extends CustomEvent<T> {
+export interface SmoothlyPopupCustomEvent<T> extends CustomEvent<T> {
     detail: T;
-    target: HTMLSmoothlyRadioButtonItemElement;
+    target: HTMLSmoothlyPopupElement;
 }
 export interface SmoothlyReorderCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLSmoothlyReorderElement;
 }
-export interface SmoothlySelectCustomEvent<T> extends CustomEvent<T> {
+export interface SmoothlySlotElementsCustomEvent<T> extends CustomEvent<T> {
     detail: T;
-    target: HTMLSmoothlySelectElement;
+    target: HTMLSmoothlySlotElementsElement;
 }
-export interface SmoothlySelectorCustomEvent<T> extends CustomEvent<T> {
+export interface SmoothlySlottedElementsCustomEvent<T> extends CustomEvent<T> {
     detail: T;
-    target: HTMLSmoothlySelectorElement;
+    target: HTMLSmoothlySlottedElementsElement;
 }
 export interface SmoothlySubmitCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLSmoothlySubmitElement;
 }
+export interface SmoothlySummaryCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSmoothlySummaryElement;
+}
 export interface SmoothlyTabCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLSmoothlyTabElement;
@@ -536,6 +742,10 @@ export interface SmoothlyTableExpandableRowCustomEvent<T> extends CustomEvent<T>
     detail: T;
     target: HTMLSmoothlyTableExpandableRowElement;
 }
+export interface SmoothlyToggleSwitchCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSmoothlyToggleSwitchElement;
+}
 export interface SmoothlyTriggerCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLSmoothlyTriggerElement;
@@ -593,11 +803,11 @@ declare global {
         prototype: HTMLSmoothlyAppRoomElement;
         new (): HTMLSmoothlyAppRoomElement;
     };
-    interface HTMLSmoothlyBacktotopElement extends Components.SmoothlyBacktotop, HTMLStencilElement {
+    interface HTMLSmoothlyBackToTopElement extends Components.SmoothlyBackToTop, HTMLStencilElement {
     }
-    var HTMLSmoothlyBacktotopElement: {
-        prototype: HTMLSmoothlyBacktotopElement;
-        new (): HTMLSmoothlyBacktotopElement;
+    var HTMLSmoothlyBackToTopElement: {
+        prototype: HTMLSmoothlyBackToTopElement;
+        new (): HTMLSmoothlyBackToTopElement;
     };
     interface HTMLSmoothlyBurgerElement extends Components.SmoothlyBurger, HTMLStencilElement {
     }
@@ -611,6 +821,12 @@ declare global {
         prototype: HTMLSmoothlyButtonElement;
         new (): HTMLSmoothlyButtonElement;
     };
+    interface HTMLSmoothlyButtonConfirmElement extends Components.SmoothlyButtonConfirm, HTMLStencilElement {
+    }
+    var HTMLSmoothlyButtonConfirmElement: {
+        prototype: HTMLSmoothlyButtonConfirmElement;
+        new (): HTMLSmoothlyButtonConfirmElement;
+    };
     interface HTMLSmoothlyButtonDemoElement extends Components.SmoothlyButtonDemo, HTMLStencilElement {
     }
     var HTMLSmoothlyButtonDemoElement: {
@@ -686,12 +902,30 @@ declare global {
         prototype: HTMLSmoothlyFilterElement;
         new (): HTMLSmoothlyFilterElement;
     };
+    interface HTMLSmoothlyFilterFieldElement extends Components.SmoothlyFilterField, HTMLStencilElement {
+    }
+    var HTMLSmoothlyFilterFieldElement: {
+        prototype: HTMLSmoothlyFilterFieldElement;
+        new (): HTMLSmoothlyFilterFieldElement;
+    };
     interface HTMLSmoothlyFilterInputElement extends Components.SmoothlyFilterInput, HTMLStencilElement {
     }
     var HTMLSmoothlyFilterInputElement: {
         prototype: HTMLSmoothlyFilterInputElement;
         new (): HTMLSmoothlyFilterInputElement;
     };
+    interface HTMLSmoothlyFilterPickerElement extends Components.SmoothlyFilterPicker, HTMLStencilElement {
+    }
+    var HTMLSmoothlyFilterPickerElement: {
+        prototype: HTMLSmoothlyFilterPickerElement;
+        new (): HTMLSmoothlyFilterPickerElement;
+    };
+    interface HTMLSmoothlyFilterToggleElement extends Components.SmoothlyFilterToggle, HTMLStencilElement {
+    }
+    var HTMLSmoothlyFilterToggleElement: {
+        prototype: HTMLSmoothlyFilterToggleElement;
+        new (): HTMLSmoothlyFilterToggleElement;
+    };
     interface HTMLSmoothlyFormElement extends Components.SmoothlyForm, HTMLStencilElement {
     }
     var HTMLSmoothlyFormElement: {
@@ -728,6 +962,24 @@ declare global {
         prototype: HTMLSmoothlyInputElement;
         new (): HTMLSmoothlyInputElement;
     };
+    interface HTMLSmoothlyInputCheckboxElement extends Components.SmoothlyInputCheckbox, HTMLStencilElement {
+    }
+    var HTMLSmoothlyInputCheckboxElement: {
+        prototype: HTMLSmoothlyInputCheckboxElement;
+        new (): HTMLSmoothlyInputCheckboxElement;
+    };
+    interface HTMLSmoothlyInputClearElement extends Components.SmoothlyInputClear, HTMLStencilElement {
+    }
+    var HTMLSmoothlyInputClearElement: {
+        prototype: HTMLSmoothlyInputClearElement;
+        new (): HTMLSmoothlyInputClearElement;
+    };
+    interface HTMLSmoothlyInputColorElement extends Components.SmoothlyInputColor, HTMLStencilElement {
+    }
+    var HTMLSmoothlyInputColorElement: {
+        prototype: HTMLSmoothlyInputColorElement;
+        new (): HTMLSmoothlyInputColorElement;
+    };
     interface HTMLSmoothlyInputDateElement extends Components.SmoothlyInputDate, HTMLStencilElement {
     }
     var HTMLSmoothlyInputDateElement: {
@@ -746,23 +998,83 @@ declare global {
         prototype: HTMLSmoothlyInputDemoElement;
         new (): HTMLSmoothlyInputDemoElement;
     };
+    interface HTMLSmoothlyInputEditElement extends Components.SmoothlyInputEdit, HTMLStencilElement {
+    }
+    var HTMLSmoothlyInputEditElement: {
+        prototype: HTMLSmoothlyInputEditElement;
+        new (): HTMLSmoothlyInputEditElement;
+    };
+    interface HTMLSmoothlyInputFileElement extends Components.SmoothlyInputFile, HTMLStencilElement {
+    }
+    var HTMLSmoothlyInputFileElement: {
+        prototype: HTMLSmoothlyInputFileElement;
+        new (): HTMLSmoothlyInputFileElement;
+    };
     interface HTMLSmoothlyInputMonthElement extends Components.SmoothlyInputMonth, HTMLStencilElement {
     }
     var HTMLSmoothlyInputMonthElement: {
         prototype: HTMLSmoothlyInputMonthElement;
         new (): HTMLSmoothlyInputMonthElement;
     };
+    interface HTMLSmoothlyInputRadioElement extends Components.SmoothlyInputRadio, HTMLStencilElement {
+    }
+    var HTMLSmoothlyInputRadioElement: {
+        prototype: HTMLSmoothlyInputRadioElement;
+        new (): HTMLSmoothlyInputRadioElement;
+    };
+    interface HTMLSmoothlyInputRadioItemElement extends Components.SmoothlyInputRadioItem, HTMLStencilElement {
+    }
+    var HTMLSmoothlyInputRadioItemElement: {
+        prototype: HTMLSmoothlyInputRadioItemElement;
+        new (): HTMLSmoothlyInputRadioItemElement;
+    };
+    interface HTMLSmoothlyInputRangeElement extends Components.SmoothlyInputRange, HTMLStencilElement {
+    }
+    var HTMLSmoothlyInputRangeElement: {
+        prototype: HTMLSmoothlyInputRangeElement;
+        new (): HTMLSmoothlyInputRangeElement;
+    };
+    interface HTMLSmoothlyInputResetElement extends Components.SmoothlyInputReset, HTMLStencilElement {
+    }
+    var HTMLSmoothlyInputResetElement: {
+        prototype: HTMLSmoothlyInputResetElement;
+        new (): HTMLSmoothlyInputResetElement;
+    };
+    interface HTMLSmoothlyInputSelectElement extends Components.SmoothlyInputSelect, HTMLStencilElement {
+    }
+    var HTMLSmoothlyInputSelectElement: {
+        prototype: HTMLSmoothlyInputSelectElement;
+        new (): HTMLSmoothlyInputSelectElement;
+    };
+    interface HTMLSmoothlyInputSubmitElement extends Components.SmoothlyInputSubmit, HTMLStencilElement {
+    }
+    var HTMLSmoothlyInputSubmitElement: {
+        prototype: HTMLSmoothlyInputSubmitElement;
+        new (): HTMLSmoothlyInputSubmitElement;
+    };
     interface HTMLSmoothlyItemElement extends Components.SmoothlyItem, HTMLStencilElement {
     }
     var HTMLSmoothlyItemElement: {
         prototype: HTMLSmoothlyItemElement;
         new (): HTMLSmoothlyItemElement;
     };
-    interface HTMLSmoothlyMenuOptionsElement extends Components.SmoothlyMenuOptions, HTMLStencilElement {
+    interface HTMLSmoothlyLabelElement extends Components.SmoothlyLabel, HTMLStencilElement {
+    }
+    var HTMLSmoothlyLabelElement: {
+        prototype: HTMLSmoothlyLabelElement;
+        new (): HTMLSmoothlyLabelElement;
+    };
+    interface HTMLSmoothlyLazyElement extends Components.SmoothlyLazy, HTMLStencilElement {
     }
-    var HTMLSmoothlyMenuOptionsElement: {
-        prototype: HTMLSmoothlyMenuOptionsElement;
-        new (): HTMLSmoothlyMenuOptionsElement;
+    var HTMLSmoothlyLazyElement: {
+        prototype: HTMLSmoothlyLazyElement;
+        new (): HTMLSmoothlyLazyElement;
+    };
+    interface HTMLSmoothlyLoadMoreElement extends Components.SmoothlyLoadMore, HTMLStencilElement {
+    }
+    var HTMLSmoothlyLoadMoreElement: {
+        prototype: HTMLSmoothlyLoadMoreElement;
+        new (): HTMLSmoothlyLoadMoreElement;
     };
     interface HTMLSmoothlyNotificationElement extends Components.SmoothlyNotification, HTMLStencilElement {
     }
@@ -776,18 +1088,30 @@ declare global {
         prototype: HTMLSmoothlyNotifierElement;
         new (): HTMLSmoothlyNotifierElement;
     };
-    interface HTMLSmoothlyOptionElement extends Components.SmoothlyOption, HTMLStencilElement {
-    }
-    var HTMLSmoothlyOptionElement: {
-        prototype: HTMLSmoothlyOptionElement;
-        new (): HTMLSmoothlyOptionElement;
-    };
     interface HTMLSmoothlyPickerElement extends Components.SmoothlyPicker, HTMLStencilElement {
     }
     var HTMLSmoothlyPickerElement: {
         prototype: HTMLSmoothlyPickerElement;
         new (): HTMLSmoothlyPickerElement;
     };
+    interface HTMLSmoothlyPickerDemoElement extends Components.SmoothlyPickerDemo, HTMLStencilElement {
+    }
+    var HTMLSmoothlyPickerDemoElement: {
+        prototype: HTMLSmoothlyPickerDemoElement;
+        new (): HTMLSmoothlyPickerDemoElement;
+    };
+    interface HTMLSmoothlyPickerMenuElement extends Components.SmoothlyPickerMenu, HTMLStencilElement {
+    }
+    var HTMLSmoothlyPickerMenuElement: {
+        prototype: HTMLSmoothlyPickerMenuElement;
+        new (): HTMLSmoothlyPickerMenuElement;
+    };
+    interface HTMLSmoothlyPickerOptionElement extends Components.SmoothlyPickerOption, HTMLStencilElement {
+    }
+    var HTMLSmoothlyPickerOptionElement: {
+        prototype: HTMLSmoothlyPickerOptionElement;
+        new (): HTMLSmoothlyPickerOptionElement;
+    };
     interface HTMLSmoothlyPopupElement extends Components.SmoothlyPopup, HTMLStencilElement {
     }
     var HTMLSmoothlyPopupElement: {
@@ -800,60 +1124,36 @@ declare global {
         prototype: HTMLSmoothlyQuietElement;
         new (): HTMLSmoothlyQuietElement;
     };
-    interface HTMLSmoothlyRadioElement extends Components.SmoothlyRadio, HTMLStencilElement {
-    }
-    var HTMLSmoothlyRadioElement: {
-        prototype: HTMLSmoothlyRadioElement;
-        new (): HTMLSmoothlyRadioElement;
-    };
-    interface HTMLSmoothlyRadioButtonElement extends Components.SmoothlyRadioButton, HTMLStencilElement {
-    }
-    var HTMLSmoothlyRadioButtonElement: {
-        prototype: HTMLSmoothlyRadioButtonElement;
-        new (): HTMLSmoothlyRadioButtonElement;
-    };
-    interface HTMLSmoothlyRadioButtonItemElement extends Components.SmoothlyRadioButtonItem, HTMLStencilElement {
-    }
-    var HTMLSmoothlyRadioButtonItemElement: {
-        prototype: HTMLSmoothlyRadioButtonItemElement;
-        new (): HTMLSmoothlyRadioButtonItemElement;
-    };
-    interface HTMLSmoothlyRadioGroupElement extends Components.SmoothlyRadioGroup, HTMLStencilElement {
-    }
-    var HTMLSmoothlyRadioGroupElement: {
-        prototype: HTMLSmoothlyRadioGroupElement;
-        new (): HTMLSmoothlyRadioGroupElement;
-    };
     interface HTMLSmoothlyReorderElement extends Components.SmoothlyReorder, HTMLStencilElement {
     }
     var HTMLSmoothlyReorderElement: {
         prototype: HTMLSmoothlyReorderElement;
         new (): HTMLSmoothlyReorderElement;
     };
-    interface HTMLSmoothlySelectElement extends Components.SmoothlySelect, HTMLStencilElement {
-    }
-    var HTMLSmoothlySelectElement: {
-        prototype: HTMLSmoothlySelectElement;
-        new (): HTMLSmoothlySelectElement;
-    };
     interface HTMLSmoothlySelectDemoElement extends Components.SmoothlySelectDemo, HTMLStencilElement {
     }
     var HTMLSmoothlySelectDemoElement: {
         prototype: HTMLSmoothlySelectDemoElement;
         new (): HTMLSmoothlySelectDemoElement;
     };
-    interface HTMLSmoothlySelectorElement extends Components.SmoothlySelector, HTMLStencilElement {
-    }
-    var HTMLSmoothlySelectorElement: {
-        prototype: HTMLSmoothlySelectorElement;
-        new (): HTMLSmoothlySelectorElement;
-    };
     interface HTMLSmoothlySkeletonElement extends Components.SmoothlySkeleton, HTMLStencilElement {
     }
     var HTMLSmoothlySkeletonElement: {
         prototype: HTMLSmoothlySkeletonElement;
         new (): HTMLSmoothlySkeletonElement;
     };
+    interface HTMLSmoothlySlotElementsElement extends Components.SmoothlySlotElements, HTMLStencilElement {
+    }
+    var HTMLSmoothlySlotElementsElement: {
+        prototype: HTMLSmoothlySlotElementsElement;
+        new (): HTMLSmoothlySlotElementsElement;
+    };
+    interface HTMLSmoothlySlottedElementsElement extends Components.SmoothlySlottedElements, HTMLStencilElement {
+    }
+    var HTMLSmoothlySlottedElementsElement: {
+        prototype: HTMLSmoothlySlottedElementsElement;
+        new (): HTMLSmoothlySlottedElementsElement;
+    };
     interface HTMLSmoothlySpinnerElement extends Components.SmoothlySpinner, HTMLStencilElement {
     }
     var HTMLSmoothlySpinnerElement: {
@@ -926,6 +1226,12 @@ declare global {
         prototype: HTMLSmoothlyTableExpandableRowElement;
         new (): HTMLSmoothlyTableExpandableRowElement;
     };
+    interface HTMLSmoothlyTableFooterElement extends Components.SmoothlyTableFooter, HTMLStencilElement {
+    }
+    var HTMLSmoothlyTableFooterElement: {
+        prototype: HTMLSmoothlyTableFooterElement;
+        new (): HTMLSmoothlyTableFooterElement;
+    };
     interface HTMLSmoothlyTableHeaderElement extends Components.SmoothlyTableHeader, HTMLStencilElement {
     }
     var HTMLSmoothlyTableHeaderElement: {
@@ -938,6 +1244,36 @@ declare global {
         prototype: HTMLSmoothlyTableRowElement;
         new (): HTMLSmoothlyTableRowElement;
     };
+    interface HTMLSmoothlyTableTestingElement extends Components.SmoothlyTableTesting, HTMLStencilElement {
+    }
+    var HTMLSmoothlyTableTestingElement: {
+        prototype: HTMLSmoothlyTableTestingElement;
+        new (): HTMLSmoothlyTableTestingElement;
+    };
+    interface HTMLSmoothlyThemeColorElement extends Components.SmoothlyThemeColor, HTMLStencilElement {
+    }
+    var HTMLSmoothlyThemeColorElement: {
+        prototype: HTMLSmoothlyThemeColorElement;
+        new (): HTMLSmoothlyThemeColorElement;
+    };
+    interface HTMLSmoothlyThemeColorVariantElement extends Components.SmoothlyThemeColorVariant, HTMLStencilElement {
+    }
+    var HTMLSmoothlyThemeColorVariantElement: {
+        prototype: HTMLSmoothlyThemeColorVariantElement;
+        new (): HTMLSmoothlyThemeColorVariantElement;
+    };
+    interface HTMLSmoothlyThemeColorsElement extends Components.SmoothlyThemeColors, HTMLStencilElement {
+    }
+    var HTMLSmoothlyThemeColorsElement: {
+        prototype: HTMLSmoothlyThemeColorsElement;
+        new (): HTMLSmoothlyThemeColorsElement;
+    };
+    interface HTMLSmoothlyThemePickerElement extends Components.SmoothlyThemePicker, HTMLStencilElement {
+    }
+    var HTMLSmoothlyThemePickerElement: {
+        prototype: HTMLSmoothlyThemePickerElement;
+        new (): HTMLSmoothlyThemePickerElement;
+    };
     interface HTMLSmoothlyToggleElement extends Components.SmoothlyToggle, HTMLStencilElement {
     }
     var HTMLSmoothlyToggleElement: {
@@ -989,9 +1325,10 @@ declare global {
         "smoothly-app": HTMLSmoothlyAppElement;
         "smoothly-app-demo": HTMLSmoothlyAppDemoElement;
         "smoothly-app-room": HTMLSmoothlyAppRoomElement;
-        "smoothly-backtotop": HTMLSmoothlyBacktotopElement;
+        "smoothly-back-to-top": HTMLSmoothlyBackToTopElement;
         "smoothly-burger": HTMLSmoothlyBurgerElement;
         "smoothly-button": HTMLSmoothlyButtonElement;
+        "smoothly-button-confirm": HTMLSmoothlyButtonConfirmElement;
         "smoothly-button-demo": HTMLSmoothlyButtonDemoElement;
         "smoothly-calendar": HTMLSmoothlyCalendarElement;
         "smoothly-checkbox": HTMLSmoothlyCheckboxElement;
@@ -1004,34 +1341,48 @@ declare global {
         "smoothly-display-date-time": HTMLSmoothlyDisplayDateTimeElement;
         "smoothly-display-demo": HTMLSmoothlyDisplayDemoElement;
         "smoothly-filter": HTMLSmoothlyFilterElement;
+        "smoothly-filter-field": HTMLSmoothlyFilterFieldElement;
         "smoothly-filter-input": HTMLSmoothlyFilterInputElement;
+        "smoothly-filter-picker": HTMLSmoothlyFilterPickerElement;
+        "smoothly-filter-toggle": HTMLSmoothlyFilterToggleElement;
         "smoothly-form": HTMLSmoothlyFormElement;
         "smoothly-frame": HTMLSmoothlyFrameElement;
         "smoothly-google-font": HTMLSmoothlyGoogleFontElement;
         "smoothly-icon": HTMLSmoothlyIconElement;
         "smoothly-icon-demo": HTMLSmoothlyIconDemoElement;
         "smoothly-input": HTMLSmoothlyInputElement;
+        "smoothly-input-checkbox": HTMLSmoothlyInputCheckboxElement;
+        "smoothly-input-clear": HTMLSmoothlyInputClearElement;
+        "smoothly-input-color": HTMLSmoothlyInputColorElement;
         "smoothly-input-date": HTMLSmoothlyInputDateElement;
         "smoothly-input-date-range": HTMLSmoothlyInputDateRangeElement;
         "smoothly-input-demo": HTMLSmoothlyInputDemoElement;
+        "smoothly-input-edit": HTMLSmoothlyInputEditElement;
+        "smoothly-input-file": HTMLSmoothlyInputFileElement;
         "smoothly-input-month": HTMLSmoothlyInputMonthElement;
+        "smoothly-input-radio": HTMLSmoothlyInputRadioElement;
+        "smoothly-input-radio-item": HTMLSmoothlyInputRadioItemElement;
+        "smoothly-input-range": HTMLSmoothlyInputRangeElement;
+        "smoothly-input-reset": HTMLSmoothlyInputResetElement;
+        "smoothly-input-select": HTMLSmoothlyInputSelectElement;
+        "smoothly-input-submit": HTMLSmoothlyInputSubmitElement;
         "smoothly-item": HTMLSmoothlyItemElement;
-        "smoothly-menu-options": HTMLSmoothlyMenuOptionsElement;
+        "smoothly-label": HTMLSmoothlyLabelElement;
+        "smoothly-lazy": HTMLSmoothlyLazyElement;
+        "smoothly-load-more": HTMLSmoothlyLoadMoreElement;
         "smoothly-notification": HTMLSmoothlyNotificationElement;
         "smoothly-notifier": HTMLSmoothlyNotifierElement;
-        "smoothly-option": HTMLSmoothlyOptionElement;
         "smoothly-picker": HTMLSmoothlyPickerElement;
+        "smoothly-picker-demo": HTMLSmoothlyPickerDemoElement;
+        "smoothly-picker-menu": HTMLSmoothlyPickerMenuElement;
+        "smoothly-picker-option": HTMLSmoothlyPickerOptionElement;
         "smoothly-popup": HTMLSmoothlyPopupElement;
         "smoothly-quiet": HTMLSmoothlyQuietElement;
-        "smoothly-radio": HTMLSmoothlyRadioElement;
-        "smoothly-radio-button": HTMLSmoothlyRadioButtonElement;
-        "smoothly-radio-button-item": HTMLSmoothlyRadioButtonItemElement;
-        "smoothly-radio-group": HTMLSmoothlyRadioGroupElement;
         "smoothly-reorder": HTMLSmoothlyReorderElement;
-        "smoothly-select": HTMLSmoothlySelectElement;
         "smoothly-select-demo": HTMLSmoothlySelectDemoElement;
-        "smoothly-selector": HTMLSmoothlySelectorElement;
         "smoothly-skeleton": HTMLSmoothlySkeletonElement;
+        "smoothly-slot-elements": HTMLSmoothlySlotElementsElement;
+        "smoothly-slotted-elements": HTMLSmoothlySlottedElementsElement;
         "smoothly-spinner": HTMLSmoothlySpinnerElement;
         "smoothly-submit": HTMLSmoothlySubmitElement;
         "smoothly-summary": HTMLSmoothlySummaryElement;
@@ -1044,8 +1395,14 @@ declare global {
         "smoothly-table-demo-filtered": HTMLSmoothlyTableDemoFilteredElement;
         "smoothly-table-expandable-cell": HTMLSmoothlyTableExpandableCellElement;
         "smoothly-table-expandable-row": HTMLSmoothlyTableExpandableRowElement;
+        "smoothly-table-footer": HTMLSmoothlyTableFooterElement;
         "smoothly-table-header": HTMLSmoothlyTableHeaderElement;
         "smoothly-table-row": HTMLSmoothlyTableRowElement;
+        "smoothly-table-testing": HTMLSmoothlyTableTestingElement;
+        "smoothly-theme-color": HTMLSmoothlyThemeColorElement;
+        "smoothly-theme-color-variant": HTMLSmoothlyThemeColorVariantElement;
+        "smoothly-theme-colors": HTMLSmoothlyThemeColorsElement;
+        "smoothly-theme-picker": HTMLSmoothlyThemePickerElement;
         "smoothly-toggle": HTMLSmoothlyToggleElement;
         "smoothly-toggle-switch": HTMLSmoothlyToggleSwitchElement;
         "smoothly-trigger": HTMLSmoothlyTriggerElement;
@@ -1062,8 +1419,7 @@ declare namespace LocalJSX {
     interface SmoothlyAccordionItem {
         "brand"?: string | string[];
         "name"?: string;
-        "onSmoothlyAccordionItemDidLoad"?: (event: SmoothlyAccordionItemCustomEvent<void>) => void;
-        "onSmoothlyAccordionItemDidUnload"?: (event: SmoothlyAccordionItemCustomEvent<void>) => void;
+        "onSmoothlyAccordionItemWillLoad"?: (event: SmoothlyAccordionItemCustomEvent<(parent: SmoothlyAccordion) => void>) => void;
         "onSmoothlyClose"?: (event: SmoothlyAccordionItemCustomEvent<{ name: string; open: boolean }>) => void;
         "onSmoothlyOpen"?: (event: SmoothlyAccordionItemCustomEvent<{ name: string; open: boolean }>) => void;
         "open"?: boolean;
@@ -1082,6 +1438,7 @@ declare namespace LocalJSX {
     }
     interface SmoothlyApp {
         "color"?: Color;
+        "home"?: string;
         "label"?: string;
         "menuOpen"?: boolean;
     }
@@ -1089,33 +1446,49 @@ declare namespace LocalJSX {
         "baseUrl"?: string;
     }
     interface SmoothlyAppRoom {
-        "icon"?: string;
+        "content"?: JSX.Element | FunctionalComponent;
+        "disabled"?: boolean;
+        "icon"?: Icon;
         "label"?: string;
-        "onSmoothlyRoomSelected"?: (event: SmoothlyAppRoomCustomEvent<HTMLElement>) => void;
+        "onSmoothlyRoomLoaded"?: (event: SmoothlyAppRoomCustomEvent<{ selected: boolean }>) => void;
+        "onSmoothlyRoomSelected"?: (event: SmoothlyAppRoomCustomEvent<{ history: boolean }>) => void;
         "path"?: string | URLPattern;
         "selected"?: boolean;
         "to"?: string;
     }
-    interface SmoothlyBacktotop {
+    interface SmoothlyBackToTop {
         "bottom"?: string;
         "opacity"?: string;
         "right"?: string;
     }
     interface SmoothlyBurger {
         "mediaQuery"?: string;
-        "onBurgerStatus"?: (event: SmoothlyBurgerCustomEvent<boolean>) => void;
+        "onSmoothlyNavStatus"?: (event: SmoothlyBurgerCustomEvent<boolean>) => void;
+        "onSmoothlyVisibleStatus"?: (event: SmoothlyBurgerCustomEvent<boolean>) => void;
         "open"?: boolean;
         "visible"?: boolean;
     }
     interface SmoothlyButton {
         "color"?: Color;
         "disabled"?: boolean;
-        "download"?: boolean;
         "expand"?: "block" | "full";
         "fill"?: Fill;
         "link"?: string;
         "shape"?: "rounded";
         "size"?: "small" | "large" | "icon" | "flexible";
+        "type"?: Button.Properties["type"];
+    }
+    interface SmoothlyButtonConfirm {
+        "color"?: Color;
+        "disabled"?: boolean;
+        "doubleClickTime"?: number;
+        "expand"?: "block" | "full";
+        "fill"?: Fill;
+        "name"?: string;
+        "onSmoothlyConfirm"?: (event: SmoothlyButtonConfirmCustomEvent<Data>) => void;
+        "onSmoothlyInputLoad"?: (event: SmoothlyButtonConfirmCustomEvent<(parent: HTMLElement) => void>) => void;
+        "shape"?: "rounded";
+        "size"?: "small" | "large" | "icon" | "flexible";
         "type"?: "link" | "button";
     }
     interface SmoothlyButtonDemo {
@@ -1126,11 +1499,11 @@ declare namespace LocalJSX {
         "max"?: Date;
         "min"?: Date;
         "month"?: Date;
-        "onDateRangeSet"?: (event: SmoothlyCalendarCustomEvent<DateRange>) => void;
-        "onDateSet"?: (event: SmoothlyCalendarCustomEvent<Date>) => void;
-        "onEndChanged"?: (event: SmoothlyCalendarCustomEvent<Date>) => void;
-        "onStartChanged"?: (event: SmoothlyCalendarCustomEvent<Date>) => void;
-        "onValueChanged"?: (event: SmoothlyCalendarCustomEvent<Date>) => void;
+        "onSmoothlyDateRangeSet"?: (event: SmoothlyCalendarCustomEvent<DateRange>) => void;
+        "onSmoothlyDateSet"?: (event: SmoothlyCalendarCustomEvent<Date>) => void;
+        "onSmoothlyEndChange"?: (event: SmoothlyCalendarCustomEvent<Date>) => void;
+        "onSmoothlyStartChange"?: (event: SmoothlyCalendarCustomEvent<Date>) => void;
+        "onSmoothlyValueChange"?: (event: SmoothlyCalendarCustomEvent<Date>) => void;
         "start"?: Date;
         "value"?: Date;
     }
@@ -1139,8 +1512,9 @@ declare namespace LocalJSX {
         "disabled"?: boolean;
         "intermediate"?: boolean;
         "name"?: string;
-        "onSmoothlyChecked"?: (event: SmoothlyCheckboxCustomEvent<Record<string, any>>) => void;
+        "onSmoothlyInput"?: (event: SmoothlyCheckboxCustomEvent<Record<string, any>>) => void;
         "size"?: "tiny" | "small" | "medium" | "large";
+        "unavailable"?: boolean;
         "value"?: any;
     }
     interface SmoothlyColor {
@@ -1180,36 +1554,49 @@ declare namespace LocalJSX {
         "onNotice"?: (event: SmoothlyDisplayDemoCustomEvent<Notice>) => void;
     }
     interface SmoothlyFilter {
-        "criteria"?: Record<string, Criteria>;
-        "inputValue"?: Criteria;
-        "onFilters"?: (event: SmoothlyFilterCustomEvent<Criteria>) => void;
-        "placeholder"?: string | undefined;
+        "onSmoothlyFilter"?: (event: SmoothlyFilterCustomEvent<selectively.Criteria>) => void;
+    }
+    interface SmoothlyFilterField {
+        "criteria"?: selectively.Criteria;
+        "onSmoothlyFilterField"?: (event: SmoothlyFilterFieldCustomEvent<selectively.Rule>) => void;
     }
     interface SmoothlyFilterInput {
-        "autocomplete"?: boolean;
-        "comparison"?: "equals" | "less" | "greater" | "starts" | "ends" | "includes";
-        "currency"?: Currency;
-        "disabled"?: boolean;
-        "maxLength"?: number;
-        "minLength"?: number;
-        "name"?: string;
-        "onFilter"?: (event: SmoothlyFilterInputCustomEvent<Criteria>) => void;
-        "pattern"?: RegExp;
+        "onSmoothlyFilterManipulate"?: (event: SmoothlyFilterInputCustomEvent<Filter.Manipulate>) => void;
+        "onSmoothlyFilterUpdate"?: (event: SmoothlyFilterInputCustomEvent<Filter.Update>) => void;
         "placeholder"?: string;
-        "readonly"?: boolean;
-        "required"?: boolean;
-        "showLabel"?: boolean;
-        "type"?: string;
-        "value"?: string;
+        "property"?: string;
+    }
+    interface SmoothlyFilterPicker {
+        "label"?: string;
+        "multiple"?: boolean;
+        "onSmoothlyFilterManipulate"?: (event: SmoothlyFilterPickerCustomEvent<Filter.Manipulate>) => void;
+        "onSmoothlyFilterUpdate"?: (event: SmoothlyFilterPickerCustomEvent<Filter.Update>) => void;
+        "property"?: string;
+    }
+    interface SmoothlyFilterToggle {
+        "active"?: boolean;
+        "flip"?: boolean;
+        "icon"?: Icon;
+        "not"?: boolean;
+        "onSmoothlyFilterManipulate"?: (event: SmoothlyFilterToggleCustomEvent<Filter.Manipulate>) => void;
+        "onSmoothlyFilterUpdate"?: (event: SmoothlyFilterToggleCustomEvent<Filter.Update>) => void;
+        "properties"?: Record<string, string>;
+        "toolTip"?: string;
     }
     interface SmoothlyForm {
         "action"?: string;
-        "looks"?: "plain" | "grid" | "border" | "line";
+        "changed"?: boolean;
+        "color"?: Color;
+        "looks"?: Looks;
         "method"?: "GET" | "POST";
         "name"?: string;
+        "onNotice"?: (event: SmoothlyFormCustomEvent<Notice>) => void;
         "onSmoothlyFormInput"?: (event: SmoothlyFormCustomEvent<Data>) => void;
         "onSmoothlyFormSubmit"?: (event: SmoothlyFormCustomEvent<Data>) => void;
+        "prevent"?: boolean;
         "processing"?: boolean;
+        "readonly"?: boolean;
+        "value"?: Readonly<Data>;
     }
     interface SmoothlyFrame {
         "name"?: string;
@@ -1224,7 +1611,7 @@ declare namespace LocalJSX {
     interface SmoothlyIcon {
         "color"?: Color;
         "fill"?: Fill;
-        "name"?: string;
+        "name"?: Icon | "empty";
         "size"?: "tiny" | "small" | "medium" | "large";
         "toolTip"?: string;
     }
@@ -1232,109 +1619,248 @@ declare namespace LocalJSX {
     }
     interface SmoothlyInput {
         "autocomplete"?: boolean;
-        "currency"?: Currency;
+        "changed"?: boolean;
+        "color"?: Color;
+        "currency"?: isoly.Currency;
+        "delay"?: number;
         "disabled"?: boolean;
-        "maxLength"?: number;
-        "minLength"?: number;
+        "looks"?: Looks;
         "name"?: string;
         "onSmoothlyBlur"?: (event: SmoothlyInputCustomEvent<void>) => void;
         "onSmoothlyChange"?: (event: SmoothlyInputCustomEvent<Record<string, any>>) => void;
+        "onSmoothlyFormDisable"?: (event: SmoothlyInputCustomEvent<(disabled: boolean) => void>) => void;
         "onSmoothlyInput"?: (event: SmoothlyInputCustomEvent<Record<string, any>>) => void;
-        "pattern"?: RegExp | undefined;
+        "onSmoothlyInputLoad"?: (event: SmoothlyInputCustomEvent<(parent: HTMLElement) => void>) => void;
+        "onSmoothlyInputLooks"?: (event: SmoothlyInputCustomEvent<(looks: Looks, color: Color) => void>) => void;
         "placeholder"?: string | undefined;
         "readonly"?: boolean;
         "required"?: boolean;
         "showLabel"?: boolean;
-        "type"?: string;
+        "type"?: tidily.Type;
         "value"?: any;
     }
+    interface SmoothlyInputCheckbox {
+        "checked"?: boolean;
+        "disabled"?: boolean;
+        "looks"?: Looks;
+        "name"?: string;
+        "onSmoothlyInput"?: (event: SmoothlyInputCheckboxCustomEvent<Data>) => void;
+        "onSmoothlyInputLoad"?: (event: SmoothlyInputCheckboxCustomEvent<(parent: HTMLElement) => void>) => void;
+        "onSmoothlyInputLooks"?: (event: SmoothlyInputCheckboxCustomEvent<(looks: Looks, color: Color) => void>) => void;
+        "value"?: Data[string];
+    }
+    interface SmoothlyInputClear {
+        "color"?: Color;
+        "disabled"?: boolean;
+        "display"?: boolean;
+        "expand"?: "block" | "full";
+        "fill"?: Fill;
+        "onSmoothlyInputLoad"?: (event: SmoothlyInputClearCustomEvent<(parent: HTMLElement) => void>) => void;
+        "shape"?: "rounded";
+        "size"?: "small" | "large" | "icon" | "flexible";
+        "type"?: "form" | "input";
+    }
+    interface SmoothlyInputColor {
+        "looks"?: Looks;
+        "name"?: string;
+        "onSmoothlyInput"?: (event: SmoothlyInputColorCustomEvent<Record<string, any>>) => void;
+        "onSmoothlyInputLoad"?: (event: SmoothlyInputColorCustomEvent<(parent: HTMLElement) => void>) => void;
+        "onSmoothlyInputLooks"?: (event: SmoothlyInputColorCustomEvent<(looks: Looks, color: Color) => void>) => void;
+        "value"?: string | undefined;
+    }
     interface SmoothlyInputDate {
+        "color"?: Color;
         "disabled"?: boolean;
+        "looks"?: Looks;
         "max"?: Date;
         "min"?: Date;
         "name"?: string;
-        "onValueChanged"?: (event: SmoothlyInputDateCustomEvent<Date>) => void;
+        "onSmoothlyInput"?: (event: SmoothlyInputDateCustomEvent<Record<string, any>>) => void;
+        "onSmoothlyInputLooks"?: (event: SmoothlyInputDateCustomEvent<(looks: Looks, color: Color) => void>) => void;
+        "onSmoothlyValueChange"?: (event: SmoothlyInputDateCustomEvent<Date>) => void;
         "open"?: boolean;
+        "showLabel"?: boolean;
         "value"?: Date;
     }
     interface SmoothlyInputDateRange {
-        "end"?: Date;
+        "color"?: Color;
+        "end"?: isoly.Date;
         "labelEnd"?: string;
         "labelStart"?: string;
-        "max"?: Date;
-        "min"?: Date;
-        "onDateRangeSelected"?: (event: SmoothlyInputDateRangeCustomEvent<{ start: Date; end: Date }>) => void;
-        "onValueChanged"?: (event: SmoothlyInputDateRangeCustomEvent<Date>) => void;
+        "looks"?: Looks;
+        "max"?: isoly.Date;
+        "min"?: isoly.Date;
+        "name"?: string;
+        "onSmoothlyInput"?: (event: SmoothlyInputDateRangeCustomEvent<Data>) => void;
+        "onSmoothlyInputLooks"?: (event: SmoothlyInputDateRangeCustomEvent<(looks: Looks, color: Color) => void>) => void;
+        "onSmoothlyValueChange"?: (event: SmoothlyInputDateRangeCustomEvent<isoly.Date>) => void;
         "open"?: boolean;
         "showLabel"?: boolean;
-        "start"?: Date;
-        "value"?: Date;
+        "start"?: isoly.Date;
+        "value"?: isoly.Date;
     }
     interface SmoothlyInputDemo {
     }
+    interface SmoothlyInputEdit {
+        "color"?: Color;
+        "disabled"?: boolean;
+        "display"?: boolean;
+        "expand"?: "block" | "full";
+        "fill"?: Fill;
+        "onSmoothlyInputLoad"?: (event: SmoothlyInputEditCustomEvent<(parent: HTMLElement) => void>) => void;
+        "shape"?: "rounded";
+        "size"?: "flexible" | "small" | "large" | "icon";
+        "type"?: "link" | "button";
+    }
+    interface SmoothlyInputFile {
+        "accept"?: string;
+        "camera"?: "front" | "back";
+        "color"?: Color;
+        "looks"?: Looks;
+        "name"?: string;
+        "onSmoothlyChange"?: (event: SmoothlyInputFileCustomEvent<Record<string, File>>) => void;
+        "onSmoothlyInput"?: (event: SmoothlyInputFileCustomEvent<Record<string, File>>) => void;
+        "onSmoothlyInputLooks"?: (event: SmoothlyInputFileCustomEvent<(looks: Looks, color: Color) => void>) => void;
+        "placeholder"?: string | undefined;
+        "showLabel"?: boolean;
+        "value"?: File;
+    }
     interface SmoothlyInputMonth {
-        "onValueChanged"?: (event: SmoothlyInputMonthCustomEvent<Date>) => void;
+        "onSmoothlyValueChange"?: (event: SmoothlyInputMonthCustomEvent<Date>) => void;
         "value"?: Date;
     }
+    interface SmoothlyInputRadio {
+        "changed"?: boolean;
+        "clearable"?: boolean;
+        "looks"?: Looks;
+        "name"?: string;
+        "onSmoothlyFormDisable"?: (event: SmoothlyInputRadioCustomEvent<(disabled: boolean) => void>) => void;
+        "onSmoothlyInput"?: (event: SmoothlyInputRadioCustomEvent<Data>) => void;
+        "onSmoothlyInputLoad"?: (event: SmoothlyInputRadioCustomEvent<(parent: HTMLElement) => void>) => void;
+        "onSmoothlyInputLooks"?: (event: SmoothlyInputRadioCustomEvent<(looks: Looks, color: Color) => void>) => void;
+        "readonly"?: boolean;
+        "value"?: any;
+    }
+    interface SmoothlyInputRadioItem {
+        "looks"?: Looks;
+        "name"?: string;
+        "onSmoothlyRadioButtonRegister"?: (event: SmoothlyInputRadioItemCustomEvent<(name: string) => void>) => void;
+        "onSmoothlySelect"?: (event: SmoothlyInputRadioItemCustomEvent<Selectable>) => void;
+        "selected"?: boolean;
+        "value"?: any;
+    }
+    interface SmoothlyInputRange {
+        "labelText"?: string;
+        "looks"?: Looks;
+        "max"?: number;
+        "min"?: number;
+        "name"?: string;
+        "onSmoothlyInput"?: (event: SmoothlyInputRangeCustomEvent<Record<string, any>>) => void;
+        "onSmoothlyInputLoad"?: (event: SmoothlyInputRangeCustomEvent<(parent: HTMLElement) => void>) => void;
+        "onSmoothlyInputLooks"?: (event: SmoothlyInputRangeCustomEvent<(looks: Looks, color: Color) => void>) => void;
+        "outputSide"?: "right" | "left";
+        "step"?: number | "any";
+        "value"?: number | undefined;
+    }
+    interface SmoothlyInputReset {
+        "color"?: Color;
+        "disabled"?: boolean;
+        "display"?: boolean;
+        "expand"?: "block" | "full";
+        "fill"?: Fill;
+        "onSmoothlyInputLoad"?: (event: SmoothlyInputResetCustomEvent<(parent: HTMLElement) => void>) => void;
+        "shape"?: "rounded";
+        "size"?: "small" | "large" | "icon" | "flexible";
+        "type"?: "form" | "input";
+    }
+    interface SmoothlyInputSelect {
+        "color"?: Color;
+        "initialPrompt"?: string;
+        "initialValue"?: unknown;
+        "looks"?: Looks;
+        "menuHeight"?: `${number}${"items" | "rem" | "px" | "vh"}`;
+        "name"?: string;
+        "onSmoothlyInput"?: (event: SmoothlyInputSelectCustomEvent<Data>) => void;
+        "onSmoothlyInputLooks"?: (event: SmoothlyInputSelectCustomEvent<(looks: Looks, color: Color) => void>) => void;
+        "onSmoothlySelect"?: (event: SmoothlyInputSelectCustomEvent<unknown>) => void;
+        "showSelected"?: boolean;
+        "type"?: "icon";
+    }
+    interface SmoothlyInputSubmit {
+        "color"?: Color;
+        "disabled"?: boolean;
+        "display"?: boolean;
+        "expand"?: "block" | "full";
+        "fill"?: Fill;
+        "onSmoothlyInputLoad"?: (event: SmoothlyInputSubmitCustomEvent<(parent: HTMLElement) => void>) => void;
+        "shape"?: "rounded";
+        "size"?: "flexible" | "small" | "large" | "icon";
+        "type"?: "link" | "button";
+    }
     interface SmoothlyItem {
         "marked"?: boolean;
-        "onItemSelected"?: (event: SmoothlyItemCustomEvent<void>) => void;
+        "onSmoothlyItemSelect"?: (event: SmoothlyItemCustomEvent<void>) => void;
         "selected"?: boolean;
         "value"?: any;
     }
-    interface SmoothlyMenuOptions {
-        "emptyMenuLabel"?: string;
-        "maxMenuHeight"?: "inherit";
-        "mutable"?: boolean;
-        "newOptionLabel"?: string;
-        "onMenuEmpty"?: (event: SmoothlyMenuOptionsCustomEvent<boolean>) => void;
-        "optionStyle"?: any;
-        "options"?: Option[];
-        "order"?: boolean;
-        "resetHighlightOnOptionsChange"?: boolean;
-        "toggle"?: boolean;
+    interface SmoothlyLabel {
+        "description"?: string;
+        "hue"?: number;
+        "shape"?: "rectangle" | "rounded";
+    }
+    interface SmoothlyLazy {
+        "content"?: JSX.Element | FunctionalComponent;
+        "show"?: boolean;
+    }
+    interface SmoothlyLoadMore {
+        "multiple"?: boolean;
+        "name"?: string;
+        "offset"?: string;
+        "onSmoothlyLoadMore"?: (event: SmoothlyLoadMoreCustomEvent<string>) => void;
     }
     interface SmoothlyNotification {
+        "closable"?: boolean;
+        "icon"?: boolean;
         "notice"?: Notice;
         "onRemove"?: (event: SmoothlyNotificationCustomEvent<Notice>) => void;
     }
     interface SmoothlyNotifier {
     }
-    interface SmoothlyOption {
-        "aliases"?: string;
-        "checkbox"?: boolean;
-        "checked"?: boolean;
-        "dataHighlight"?: boolean;
-        "divider"?: boolean;
+    interface SmoothlyPicker {
+        "looks"?: Looks;
+        "multiple"?: boolean;
+        "mutable"?: boolean;
         "name"?: string;
-        "new"?: boolean;
-        "onOptionAdd"?: (event: SmoothlyOptionCustomEvent<{ name: string; value: string }>) => void;
-        "onOptionHover"?: (event: SmoothlyOptionCustomEvent<{ value: any; name: string }>) => void;
-        "onOptionSelect"?: (event: SmoothlyOptionCustomEvent<{ value: any; name: string }>) => void;
-        "onOptionUnselect"?: (event: SmoothlyOptionCustomEvent<{ value: any; name: string }>) => void;
-        "toggle"?: boolean;
-        "value"?: string;
+        "onSmoothlyChange"?: (event: SmoothlyPickerCustomEvent<Record<string, any | any[]>>) => void;
+        "onSmoothlyInput"?: (event: SmoothlyPickerCustomEvent<Record<string, any | any[]>>) => void;
+        "onSmoothlyInputLooks"?: (event: SmoothlyPickerCustomEvent<(looks: Looks) => void>) => void;
+        "onSmoothlyPickerLoaded"?: (event: SmoothlyPickerCustomEvent<Controls>) => void;
+        "open"?: boolean;
+        "readonly"?: boolean;
+        "validator"?: (value: string) => boolean | { result: boolean; notice: Notice };
     }
-    interface SmoothlyPicker {
-        "disabled"?: boolean;
-        "emptyMenuLabel"?: string;
-        "label"?: string;
-        "labelSetting"?: "hide" | "default";
-        "maxHeight"?: string;
-        "maxMenuHeight"?: string;
+    interface SmoothlyPickerDemo {
+    }
+    interface SmoothlyPickerMenu {
+        "looks"?: Looks;
         "multiple"?: boolean;
         "mutable"?: boolean;
-        "newOptionLabel"?: string;
-        "onMenuClose"?: (event: SmoothlyPickerCustomEvent<Option[]>) => void;
-        "onNotice"?: (event: SmoothlyPickerCustomEvent<Notice>) => void;
-        "optionStyle"?: any;
-        "options"?: (Option & { checked?: boolean })[];
+        "onNotice"?: (event: SmoothlyPickerMenuCustomEvent<Notice>) => void;
+        "onSmoothlyPickerMenuLoaded"?: (event: SmoothlyPickerMenuCustomEvent<Controls & { synced: () => boolean }>) => void;
+        "open"?: boolean;
         "readonly"?: boolean;
-        "selectAllName"?: string;
-        "selectNoneName"?: string;
-        "selectionName"?: string;
-        "selections"?: Option[];
-        "valueValidator"?: (value: any) => [boolean, Notice | undefined];
+        "validator"?: (value: string) => boolean | { result: boolean; notice: Notice };
+    }
+    interface SmoothlyPickerOption {
+        "onSmoothlyPickerOptionChange"?: (event: SmoothlyPickerOptionCustomEvent<Option>) => void;
+        "onSmoothlyPickerOptionLoad"?: (event: SmoothlyPickerOptionCustomEvent<Option.Load>) => void;
+        "onSmoothlyPickerOptionLoaded"?: (event: SmoothlyPickerOptionCustomEvent<Option>) => void;
+        "position"?: number;
+        "required"?: boolean;
+        "search"?: string[];
+        "selected"?: boolean;
+        "value"?: any;
+        "visible"?: boolean;
     }
     interface SmoothlyPopup {
         "direction"?: "up" | "down";
@@ -1344,44 +1870,11 @@ declare namespace LocalJSX {
     interface SmoothlyQuiet {
         "color"?: string;
     }
-    interface SmoothlyRadio {
-        "checked"?: boolean;
-        "name"?: string;
-        "onSmoothlySelected"?: (event: SmoothlyRadioCustomEvent<{ name: string; value: string }>) => void;
-        "tabIndex"?: number;
-        "value"?: string;
-    }
-    interface SmoothlyRadioButton {
-        "decoration"?: "button" | "radio";
-        "deselectable"?: boolean;
-        "name"?: string;
-        "onRadioButtonSelected"?: (event: SmoothlyRadioButtonCustomEvent<{ name: string | undefined; value: any }>) => void;
-        "value"?: any;
-    }
-    interface SmoothlyRadioButtonItem {
-        "color"?: Color;
-        "onRadioItemSelectInternal"?: (event: SmoothlyRadioButtonItemCustomEvent<Selected>) => void;
-        "selected"?: boolean;
-        "value"?: any;
-    }
-    interface SmoothlyRadioGroup {
-        "orientation"?: "horizontal" | "vertical";
-    }
     interface SmoothlyReorder {
         "onReorder"?: (event: SmoothlyReorderCustomEvent<[number, number]>) => void;
     }
-    interface SmoothlySelect {
-        "background"?: string;
-        "identifier"?: string;
-        "onSelectionChanged"?: (event: SmoothlySelectCustomEvent<{ identifier: string; value: string }>) => void;
-        "value"?: string;
-    }
     interface SmoothlySelectDemo {
     }
-    interface SmoothlySelector {
-        "initialPrompt"?: string;
-        "onSelected"?: (event: SmoothlySelectorCustomEvent<any>) => void;
-    }
     interface SmoothlySkeleton {
         "align"?: "left" | "center" | "right";
         "color"?: string;
@@ -1390,6 +1883,15 @@ declare namespace LocalJSX {
         "width"?: string;
         "widths"?: string[];
     }
+    interface SmoothlySlotElements {
+        "clone"?: boolean;
+        "nodes"?: Node | Node[];
+        "onSmoothlySlotEmpty"?: (event: SmoothlySlotElementsCustomEvent<Slot>) => void;
+    }
+    interface SmoothlySlottedElements {
+        "clone"?: boolean;
+        "onSmoothlySlottedChange"?: (event: SmoothlySlottedElementsCustomEvent<Node[]>) => void;
+    }
     interface SmoothlySpinner {
         "active"?: boolean;
         "size"?: "small" | "medium" | "large";
@@ -1399,14 +1901,18 @@ declare namespace LocalJSX {
         "disabled"?: boolean;
         "expand"?: "block" | "full";
         "fill"?: Fill;
+        "onSmoothlyInputLoad"?: (event: SmoothlySubmitCustomEvent<(parent: HTMLElement) => void>) => void;
         "onSmoothlySubmit"?: (event: SmoothlySubmitCustomEvent<any>) => void;
+        "prevent"?: boolean;
         "shape"?: "rounded";
-        "size"?: "small" | "large" | "icon";
+        "size"?: "flexible" | "small" | "large" | "icon";
         "type"?: "link" | "button";
     }
     interface SmoothlySummary {
         "color"?: Color;
         "fill"?: Fill;
+        "onSmoothlySummaryOpen"?: (event: SmoothlySummaryCustomEvent<boolean>) => void;
+        "open"?: boolean;
         "size"?: "tiny" | "small" | "medium" | "large";
     }
     interface SmoothlySvg {
@@ -1423,9 +1929,11 @@ declare namespace LocalJSX {
     }
     interface SmoothlyTable {
         "align"?: "middle" | "bottom" | "top";
+        "color"?: Color;
         "onSmoothlyNestedTable"?: (event: SmoothlyTableCustomEvent<() => void>) => void;
-        "onSpotlightChange"?: (event: SmoothlyTableCustomEvent<{ allowSpotlight: boolean; owner?: EventTarget }>) => void;
-        "onTableLoad"?: (event: SmoothlyTableCustomEvent<(owner: EventTarget) => void>) => void;
+        "onSmoothlySpotlightChange"?: (event: SmoothlyTableCustomEvent<{ allowSpotlight: boolean; owner?: EventTarget }>) => void;
+        "onSmoothlyTableLoad"?: (event: SmoothlyTableCustomEvent<(owner: EventTarget) => void>) => void;
+        "open"?: boolean;
         "root"?: boolean;
     }
     interface SmoothlyTableCell {
@@ -1435,24 +1943,39 @@ declare namespace LocalJSX {
     interface SmoothlyTableDemoFiltered {
     }
     interface SmoothlyTableExpandableCell {
-        "align"?: "left" | "center" | "right";
-        "onExpandableChange"?: (event: SmoothlyTableExpandableCellCustomEvent<boolean>) => void;
-        "onExpandableLoad"?: (event: SmoothlyTableExpandableCellCustomEvent<{ allowSpotlight: (allowed: boolean) => void }>) => void;
-        "onExpansionLoad"?: (event: SmoothlyTableExpandableCellCustomEvent<void>) => void;
-        "onExpansionOpen"?: (event: SmoothlyTableExpandableCellCustomEvent<HTMLElement>) => void;
+        "onSmoothlyExpandableChange"?: (event: SmoothlyTableExpandableCellCustomEvent<boolean>) => void;
+        "onSmoothlyExpandableLoad"?: (event: SmoothlyTableExpandableCellCustomEvent<{ allowSpotlight: (allowed: boolean) => void }>) => void;
+        "onSmoothlyExpansionLoad"?: (event: SmoothlyTableExpandableCellCustomEvent<void>) => void;
+        "onSmoothlyExpansionOpen"?: (event: SmoothlyTableExpandableCellCustomEvent<HTMLElement>) => void;
         "open"?: boolean;
     }
     interface SmoothlyTableExpandableRow {
-        "align"?: "left" | "center" | "right";
-        "onExpandableChange"?: (event: SmoothlyTableExpandableRowCustomEvent<boolean>) => void;
-        "onExpandableLoad"?: (event: SmoothlyTableExpandableRowCustomEvent<{ allowSpotlight: (allowed: boolean) => void }>) => void;
-        "onExpansionOpen"?: (event: SmoothlyTableExpandableRowCustomEvent<HTMLElement>) => void;
+        "onSmoothlyExpandableChange"?: (event: SmoothlyTableExpandableRowCustomEvent<boolean>) => void;
+        "onSmoothlyExpandableLoad"?: (event: SmoothlyTableExpandableRowCustomEvent<{ allowSpotlight: (allowed: boolean) => void }>) => void;
+        "onSmoothlyExpansionOpen"?: (event: SmoothlyTableExpandableRowCustomEvent<HTMLElement>) => void;
         "open"?: boolean;
     }
+    interface SmoothlyTableFooter {
+    }
     interface SmoothlyTableHeader {
         "name"?: string;
     }
     interface SmoothlyTableRow {
+        "open"?: boolean;
+    }
+    interface SmoothlyTableTesting {
+    }
+    interface SmoothlyThemeColor {
+        "color"?: Color;
+    }
+    interface SmoothlyThemeColorVariant {
+        "color"?: Color;
+        "variant"?: "shade" | "tint" | "color";
+    }
+    interface SmoothlyThemeColors {
+    }
+    interface SmoothlyThemePicker {
+        "element"?: string;
     }
     interface SmoothlyToggle {
         "disabled"?: boolean;
@@ -1462,11 +1985,13 @@ declare namespace LocalJSX {
         "value"?: any;
     }
     interface SmoothlyToggleSwitch {
+        "checkmark"?: boolean;
+        "color"?: Color;
         "disabled"?: boolean;
-        "name"?: string;
+        "fill"?: Fill;
+        "onSmoothlyToggleSwitchChange"?: (event: SmoothlyToggleSwitchCustomEvent<boolean>) => void;
         "selected"?: boolean;
         "size"?: "small" | "default" | "large";
-        "value"?: any;
     }
     interface SmoothlyTrigger {
         "color"?: Color | undefined;
@@ -1484,7 +2009,7 @@ declare namespace LocalJSX {
     }
     interface SmoothlyTriggerSource {
         "listen"?: string;
-        "onMessage"?: (event: SmoothlyTriggerSourceCustomEvent<Message<any>>) => void;
+        "onSmoothlyMessage"?: (event: SmoothlyTriggerSourceCustomEvent<Message<any>>) => void;
         "onTrigger"?: (event: SmoothlyTriggerSourceCustomEvent<Trigger>) => void;
     }
     interface SmoothlyTuple {
@@ -1502,9 +2027,10 @@ declare namespace LocalJSX {
         "smoothly-app": SmoothlyApp;
         "smoothly-app-demo": SmoothlyAppDemo;
         "smoothly-app-room": SmoothlyAppRoom;
-        "smoothly-backtotop": SmoothlyBacktotop;
+        "smoothly-back-to-top": SmoothlyBackToTop;
         "smoothly-burger": SmoothlyBurger;
         "smoothly-button": SmoothlyButton;
+        "smoothly-button-confirm": SmoothlyButtonConfirm;
         "smoothly-button-demo": SmoothlyButtonDemo;
         "smoothly-calendar": SmoothlyCalendar;
         "smoothly-checkbox": SmoothlyCheckbox;
@@ -1517,34 +2043,48 @@ declare namespace LocalJSX {
         "smoothly-display-date-time": SmoothlyDisplayDateTime;
         "smoothly-display-demo": SmoothlyDisplayDemo;
         "smoothly-filter": SmoothlyFilter;
+        "smoothly-filter-field": SmoothlyFilterField;
         "smoothly-filter-input": SmoothlyFilterInput;
+        "smoothly-filter-picker": SmoothlyFilterPicker;
+        "smoothly-filter-toggle": SmoothlyFilterToggle;
         "smoothly-form": SmoothlyForm;
         "smoothly-frame": SmoothlyFrame;
         "smoothly-google-font": SmoothlyGoogleFont;
         "smoothly-icon": SmoothlyIcon;
         "smoothly-icon-demo": SmoothlyIconDemo;
         "smoothly-input": SmoothlyInput;
+        "smoothly-input-checkbox": SmoothlyInputCheckbox;
+        "smoothly-input-clear": SmoothlyInputClear;
+        "smoothly-input-color": SmoothlyInputColor;
         "smoothly-input-date": SmoothlyInputDate;
         "smoothly-input-date-range": SmoothlyInputDateRange;
         "smoothly-input-demo": SmoothlyInputDemo;
+        "smoothly-input-edit": SmoothlyInputEdit;
+        "smoothly-input-file": SmoothlyInputFile;
         "smoothly-input-month": SmoothlyInputMonth;
+        "smoothly-input-radio": SmoothlyInputRadio;
+        "smoothly-input-radio-item": SmoothlyInputRadioItem;
+        "smoothly-input-range": SmoothlyInputRange;
+        "smoothly-input-reset": SmoothlyInputReset;
+        "smoothly-input-select": SmoothlyInputSelect;
+        "smoothly-input-submit": SmoothlyInputSubmit;
         "smoothly-item": SmoothlyItem;
-        "smoothly-menu-options": SmoothlyMenuOptions;
+        "smoothly-label": SmoothlyLabel;
+        "smoothly-lazy": SmoothlyLazy;
+        "smoothly-load-more": SmoothlyLoadMore;
         "smoothly-notification": SmoothlyNotification;
         "smoothly-notifier": SmoothlyNotifier;
-        "smoothly-option": SmoothlyOption;
         "smoothly-picker": SmoothlyPicker;
+        "smoothly-picker-demo": SmoothlyPickerDemo;
+        "smoothly-picker-menu": SmoothlyPickerMenu;
+        "smoothly-picker-option": SmoothlyPickerOption;
         "smoothly-popup": SmoothlyPopup;
         "smoothly-quiet": SmoothlyQuiet;
-        "smoothly-radio": SmoothlyRadio;
-        "smoothly-radio-button": SmoothlyRadioButton;
-        "smoothly-radio-button-item": SmoothlyRadioButtonItem;
-        "smoothly-radio-group": SmoothlyRadioGroup;
         "smoothly-reorder": SmoothlyReorder;
-        "smoothly-select": SmoothlySelect;
         "smoothly-select-demo": SmoothlySelectDemo;
-        "smoothly-selector": SmoothlySelector;
         "smoothly-skeleton": SmoothlySkeleton;
+        "smoothly-slot-elements": SmoothlySlotElements;
+        "smoothly-slotted-elements": SmoothlySlottedElements;
         "smoothly-spinner": SmoothlySpinner;
         "smoothly-submit": SmoothlySubmit;
         "smoothly-summary": SmoothlySummary;
@@ -1557,8 +2097,14 @@ declare namespace LocalJSX {
         "smoothly-table-demo-filtered": SmoothlyTableDemoFiltered;
         "smoothly-table-expandable-cell": SmoothlyTableExpandableCell;
         "smoothly-table-expandable-row": SmoothlyTableExpandableRow;
+        "smoothly-table-footer": SmoothlyTableFooter;
         "smoothly-table-header": SmoothlyTableHeader;
         "smoothly-table-row": SmoothlyTableRow;
+        "smoothly-table-testing": SmoothlyTableTesting;
+        "smoothly-theme-color": SmoothlyThemeColor;
+        "smoothly-theme-color-variant": SmoothlyThemeColorVariant;
+        "smoothly-theme-colors": SmoothlyThemeColors;
+        "smoothly-theme-picker": SmoothlyThemePicker;
         "smoothly-toggle": SmoothlyToggle;
         "smoothly-toggle-switch": SmoothlyToggleSwitch;
         "smoothly-trigger": SmoothlyTrigger;
@@ -1580,9 +2126,10 @@ declare module "@stencil/core" {
             "smoothly-app": LocalJSX.SmoothlyApp & JSXBase.HTMLAttributes<HTMLSmoothlyAppElement>;
             "smoothly-app-demo": LocalJSX.SmoothlyAppDemo & JSXBase.HTMLAttributes<HTMLSmoothlyAppDemoElement>;
             "smoothly-app-room": LocalJSX.SmoothlyAppRoom & JSXBase.HTMLAttributes<HTMLSmoothlyAppRoomElement>;
-            "smoothly-backtotop": LocalJSX.SmoothlyBacktotop & JSXBase.HTMLAttributes<HTMLSmoothlyBacktotopElement>;
+            "smoothly-back-to-top": LocalJSX.SmoothlyBackToTop & JSXBase.HTMLAttributes<HTMLSmoothlyBackToTopElement>;
             "smoothly-burger": LocalJSX.SmoothlyBurger & JSXBase.HTMLAttributes<HTMLSmoothlyBurgerElement>;
             "smoothly-button": LocalJSX.SmoothlyButton & JSXBase.HTMLAttributes<HTMLSmoothlyButtonElement>;
+            "smoothly-button-confirm": LocalJSX.SmoothlyButtonConfirm & JSXBase.HTMLAttributes<HTMLSmoothlyButtonConfirmElement>;
             "smoothly-button-demo": LocalJSX.SmoothlyButtonDemo & JSXBase.HTMLAttributes<HTMLSmoothlyButtonDemoElement>;
             "smoothly-calendar": LocalJSX.SmoothlyCalendar & JSXBase.HTMLAttributes<HTMLSmoothlyCalendarElement>;
             "smoothly-checkbox": LocalJSX.SmoothlyCheckbox & JSXBase.HTMLAttributes<HTMLSmoothlyCheckboxElement>;
@@ -1598,34 +2145,48 @@ declare module "@stencil/core" {
             "smoothly-display-date-time": LocalJSX.SmoothlyDisplayDateTime & JSXBase.HTMLAttributes<HTMLSmoothlyDisplayDateTimeElement>;
             "smoothly-display-demo": LocalJSX.SmoothlyDisplayDemo & JSXBase.HTMLAttributes<HTMLSmoothlyDisplayDemoElement>;
             "smoothly-filter": LocalJSX.SmoothlyFilter & JSXBase.HTMLAttributes<HTMLSmoothlyFilterElement>;
+            "smoothly-filter-field": LocalJSX.SmoothlyFilterField & JSXBase.HTMLAttributes<HTMLSmoothlyFilterFieldElement>;
             "smoothly-filter-input": LocalJSX.SmoothlyFilterInput & JSXBase.HTMLAttributes<HTMLSmoothlyFilterInputElement>;
+            "smoothly-filter-picker": LocalJSX.SmoothlyFilterPicker & JSXBase.HTMLAttributes<HTMLSmoothlyFilterPickerElement>;
+            "smoothly-filter-toggle": LocalJSX.SmoothlyFilterToggle & JSXBase.HTMLAttributes<HTMLSmoothlyFilterToggleElement>;
             "smoothly-form": LocalJSX.SmoothlyForm & JSXBase.HTMLAttributes<HTMLSmoothlyFormElement>;
             "smoothly-frame": LocalJSX.SmoothlyFrame & JSXBase.HTMLAttributes<HTMLSmoothlyFrameElement>;
             "smoothly-google-font": LocalJSX.SmoothlyGoogleFont & JSXBase.HTMLAttributes<HTMLSmoothlyGoogleFontElement>;
             "smoothly-icon": LocalJSX.SmoothlyIcon & JSXBase.HTMLAttributes<HTMLSmoothlyIconElement>;
             "smoothly-icon-demo": LocalJSX.SmoothlyIconDemo & JSXBase.HTMLAttributes<HTMLSmoothlyIconDemoElement>;
             "smoothly-input": LocalJSX.SmoothlyInput & JSXBase.HTMLAttributes<HTMLSmoothlyInputElement>;
+            "smoothly-input-checkbox": LocalJSX.SmoothlyInputCheckbox & JSXBase.HTMLAttributes<HTMLSmoothlyInputCheckboxElement>;
+            "smoothly-input-clear": LocalJSX.SmoothlyInputClear & JSXBase.HTMLAttributes<HTMLSmoothlyInputClearElement>;
+            "smoothly-input-color": LocalJSX.SmoothlyInputColor & JSXBase.HTMLAttributes<HTMLSmoothlyInputColorElement>;
             "smoothly-input-date": LocalJSX.SmoothlyInputDate & JSXBase.HTMLAttributes<HTMLSmoothlyInputDateElement>;
             "smoothly-input-date-range": LocalJSX.SmoothlyInputDateRange & JSXBase.HTMLAttributes<HTMLSmoothlyInputDateRangeElement>;
             "smoothly-input-demo": LocalJSX.SmoothlyInputDemo & JSXBase.HTMLAttributes<HTMLSmoothlyInputDemoElement>;
+            "smoothly-input-edit": LocalJSX.SmoothlyInputEdit & JSXBase.HTMLAttributes<HTMLSmoothlyInputEditElement>;
+            "smoothly-input-file": LocalJSX.SmoothlyInputFile & JSXBase.HTMLAttributes<HTMLSmoothlyInputFileElement>;
             "smoothly-input-month": LocalJSX.SmoothlyInputMonth & JSXBase.HTMLAttributes<HTMLSmoothlyInputMonthElement>;
+            "smoothly-input-radio": LocalJSX.SmoothlyInputRadio & JSXBase.HTMLAttributes<HTMLSmoothlyInputRadioElement>;
+            "smoothly-input-radio-item": LocalJSX.SmoothlyInputRadioItem & JSXBase.HTMLAttributes<HTMLSmoothlyInputRadioItemElement>;
+            "smoothly-input-range": LocalJSX.SmoothlyInputRange & JSXBase.HTMLAttributes<HTMLSmoothlyInputRangeElement>;
+            "smoothly-input-reset": LocalJSX.SmoothlyInputReset & JSXBase.HTMLAttributes<HTMLSmoothlyInputResetElement>;
+            "smoothly-input-select": LocalJSX.SmoothlyInputSelect & JSXBase.HTMLAttributes<HTMLSmoothlyInputSelectElement>;
+            "smoothly-input-submit": LocalJSX.SmoothlyInputSubmit & JSXBase.HTMLAttributes<HTMLSmoothlyInputSubmitElement>;
             "smoothly-item": LocalJSX.SmoothlyItem & JSXBase.HTMLAttributes<HTMLSmoothlyItemElement>;
-            "smoothly-menu-options": LocalJSX.SmoothlyMenuOptions & JSXBase.HTMLAttributes<HTMLSmoothlyMenuOptionsElement>;
+            "smoothly-label": LocalJSX.SmoothlyLabel & JSXBase.HTMLAttributes<HTMLSmoothlyLabelElement>;
+            "smoothly-lazy": LocalJSX.SmoothlyLazy & JSXBase.HTMLAttributes<HTMLSmoothlyLazyElement>;
+            "smoothly-load-more": LocalJSX.SmoothlyLoadMore & JSXBase.HTMLAttributes<HTMLSmoothlyLoadMoreElement>;
             "smoothly-notification": LocalJSX.SmoothlyNotification & JSXBase.HTMLAttributes<HTMLSmoothlyNotificationElement>;
             "smoothly-notifier": LocalJSX.SmoothlyNotifier & JSXBase.HTMLAttributes<HTMLSmoothlyNotifierElement>;
-            "smoothly-option": LocalJSX.SmoothlyOption & JSXBase.HTMLAttributes<HTMLSmoothlyOptionElement>;
             "smoothly-picker": LocalJSX.SmoothlyPicker & JSXBase.HTMLAttributes<HTMLSmoothlyPickerElement>;
+            "smoothly-picker-demo": LocalJSX.SmoothlyPickerDemo & JSXBase.HTMLAttributes<HTMLSmoothlyPickerDemoElement>;
+            "smoothly-picker-menu": LocalJSX.SmoothlyPickerMenu & JSXBase.HTMLAttributes<HTMLSmoothlyPickerMenuElement>;
+            "smoothly-picker-option": LocalJSX.SmoothlyPickerOption & JSXBase.HTMLAttributes<HTMLSmoothlyPickerOptionElement>;
             "smoothly-popup": LocalJSX.SmoothlyPopup & JSXBase.HTMLAttributes<HTMLSmoothlyPopupElement>;
             "smoothly-quiet": LocalJSX.SmoothlyQuiet & JSXBase.HTMLAttributes<HTMLSmoothlyQuietElement>;
-            "smoothly-radio": LocalJSX.SmoothlyRadio & JSXBase.HTMLAttributes<HTMLSmoothlyRadioElement>;
-            "smoothly-radio-button": LocalJSX.SmoothlyRadioButton & JSXBase.HTMLAttributes<HTMLSmoothlyRadioButtonElement>;
-            "smoothly-radio-button-item": LocalJSX.SmoothlyRadioButtonItem & JSXBase.HTMLAttributes<HTMLSmoothlyRadioButtonItemElement>;
-            "smoothly-radio-group": LocalJSX.SmoothlyRadioGroup & JSXBase.HTMLAttributes<HTMLSmoothlyRadioGroupElement>;
             "smoothly-reorder": LocalJSX.SmoothlyReorder & JSXBase.HTMLAttributes<HTMLSmoothlyReorderElement>;
-            "smoothly-select": LocalJSX.SmoothlySelect & JSXBase.HTMLAttributes<HTMLSmoothlySelectElement>;
             "smoothly-select-demo": LocalJSX.SmoothlySelectDemo & JSXBase.HTMLAttributes<HTMLSmoothlySelectDemoElement>;
-            "smoothly-selector": LocalJSX.SmoothlySelector & JSXBase.HTMLAttributes<HTMLSmoothlySelectorElement>;
             "smoothly-skeleton": LocalJSX.SmoothlySkeleton & JSXBase.HTMLAttributes<HTMLSmoothlySkeletonElement>;
+            "smoothly-slot-elements": LocalJSX.SmoothlySlotElements & JSXBase.HTMLAttributes<HTMLSmoothlySlotElementsElement>;
+            "smoothly-slotted-elements": LocalJSX.SmoothlySlottedElements & JSXBase.HTMLAttributes<HTMLSmoothlySlottedElementsElement>;
             "smoothly-spinner": LocalJSX.SmoothlySpinner & JSXBase.HTMLAttributes<HTMLSmoothlySpinnerElement>;
             "smoothly-submit": LocalJSX.SmoothlySubmit & JSXBase.HTMLAttributes<HTMLSmoothlySubmitElement>;
             "smoothly-summary": LocalJSX.SmoothlySummary & JSXBase.HTMLAttributes<HTMLSmoothlySummaryElement>;
@@ -1638,8 +2199,14 @@ declare module "@stencil/core" {
             "smoothly-table-demo-filtered": LocalJSX.SmoothlyTableDemoFiltered & JSXBase.HTMLAttributes<HTMLSmoothlyTableDemoFilteredElement>;
             "smoothly-table-expandable-cell": LocalJSX.SmoothlyTableExpandableCell & JSXBase.HTMLAttributes<HTMLSmoothlyTableExpandableCellElement>;
             "smoothly-table-expandable-row": LocalJSX.SmoothlyTableExpandableRow & JSXBase.HTMLAttributes<HTMLSmoothlyTableExpandableRowElement>;
+            "smoothly-table-footer": LocalJSX.SmoothlyTableFooter & JSXBase.HTMLAttributes<HTMLSmoothlyTableFooterElement>;
             "smoothly-table-header": LocalJSX.SmoothlyTableHeader & JSXBase.HTMLAttributes<HTMLSmoothlyTableHeaderElement>;
             "smoothly-table-row": LocalJSX.SmoothlyTableRow & JSXBase.HTMLAttributes<HTMLSmoothlyTableRowElement>;
+            "smoothly-table-testing": LocalJSX.SmoothlyTableTesting & JSXBase.HTMLAttributes<HTMLSmoothlyTableTestingElement>;
+            "smoothly-theme-color": LocalJSX.SmoothlyThemeColor & JSXBase.HTMLAttributes<HTMLSmoothlyThemeColorElement>;
+            "smoothly-theme-color-variant": LocalJSX.SmoothlyThemeColorVariant & JSXBase.HTMLAttributes<HTMLSmoothlyThemeColorVariantElement>;
+            "smoothly-theme-colors": LocalJSX.SmoothlyThemeColors & JSXBase.HTMLAttributes<HTMLSmoothlyThemeColorsElement>;
+            "smoothly-theme-picker": LocalJSX.SmoothlyThemePicker & JSXBase.HTMLAttributes<HTMLSmoothlyThemePickerElement>;
             "smoothly-toggle": LocalJSX.SmoothlyToggle & JSXBase.HTMLAttributes<HTMLSmoothlyToggleElement>;
             "smoothly-toggle-switch": LocalJSX.SmoothlyToggleSwitch & JSXBase.HTMLAttributes<HTMLSmoothlyToggleSwitchElement>;
             "smoothly-trigger": LocalJSX.SmoothlyTrigger & JSXBase.HTMLAttributes<HTMLSmoothlyTriggerElement>;