smoothly 1.0.0-alpha.99 → 1.0.0

package/dist/types/components/input/color/index.d.ts

@@ -0,0 +1,24 @@
+import { ComponentWillLoad, EventEmitter, VNode } from "../../../stencil-public-runtime";
+import { SmoothlyInputCustomEvent } from "../../../components";
+import { Color } from "../../../model";
+import { Clearable } from "../Clearable";
+import { SmoothlyInput } from "../index";
+import { Input } from "../Input";
+import { Looks } from "../Looks";
+export declare class SmoothlyInputColor implements Input, Clearable, ComponentWillLoad {
+  element: HTMLElement;
+  value: string | undefined;
+  looks: Looks;
+  name: string;
+  smoothlyInputLooks: EventEmitter<(looks: Looks, color: Color) => void>;
+  smoothlyInput: EventEmitter<Record<string, any>>;
+  smoothlyInputLoad: EventEmitter<(parent: HTMLElement) => void>;
+  componentWillLoad(): void | Promise<void>;
+  smoothlyInputHandler(event: CustomEvent<Record<string, any>>): void;
+  smoothlyInputLooksHandler(event: CustomEvent<(looks: Looks) => void>): void;
+  smoothlyInputLoadHandler(event: CustomEvent<(parent: SmoothlyInput) => void>): void;
+  clear(): Promise<void>;
+  valueChanged(): void;
+  inputHandler(event: SmoothlyInputCustomEvent<Record<string, any>>): void;
+  render(): VNode | VNode[];
+}

package/dist/types/components/input/date/index.d.ts

