glimpse-sdk 0.3.0 → 0.7.0

package/dist/src/widgets.d.ts

@@ -1,369 +1,528 @@
-import { Icon } from "./protocol.js";
-export type Align = "fill" | "start" | "end" | "center" | "baseline";
-export type Orientation = "horizontal" | "vertical";
-export type Variant = "normal" | "muted" | "accent" | "success" | "warning" | "danger";
-export type ButtonVariant = "primary" | "secondary" | "compact" | "flat" | "danger";
+export type InlineHandler = (event: unknown) => void | Promise<void>;
+export declare class InlineHandlerRegistry {
+    readonly handlers: Map<string, InlineHandler>;
+    add(event: "click" | "toggle" | "change", id: string, handler: InlineHandler): void;
+}
+export type BadgeKind = "default" | "success" | "warning" | "error" | "accent";
+export type StatusDotStatus = "neutral" | "success" | "warning" | "error" | "accent";
 export type PagerAppearance = "dots" | "numbers";
-export type ContentFit = "fill" | "contain" | "cover" | "scale_down";
-export type LevelBarMode = "continuous" | "discrete";
-export interface WidgetNode {
-    toProtocol(): Record<string, unknown>;
+export type PopoverSize = "small" | "medium" | "large" | "wide";
+export interface ProtocolNode {
+    type: string;
+    data: Record<string, unknown>;
 }
-export interface CommonProps {
-    id?: string;
+export interface CommonOptions {
     visible?: boolean;
-    hexpand?: boolean;
-    vexpand?: boolean;
-    halign?: Align;
-    valign?: Align;
     tooltip?: string;
-    variant?: Variant;
-}
-declare abstract class WidgetBase implements WidgetNode {
-    protected readonly common: CommonProps;
-    protected constructor(common?: CommonProps);
-    protected withCommon(payload: Record<string, unknown>): Record<string, unknown>;
-    abstract toProtocol(): Record<string, unknown>;
+    css_classes?: string[];
+    styles?: Record<string, string>;
+}
+export declare abstract class WidgetBase {
+    protected readonly common: CommonOptions;
+    protected constructor(common?: CommonOptions);
+    abstract readonly type: string;
+    abstract data(): Record<string, unknown>;
+    bindHandlers(_registry: InlineHandlerRegistry, _path: number[]): void;
+    toProtocol(): ProtocolNode;
+    protected commonData(): Record<string, unknown>;
 }
 export declare class Label extends WidgetBase {
-    readonly text: string;
+    readonly type = "label";
     private readonly options;
-    constructor(text: string, options?: CommonProps & {
-        wrap?: boolean;
+    constructor(options: string | CommonOptions & {
+        label: string;
         xalign?: number;
-        selectable?: boolean;
-    });
-    toProtocol(): Record<string, unknown>;
-}
-export declare class Image extends WidgetBase {
-    readonly icon: Icon;
-    private readonly options;
-    constructor(icon: Icon, options?: CommonProps & {
-        pixel_size?: number;
-    });
-    toProtocol(): Record<string, unknown>;
-}
-export declare class Progress extends WidgetBase {
-    private readonly options;
-    constructor(options: CommonProps & {
-        value: number;
-        max?: number;
-        show_text?: boolean;
-        text?: string;
+        wrap?: boolean;
     });
-    toProtocol(): Record<string, unknown>;
+    data(): Record<string, unknown>;
 }
-export declare class LevelBar extends WidgetBase {
+export declare class Header extends WidgetBase {
     private readonly options;
-    constructor(options: CommonProps & {
-        value: number;
-        min?: number;
-        max?: number;
-        mode?: LevelBarMode;
+    readonly type = "header";
+    constructor(options: CommonOptions & {
+        label: string;
     });
-    toProtocol(): Record<string, unknown>;
+    data(): Record<string, unknown>;
 }
-export declare class Picture extends WidgetBase {
-    readonly options: CommonProps & {
-        path: string;
-        content_fit?: ContentFit;
-    };
-    constructor(options: CommonProps & {
-        path: string;
-        content_fit?: ContentFit;
-    });
-    toProtocol(): Record<string, unknown>;
-}
-export declare class Button extends WidgetBase {
+export declare class Hero extends WidgetBase {
     private readonly options;
-    constructor(options?: Omit<CommonProps, "variant"> & {
-        label?: string;
+    readonly type = "hero";
+    constructor(options: CommonOptions & {
+        title: string;
+        subtitle?: string;
+        id?: string;
         icon?: string;
-        enabled?: boolean;
-        variant?: ButtonVariant;
-    });
-    toProtocol(): Record<string, unknown>;
-}
-export declare class LinkButton extends WidgetBase {
-    private readonly options;
-    constructor(options: CommonProps & {
-        uri: string;
-        label?: string;
+        icon_size?: number;
+        toggle?: boolean;
+        toggle_sensitive?: boolean;
+        separator?: boolean;
+        trailing?: TreeNode;
+        on_toggle?: InlineHandler;
     });
-    toProtocol(): Record<string, unknown>;
+    data(): Record<string, unknown>;
+    bindHandlers(registry: InlineHandlerRegistry, path: number[]): void;
 }
-export declare class Expander extends WidgetBase {
+export declare class Badge extends WidgetBase {
     private readonly options;
-    constructor(options: CommonProps & {
+    readonly type = "badge";
+    constructor(options: CommonOptions & {
         label: string;
-        child: TreeNode;
-        expanded?: boolean;
+        kind?: BadgeKind;
     });
-    toProtocol(): Record<string, unknown>;
+    data(): Record<string, unknown>;
 }
-export declare class TreeExpander extends WidgetBase {
+export declare class StatusDot extends WidgetBase {
     private readonly options;
-    constructor(options: CommonProps & {
-        child: TreeNode;
-        hide_expander?: boolean;
-        indent_for_depth?: boolean;
-        indent_for_icon?: boolean;
+    readonly type = "status_dot";
+    constructor(options?: CommonOptions & {
+        status?: StatusDotStatus;
     });
-    toProtocol(): Record<string, unknown>;
+    data(): Record<string, unknown>;
 }
-export declare class MenuButton extends WidgetBase {
+export declare class PanelIndicator extends WidgetBase {
     private readonly options;
-    constructor(options: CommonProps & {
-        label?: string;
+    readonly type = "panel_indicator";
+    constructor(options: CommonOptions & {
+        id?: string;
         icon?: string;
-        popover: TreeNode;
-    });
-    toProtocol(): Record<string, unknown>;
-}
-export declare class Switch extends WidgetBase {
-    private readonly options;
-    constructor(options?: CommonProps & {
         label?: string;
         active?: boolean;
+        checked?: boolean;
+        needs_attention?: boolean;
+        extra?: TreeNode;
+        on_click?: InlineHandler;
     });
-    toProtocol(): Record<string, unknown>;
+    data(): Record<string, unknown>;
+    bindHandlers(registry: InlineHandlerRegistry, path: number[]): void;
 }
-export declare class ToggleButton extends WidgetBase {
+export declare class EmptyState extends WidgetBase {
     private readonly options;
-    constructor(options?: CommonProps & {
-        label?: string;
-        active?: boolean;
+    readonly type = "empty_state";
+    constructor(options: CommonOptions & {
+        title: string;
+        subtitle?: string;
     });
-    toProtocol(): Record<string, unknown>;
+    data(): Record<string, unknown>;
 }
-export declare class Slider extends WidgetBase {
+export declare class Spinner extends WidgetBase {
     private readonly options;
-    constructor(options?: CommonProps & {
-        min?: number;
-        max?: number;
-        step?: number;
-        value?: number;
-        orientation?: Orientation;
-        draw_value?: boolean;
+    readonly type = "spinner";
+    constructor(options?: CommonOptions & {
+        spinning?: boolean;
     });
-    toProtocol(): Record<string, unknown>;
+    data(): Record<string, unknown>;
 }
-export declare class Checkbox extends WidgetBase {
+export declare class Meter extends WidgetBase {
     private readonly options;
-    constructor(options?: CommonProps & {
+    readonly type = "meter";
+    constructor(options?: CommonOptions & {
+        id?: string;
+        icon?: string;
         label?: string;
-        active?: boolean;
-    });
-    toProtocol(): Record<string, unknown>;
-}
-export declare class SelectOption {
-    readonly id: string;
-    readonly label: string;
-    constructor(id: string, label: string);
-    toProtocol(): Record<string, unknown>;
-}
-export declare class Select extends WidgetBase {
-    private readonly options;
-    constructor(options?: CommonProps & {
-        items?: SelectOption[];
-        selected?: number;
+        value?: number;
+        min?: number;
+        max?: number;
+        step?: number;
+        text?: string;
+        interactive?: boolean;
+        on_change?: InlineHandler;
     });
-    toProtocol(): Record<string, unknown>;
+    data(): Record<string, unknown>;
+    bindHandlers(registry: InlineHandlerRegistry, _path: number[]): void;
 }
 export declare class Separator extends WidgetBase {
-    private readonly options;
-    constructor(options?: CommonProps & {
-        orientation?: Orientation;
-    });
-    toProtocol(): Record<string, unknown>;
+    readonly type = "separator";
+    constructor(common?: CommonOptions);
+    data(): Record<string, unknown>;
 }
 export declare class Scroll extends WidgetBase {
-    private readonly child;
-    constructor(child: TreeNode, options?: CommonProps);
-    toProtocol(): Record<string, unknown>;
-}
-export declare class Overlay extends WidgetBase {
     private readonly options;
-    constructor(options: CommonProps & {
+    readonly type = "scroll";
+    constructor(options: CommonOptions & {
         child: TreeNode;
-        overlays?: TreeNode[];
     });
-    toProtocol(): Record<string, unknown>;
+    data(): Record<string, unknown>;
+    bindHandlers(registry: InlineHandlerRegistry, path: number[]): void;
 }
-export declare class ListBox extends WidgetBase {
-    private readonly options;
-    constructor(options?: CommonProps & {
+declare abstract class ChildrenWidget extends WidgetBase {
+    constructor(common?: CommonOptions & {
         children?: TreeNode[];
     });
-    toProtocol(): Record<string, unknown>;
+    protected readonly kids: TreeNode[];
+    data(): Record<string, unknown>;
+    bindHandlers(registry: InlineHandlerRegistry, path: number[]): void;
 }
-export declare class GridChild {
-    readonly row: number;
-    readonly column: number;
-    readonly child: TreeNode;
-    readonly width: number;
-    readonly height: number;
-    constructor(row: number, column: number, child: TreeNode, width?: number, height?: number);
-    toProtocol(): Record<string, unknown>;
+export declare class Row extends ChildrenWidget {
+    readonly type = "row";
+}
+export declare class Column extends ChildrenWidget {
+    readonly type = "column";
+}
+export declare class BoxedList extends ChildrenWidget {
+    readonly type = "boxed_list";
 }
-export declare class Grid extends WidgetBase {
+export declare class ButtonRow extends ChildrenWidget {
+    readonly type = "button_row";
+}
+export declare class CircleBox extends WidgetBase {
     private readonly options;
-    constructor(options?: CommonProps & {
-        children?: GridChild[];
-        row_spacing?: number;
-        column_spacing?: number;
+    readonly type = "circle_box";
+    constructor(options: CommonOptions & {
+        color: string;
     });
-    toProtocol(): Record<string, unknown>;
+    data(): Record<string, unknown>;
 }
-export declare class Hero extends WidgetBase {
+export declare class Container extends ChildrenWidget {
+    readonly type = "container";
+}
+export declare class PopoverShell extends ChildrenWidget {
     private readonly options;
-    constructor(options: CommonProps & {
-        title: string;
-        subtitle: string;
-        icon?: Icon;
+    readonly type = "popover_shell";
+    constructor(options?: CommonOptions & {
+        children?: TreeNode[];
+        size?: PopoverSize;
+        footer?: TreeNode[];
+        footer_visible?: boolean;
+    });
+    data(): Record<string, unknown>;
+    bindHandlers(registry: InlineHandlerRegistry, path: number[]): void;
+}
+export declare class Tile extends WidgetBase {
+    protected readonly options: CommonOptions & {
+        primary: string;
+        id?: string;
+        secondary?: string;
+        left_icon?: string;
+        left?: TreeNode;
+        right?: TreeNode;
+        activatable?: boolean;
+        on_click?: InlineHandler;
+    };
+    readonly type: string;
+    constructor(options: CommonOptions & {
+        primary: string;
+        id?: string;
+        secondary?: string;
+        left_icon?: string;
+        left?: TreeNode;
+        right?: TreeNode;
+        activatable?: boolean;
+        on_click?: InlineHandler;
     });
-    toProtocol(): Record<string, unknown>;
+    data(): Record<string, unknown>;
+    bindHandlers(registry: InlineHandlerRegistry, path: number[]): void;
+}
+export declare class SegmentedTile extends Tile {
+    protected readonly options: ConstructorParameters<typeof Tile>[0] & {
+        child?: TreeNode;
+        expanded?: boolean;
+        on_toggle?: InlineHandler;
+    };
+    readonly type = "segmented_tile";
+    constructor(options: ConstructorParameters<typeof Tile>[0] & {
+        child?: TreeNode;
+        expanded?: boolean;
+        on_toggle?: InlineHandler;
+    });
+    data(): Record<string, unknown>;
+    bindHandlers(registry: InlineHandlerRegistry, path: number[]): void;
 }
-export declare class Card extends WidgetBase {
+export declare class SwitchTile extends WidgetBase {
     private readonly options;
-    constructor(options?: CommonProps & {
-        children?: TreeNode[];
+    readonly type = "switch_tile";
+    constructor(options: CommonOptions & {
+        id: string;
+        primary: string;
+        secondary?: string;
+        left_icon?: string;
+        left?: TreeNode;
+        active?: boolean;
+        on_toggle?: InlineHandler;
     });
-    toProtocol(): Record<string, unknown>;
+    data(): Record<string, unknown>;
+    bindHandlers(registry: InlineHandlerRegistry, path: number[]): void;
 }
-export declare class Section extends WidgetBase {
+export declare class ExpanderTile extends WidgetBase {
     private readonly options;
-    constructor(options: CommonProps & {
-        title?: string;
-        subtitle?: string;
-        children?: TreeNode[];
+    readonly type = "expander_tile";
+    constructor(options: CommonOptions & {
+        primary: string;
+        id?: string;
+        secondary?: string;
+        left_icon?: string;
+        left?: TreeNode;
+        child?: TreeNode;
+        expanded?: boolean;
+        on_toggle?: InlineHandler;
     });
-    toProtocol(): Record<string, unknown>;
+    data(): Record<string, unknown>;
+    bindHandlers(registry: InlineHandlerRegistry, path: number[]): void;
 }
-export declare class Meter extends WidgetBase {
+export declare class SliderTile extends WidgetBase {
     private readonly options;
-    constructor(options: CommonProps & {
-        icon?: Icon;
+    readonly type = "slider_tile";
+    constructor(options: CommonOptions & {
+        id: string;
         label?: string;
-        value: number;
+        left_icon?: string;
+        left?: TreeNode;
+        value?: number;
         min?: number;
         max?: number;
         step?: number;
-        text?: string;
-        interactive?: boolean;
+        page?: number;
+        digits?: number;
+        snap_step?: number;
+        on_change?: InlineHandler;
+    });
+    data(): Record<string, unknown>;
+    bindHandlers(registry: InlineHandlerRegistry, path: number[]): void;
+}
+export declare class ChoiceTile extends WidgetBase {
+    private readonly options;
+    readonly type = "choice_tile";
+    constructor(options: CommonOptions & {
+        primary: string;
+        id?: string;
+        secondary?: string;
+        left_icon?: string;
+        left?: TreeNode;
+        selected?: boolean;
+        on_click?: InlineHandler;
+    });
+    data(): Record<string, unknown>;
+    bindHandlers(registry: InlineHandlerRegistry, path: number[]): void;
+}
+export declare class Choice {
+    readonly options: {
+        id: string;
+        primary: string;
+        secondary?: string;
+        icon?: string;
+    };
+    constructor(options: {
+        id: string;
+        primary: string;
+        secondary?: string;
+        icon?: string;
     });
     toProtocol(): Record<string, unknown>;
 }
-export declare class Copyable extends WidgetBase {
+export declare class ChoiceList extends WidgetBase {
     private readonly options;
-    constructor(options: CommonProps & {
-        label?: string;
-        value: string;
+    readonly type = "choice_list";
+    constructor(options: CommonOptions & {
+        id: string;
+        choices?: Choice[];
+        active?: string;
+        on_change?: InlineHandler;
     });
-    toProtocol(): Record<string, unknown>;
+    data(): Record<string, unknown>;
+    bindHandlers(registry: InlineHandlerRegistry, _path: number[]): void;
 }
-export declare class Row extends WidgetBase {
+export declare class KeyValueGrid extends WidgetBase {
     private readonly options;
-    constructor(options?: CommonProps & {
-        spacing?: number;
-        children?: TreeNode[];
+    readonly type = "key_value_grid";
+    constructor(options?: CommonOptions & {
+        rows?: {
+            key: string;
+            value: string;
+        }[];
     });
-    toProtocol(): Record<string, unknown>;
+    data(): Record<string, unknown>;
 }
-export declare class Column extends WidgetBase {
+export declare class PagerItem extends WidgetBase {
     private readonly options;
-    constructor(options?: CommonProps & {
-        spacing?: number;
-        children?: TreeNode[];
+    readonly type = "pager_item";
+    constructor(options: CommonOptions & {
+        id: number;
+        label?: string;
+        appearance?: PagerAppearance;
+        active?: boolean;
+        inactive?: boolean;
+        occupied?: boolean;
+        urgent?: boolean;
+        on_click?: InlineHandler;
     });
-    toProtocol(): Record<string, unknown>;
+    data(): Record<string, unknown>;
+    bindHandlers(registry: InlineHandlerRegistry, _path: number[]): void;
 }
-export declare class Spinner extends WidgetBase {
+export declare class PagerStrip extends WidgetBase {
     private readonly options;
-    constructor(options?: CommonProps & {
-        spinning?: boolean;
+    readonly type = "pager_strip";
+    constructor(options?: CommonOptions & {
+        id?: string;
+        items?: PagerItem[];
+        placeholder?: boolean;
+        on_change?: InlineHandler;
     });
-    toProtocol(): Record<string, unknown>;
+    data(): Record<string, unknown>;
+    bindHandlers(registry: InlineHandlerRegistry, path: number[]): void;
 }
-export type Properties = Record<string, string>;
-export declare class PropertyList extends WidgetBase {
-    private readonly options;
-    constructor(options?: CommonProps & {
-        title?: string;
-        rows?: Properties;
+declare abstract class ActiveIndicator extends WidgetBase {
+    protected readonly options: CommonOptions & {
+        active?: boolean;
+    };
+    constructor(options?: CommonOptions & {
+        active?: boolean;
     });
-    toProtocol(): Record<string, unknown>;
+    data(): Record<string, unknown>;
 }
-export declare class Item extends WidgetBase {
+export declare class CameraIndicator extends ActiveIndicator {
+    readonly type = "camera_indicator";
+}
+export declare class MicIndicator extends ActiveIndicator {
+    readonly type = "mic_indicator";
+}
+export declare class MutedIndicator extends ActiveIndicator {
+    readonly type = "muted_indicator";
+}
+export declare class LocationIndicator extends ActiveIndicator {
+    readonly type = "location_indicator";
+}
+export declare class ScreenCastIndicator extends ActiveIndicator {
+    protected readonly options: CommonOptions & {
+        active?: boolean;
+        timer_text?: string;
+    };
+    readonly type = "screencast_indicator";
+    constructor(options?: CommonOptions & {
+        active?: boolean;
+        timer_text?: string;
+    });
+    data(): Record<string, unknown>;
+}
+export declare class Calendar extends WidgetBase {
     private readonly options;
-    constructor(options: CommonProps & {
-        label: string;
-        sublabel?: string;
-        icon?: string;
-        right?: TreeNode;
+    readonly type = "calendar";
+    constructor(options: CommonOptions & {
+        selected_date: string;
+        id?: string;
+        event_days?: string[];
+        on_change?: InlineHandler;
     });
-    toProtocol(): Record<string, unknown>;
+    data(): Record<string, unknown>;
+    bindHandlers(registry: InlineHandlerRegistry, _path: number[]): void;
 }
-export declare class ActionItem extends WidgetBase {
+export declare class BatteryHero extends WidgetBase {
     private readonly options;
-    constructor(options: CommonProps & {
-        label: string;
-        sublabel?: string;
-        icon?: string;
-        right?: TreeNode;
-        enabled?: boolean;
+    readonly type = "battery_hero";
+    constructor(options: CommonOptions & {
+        icon: string;
+        percentage: string;
+        fraction: number;
+        state: string;
     });
-    toProtocol(): Record<string, unknown>;
+    data(): Record<string, unknown>;
 }
-export declare class EmptyState extends WidgetBase {
+export declare class DateHero extends WidgetBase {
     private readonly options;
-    constructor(options: CommonProps & {
+    readonly type = "date_hero";
+    constructor(options: CommonOptions & {
+        weekday: string;
+        date: string;
+    });
+    data(): Record<string, unknown>;
+}
+export declare class EventItem {
+    readonly options: {
+        id: string;
         title: string;
-        subtitle?: string;
+        start: string;
+        end?: string;
+        location?: string;
+        all_day?: boolean;
+    };
+    constructor(options: {
+        id: string;
+        title: string;
+        start: string;
+        end?: string;
+        location?: string;
+        all_day?: boolean;
     });
     toProtocol(): Record<string, unknown>;
 }
-export declare class Badge extends WidgetBase {
+export declare class Events extends WidgetBase {
     private readonly options;
-    constructor(options: CommonProps & {
-        label: string;
+    readonly type = "events";
+    constructor(options: CommonOptions & {
+        date: string;
+        events?: EventItem[];
+        loading?: boolean;
     });
-    toProtocol(): Record<string, unknown>;
+    data(): Record<string, unknown>;
 }
-export declare class StatusDot extends WidgetBase {
-    constructor(options?: CommonProps);
+export declare class WeatherForecastItem {
+    readonly options: {
+        day_name: string;
+        icon: string;
+        condition: string;
+        temperatures: string;
+        is_today?: boolean;
+    };
+    constructor(options: {
+        day_name: string;
+        icon: string;
+        condition: string;
+        temperatures: string;
+        is_today?: boolean;
+    });
     toProtocol(): Record<string, unknown>;
 }
-export declare class PagerItem extends WidgetBase {
+export declare class WeatherForecastList extends WidgetBase {
     private readonly options;
-    constructor(options?: CommonProps & {
-        appearance?: PagerAppearance;
-        label?: string;
-        active?: boolean;
-        inactive?: boolean;
-        occupied?: boolean;
-        urgent?: boolean;
+    readonly type = "weather_forecast_list";
+    constructor(options?: CommonOptions & {
+        items?: WeatherForecastItem[];
+    });
+    data(): Record<string, unknown>;
+}
+export declare class WeatherHourlyItem {
+    readonly options: {
+        time: string;
+        icon: string;
+        temperature: string;
+    };
+    constructor(options: {
+        time: string;
+        icon: string;
+        temperature: string;
     });
-    toData(): Record<string, unknown>;
     toProtocol(): Record<string, unknown>;
 }
-export declare class PagerStrip extends WidgetBase {
+export declare class WeatherHourlyStrip extends WidgetBase {
     private readonly options;
-    constructor(options?: CommonProps & {
-        items?: PagerItem[];
+    readonly type = "weather_hourly_strip";
+    constructor(options?: CommonOptions & {
+        items?: WeatherHourlyItem[];
+    });
+    data(): Record<string, unknown>;
+}
+export declare class WorldClockRow {
+    readonly options: {
+        name: string;
+        timezone: string;
+        time: string;
+        offset: string;
+        day_label?: string;
+    };
+    constructor(options: {
+        name: string;
+        timezone: string;
+        time: string;
+        offset: string;
+        day_label?: string;
     });
     toProtocol(): Record<string, unknown>;
 }
-export declare class Box extends WidgetBase {
+export declare class WorldClock extends WidgetBase {
     private readonly options;
-    constructor(options?: CommonProps & {
-        orientation?: Orientation;
-        spacing?: number;
-        children?: TreeNode[];
+    readonly type = "world_clock";
+    constructor(options?: CommonOptions & {
+        rows?: WorldClockRow[];
     });
-    static vertical(children: TreeNode[], spacing?: number, options?: CommonProps): Box;
-    static horizontal(children: TreeNode[], spacing?: number, options?: CommonProps): Box;
-    toProtocol(): Record<string, unknown>;
+    data(): Record<string, unknown>;
 }
-export type TreeNode = Hero | Card | Section | Meter | Copyable | PropertyList | Item | ActionItem | EmptyState | Badge | StatusDot | PagerItem | PagerStrip | Box | Row | Column | Grid | Scroll | Overlay | ListBox | LevelBar | TreeExpander | MenuButton | Progress | Separator | Spinner | Label | Image | Picture | Button | LinkButton | Expander | Switch | ToggleButton | Slider | Select | Checkbox;
+export type TreeNode = Row | Column | Container | CircleBox | BoxedList | PopoverShell | Label | Header | Hero | Badge | StatusDot | PanelIndicator | EmptyState | Spinner | Meter | Separator | Scroll | Tile | SegmentedTile | ButtonRow | SwitchTile | ExpanderTile | SliderTile | ChoiceTile | ChoiceList | KeyValueGrid | PagerItem | PagerStrip | CameraIndicator | MicIndicator | MutedIndicator | ScreenCastIndicator | LocationIndicator | Calendar | BatteryHero | DateHero | Events | WeatherForecastList | WeatherHourlyStrip | WorldClock;
 export {};