/* eslint-disable */
/* tslint:disable */
/**
 * This is an autogenerated file created by the Stencil compiler.
 * It contains typing information for all components that exist in this project.
 */
import { HTMLStencilElement, JSXBase } from "./stencil-public-runtime";
import { Color, Data, Fill, Icon, Message, Notice, Submit, Trigger } from "./model";
import { FunctionalComponent, VNode } from "./stencil-public-runtime";
import { Button } from "./components/button/Button";
import { Editable } from "./components/input/Editable";
import { isoly } from "isoly";
import { DateFormat } from "./components/input/date/text/DateFormat";
import { tidily } from "tidily";
import { isly } from "isly";
import { Looks } from "./components/input/Looks";
import { Key } from "./components/input/Key";
import { Input } from "./components/input/Input";
import { RGB } from "./model/Color/RGB";
import { RadioItemSelect } from "./components/input/radio/RadioItemSelect";
import { SmoothlyInputRadio } from "./components/input/radio/index";
import { layout } from "./components/input/select/layout";
import { SmoothlyTabs } from "./components/tabs";
export { Color, Data, Fill, Icon, Message, Notice, Submit, Trigger } from "./model";
export { FunctionalComponent, VNode } from "./stencil-public-runtime";
export { Button } from "./components/button/Button";
export { Editable } from "./components/input/Editable";
export { isoly } from "isoly";
export { DateFormat } from "./components/input/date/text/DateFormat";
export { tidily } from "tidily";
export { isly } from "isly";
export { Looks } from "./components/input/Looks";
export { Key } from "./components/input/Key";
export { Input } from "./components/input/Input";
export { RGB } from "./model/Color/RGB";
export { RadioItemSelect } from "./components/input/radio/RadioItemSelect";
export { SmoothlyInputRadio } from "./components/input/radio/index";
export { layout } from "./components/input/select/layout";
export { SmoothlyTabs } from "./components/tabs";
export namespace Components {
    interface SmoothlyApp {
        "color": Color;
        "home"?: string;
        "label"?: string;
        /**
          * @default false
         */
        "menuOpen": boolean;
        /**
          * @default "48rem"
         */
        "navBreakpoint": `${number}${"px" | "em" | "rem"}`;
        "selectRoom": (path: string) => Promise<void>;
    }
    interface SmoothlyAppDemo {
        "baseUrl": string;
    }
    interface SmoothlyAppRoom {
        "content"?: VNode | FunctionalComponent;
        "disabled": boolean;
        "getContent": () => Promise<HTMLElement | undefined>;
        "icon"?: Icon;
        "label"?: string;
        /**
          * @default ""
         */
        "path": string | URLPattern | (string | URLPattern)[];
        "selected"?: boolean;
        "setMobileMode": (mobile: boolean) => Promise<void>;
        "setSelected": (selected: boolean, options?: { history?: boolean; }) => Promise<void>;
    }
    interface SmoothlyBackToTop {
        /**
          * @default "1rem"
         */
        "bottom": string;
        /**
          * @default "0.5"
         */
        "opacity": string;
        /**
          * @default "1rem"
         */
        "right": string;
    }
    interface SmoothlyBurger {
        /**
          * @default false
         */
        "open": boolean;
    }
    interface SmoothlyButton {
        "color"?: Color;
        /**
          * @default false
         */
        "disabled": boolean;
        "expand"?: "block" | "full";
        "fill"?: Fill;
        "link"?: string;
        "shape"?: "rounded";
        "size": "small" | "large" | "icon" | "flexible";
        "tooltip"?: string;
        "type": Button.Properties["type"];
    }
    interface SmoothlyButtonConfirm {
        "color"?: Color;
        /**
          * @default false
         */
        "disabled": boolean;
        /**
          * @default 0.2
         */
        "doubleClickTime": number;
        "expand"?: "block" | "full";
        "fill"?: Fill;
        "name": string;
        "shape"?: "rounded";
        "size": "small" | "large" | "icon" | "flexible";
    }
    interface SmoothlyButtonDemo {
    }
    interface SmoothlyButtonDemoStandard {
    }
    interface SmoothlyCalendar {
        "doubleInput": boolean;
        "end"?: isoly.Date;
        "jumpTo": (yearMonth: { Y?: string; M?: string; }) => Promise<void>;
        "max": isoly.Date;
        "min": isoly.Date;
        "month"?: isoly.Date;
        "start"?: isoly.Date;
        "value"?: isoly.Date;
    }
    interface SmoothlyCheckbox {
        /**
          * @default false
         */
        "checked": boolean;
        "clear": () => Promise<void>;
        /**
          * @default false
         */
        "disabled": boolean;
        /**
          * @default false
         */
        "intermediate": boolean;
        "name": string;
        /**
          * @default "tiny"
         */
        "size": "tiny" | "small" | "medium" | "large";
        "toggle": () => Promise<void>;
        /**
          * @default false
         */
        "unavailable": boolean;
        "value": any;
    }
    interface SmoothlyColor {
        "color"?: Color;
    }
    interface SmoothlyCountry {
        /**
          * @default "alpha2"
         */
        "text": "alpha2" | "name" | "none";
        "value": isoly.CountryCode.Alpha2;
    }
    interface SmoothlyDateText {
        "deselect": () => Promise<void>;
        "disabled": boolean;
        /**
          * @default getLocale()
         */
        "locale"?: isoly.Locale;
        "readonly": boolean;
        "select": (place?: "start" | "end") => Promise<void>;
        "setValue": (value: isoly.Date | undefined) => Promise<void>;
        /**
          * @default true
         */
        "showLabel": boolean;
        "value"?: isoly.Date;
    }
    interface SmoothlyDialog {
        /**
          * @default false
         */
        "closable": boolean;
        "color": Color | undefined;
        "header": string | undefined;
        /**
          * @default true
         */
        "open": boolean;
    }
    interface SmoothlyDialogDemo {
    }
    interface SmoothlyDisplay {
        "collapseDepth"?: number;
        "country"?: isoly.CountryCode.Alpha2;
        "currency"?: isoly.Currency;
        "format"?: isoly.DateTime.Format;
        "label"?: string;
        "toInteger"?: boolean;
        "type": tidily.Type | "json";
        "value"?: any;
    }
    interface SmoothlyDisplayDemo {
    }
    interface SmoothlyDisplayDemoJson {
    }
    interface SmoothlyDisplayJson {
        "collapseDepth"?: number;
        "value": any;
    }
    interface SmoothlyDisplayJsonObject {
        "collapseDepth"?: number;
        "value": Record<string, any> | any[];
    }
    interface SmoothlyDisplayJsonPrimitive {
        "value": any;
    }
    interface SmoothlyDisplayJsonRecordKey {
        "value": any;
    }
    interface SmoothlyForm {
        "action"?: string;
        "clear": () => Promise<void>;
        "color"?: Color;
        "edit": (editable: boolean) => Promise<void>;
        "listen": (listener: Editable.Observer.Listener) => Promise<void>;
        "looks"?: Looks;
        "name"?: string;
        /**
          * @default true
         */
        "prevent": boolean;
        "processing"?: Promise<boolean>;
        /**
          * @default false
         */
        "readonly": boolean;
        "removeInput": (name: string) => Promise<void>;
        "reset": () => Promise<void>;
        "setInitialValue": () => Promise<void>;
        "submit": (remove?: boolean) => Promise<void>;
        /**
          * @default this.action ? "create" : undefined
         */
        "type"?: "update" | "change" | "fetch" | "create";
        "validator"?: isly.Type<any>;
        /**
          * @default {}
         */
        "value": Readonly<Data>;
    }
    interface SmoothlyFormDemo {
    }
    interface SmoothlyFormDemoAll {
    }
    interface SmoothlyFormDemoCard {
    }
    interface SmoothlyFormDemoControlled {
    }
    interface SmoothlyFormDemoDate {
    }
    interface SmoothlyFormDemoDateRange {
    }
    interface SmoothlyFormDemoLogin {
    }
    interface SmoothlyFormDemoPet {
    }
    interface SmoothlyFormDemoPrices {
    }
    interface SmoothlyFormDemoSchedule {
    }
    interface SmoothlyFormDemoTransparent {
    }
    interface SmoothlyFormDemoTyped {
    }
    interface SmoothlyFrame {
        "name": string;
        "origin": string | undefined;
        "send": (message2: string | Message<any>, content?: Trigger | any) => Promise<void>;
        "url": string;
    }
    interface SmoothlyIcon {
        "color": Color;
        /**
          * @default "solid"
         */
        "fill": Fill;
        "flip"?: "x" | "y";
        /**
          * @default "empty"
         */
        "name": Icon | "empty";
        "rotate"?: number;
        "size"?: "tiny" | "small" | "medium" | "large" | "xlarge";
        "tooltip"?: string;
    }
    interface SmoothlyIconDemo {
    }
    interface SmoothlyInput {
        "autocomplete"?: Exclude<tidily.Settings["autocomplete"], undefined>;
        "clear": () => Promise<void>;
        "color"?: Color;
        "copyable"?: boolean;
        "currency"?: isoly.Currency;
        /**
          * @default false
         */
        "disabled": boolean;
        "edit": (editable: boolean) => Promise<void>;
        "errorMessage"?: string;
        "getValue": () => Promise<any | undefined>;
        /**
          * @default false
         */
        "invalid"?: boolean;
        "listen": (listener: Editable.Observer.Listener) => Promise<void>;
        "looks"?: Looks;
        "max"?: number;
        "min"?: number;
        "name": string;
        "pad"?: number;
        "placeholder": string | undefined;
        /**
          * @default false
         */
        "readonly": boolean;
        "register": () => Promise<void>;
        /**
          * @default false
         */
        "required": boolean;
        "reset": () => Promise<void>;
        "setCustomInitialValue": (value: any) => Promise<void>;
        "setFocus": () => Promise<void>;
        "setInitialValue": () => Promise<void>;
        "setSelection": (start: number, end: number) => Promise<void>;
        "setValue": (value: any) => Promise<void>;
        /**
          * @default true
         */
        "showLabel": boolean;
        "toInteger"?: boolean;
        /**
          * @default "text"
         */
        "type": tidily.Type;
        "unregister": () => Promise<void>;
        "value": any;
    }
    interface SmoothlyInputCheckbox {
        /**
          * @default false
         */
        "checked": boolean;
        "clear": () => Promise<void>;
        "color"?: Color;
        "disabled": boolean;
        "edit": (editable: boolean) => Promise<void>;
        "getValue": () => Promise<boolean>;
        "listen": (listener: Editable.Observer.Listener) => Promise<void>;
        "looks"?: Looks;
        "name": string;
        /**
          * @default false
         */
        "readonly": boolean;
        "register": () => Promise<void>;
        "reset": () => Promise<void>;
        "setInitialValue": () => Promise<void>;
        "unregister": () => Promise<void>;
        "value"?: Record<"true" | "false", any>;
    }
    interface SmoothlyInputCheckboxDemo {
    }
    interface SmoothlyInputClear {
        "color"?: Color;
        "disabled"?: boolean;
        /**
          * @default true
         */
        "display": boolean;
        "expand"?: "block" | "full";
        /**
          * @default "clear"
         */
        "fill"?: Fill;
        "shape"?: "rounded";
        /**
          * @default "icon"
         */
        "size": "small" | "large" | "icon" | "flexible";
        /**
          * @default "Clear"
         */
        "tooltip": string;
        /**
          * @default "input"
         */
        "type": "form" | "input";
    }
    interface SmoothlyInputColor {
        "clear": () => Promise<void>;
        "color"?: Color;
        "disabled"?: boolean;
        "edit": (editable: boolean) => Promise<void>;
        "getValue": () => Promise<RGB | string | undefined>;
        "listen": (listener: Editable.Observer.Listener) => Promise<void>;
        "looks"?: Looks;
        "name": string;
        /**
          * @default "rgb"
         */
        "output": "rgb" | "hex";
        /**
          * @default false
         */
        "readonly": boolean;
        "register": () => Promise<void>;
        "reset": () => Promise<void>;
        "setInitialValue": () => Promise<void>;
        /**
          * @default true
         */
        "showLabel": boolean;
        "unregister": () => Promise<void>;
        /**
          * @default undefined
         */
        "value": string | undefined;
    }
    interface SmoothlyInputColorDemo {
    }
    interface SmoothlyInputDate {
        /**
          * @default false
         */
        "alwaysShowGuide": boolean;
        "clear": () => Promise<void>;
        "color"?: Color;
        "disabled"?: boolean;
        "edit": (editable: boolean) => Promise<void>;
        "errorMessage"?: string;
        "getValue": () => Promise<isoly.Date | undefined>;
        /**
          * @default false
         */
        "invalid"?: boolean;
        "listen": (listener: Editable.Observer.Listener) => Promise<void>;
        "locale"?: isoly.Locale;
        "looks"?: Looks;
        "max": isoly.Date;
        "min": isoly.Date;
        "name": string;
        "open": boolean;
        "placeholder"?: string;
        /**
          * @default false
         */
        "readonly": boolean;
        "register": () => Promise<void>;
        "reset": () => Promise<void>;
        "setInitialValue": () => Promise<void>;
        /**
          * @default true
         */
        "showLabel": boolean;
        "unregister": () => Promise<void>;
        "value"?: isoly.Date;
    }
    interface SmoothlyInputDateDemo {
    }
    interface SmoothlyInputDateRange {
        /**
          * @default false
         */
        "alwaysShowGuide": boolean;
        "clear": () => Promise<void>;
        "color"?: Color;
        "disabled"?: boolean;
        "edit": (editable: boolean) => Promise<void>;
        "end": isoly.Date | undefined;
        "errorMessage"?: string;
        "getValue": () => Promise<Partial<isoly.DateRange> | undefined>;
        /**
          * @default false
         */
        "invalid"?: boolean;
        "listen": (listener: Editable.Observer.Listener) => Promise<void>;
        "locale"?: isoly.Locale;
        "looks"?: Looks;
        "max"?: isoly.Date;
        "min"?: isoly.Date;
        /**
          * @default "dateRange"
         */
        "name": string;
        "placeholder": string;
        /**
          * @default false
         */
        "readonly": boolean;
        "register": () => Promise<void>;
        "reset": () => Promise<void>;
        "setInitialValue": () => Promise<void>;
        /**
          * @default true
         */
        "showLabel": boolean;
        "start": isoly.Date | undefined;
        "unregister": () => Promise<void>;
    }
    interface SmoothlyInputDateTime {
        "clear": () => Promise<void>;
        "color"?: Color;
        "disabled"?: boolean;
        "edit": (editable: boolean) => Promise<void>;
        "errorMessage"?: string;
        "getValue": () => Promise<isoly.DateTime | undefined>;
        /**
          * @default false
         */
        "invalid"?: boolean;
        "listen": (listener: Editable.Observer.Listener) => Promise<void>;
        "looks"?: Looks;
        "max"?: isoly.DateTime;
        "min"?: isoly.DateTime;
        "name": string;
        "open": boolean;
        /**
          * @default false
         */
        "readonly": boolean;
        "register": () => Promise<void>;
        "reset": () => Promise<void>;
        "setInitialValue": () => Promise<void>;
        /**
          * @default true
         */
        "showLabel": boolean;
        "unregister": () => Promise<void>;
        "value"?: isoly.DateTime;
    }
    interface SmoothlyInputDemo {
    }
    interface SmoothlyInputDemoRadio {
    }
    interface SmoothlyInputDemoStandard {
    }
    interface SmoothlyInputDemoUserInput {
    }
    interface SmoothlyInputEdit {
        /**
          * @default "tertiary"
         */
        "color"?: Color;
        /**
          * @default false
         */
        "disabled": boolean;
        /**
          * @default true
         */
        "display": boolean;
        "expand"?: "block" | "full";
        "fill"?: Fill;
        "shape"?: "rounded";
        "size": "flexible" | "small" | "large" | "icon";
        /**
          * @default "Edit"
         */
        "tooltip": string;
        /**
          * @default "input"
         */
        "type": "form" | "input";
    }
    interface SmoothlyInputFile {
        "accept"?: string;
        "binary": () => Promise<boolean>;
        "camera": "front" | "back";
        "clear": () => Promise<void>;
        "color"?: Color;
        "disabled"?: boolean;
        "edit": (editable: boolean) => Promise<void>;
        "getValue": () => Promise<File | undefined>;
        "listen": (listener: Editable.Observer.Listener) => Promise<void>;
        "looks"?: Looks;
        "name": string;
        "placeholder": string | undefined;
        /**
          * @default false
         */
        "readonly": boolean;
        "register": () => Promise<void>;
        "reset": () => Promise<void>;
        "setInitialValue": () => Promise<void>;
        /**
          * @default true
         */
        "showLabel": boolean;
        "unregister": () => Promise<void>;
        "value"?: File;
    }
    interface SmoothlyInputMonth {
        "clear": () => Promise<void>;
        "color"?: Color;
        "edit": (editable: boolean) => Promise<void>;
        "getValue": () => Promise<isoly.Date | undefined>;
        /**
          * @default false
         */
        "inCalendar": boolean;
        "listen": (listener: Editable.Observer.Listener) => Promise<void>;
        "looks"?: Looks;
        "max"?: isoly.Date;
        "min"?: isoly.Date;
        "name": string;
        /**
          * @default false
         */
        "next": boolean;
        /**
          * @default false
         */
        "previous": boolean;
        "readonly": boolean;
        "register": () => Promise<void>;
        "reset": () => Promise<void>;
        "setInitialValue": () => Promise<void>;
        /**
          * @default true
         */
        "showLabel": boolean;
        "unregister": () => Promise<void>;
        /**
          * @default isoly.Date.now()
         */
        "value"?: isoly.Date;
    }
    interface SmoothlyInputPriceDemo {
    }
    interface SmoothlyInputRadio {
        "clear": () => Promise<void>;
        "clearable"?: boolean;
        "color"?: Color;
        "direction"?: "row" | "column";
        "disabled"?: boolean;
        "edit": (editable: boolean) => Promise<void>;
        "getValue": () => Promise<any | undefined>;
        "listen": (listener: Editable.Observer.Listener) => Promise<void>;
        "looks"?: Looks;
        "name": string;
        /**
          * @default false
         */
        "readonly": boolean;
        "register": () => Promise<void>;
        "reset": () => Promise<void>;
        "setInitialValue": () => Promise<void>;
        /**
          * @default true
         */
        "showLabel": boolean;
        "unregister": () => Promise<void>;
        /**
          * @default undefined
         */
        "value": any;
    }
    interface SmoothlyInputRadioItem {
        "looks"?: Looks;
        "name": string;
        /**
          * @default false
         */
        "selected": boolean;
        "value": any;
    }
    interface SmoothlyInputRange {
        "clear": () => Promise<void>;
        "color"?: Color;
        /**
          * @default false
         */
        "defined": boolean;
        "disabled"?: boolean;
        "edit": (editable: boolean) => Promise<void>;
        "getValue": () => Promise<number | undefined>;
        "label": string;
        "listen": (listener: Editable.Observer.Listener) => Promise<void>;
        "looks"?: Looks;
        /**
          * @default 100
         */
        "max": number;
        /**
          * @default 0
         */
        "min": number;
        /**
          * @default "range"
         */
        "name": string;
        /**
          * @default "left"
         */
        "outputSide": "right" | "left";
        /**
          * @default false
         */
        "readonly": boolean;
        "register": () => Promise<void>;
        "reset": () => Promise<void>;
        "setInitialValue": () => Promise<void>;
        "step"?: number;
        /**
          * @default "text"
         */
        "type": Extract<tidily.Type, "text" | "percent">;
        "unregister": () => Promise<void>;
        /**
          * @default undefined
         */
        "value": number | undefined;
    }
    interface SmoothlyInputRangeDemo {
    }
    interface SmoothlyInputReset {
        "color"?: Color;
        "disabled"?: boolean;
        /**
          * @default true
         */
        "display": boolean;
        "expand"?: "block" | "full";
        "fill"?: Fill;
        "shape"?: "rounded";
        /**
          * @default "icon"
         */
        "size": "flexible" | "small" | "large" | "icon";
        /**
          * @default "Reset"
         */
        "tooltip": string;
        /**
          * @default "input"
         */
        "type": "form" | "input";
    }
    interface SmoothlyInputSelect {
        "clear": () => Promise<void>;
        /**
          * @default true
         */
        "clearable": boolean;
        "color"?: Color;
        /**
          * @default false
         */
        "defined": boolean;
        /**
          * @default false
         */
        "disabled": boolean;
        "edit": (editable: boolean) => Promise<void>;
        "errorMessage"?: string;
        "getItems": () => Promise<HTMLSmoothlyItemElement[]>;
        "getValue": () => Promise<any | any[] | undefined>;
        /**
          * @default false
         */
        "inCalendar": boolean;
        /**
          * @default false
         */
        "invalid"?: boolean;
        "listen": (listener: Editable.Observer.Listener) => Promise<void>;
        "looks"?: Looks;
        "menuHeight"?: layout.MenuHeight;
        /**
          * @default false
         */
        "multiple": boolean;
        /**
          * @default false
         */
        "mutable": boolean;
        /**
          * @default "selected"
         */
        "name": string;
        "ordered"?: boolean;
        "placeholder"?: string | any;
        /**
          * @default false
         */
        "readonly": boolean;
        "register": () => Promise<void>;
        /**
          * @default false
         */
        "required": boolean;
        "reset": () => Promise<void>;
        /**
          * @default false
         */
        "searchDisabled": boolean;
        "setInitialValue": () => Promise<void>;
        /**
          * @default true
         */
        "showLabel": boolean;
        /**
          * @default true
         */
        "showSelected"?: boolean;
        "unregister": () => Promise<void>;
    }
    interface SmoothlyInputSubmit {
        "color"?: Color;
        /**
          * @default false
         */
        "delete": boolean;
        /**
          * @default false
         */
        "disabled": boolean;
        /**
          * @default false
         */
        "display": boolean;
        "expand"?: "block" | "full";
        "fill"?: Fill;
        /**
          * @default "checkmark-outline"
         */
        "icon": Icon | false;
        "shape"?: "rounded";
        /**
          * @default "icon"
         */
        "size": "flexible" | "small" | "large" | "icon";
        /**
          * @default this.delete ? "Remove" : "Submit"
         */
        "tooltip": string;
    }
    interface SmoothlyItem {
        /**
          * @default true
         */
        "deselectable": boolean;
        /**
          * @default false
         */
        "disabled": boolean;
        "filter": (filter: string) => Promise<void>;
        "marked": boolean;
        /**
          * @default false
         */
        "selected": boolean;
        "value": any;
    }
    interface SmoothlyLabel {
        "description"?: string;
        "hue"?: number;
        "shape": "rectangle" | "rounded";
    }
    interface SmoothlyLazy {
        "content"?: VNode | FunctionalComponent;
        /**
          * @default false
         */
        "show": boolean;
    }
    interface SmoothlyLoadMore {
        /**
          * @default false
         */
        "multiple": boolean;
        /**
          * @default ""
         */
        "name": string;
        /**
          * @default "intersection"
         */
        "triggerMode": "scroll" | "intersection";
    }
    interface SmoothlyModal {
        /**
          * @default "center"
         */
        "align": "top" | "center";
        /**
          * @default false
         */
        "closable": boolean;
        "closeModal": () => Promise<void>;
        /**
          * @default false
         */
        "open": boolean;
        "openModal": () => Promise<void>;
    }
    interface SmoothlyNotification {
        /**
          * @default true
         */
        "closable": boolean;
        "icon": boolean;
        "notice": Notice;
    }
    interface SmoothlyNotifier {
        /**
          * @default false
         */
        "icon": boolean;
    }
    interface SmoothlyNotifierDemo {
    }
    interface SmoothlySpinner {
        "overlay": boolean;
        /**
          * @default "large"
         */
        "size": "small" | "icon" | "medium" | "large";
    }
    interface SmoothlySubmit {
        /**
          * @default "success"
         */
        "color"?: Color;
        /**
          * @default false
         */
        "disabled": boolean;
        "expand"?: "block" | "full";
        "fill"?: Fill;
        /**
          * @default true
         */
        "prevent": boolean;
        "shape"?: "rounded";
        "size": "flexible" | "small" | "large" | "icon";
        "type": "link" | "button";
    }
    interface SmoothlySummary {
        /**
          * @default false
         */
        "open": boolean;
    }
    interface SmoothlyTab {
        "disabled": boolean;
        "label": string;
        "name": string;
        "open": boolean;
        "tooltip": string;
    }
    interface SmoothlyTable {
        /**
          * @default 1
         */
        "columns": number;
    }
    interface SmoothlyTableBody {
    }
    interface SmoothlyTableCell {
        /**
          * @default 1
         */
        "span"?: number;
    }
    interface SmoothlyTableDemo {
    }
    interface SmoothlyTableDemoColspan {
    }
    interface SmoothlyTableDemoFillerRow {
    }
    interface SmoothlyTableDemoGroup {
    }
    interface SmoothlyTableDemoNestedNoCell {
    }
    interface SmoothlyTableDemoNestedNoCellInner {
        "data"?: {
		id: number
		name: string
		age: number
		balance: number
	}[];
    }
    interface SmoothlyTableDemoSimple {
    }
    interface SmoothlyTableExpandableCell {
        "close": () => Promise<void>;
        /**
          * @default false
         */
        "open": boolean;
        /**
          * @default 1
         */
        "span"?: number;
    }
    interface SmoothlyTableExpandableRow {
        /**
          * @default false
         */
        "open": boolean;
    }
    interface SmoothlyTableFillerRow {
    }
    interface SmoothlyTableFoot {
    }
    interface SmoothlyTableHead {
    }
    interface SmoothlyTableRow {
    }
    interface SmoothlyTableRowGroup {
        /**
          * @default false
         */
        "align": boolean;
        /**
          * @default false
         */
        "open": boolean;
    }
    interface SmoothlyTabs {
        "numberOfTabs": number;
        "removeTab": (tab: HTMLSmoothlyTabElement) => Promise<void>;
        /**
          * @default "always"
         */
        "tabs": "always" | "multiple";
    }
    interface SmoothlyTabsDemo {
    }
    interface SmoothlyThemeColor {
        "color": Color;
    }
    interface SmoothlyThemeColorVariant {
        "color": Color;
        /**
          * @default "color"
         */
        "variant": "shade" | "tint" | "color";
    }
    interface SmoothlyThemeColors {
    }
    interface SmoothlyThemeDemo {
    }
    interface SmoothlyThemeGuide {
    }
    interface SmoothlyThemePicker {
        /**
          * @default "smoothly-css"
         */
        "element": string;
    }
    interface SmoothlyToggleSwitch {
        /**
          * @default true
         */
        "checkmark": boolean;
        /**
          * @default "medium"
         */
        "color": Color;
        /**
          * @default false
         */
        "disabled": boolean;
        /**
          * @default "clear"
         */
        "fill": Fill;
        /**
          * @default false
         */
        "selected": boolean;
        /**
          * @default "default"
         */
        "size": "tiny" | "small" | "default" | "large";
    }
    interface SmoothlyToggleSwitchDemo {
    }
    interface SmoothlyTrigger {
        "color": Color | undefined;
        /**
          * @default false
         */
        "disabled": boolean;
        "fill": Fill;
        "name": string;
        /**
          * @default "button"
         */
        "type": "link" | "button";
        "value"?: any;
    }
    interface SmoothlyTriggerSink {
        "context"?: Window;
        "destination": string;
        "filter"?: string;
    }
    interface SmoothlyTriggerSource {
        "listen": string;
    }
}
export interface SmoothlyAppCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLSmoothlyAppElement;
}
export interface SmoothlyAppRoomCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLSmoothlyAppRoomElement;
}
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;
}
export interface SmoothlyCheckboxCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLSmoothlyCheckboxElement;
}
export interface SmoothlyDateTextCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLSmoothlyDateTextElement;
}
export interface SmoothlyDisplayDemoCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLSmoothlyDisplayDemoElement;
}
export interface SmoothlyFormCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLSmoothlyFormElement;
}
export interface SmoothlyFormDemoDateCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLSmoothlyFormDemoDateElement;
}
export interface SmoothlyFormDemoDateRangeCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLSmoothlyFormDemoDateRangeElement;
}
export interface SmoothlyFrameCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLSmoothlyFrameElement;
}
export interface SmoothlyIconDemoCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLSmoothlyIconDemoElement;
}
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;
}
export interface SmoothlyInputDateRangeCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLSmoothlyInputDateRangeElement;
}
export interface SmoothlyInputDateTimeCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLSmoothlyInputDateTimeElement;
}
export interface SmoothlyInputDemoCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLSmoothlyInputDemoElement;
}
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 SmoothlyLoadMoreCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLSmoothlyLoadMoreElement;
}
export interface SmoothlyModalCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLSmoothlyModalElement;
}
export interface SmoothlyNotificationCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLSmoothlyNotificationElement;
}
export interface SmoothlyNotifierDemoCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLSmoothlyNotifierDemoElement;
}
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;
}
export interface SmoothlyTableExpandableCellCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLSmoothlyTableExpandableCellElement;
}
export interface SmoothlyTableExpandableRowCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLSmoothlyTableExpandableRowElement;
}
export interface SmoothlyTableRowGroupCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLSmoothlyTableRowGroupElement;
}
export interface SmoothlyTabsCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLSmoothlyTabsElement;
}
export interface SmoothlyToggleSwitchCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLSmoothlyToggleSwitchElement;
}
export interface SmoothlyTriggerCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLSmoothlyTriggerElement;
}
export interface SmoothlyTriggerSourceCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLSmoothlyTriggerSourceElement;
}
declare global {
    interface HTMLSmoothlyAppElementEventMap {
        "smoothlyUrlChange": string;
    }
    interface HTMLSmoothlyAppElement extends Components.SmoothlyApp, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyAppElementEventMap>(type: K, listener: (this: HTMLSmoothlyAppElement, ev: SmoothlyAppCustomEvent<HTMLSmoothlyAppElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyAppElementEventMap>(type: K, listener: (this: HTMLSmoothlyAppElement, ev: SmoothlyAppCustomEvent<HTMLSmoothlyAppElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyAppElement: {
        prototype: HTMLSmoothlyAppElement;
        new (): HTMLSmoothlyAppElement;
    };
    interface HTMLSmoothlyAppDemoElement extends Components.SmoothlyAppDemo, HTMLStencilElement {
    }
    var HTMLSmoothlyAppDemoElement: {
        prototype: HTMLSmoothlyAppDemoElement;
        new (): HTMLSmoothlyAppDemoElement;
    };
    interface HTMLSmoothlyAppRoomElementEventMap {
        "smoothlyRoomSelect": { history: boolean; path: string; query?: string };
        "smoothlyRoomLoad": { selected: boolean };
        "smoothlyUrlChange": string;
    }
    interface HTMLSmoothlyAppRoomElement extends Components.SmoothlyAppRoom, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyAppRoomElementEventMap>(type: K, listener: (this: HTMLSmoothlyAppRoomElement, ev: SmoothlyAppRoomCustomEvent<HTMLSmoothlyAppRoomElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyAppRoomElementEventMap>(type: K, listener: (this: HTMLSmoothlyAppRoomElement, ev: SmoothlyAppRoomCustomEvent<HTMLSmoothlyAppRoomElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyAppRoomElement: {
        prototype: HTMLSmoothlyAppRoomElement;
        new (): HTMLSmoothlyAppRoomElement;
    };
    interface HTMLSmoothlyBackToTopElement extends Components.SmoothlyBackToTop, HTMLStencilElement {
    }
    var HTMLSmoothlyBackToTopElement: {
        prototype: HTMLSmoothlyBackToTopElement;
        new (): HTMLSmoothlyBackToTopElement;
    };
    interface HTMLSmoothlyBurgerElementEventMap {
        "smoothlyNavStatus": boolean;
    }
    interface HTMLSmoothlyBurgerElement extends Components.SmoothlyBurger, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyBurgerElementEventMap>(type: K, listener: (this: HTMLSmoothlyBurgerElement, ev: SmoothlyBurgerCustomEvent<HTMLSmoothlyBurgerElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyBurgerElementEventMap>(type: K, listener: (this: HTMLSmoothlyBurgerElement, ev: SmoothlyBurgerCustomEvent<HTMLSmoothlyBurgerElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyBurgerElement: {
        prototype: HTMLSmoothlyBurgerElement;
        new (): HTMLSmoothlyBurgerElement;
    };
    interface HTMLSmoothlyButtonElement extends Components.SmoothlyButton, HTMLStencilElement {
    }
    var HTMLSmoothlyButtonElement: {
        prototype: HTMLSmoothlyButtonElement;
        new (): HTMLSmoothlyButtonElement;
    };
    interface HTMLSmoothlyButtonConfirmElementEventMap {
        "smoothlyInputLoad": (parent: Editable) => void;
        "smoothlyConfirm": Data;
    }
    interface HTMLSmoothlyButtonConfirmElement extends Components.SmoothlyButtonConfirm, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyButtonConfirmElementEventMap>(type: K, listener: (this: HTMLSmoothlyButtonConfirmElement, ev: SmoothlyButtonConfirmCustomEvent<HTMLSmoothlyButtonConfirmElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyButtonConfirmElementEventMap>(type: K, listener: (this: HTMLSmoothlyButtonConfirmElement, ev: SmoothlyButtonConfirmCustomEvent<HTMLSmoothlyButtonConfirmElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyButtonConfirmElement: {
        prototype: HTMLSmoothlyButtonConfirmElement;
        new (): HTMLSmoothlyButtonConfirmElement;
    };
    interface HTMLSmoothlyButtonDemoElement extends Components.SmoothlyButtonDemo, HTMLStencilElement {
    }
    var HTMLSmoothlyButtonDemoElement: {
        prototype: HTMLSmoothlyButtonDemoElement;
        new (): HTMLSmoothlyButtonDemoElement;
    };
    interface HTMLSmoothlyButtonDemoStandardElement extends Components.SmoothlyButtonDemoStandard, HTMLStencilElement {
    }
    var HTMLSmoothlyButtonDemoStandardElement: {
        prototype: HTMLSmoothlyButtonDemoStandardElement;
        new (): HTMLSmoothlyButtonDemoStandardElement;
    };
    interface HTMLSmoothlyCalendarElementEventMap {
        "smoothlyDateSet": isoly.Date;
        "smoothlyDateRangeSet": isoly.DateRange;
    }
    interface HTMLSmoothlyCalendarElement extends Components.SmoothlyCalendar, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyCalendarElementEventMap>(type: K, listener: (this: HTMLSmoothlyCalendarElement, ev: SmoothlyCalendarCustomEvent<HTMLSmoothlyCalendarElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyCalendarElementEventMap>(type: K, listener: (this: HTMLSmoothlyCalendarElement, ev: SmoothlyCalendarCustomEvent<HTMLSmoothlyCalendarElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyCalendarElement: {
        prototype: HTMLSmoothlyCalendarElement;
        new (): HTMLSmoothlyCalendarElement;
    };
    interface HTMLSmoothlyCheckboxElementEventMap {
        "smoothlyInput": Record<string, any>;
    }
    interface HTMLSmoothlyCheckboxElement extends Components.SmoothlyCheckbox, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyCheckboxElementEventMap>(type: K, listener: (this: HTMLSmoothlyCheckboxElement, ev: SmoothlyCheckboxCustomEvent<HTMLSmoothlyCheckboxElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyCheckboxElementEventMap>(type: K, listener: (this: HTMLSmoothlyCheckboxElement, ev: SmoothlyCheckboxCustomEvent<HTMLSmoothlyCheckboxElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyCheckboxElement: {
        prototype: HTMLSmoothlyCheckboxElement;
        new (): HTMLSmoothlyCheckboxElement;
    };
    interface HTMLSmoothlyColorElement extends Components.SmoothlyColor, HTMLStencilElement {
    }
    var HTMLSmoothlyColorElement: {
        prototype: HTMLSmoothlyColorElement;
        new (): HTMLSmoothlyColorElement;
    };
    interface HTMLSmoothlyCountryElement extends Components.SmoothlyCountry, HTMLStencilElement {
    }
    var HTMLSmoothlyCountryElement: {
        prototype: HTMLSmoothlyCountryElement;
        new (): HTMLSmoothlyCountryElement;
    };
    interface HTMLSmoothlyDateTextElementEventMap {
        "smoothlyDateTextHasText": boolean;
        "smoothlyDateTextChange": isoly.Date | undefined;
        "smoothlyDateTextFocusChange": boolean;
        "smoothlyDateHasPartialDate": DateFormat.Parts;
        "smoothlyDateTextDone": void;
        "smoothlyDateTextPrevious": void;
        "smoothlyDateTextNext": void;
    }
    interface HTMLSmoothlyDateTextElement extends Components.SmoothlyDateText, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyDateTextElementEventMap>(type: K, listener: (this: HTMLSmoothlyDateTextElement, ev: SmoothlyDateTextCustomEvent<HTMLSmoothlyDateTextElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyDateTextElementEventMap>(type: K, listener: (this: HTMLSmoothlyDateTextElement, ev: SmoothlyDateTextCustomEvent<HTMLSmoothlyDateTextElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyDateTextElement: {
        prototype: HTMLSmoothlyDateTextElement;
        new (): HTMLSmoothlyDateTextElement;
    };
    interface HTMLSmoothlyDialogElement extends Components.SmoothlyDialog, HTMLStencilElement {
    }
    var HTMLSmoothlyDialogElement: {
        prototype: HTMLSmoothlyDialogElement;
        new (): HTMLSmoothlyDialogElement;
    };
    interface HTMLSmoothlyDialogDemoElement extends Components.SmoothlyDialogDemo, HTMLStencilElement {
    }
    var HTMLSmoothlyDialogDemoElement: {
        prototype: HTMLSmoothlyDialogDemoElement;
        new (): HTMLSmoothlyDialogDemoElement;
    };
    interface HTMLSmoothlyDisplayElement extends Components.SmoothlyDisplay, HTMLStencilElement {
    }
    var HTMLSmoothlyDisplayElement: {
        prototype: HTMLSmoothlyDisplayElement;
        new (): HTMLSmoothlyDisplayElement;
    };
    interface HTMLSmoothlyDisplayDemoElementEventMap {
        "notice": Notice;
    }
    interface HTMLSmoothlyDisplayDemoElement extends Components.SmoothlyDisplayDemo, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyDisplayDemoElementEventMap>(type: K, listener: (this: HTMLSmoothlyDisplayDemoElement, ev: SmoothlyDisplayDemoCustomEvent<HTMLSmoothlyDisplayDemoElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyDisplayDemoElementEventMap>(type: K, listener: (this: HTMLSmoothlyDisplayDemoElement, ev: SmoothlyDisplayDemoCustomEvent<HTMLSmoothlyDisplayDemoElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyDisplayDemoElement: {
        prototype: HTMLSmoothlyDisplayDemoElement;
        new (): HTMLSmoothlyDisplayDemoElement;
    };
    interface HTMLSmoothlyDisplayDemoJsonElement extends Components.SmoothlyDisplayDemoJson, HTMLStencilElement {
    }
    var HTMLSmoothlyDisplayDemoJsonElement: {
        prototype: HTMLSmoothlyDisplayDemoJsonElement;
        new (): HTMLSmoothlyDisplayDemoJsonElement;
    };
    interface HTMLSmoothlyDisplayJsonElement extends Components.SmoothlyDisplayJson, HTMLStencilElement {
    }
    var HTMLSmoothlyDisplayJsonElement: {
        prototype: HTMLSmoothlyDisplayJsonElement;
        new (): HTMLSmoothlyDisplayJsonElement;
    };
    interface HTMLSmoothlyDisplayJsonObjectElement extends Components.SmoothlyDisplayJsonObject, HTMLStencilElement {
    }
    var HTMLSmoothlyDisplayJsonObjectElement: {
        prototype: HTMLSmoothlyDisplayJsonObjectElement;
        new (): HTMLSmoothlyDisplayJsonObjectElement;
    };
    interface HTMLSmoothlyDisplayJsonPrimitiveElement extends Components.SmoothlyDisplayJsonPrimitive, HTMLStencilElement {
    }
    var HTMLSmoothlyDisplayJsonPrimitiveElement: {
        prototype: HTMLSmoothlyDisplayJsonPrimitiveElement;
        new (): HTMLSmoothlyDisplayJsonPrimitiveElement;
    };
    interface HTMLSmoothlyDisplayJsonRecordKeyElement extends Components.SmoothlyDisplayJsonRecordKey, HTMLStencilElement {
    }
    var HTMLSmoothlyDisplayJsonRecordKeyElement: {
        prototype: HTMLSmoothlyDisplayJsonRecordKeyElement;
        new (): HTMLSmoothlyDisplayJsonRecordKeyElement;
    };
    interface HTMLSmoothlyFormElementEventMap {
        "smoothlyFormDisable": (disabled: boolean) => void;
        "smoothlyFormInput": Data;
        "smoothlyFormSubmit": Submit;
        "smoothlyFormReset": void;
        "smoothlyFormEdit": boolean;
        "smoothlyFormClear": void;
        "notice": Notice;
    }
    interface HTMLSmoothlyFormElement extends Components.SmoothlyForm, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyFormElementEventMap>(type: K, listener: (this: HTMLSmoothlyFormElement, ev: SmoothlyFormCustomEvent<HTMLSmoothlyFormElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyFormElementEventMap>(type: K, listener: (this: HTMLSmoothlyFormElement, ev: SmoothlyFormCustomEvent<HTMLSmoothlyFormElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyFormElement: {
        prototype: HTMLSmoothlyFormElement;
        new (): HTMLSmoothlyFormElement;
    };
    interface HTMLSmoothlyFormDemoElement extends Components.SmoothlyFormDemo, HTMLStencilElement {
    }
    var HTMLSmoothlyFormDemoElement: {
        prototype: HTMLSmoothlyFormDemoElement;
        new (): HTMLSmoothlyFormDemoElement;
    };
    interface HTMLSmoothlyFormDemoAllElement extends Components.SmoothlyFormDemoAll, HTMLStencilElement {
    }
    var HTMLSmoothlyFormDemoAllElement: {
        prototype: HTMLSmoothlyFormDemoAllElement;
        new (): HTMLSmoothlyFormDemoAllElement;
    };
    interface HTMLSmoothlyFormDemoCardElement extends Components.SmoothlyFormDemoCard, HTMLStencilElement {
    }
    var HTMLSmoothlyFormDemoCardElement: {
        prototype: HTMLSmoothlyFormDemoCardElement;
        new (): HTMLSmoothlyFormDemoCardElement;
    };
    interface HTMLSmoothlyFormDemoControlledElement extends Components.SmoothlyFormDemoControlled, HTMLStencilElement {
    }
    var HTMLSmoothlyFormDemoControlledElement: {
        prototype: HTMLSmoothlyFormDemoControlledElement;
        new (): HTMLSmoothlyFormDemoControlledElement;
    };
    interface HTMLSmoothlyFormDemoDateElementEventMap {
        "notice": Notice;
    }
    interface HTMLSmoothlyFormDemoDateElement extends Components.SmoothlyFormDemoDate, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyFormDemoDateElementEventMap>(type: K, listener: (this: HTMLSmoothlyFormDemoDateElement, ev: SmoothlyFormDemoDateCustomEvent<HTMLSmoothlyFormDemoDateElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyFormDemoDateElementEventMap>(type: K, listener: (this: HTMLSmoothlyFormDemoDateElement, ev: SmoothlyFormDemoDateCustomEvent<HTMLSmoothlyFormDemoDateElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyFormDemoDateElement: {
        prototype: HTMLSmoothlyFormDemoDateElement;
        new (): HTMLSmoothlyFormDemoDateElement;
    };
    interface HTMLSmoothlyFormDemoDateRangeElementEventMap {
        "notice": Notice;
    }
    interface HTMLSmoothlyFormDemoDateRangeElement extends Components.SmoothlyFormDemoDateRange, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyFormDemoDateRangeElementEventMap>(type: K, listener: (this: HTMLSmoothlyFormDemoDateRangeElement, ev: SmoothlyFormDemoDateRangeCustomEvent<HTMLSmoothlyFormDemoDateRangeElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyFormDemoDateRangeElementEventMap>(type: K, listener: (this: HTMLSmoothlyFormDemoDateRangeElement, ev: SmoothlyFormDemoDateRangeCustomEvent<HTMLSmoothlyFormDemoDateRangeElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyFormDemoDateRangeElement: {
        prototype: HTMLSmoothlyFormDemoDateRangeElement;
        new (): HTMLSmoothlyFormDemoDateRangeElement;
    };
    interface HTMLSmoothlyFormDemoLoginElement extends Components.SmoothlyFormDemoLogin, HTMLStencilElement {
    }
    var HTMLSmoothlyFormDemoLoginElement: {
        prototype: HTMLSmoothlyFormDemoLoginElement;
        new (): HTMLSmoothlyFormDemoLoginElement;
    };
    interface HTMLSmoothlyFormDemoPetElement extends Components.SmoothlyFormDemoPet, HTMLStencilElement {
    }
    var HTMLSmoothlyFormDemoPetElement: {
        prototype: HTMLSmoothlyFormDemoPetElement;
        new (): HTMLSmoothlyFormDemoPetElement;
    };
    interface HTMLSmoothlyFormDemoPricesElement extends Components.SmoothlyFormDemoPrices, HTMLStencilElement {
    }
    var HTMLSmoothlyFormDemoPricesElement: {
        prototype: HTMLSmoothlyFormDemoPricesElement;
        new (): HTMLSmoothlyFormDemoPricesElement;
    };
    interface HTMLSmoothlyFormDemoScheduleElement extends Components.SmoothlyFormDemoSchedule, HTMLStencilElement {
    }
    var HTMLSmoothlyFormDemoScheduleElement: {
        prototype: HTMLSmoothlyFormDemoScheduleElement;
        new (): HTMLSmoothlyFormDemoScheduleElement;
    };
    interface HTMLSmoothlyFormDemoTransparentElement extends Components.SmoothlyFormDemoTransparent, HTMLStencilElement {
    }
    var HTMLSmoothlyFormDemoTransparentElement: {
        prototype: HTMLSmoothlyFormDemoTransparentElement;
        new (): HTMLSmoothlyFormDemoTransparentElement;
    };
    interface HTMLSmoothlyFormDemoTypedElement extends Components.SmoothlyFormDemoTyped, HTMLStencilElement {
    }
    var HTMLSmoothlyFormDemoTypedElement: {
        prototype: HTMLSmoothlyFormDemoTypedElement;
        new (): HTMLSmoothlyFormDemoTypedElement;
    };
    interface HTMLSmoothlyFrameElementEventMap {
        "trigger": Trigger;
        "message2": Message<any>;
    }
    interface HTMLSmoothlyFrameElement extends Components.SmoothlyFrame, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyFrameElementEventMap>(type: K, listener: (this: HTMLSmoothlyFrameElement, ev: SmoothlyFrameCustomEvent<HTMLSmoothlyFrameElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyFrameElementEventMap>(type: K, listener: (this: HTMLSmoothlyFrameElement, ev: SmoothlyFrameCustomEvent<HTMLSmoothlyFrameElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyFrameElement: {
        prototype: HTMLSmoothlyFrameElement;
        new (): HTMLSmoothlyFrameElement;
    };
    interface HTMLSmoothlyIconElement extends Components.SmoothlyIcon, HTMLStencilElement {
    }
    var HTMLSmoothlyIconElement: {
        prototype: HTMLSmoothlyIconElement;
        new (): HTMLSmoothlyIconElement;
    };
    interface HTMLSmoothlyIconDemoElementEventMap {
        "notice": Notice;
    }
    interface HTMLSmoothlyIconDemoElement extends Components.SmoothlyIconDemo, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyIconDemoElementEventMap>(type: K, listener: (this: HTMLSmoothlyIconDemoElement, ev: SmoothlyIconDemoCustomEvent<HTMLSmoothlyIconDemoElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyIconDemoElementEventMap>(type: K, listener: (this: HTMLSmoothlyIconDemoElement, ev: SmoothlyIconDemoCustomEvent<HTMLSmoothlyIconDemoElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyIconDemoElement: {
        prototype: HTMLSmoothlyIconDemoElement;
        new (): HTMLSmoothlyIconDemoElement;
    };
    interface HTMLSmoothlyInputElementEventMap {
        "smoothlyInputLooks": (looks?: Looks, color?: Color) => void;
        "smoothlyInputLoad": (parent: Editable) => void;
        "smoothlyFormDisable": (disabled: boolean) => void;
        "smoothlyKeydown": Key;
        "smoothlyBlur": void;
        "smoothlyChange": Record<string, any>;
        "smoothlyInput": Record<string, any>;
        "smoothlyUserInput": Input.UserInput;
    }
    interface HTMLSmoothlyInputElement extends Components.SmoothlyInput, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyInputElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputElement, ev: SmoothlyInputCustomEvent<HTMLSmoothlyInputElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyInputElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputElement, ev: SmoothlyInputCustomEvent<HTMLSmoothlyInputElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyInputElement: {
        prototype: HTMLSmoothlyInputElement;
        new (): HTMLSmoothlyInputElement;
    };
    interface HTMLSmoothlyInputCheckboxElementEventMap {
        "smoothlyInputLooks": (looks?: Looks, color?: Color) => void;
        "smoothlyInput": Data;
        "smoothlyUserInput": Input.UserInput;
        "smoothlyInputLoad": (parent: Editable) => void;
        "smoothlyFormDisable": (disabled: boolean) => void;
    }
    interface HTMLSmoothlyInputCheckboxElement extends Components.SmoothlyInputCheckbox, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyInputCheckboxElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputCheckboxElement, ev: SmoothlyInputCheckboxCustomEvent<HTMLSmoothlyInputCheckboxElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyInputCheckboxElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputCheckboxElement, ev: SmoothlyInputCheckboxCustomEvent<HTMLSmoothlyInputCheckboxElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyInputCheckboxElement: {
        prototype: HTMLSmoothlyInputCheckboxElement;
        new (): HTMLSmoothlyInputCheckboxElement;
    };
    interface HTMLSmoothlyInputCheckboxDemoElement extends Components.SmoothlyInputCheckboxDemo, HTMLStencilElement {
    }
    var HTMLSmoothlyInputCheckboxDemoElement: {
        prototype: HTMLSmoothlyInputCheckboxDemoElement;
        new (): HTMLSmoothlyInputCheckboxDemoElement;
    };
    interface HTMLSmoothlyInputClearElementEventMap {
        "smoothlyInputLoad": (parent: Editable) => void;
    }
    interface HTMLSmoothlyInputClearElement extends Components.SmoothlyInputClear, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyInputClearElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputClearElement, ev: SmoothlyInputClearCustomEvent<HTMLSmoothlyInputClearElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyInputClearElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputClearElement, ev: SmoothlyInputClearCustomEvent<HTMLSmoothlyInputClearElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyInputClearElement: {
        prototype: HTMLSmoothlyInputClearElement;
        new (): HTMLSmoothlyInputClearElement;
    };
    interface HTMLSmoothlyInputColorElementEventMap {
        "smoothlyInputLooks": (looks?: Looks, color?: Color) => void;
        "smoothlyInput": Record<string, any>;
        "smoothlyUserInput": Input.UserInput;
        "smoothlyInputLoad": (parent: Editable) => void;
        "smoothlyFormDisable": (disabled: boolean) => void;
    }
    interface HTMLSmoothlyInputColorElement extends Components.SmoothlyInputColor, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyInputColorElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputColorElement, ev: SmoothlyInputColorCustomEvent<HTMLSmoothlyInputColorElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyInputColorElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputColorElement, ev: SmoothlyInputColorCustomEvent<HTMLSmoothlyInputColorElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyInputColorElement: {
        prototype: HTMLSmoothlyInputColorElement;
        new (): HTMLSmoothlyInputColorElement;
    };
    interface HTMLSmoothlyInputColorDemoElement extends Components.SmoothlyInputColorDemo, HTMLStencilElement {
    }
    var HTMLSmoothlyInputColorDemoElement: {
        prototype: HTMLSmoothlyInputColorDemoElement;
        new (): HTMLSmoothlyInputColorDemoElement;
    };
    interface HTMLSmoothlyInputDateElementEventMap {
        "smoothlyInputLoad": (parent: Editable) => void;
        "smoothlyValueChange": isoly.Date;
        "smoothlyInput": Record<string, any>;
        "smoothlyUserInput": Input.UserInput;
        "smoothlyInputLooks": (looks?: Looks, color?: Color) => void;
        "smoothlyFormDisable": (disabled: boolean) => void;
    }
    interface HTMLSmoothlyInputDateElement extends Components.SmoothlyInputDate, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyInputDateElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputDateElement, ev: SmoothlyInputDateCustomEvent<HTMLSmoothlyInputDateElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyInputDateElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputDateElement, ev: SmoothlyInputDateCustomEvent<HTMLSmoothlyInputDateElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyInputDateElement: {
        prototype: HTMLSmoothlyInputDateElement;
        new (): HTMLSmoothlyInputDateElement;
    };
    interface HTMLSmoothlyInputDateDemoElement extends Components.SmoothlyInputDateDemo, HTMLStencilElement {
    }
    var HTMLSmoothlyInputDateDemoElement: {
        prototype: HTMLSmoothlyInputDateDemoElement;
        new (): HTMLSmoothlyInputDateDemoElement;
    };
    interface HTMLSmoothlyInputDateRangeElementEventMap {
        "smoothlyInput": { [name: string]: Partial<isoly.DateRange> | undefined };
        "smoothlyUserInput": Input.UserInput<Partial<isoly.DateRange> | undefined>;
        "smoothlyInputLoad": (parent: Editable) => void;
        "smoothlyInputLooks": (looks?: Looks, color?: Color) => void;
        "smoothlyFormDisable": (disabled: boolean) => void;
    }
    interface HTMLSmoothlyInputDateRangeElement extends Components.SmoothlyInputDateRange, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyInputDateRangeElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputDateRangeElement, ev: SmoothlyInputDateRangeCustomEvent<HTMLSmoothlyInputDateRangeElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyInputDateRangeElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputDateRangeElement, ev: SmoothlyInputDateRangeCustomEvent<HTMLSmoothlyInputDateRangeElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyInputDateRangeElement: {
        prototype: HTMLSmoothlyInputDateRangeElement;
        new (): HTMLSmoothlyInputDateRangeElement;
    };
    interface HTMLSmoothlyInputDateTimeElementEventMap {
        "smoothlyInputLoad": (parent: Editable) => void;
        "smoothlyValueChange": isoly.DateTime;
        "smoothlyInput": Record<string, any>;
        "smoothlyUserInput": Input.UserInput;
        "smoothlyInputLooks": (looks?: Looks, color?: Color) => void;
        "smoothlyFormDisable": (disabled: boolean) => void;
    }
    interface HTMLSmoothlyInputDateTimeElement extends Components.SmoothlyInputDateTime, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyInputDateTimeElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputDateTimeElement, ev: SmoothlyInputDateTimeCustomEvent<HTMLSmoothlyInputDateTimeElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyInputDateTimeElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputDateTimeElement, ev: SmoothlyInputDateTimeCustomEvent<HTMLSmoothlyInputDateTimeElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyInputDateTimeElement: {
        prototype: HTMLSmoothlyInputDateTimeElement;
        new (): HTMLSmoothlyInputDateTimeElement;
    };
    interface HTMLSmoothlyInputDemoElementEventMap {
        "smoothlyUrlUpdate": { path: string; query?: string };
    }
    interface HTMLSmoothlyInputDemoElement extends Components.SmoothlyInputDemo, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyInputDemoElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputDemoElement, ev: SmoothlyInputDemoCustomEvent<HTMLSmoothlyInputDemoElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyInputDemoElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputDemoElement, ev: SmoothlyInputDemoCustomEvent<HTMLSmoothlyInputDemoElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyInputDemoElement: {
        prototype: HTMLSmoothlyInputDemoElement;
        new (): HTMLSmoothlyInputDemoElement;
    };
    interface HTMLSmoothlyInputDemoRadioElement extends Components.SmoothlyInputDemoRadio, HTMLStencilElement {
    }
    var HTMLSmoothlyInputDemoRadioElement: {
        prototype: HTMLSmoothlyInputDemoRadioElement;
        new (): HTMLSmoothlyInputDemoRadioElement;
    };
    interface HTMLSmoothlyInputDemoStandardElement extends Components.SmoothlyInputDemoStandard, HTMLStencilElement {
    }
    var HTMLSmoothlyInputDemoStandardElement: {
        prototype: HTMLSmoothlyInputDemoStandardElement;
        new (): HTMLSmoothlyInputDemoStandardElement;
    };
    interface HTMLSmoothlyInputDemoUserInputElement extends Components.SmoothlyInputDemoUserInput, HTMLStencilElement {
    }
    var HTMLSmoothlyInputDemoUserInputElement: {
        prototype: HTMLSmoothlyInputDemoUserInputElement;
        new (): HTMLSmoothlyInputDemoUserInputElement;
    };
    interface HTMLSmoothlyInputEditElementEventMap {
        "smoothlyInputLoad": (parent: Editable) => void;
    }
    interface HTMLSmoothlyInputEditElement extends Components.SmoothlyInputEdit, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyInputEditElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputEditElement, ev: SmoothlyInputEditCustomEvent<HTMLSmoothlyInputEditElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyInputEditElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputEditElement, ev: SmoothlyInputEditCustomEvent<HTMLSmoothlyInputEditElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyInputEditElement: {
        prototype: HTMLSmoothlyInputEditElement;
        new (): HTMLSmoothlyInputEditElement;
    };
    interface HTMLSmoothlyInputFileElementEventMap {
        "smoothlyInputLooks": (looks?: Looks, color?: Color) => void;
        "smoothlyInput": Record<string, any>;
        "smoothlyUserInput": Input.UserInput;
        "smoothlyInputLoad": (parent: Editable) => void;
        "smoothlyFormDisable": (disabled: boolean) => void;
    }
    interface HTMLSmoothlyInputFileElement extends Components.SmoothlyInputFile, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyInputFileElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputFileElement, ev: SmoothlyInputFileCustomEvent<HTMLSmoothlyInputFileElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyInputFileElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputFileElement, ev: SmoothlyInputFileCustomEvent<HTMLSmoothlyInputFileElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyInputFileElement: {
        prototype: HTMLSmoothlyInputFileElement;
        new (): HTMLSmoothlyInputFileElement;
    };
    interface HTMLSmoothlyInputMonthElementEventMap {
        "smoothlyInput": Data;
        "smoothlyUserInput": Input.UserInput;
        "smoothlyInputLoad": (parent: Editable) => void;
        "smoothlyFormDisable": (disabled: boolean) => void;
        "smoothlyInputLooks": (looks?: Looks, color?: Color) => void;
    }
    interface HTMLSmoothlyInputMonthElement extends Components.SmoothlyInputMonth, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyInputMonthElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputMonthElement, ev: SmoothlyInputMonthCustomEvent<HTMLSmoothlyInputMonthElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyInputMonthElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputMonthElement, ev: SmoothlyInputMonthCustomEvent<HTMLSmoothlyInputMonthElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyInputMonthElement: {
        prototype: HTMLSmoothlyInputMonthElement;
        new (): HTMLSmoothlyInputMonthElement;
    };
    interface HTMLSmoothlyInputPriceDemoElement extends Components.SmoothlyInputPriceDemo, HTMLStencilElement {
    }
    var HTMLSmoothlyInputPriceDemoElement: {
        prototype: HTMLSmoothlyInputPriceDemoElement;
        new (): HTMLSmoothlyInputPriceDemoElement;
    };
    interface HTMLSmoothlyInputRadioElementEventMap {
        "smoothlyInputLooks": (looks?: Looks, color?: Color) => void;
        "smoothlyInput": Data;
        "smoothlyUserInput": Input.UserInput;
        "smoothlyInputLoad": (parent: Editable) => void;
        "smoothlyFormDisable": (disabled: boolean) => void;
    }
    interface HTMLSmoothlyInputRadioElement extends Components.SmoothlyInputRadio, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyInputRadioElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputRadioElement, ev: SmoothlyInputRadioCustomEvent<HTMLSmoothlyInputRadioElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyInputRadioElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputRadioElement, ev: SmoothlyInputRadioCustomEvent<HTMLSmoothlyInputRadioElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyInputRadioElement: {
        prototype: HTMLSmoothlyInputRadioElement;
        new (): HTMLSmoothlyInputRadioElement;
    };
    interface HTMLSmoothlyInputRadioItemElementEventMap {
        "smoothlyRadioItemSelect": RadioItemSelect;
        "smoothlyRadioItemRegister": (parent: SmoothlyInputRadio) => void;
    }
    interface HTMLSmoothlyInputRadioItemElement extends Components.SmoothlyInputRadioItem, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyInputRadioItemElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputRadioItemElement, ev: SmoothlyInputRadioItemCustomEvent<HTMLSmoothlyInputRadioItemElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyInputRadioItemElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputRadioItemElement, ev: SmoothlyInputRadioItemCustomEvent<HTMLSmoothlyInputRadioItemElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyInputRadioItemElement: {
        prototype: HTMLSmoothlyInputRadioItemElement;
        new (): HTMLSmoothlyInputRadioItemElement;
    };
    interface HTMLSmoothlyInputRangeElementEventMap {
        "smoothlyInputLooks": (looks?: Looks, color?: Color) => void;
        "smoothlyInput": Record<string, any>;
        "smoothlyUserInput": Input.UserInput;
        "smoothlyInputLoad": (parent: Editable) => void;
        "smoothlyFormDisable": (disabled: boolean) => void;
    }
    interface HTMLSmoothlyInputRangeElement extends Components.SmoothlyInputRange, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyInputRangeElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputRangeElement, ev: SmoothlyInputRangeCustomEvent<HTMLSmoothlyInputRangeElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyInputRangeElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputRangeElement, ev: SmoothlyInputRangeCustomEvent<HTMLSmoothlyInputRangeElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyInputRangeElement: {
        prototype: HTMLSmoothlyInputRangeElement;
        new (): HTMLSmoothlyInputRangeElement;
    };
    interface HTMLSmoothlyInputRangeDemoElement extends Components.SmoothlyInputRangeDemo, HTMLStencilElement {
    }
    var HTMLSmoothlyInputRangeDemoElement: {
        prototype: HTMLSmoothlyInputRangeDemoElement;
        new (): HTMLSmoothlyInputRangeDemoElement;
    };
    interface HTMLSmoothlyInputResetElementEventMap {
        "smoothlyInputLoad": (parent: Editable) => void;
    }
    interface HTMLSmoothlyInputResetElement extends Components.SmoothlyInputReset, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyInputResetElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputResetElement, ev: SmoothlyInputResetCustomEvent<HTMLSmoothlyInputResetElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyInputResetElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputResetElement, ev: SmoothlyInputResetCustomEvent<HTMLSmoothlyInputResetElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyInputResetElement: {
        prototype: HTMLSmoothlyInputResetElement;
        new (): HTMLSmoothlyInputResetElement;
    };
    interface HTMLSmoothlyInputSelectElementEventMap {
        "smoothlyInput": Data;
        "smoothlyUserInput": Input.UserInput;
        "smoothlyInputLooks": (looks?: Looks, color?: Color) => void;
        "smoothlyInputLoad": (parent: Editable) => void;
        "smoothlyFormDisable": (disabled: boolean) => void;
        "smoothlyItemSelect": HTMLSmoothlyItemElement;
        "smoothlySelectOpen": boolean;
    }
    interface HTMLSmoothlyInputSelectElement extends Components.SmoothlyInputSelect, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyInputSelectElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputSelectElement, ev: SmoothlyInputSelectCustomEvent<HTMLSmoothlyInputSelectElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyInputSelectElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputSelectElement, ev: SmoothlyInputSelectCustomEvent<HTMLSmoothlyInputSelectElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyInputSelectElement: {
        prototype: HTMLSmoothlyInputSelectElement;
        new (): HTMLSmoothlyInputSelectElement;
    };
    interface HTMLSmoothlyInputSubmitElementEventMap {
        "smoothlyInputLoad": (parent: Editable) => void;
    }
    interface HTMLSmoothlyInputSubmitElement extends Components.SmoothlyInputSubmit, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyInputSubmitElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputSubmitElement, ev: SmoothlyInputSubmitCustomEvent<HTMLSmoothlyInputSubmitElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyInputSubmitElementEventMap>(type: K, listener: (this: HTMLSmoothlyInputSubmitElement, ev: SmoothlyInputSubmitCustomEvent<HTMLSmoothlyInputSubmitElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyInputSubmitElement: {
        prototype: HTMLSmoothlyInputSubmitElement;
        new (): HTMLSmoothlyInputSubmitElement;
    };
    interface HTMLSmoothlyItemElementEventMap {
        "smoothlyItemSelect": { userInitiated: boolean; item: HTMLSmoothlyItemElement };
        "smoothlyInputLoad": (parent: Editable) => void;
        "smoothlyItemDOMChange": void;
    }
    interface HTMLSmoothlyItemElement extends Components.SmoothlyItem, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyItemElementEventMap>(type: K, listener: (this: HTMLSmoothlyItemElement, ev: SmoothlyItemCustomEvent<HTMLSmoothlyItemElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyItemElementEventMap>(type: K, listener: (this: HTMLSmoothlyItemElement, ev: SmoothlyItemCustomEvent<HTMLSmoothlyItemElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var 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 HTMLSmoothlyLoadMoreElementEventMap {
        "smoothlyLoadMore": string;
    }
    interface HTMLSmoothlyLoadMoreElement extends Components.SmoothlyLoadMore, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyLoadMoreElementEventMap>(type: K, listener: (this: HTMLSmoothlyLoadMoreElement, ev: SmoothlyLoadMoreCustomEvent<HTMLSmoothlyLoadMoreElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyLoadMoreElementEventMap>(type: K, listener: (this: HTMLSmoothlyLoadMoreElement, ev: SmoothlyLoadMoreCustomEvent<HTMLSmoothlyLoadMoreElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyLoadMoreElement: {
        prototype: HTMLSmoothlyLoadMoreElement;
        new (): HTMLSmoothlyLoadMoreElement;
    };
    interface HTMLSmoothlyModalElementEventMap {
        "smoothlyModalChange": boolean;
    }
    interface HTMLSmoothlyModalElement extends Components.SmoothlyModal, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyModalElementEventMap>(type: K, listener: (this: HTMLSmoothlyModalElement, ev: SmoothlyModalCustomEvent<HTMLSmoothlyModalElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyModalElementEventMap>(type: K, listener: (this: HTMLSmoothlyModalElement, ev: SmoothlyModalCustomEvent<HTMLSmoothlyModalElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyModalElement: {
        prototype: HTMLSmoothlyModalElement;
        new (): HTMLSmoothlyModalElement;
    };
    interface HTMLSmoothlyNotificationElementEventMap {
        "remove": Notice;
    }
    interface HTMLSmoothlyNotificationElement extends Components.SmoothlyNotification, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyNotificationElementEventMap>(type: K, listener: (this: HTMLSmoothlyNotificationElement, ev: SmoothlyNotificationCustomEvent<HTMLSmoothlyNotificationElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyNotificationElementEventMap>(type: K, listener: (this: HTMLSmoothlyNotificationElement, ev: SmoothlyNotificationCustomEvent<HTMLSmoothlyNotificationElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyNotificationElement: {
        prototype: HTMLSmoothlyNotificationElement;
        new (): HTMLSmoothlyNotificationElement;
    };
    interface HTMLSmoothlyNotifierElement extends Components.SmoothlyNotifier, HTMLStencilElement {
    }
    var HTMLSmoothlyNotifierElement: {
        prototype: HTMLSmoothlyNotifierElement;
        new (): HTMLSmoothlyNotifierElement;
    };
    interface HTMLSmoothlyNotifierDemoElementEventMap {
        "notice": Notice;
    }
    interface HTMLSmoothlyNotifierDemoElement extends Components.SmoothlyNotifierDemo, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyNotifierDemoElementEventMap>(type: K, listener: (this: HTMLSmoothlyNotifierDemoElement, ev: SmoothlyNotifierDemoCustomEvent<HTMLSmoothlyNotifierDemoElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyNotifierDemoElementEventMap>(type: K, listener: (this: HTMLSmoothlyNotifierDemoElement, ev: SmoothlyNotifierDemoCustomEvent<HTMLSmoothlyNotifierDemoElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyNotifierDemoElement: {
        prototype: HTMLSmoothlyNotifierDemoElement;
        new (): HTMLSmoothlyNotifierDemoElement;
    };
    interface HTMLSmoothlySpinnerElement extends Components.SmoothlySpinner, HTMLStencilElement {
    }
    var HTMLSmoothlySpinnerElement: {
        prototype: HTMLSmoothlySpinnerElement;
        new (): HTMLSmoothlySpinnerElement;
    };
    interface HTMLSmoothlySubmitElementEventMap {
        "smoothlyInputLoad": (parent: Editable) => void;
    }
    interface HTMLSmoothlySubmitElement extends Components.SmoothlySubmit, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlySubmitElementEventMap>(type: K, listener: (this: HTMLSmoothlySubmitElement, ev: SmoothlySubmitCustomEvent<HTMLSmoothlySubmitElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlySubmitElementEventMap>(type: K, listener: (this: HTMLSmoothlySubmitElement, ev: SmoothlySubmitCustomEvent<HTMLSmoothlySubmitElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlySubmitElement: {
        prototype: HTMLSmoothlySubmitElement;
        new (): HTMLSmoothlySubmitElement;
    };
    interface HTMLSmoothlySummaryElementEventMap {
        "smoothlySummaryOpen": boolean;
    }
    interface HTMLSmoothlySummaryElement extends Components.SmoothlySummary, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlySummaryElementEventMap>(type: K, listener: (this: HTMLSmoothlySummaryElement, ev: SmoothlySummaryCustomEvent<HTMLSmoothlySummaryElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlySummaryElementEventMap>(type: K, listener: (this: HTMLSmoothlySummaryElement, ev: SmoothlySummaryCustomEvent<HTMLSmoothlySummaryElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlySummaryElement: {
        prototype: HTMLSmoothlySummaryElement;
        new (): HTMLSmoothlySummaryElement;
    };
    interface HTMLSmoothlyTabElementEventMap {
        "smoothlyTabOpen": string;
        "smoothlyTabLoad": (smoothlyTabs: SmoothlyTabs) => void;
    }
    interface HTMLSmoothlyTabElement extends Components.SmoothlyTab, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyTabElementEventMap>(type: K, listener: (this: HTMLSmoothlyTabElement, ev: SmoothlyTabCustomEvent<HTMLSmoothlyTabElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyTabElementEventMap>(type: K, listener: (this: HTMLSmoothlyTabElement, ev: SmoothlyTabCustomEvent<HTMLSmoothlyTabElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyTabElement: {
        prototype: HTMLSmoothlyTabElement;
        new (): HTMLSmoothlyTabElement;
    };
    interface HTMLSmoothlyTableElement extends Components.SmoothlyTable, HTMLStencilElement {
    }
    var HTMLSmoothlyTableElement: {
        prototype: HTMLSmoothlyTableElement;
        new (): HTMLSmoothlyTableElement;
    };
    interface HTMLSmoothlyTableBodyElement extends Components.SmoothlyTableBody, HTMLStencilElement {
    }
    var HTMLSmoothlyTableBodyElement: {
        prototype: HTMLSmoothlyTableBodyElement;
        new (): HTMLSmoothlyTableBodyElement;
    };
    interface HTMLSmoothlyTableCellElement extends Components.SmoothlyTableCell, HTMLStencilElement {
    }
    var HTMLSmoothlyTableCellElement: {
        prototype: HTMLSmoothlyTableCellElement;
        new (): HTMLSmoothlyTableCellElement;
    };
    interface HTMLSmoothlyTableDemoElement extends Components.SmoothlyTableDemo, HTMLStencilElement {
    }
    var HTMLSmoothlyTableDemoElement: {
        prototype: HTMLSmoothlyTableDemoElement;
        new (): HTMLSmoothlyTableDemoElement;
    };
    interface HTMLSmoothlyTableDemoColspanElement extends Components.SmoothlyTableDemoColspan, HTMLStencilElement {
    }
    var HTMLSmoothlyTableDemoColspanElement: {
        prototype: HTMLSmoothlyTableDemoColspanElement;
        new (): HTMLSmoothlyTableDemoColspanElement;
    };
    interface HTMLSmoothlyTableDemoFillerRowElement extends Components.SmoothlyTableDemoFillerRow, HTMLStencilElement {
    }
    var HTMLSmoothlyTableDemoFillerRowElement: {
        prototype: HTMLSmoothlyTableDemoFillerRowElement;
        new (): HTMLSmoothlyTableDemoFillerRowElement;
    };
    interface HTMLSmoothlyTableDemoGroupElement extends Components.SmoothlyTableDemoGroup, HTMLStencilElement {
    }
    var HTMLSmoothlyTableDemoGroupElement: {
        prototype: HTMLSmoothlyTableDemoGroupElement;
        new (): HTMLSmoothlyTableDemoGroupElement;
    };
    interface HTMLSmoothlyTableDemoNestedNoCellElement extends Components.SmoothlyTableDemoNestedNoCell, HTMLStencilElement {
    }
    var HTMLSmoothlyTableDemoNestedNoCellElement: {
        prototype: HTMLSmoothlyTableDemoNestedNoCellElement;
        new (): HTMLSmoothlyTableDemoNestedNoCellElement;
    };
    interface HTMLSmoothlyTableDemoNestedNoCellInnerElement extends Components.SmoothlyTableDemoNestedNoCellInner, HTMLStencilElement {
    }
    var HTMLSmoothlyTableDemoNestedNoCellInnerElement: {
        prototype: HTMLSmoothlyTableDemoNestedNoCellInnerElement;
        new (): HTMLSmoothlyTableDemoNestedNoCellInnerElement;
    };
    interface HTMLSmoothlyTableDemoSimpleElement extends Components.SmoothlyTableDemoSimple, HTMLStencilElement {
    }
    var HTMLSmoothlyTableDemoSimpleElement: {
        prototype: HTMLSmoothlyTableDemoSimpleElement;
        new (): HTMLSmoothlyTableDemoSimpleElement;
    };
    interface HTMLSmoothlyTableExpandableCellElementEventMap {
        "smoothlyTableExpandableCellChange": boolean;
        "smoothlyTableExpandableCellRegister": void;
    }
    interface HTMLSmoothlyTableExpandableCellElement extends Components.SmoothlyTableExpandableCell, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyTableExpandableCellElementEventMap>(type: K, listener: (this: HTMLSmoothlyTableExpandableCellElement, ev: SmoothlyTableExpandableCellCustomEvent<HTMLSmoothlyTableExpandableCellElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyTableExpandableCellElementEventMap>(type: K, listener: (this: HTMLSmoothlyTableExpandableCellElement, ev: SmoothlyTableExpandableCellCustomEvent<HTMLSmoothlyTableExpandableCellElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyTableExpandableCellElement: {
        prototype: HTMLSmoothlyTableExpandableCellElement;
        new (): HTMLSmoothlyTableExpandableCellElement;
    };
    interface HTMLSmoothlyTableExpandableRowElementEventMap {
        "smoothlyTableExpandableRowChange": boolean;
    }
    interface HTMLSmoothlyTableExpandableRowElement extends Components.SmoothlyTableExpandableRow, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyTableExpandableRowElementEventMap>(type: K, listener: (this: HTMLSmoothlyTableExpandableRowElement, ev: SmoothlyTableExpandableRowCustomEvent<HTMLSmoothlyTableExpandableRowElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyTableExpandableRowElementEventMap>(type: K, listener: (this: HTMLSmoothlyTableExpandableRowElement, ev: SmoothlyTableExpandableRowCustomEvent<HTMLSmoothlyTableExpandableRowElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyTableExpandableRowElement: {
        prototype: HTMLSmoothlyTableExpandableRowElement;
        new (): HTMLSmoothlyTableExpandableRowElement;
    };
    interface HTMLSmoothlyTableFillerRowElement extends Components.SmoothlyTableFillerRow, HTMLStencilElement {
    }
    var HTMLSmoothlyTableFillerRowElement: {
        prototype: HTMLSmoothlyTableFillerRowElement;
        new (): HTMLSmoothlyTableFillerRowElement;
    };
    interface HTMLSmoothlyTableFootElement extends Components.SmoothlyTableFoot, HTMLStencilElement {
    }
    var HTMLSmoothlyTableFootElement: {
        prototype: HTMLSmoothlyTableFootElement;
        new (): HTMLSmoothlyTableFootElement;
    };
    interface HTMLSmoothlyTableHeadElement extends Components.SmoothlyTableHead, HTMLStencilElement {
    }
    var HTMLSmoothlyTableHeadElement: {
        prototype: HTMLSmoothlyTableHeadElement;
        new (): HTMLSmoothlyTableHeadElement;
    };
    interface HTMLSmoothlyTableRowElement extends Components.SmoothlyTableRow, HTMLStencilElement {
    }
    var HTMLSmoothlyTableRowElement: {
        prototype: HTMLSmoothlyTableRowElement;
        new (): HTMLSmoothlyTableRowElement;
    };
    interface HTMLSmoothlyTableRowGroupElementEventMap {
        "smoothlyTableRowGroupChange": boolean;
    }
    interface HTMLSmoothlyTableRowGroupElement extends Components.SmoothlyTableRowGroup, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyTableRowGroupElementEventMap>(type: K, listener: (this: HTMLSmoothlyTableRowGroupElement, ev: SmoothlyTableRowGroupCustomEvent<HTMLSmoothlyTableRowGroupElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyTableRowGroupElementEventMap>(type: K, listener: (this: HTMLSmoothlyTableRowGroupElement, ev: SmoothlyTableRowGroupCustomEvent<HTMLSmoothlyTableRowGroupElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyTableRowGroupElement: {
        prototype: HTMLSmoothlyTableRowGroupElement;
        new (): HTMLSmoothlyTableRowGroupElement;
    };
    interface HTMLSmoothlyTabsElementEventMap {
        "smoothlyTabOpen": string;
    }
    interface HTMLSmoothlyTabsElement extends Components.SmoothlyTabs, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyTabsElementEventMap>(type: K, listener: (this: HTMLSmoothlyTabsElement, ev: SmoothlyTabsCustomEvent<HTMLSmoothlyTabsElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyTabsElementEventMap>(type: K, listener: (this: HTMLSmoothlyTabsElement, ev: SmoothlyTabsCustomEvent<HTMLSmoothlyTabsElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyTabsElement: {
        prototype: HTMLSmoothlyTabsElement;
        new (): HTMLSmoothlyTabsElement;
    };
    interface HTMLSmoothlyTabsDemoElement extends Components.SmoothlyTabsDemo, HTMLStencilElement {
    }
    var HTMLSmoothlyTabsDemoElement: {
        prototype: HTMLSmoothlyTabsDemoElement;
        new (): HTMLSmoothlyTabsDemoElement;
    };
    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 HTMLSmoothlyThemeDemoElement extends Components.SmoothlyThemeDemo, HTMLStencilElement {
    }
    var HTMLSmoothlyThemeDemoElement: {
        prototype: HTMLSmoothlyThemeDemoElement;
        new (): HTMLSmoothlyThemeDemoElement;
    };
    interface HTMLSmoothlyThemeGuideElement extends Components.SmoothlyThemeGuide, HTMLStencilElement {
    }
    var HTMLSmoothlyThemeGuideElement: {
        prototype: HTMLSmoothlyThemeGuideElement;
        new (): HTMLSmoothlyThemeGuideElement;
    };
    interface HTMLSmoothlyThemePickerElement extends Components.SmoothlyThemePicker, HTMLStencilElement {
    }
    var HTMLSmoothlyThemePickerElement: {
        prototype: HTMLSmoothlyThemePickerElement;
        new (): HTMLSmoothlyThemePickerElement;
    };
    interface HTMLSmoothlyToggleSwitchElementEventMap {
        "smoothlyToggleSwitchChange": boolean;
    }
    interface HTMLSmoothlyToggleSwitchElement extends Components.SmoothlyToggleSwitch, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyToggleSwitchElementEventMap>(type: K, listener: (this: HTMLSmoothlyToggleSwitchElement, ev: SmoothlyToggleSwitchCustomEvent<HTMLSmoothlyToggleSwitchElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyToggleSwitchElementEventMap>(type: K, listener: (this: HTMLSmoothlyToggleSwitchElement, ev: SmoothlyToggleSwitchCustomEvent<HTMLSmoothlyToggleSwitchElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyToggleSwitchElement: {
        prototype: HTMLSmoothlyToggleSwitchElement;
        new (): HTMLSmoothlyToggleSwitchElement;
    };
    interface HTMLSmoothlyToggleSwitchDemoElement extends Components.SmoothlyToggleSwitchDemo, HTMLStencilElement {
    }
    var HTMLSmoothlyToggleSwitchDemoElement: {
        prototype: HTMLSmoothlyToggleSwitchDemoElement;
        new (): HTMLSmoothlyToggleSwitchDemoElement;
    };
    interface HTMLSmoothlyTriggerElementEventMap {
        "trigger": Trigger;
    }
    interface HTMLSmoothlyTriggerElement extends Components.SmoothlyTrigger, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyTriggerElementEventMap>(type: K, listener: (this: HTMLSmoothlyTriggerElement, ev: SmoothlyTriggerCustomEvent<HTMLSmoothlyTriggerElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyTriggerElementEventMap>(type: K, listener: (this: HTMLSmoothlyTriggerElement, ev: SmoothlyTriggerCustomEvent<HTMLSmoothlyTriggerElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyTriggerElement: {
        prototype: HTMLSmoothlyTriggerElement;
        new (): HTMLSmoothlyTriggerElement;
    };
    interface HTMLSmoothlyTriggerSinkElement extends Components.SmoothlyTriggerSink, HTMLStencilElement {
    }
    var HTMLSmoothlyTriggerSinkElement: {
        prototype: HTMLSmoothlyTriggerSinkElement;
        new (): HTMLSmoothlyTriggerSinkElement;
    };
    interface HTMLSmoothlyTriggerSourceElementEventMap {
        "trigger": Trigger;
        "smoothlyMessage": Message<any>;
    }
    interface HTMLSmoothlyTriggerSourceElement extends Components.SmoothlyTriggerSource, HTMLStencilElement {
        addEventListener<K extends keyof HTMLSmoothlyTriggerSourceElementEventMap>(type: K, listener: (this: HTMLSmoothlyTriggerSourceElement, ev: SmoothlyTriggerSourceCustomEvent<HTMLSmoothlyTriggerSourceElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLSmoothlyTriggerSourceElementEventMap>(type: K, listener: (this: HTMLSmoothlyTriggerSourceElement, ev: SmoothlyTriggerSourceCustomEvent<HTMLSmoothlyTriggerSourceElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLSmoothlyTriggerSourceElement: {
        prototype: HTMLSmoothlyTriggerSourceElement;
        new (): HTMLSmoothlyTriggerSourceElement;
    };
    interface HTMLElementTagNameMap {
        "smoothly-app": HTMLSmoothlyAppElement;
        "smoothly-app-demo": HTMLSmoothlyAppDemoElement;
        "smoothly-app-room": HTMLSmoothlyAppRoomElement;
        "smoothly-back-to-top": HTMLSmoothlyBackToTopElement;
        "smoothly-burger": HTMLSmoothlyBurgerElement;
        "smoothly-button": HTMLSmoothlyButtonElement;
        "smoothly-button-confirm": HTMLSmoothlyButtonConfirmElement;
        "smoothly-button-demo": HTMLSmoothlyButtonDemoElement;
        "smoothly-button-demo-standard": HTMLSmoothlyButtonDemoStandardElement;
        "smoothly-calendar": HTMLSmoothlyCalendarElement;
        "smoothly-checkbox": HTMLSmoothlyCheckboxElement;
        "smoothly-color": HTMLSmoothlyColorElement;
        "smoothly-country": HTMLSmoothlyCountryElement;
        "smoothly-date-text": HTMLSmoothlyDateTextElement;
        "smoothly-dialog": HTMLSmoothlyDialogElement;
        "smoothly-dialog-demo": HTMLSmoothlyDialogDemoElement;
        "smoothly-display": HTMLSmoothlyDisplayElement;
        "smoothly-display-demo": HTMLSmoothlyDisplayDemoElement;
        "smoothly-display-demo-json": HTMLSmoothlyDisplayDemoJsonElement;
        "smoothly-display-json": HTMLSmoothlyDisplayJsonElement;
        "smoothly-display-json-object": HTMLSmoothlyDisplayJsonObjectElement;
        "smoothly-display-json-primitive": HTMLSmoothlyDisplayJsonPrimitiveElement;
        "smoothly-display-json-record-key": HTMLSmoothlyDisplayJsonRecordKeyElement;
        "smoothly-form": HTMLSmoothlyFormElement;
        "smoothly-form-demo": HTMLSmoothlyFormDemoElement;
        "smoothly-form-demo-all": HTMLSmoothlyFormDemoAllElement;
        "smoothly-form-demo-card": HTMLSmoothlyFormDemoCardElement;
        "smoothly-form-demo-controlled": HTMLSmoothlyFormDemoControlledElement;
        "smoothly-form-demo-date": HTMLSmoothlyFormDemoDateElement;
        "smoothly-form-demo-date-range": HTMLSmoothlyFormDemoDateRangeElement;
        "smoothly-form-demo-login": HTMLSmoothlyFormDemoLoginElement;
        "smoothly-form-demo-pet": HTMLSmoothlyFormDemoPetElement;
        "smoothly-form-demo-prices": HTMLSmoothlyFormDemoPricesElement;
        "smoothly-form-demo-schedule": HTMLSmoothlyFormDemoScheduleElement;
        "smoothly-form-demo-transparent": HTMLSmoothlyFormDemoTransparentElement;
        "smoothly-form-demo-typed": HTMLSmoothlyFormDemoTypedElement;
        "smoothly-frame": HTMLSmoothlyFrameElement;
        "smoothly-icon": HTMLSmoothlyIconElement;
        "smoothly-icon-demo": HTMLSmoothlyIconDemoElement;
        "smoothly-input": HTMLSmoothlyInputElement;
        "smoothly-input-checkbox": HTMLSmoothlyInputCheckboxElement;
        "smoothly-input-checkbox-demo": HTMLSmoothlyInputCheckboxDemoElement;
        "smoothly-input-clear": HTMLSmoothlyInputClearElement;
        "smoothly-input-color": HTMLSmoothlyInputColorElement;
        "smoothly-input-color-demo": HTMLSmoothlyInputColorDemoElement;
        "smoothly-input-date": HTMLSmoothlyInputDateElement;
        "smoothly-input-date-demo": HTMLSmoothlyInputDateDemoElement;
        "smoothly-input-date-range": HTMLSmoothlyInputDateRangeElement;
        "smoothly-input-date-time": HTMLSmoothlyInputDateTimeElement;
        "smoothly-input-demo": HTMLSmoothlyInputDemoElement;
        "smoothly-input-demo-radio": HTMLSmoothlyInputDemoRadioElement;
        "smoothly-input-demo-standard": HTMLSmoothlyInputDemoStandardElement;
        "smoothly-input-demo-user-input": HTMLSmoothlyInputDemoUserInputElement;
        "smoothly-input-edit": HTMLSmoothlyInputEditElement;
        "smoothly-input-file": HTMLSmoothlyInputFileElement;
        "smoothly-input-month": HTMLSmoothlyInputMonthElement;
        "smoothly-input-price-demo": HTMLSmoothlyInputPriceDemoElement;
        "smoothly-input-radio": HTMLSmoothlyInputRadioElement;
        "smoothly-input-radio-item": HTMLSmoothlyInputRadioItemElement;
        "smoothly-input-range": HTMLSmoothlyInputRangeElement;
        "smoothly-input-range-demo": HTMLSmoothlyInputRangeDemoElement;
        "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-modal": HTMLSmoothlyModalElement;
        "smoothly-notification": HTMLSmoothlyNotificationElement;
        "smoothly-notifier": HTMLSmoothlyNotifierElement;
        "smoothly-notifier-demo": HTMLSmoothlyNotifierDemoElement;
        "smoothly-spinner": HTMLSmoothlySpinnerElement;
        "smoothly-submit": HTMLSmoothlySubmitElement;
        "smoothly-summary": HTMLSmoothlySummaryElement;
        "smoothly-tab": HTMLSmoothlyTabElement;
        "smoothly-table": HTMLSmoothlyTableElement;
        "smoothly-table-body": HTMLSmoothlyTableBodyElement;
        "smoothly-table-cell": HTMLSmoothlyTableCellElement;
        "smoothly-table-demo": HTMLSmoothlyTableDemoElement;
        "smoothly-table-demo-colspan": HTMLSmoothlyTableDemoColspanElement;
        "smoothly-table-demo-filler-row": HTMLSmoothlyTableDemoFillerRowElement;
        "smoothly-table-demo-group": HTMLSmoothlyTableDemoGroupElement;
        "smoothly-table-demo-nested-no-cell": HTMLSmoothlyTableDemoNestedNoCellElement;
        "smoothly-table-demo-nested-no-cell-inner": HTMLSmoothlyTableDemoNestedNoCellInnerElement;
        "smoothly-table-demo-simple": HTMLSmoothlyTableDemoSimpleElement;
        "smoothly-table-expandable-cell": HTMLSmoothlyTableExpandableCellElement;
        "smoothly-table-expandable-row": HTMLSmoothlyTableExpandableRowElement;
        "smoothly-table-filler-row": HTMLSmoothlyTableFillerRowElement;
        "smoothly-table-foot": HTMLSmoothlyTableFootElement;
        "smoothly-table-head": HTMLSmoothlyTableHeadElement;
        "smoothly-table-row": HTMLSmoothlyTableRowElement;
        "smoothly-table-row-group": HTMLSmoothlyTableRowGroupElement;
        "smoothly-tabs": HTMLSmoothlyTabsElement;
        "smoothly-tabs-demo": HTMLSmoothlyTabsDemoElement;
        "smoothly-theme-color": HTMLSmoothlyThemeColorElement;
        "smoothly-theme-color-variant": HTMLSmoothlyThemeColorVariantElement;
        "smoothly-theme-colors": HTMLSmoothlyThemeColorsElement;
        "smoothly-theme-demo": HTMLSmoothlyThemeDemoElement;
        "smoothly-theme-guide": HTMLSmoothlyThemeGuideElement;
        "smoothly-theme-picker": HTMLSmoothlyThemePickerElement;
        "smoothly-toggle-switch": HTMLSmoothlyToggleSwitchElement;
        "smoothly-toggle-switch-demo": HTMLSmoothlyToggleSwitchDemoElement;
        "smoothly-trigger": HTMLSmoothlyTriggerElement;
        "smoothly-trigger-sink": HTMLSmoothlyTriggerSinkElement;
        "smoothly-trigger-source": HTMLSmoothlyTriggerSourceElement;
    }
}
declare namespace LocalJSX {
    interface SmoothlyApp {
        "color"?: Color;
        "home"?: string;
        "label"?: string;
        /**
          * @default false
         */
        "menuOpen"?: boolean;
        /**
          * @default "48rem"
         */
        "navBreakpoint"?: `${number}${"px" | "em" | "rem"}`;
        "onSmoothlyUrlChange"?: (event: SmoothlyAppCustomEvent<string>) => void;
    }
    interface SmoothlyAppDemo {
        "baseUrl"?: string;
    }
    interface SmoothlyAppRoom {
        "content"?: VNode | FunctionalComponent;
        "disabled"?: boolean;
        "icon"?: Icon;
        "label"?: string;
        "onSmoothlyRoomLoad"?: (event: SmoothlyAppRoomCustomEvent<{ selected: boolean }>) => void;
        "onSmoothlyRoomSelect"?: (event: SmoothlyAppRoomCustomEvent<{ history: boolean; path: string; query?: string }>) => void;
        "onSmoothlyUrlChange"?: (event: SmoothlyAppRoomCustomEvent<string>) => void;
        /**
          * @default ""
         */
        "path"?: string | URLPattern | (string | URLPattern)[];
        "selected"?: boolean;
    }
    interface SmoothlyBackToTop {
        /**
          * @default "1rem"
         */
        "bottom"?: string;
        /**
          * @default "0.5"
         */
        "opacity"?: string;
        /**
          * @default "1rem"
         */
        "right"?: string;
    }
    interface SmoothlyBurger {
        "onSmoothlyNavStatus"?: (event: SmoothlyBurgerCustomEvent<boolean>) => void;
        /**
          * @default false
         */
        "open"?: boolean;
    }
    interface SmoothlyButton {
        "color"?: Color;
        /**
          * @default false
         */
        "disabled"?: boolean;
        "expand"?: "block" | "full";
        "fill"?: Fill;
        "link"?: string;
        "shape"?: "rounded";
        "size"?: "small" | "large" | "icon" | "flexible";
        "tooltip"?: string;
        "type"?: Button.Properties["type"];
    }
    interface SmoothlyButtonConfirm {
        "color"?: Color;
        /**
          * @default false
         */
        "disabled"?: boolean;
        /**
          * @default 0.2
         */
        "doubleClickTime"?: number;
        "expand"?: "block" | "full";
        "fill"?: Fill;
        "name"?: string;
        "onSmoothlyConfirm"?: (event: SmoothlyButtonConfirmCustomEvent<Data>) => void;
        "onSmoothlyInputLoad"?: (event: SmoothlyButtonConfirmCustomEvent<(parent: Editable) => void>) => void;
        "shape"?: "rounded";
        "size"?: "small" | "large" | "icon" | "flexible";
    }
    interface SmoothlyButtonDemo {
    }
    interface SmoothlyButtonDemoStandard {
    }
    interface SmoothlyCalendar {
        "doubleInput"?: boolean;
        "end"?: isoly.Date;
        "max"?: isoly.Date;
        "min"?: isoly.Date;
        "month"?: isoly.Date;
        "onSmoothlyDateRangeSet"?: (event: SmoothlyCalendarCustomEvent<isoly.DateRange>) => void;
        "onSmoothlyDateSet"?: (event: SmoothlyCalendarCustomEvent<isoly.Date>) => void;
        "start"?: isoly.Date;
        "value"?: isoly.Date;
    }
    interface SmoothlyCheckbox {
        /**
          * @default false
         */
        "checked"?: boolean;
        /**
          * @default false
         */
        "disabled"?: boolean;
        /**
          * @default false
         */
        "intermediate"?: boolean;
        "name"?: string;
        "onSmoothlyInput"?: (event: SmoothlyCheckboxCustomEvent<Record<string, any>>) => void;
        /**
          * @default "tiny"
         */
        "size"?: "tiny" | "small" | "medium" | "large";
        /**
          * @default false
         */
        "unavailable"?: boolean;
        "value"?: any;
    }
    interface SmoothlyColor {
        "color"?: Color;
    }
    interface SmoothlyCountry {
        /**
          * @default "alpha2"
         */
        "text"?: "alpha2" | "name" | "none";
        "value"?: isoly.CountryCode.Alpha2;
    }
    interface SmoothlyDateText {
        "disabled"?: boolean;
        /**
          * @default getLocale()
         */
        "locale"?: isoly.Locale;
        "onSmoothlyDateHasPartialDate"?: (event: SmoothlyDateTextCustomEvent<DateFormat.Parts>) => void;
        "onSmoothlyDateTextChange"?: (event: SmoothlyDateTextCustomEvent<isoly.Date | undefined>) => void;
        "onSmoothlyDateTextDone"?: (event: SmoothlyDateTextCustomEvent<void>) => void;
        "onSmoothlyDateTextFocusChange"?: (event: SmoothlyDateTextCustomEvent<boolean>) => void;
        "onSmoothlyDateTextHasText"?: (event: SmoothlyDateTextCustomEvent<boolean>) => void;
        "onSmoothlyDateTextNext"?: (event: SmoothlyDateTextCustomEvent<void>) => void;
        "onSmoothlyDateTextPrevious"?: (event: SmoothlyDateTextCustomEvent<void>) => void;
        "readonly"?: boolean;
        /**
          * @default true
         */
        "showLabel"?: boolean;
        "value"?: isoly.Date;
    }
    interface SmoothlyDialog {
        /**
          * @default false
         */
        "closable"?: boolean;
        "color"?: Color | undefined;
        "header"?: string | undefined;
        /**
          * @default true
         */
        "open"?: boolean;
    }
    interface SmoothlyDialogDemo {
    }
    interface SmoothlyDisplay {
        "collapseDepth"?: number;
        "country"?: isoly.CountryCode.Alpha2;
        "currency"?: isoly.Currency;
        "format"?: isoly.DateTime.Format;
        "label"?: string;
        "toInteger"?: boolean;
        "type"?: tidily.Type | "json";
        "value"?: any;
    }
    interface SmoothlyDisplayDemo {
        "onNotice"?: (event: SmoothlyDisplayDemoCustomEvent<Notice>) => void;
    }
    interface SmoothlyDisplayDemoJson {
    }
    interface SmoothlyDisplayJson {
        "collapseDepth"?: number;
        "value"?: any;
    }
    interface SmoothlyDisplayJsonObject {
        "collapseDepth"?: number;
        "value"?: Record<string, any> | any[];
    }
    interface SmoothlyDisplayJsonPrimitive {
        "value"?: any;
    }
    interface SmoothlyDisplayJsonRecordKey {
        "value"?: any;
    }
    interface SmoothlyForm {
        "action"?: string;
        "color"?: Color;
        "looks"?: Looks;
        "name"?: string;
        "onNotice"?: (event: SmoothlyFormCustomEvent<Notice>) => void;
        "onSmoothlyFormClear"?: (event: SmoothlyFormCustomEvent<void>) => void;
        "onSmoothlyFormDisable"?: (event: SmoothlyFormCustomEvent<(disabled: boolean) => void>) => void;
        "onSmoothlyFormEdit"?: (event: SmoothlyFormCustomEvent<boolean>) => void;
        "onSmoothlyFormInput"?: (event: SmoothlyFormCustomEvent<Data>) => void;
        "onSmoothlyFormReset"?: (event: SmoothlyFormCustomEvent<void>) => void;
        "onSmoothlyFormSubmit"?: (event: SmoothlyFormCustomEvent<Submit>) => void;
        /**
          * @default true
         */
        "prevent"?: boolean;
        "processing"?: Promise<boolean>;
        /**
          * @default false
         */
        "readonly"?: boolean;
        /**
          * @default this.action ? "create" : undefined
         */
        "type"?: "update" | "change" | "fetch" | "create";
        "validator"?: isly.Type<any>;
        /**
          * @default {}
         */
        "value"?: Readonly<Data>;
    }
    interface SmoothlyFormDemo {
    }
    interface SmoothlyFormDemoAll {
    }
    interface SmoothlyFormDemoCard {
    }
    interface SmoothlyFormDemoControlled {
    }
    interface SmoothlyFormDemoDate {
        "onNotice"?: (event: SmoothlyFormDemoDateCustomEvent<Notice>) => void;
    }
    interface SmoothlyFormDemoDateRange {
        "onNotice"?: (event: SmoothlyFormDemoDateRangeCustomEvent<Notice>) => void;
    }
    interface SmoothlyFormDemoLogin {
    }
    interface SmoothlyFormDemoPet {
    }
    interface SmoothlyFormDemoPrices {
    }
    interface SmoothlyFormDemoSchedule {
    }
    interface SmoothlyFormDemoTransparent {
    }
    interface SmoothlyFormDemoTyped {
    }
    interface SmoothlyFrame {
        "name"?: string;
        "onMessage2"?: (event: SmoothlyFrameCustomEvent<Message<any>>) => void;
        "onTrigger"?: (event: SmoothlyFrameCustomEvent<Trigger>) => void;
        "origin"?: string | undefined;
        "url"?: string;
    }
    interface SmoothlyIcon {
        "color"?: Color;
        /**
          * @default "solid"
         */
        "fill"?: Fill;
        "flip"?: "x" | "y";
        /**
          * @default "empty"
         */
        "name"?: Icon | "empty";
        "rotate"?: number;
        "size"?: "tiny" | "small" | "medium" | "large" | "xlarge";
        "tooltip"?: string;
    }
    interface SmoothlyIconDemo {
        "onNotice"?: (event: SmoothlyIconDemoCustomEvent<Notice>) => void;
    }
    interface SmoothlyInput {
        "autocomplete"?: Exclude<tidily.Settings["autocomplete"], undefined>;
        "color"?: Color;
        "copyable"?: boolean;
        "currency"?: isoly.Currency;
        /**
          * @default false
         */
        "disabled"?: boolean;
        "errorMessage"?: string;
        /**
          * @default false
         */
        "invalid"?: boolean;
        "looks"?: Looks;
        "max"?: number;
        "min"?: 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: Editable) => void>) => void;
        "onSmoothlyInputLooks"?: (event: SmoothlyInputCustomEvent<(looks?: Looks, color?: Color) => void>) => void;
        "onSmoothlyKeydown"?: (event: SmoothlyInputCustomEvent<Key>) => void;
        "onSmoothlyUserInput"?: (event: SmoothlyInputCustomEvent<Input.UserInput>) => void;
        "pad"?: number;
        "placeholder"?: string | undefined;
        /**
          * @default false
         */
        "readonly"?: boolean;
        /**
          * @default false
         */
        "required"?: boolean;
        /**
          * @default true
         */
        "showLabel"?: boolean;
        "toInteger"?: boolean;
        /**
          * @default "text"
         */
        "type"?: tidily.Type;
        "value"?: any;
    }
    interface SmoothlyInputCheckbox {
        /**
          * @default false
         */
        "checked"?: boolean;
        "color"?: Color;
        "disabled"?: boolean;
        "looks"?: Looks;
        "name"?: string;
        "onSmoothlyFormDisable"?: (event: SmoothlyInputCheckboxCustomEvent<(disabled: boolean) => void>) => void;
        "onSmoothlyInput"?: (event: SmoothlyInputCheckboxCustomEvent<Data>) => void;
        "onSmoothlyInputLoad"?: (event: SmoothlyInputCheckboxCustomEvent<(parent: Editable) => void>) => void;
        "onSmoothlyInputLooks"?: (event: SmoothlyInputCheckboxCustomEvent<(looks?: Looks, color?: Color) => void>) => void;
        "onSmoothlyUserInput"?: (event: SmoothlyInputCheckboxCustomEvent<Input.UserInput>) => void;
        /**
          * @default false
         */
        "readonly"?: boolean;
        "value"?: Record<"true" | "false", any>;
    }
    interface SmoothlyInputCheckboxDemo {
    }
    interface SmoothlyInputClear {
        "color"?: Color;
        "disabled"?: boolean;
        /**
          * @default true
         */
        "display"?: boolean;
        "expand"?: "block" | "full";
        /**
          * @default "clear"
         */
        "fill"?: Fill;
        "onSmoothlyInputLoad"?: (event: SmoothlyInputClearCustomEvent<(parent: Editable) => void>) => void;
        "shape"?: "rounded";
        /**
          * @default "icon"
         */
        "size"?: "small" | "large" | "icon" | "flexible";
        /**
          * @default "Clear"
         */
        "tooltip"?: string;
        /**
          * @default "input"
         */
        "type"?: "form" | "input";
    }
    interface SmoothlyInputColor {
        "color"?: Color;
        "disabled"?: boolean;
        "looks"?: Looks;
        "name"?: string;
        "onSmoothlyFormDisable"?: (event: SmoothlyInputColorCustomEvent<(disabled: boolean) => void>) => void;
        "onSmoothlyInput"?: (event: SmoothlyInputColorCustomEvent<Record<string, any>>) => void;
        "onSmoothlyInputLoad"?: (event: SmoothlyInputColorCustomEvent<(parent: Editable) => void>) => void;
        "onSmoothlyInputLooks"?: (event: SmoothlyInputColorCustomEvent<(looks?: Looks, color?: Color) => void>) => void;
        "onSmoothlyUserInput"?: (event: SmoothlyInputColorCustomEvent<Input.UserInput>) => void;
        /**
          * @default "rgb"
         */
        "output"?: "rgb" | "hex";
        /**
          * @default false
         */
        "readonly"?: boolean;
        /**
          * @default true
         */
        "showLabel"?: boolean;
        /**
          * @default undefined
         */
        "value"?: string | undefined;
    }
    interface SmoothlyInputColorDemo {
    }
    interface SmoothlyInputDate {
        /**
          * @default false
         */
        "alwaysShowGuide"?: boolean;
        "color"?: Color;
        "disabled"?: boolean;
        "errorMessage"?: string;
        /**
          * @default false
         */
        "invalid"?: boolean;
        "locale"?: isoly.Locale;
        "looks"?: Looks;
        "max"?: isoly.Date;
        "min"?: isoly.Date;
        "name"?: string;
        "onSmoothlyFormDisable"?: (event: SmoothlyInputDateCustomEvent<(disabled: boolean) => void>) => void;
        "onSmoothlyInput"?: (event: SmoothlyInputDateCustomEvent<Record<string, any>>) => void;
        "onSmoothlyInputLoad"?: (event: SmoothlyInputDateCustomEvent<(parent: Editable) => void>) => void;
        "onSmoothlyInputLooks"?: (event: SmoothlyInputDateCustomEvent<(looks?: Looks, color?: Color) => void>) => void;
        "onSmoothlyUserInput"?: (event: SmoothlyInputDateCustomEvent<Input.UserInput>) => void;
        "onSmoothlyValueChange"?: (event: SmoothlyInputDateCustomEvent<isoly.Date>) => void;
        "open"?: boolean;
        "placeholder"?: string;
        /**
          * @default false
         */
        "readonly"?: boolean;
        /**
          * @default true
         */
        "showLabel"?: boolean;
        "value"?: isoly.Date;
    }
    interface SmoothlyInputDateDemo {
    }
    interface SmoothlyInputDateRange {
        /**
          * @default false
         */
        "alwaysShowGuide"?: boolean;
        "color"?: Color;
        "disabled"?: boolean;
        "end"?: isoly.Date | undefined;
        "errorMessage"?: string;
        /**
          * @default false
         */
        "invalid"?: boolean;
        "locale"?: isoly.Locale;
        "looks"?: Looks;
        "max"?: isoly.Date;
        "min"?: isoly.Date;
        /**
          * @default "dateRange"
         */
        "name"?: string;
        "onSmoothlyFormDisable"?: (event: SmoothlyInputDateRangeCustomEvent<(disabled: boolean) => void>) => void;
        "onSmoothlyInput"?: (event: SmoothlyInputDateRangeCustomEvent<{ [name: string]: Partial<isoly.DateRange> | undefined }>) => void;
        "onSmoothlyInputLoad"?: (event: SmoothlyInputDateRangeCustomEvent<(parent: Editable) => void>) => void;
        "onSmoothlyInputLooks"?: (event: SmoothlyInputDateRangeCustomEvent<(looks?: Looks, color?: Color) => void>) => void;
        "onSmoothlyUserInput"?: (event: SmoothlyInputDateRangeCustomEvent<Input.UserInput<Partial<isoly.DateRange> | undefined>>) => void;
        "placeholder"?: string;
        /**
          * @default false
         */
        "readonly"?: boolean;
        /**
          * @default true
         */
        "showLabel"?: boolean;
        "start"?: isoly.Date | undefined;
    }
    interface SmoothlyInputDateTime {
        "color"?: Color;
        "disabled"?: boolean;
        "errorMessage"?: string;
        /**
          * @default false
         */
        "invalid"?: boolean;
        "looks"?: Looks;
        "max"?: isoly.DateTime;
        "min"?: isoly.DateTime;
        "name"?: string;
        "onSmoothlyFormDisable"?: (event: SmoothlyInputDateTimeCustomEvent<(disabled: boolean) => void>) => void;
        "onSmoothlyInput"?: (event: SmoothlyInputDateTimeCustomEvent<Record<string, any>>) => void;
        "onSmoothlyInputLoad"?: (event: SmoothlyInputDateTimeCustomEvent<(parent: Editable) => void>) => void;
        "onSmoothlyInputLooks"?: (event: SmoothlyInputDateTimeCustomEvent<(looks?: Looks, color?: Color) => void>) => void;
        "onSmoothlyUserInput"?: (event: SmoothlyInputDateTimeCustomEvent<Input.UserInput>) => void;
        "onSmoothlyValueChange"?: (event: SmoothlyInputDateTimeCustomEvent<isoly.DateTime>) => void;
        "open"?: boolean;
        /**
          * @default false
         */
        "readonly"?: boolean;
        /**
          * @default true
         */
        "showLabel"?: boolean;
        "value"?: isoly.DateTime;
    }
    interface SmoothlyInputDemo {
        "onSmoothlyUrlUpdate"?: (event: SmoothlyInputDemoCustomEvent<{ path: string; query?: string }>) => void;
    }
    interface SmoothlyInputDemoRadio {
    }
    interface SmoothlyInputDemoStandard {
    }
    interface SmoothlyInputDemoUserInput {
    }
    interface SmoothlyInputEdit {
        /**
          * @default "tertiary"
         */
        "color"?: Color;
        /**
          * @default false
         */
        "disabled"?: boolean;
        /**
          * @default true
         */
        "display"?: boolean;
        "expand"?: "block" | "full";
        "fill"?: Fill;
        "onSmoothlyInputLoad"?: (event: SmoothlyInputEditCustomEvent<(parent: Editable) => void>) => void;
        "shape"?: "rounded";
        "size"?: "flexible" | "small" | "large" | "icon";
        /**
          * @default "Edit"
         */
        "tooltip"?: string;
        /**
          * @default "input"
         */
        "type"?: "form" | "input";
    }
    interface SmoothlyInputFile {
        "accept"?: string;
        "camera"?: "front" | "back";
        "color"?: Color;
        "disabled"?: boolean;
        "looks"?: Looks;
        "name"?: string;
        "onSmoothlyFormDisable"?: (event: SmoothlyInputFileCustomEvent<(disabled: boolean) => void>) => void;
        "onSmoothlyInput"?: (event: SmoothlyInputFileCustomEvent<Record<string, any>>) => void;
        "onSmoothlyInputLoad"?: (event: SmoothlyInputFileCustomEvent<(parent: Editable) => void>) => void;
        "onSmoothlyInputLooks"?: (event: SmoothlyInputFileCustomEvent<(looks?: Looks, color?: Color) => void>) => void;
        "onSmoothlyUserInput"?: (event: SmoothlyInputFileCustomEvent<Input.UserInput>) => void;
        "placeholder"?: string | undefined;
        /**
          * @default false
         */
        "readonly"?: boolean;
        /**
          * @default true
         */
        "showLabel"?: boolean;
        "value"?: File;
    }
    interface SmoothlyInputMonth {
        "color"?: Color;
        /**
          * @default false
         */
        "inCalendar"?: boolean;
        "looks"?: Looks;
        "max"?: isoly.Date;
        "min"?: isoly.Date;
        "name"?: string;
        /**
          * @default false
         */
        "next"?: boolean;
        "onSmoothlyFormDisable"?: (event: SmoothlyInputMonthCustomEvent<(disabled: boolean) => void>) => void;
        "onSmoothlyInput"?: (event: SmoothlyInputMonthCustomEvent<Data>) => void;
        "onSmoothlyInputLoad"?: (event: SmoothlyInputMonthCustomEvent<(parent: Editable) => void>) => void;
        "onSmoothlyInputLooks"?: (event: SmoothlyInputMonthCustomEvent<(looks?: Looks, color?: Color) => void>) => void;
        "onSmoothlyUserInput"?: (event: SmoothlyInputMonthCustomEvent<Input.UserInput>) => void;
        /**
          * @default false
         */
        "previous"?: boolean;
        "readonly"?: boolean;
        /**
          * @default true
         */
        "showLabel"?: boolean;
        /**
          * @default isoly.Date.now()
         */
        "value"?: isoly.Date;
    }
    interface SmoothlyInputPriceDemo {
    }
    interface SmoothlyInputRadio {
        "clearable"?: boolean;
        "color"?: Color;
        "direction"?: "row" | "column";
        "disabled"?: boolean;
        "looks"?: Looks;
        "name"?: string;
        "onSmoothlyFormDisable"?: (event: SmoothlyInputRadioCustomEvent<(disabled: boolean) => void>) => void;
        "onSmoothlyInput"?: (event: SmoothlyInputRadioCustomEvent<Data>) => void;
        "onSmoothlyInputLoad"?: (event: SmoothlyInputRadioCustomEvent<(parent: Editable) => void>) => void;
        "onSmoothlyInputLooks"?: (event: SmoothlyInputRadioCustomEvent<(looks?: Looks, color?: Color) => void>) => void;
        "onSmoothlyUserInput"?: (event: SmoothlyInputRadioCustomEvent<Input.UserInput>) => void;
        /**
          * @default false
         */
        "readonly"?: boolean;
        /**
          * @default true
         */
        "showLabel"?: boolean;
        /**
          * @default undefined
         */
        "value"?: any;
    }
    interface SmoothlyInputRadioItem {
        "looks"?: Looks;
        "name"?: string;
        "onSmoothlyRadioItemRegister"?: (event: SmoothlyInputRadioItemCustomEvent<(parent: SmoothlyInputRadio) => void>) => void;
        "onSmoothlyRadioItemSelect"?: (event: SmoothlyInputRadioItemCustomEvent<RadioItemSelect>) => void;
        /**
          * @default false
         */
        "selected"?: boolean;
        "value"?: any;
    }
    interface SmoothlyInputRange {
        "color"?: Color;
        /**
          * @default false
         */
        "defined"?: boolean;
        "disabled"?: boolean;
        "label"?: string;
        "looks"?: Looks;
        /**
          * @default 100
         */
        "max"?: number;
        /**
          * @default 0
         */
        "min"?: number;
        /**
          * @default "range"
         */
        "name"?: string;
        "onSmoothlyFormDisable"?: (event: SmoothlyInputRangeCustomEvent<(disabled: boolean) => void>) => void;
        "onSmoothlyInput"?: (event: SmoothlyInputRangeCustomEvent<Record<string, any>>) => void;
        "onSmoothlyInputLoad"?: (event: SmoothlyInputRangeCustomEvent<(parent: Editable) => void>) => void;
        "onSmoothlyInputLooks"?: (event: SmoothlyInputRangeCustomEvent<(looks?: Looks, color?: Color) => void>) => void;
        "onSmoothlyUserInput"?: (event: SmoothlyInputRangeCustomEvent<Input.UserInput>) => void;
        /**
          * @default "left"
         */
        "outputSide"?: "right" | "left";
        /**
          * @default false
         */
        "readonly"?: boolean;
        "step"?: number;
        /**
          * @default "text"
         */
        "type"?: Extract<tidily.Type, "text" | "percent">;
        /**
          * @default undefined
         */
        "value"?: number | undefined;
    }
    interface SmoothlyInputRangeDemo {
    }
    interface SmoothlyInputReset {
        "color"?: Color;
        "disabled"?: boolean;
        /**
          * @default true
         */
        "display"?: boolean;
        "expand"?: "block" | "full";
        "fill"?: Fill;
        "onSmoothlyInputLoad"?: (event: SmoothlyInputResetCustomEvent<(parent: Editable) => void>) => void;
        "shape"?: "rounded";
        /**
          * @default "icon"
         */
        "size"?: "flexible" | "small" | "large" | "icon";
        /**
          * @default "Reset"
         */
        "tooltip"?: string;
        /**
          * @default "input"
         */
        "type"?: "form" | "input";
    }
    interface SmoothlyInputSelect {
        /**
          * @default true
         */
        "clearable"?: boolean;
        "color"?: Color;
        /**
          * @default false
         */
        "defined"?: boolean;
        /**
          * @default false
         */
        "disabled"?: boolean;
        "errorMessage"?: string;
        /**
          * @default false
         */
        "inCalendar"?: boolean;
        /**
          * @default false
         */
        "invalid"?: boolean;
        "looks"?: Looks;
        "menuHeight"?: layout.MenuHeight;
        /**
          * @default false
         */
        "multiple"?: boolean;
        /**
          * @default false
         */
        "mutable"?: boolean;
        /**
          * @default "selected"
         */
        "name"?: string;
        "onSmoothlyFormDisable"?: (event: SmoothlyInputSelectCustomEvent<(disabled: boolean) => void>) => void;
        "onSmoothlyInput"?: (event: SmoothlyInputSelectCustomEvent<Data>) => void;
        "onSmoothlyInputLoad"?: (event: SmoothlyInputSelectCustomEvent<(parent: Editable) => void>) => void;
        "onSmoothlyInputLooks"?: (event: SmoothlyInputSelectCustomEvent<(looks?: Looks, color?: Color) => void>) => void;
        "onSmoothlyItemSelect"?: (event: SmoothlyInputSelectCustomEvent<HTMLSmoothlyItemElement>) => void;
        "onSmoothlySelectOpen"?: (event: SmoothlyInputSelectCustomEvent<boolean>) => void;
        "onSmoothlyUserInput"?: (event: SmoothlyInputSelectCustomEvent<Input.UserInput>) => void;
        "ordered"?: boolean;
        "placeholder"?: string | any;
        /**
          * @default false
         */
        "readonly"?: boolean;
        /**
          * @default false
         */
        "required"?: boolean;
        /**
          * @default false
         */
        "searchDisabled"?: boolean;
        /**
          * @default true
         */
        "showLabel"?: boolean;
        /**
          * @default true
         */
        "showSelected"?: boolean;
    }
    interface SmoothlyInputSubmit {
        "color"?: Color;
        /**
          * @default false
         */
        "delete"?: boolean;
        /**
          * @default false
         */
        "disabled"?: boolean;
        /**
          * @default false
         */
        "display"?: boolean;
        "expand"?: "block" | "full";
        "fill"?: Fill;
        /**
          * @default "checkmark-outline"
         */
        "icon"?: Icon | false;
        "onSmoothlyInputLoad"?: (event: SmoothlyInputSubmitCustomEvent<(parent: Editable) => void>) => void;
        "shape"?: "rounded";
        /**
          * @default "icon"
         */
        "size"?: "flexible" | "small" | "large" | "icon";
        /**
          * @default this.delete ? "Remove" : "Submit"
         */
        "tooltip"?: string;
    }
    interface SmoothlyItem {
        /**
          * @default true
         */
        "deselectable"?: boolean;
        /**
          * @default false
         */
        "disabled"?: boolean;
        "marked"?: boolean;
        "onSmoothlyInputLoad"?: (event: SmoothlyItemCustomEvent<(parent: Editable) => void>) => void;
        "onSmoothlyItemDOMChange"?: (event: SmoothlyItemCustomEvent<void>) => void;
        "onSmoothlyItemSelect"?: (event: SmoothlyItemCustomEvent<{ userInitiated: boolean; item: HTMLSmoothlyItemElement }>) => void;
        /**
          * @default false
         */
        "selected"?: boolean;
        "value"?: any;
    }
    interface SmoothlyLabel {
        "description"?: string;
        "hue"?: number;
        "shape"?: "rectangle" | "rounded";
    }
    interface SmoothlyLazy {
        "content"?: VNode | FunctionalComponent;
        /**
          * @default false
         */
        "show"?: boolean;
    }
    interface SmoothlyLoadMore {
        /**
          * @default false
         */
        "multiple"?: boolean;
        /**
          * @default ""
         */
        "name"?: string;
        "onSmoothlyLoadMore"?: (event: SmoothlyLoadMoreCustomEvent<string>) => void;
        /**
          * @default "intersection"
         */
        "triggerMode"?: "scroll" | "intersection";
    }
    interface SmoothlyModal {
        /**
          * @default "center"
         */
        "align"?: "top" | "center";
        /**
          * @default false
         */
        "closable"?: boolean;
        "onSmoothlyModalChange"?: (event: SmoothlyModalCustomEvent<boolean>) => void;
        /**
          * @default false
         */
        "open"?: boolean;
    }
    interface SmoothlyNotification {
        /**
          * @default true
         */
        "closable"?: boolean;
        "icon"?: boolean;
        "notice"?: Notice;
        "onRemove"?: (event: SmoothlyNotificationCustomEvent<Notice>) => void;
    }
    interface SmoothlyNotifier {
        /**
          * @default false
         */
        "icon"?: boolean;
    }
    interface SmoothlyNotifierDemo {
        "onNotice"?: (event: SmoothlyNotifierDemoCustomEvent<Notice>) => void;
    }
    interface SmoothlySpinner {
        "overlay"?: boolean;
        /**
          * @default "large"
         */
        "size"?: "small" | "icon" | "medium" | "large";
    }
    interface SmoothlySubmit {
        /**
          * @default "success"
         */
        "color"?: Color;
        /**
          * @default false
         */
        "disabled"?: boolean;
        "expand"?: "block" | "full";
        "fill"?: Fill;
        "onSmoothlyInputLoad"?: (event: SmoothlySubmitCustomEvent<(parent: Editable) => void>) => void;
        /**
          * @default true
         */
        "prevent"?: boolean;
        "shape"?: "rounded";
        "size"?: "flexible" | "small" | "large" | "icon";
        "type"?: "link" | "button";
    }
    interface SmoothlySummary {
        "onSmoothlySummaryOpen"?: (event: SmoothlySummaryCustomEvent<boolean>) => void;
        /**
          * @default false
         */
        "open"?: boolean;
    }
    interface SmoothlyTab {
        "disabled"?: boolean;
        "label"?: string;
        "name"?: string;
        "onSmoothlyTabLoad"?: (event: SmoothlyTabCustomEvent<(smoothlyTabs: SmoothlyTabs) => void>) => void;
        "onSmoothlyTabOpen"?: (event: SmoothlyTabCustomEvent<string>) => void;
        "open"?: boolean;
        "tooltip"?: string;
    }
    interface SmoothlyTable {
        /**
          * @default 1
         */
        "columns"?: number;
    }
    interface SmoothlyTableBody {
    }
    interface SmoothlyTableCell {
        /**
          * @default 1
         */
        "span"?: number;
    }
    interface SmoothlyTableDemo {
    }
    interface SmoothlyTableDemoColspan {
    }
    interface SmoothlyTableDemoFillerRow {
    }
    interface SmoothlyTableDemoGroup {
    }
    interface SmoothlyTableDemoNestedNoCell {
    }
    interface SmoothlyTableDemoNestedNoCellInner {
        "data"?: {
		id: number
		name: string
		age: number
		balance: number
	}[];
    }
    interface SmoothlyTableDemoSimple {
    }
    interface SmoothlyTableExpandableCell {
        "onSmoothlyTableExpandableCellChange"?: (event: SmoothlyTableExpandableCellCustomEvent<boolean>) => void;
        "onSmoothlyTableExpandableCellRegister"?: (event: SmoothlyTableExpandableCellCustomEvent<void>) => void;
        /**
          * @default false
         */
        "open"?: boolean;
        /**
          * @default 1
         */
        "span"?: number;
    }
    interface SmoothlyTableExpandableRow {
        "onSmoothlyTableExpandableRowChange"?: (event: SmoothlyTableExpandableRowCustomEvent<boolean>) => void;
        /**
          * @default false
         */
        "open"?: boolean;
    }
    interface SmoothlyTableFillerRow {
    }
    interface SmoothlyTableFoot {
    }
    interface SmoothlyTableHead {
    }
    interface SmoothlyTableRow {
    }
    interface SmoothlyTableRowGroup {
        /**
          * @default false
         */
        "align"?: boolean;
        "onSmoothlyTableRowGroupChange"?: (event: SmoothlyTableRowGroupCustomEvent<boolean>) => void;
        /**
          * @default false
         */
        "open"?: boolean;
    }
    interface SmoothlyTabs {
        "numberOfTabs"?: number;
        "onSmoothlyTabOpen"?: (event: SmoothlyTabsCustomEvent<string>) => void;
        /**
          * @default "always"
         */
        "tabs"?: "always" | "multiple";
    }
    interface SmoothlyTabsDemo {
    }
    interface SmoothlyThemeColor {
        "color"?: Color;
    }
    interface SmoothlyThemeColorVariant {
        "color"?: Color;
        /**
          * @default "color"
         */
        "variant"?: "shade" | "tint" | "color";
    }
    interface SmoothlyThemeColors {
    }
    interface SmoothlyThemeDemo {
    }
    interface SmoothlyThemeGuide {
    }
    interface SmoothlyThemePicker {
        /**
          * @default "smoothly-css"
         */
        "element"?: string;
    }
    interface SmoothlyToggleSwitch {
        /**
          * @default true
         */
        "checkmark"?: boolean;
        /**
          * @default "medium"
         */
        "color"?: Color;
        /**
          * @default false
         */
        "disabled"?: boolean;
        /**
          * @default "clear"
         */
        "fill"?: Fill;
        "onSmoothlyToggleSwitchChange"?: (event: SmoothlyToggleSwitchCustomEvent<boolean>) => void;
        /**
          * @default false
         */
        "selected"?: boolean;
        /**
          * @default "default"
         */
        "size"?: "tiny" | "small" | "default" | "large";
    }
    interface SmoothlyToggleSwitchDemo {
    }
    interface SmoothlyTrigger {
        "color"?: Color | undefined;
        /**
          * @default false
         */
        "disabled"?: boolean;
        "fill"?: Fill;
        "name"?: string;
        "onTrigger"?: (event: SmoothlyTriggerCustomEvent<Trigger>) => void;
        /**
          * @default "button"
         */
        "type"?: "link" | "button";
        "value"?: any;
    }
    interface SmoothlyTriggerSink {
        "context"?: Window;
        "destination"?: string;
        "filter"?: string;
    }
    interface SmoothlyTriggerSource {
        "listen"?: string;
        "onSmoothlyMessage"?: (event: SmoothlyTriggerSourceCustomEvent<Message<any>>) => void;
        "onTrigger"?: (event: SmoothlyTriggerSourceCustomEvent<Trigger>) => void;
    }

    interface SmoothlyAppAttributes {
        "label": string;
        "color": Color;
        "home": string;
        "menuOpen": boolean;
        "navBreakpoint": `${number}${"px" | "em" | "rem"}`;
    }
    interface SmoothlyAppDemoAttributes {
        "baseUrl": string;
    }
    interface SmoothlyAppRoomAttributes {
        "label": string;
        "icon": Icon;
        "disabled": boolean;
        "path": string | URLPattern | (string | URLPattern)[];
        "selected": boolean;
    }
    interface SmoothlyBackToTopAttributes {
        "opacity": string;
        "bottom": string;
        "right": string;
    }
    interface SmoothlyBurgerAttributes {
        "open": boolean;
    }
    interface SmoothlyButtonAttributes {
        "color": Color;
        "expand": "block" | "full";
        "fill": Fill;
        "tooltip": string;
        "disabled": boolean;
        "type": Button.Properties["type"];
        "size": "small" | "large" | "icon" | "flexible";
        "shape": "rounded";
        "link": string;
    }
    interface SmoothlyButtonConfirmAttributes {
        "color": Color;
        "name": string;
        "doubleClickTime": number;
        "expand": "block" | "full";
        "fill": Fill;
        "disabled": boolean;
        "shape": "rounded";
        "size": "small" | "large" | "icon" | "flexible";
    }
    interface SmoothlyCalendarAttributes {
        "month": isoly.Date;
        "value": isoly.Date;
        "start": isoly.Date;
        "end": isoly.Date;
        "max": isoly.Date;
        "min": isoly.Date;
        "doubleInput": boolean;
    }
    interface SmoothlyCheckboxAttributes {
        "size": "tiny" | "small" | "medium" | "large";
        "checked": boolean;
        "intermediate": boolean;
        "unavailable": boolean;
        "disabled": boolean;
        "name": string;
        "value": string;
    }
    interface SmoothlyColorAttributes {
        "color": Color;
    }
    interface SmoothlyCountryAttributes {
        "value": isoly.CountryCode.Alpha2;
        "text": "alpha2" | "name" | "none";
    }
    interface SmoothlyDateTextAttributes {
        "locale": isoly.Locale;
        "readonly": boolean;
        "disabled": boolean;
        "showLabel": boolean;
        "value": isoly.Date;
    }
    interface SmoothlyDialogAttributes {
        "color": Color | undefined;
        "open": boolean;
        "closable": boolean;
        "header": string | undefined;
    }
    interface SmoothlyDisplayAttributes {
        "type": tidily.Type | "json";
        "label": string;
        "value": string;
        "collapseDepth": number;
        "toInteger": boolean;
        "currency": isoly.Currency;
        "country": isoly.CountryCode.Alpha2;
    }
    interface SmoothlyDisplayJsonAttributes {
        "value": string;
        "collapseDepth": number;
    }
    interface SmoothlyDisplayJsonObjectAttributes {
        "collapseDepth": number;
    }
    interface SmoothlyDisplayJsonPrimitiveAttributes {
        "value": string;
    }
    interface SmoothlyDisplayJsonRecordKeyAttributes {
        "value": string;
    }
    interface SmoothlyFormAttributes {
        "color": Color;
        "action": string;
        "type": "update" | "change" | "fetch" | "create";
        "readonly": boolean;
        "looks": Looks;
        "name": string;
        "prevent": boolean;
    }
    interface SmoothlyFrameAttributes {
        "url": string;
        "name": string;
        "origin": string | undefined;
    }
    interface SmoothlyIconAttributes {
        "color": Color;
        "fill": Fill;
        "name": Icon | "empty";
        "size": "tiny" | "small" | "medium" | "large" | "xlarge";
        "rotate": number;
        "flip": "x" | "y";
        "tooltip": string;
    }
    interface SmoothlyInputAttributes {
        "color": Color;
        "looks": Looks;
        "name": string;
        "value": string;
        "type": tidily.Type;
        "required": boolean;
        "showLabel": boolean;
        "autocomplete": Exclude<tidily.Settings["autocomplete"], undefined>;
        "placeholder": string | undefined;
        "disabled": boolean;
        "readonly": boolean;
        "toInteger": boolean;
        "currency": isoly.Currency;
        "min": number;
        "max": number;
        "pad": number;
        "invalid": boolean;
        "errorMessage": string;
        "copyable": boolean;
    }
    interface SmoothlyInputCheckboxAttributes {
        "name": string;
        "readonly": boolean;
        "disabled": boolean;
        "checked": boolean;
        "looks": Looks;
        "color": Color;
    }
    interface SmoothlyInputClearAttributes {
        "color": Color;
        "expand": "block" | "full";
        "fill": Fill;
        "disabled": boolean;
        "size": "small" | "large" | "icon" | "flexible";
        "shape": "rounded";
        "display": boolean;
        "type": "form" | "input";
        "tooltip": string;
    }
    interface SmoothlyInputColorAttributes {
        "value": string | undefined;
        "looks": Looks;
        "color": Color;
        "readonly": boolean;
        "disabled": boolean;
        "output": "rgb" | "hex";
        "name": string;
        "showLabel": boolean;
    }
    interface SmoothlyInputDateAttributes {
        "locale": isoly.Locale;
        "color": Color;
        "looks": Looks;
        "name": string;
        "readonly": boolean;
        "disabled": boolean;
        "invalid": boolean;
        "errorMessage": string;
        "placeholder": string;
        "alwaysShowGuide": boolean;
        "value": isoly.Date;
        "open": boolean;
        "max": isoly.Date;
        "min": isoly.Date;
        "showLabel": boolean;
    }
    interface SmoothlyInputDateRangeAttributes {
        "locale": isoly.Locale;
        "name": string;
        "color": Color;
        "looks": Looks;
        "readonly": boolean;
        "disabled": boolean;
        "showLabel": boolean;
        "start": isoly.Date | undefined;
        "end": isoly.Date | undefined;
        "placeholder": string;
        "alwaysShowGuide": boolean;
        "invalid": boolean;
        "errorMessage": string;
        "max": isoly.Date;
        "min": isoly.Date;
    }
    interface SmoothlyInputDateTimeAttributes {
        "color": Color;
        "looks": Looks;
        "name": string;
        "readonly": boolean;
        "disabled": boolean;
        "invalid": boolean;
        "errorMessage": string;
        "value": isoly.DateTime;
        "open": boolean;
        "showLabel": boolean;
        "min": isoly.DateTime;
        "max": isoly.DateTime;
    }
    interface SmoothlyInputEditAttributes {
        "color": Color;
        "expand": "block" | "full";
        "fill": Fill;
        "disabled": boolean;
        "display": boolean;
        "shape": "rounded";
        "type": "form" | "input";
        "size": "flexible" | "small" | "large" | "icon";
        "tooltip": string;
    }
    interface SmoothlyInputFileAttributes {
        "readonly": boolean;
        "disabled": boolean;
        "accept": string;
        "color": Color;
        "looks": Looks;
        "camera": "front" | "back";
        "name": string;
        "showLabel": boolean;
        "placeholder": string | undefined;
    }
    interface SmoothlyInputMonthAttributes {
        "readonly": boolean;
        "color": Color;
        "looks": Looks;
        "name": string;
        "value": isoly.Date;
        "max": isoly.Date;
        "min": isoly.Date;
        "next": boolean;
        "previous": boolean;
        "inCalendar": boolean;
        "showLabel": boolean;
    }
    interface SmoothlyInputRadioAttributes {
        "value": string;
        "looks": Looks;
        "color": Color;
        "direction": "row" | "column";
        "clearable": boolean;
        "readonly": boolean;
        "disabled": boolean;
        "name": string;
        "showLabel": boolean;
    }
    interface SmoothlyInputRadioItemAttributes {
        "value": string;
        "selected": boolean;
        "looks": Looks;
        "name": string;
    }
    interface SmoothlyInputRangeAttributes {
        "value": number | undefined;
        "looks": Looks;
        "color": Color;
        "defined": boolean;
        "readonly": boolean;
        "disabled": boolean;
        "type": Extract<tidily.Type, "text" | "percent">;
        "min": number;
        "max": number;
        "name": string;
        "step": number;
        "outputSide": "right" | "left";
        "label": string;
    }
    interface SmoothlyInputResetAttributes {
        "color": Color;
        "expand": "block" | "full";
        "fill": Fill;
        "disabled": boolean;
        "size": "flexible" | "small" | "large" | "icon";
        "shape": "rounded";
        "display": boolean;
        "type": "form" | "input";
        "tooltip": string;
    }
    interface SmoothlyInputSelectAttributes {
        "invalid": boolean;
        "errorMessage": string;
        "name": string;
        "color": Color;
        "looks": Looks;
        "showLabel": boolean;
        "showSelected": boolean;
        "readonly": boolean;
        "disabled": boolean;
        "inCalendar": boolean;
        "ordered": boolean;
        "multiple": boolean;
        "clearable": boolean;
        "defined": boolean;
        "placeholder": string;
        "menuHeight": layout.MenuHeight;
        "required": boolean;
        "searchDisabled": boolean;
        "mutable": boolean;
    }
    interface SmoothlyInputSubmitAttributes {
        "delete": boolean;
        "color": Color;
        "icon": string;
        "expand": "block" | "full";
        "fill": Fill;
        "disabled": boolean;
        "display": boolean;
        "shape": "rounded";
        "size": "flexible" | "small" | "large" | "icon";
        "tooltip": string;
    }
    interface SmoothlyItemAttributes {
        "value": string;
        "selected": boolean;
        "marked": boolean;
        "disabled": boolean;
        "deselectable": boolean;
    }
    interface SmoothlyLabelAttributes {
        "hue": number;
        "description": string;
        "shape": "rectangle" | "rounded";
    }
    interface SmoothlyLazyAttributes {
        "show": boolean;
    }
    interface SmoothlyLoadMoreAttributes {
        "triggerMode": "scroll" | "intersection";
        "name": string;
        "multiple": boolean;
    }
    interface SmoothlyModalAttributes {
        "open": boolean;
        "closable": boolean;
        "align": "top" | "center";
    }
    interface SmoothlyNotificationAttributes {
        "closable": boolean;
        "icon": boolean;
    }
    interface SmoothlyNotifierAttributes {
        "icon": boolean;
    }
    interface SmoothlySpinnerAttributes {
        "size": "small" | "icon" | "medium" | "large";
        "overlay": boolean;
    }
    interface SmoothlySubmitAttributes {
        "color": Color;
        "expand": "block" | "full";
        "fill": Fill;
        "disabled": boolean;
        "type": "link" | "button";
        "size": "flexible" | "small" | "large" | "icon";
        "shape": "rounded";
        "prevent": boolean;
    }
    interface SmoothlySummaryAttributes {
        "open": boolean;
    }
    interface SmoothlyTabAttributes {
        "label": string;
        "name": string;
        "tooltip": string;
        "open": boolean;
        "disabled": boolean;
    }
    interface SmoothlyTableAttributes {
        "columns": number;
    }
    interface SmoothlyTableCellAttributes {
        "span": number;
    }
    interface SmoothlyTableExpandableCellAttributes {
        "span": number;
        "open": boolean;
    }
    interface SmoothlyTableExpandableRowAttributes {
        "open": boolean;
    }
    interface SmoothlyTableRowGroupAttributes {
        "align": boolean;
        "open": boolean;
    }
    interface SmoothlyTabsAttributes {
        "tabs": "always" | "multiple";
        "numberOfTabs": number;
    }
    interface SmoothlyThemeColorAttributes {
        "color": Color;
    }
    interface SmoothlyThemeColorVariantAttributes {
        "color": Color;
        "variant": "shade" | "tint" | "color";
    }
    interface SmoothlyThemePickerAttributes {
        "element": string;
    }
    interface SmoothlyToggleSwitchAttributes {
        "checkmark": boolean;
        "selected": boolean;
        "disabled": boolean;
        "size": "tiny" | "small" | "default" | "large";
        "color": Color;
        "fill": Fill;
    }
    interface SmoothlyTriggerAttributes {
        "color": Color | undefined;
        "fill": Fill;
        "disabled": boolean;
        "type": "link" | "button";
        "name": string;
        "value": string;
    }
    interface SmoothlyTriggerSinkAttributes {
        "destination": string;
        "filter": string;
    }
    interface SmoothlyTriggerSourceAttributes {
        "listen": string;
    }

    interface IntrinsicElements {
        "smoothly-app": Omit<SmoothlyApp, keyof SmoothlyAppAttributes> & { [K in keyof SmoothlyApp & keyof SmoothlyAppAttributes]?: SmoothlyApp[K] } & { [K in keyof SmoothlyApp & keyof SmoothlyAppAttributes as `attr:${K}`]?: SmoothlyAppAttributes[K] } & { [K in keyof SmoothlyApp & keyof SmoothlyAppAttributes as `prop:${K}`]?: SmoothlyApp[K] };
        "smoothly-app-demo": Omit<SmoothlyAppDemo, keyof SmoothlyAppDemoAttributes> & { [K in keyof SmoothlyAppDemo & keyof SmoothlyAppDemoAttributes]?: SmoothlyAppDemo[K] } & { [K in keyof SmoothlyAppDemo & keyof SmoothlyAppDemoAttributes as `attr:${K}`]?: SmoothlyAppDemoAttributes[K] } & { [K in keyof SmoothlyAppDemo & keyof SmoothlyAppDemoAttributes as `prop:${K}`]?: SmoothlyAppDemo[K] };
        "smoothly-app-room": Omit<SmoothlyAppRoom, keyof SmoothlyAppRoomAttributes> & { [K in keyof SmoothlyAppRoom & keyof SmoothlyAppRoomAttributes]?: SmoothlyAppRoom[K] } & { [K in keyof SmoothlyAppRoom & keyof SmoothlyAppRoomAttributes as `attr:${K}`]?: SmoothlyAppRoomAttributes[K] } & { [K in keyof SmoothlyAppRoom & keyof SmoothlyAppRoomAttributes as `prop:${K}`]?: SmoothlyAppRoom[K] };
        "smoothly-back-to-top": Omit<SmoothlyBackToTop, keyof SmoothlyBackToTopAttributes> & { [K in keyof SmoothlyBackToTop & keyof SmoothlyBackToTopAttributes]?: SmoothlyBackToTop[K] } & { [K in keyof SmoothlyBackToTop & keyof SmoothlyBackToTopAttributes as `attr:${K}`]?: SmoothlyBackToTopAttributes[K] } & { [K in keyof SmoothlyBackToTop & keyof SmoothlyBackToTopAttributes as `prop:${K}`]?: SmoothlyBackToTop[K] };
        "smoothly-burger": Omit<SmoothlyBurger, keyof SmoothlyBurgerAttributes> & { [K in keyof SmoothlyBurger & keyof SmoothlyBurgerAttributes]?: SmoothlyBurger[K] } & { [K in keyof SmoothlyBurger & keyof SmoothlyBurgerAttributes as `attr:${K}`]?: SmoothlyBurgerAttributes[K] } & { [K in keyof SmoothlyBurger & keyof SmoothlyBurgerAttributes as `prop:${K}`]?: SmoothlyBurger[K] };
        "smoothly-button": Omit<SmoothlyButton, keyof SmoothlyButtonAttributes> & { [K in keyof SmoothlyButton & keyof SmoothlyButtonAttributes]?: SmoothlyButton[K] } & { [K in keyof SmoothlyButton & keyof SmoothlyButtonAttributes as `attr:${K}`]?: SmoothlyButtonAttributes[K] } & { [K in keyof SmoothlyButton & keyof SmoothlyButtonAttributes as `prop:${K}`]?: SmoothlyButton[K] };
        "smoothly-button-confirm": Omit<SmoothlyButtonConfirm, keyof SmoothlyButtonConfirmAttributes> & { [K in keyof SmoothlyButtonConfirm & keyof SmoothlyButtonConfirmAttributes]?: SmoothlyButtonConfirm[K] } & { [K in keyof SmoothlyButtonConfirm & keyof SmoothlyButtonConfirmAttributes as `attr:${K}`]?: SmoothlyButtonConfirmAttributes[K] } & { [K in keyof SmoothlyButtonConfirm & keyof SmoothlyButtonConfirmAttributes as `prop:${K}`]?: SmoothlyButtonConfirm[K] };
        "smoothly-button-demo": SmoothlyButtonDemo;
        "smoothly-button-demo-standard": SmoothlyButtonDemoStandard;
        "smoothly-calendar": Omit<SmoothlyCalendar, keyof SmoothlyCalendarAttributes> & { [K in keyof SmoothlyCalendar & keyof SmoothlyCalendarAttributes]?: SmoothlyCalendar[K] } & { [K in keyof SmoothlyCalendar & keyof SmoothlyCalendarAttributes as `attr:${K}`]?: SmoothlyCalendarAttributes[K] } & { [K in keyof SmoothlyCalendar & keyof SmoothlyCalendarAttributes as `prop:${K}`]?: SmoothlyCalendar[K] };
        "smoothly-checkbox": Omit<SmoothlyCheckbox, keyof SmoothlyCheckboxAttributes> & { [K in keyof SmoothlyCheckbox & keyof SmoothlyCheckboxAttributes]?: SmoothlyCheckbox[K] } & { [K in keyof SmoothlyCheckbox & keyof SmoothlyCheckboxAttributes as `attr:${K}`]?: SmoothlyCheckboxAttributes[K] } & { [K in keyof SmoothlyCheckbox & keyof SmoothlyCheckboxAttributes as `prop:${K}`]?: SmoothlyCheckbox[K] };
        "smoothly-color": Omit<SmoothlyColor, keyof SmoothlyColorAttributes> & { [K in keyof SmoothlyColor & keyof SmoothlyColorAttributes]?: SmoothlyColor[K] } & { [K in keyof SmoothlyColor & keyof SmoothlyColorAttributes as `attr:${K}`]?: SmoothlyColorAttributes[K] } & { [K in keyof SmoothlyColor & keyof SmoothlyColorAttributes as `prop:${K}`]?: SmoothlyColor[K] };
        "smoothly-country": Omit<SmoothlyCountry, keyof SmoothlyCountryAttributes> & { [K in keyof SmoothlyCountry & keyof SmoothlyCountryAttributes]?: SmoothlyCountry[K] } & { [K in keyof SmoothlyCountry & keyof SmoothlyCountryAttributes as `attr:${K}`]?: SmoothlyCountryAttributes[K] } & { [K in keyof SmoothlyCountry & keyof SmoothlyCountryAttributes as `prop:${K}`]?: SmoothlyCountry[K] };
        "smoothly-date-text": Omit<SmoothlyDateText, keyof SmoothlyDateTextAttributes> & { [K in keyof SmoothlyDateText & keyof SmoothlyDateTextAttributes]?: SmoothlyDateText[K] } & { [K in keyof SmoothlyDateText & keyof SmoothlyDateTextAttributes as `attr:${K}`]?: SmoothlyDateTextAttributes[K] } & { [K in keyof SmoothlyDateText & keyof SmoothlyDateTextAttributes as `prop:${K}`]?: SmoothlyDateText[K] };
        "smoothly-dialog": Omit<SmoothlyDialog, keyof SmoothlyDialogAttributes> & { [K in keyof SmoothlyDialog & keyof SmoothlyDialogAttributes]?: SmoothlyDialog[K] } & { [K in keyof SmoothlyDialog & keyof SmoothlyDialogAttributes as `attr:${K}`]?: SmoothlyDialogAttributes[K] } & { [K in keyof SmoothlyDialog & keyof SmoothlyDialogAttributes as `prop:${K}`]?: SmoothlyDialog[K] };
        "smoothly-dialog-demo": SmoothlyDialogDemo;
        "smoothly-display": Omit<SmoothlyDisplay, keyof SmoothlyDisplayAttributes> & { [K in keyof SmoothlyDisplay & keyof SmoothlyDisplayAttributes]?: SmoothlyDisplay[K] } & { [K in keyof SmoothlyDisplay & keyof SmoothlyDisplayAttributes as `attr:${K}`]?: SmoothlyDisplayAttributes[K] } & { [K in keyof SmoothlyDisplay & keyof SmoothlyDisplayAttributes as `prop:${K}`]?: SmoothlyDisplay[K] };
        "smoothly-display-demo": SmoothlyDisplayDemo;
        "smoothly-display-demo-json": SmoothlyDisplayDemoJson;
        "smoothly-display-json": Omit<SmoothlyDisplayJson, keyof SmoothlyDisplayJsonAttributes> & { [K in keyof SmoothlyDisplayJson & keyof SmoothlyDisplayJsonAttributes]?: SmoothlyDisplayJson[K] } & { [K in keyof SmoothlyDisplayJson & keyof SmoothlyDisplayJsonAttributes as `attr:${K}`]?: SmoothlyDisplayJsonAttributes[K] } & { [K in keyof SmoothlyDisplayJson & keyof SmoothlyDisplayJsonAttributes as `prop:${K}`]?: SmoothlyDisplayJson[K] };
        "smoothly-display-json-object": Omit<SmoothlyDisplayJsonObject, keyof SmoothlyDisplayJsonObjectAttributes> & { [K in keyof SmoothlyDisplayJsonObject & keyof SmoothlyDisplayJsonObjectAttributes]?: SmoothlyDisplayJsonObject[K] } & { [K in keyof SmoothlyDisplayJsonObject & keyof SmoothlyDisplayJsonObjectAttributes as `attr:${K}`]?: SmoothlyDisplayJsonObjectAttributes[K] } & { [K in keyof SmoothlyDisplayJsonObject & keyof SmoothlyDisplayJsonObjectAttributes as `prop:${K}`]?: SmoothlyDisplayJsonObject[K] };
        "smoothly-display-json-primitive": Omit<SmoothlyDisplayJsonPrimitive, keyof SmoothlyDisplayJsonPrimitiveAttributes> & { [K in keyof SmoothlyDisplayJsonPrimitive & keyof SmoothlyDisplayJsonPrimitiveAttributes]?: SmoothlyDisplayJsonPrimitive[K] } & { [K in keyof SmoothlyDisplayJsonPrimitive & keyof SmoothlyDisplayJsonPrimitiveAttributes as `attr:${K}`]?: SmoothlyDisplayJsonPrimitiveAttributes[K] } & { [K in keyof SmoothlyDisplayJsonPrimitive & keyof SmoothlyDisplayJsonPrimitiveAttributes as `prop:${K}`]?: SmoothlyDisplayJsonPrimitive[K] };
        "smoothly-display-json-record-key": Omit<SmoothlyDisplayJsonRecordKey, keyof SmoothlyDisplayJsonRecordKeyAttributes> & { [K in keyof SmoothlyDisplayJsonRecordKey & keyof SmoothlyDisplayJsonRecordKeyAttributes]?: SmoothlyDisplayJsonRecordKey[K] } & { [K in keyof SmoothlyDisplayJsonRecordKey & keyof SmoothlyDisplayJsonRecordKeyAttributes as `attr:${K}`]?: SmoothlyDisplayJsonRecordKeyAttributes[K] } & { [K in keyof SmoothlyDisplayJsonRecordKey & keyof SmoothlyDisplayJsonRecordKeyAttributes as `prop:${K}`]?: SmoothlyDisplayJsonRecordKey[K] };
        "smoothly-form": Omit<SmoothlyForm, keyof SmoothlyFormAttributes> & { [K in keyof SmoothlyForm & keyof SmoothlyFormAttributes]?: SmoothlyForm[K] } & { [K in keyof SmoothlyForm & keyof SmoothlyFormAttributes as `attr:${K}`]?: SmoothlyFormAttributes[K] } & { [K in keyof SmoothlyForm & keyof SmoothlyFormAttributes as `prop:${K}`]?: SmoothlyForm[K] };
        "smoothly-form-demo": SmoothlyFormDemo;
        "smoothly-form-demo-all": SmoothlyFormDemoAll;
        "smoothly-form-demo-card": SmoothlyFormDemoCard;
        "smoothly-form-demo-controlled": SmoothlyFormDemoControlled;
        "smoothly-form-demo-date": SmoothlyFormDemoDate;
        "smoothly-form-demo-date-range": SmoothlyFormDemoDateRange;
        "smoothly-form-demo-login": SmoothlyFormDemoLogin;
        "smoothly-form-demo-pet": SmoothlyFormDemoPet;
        "smoothly-form-demo-prices": SmoothlyFormDemoPrices;
        "smoothly-form-demo-schedule": SmoothlyFormDemoSchedule;
        "smoothly-form-demo-transparent": SmoothlyFormDemoTransparent;
        "smoothly-form-demo-typed": SmoothlyFormDemoTyped;
        "smoothly-frame": Omit<SmoothlyFrame, keyof SmoothlyFrameAttributes> & { [K in keyof SmoothlyFrame & keyof SmoothlyFrameAttributes]?: SmoothlyFrame[K] } & { [K in keyof SmoothlyFrame & keyof SmoothlyFrameAttributes as `attr:${K}`]?: SmoothlyFrameAttributes[K] } & { [K in keyof SmoothlyFrame & keyof SmoothlyFrameAttributes as `prop:${K}`]?: SmoothlyFrame[K] };
        "smoothly-icon": Omit<SmoothlyIcon, keyof SmoothlyIconAttributes> & { [K in keyof SmoothlyIcon & keyof SmoothlyIconAttributes]?: SmoothlyIcon[K] } & { [K in keyof SmoothlyIcon & keyof SmoothlyIconAttributes as `attr:${K}`]?: SmoothlyIconAttributes[K] } & { [K in keyof SmoothlyIcon & keyof SmoothlyIconAttributes as `prop:${K}`]?: SmoothlyIcon[K] };
        "smoothly-icon-demo": SmoothlyIconDemo;
        "smoothly-input": Omit<SmoothlyInput, keyof SmoothlyInputAttributes> & { [K in keyof SmoothlyInput & keyof SmoothlyInputAttributes]?: SmoothlyInput[K] } & { [K in keyof SmoothlyInput & keyof SmoothlyInputAttributes as `attr:${K}`]?: SmoothlyInputAttributes[K] } & { [K in keyof SmoothlyInput & keyof SmoothlyInputAttributes as `prop:${K}`]?: SmoothlyInput[K] };
        "smoothly-input-checkbox": Omit<SmoothlyInputCheckbox, keyof SmoothlyInputCheckboxAttributes> & { [K in keyof SmoothlyInputCheckbox & keyof SmoothlyInputCheckboxAttributes]?: SmoothlyInputCheckbox[K] } & { [K in keyof SmoothlyInputCheckbox & keyof SmoothlyInputCheckboxAttributes as `attr:${K}`]?: SmoothlyInputCheckboxAttributes[K] } & { [K in keyof SmoothlyInputCheckbox & keyof SmoothlyInputCheckboxAttributes as `prop:${K}`]?: SmoothlyInputCheckbox[K] };
        "smoothly-input-checkbox-demo": SmoothlyInputCheckboxDemo;
        "smoothly-input-clear": Omit<SmoothlyInputClear, keyof SmoothlyInputClearAttributes> & { [K in keyof SmoothlyInputClear & keyof SmoothlyInputClearAttributes]?: SmoothlyInputClear[K] } & { [K in keyof SmoothlyInputClear & keyof SmoothlyInputClearAttributes as `attr:${K}`]?: SmoothlyInputClearAttributes[K] } & { [K in keyof SmoothlyInputClear & keyof SmoothlyInputClearAttributes as `prop:${K}`]?: SmoothlyInputClear[K] };
        "smoothly-input-color": Omit<SmoothlyInputColor, keyof SmoothlyInputColorAttributes> & { [K in keyof SmoothlyInputColor & keyof SmoothlyInputColorAttributes]?: SmoothlyInputColor[K] } & { [K in keyof SmoothlyInputColor & keyof SmoothlyInputColorAttributes as `attr:${K}`]?: SmoothlyInputColorAttributes[K] } & { [K in keyof SmoothlyInputColor & keyof SmoothlyInputColorAttributes as `prop:${K}`]?: SmoothlyInputColor[K] };
        "smoothly-input-color-demo": SmoothlyInputColorDemo;
        "smoothly-input-date": Omit<SmoothlyInputDate, keyof SmoothlyInputDateAttributes> & { [K in keyof SmoothlyInputDate & keyof SmoothlyInputDateAttributes]?: SmoothlyInputDate[K] } & { [K in keyof SmoothlyInputDate & keyof SmoothlyInputDateAttributes as `attr:${K}`]?: SmoothlyInputDateAttributes[K] } & { [K in keyof SmoothlyInputDate & keyof SmoothlyInputDateAttributes as `prop:${K}`]?: SmoothlyInputDate[K] };
        "smoothly-input-date-demo": SmoothlyInputDateDemo;
        "smoothly-input-date-range": Omit<SmoothlyInputDateRange, keyof SmoothlyInputDateRangeAttributes> & { [K in keyof SmoothlyInputDateRange & keyof SmoothlyInputDateRangeAttributes]?: SmoothlyInputDateRange[K] } & { [K in keyof SmoothlyInputDateRange & keyof SmoothlyInputDateRangeAttributes as `attr:${K}`]?: SmoothlyInputDateRangeAttributes[K] } & { [K in keyof SmoothlyInputDateRange & keyof SmoothlyInputDateRangeAttributes as `prop:${K}`]?: SmoothlyInputDateRange[K] };
        "smoothly-input-date-time": Omit<SmoothlyInputDateTime, keyof SmoothlyInputDateTimeAttributes> & { [K in keyof SmoothlyInputDateTime & keyof SmoothlyInputDateTimeAttributes]?: SmoothlyInputDateTime[K] } & { [K in keyof SmoothlyInputDateTime & keyof SmoothlyInputDateTimeAttributes as `attr:${K}`]?: SmoothlyInputDateTimeAttributes[K] } & { [K in keyof SmoothlyInputDateTime & keyof SmoothlyInputDateTimeAttributes as `prop:${K}`]?: SmoothlyInputDateTime[K] };
        "smoothly-input-demo": SmoothlyInputDemo;
        "smoothly-input-demo-radio": SmoothlyInputDemoRadio;
        "smoothly-input-demo-standard": SmoothlyInputDemoStandard;
        "smoothly-input-demo-user-input": SmoothlyInputDemoUserInput;
        "smoothly-input-edit": Omit<SmoothlyInputEdit, keyof SmoothlyInputEditAttributes> & { [K in keyof SmoothlyInputEdit & keyof SmoothlyInputEditAttributes]?: SmoothlyInputEdit[K] } & { [K in keyof SmoothlyInputEdit & keyof SmoothlyInputEditAttributes as `attr:${K}`]?: SmoothlyInputEditAttributes[K] } & { [K in keyof SmoothlyInputEdit & keyof SmoothlyInputEditAttributes as `prop:${K}`]?: SmoothlyInputEdit[K] };
        "smoothly-input-file": Omit<SmoothlyInputFile, keyof SmoothlyInputFileAttributes> & { [K in keyof SmoothlyInputFile & keyof SmoothlyInputFileAttributes]?: SmoothlyInputFile[K] } & { [K in keyof SmoothlyInputFile & keyof SmoothlyInputFileAttributes as `attr:${K}`]?: SmoothlyInputFileAttributes[K] } & { [K in keyof SmoothlyInputFile & keyof SmoothlyInputFileAttributes as `prop:${K}`]?: SmoothlyInputFile[K] };
        "smoothly-input-month": Omit<SmoothlyInputMonth, keyof SmoothlyInputMonthAttributes> & { [K in keyof SmoothlyInputMonth & keyof SmoothlyInputMonthAttributes]?: SmoothlyInputMonth[K] } & { [K in keyof SmoothlyInputMonth & keyof SmoothlyInputMonthAttributes as `attr:${K}`]?: SmoothlyInputMonthAttributes[K] } & { [K in keyof SmoothlyInputMonth & keyof SmoothlyInputMonthAttributes as `prop:${K}`]?: SmoothlyInputMonth[K] };
        "smoothly-input-price-demo": SmoothlyInputPriceDemo;
        "smoothly-input-radio": Omit<SmoothlyInputRadio, keyof SmoothlyInputRadioAttributes> & { [K in keyof SmoothlyInputRadio & keyof SmoothlyInputRadioAttributes]?: SmoothlyInputRadio[K] } & { [K in keyof SmoothlyInputRadio & keyof SmoothlyInputRadioAttributes as `attr:${K}`]?: SmoothlyInputRadioAttributes[K] } & { [K in keyof SmoothlyInputRadio & keyof SmoothlyInputRadioAttributes as `prop:${K}`]?: SmoothlyInputRadio[K] };
        "smoothly-input-radio-item": Omit<SmoothlyInputRadioItem, keyof SmoothlyInputRadioItemAttributes> & { [K in keyof SmoothlyInputRadioItem & keyof SmoothlyInputRadioItemAttributes]?: SmoothlyInputRadioItem[K] } & { [K in keyof SmoothlyInputRadioItem & keyof SmoothlyInputRadioItemAttributes as `attr:${K}`]?: SmoothlyInputRadioItemAttributes[K] } & { [K in keyof SmoothlyInputRadioItem & keyof SmoothlyInputRadioItemAttributes as `prop:${K}`]?: SmoothlyInputRadioItem[K] };
        "smoothly-input-range": Omit<SmoothlyInputRange, keyof SmoothlyInputRangeAttributes> & { [K in keyof SmoothlyInputRange & keyof SmoothlyInputRangeAttributes]?: SmoothlyInputRange[K] } & { [K in keyof SmoothlyInputRange & keyof SmoothlyInputRangeAttributes as `attr:${K}`]?: SmoothlyInputRangeAttributes[K] } & { [K in keyof SmoothlyInputRange & keyof SmoothlyInputRangeAttributes as `prop:${K}`]?: SmoothlyInputRange[K] };
        "smoothly-input-range-demo": SmoothlyInputRangeDemo;
        "smoothly-input-reset": Omit<SmoothlyInputReset, keyof SmoothlyInputResetAttributes> & { [K in keyof SmoothlyInputReset & keyof SmoothlyInputResetAttributes]?: SmoothlyInputReset[K] } & { [K in keyof SmoothlyInputReset & keyof SmoothlyInputResetAttributes as `attr:${K}`]?: SmoothlyInputResetAttributes[K] } & { [K in keyof SmoothlyInputReset & keyof SmoothlyInputResetAttributes as `prop:${K}`]?: SmoothlyInputReset[K] };
        "smoothly-input-select": Omit<SmoothlyInputSelect, keyof SmoothlyInputSelectAttributes> & { [K in keyof SmoothlyInputSelect & keyof SmoothlyInputSelectAttributes]?: SmoothlyInputSelect[K] } & { [K in keyof SmoothlyInputSelect & keyof SmoothlyInputSelectAttributes as `attr:${K}`]?: SmoothlyInputSelectAttributes[K] } & { [K in keyof SmoothlyInputSelect & keyof SmoothlyInputSelectAttributes as `prop:${K}`]?: SmoothlyInputSelect[K] };
        "smoothly-input-submit": Omit<SmoothlyInputSubmit, keyof SmoothlyInputSubmitAttributes> & { [K in keyof SmoothlyInputSubmit & keyof SmoothlyInputSubmitAttributes]?: SmoothlyInputSubmit[K] } & { [K in keyof SmoothlyInputSubmit & keyof SmoothlyInputSubmitAttributes as `attr:${K}`]?: SmoothlyInputSubmitAttributes[K] } & { [K in keyof SmoothlyInputSubmit & keyof SmoothlyInputSubmitAttributes as `prop:${K}`]?: SmoothlyInputSubmit[K] };
        "smoothly-item": Omit<SmoothlyItem, keyof SmoothlyItemAttributes> & { [K in keyof SmoothlyItem & keyof SmoothlyItemAttributes]?: SmoothlyItem[K] } & { [K in keyof SmoothlyItem & keyof SmoothlyItemAttributes as `attr:${K}`]?: SmoothlyItemAttributes[K] } & { [K in keyof SmoothlyItem & keyof SmoothlyItemAttributes as `prop:${K}`]?: SmoothlyItem[K] };
        "smoothly-label": Omit<SmoothlyLabel, keyof SmoothlyLabelAttributes> & { [K in keyof SmoothlyLabel & keyof SmoothlyLabelAttributes]?: SmoothlyLabel[K] } & { [K in keyof SmoothlyLabel & keyof SmoothlyLabelAttributes as `attr:${K}`]?: SmoothlyLabelAttributes[K] } & { [K in keyof SmoothlyLabel & keyof SmoothlyLabelAttributes as `prop:${K}`]?: SmoothlyLabel[K] };
        "smoothly-lazy": Omit<SmoothlyLazy, keyof SmoothlyLazyAttributes> & { [K in keyof SmoothlyLazy & keyof SmoothlyLazyAttributes]?: SmoothlyLazy[K] } & { [K in keyof SmoothlyLazy & keyof SmoothlyLazyAttributes as `attr:${K}`]?: SmoothlyLazyAttributes[K] } & { [K in keyof SmoothlyLazy & keyof SmoothlyLazyAttributes as `prop:${K}`]?: SmoothlyLazy[K] };
        "smoothly-load-more": Omit<SmoothlyLoadMore, keyof SmoothlyLoadMoreAttributes> & { [K in keyof SmoothlyLoadMore & keyof SmoothlyLoadMoreAttributes]?: SmoothlyLoadMore[K] } & { [K in keyof SmoothlyLoadMore & keyof SmoothlyLoadMoreAttributes as `attr:${K}`]?: SmoothlyLoadMoreAttributes[K] } & { [K in keyof SmoothlyLoadMore & keyof SmoothlyLoadMoreAttributes as `prop:${K}`]?: SmoothlyLoadMore[K] };
        "smoothly-modal": Omit<SmoothlyModal, keyof SmoothlyModalAttributes> & { [K in keyof SmoothlyModal & keyof SmoothlyModalAttributes]?: SmoothlyModal[K] } & { [K in keyof SmoothlyModal & keyof SmoothlyModalAttributes as `attr:${K}`]?: SmoothlyModalAttributes[K] } & { [K in keyof SmoothlyModal & keyof SmoothlyModalAttributes as `prop:${K}`]?: SmoothlyModal[K] };
        "smoothly-notification": Omit<SmoothlyNotification, keyof SmoothlyNotificationAttributes> & { [K in keyof SmoothlyNotification & keyof SmoothlyNotificationAttributes]?: SmoothlyNotification[K] } & { [K in keyof SmoothlyNotification & keyof SmoothlyNotificationAttributes as `attr:${K}`]?: SmoothlyNotificationAttributes[K] } & { [K in keyof SmoothlyNotification & keyof SmoothlyNotificationAttributes as `prop:${K}`]?: SmoothlyNotification[K] };
        "smoothly-notifier": Omit<SmoothlyNotifier, keyof SmoothlyNotifierAttributes> & { [K in keyof SmoothlyNotifier & keyof SmoothlyNotifierAttributes]?: SmoothlyNotifier[K] } & { [K in keyof SmoothlyNotifier & keyof SmoothlyNotifierAttributes as `attr:${K}`]?: SmoothlyNotifierAttributes[K] } & { [K in keyof SmoothlyNotifier & keyof SmoothlyNotifierAttributes as `prop:${K}`]?: SmoothlyNotifier[K] };
        "smoothly-notifier-demo": SmoothlyNotifierDemo;
        "smoothly-spinner": Omit<SmoothlySpinner, keyof SmoothlySpinnerAttributes> & { [K in keyof SmoothlySpinner & keyof SmoothlySpinnerAttributes]?: SmoothlySpinner[K] } & { [K in keyof SmoothlySpinner & keyof SmoothlySpinnerAttributes as `attr:${K}`]?: SmoothlySpinnerAttributes[K] } & { [K in keyof SmoothlySpinner & keyof SmoothlySpinnerAttributes as `prop:${K}`]?: SmoothlySpinner[K] };
        "smoothly-submit": Omit<SmoothlySubmit, keyof SmoothlySubmitAttributes> & { [K in keyof SmoothlySubmit & keyof SmoothlySubmitAttributes]?: SmoothlySubmit[K] } & { [K in keyof SmoothlySubmit & keyof SmoothlySubmitAttributes as `attr:${K}`]?: SmoothlySubmitAttributes[K] } & { [K in keyof SmoothlySubmit & keyof SmoothlySubmitAttributes as `prop:${K}`]?: SmoothlySubmit[K] };
        "smoothly-summary": Omit<SmoothlySummary, keyof SmoothlySummaryAttributes> & { [K in keyof SmoothlySummary & keyof SmoothlySummaryAttributes]?: SmoothlySummary[K] } & { [K in keyof SmoothlySummary & keyof SmoothlySummaryAttributes as `attr:${K}`]?: SmoothlySummaryAttributes[K] } & { [K in keyof SmoothlySummary & keyof SmoothlySummaryAttributes as `prop:${K}`]?: SmoothlySummary[K] };
        "smoothly-tab": Omit<SmoothlyTab, keyof SmoothlyTabAttributes> & { [K in keyof SmoothlyTab & keyof SmoothlyTabAttributes]?: SmoothlyTab[K] } & { [K in keyof SmoothlyTab & keyof SmoothlyTabAttributes as `attr:${K}`]?: SmoothlyTabAttributes[K] } & { [K in keyof SmoothlyTab & keyof SmoothlyTabAttributes as `prop:${K}`]?: SmoothlyTab[K] };
        "smoothly-table": Omit<SmoothlyTable, keyof SmoothlyTableAttributes> & { [K in keyof SmoothlyTable & keyof SmoothlyTableAttributes]?: SmoothlyTable[K] } & { [K in keyof SmoothlyTable & keyof SmoothlyTableAttributes as `attr:${K}`]?: SmoothlyTableAttributes[K] } & { [K in keyof SmoothlyTable & keyof SmoothlyTableAttributes as `prop:${K}`]?: SmoothlyTable[K] };
        "smoothly-table-body": SmoothlyTableBody;
        "smoothly-table-cell": Omit<SmoothlyTableCell, keyof SmoothlyTableCellAttributes> & { [K in keyof SmoothlyTableCell & keyof SmoothlyTableCellAttributes]?: SmoothlyTableCell[K] } & { [K in keyof SmoothlyTableCell & keyof SmoothlyTableCellAttributes as `attr:${K}`]?: SmoothlyTableCellAttributes[K] } & { [K in keyof SmoothlyTableCell & keyof SmoothlyTableCellAttributes as `prop:${K}`]?: SmoothlyTableCell[K] };
        "smoothly-table-demo": SmoothlyTableDemo;
        "smoothly-table-demo-colspan": SmoothlyTableDemoColspan;
        "smoothly-table-demo-filler-row": SmoothlyTableDemoFillerRow;
        "smoothly-table-demo-group": SmoothlyTableDemoGroup;
        "smoothly-table-demo-nested-no-cell": SmoothlyTableDemoNestedNoCell;
        "smoothly-table-demo-nested-no-cell-inner": SmoothlyTableDemoNestedNoCellInner;
        "smoothly-table-demo-simple": SmoothlyTableDemoSimple;
        "smoothly-table-expandable-cell": Omit<SmoothlyTableExpandableCell, keyof SmoothlyTableExpandableCellAttributes> & { [K in keyof SmoothlyTableExpandableCell & keyof SmoothlyTableExpandableCellAttributes]?: SmoothlyTableExpandableCell[K] } & { [K in keyof SmoothlyTableExpandableCell & keyof SmoothlyTableExpandableCellAttributes as `attr:${K}`]?: SmoothlyTableExpandableCellAttributes[K] } & { [K in keyof SmoothlyTableExpandableCell & keyof SmoothlyTableExpandableCellAttributes as `prop:${K}`]?: SmoothlyTableExpandableCell[K] };
        "smoothly-table-expandable-row": Omit<SmoothlyTableExpandableRow, keyof SmoothlyTableExpandableRowAttributes> & { [K in keyof SmoothlyTableExpandableRow & keyof SmoothlyTableExpandableRowAttributes]?: SmoothlyTableExpandableRow[K] } & { [K in keyof SmoothlyTableExpandableRow & keyof SmoothlyTableExpandableRowAttributes as `attr:${K}`]?: SmoothlyTableExpandableRowAttributes[K] } & { [K in keyof SmoothlyTableExpandableRow & keyof SmoothlyTableExpandableRowAttributes as `prop:${K}`]?: SmoothlyTableExpandableRow[K] };
        "smoothly-table-filler-row": SmoothlyTableFillerRow;
        "smoothly-table-foot": SmoothlyTableFoot;
        "smoothly-table-head": SmoothlyTableHead;
        "smoothly-table-row": SmoothlyTableRow;
        "smoothly-table-row-group": Omit<SmoothlyTableRowGroup, keyof SmoothlyTableRowGroupAttributes> & { [K in keyof SmoothlyTableRowGroup & keyof SmoothlyTableRowGroupAttributes]?: SmoothlyTableRowGroup[K] } & { [K in keyof SmoothlyTableRowGroup & keyof SmoothlyTableRowGroupAttributes as `attr:${K}`]?: SmoothlyTableRowGroupAttributes[K] } & { [K in keyof SmoothlyTableRowGroup & keyof SmoothlyTableRowGroupAttributes as `prop:${K}`]?: SmoothlyTableRowGroup[K] };
        "smoothly-tabs": Omit<SmoothlyTabs, keyof SmoothlyTabsAttributes> & { [K in keyof SmoothlyTabs & keyof SmoothlyTabsAttributes]?: SmoothlyTabs[K] } & { [K in keyof SmoothlyTabs & keyof SmoothlyTabsAttributes as `attr:${K}`]?: SmoothlyTabsAttributes[K] } & { [K in keyof SmoothlyTabs & keyof SmoothlyTabsAttributes as `prop:${K}`]?: SmoothlyTabs[K] };
        "smoothly-tabs-demo": SmoothlyTabsDemo;
        "smoothly-theme-color": Omit<SmoothlyThemeColor, keyof SmoothlyThemeColorAttributes> & { [K in keyof SmoothlyThemeColor & keyof SmoothlyThemeColorAttributes]?: SmoothlyThemeColor[K] } & { [K in keyof SmoothlyThemeColor & keyof SmoothlyThemeColorAttributes as `attr:${K}`]?: SmoothlyThemeColorAttributes[K] } & { [K in keyof SmoothlyThemeColor & keyof SmoothlyThemeColorAttributes as `prop:${K}`]?: SmoothlyThemeColor[K] };
        "smoothly-theme-color-variant": Omit<SmoothlyThemeColorVariant, keyof SmoothlyThemeColorVariantAttributes> & { [K in keyof SmoothlyThemeColorVariant & keyof SmoothlyThemeColorVariantAttributes]?: SmoothlyThemeColorVariant[K] } & { [K in keyof SmoothlyThemeColorVariant & keyof SmoothlyThemeColorVariantAttributes as `attr:${K}`]?: SmoothlyThemeColorVariantAttributes[K] } & { [K in keyof SmoothlyThemeColorVariant & keyof SmoothlyThemeColorVariantAttributes as `prop:${K}`]?: SmoothlyThemeColorVariant[K] };
        "smoothly-theme-colors": SmoothlyThemeColors;
        "smoothly-theme-demo": SmoothlyThemeDemo;
        "smoothly-theme-guide": SmoothlyThemeGuide;
        "smoothly-theme-picker": Omit<SmoothlyThemePicker, keyof SmoothlyThemePickerAttributes> & { [K in keyof SmoothlyThemePicker & keyof SmoothlyThemePickerAttributes]?: SmoothlyThemePicker[K] } & { [K in keyof SmoothlyThemePicker & keyof SmoothlyThemePickerAttributes as `attr:${K}`]?: SmoothlyThemePickerAttributes[K] } & { [K in keyof SmoothlyThemePicker & keyof SmoothlyThemePickerAttributes as `prop:${K}`]?: SmoothlyThemePicker[K] };
        "smoothly-toggle-switch": Omit<SmoothlyToggleSwitch, keyof SmoothlyToggleSwitchAttributes> & { [K in keyof SmoothlyToggleSwitch & keyof SmoothlyToggleSwitchAttributes]?: SmoothlyToggleSwitch[K] } & { [K in keyof SmoothlyToggleSwitch & keyof SmoothlyToggleSwitchAttributes as `attr:${K}`]?: SmoothlyToggleSwitchAttributes[K] } & { [K in keyof SmoothlyToggleSwitch & keyof SmoothlyToggleSwitchAttributes as `prop:${K}`]?: SmoothlyToggleSwitch[K] };
        "smoothly-toggle-switch-demo": SmoothlyToggleSwitchDemo;
        "smoothly-trigger": Omit<SmoothlyTrigger, keyof SmoothlyTriggerAttributes> & { [K in keyof SmoothlyTrigger & keyof SmoothlyTriggerAttributes]?: SmoothlyTrigger[K] } & { [K in keyof SmoothlyTrigger & keyof SmoothlyTriggerAttributes as `attr:${K}`]?: SmoothlyTriggerAttributes[K] } & { [K in keyof SmoothlyTrigger & keyof SmoothlyTriggerAttributes as `prop:${K}`]?: SmoothlyTrigger[K] };
        "smoothly-trigger-sink": Omit<SmoothlyTriggerSink, keyof SmoothlyTriggerSinkAttributes> & { [K in keyof SmoothlyTriggerSink & keyof SmoothlyTriggerSinkAttributes]?: SmoothlyTriggerSink[K] } & { [K in keyof SmoothlyTriggerSink & keyof SmoothlyTriggerSinkAttributes as `attr:${K}`]?: SmoothlyTriggerSinkAttributes[K] } & { [K in keyof SmoothlyTriggerSink & keyof SmoothlyTriggerSinkAttributes as `prop:${K}`]?: SmoothlyTriggerSink[K] };
        "smoothly-trigger-source": Omit<SmoothlyTriggerSource, keyof SmoothlyTriggerSourceAttributes> & { [K in keyof SmoothlyTriggerSource & keyof SmoothlyTriggerSourceAttributes]?: SmoothlyTriggerSource[K] } & { [K in keyof SmoothlyTriggerSource & keyof SmoothlyTriggerSourceAttributes as `attr:${K}`]?: SmoothlyTriggerSourceAttributes[K] } & { [K in keyof SmoothlyTriggerSource & keyof SmoothlyTriggerSourceAttributes as `prop:${K}`]?: SmoothlyTriggerSource[K] };
    }
}
export { LocalJSX as JSX };
declare module "@stencil/core" {
    export namespace JSX {
        interface IntrinsicElements {
            "smoothly-app": LocalJSX.IntrinsicElements["smoothly-app"] & JSXBase.HTMLAttributes<HTMLSmoothlyAppElement>;
            "smoothly-app-demo": LocalJSX.IntrinsicElements["smoothly-app-demo"] & JSXBase.HTMLAttributes<HTMLSmoothlyAppDemoElement>;
            "smoothly-app-room": LocalJSX.IntrinsicElements["smoothly-app-room"] & JSXBase.HTMLAttributes<HTMLSmoothlyAppRoomElement>;
            "smoothly-back-to-top": LocalJSX.IntrinsicElements["smoothly-back-to-top"] & JSXBase.HTMLAttributes<HTMLSmoothlyBackToTopElement>;
            "smoothly-burger": LocalJSX.IntrinsicElements["smoothly-burger"] & JSXBase.HTMLAttributes<HTMLSmoothlyBurgerElement>;
            "smoothly-button": LocalJSX.IntrinsicElements["smoothly-button"] & JSXBase.HTMLAttributes<HTMLSmoothlyButtonElement>;
            "smoothly-button-confirm": LocalJSX.IntrinsicElements["smoothly-button-confirm"] & JSXBase.HTMLAttributes<HTMLSmoothlyButtonConfirmElement>;
            "smoothly-button-demo": LocalJSX.IntrinsicElements["smoothly-button-demo"] & JSXBase.HTMLAttributes<HTMLSmoothlyButtonDemoElement>;
            "smoothly-button-demo-standard": LocalJSX.IntrinsicElements["smoothly-button-demo-standard"] & JSXBase.HTMLAttributes<HTMLSmoothlyButtonDemoStandardElement>;
            "smoothly-calendar": LocalJSX.IntrinsicElements["smoothly-calendar"] & JSXBase.HTMLAttributes<HTMLSmoothlyCalendarElement>;
            "smoothly-checkbox": LocalJSX.IntrinsicElements["smoothly-checkbox"] & JSXBase.HTMLAttributes<HTMLSmoothlyCheckboxElement>;
            "smoothly-color": LocalJSX.IntrinsicElements["smoothly-color"] & JSXBase.HTMLAttributes<HTMLSmoothlyColorElement>;
            "smoothly-country": LocalJSX.IntrinsicElements["smoothly-country"] & JSXBase.HTMLAttributes<HTMLSmoothlyCountryElement>;
            "smoothly-date-text": LocalJSX.IntrinsicElements["smoothly-date-text"] & JSXBase.HTMLAttributes<HTMLSmoothlyDateTextElement>;
            "smoothly-dialog": LocalJSX.IntrinsicElements["smoothly-dialog"] & JSXBase.HTMLAttributes<HTMLSmoothlyDialogElement>;
            "smoothly-dialog-demo": LocalJSX.IntrinsicElements["smoothly-dialog-demo"] & JSXBase.HTMLAttributes<HTMLSmoothlyDialogDemoElement>;
            "smoothly-display": LocalJSX.IntrinsicElements["smoothly-display"] & JSXBase.HTMLAttributes<HTMLSmoothlyDisplayElement>;
            "smoothly-display-demo": LocalJSX.IntrinsicElements["smoothly-display-demo"] & JSXBase.HTMLAttributes<HTMLSmoothlyDisplayDemoElement>;
            "smoothly-display-demo-json": LocalJSX.IntrinsicElements["smoothly-display-demo-json"] & JSXBase.HTMLAttributes<HTMLSmoothlyDisplayDemoJsonElement>;
            "smoothly-display-json": LocalJSX.IntrinsicElements["smoothly-display-json"] & JSXBase.HTMLAttributes<HTMLSmoothlyDisplayJsonElement>;
            "smoothly-display-json-object": LocalJSX.IntrinsicElements["smoothly-display-json-object"] & JSXBase.HTMLAttributes<HTMLSmoothlyDisplayJsonObjectElement>;
            "smoothly-display-json-primitive": LocalJSX.IntrinsicElements["smoothly-display-json-primitive"] & JSXBase.HTMLAttributes<HTMLSmoothlyDisplayJsonPrimitiveElement>;
            "smoothly-display-json-record-key": LocalJSX.IntrinsicElements["smoothly-display-json-record-key"] & JSXBase.HTMLAttributes<HTMLSmoothlyDisplayJsonRecordKeyElement>;
            "smoothly-form": LocalJSX.IntrinsicElements["smoothly-form"] & JSXBase.HTMLAttributes<HTMLSmoothlyFormElement>;
            "smoothly-form-demo": LocalJSX.IntrinsicElements["smoothly-form-demo"] & JSXBase.HTMLAttributes<HTMLSmoothlyFormDemoElement>;
            "smoothly-form-demo-all": LocalJSX.IntrinsicElements["smoothly-form-demo-all"] & JSXBase.HTMLAttributes<HTMLSmoothlyFormDemoAllElement>;
            "smoothly-form-demo-card": LocalJSX.IntrinsicElements["smoothly-form-demo-card"] & JSXBase.HTMLAttributes<HTMLSmoothlyFormDemoCardElement>;
            "smoothly-form-demo-controlled": LocalJSX.IntrinsicElements["smoothly-form-demo-controlled"] & JSXBase.HTMLAttributes<HTMLSmoothlyFormDemoControlledElement>;
            "smoothly-form-demo-date": LocalJSX.IntrinsicElements["smoothly-form-demo-date"] & JSXBase.HTMLAttributes<HTMLSmoothlyFormDemoDateElement>;
            "smoothly-form-demo-date-range": LocalJSX.IntrinsicElements["smoothly-form-demo-date-range"] & JSXBase.HTMLAttributes<HTMLSmoothlyFormDemoDateRangeElement>;
            "smoothly-form-demo-login": LocalJSX.IntrinsicElements["smoothly-form-demo-login"] & JSXBase.HTMLAttributes<HTMLSmoothlyFormDemoLoginElement>;
            "smoothly-form-demo-pet": LocalJSX.IntrinsicElements["smoothly-form-demo-pet"] & JSXBase.HTMLAttributes<HTMLSmoothlyFormDemoPetElement>;
            "smoothly-form-demo-prices": LocalJSX.IntrinsicElements["smoothly-form-demo-prices"] & JSXBase.HTMLAttributes<HTMLSmoothlyFormDemoPricesElement>;
            "smoothly-form-demo-schedule": LocalJSX.IntrinsicElements["smoothly-form-demo-schedule"] & JSXBase.HTMLAttributes<HTMLSmoothlyFormDemoScheduleElement>;
            "smoothly-form-demo-transparent": LocalJSX.IntrinsicElements["smoothly-form-demo-transparent"] & JSXBase.HTMLAttributes<HTMLSmoothlyFormDemoTransparentElement>;
            "smoothly-form-demo-typed": LocalJSX.IntrinsicElements["smoothly-form-demo-typed"] & JSXBase.HTMLAttributes<HTMLSmoothlyFormDemoTypedElement>;
            "smoothly-frame": LocalJSX.IntrinsicElements["smoothly-frame"] & JSXBase.HTMLAttributes<HTMLSmoothlyFrameElement>;
            "smoothly-icon": LocalJSX.IntrinsicElements["smoothly-icon"] & JSXBase.HTMLAttributes<HTMLSmoothlyIconElement>;
            "smoothly-icon-demo": LocalJSX.IntrinsicElements["smoothly-icon-demo"] & JSXBase.HTMLAttributes<HTMLSmoothlyIconDemoElement>;
            "smoothly-input": LocalJSX.IntrinsicElements["smoothly-input"] & JSXBase.HTMLAttributes<HTMLSmoothlyInputElement>;
            "smoothly-input-checkbox": LocalJSX.IntrinsicElements["smoothly-input-checkbox"] & JSXBase.HTMLAttributes<HTMLSmoothlyInputCheckboxElement>;
            "smoothly-input-checkbox-demo": LocalJSX.IntrinsicElements["smoothly-input-checkbox-demo"] & JSXBase.HTMLAttributes<HTMLSmoothlyInputCheckboxDemoElement>;
            "smoothly-input-clear": LocalJSX.IntrinsicElements["smoothly-input-clear"] & JSXBase.HTMLAttributes<HTMLSmoothlyInputClearElement>;
            "smoothly-input-color": LocalJSX.IntrinsicElements["smoothly-input-color"] & JSXBase.HTMLAttributes<HTMLSmoothlyInputColorElement>;
            "smoothly-input-color-demo": LocalJSX.IntrinsicElements["smoothly-input-color-demo"] & JSXBase.HTMLAttributes<HTMLSmoothlyInputColorDemoElement>;
            "smoothly-input-date": LocalJSX.IntrinsicElements["smoothly-input-date"] & JSXBase.HTMLAttributes<HTMLSmoothlyInputDateElement>;
            "smoothly-input-date-demo": LocalJSX.IntrinsicElements["smoothly-input-date-demo"] & JSXBase.HTMLAttributes<HTMLSmoothlyInputDateDemoElement>;
            "smoothly-input-date-range": LocalJSX.IntrinsicElements["smoothly-input-date-range"] & JSXBase.HTMLAttributes<HTMLSmoothlyInputDateRangeElement>;
            "smoothly-input-date-time": LocalJSX.IntrinsicElements["smoothly-input-date-time"] & JSXBase.HTMLAttributes<HTMLSmoothlyInputDateTimeElement>;
            "smoothly-input-demo": LocalJSX.IntrinsicElements["smoothly-input-demo"] & JSXBase.HTMLAttributes<HTMLSmoothlyInputDemoElement>;
            "smoothly-input-demo-radio": LocalJSX.IntrinsicElements["smoothly-input-demo-radio"] & JSXBase.HTMLAttributes<HTMLSmoothlyInputDemoRadioElement>;
            "smoothly-input-demo-standard": LocalJSX.IntrinsicElements["smoothly-input-demo-standard"] & JSXBase.HTMLAttributes<HTMLSmoothlyInputDemoStandardElement>;
            "smoothly-input-demo-user-input": LocalJSX.IntrinsicElements["smoothly-input-demo-user-input"] & JSXBase.HTMLAttributes<HTMLSmoothlyInputDemoUserInputElement>;
            "smoothly-input-edit": LocalJSX.IntrinsicElements["smoothly-input-edit"] & JSXBase.HTMLAttributes<HTMLSmoothlyInputEditElement>;
            "smoothly-input-file": LocalJSX.IntrinsicElements["smoothly-input-file"] & JSXBase.HTMLAttributes<HTMLSmoothlyInputFileElement>;
            "smoothly-input-month": LocalJSX.IntrinsicElements["smoothly-input-month"] & JSXBase.HTMLAttributes<HTMLSmoothlyInputMonthElement>;
            "smoothly-input-price-demo": LocalJSX.IntrinsicElements["smoothly-input-price-demo"] & JSXBase.HTMLAttributes<HTMLSmoothlyInputPriceDemoElement>;
            "smoothly-input-radio": LocalJSX.IntrinsicElements["smoothly-input-radio"] & JSXBase.HTMLAttributes<HTMLSmoothlyInputRadioElement>;
            "smoothly-input-radio-item": LocalJSX.IntrinsicElements["smoothly-input-radio-item"] & JSXBase.HTMLAttributes<HTMLSmoothlyInputRadioItemElement>;
            "smoothly-input-range": LocalJSX.IntrinsicElements["smoothly-input-range"] & JSXBase.HTMLAttributes<HTMLSmoothlyInputRangeElement>;
            "smoothly-input-range-demo": LocalJSX.IntrinsicElements["smoothly-input-range-demo"] & JSXBase.HTMLAttributes<HTMLSmoothlyInputRangeDemoElement>;
            "smoothly-input-reset": LocalJSX.IntrinsicElements["smoothly-input-reset"] & JSXBase.HTMLAttributes<HTMLSmoothlyInputResetElement>;
            "smoothly-input-select": LocalJSX.IntrinsicElements["smoothly-input-select"] & JSXBase.HTMLAttributes<HTMLSmoothlyInputSelectElement>;
            "smoothly-input-submit": LocalJSX.IntrinsicElements["smoothly-input-submit"] & JSXBase.HTMLAttributes<HTMLSmoothlyInputSubmitElement>;
            "smoothly-item": LocalJSX.IntrinsicElements["smoothly-item"] & JSXBase.HTMLAttributes<HTMLSmoothlyItemElement>;
            "smoothly-label": LocalJSX.IntrinsicElements["smoothly-label"] & JSXBase.HTMLAttributes<HTMLSmoothlyLabelElement>;
            "smoothly-lazy": LocalJSX.IntrinsicElements["smoothly-lazy"] & JSXBase.HTMLAttributes<HTMLSmoothlyLazyElement>;
            "smoothly-load-more": LocalJSX.IntrinsicElements["smoothly-load-more"] & JSXBase.HTMLAttributes<HTMLSmoothlyLoadMoreElement>;
            "smoothly-modal": LocalJSX.IntrinsicElements["smoothly-modal"] & JSXBase.HTMLAttributes<HTMLSmoothlyModalElement>;
            "smoothly-notification": LocalJSX.IntrinsicElements["smoothly-notification"] & JSXBase.HTMLAttributes<HTMLSmoothlyNotificationElement>;
            "smoothly-notifier": LocalJSX.IntrinsicElements["smoothly-notifier"] & JSXBase.HTMLAttributes<HTMLSmoothlyNotifierElement>;
            "smoothly-notifier-demo": LocalJSX.IntrinsicElements["smoothly-notifier-demo"] & JSXBase.HTMLAttributes<HTMLSmoothlyNotifierDemoElement>;
            "smoothly-spinner": LocalJSX.IntrinsicElements["smoothly-spinner"] & JSXBase.HTMLAttributes<HTMLSmoothlySpinnerElement>;
            "smoothly-submit": LocalJSX.IntrinsicElements["smoothly-submit"] & JSXBase.HTMLAttributes<HTMLSmoothlySubmitElement>;
            "smoothly-summary": LocalJSX.IntrinsicElements["smoothly-summary"] & JSXBase.HTMLAttributes<HTMLSmoothlySummaryElement>;
            "smoothly-tab": LocalJSX.IntrinsicElements["smoothly-tab"] & JSXBase.HTMLAttributes<HTMLSmoothlyTabElement>;
            "smoothly-table": LocalJSX.IntrinsicElements["smoothly-table"] & JSXBase.HTMLAttributes<HTMLSmoothlyTableElement>;
            "smoothly-table-body": LocalJSX.IntrinsicElements["smoothly-table-body"] & JSXBase.HTMLAttributes<HTMLSmoothlyTableBodyElement>;
            "smoothly-table-cell": LocalJSX.IntrinsicElements["smoothly-table-cell"] & JSXBase.HTMLAttributes<HTMLSmoothlyTableCellElement>;
            "smoothly-table-demo": LocalJSX.IntrinsicElements["smoothly-table-demo"] & JSXBase.HTMLAttributes<HTMLSmoothlyTableDemoElement>;
            "smoothly-table-demo-colspan": LocalJSX.IntrinsicElements["smoothly-table-demo-colspan"] & JSXBase.HTMLAttributes<HTMLSmoothlyTableDemoColspanElement>;
            "smoothly-table-demo-filler-row": LocalJSX.IntrinsicElements["smoothly-table-demo-filler-row"] & JSXBase.HTMLAttributes<HTMLSmoothlyTableDemoFillerRowElement>;
            "smoothly-table-demo-group": LocalJSX.IntrinsicElements["smoothly-table-demo-group"] & JSXBase.HTMLAttributes<HTMLSmoothlyTableDemoGroupElement>;
            "smoothly-table-demo-nested-no-cell": LocalJSX.IntrinsicElements["smoothly-table-demo-nested-no-cell"] & JSXBase.HTMLAttributes<HTMLSmoothlyTableDemoNestedNoCellElement>;
            "smoothly-table-demo-nested-no-cell-inner": LocalJSX.IntrinsicElements["smoothly-table-demo-nested-no-cell-inner"] & JSXBase.HTMLAttributes<HTMLSmoothlyTableDemoNestedNoCellInnerElement>;
            "smoothly-table-demo-simple": LocalJSX.IntrinsicElements["smoothly-table-demo-simple"] & JSXBase.HTMLAttributes<HTMLSmoothlyTableDemoSimpleElement>;
            "smoothly-table-expandable-cell": LocalJSX.IntrinsicElements["smoothly-table-expandable-cell"] & JSXBase.HTMLAttributes<HTMLSmoothlyTableExpandableCellElement>;
            "smoothly-table-expandable-row": LocalJSX.IntrinsicElements["smoothly-table-expandable-row"] & JSXBase.HTMLAttributes<HTMLSmoothlyTableExpandableRowElement>;
            "smoothly-table-filler-row": LocalJSX.IntrinsicElements["smoothly-table-filler-row"] & JSXBase.HTMLAttributes<HTMLSmoothlyTableFillerRowElement>;
            "smoothly-table-foot": LocalJSX.IntrinsicElements["smoothly-table-foot"] & JSXBase.HTMLAttributes<HTMLSmoothlyTableFootElement>;
            "smoothly-table-head": LocalJSX.IntrinsicElements["smoothly-table-head"] & JSXBase.HTMLAttributes<HTMLSmoothlyTableHeadElement>;
            "smoothly-table-row": LocalJSX.IntrinsicElements["smoothly-table-row"] & JSXBase.HTMLAttributes<HTMLSmoothlyTableRowElement>;
            "smoothly-table-row-group": LocalJSX.IntrinsicElements["smoothly-table-row-group"] & JSXBase.HTMLAttributes<HTMLSmoothlyTableRowGroupElement>;
            "smoothly-tabs": LocalJSX.IntrinsicElements["smoothly-tabs"] & JSXBase.HTMLAttributes<HTMLSmoothlyTabsElement>;
            "smoothly-tabs-demo": LocalJSX.IntrinsicElements["smoothly-tabs-demo"] & JSXBase.HTMLAttributes<HTMLSmoothlyTabsDemoElement>;
            "smoothly-theme-color": LocalJSX.IntrinsicElements["smoothly-theme-color"] & JSXBase.HTMLAttributes<HTMLSmoothlyThemeColorElement>;
            "smoothly-theme-color-variant": LocalJSX.IntrinsicElements["smoothly-theme-color-variant"] & JSXBase.HTMLAttributes<HTMLSmoothlyThemeColorVariantElement>;
            "smoothly-theme-colors": LocalJSX.IntrinsicElements["smoothly-theme-colors"] & JSXBase.HTMLAttributes<HTMLSmoothlyThemeColorsElement>;
            "smoothly-theme-demo": LocalJSX.IntrinsicElements["smoothly-theme-demo"] & JSXBase.HTMLAttributes<HTMLSmoothlyThemeDemoElement>;
            "smoothly-theme-guide": LocalJSX.IntrinsicElements["smoothly-theme-guide"] & JSXBase.HTMLAttributes<HTMLSmoothlyThemeGuideElement>;
            "smoothly-theme-picker": LocalJSX.IntrinsicElements["smoothly-theme-picker"] & JSXBase.HTMLAttributes<HTMLSmoothlyThemePickerElement>;
            "smoothly-toggle-switch": LocalJSX.IntrinsicElements["smoothly-toggle-switch"] & JSXBase.HTMLAttributes<HTMLSmoothlyToggleSwitchElement>;
            "smoothly-toggle-switch-demo": LocalJSX.IntrinsicElements["smoothly-toggle-switch-demo"] & JSXBase.HTMLAttributes<HTMLSmoothlyToggleSwitchDemoElement>;
            "smoothly-trigger": LocalJSX.IntrinsicElements["smoothly-trigger"] & JSXBase.HTMLAttributes<HTMLSmoothlyTriggerElement>;
            "smoothly-trigger-sink": LocalJSX.IntrinsicElements["smoothly-trigger-sink"] & JSXBase.HTMLAttributes<HTMLSmoothlyTriggerSinkElement>;
            "smoothly-trigger-source": LocalJSX.IntrinsicElements["smoothly-trigger-source"] & JSXBase.HTMLAttributes<HTMLSmoothlyTriggerSourceElement>;
        }
    }
}