@@ -15,7 +15,7 @@ export declare class InputDate implements Clearable, Input {
   min: Date;
   showLabel: boolean;
   disabled: boolean;
-  valueChanged: EventEmitter<Date>;
+  smoothlyValueChange: EventEmitter<Date>;
   smoothlyInput: EventEmitter<Record<string, any>>;
   smoothlyInputLooks: EventEmitter<(looks: Looks, color: Color) => void>;
   componentWillLoad(): void;

package/dist/types/components/input/date/range/index.d.ts

@@ -18,7 +18,7 @@ export declare class InputDateRange implements Clearable, Input {
   showLabel: boolean;
   labelStart: string;
   labelEnd: string;
-  valueChanged: EventEmitter<isoly.Date>;
+  smoothlyValueChange: EventEmitter<isoly.Date>;
   smoothlyInput: EventEmitter<Data>;
   smoothlyInputLooks: EventEmitter<(looks: Looks, color: Color) => void>;
   clear(): Promise<void>;
@@ -29,5 +29,5 @@ export declare class InputDateRange implements Clearable, Input {
   onStartChanged(event: CustomEvent<isoly.Date>): void;
   onEndChanged(event: CustomEvent<isoly.Date>): void;
   onDateRangeSet(event: CustomEvent<isoly.DateRange>): void;
-  render(): any[];
+  render(): any;
 }

package/dist/types/components/input/demo/index.d.ts

@@ -1,8 +1,5 @@
+import { isoly } from "isoly";
 export declare class SmoothlyInputDemo {
-  private selectElement;
-  handleSelectionChanged(event: CustomEvent<{
-    identifier: string;
-    value: string;
-  }>): void;
-  render(): any[];
+  duration: isoly.TimeSpan;
+  render(): any;
 }

package/dist/types/components/input/edit/index.d.ts

@@ -0,0 +1,18 @@
+import { ComponentWillLoad, EventEmitter, VNode } from "../../../stencil-public-runtime";
+import { Color, Fill } from "../../../model";
+export declare class SmoothlyInputEdit implements ComponentWillLoad {
+  private parent?;
+  color?: Color;
+  expand?: "block" | "full";
+  fill?: Fill;
+  disabled: boolean;
+  display: boolean;
+  shape?: "rounded";
+  type: "link" | "button";
+  size: "flexible" | "small" | "large" | "icon";
+  toolTip: string;
+  smoothlyInputLoad: EventEmitter<(parent: HTMLElement) => void>;
+  componentWillLoad(): void;
+  clickHandler(): void;
+  render(): VNode | VNode[];
+}

package/dist/types/components/input/index.d.ts

@@ -1,54 +1,62 @@
 import { EventEmitter } from "../../stencil-public-runtime";
-import { Currency } from "isoly";
-import { Converter, Direction, Formatter, Settings, State as TidilyState } from "tidily";
+import { isoly } from "isoly";
+import { tidily } from "tidily";
 import { Color } from "../../model";
-import { Changeable } from "./Changeable";
 import { Clearable } from "./Clearable";
+import { Editable } from "./Editable";
 import { Input } from "./Input";
 import { Looks } from "./Looks";
-export declare class SmoothlyInput implements Changeable, Clearable, Input {
-  private inputElement;
-  private keepFocusOnReRender;
-  private lastValue;
-  private state;
+export declare class SmoothlyInput implements Clearable, Input, Editable {
   color?: Color;
+  delay: number;
   looks: Looks;
   name: string;
   value: any;
-  type: string;
+  type: tidily.Type;
   required: boolean;
-  minLength: number;
   showLabel: boolean;
-  maxLength: number;
   autocomplete: boolean;
-  pattern: RegExp | undefined;
   placeholder: string | undefined;
   disabled: boolean;
   readonly: boolean;
-  currency?: Currency;
-  initialValue?: any;
-  smoothlyInputLooks: EventEmitter<(looks: Looks, color: Color) => void>;
+  currency?: isoly.Currency;
   changed: boolean;
+  formatter: tidily.Formatter & tidily.Converter<any>;
+  initialValue?: any;
+  private inputElement;
+  private keepFocusOnReRender;
+  private lastValue;
+  private state;
+  private abortInputEvent?;
+  private uneditable;
   private listener;
-  listen(property: "changed", listener: (parent: Changeable) => Promise<void>): void;
-  SmoothlyInputLoadHandler(event: CustomEvent<(parent: SmoothlyInput) => void>): Promise<void>;
-  get formatter(): Formatter & Converter<any>;
-  private newState;
+  smoothlyInputLooks: EventEmitter<(looks: Looks, color: Color) => void>;
+  smoothlyInputLoad: EventEmitter<(parent: HTMLElement) => void>;
+  smoothlyFormDisable: EventEmitter<(disabled: boolean) => void>;
   smoothlyBlur: EventEmitter<void>;
   smoothlyChange: EventEmitter<Record<string, any>>;
   smoothlyInput: EventEmitter<Record<string, any>>;
+  listen(property: "changed", listener: (parent: Editable) => Promise<void>): Promise<void>;
+  SmoothlyInputLoadHandler(event: CustomEvent<(parent: SmoothlyInput) => void>): Promise<void>;
+  typeChange(): void;
+  private newState;
   valueWatcher(value: any, before: any): void;
+  smoothlyInputEmit(value: any): Promise<void>;
+  watchingReadonly(): void;
   onCurrency(): void;
   componentWillLoad(): void;
   componentDidRender(): void;
   clear(): Promise<void>;
+  edit(editable: boolean): Promise<void>;
+  reset(): Promise<void>;
+  setInitialValue(): Promise<void>;
   getFormData(name: string): Promise<Record<string, any>>;
   hasNameAndValue(element: any): element is {
     name: string;
     value: string;
   };
   setKeepFocusOnReRender(keepFocus: boolean): Promise<void>;
-  setSelectionRange(start: number, end: number, direction?: Direction): Promise<void>;
+  setSelectionRange(start: number, end: number, direction?: tidily.Direction): Promise<void>;
   onBlur(event: FocusEvent): void;
   onFocus(event: FocusEvent): void;
   onClick(event: MouseEvent): void;
@@ -56,7 +64,8 @@ export declare class SmoothlyInput implements Changeable, Clearable, Input {
   onPaste(event: ClipboardEvent): void;
   onInput(event: InputEvent): void;
   private expiresAutocompleteFix;
+  private processPaste;
   private processKey;
-  updateBackend(after: Readonly<TidilyState> & Readonly<Settings>, backend: HTMLInputElement): void;
+  updateBackend(after: Readonly<tidily.State> & Readonly<tidily.Settings>, backend: HTMLInputElement, setSelection?: boolean): void;
   render(): any;
 }

package/dist/types/components/input/month/index.d.ts

@@ -2,7 +2,7 @@ import { EventEmitter } from "../../../stencil-public-runtime";
 import { Date } from "isoly";
 export declare class MonthSelector {
   value?: Date;
-  valueChanged: EventEmitter<Date>;
+  smoothlyValueChange: EventEmitter<Date>;
   onValueChanged(next: Date): void;
   private adjustMonth;
   render(): any[];

package/dist/types/components/input/radio/Selected.d.ts

@@ -0,0 +1,10 @@
+import { isly } from "isly";
+export interface Selectable {
+  value: any;
+  selected: boolean;
+  select: (selected: boolean) => void;
+}
+export declare namespace Selected {
+  const type: isly.object.ExtendableType<Selectable>;
+  const is: isly.Type.IsFunction<Selectable>;
+}

package/dist/types/components/input/radio/index.d.ts

@@ -0,0 +1,36 @@
+import { ComponentWillLoad, EventEmitter, VNode } from "../../../stencil-public-runtime";
+import { Color, Data } from "../../../model";
+import { Clearable } from "../Clearable";
+import { Editable } from "../Editable";
+import { Input } from "../Input";
+import { Looks } from "../Looks";
+import { Selectable } from "./Selected";
+export declare class SmoothlyInputRadio implements Input, Clearable, Editable, ComponentWillLoad {
+  private active?;
+  private valueReceivedOnLoad;
+  private listener;
+  initialValue?: Selectable;
+  changed: boolean;
+  value: any;
+  looks: Looks;
+  clearable?: boolean;
+  readonly: boolean;
+  name: string;
+  smoothlyInputLooks: EventEmitter<(looks: Looks, color: Color) => void>;
+  smoothlyInput: EventEmitter<Data>;
+  smoothlyInputLoad: EventEmitter<(parent: HTMLElement) => void>;
+  smoothlyFormDisable: EventEmitter<(disabled: boolean) => void>;
+  componentWillLoad(): void | Promise<void>;
+  componentDidLoad(): void | Promise<void>;
+  handleRegister(event: CustomEvent<(name: string) => void>): void;
+  SmoothlyInputLoadHandler(event: CustomEvent<(parent: SmoothlyInputRadio) => void>): void;
+  smoothlyRadioInputHandler(event: CustomEvent<Selectable>): void;
+  listen(property: "changed", listener: (parent: Editable) => Promise<void>): Promise<void>;
+  clear(): Promise<void>;
+  edit(editable: boolean): Promise<void>;
+  reset(): Promise<void>;
+  setInitialValue(): Promise<void>;
+  valueChanged(): void;
+  watchingReadonly(): void;
+  render(): VNode | VNode[];
+}

package/dist/types/components/input/radio/item/index.d.ts

@@ -0,0 +1,15 @@
+import { EventEmitter, VNode } from "../../../../stencil-public-runtime";
+import { Looks } from "../../Looks";
+import { Selectable } from "../Selected";
+export declare class SmoothlyInputRadioItem {
+  element: HTMLInputElement;
+  value: any;
+  selected: boolean;
+  looks: Looks;
+  name: string;
+  smoothlySelect: EventEmitter<Selectable>;
+  smoothlyRadioButtonRegister: EventEmitter<(name: string) => void>;
+  componentWillLoad(): void | Promise<void>;
+  inputHandler(): void;
+  render(): VNode | VNode[];
+}

package/dist/types/components/input/range/index.d.ts

@@ -0,0 +1,33 @@
+import { ComponentWillLoad, EventEmitter, VNode } from "../../../stencil-public-runtime";
+import { Color } from "../../../model";
+import { Clearable } from "../Clearable";
+import { Editable } from "../Editable";
+import { Input } from "../Input";
+import { Looks } from "../Looks";
+export declare class SmoothlyInputRange implements Input, Clearable, Editable, ComponentWillLoad {
+  private listener;
+  value: number | undefined;
+  private initialValue;
+  looks: Looks;
+  changed: boolean;
+  readonly: boolean;
+  min: number;
+  max: number;
+  name: string;
+  labelText?: string;
+  step: number | "any";
+  outputSide: "right" | "left";
+  smoothlyInputLooks: EventEmitter<(looks: Looks, color: Color) => void>;
+  smoothlyInput: EventEmitter<Record<string, any>>;
+  smoothlyInputLoad: EventEmitter<(parent: HTMLElement) => void>;
+  smoothlyFormDisable: EventEmitter<(disabled: boolean) => void>;
+  componentWillLoad(): void | Promise<void>;
+  clear(): Promise<void>;
+  listen(property: "changed", listener: (parent: Editable) => Promise<void>): Promise<void>;
+  edit(editable: boolean): Promise<void>;
+  reset(): Promise<void>;
+  setInitialValue(): Promise<void>;
+  valueChanged(): void;
+  inputHandler(event: Event): void;
+  render(): VNode | VNode[];
+}

package/dist/types/components/input/reset/index.d.ts

@@ -0,0 +1,19 @@
+import { EventEmitter } from "../../../stencil-public-runtime";
+import { Color, Fill } from "../../../model";
+export declare class SmoothlyInputReset {
+  readonlyAtLoad: boolean;
+  color?: Color;
+  expand?: "block" | "full";
+  fill?: Fill;
+  disabled: boolean;
+  size: "small" | "large" | "icon" | "flexible";
+  shape?: "rounded";
+  display: boolean;
+  type: "form" | "input";
+  tooltip: string;
+  private parent?;
+  smoothlyInputLoad: EventEmitter<(parent: HTMLElement) => void>;
+  componentWillLoad(): Promise<void>;
+  clickHandler(event: MouseEvent): void;
+  render(): any;
+}

package/dist/types/components/input/select/index.d.ts

@@ -1,32 +1,55 @@
-import { EventEmitter } from "../../../stencil-public-runtime";
-import { Color } from "../../../model";
+import { ComponentWillLoad, EventEmitter, VNode } from "../../../stencil-public-runtime";
+import { Color, Data } from "../../../model";
+import { Clearable } from "../Clearable";
+import { Editable } from "../Editable";
 import { Input } from "../Input";
 import { Looks } from "../Looks";
-export declare class SmoothlyInputSelect implements Input {
+export declare class SmoothlyInputSelect implements Input, Editable, Clearable, ComponentWillLoad {
+  private initialValue;
+  private initialValueHandled;
+  private listener;
+  items: HTMLSmoothlyItemElement[];
+  itemHeight: number | undefined;
+  displaySelectedElement?: HTMLElement;
   element: HTMLSmoothlyInputSelectElement;
   name: string;
   color?: Color;
   looks: Looks;
-  initialPrompt?: string;
-  opened: boolean;
-  items: HTMLSmoothlyItemElement[];
-  selectedElement?: HTMLSmoothlyItemElement;
-  missing: boolean;
-  mainElement?: HTMLElement;
+  showSelected?: boolean;
+  readonly: boolean;
+  multiple: boolean;
+  clearable: boolean;
+  changed: boolean;
+  placeholder?: string | any;
+  menuHeight?: `${number}${"items" | "rem" | "px" | "vh"}`;
+  open: boolean;
+  selected: HTMLSmoothlyItemElement[];
   filter: string;
-  selected: EventEmitter<any>;
-  smoothlyInput: EventEmitter<Record<number, any>>;
-  aside?: HTMLElement;
+  smoothlySelect: EventEmitter<unknown>;
+  smoothlyInput: EventEmitter<Data>;
   smoothlyInputLooks: EventEmitter<(looks: Looks, color: Color) => void>;
-  componentWillLoad(): void;
+  smoothlyInputLoad: EventEmitter<(parent: HTMLElement) => void>;
+  smoothlyFormDisable: EventEmitter<(disabled: boolean) => void>;
+  smoothlyItemSelect: EventEmitter<HTMLSmoothlyItemElement>;
+  componentWillLoad(): void | Promise<void>;
+  componentDidLoad(): void | Promise<void>;
+  componentDidRender(): void | Promise<void>;
+  listen(property: "changed", listener: (parent: Editable) => Promise<void>): Promise<void>;
   reset(): Promise<void>;
-  onSelectedChange(value: HTMLSmoothlyItemElement | undefined, old: HTMLSmoothlyItemElement | undefined): void;
+  clear(): Promise<void>;
+  edit(editable: boolean): Promise<void>;
+  setInitialValue(): Promise<void>;
+  onSelectedChange(): void;
   onFilterChange(value: string): Promise<void>;
-  onClick(event: UIEvent): void;
-  onItemSelected(event: Event): void;
+  watchingReadonly(): void;
+  smoothlyInputLoadHandler(event: CustomEvent<(parent: SmoothlyInputSelect) => void>): Promise<void>;
+  onWindowClick(event: Event): void;
+  onItemSelect(event: CustomEvent<HTMLSmoothlyItemElement>): void;
   onClosed(): void;
+  handleShowOptions(event?: Event): void;
+  areValuesEqual(selected: HTMLSmoothlyItemElement[], initialValue: HTMLSmoothlyItemElement[]): boolean;
+  displaySelected(): void;
   onKeyDown(event: KeyboardEvent): void;
   private move;
-  render(): any;
-  componentDidRender(): void;
+  render(): VNode | VNode[];
 }

package/dist/types/components/input/submit/index.d.ts

@@ -0,0 +1,19 @@
+import { ComponentWillLoad, EventEmitter, VNode } from "../../../stencil-public-runtime";
+import { Color, Fill } from "../../../model";
+export declare class SmoothlyInputSubmit implements ComponentWillLoad {
+  private parent?;
+  delete: boolean;
+  color?: Color;
+  expand?: "block" | "full";
+  fill?: Fill;
+  disabled: boolean;
+  display: boolean;
+  shape?: "rounded";
+  type: "link" | "button";
+  size: "flexible" | "small" | "large" | "icon";
+  toolTip: string;
+  smoothlyInputLoad: EventEmitter<(parent: HTMLElement) => void>;
+  componentWillLoad(): void;
+  clickHandler(): void;
+  render(): VNode | VNode[];
+}

package/dist/types/components/item/Item.d.ts

@@ -0,0 +1,10 @@
+import { isly } from "isly";
+export interface Item {
+  value: any;
+  selected?: boolean;
+  filter: (filter: string) => Promise<void>;
+}
+export declare namespace Item {
+  const type: isly.object.ExtendableType<Item>;
+  const is: isly.Type.IsFunction<Item>;
+}

package/dist/types/components/item/index.d.ts

@@ -1,13 +1,16 @@
-import { EventEmitter } from "../../stencil-public-runtime";
-export declare class Item {
+import { ComponentDidLoad, ComponentWillLoad, EventEmitter } from "../../stencil-public-runtime";
+import { Item } from "./Item";
+export declare class SmoothlyItem implements Item, ComponentWillLoad, ComponentDidLoad {
   element: HTMLSmoothlyItemElement;
   value: any;
   selected: boolean;
   marked: boolean;
-  itemSelected: EventEmitter<void>;
-  onSelectedChanged(value: boolean, old: boolean): void;
+  selectable: boolean;
+  smoothlyItemSelect: EventEmitter<HTMLSmoothlyItemElement>;
+  smoothlyInputLoad: EventEmitter<(parent: HTMLElement) => void>;
   onClick(): void;
+  componentWillLoad(): void;
   componentDidLoad(): void;
-  filter(filter: string): Promise<boolean>;
+  filter(filter: string): Promise<void>;
   render(): any;
 }

package/dist/types/components/label/index.d.ts

@@ -0,0 +1,6 @@
+export declare class SmoothlyLabel {
+  hue: number;
+  description: string;
+  shape: "rectangle" | "rounded";
+  render(): any;
+}

package/dist/types/components/lazy/index.d.ts

@@ -0,0 +1,7 @@
+import { FunctionalComponent, JSX, VNode } from "../../stencil-public-runtime";
+export declare class SmoothlyLazy {
+  show: boolean;
+  content?: JSX.Element | FunctionalComponent;
+  loadMoreHandler(event: CustomEvent<string>): void;
+  render(): VNode | VNode[];
+}

package/dist/types/components/load-more/index.d.ts

@@ -0,0 +1,11 @@
+import { ComponentWillLoad, EventEmitter, VNode } from "../../stencil-public-runtime";
+export declare class LoadMore implements ComponentWillLoad {
+  element: HTMLSmoothlyLoadMoreElement;
+  offset: string;
+  name: string;
+  multiple: boolean;
+  smoothlyLoadMore: EventEmitter<string>;
+  componentWillLoad(): void;
+  observationHandler(observer: IntersectionObserver, entries: IntersectionObserverEntry[]): void;
+  render(): VNode | VNode[];
+}

package/dist/types/components/picker/demo/index.d.ts

@@ -3,10 +3,15 @@ import { Controls } from "../menu";
 export declare class SmoothlyPickerDemo {
   private controls?;
   private users;
+  counter: number;
   data: {
     message: string;
-    emails: string[];
-    options: string[];
+    emails: {
+      value: string;
+    }[];
+    options: {
+      value: string;
+    }[];
   };
   change?: SmoothlyPickerDemo["data"];
   inputHandler(event: CustomEvent<Data>): void;

package/dist/types/components/picker/index.d.ts

@@ -1,13 +1,18 @@
-import { EventEmitter } from "../../stencil-public-runtime";
+import { ComponentDidLoad, EventEmitter, VNode } from "../../stencil-public-runtime";
 import { Notice, Option } from "../../model";
 import { Clearable } from "../input/Clearable";
+import { Editable } from "../input/Editable";
 import { Input } from "../input/Input";
 import { Looks } from "../input/Looks";
 import { Controls } from "./menu";
-export declare class SmoothlyPicker implements Clearable, Input {
+export declare class SmoothlyPicker implements Clearable, Editable, Input, ComponentDidLoad {
+  private valueRecivedOnLoad;
+  private initialValue;
+  private listener;
   element: HTMLSmoothlyPickerElement;
   looks: Looks;
   name: string;
+  changed: boolean;
   open: boolean;
   mutable: boolean;
   multiple: boolean;
@@ -22,16 +27,25 @@ export declare class SmoothlyPicker implements Clearable, Input {
   smoothlyInput: EventEmitter<Record<string, any | any[]>>;
   smoothlyChange: EventEmitter<Record<string, any | any[]>>;
   smoothlyInputLooks: EventEmitter<(looks: Looks) => void>;
+  smoothlyFormDisable: EventEmitter<(disabled: boolean) => void>;
+  smoothlyInputLoad: EventEmitter<(parent: HTMLElement) => void>;
   private controls?;
-  componentWillLoad(): void;
+  componentWillLoad(): void | Promise<void>;
   selectedChanged(): void;
-  componentDidLoad(): void;
+  componentDidLoad(): void | Promise<void>;
   smoothlyInputLooksHandler(event: CustomEvent<(looks: Looks) => void>): void;
-  menuLoadedHandler(event: CustomEvent<Controls>): void;
+  menuLoadedHandler(event: CustomEvent<Controls & {
+    synced: () => boolean;
+  }>): void;
   optionLoadedHandler(event: CustomEvent<Option>): void;
   optionChangeHandler(event: CustomEvent<Option>): void;
   clickHandler(event: MouseEvent): void;
   focusHandler(event: FocusEvent): void;
   clear(): Promise<void>;
-  render(): any;
+  listen(property: "changed", listener: (parent: Editable) => Promise<void>): Promise<void>;
+  edit(editable: boolean): Promise<void>;
+  reset(): Promise<void>;
+  setInitialValue(): Promise<void>;
+  areValuesEqual(selected: Map<any, Option>, initialValue: Map<any, Option>): boolean;
+  render(): VNode | VNode[];
 }

package/dist/types/components/picker/menu/index.d.ts

@@ -5,10 +5,12 @@ import { Slot } from "../slot-elements";
 export interface Controls {
   remember: () => void;
   restore: () => void;
+  clear: () => void;
 }
 export declare class SmoothlyPickerMenu {
   element: HTMLSmoothlyPickerMenuElement;
   looks: Looks;
+  open: boolean;
   multiple: boolean;
   mutable: boolean;
   readonly: boolean;
@@ -24,13 +26,19 @@ export declare class SmoothlyPickerMenu {
   search: string;
   valid: boolean;
   display: Node[];
+  flip: boolean;
+  flipChecked: boolean;
   notice: EventEmitter<Notice>;
   smoothlyPickerMenuLoaded: EventEmitter<Controls>;
   private memory?;
   private listElement?;
   private searchElement?;
+  componentWillLoad(): void;
   componentDidLoad(): void;
+  disconnectedCallback(): void;
+  openChange(): void;
   readonlyChanged(): void;
+  scrollHandler(): void;
   optionLoadHandler(event: CustomEvent<Option.Load>): void;
   optionLoadedHandler(event: CustomEvent<Option>): void;
   optionChangeHandler(event: CustomEvent<Option>): void;

package/dist/types/components/picker/option/index.d.ts

@@ -6,6 +6,8 @@ export declare class SmoothlyPickerOption {
   visible: boolean;
   value: any;
   search: string[];
+  position: number;
+  required: boolean;
   readonly: boolean;
   slotted: Node[];
   smoothlyPickerOptionLoad: EventEmitter<Option.Load>;

package/dist/types/components/popup/index.d.ts

@@ -7,7 +7,7 @@ export declare class SmoothlyPopup {
     "--right"?: string;
   };
   popup: EventEmitter<boolean>;
-  private aside;
+  private popupElement;
   private onClick;
   render(): any;
 }

package/dist/types/components/submit/index.d.ts

@@ -9,7 +9,6 @@ export declare class SmoothlySubmit {
   size: "flexible" | "small" | "large" | "icon";
   shape?: "rounded";
   prevent: boolean;
-  smoothlySubmit: EventEmitter;
   private parent?;
   smoothlyInputLoad: EventEmitter<(parent: HTMLElement) => void>;
   componentWillLoad(): Promise<void>;

package/dist/types/components/table/demo/filtered/Root.d.ts

@@ -19,6 +19,8 @@ export interface Cat {
   origin: string;
   coat: string;
   pattern: string;
+  price?: number;
+  nested?: Cat;
 }
 export interface Link {
   url?: string;

package/dist/types/components/table/demo/filtered/index.d.ts

@@ -1,13 +1,13 @@
 import { ComponentWillLoad } from "../../../../stencil-public-runtime";
-import { Criteria } from "selectively";
+import { selectively } from "selectively";
 import { Selector } from "../../Selector";
-import { Cat, Root } from "./Root";
+import { Cat } from "./Root";
 export declare class TableDemoFiltered implements ComponentWillLoad {
-  criteria: Criteria;
-  data?: Root | false;
+  criteria: selectively.Criteria;
+  cats?: Cat[] | false;
   selector: Selector<Cat>;
-  onFilterUpdate(event: CustomEvent<Record<string, Criteria>>): void;
+  onFilterUpdate(event: CustomEvent<selectively.Criteria>): void;
   smoothlyInputHandler(event: CustomEvent<Record<string, any>>): void;
   componentWillLoad(): Promise<void>;
-  render(): any[] | "Failed to load data.";
+  render(): any;
 }

package/dist/types/components/table/demo/index.d.ts

@@ -1,3 +1,3 @@
 export declare class TableDemo {
-  render(): any[];
+  render(): any;
 }

package/dist/types/components/table/expandable/cell/index.d.ts

@@ -5,7 +5,6 @@ export declare class TableExpandableCell implements ComponentWillLoad {
   element: HTMLSmoothlyTableExpandableCellElement;
   allowSpotlight: boolean;
   spotlight: boolean;
-  align: "left" | "center" | "right";
   open: boolean;
   smoothlyExpansionOpen: EventEmitter<HTMLElement>;
   smoothlyExpansionLoad: EventEmitter<void>;