smoothly 1.0.0-alpha.99 → 1.0.0

package/dist/types/components.d.ts

@@ -8,17 +8,19 @@ 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, Data as Data1, Fill, Message, Notice, Option, Trigger } from "./model";
-import { Icon } from "./components/icon/Icon";
+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 { Direction, Type } from "tidily";
-import { Criteria } from "selectively";
-import { Data } from "./model/Data";
-import { GoogleFont } from "./model/GoogleFont";
+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 { Selectable } from "./components/input/radio/Selected";
 import { Controls } from "./components/picker/menu";
 import { Controls as Controls1 } from "./components/picker/menu/index";
-import { Selected } from "./components/radio-button/Selected";
 import { Slot } from "./components/picker/slot-elements/index";
 export namespace Components {
     interface SmoothlyAccordion {
@@ -44,13 +46,17 @@ export namespace Components {
     }
     interface SmoothlyApp {
         "color": Color;
+        "home"?: string;
         "label": string;
         "menuOpen": boolean;
+        "selectRoom": (path: string) => Promise<void>;
     }
     interface SmoothlyAppDemo {
         "baseUrl": string;
     }
     interface SmoothlyAppRoom {
+        "content"?: JSX.Element | FunctionalComponent;
+        "disabled": boolean;
         "getContent": () => Promise<HTMLElement | undefined>;
         "icon"?: Icon;
         "label"?: string;
@@ -72,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 {
@@ -99,6 +115,7 @@ export namespace Components {
         "name": string;
         "size": "tiny" | "small" | "medium" | "large";
         "toggle": () => Promise<void>;
+        "unavailable": boolean;
         "value": any;
     }
     interface SmoothlyColor {
@@ -137,39 +154,45 @@ 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;
+        "type": "array" | "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>;
         "color"?: Color;
-        "looks": "plain" | "grid" | "border" | "line";
-        "method"?: "GET" | "POST";
+        "edit": (editable: boolean) => Promise<void>;
+        "listen": (property: "changed", listener: (parent: Editable) => Promise<void>) => Promise<void>;
+        "looks": Looks;
         "name"?: string;
         "prevent": boolean;
         "processing": boolean;
-        "submit": () => Promise<void>;
+        "readonly": boolean;
+        "reset": () => Promise<void>;
+        "setInitialValue": () => Promise<void>;
+        "submit": (remove?: boolean) => Promise<void>;
+        "type": "update" | "change" | "fetch" | "create";
         "value": Readonly<Data>;
     }
     interface SmoothlyFrame {
@@ -184,7 +207,9 @@ export namespace Components {
     interface SmoothlyIcon {
         "color": Color;
         "fill": Fill;
-        "name"?: Icon | "empty";
+        "flip"?: "x" | "y";
+        "name": Icon | "empty";
+        "rotate"?: number;
         "size": "tiny" | "small" | "medium" | "large";
         "toolTip"?: string;
     }
@@ -195,23 +220,39 @@ export namespace Components {
         "changed": boolean;
         "clear": () => Promise<void>;
         "color"?: Color;
-        "currency"?: Currency;
+        "currency"?: isoly.Currency;
+        "delay": number;
         "disabled": boolean;
+        "edit": (editable: boolean) => Promise<void>;
         "getFormData": (name: string) => Promise<Record<string, any>>;
+        "listen": (property: "changed", listener: (parent: Editable) => Promise<void>) => Promise<void>;
         "looks": Looks;
-        "maxLength": number;
-        "minLength": number;
         "name": string;
-        "pattern": RegExp | undefined;
         "placeholder": string | undefined;
         "readonly": boolean;
         "required": boolean;
+        "reset": () => Promise<void>;
+        "setInitialValue": () => 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 {
+        "changed": boolean;
+        "checked": boolean;
+        "clear": () => Promise<void>;
+        "disabled": 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>;
+        "setInitialValue": () => Promise<void>;
+        "value": boolean;
+    }
     interface SmoothlyInputClear {
         "color"?: Color;
         "disabled": boolean;
@@ -222,6 +263,12 @@ export namespace Components {
         "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;
@@ -251,6 +298,17 @@ export namespace Components {
     }
     interface SmoothlyInputDemo {
     }
+    interface SmoothlyInputEdit {
+        "color"?: Color;
+        "disabled": boolean;
+        "display": boolean;
+        "expand"?: "block" | "full";
+        "fill"?: Fill;
+        "shape"?: "rounded";
+        "size": "flexible" | "small" | "large" | "icon";
+        "toolTip": string;
+        "type": "link" | "button";
+    }
     interface SmoothlyInputFile {
         "accept"?: string;
         "camera": "front" | "back";
@@ -265,19 +323,103 @@ export namespace Components {
     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>;
+        "setInitialValue": () => Promise<void>;
+        "value": any;
+    }
+    interface SmoothlyInputRadioItem {
+        "looks": Looks;
+        "name": string;
+        "selected": boolean;
+        "value": any;
+    }
+    interface SmoothlyInputRange {
+        "changed": boolean;
+        "clear": () => Promise<void>;
+        "edit": (editable: boolean) => Promise<void>;
+        "labelText"?: string;
+        "listen": (property: "changed", listener: (parent: Editable) => Promise<void>) => Promise<void>;
+        "looks": Looks;
+        "max": number;
+        "min": number;
+        "name": string;
+        "outputSide": "right" | "left";
+        "readonly": boolean;
+        "reset": () => Promise<void>;
+        "setInitialValue": () => Promise<void>;
+        "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";
+        "tooltip": string;
+        "type": "form" | "input";
+    }
     interface SmoothlyInputSelect {
+        "changed": boolean;
+        "clear": () => Promise<void>;
+        "clearable": boolean;
         "color"?: Color;
-        "initialPrompt"?: string;
+        "edit": (editable: boolean) => Promise<void>;
+        "listen": (property: "changed", listener: (parent: Editable) => Promise<void>) => Promise<void>;
         "looks": Looks;
+        "menuHeight"?: `${number}${"items" | "rem" | "px" | "vh"}`;
+        "multiple": boolean;
         "name": string;
+        "placeholder"?: string | any;
+        "readonly": boolean;
         "reset": () => Promise<void>;
+        "setInitialValue": () => Promise<void>;
+        "showSelected"?: boolean;
+    }
+    interface SmoothlyInputSubmit {
+        "color"?: Color;
+        "delete": boolean;
+        "disabled": boolean;
+        "display": boolean;
+        "expand"?: "block" | "full";
+        "fill"?: Fill;
+        "shape"?: "rounded";
+        "size": "flexible" | "small" | "large" | "icon";
+        "toolTip": string;
+        "type": "link" | "button";
     }
     interface SmoothlyItem {
-        "filter": (filter: string) => Promise<boolean>;
+        "filter": (filter: string) => Promise<void>;
         "marked": boolean;
+        "selectable": boolean;
         "selected": boolean;
         "value": any;
     }
+    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;
@@ -286,13 +428,18 @@ export namespace Components {
     interface SmoothlyNotifier {
     }
     interface SmoothlyPicker {
+        "changed": boolean;
         "clear": () => Promise<void>;
+        "edit": (editable: boolean) => Promise<void>;
+        "listen": (property: "changed", listener: (parent: Editable) => Promise<void>) => Promise<void>;
         "looks": Looks;
         "multiple": boolean;
         "mutable": boolean;
         "name": string;
         "open": boolean;
         "readonly": boolean;
+        "reset": () => Promise<void>;
+        "setInitialValue": () => Promise<void>;
         "validator"?: (value: string) => boolean | { result: boolean; notice: Notice };
     }
     interface SmoothlyPickerDemo {
@@ -301,11 +448,14 @@ export namespace Components {
         "looks": Looks;
         "multiple": boolean;
         "mutable": boolean;
+        "open": boolean;
         "readonly": boolean;
         "validator"?: (value: string) => boolean | { result: boolean; notice: Notice };
     }
     interface SmoothlyPickerOption {
         "clickHandler": () => Promise<void>;
+        "position": number;
+        "required": boolean;
         "search": string[];
         "selected": boolean;
         "value": any;
@@ -318,26 +468,6 @@ export namespace Components {
     interface SmoothlyQuiet {
         "color": string;
     }
-    interface SmoothlyRadio {
-        "checked": boolean;
-        "name": string;
-        "tab": 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 SmoothlySelectDemo {
@@ -390,6 +520,7 @@ export namespace Components {
     }
     interface SmoothlyTable {
         "align": "middle" | "bottom" | "top";
+        "color"?: Color;
         "open": boolean;
         "root": boolean;
     }
@@ -400,13 +531,13 @@ 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;
     }
@@ -415,6 +546,18 @@ export namespace Components {
     }
     interface SmoothlyTableTesting {
     }
+    interface SmoothlyThemeColor {
+        "color": Color;
+    }
+    interface SmoothlyThemeColorVariant {
+        "color": Color;
+        "variant": "shade" | "tint" | "color";
+    }
+    interface SmoothlyThemeColors {
+    }
+    interface SmoothlyThemePicker {
+        "element": string;
+    }
     interface SmoothlyToggle {
         "disabled": boolean;
         "name": string;
@@ -423,11 +566,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;
@@ -464,6 +608,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;
@@ -480,10 +628,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;
@@ -496,10 +656,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;
@@ -508,6 +676,10 @@ 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;
@@ -516,14 +688,38 @@ 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 SmoothlyLoadMoreCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSmoothlyLoadMoreElement;
+}
 export interface SmoothlyNotificationCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLSmoothlyNotificationElement;
@@ -544,18 +740,6 @@ export interface SmoothlyPopupCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLSmoothlyPopupElement;
 }
-export interface SmoothlyRadioCustomEvent<T> extends CustomEvent<T> {
-    detail: T;
-    target: HTMLSmoothlyRadioElement;
-}
-export interface SmoothlyRadioButtonCustomEvent<T> extends CustomEvent<T> {
-    detail: T;
-    target: HTMLSmoothlyRadioButtonElement;
-}
-export interface SmoothlyRadioButtonItemCustomEvent<T> extends CustomEvent<T> {
-    detail: T;
-    target: HTMLSmoothlyRadioButtonItemElement;
-}
 export interface SmoothlyReorderCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLSmoothlyReorderElement;
@@ -592,6 +776,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;
@@ -667,6 +855,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: {
@@ -742,12 +936,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: {
@@ -784,12 +996,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: {
@@ -808,6 +1032,12 @@ 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: {
@@ -820,18 +1050,66 @@ declare global {
         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 HTMLSmoothlyLabelElement extends Components.SmoothlyLabel, HTMLStencilElement {
+    }
+    var HTMLSmoothlyLabelElement: {
+        prototype: HTMLSmoothlyLabelElement;
+        new (): HTMLSmoothlyLabelElement;
+    };
+    interface HTMLSmoothlyLazyElement extends Components.SmoothlyLazy, HTMLStencilElement {
+    }
+    var HTMLSmoothlyLazyElement: {
+        prototype: HTMLSmoothlyLazyElement;
+        new (): HTMLSmoothlyLazyElement;
+    };
+    interface HTMLSmoothlyLoadMoreElement extends Components.SmoothlyLoadMore, HTMLStencilElement {
+    }
+    var HTMLSmoothlyLoadMoreElement: {
+        prototype: HTMLSmoothlyLoadMoreElement;
+        new (): HTMLSmoothlyLoadMoreElement;
+    };
     interface HTMLSmoothlyNotificationElement extends Components.SmoothlyNotification, HTMLStencilElement {
     }
     var HTMLSmoothlyNotificationElement: {
@@ -880,30 +1158,6 @@ 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: {
@@ -1006,6 +1260,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: {
@@ -1024,6 +1284,30 @@ declare global {
         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: {
@@ -1078,6 +1362,7 @@ declare global {
         "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;
@@ -1090,21 +1375,35 @@ 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-label": HTMLSmoothlyLabelElement;
+        "smoothly-lazy": HTMLSmoothlyLazyElement;
+        "smoothly-load-more": HTMLSmoothlyLoadMoreElement;
         "smoothly-notification": HTMLSmoothlyNotificationElement;
         "smoothly-notifier": HTMLSmoothlyNotifierElement;
         "smoothly-picker": HTMLSmoothlyPickerElement;
@@ -1113,10 +1412,6 @@ declare global {
         "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-demo": HTMLSmoothlySelectDemoElement;
         "smoothly-skeleton": HTMLSmoothlySkeletonElement;
@@ -1134,9 +1429,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;
@@ -1172,6 +1472,7 @@ declare namespace LocalJSX {
     }
     interface SmoothlyApp {
         "color"?: Color;
+        "home"?: string;
         "label"?: string;
         "menuOpen"?: boolean;
     }
@@ -1179,6 +1480,8 @@ declare namespace LocalJSX {
         "baseUrl"?: string;
     }
     interface SmoothlyAppRoom {
+        "content"?: JSX.Element | FunctionalComponent;
+        "disabled"?: boolean;
         "icon"?: Icon;
         "label"?: string;
         "onSmoothlyRoomLoaded"?: (event: SmoothlyAppRoomCustomEvent<{ selected: boolean }>) => void;
@@ -1194,20 +1497,32 @@ declare namespace LocalJSX {
     }
     interface SmoothlyBurger {
         "mediaQuery"?: string;
-        "onNavStatus"?: (event: SmoothlyBurgerCustomEvent<boolean>) => void;
-        "onVisibleStatus"?: (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 {
@@ -1218,11 +1533,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;
     }
@@ -1233,6 +1548,7 @@ declare namespace LocalJSX {
         "name"?: string;
         "onSmoothlyInput"?: (event: SmoothlyCheckboxCustomEvent<Record<string, any>>) => void;
         "size"?: "tiny" | "small" | "medium" | "large";
+        "unavailable"?: boolean;
         "value"?: any;
     }
     interface SmoothlyColor {
@@ -1272,39 +1588,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;
+        "type"?: "array" | "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;
         "changed"?: boolean;
         "color"?: Color;
-        "looks"?: "plain" | "grid" | "border" | "line";
-        "method"?: "GET" | "POST";
+        "looks"?: Looks;
         "name"?: string;
+        "onNotice"?: (event: SmoothlyFormCustomEvent<Notice>) => void;
         "onSmoothlyFormInput"?: (event: SmoothlyFormCustomEvent<Data>) => void;
-        "onSmoothlyFormSubmit"?: (event: SmoothlyFormCustomEvent<Data>) => void;
+        "onSmoothlyFormSubmit"?: (event: SmoothlyFormCustomEvent<{ value: Data; type: "update" | "change" | "fetch" | "create" | "remove" }>) => void;
         "prevent"?: boolean;
         "processing"?: boolean;
+        "readonly"?: boolean;
+        "type"?: "update" | "change" | "fetch" | "create";
         "value"?: Readonly<Data>;
     }
     interface SmoothlyFrame {
@@ -1320,7 +1646,9 @@ declare namespace LocalJSX {
     interface SmoothlyIcon {
         "color"?: Color;
         "fill"?: Fill;
+        "flip"?: "x" | "y";
         "name"?: Icon | "empty";
+        "rotate"?: number;
         "size"?: "tiny" | "small" | "medium" | "large";
         "toolTip"?: string;
     }
@@ -1330,24 +1658,37 @@ declare namespace LocalJSX {
         "autocomplete"?: boolean;
         "changed"?: boolean;
         "color"?: Color;
-        "currency"?: Currency;
+        "currency"?: isoly.Currency;
+        "delay"?: number;
         "disabled"?: boolean;
         "looks"?: Looks;
-        "maxLength"?: number;
-        "minLength"?: number;
         "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;
+        "onSmoothlyInputLoad"?: (event: SmoothlyInputCustomEvent<(parent: HTMLElement) => void>) => void;
         "onSmoothlyInputLooks"?: (event: SmoothlyInputCustomEvent<(looks: Looks, color: Color) => void>) => void;
-        "pattern"?: RegExp | undefined;
         "placeholder"?: string | undefined;
         "readonly"?: boolean;
         "required"?: boolean;
         "showLabel"?: boolean;
-        "type"?: string;
+        "type"?: tidily.Type;
         "value"?: any;
     }
+    interface SmoothlyInputCheckbox {
+        "changed"?: boolean;
+        "checked"?: boolean;
+        "disabled"?: boolean;
+        "looks"?: Looks;
+        "name"?: string;
+        "onSmoothlyFormDisable"?: (event: SmoothlyInputCheckboxCustomEvent<(disabled: boolean) => void>) => void;
+        "onSmoothlyInput"?: (event: SmoothlyInputCheckboxCustomEvent<Data>) => void;
+        "onSmoothlyInputLoad"?: (event: SmoothlyInputCheckboxCustomEvent<(parent: HTMLElement) => void>) => void;
+        "onSmoothlyInputLooks"?: (event: SmoothlyInputCheckboxCustomEvent<(looks: Looks, color: Color) => void>) => void;
+        "readonly"?: boolean;
+        "value"?: boolean;
+    }
     interface SmoothlyInputClear {
         "color"?: Color;
         "disabled"?: boolean;
@@ -1359,6 +1700,14 @@ declare namespace LocalJSX {
         "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;
@@ -1368,7 +1717,7 @@ declare namespace LocalJSX {
         "name"?: string;
         "onSmoothlyInput"?: (event: SmoothlyInputDateCustomEvent<Record<string, any>>) => void;
         "onSmoothlyInputLooks"?: (event: SmoothlyInputDateCustomEvent<(looks: Looks, color: Color) => void>) => void;
-        "onValueChanged"?: (event: SmoothlyInputDateCustomEvent<Date>) => void;
+        "onSmoothlyValueChange"?: (event: SmoothlyInputDateCustomEvent<Date>) => void;
         "open"?: boolean;
         "showLabel"?: boolean;
         "value"?: Date;
@@ -1382,9 +1731,9 @@ declare namespace LocalJSX {
         "max"?: isoly.Date;
         "min"?: isoly.Date;
         "name"?: string;
-        "onSmoothlyInput"?: (event: SmoothlyInputDateRangeCustomEvent<Data1>) => void;
+        "onSmoothlyInput"?: (event: SmoothlyInputDateRangeCustomEvent<Data>) => void;
         "onSmoothlyInputLooks"?: (event: SmoothlyInputDateRangeCustomEvent<(looks: Looks, color: Color) => void>) => void;
-        "onValueChanged"?: (event: SmoothlyInputDateRangeCustomEvent<isoly.Date>) => void;
+        "onSmoothlyValueChange"?: (event: SmoothlyInputDateRangeCustomEvent<isoly.Date>) => void;
         "open"?: boolean;
         "showLabel"?: boolean;
         "start"?: isoly.Date;
@@ -1392,6 +1741,18 @@ declare namespace LocalJSX {
     }
     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";
+        "toolTip"?: string;
+        "type"?: "link" | "button";
+    }
     interface SmoothlyInputFile {
         "accept"?: string;
         "camera"?: "front" | "back";
@@ -1406,24 +1767,111 @@ declare namespace LocalJSX {
         "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 {
+        "changed"?: boolean;
+        "labelText"?: string;
+        "looks"?: Looks;
+        "max"?: number;
+        "min"?: number;
+        "name"?: string;
+        "onSmoothlyFormDisable"?: (event: SmoothlyInputRangeCustomEvent<(disabled: boolean) => void>) => void;
+        "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";
+        "readonly"?: boolean;
+        "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";
+        "tooltip"?: string;
+        "type"?: "form" | "input";
+    }
     interface SmoothlyInputSelect {
+        "changed"?: boolean;
+        "clearable"?: boolean;
         "color"?: Color;
-        "initialPrompt"?: string;
         "looks"?: Looks;
+        "menuHeight"?: `${number}${"items" | "rem" | "px" | "vh"}`;
+        "multiple"?: boolean;
         "name"?: string;
-        "onSelected"?: (event: SmoothlyInputSelectCustomEvent<any>) => void;
-        "onSmoothlyInput"?: (event: SmoothlyInputSelectCustomEvent<Record<number, any>>) => void;
+        "onSmoothlyFormDisable"?: (event: SmoothlyInputSelectCustomEvent<(disabled: boolean) => void>) => void;
+        "onSmoothlyInput"?: (event: SmoothlyInputSelectCustomEvent<Data>) => void;
+        "onSmoothlyInputLoad"?: (event: SmoothlyInputSelectCustomEvent<(parent: HTMLElement) => void>) => void;
         "onSmoothlyInputLooks"?: (event: SmoothlyInputSelectCustomEvent<(looks: Looks, color: Color) => void>) => void;
+        "onSmoothlyItemSelect"?: (event: SmoothlyInputSelectCustomEvent<HTMLSmoothlyItemElement>) => void;
+        "onSmoothlySelect"?: (event: SmoothlyInputSelectCustomEvent<unknown>) => void;
+        "placeholder"?: string | any;
+        "readonly"?: boolean;
+        "showSelected"?: boolean;
+    }
+    interface SmoothlyInputSubmit {
+        "color"?: Color;
+        "delete"?: boolean;
+        "disabled"?: boolean;
+        "display"?: boolean;
+        "expand"?: "block" | "full";
+        "fill"?: Fill;
+        "onSmoothlyInputLoad"?: (event: SmoothlyInputSubmitCustomEvent<(parent: HTMLElement) => void>) => void;
+        "shape"?: "rounded";
+        "size"?: "flexible" | "small" | "large" | "icon";
+        "toolTip"?: string;
+        "type"?: "link" | "button";
     }
     interface SmoothlyItem {
         "marked"?: boolean;
-        "onItemSelected"?: (event: SmoothlyItemCustomEvent<void>) => void;
+        "onSmoothlyInputLoad"?: (event: SmoothlyItemCustomEvent<(parent: HTMLElement) => void>) => void;
+        "onSmoothlyItemSelect"?: (event: SmoothlyItemCustomEvent<HTMLSmoothlyItemElement>) => void;
+        "selectable"?: boolean;
         "selected"?: boolean;
         "value"?: any;
     }
+    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;
@@ -1433,12 +1881,15 @@ declare namespace LocalJSX {
     interface SmoothlyNotifier {
     }
     interface SmoothlyPicker {
+        "changed"?: boolean;
         "looks"?: Looks;
         "multiple"?: boolean;
         "mutable"?: boolean;
         "name"?: string;
         "onSmoothlyChange"?: (event: SmoothlyPickerCustomEvent<Record<string, any | any[]>>) => void;
+        "onSmoothlyFormDisable"?: (event: SmoothlyPickerCustomEvent<(disabled: boolean) => void>) => void;
         "onSmoothlyInput"?: (event: SmoothlyPickerCustomEvent<Record<string, any | any[]>>) => void;
+        "onSmoothlyInputLoad"?: (event: SmoothlyPickerCustomEvent<(parent: HTMLElement) => void>) => void;
         "onSmoothlyInputLooks"?: (event: SmoothlyPickerCustomEvent<(looks: Looks) => void>) => void;
         "onSmoothlyPickerLoaded"?: (event: SmoothlyPickerCustomEvent<Controls>) => void;
         "open"?: boolean;
@@ -1453,6 +1904,7 @@ declare namespace LocalJSX {
         "mutable"?: boolean;
         "onNotice"?: (event: SmoothlyPickerMenuCustomEvent<Notice>) => void;
         "onSmoothlyPickerMenuLoaded"?: (event: SmoothlyPickerMenuCustomEvent<Controls>) => void;
+        "open"?: boolean;
         "readonly"?: boolean;
         "validator"?: (value: string) => boolean | { result: boolean; notice: Notice };
     }
@@ -1460,6 +1912,8 @@ declare namespace LocalJSX {
         "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;
@@ -1473,30 +1927,6 @@ declare namespace LocalJSX {
     interface SmoothlyQuiet {
         "color"?: string;
     }
-    interface SmoothlyRadio {
-        "checked"?: boolean;
-        "name"?: string;
-        "onSmoothlySelected"?: (event: SmoothlyRadioCustomEvent<{ name: string; value: string }>) => void;
-        "tab"?: number;
-        "value"?: string;
-    }
-    interface SmoothlyRadioButton {
-        "decoration"?: "button" | "radio";
-        "deselectable"?: boolean;
-        "name"?: string;
-        "onSmoothlyChange"?: (event: SmoothlyRadioButtonCustomEvent<Record<string, string>>) => void;
-        "onSmoothlyInput"?: (event: SmoothlyRadioButtonCustomEvent<Record<string, string>>) => 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;
     }
@@ -1529,7 +1959,6 @@ declare namespace LocalJSX {
         "expand"?: "block" | "full";
         "fill"?: Fill;
         "onSmoothlyInputLoad"?: (event: SmoothlySubmitCustomEvent<(parent: HTMLElement) => void>) => void;
-        "onSmoothlySubmit"?: (event: SmoothlySubmitCustomEvent<any>) => void;
         "prevent"?: boolean;
         "shape"?: "rounded";
         "size"?: "flexible" | "small" | "large" | "icon";
@@ -1556,6 +1985,7 @@ declare namespace LocalJSX {
     }
     interface SmoothlyTable {
         "align"?: "middle" | "bottom" | "top";
+        "color"?: Color;
         "onSmoothlyNestedTable"?: (event: SmoothlyTableCustomEvent<() => void>) => void;
         "onSmoothlySpotlightChange"?: (event: SmoothlyTableCustomEvent<{ allowSpotlight: boolean; owner?: EventTarget }>) => void;
         "onSmoothlyTableLoad"?: (event: SmoothlyTableCustomEvent<(owner: EventTarget) => void>) => void;
@@ -1569,7 +1999,6 @@ declare namespace LocalJSX {
     interface SmoothlyTableDemoFiltered {
     }
     interface SmoothlyTableExpandableCell {
-        "align"?: "left" | "center" | "right";
         "onSmoothlyExpandableChange"?: (event: SmoothlyTableExpandableCellCustomEvent<boolean>) => void;
         "onSmoothlyExpandableLoad"?: (event: SmoothlyTableExpandableCellCustomEvent<{ allowSpotlight: (allowed: boolean) => void }>) => void;
         "onSmoothlyExpansionLoad"?: (event: SmoothlyTableExpandableCellCustomEvent<void>) => void;
@@ -1577,12 +2006,13 @@ declare namespace LocalJSX {
         "open"?: boolean;
     }
     interface SmoothlyTableExpandableRow {
-        "align"?: "left" | "center" | "right";
         "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;
     }
@@ -1591,6 +2021,18 @@ declare namespace LocalJSX {
     }
     interface SmoothlyTableTesting {
     }
+    interface SmoothlyThemeColor {
+        "color"?: Color;
+    }
+    interface SmoothlyThemeColorVariant {
+        "color"?: Color;
+        "variant"?: "shade" | "tint" | "color";
+    }
+    interface SmoothlyThemeColors {
+    }
+    interface SmoothlyThemePicker {
+        "element"?: string;
+    }
     interface SmoothlyToggle {
         "disabled"?: boolean;
         "name"?: string;
@@ -1599,11 +2041,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;
@@ -1642,6 +2086,7 @@ declare namespace LocalJSX {
         "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;
@@ -1654,21 +2099,35 @@ 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-label": SmoothlyLabel;
+        "smoothly-lazy": SmoothlyLazy;
+        "smoothly-load-more": SmoothlyLoadMore;
         "smoothly-notification": SmoothlyNotification;
         "smoothly-notifier": SmoothlyNotifier;
         "smoothly-picker": SmoothlyPicker;
@@ -1677,10 +2136,6 @@ declare namespace LocalJSX {
         "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-demo": SmoothlySelectDemo;
         "smoothly-skeleton": SmoothlySkeleton;
@@ -1698,9 +2153,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;
@@ -1725,6 +2185,7 @@ declare module "@stencil/core" {
             "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>;
@@ -1740,21 +2201,35 @@ 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-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-picker": LocalJSX.SmoothlyPicker & JSXBase.HTMLAttributes<HTMLSmoothlyPickerElement>;
@@ -1763,10 +2238,6 @@ declare module "@stencil/core" {
             "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-demo": LocalJSX.SmoothlySelectDemo & JSXBase.HTMLAttributes<HTMLSmoothlySelectDemoElement>;
             "smoothly-skeleton": LocalJSX.SmoothlySkeleton & JSXBase.HTMLAttributes<HTMLSmoothlySkeletonElement>;
@@ -1784,9 +2255,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>;