@jimka/typescript-ui 0.1.0

package/dist/lib/types/component/container/AccordionPanel.d.ts

@@ -0,0 +1,25 @@
+import { Container, ContainerOptions } from "../../core/Container.js";
+import { Component } from "../../core/Component.js";
+import { Accordion, SectionToggleCallback } from "../../layout/Accordion.js";
+export interface AccordionSectionConfig {
+    label: string;
+    component: Component;
+    initiallyOpen?: boolean;
+    glyph?: string;
+    tools?: Component[];
+    weight?: number;
+}
+export interface AccordionPanelOptions extends ContainerOptions {
+    sections?: AccordionSectionConfig[];
+    singleOpen?: boolean;
+    resizable?: boolean;
+    onSectionToggle?: SectionToggleCallback;
+}
+declare class AccordionPanel<TOptions extends AccordionPanelOptions = AccordionPanelOptions> extends Container<TOptions> {
+    constructor(options?: TOptions);
+    addSection(component: Component, label: string, initiallyOpen?: boolean, glyph?: string, tools?: Component[], weight?: number): this;
+    getAccordion(): Accordion;
+}
+declare const AccordionPanelCallable: import("../../core/Callable.js").Callable<typeof AccordionPanel>;
+type AccordionPanelCallable<TOptions extends AccordionPanelOptions = AccordionPanelOptions> = AccordionPanel<TOptions>;
+export { AccordionPanel as _AccordionPanel, AccordionPanelCallable as AccordionPanel, };

package/dist/lib/types/component/container/CollapseButton.d.ts

@@ -0,0 +1,30 @@
+import { Component, ComponentOptions } from "../../core/Component.js";
+import type { Handle } from "../../core/DOM.js";
+export type CollapseDirection = "north" | "south" | "east" | "west";
+export type CollapseButtonEvent = "collapse";
+export interface CollapseButtonOptions extends ComponentOptions {
+    direction?: CollapseDirection;
+    listeners?: {
+        collapse?: () => void;
+    };
+}
+declare class CollapseButton extends Component<CollapseButtonOptions> {
+    private _direction;
+    private _listeners;
+    constructor(options?: CollapseButtonOptions);
+    protected applyOptions(options: CollapseButtonOptions): this;
+    protected render(): Handle;
+    private applyRotation;
+    setStripMode(filled: boolean): this;
+    getDirection(): CollapseDirection;
+    setDirection(direction: CollapseDirection): this;
+    on(event: "collapse", listener: () => void): this;
+    off(event: CollapseButtonEvent, listener: Function): this;
+    protected emit(event: CollapseButtonEvent): void;
+    private onDoubleClick;
+    private onMouseDown;
+    destroy(): void;
+}
+declare const CollapseButtonCallable: import("../../core/Callable.js").Callable<typeof CollapseButton>;
+type CollapseButtonCallable = CollapseButton;
+export { CollapseButton as _CollapseButton, CollapseButtonCallable as CollapseButton };

package/dist/lib/types/component/container/DialogBackdrop.d.ts

@@ -0,0 +1,12 @@
+import { Component, ComponentOptions } from "../../core/Component.js";
+interface DialogBackdropOptions extends ComponentOptions {
+}
+declare class DialogBackdrop extends Component<DialogBackdropOptions> {
+    constructor(options?: DialogBackdropOptions);
+    addClickListener(listener: Function): this;
+    resize(): void;
+    destroy(): void;
+}
+declare const DialogBackdropCallable: import("../../core/Callable.js").Callable<typeof DialogBackdrop>;
+type DialogBackdropCallable = DialogBackdrop;
+export { DialogBackdrop as _DialogBackdrop, DialogBackdropCallable as DialogBackdrop };

package/dist/lib/types/component/container/FieldSet.d.ts

@@ -0,0 +1,23 @@
+import { Component, ComponentOptions } from "../../core/Component.js";
+import { Size } from "../../primitive/Size.js";
+export interface FieldSetOptions extends ComponentOptions {
+    legend?: string;
+}
+declare class FieldSet extends Component {
+    private static readonly LEGEND_CLEARANCE_FALLBACK;
+    private _legend;
+    private _legendClearance;
+    constructor(title?: string, options?: FieldSetOptions, subclassDefaults?: Partial<FieldSetOptions>);
+    protected applyOptions(options: FieldSetOptions): this;
+    getTitle(): string;
+    setTitle(title: string): this;
+    private clampLegendWidth;
+    getMinSize(): Size | null;
+    getPerimeterSize(): import("../../core/Component.js").PerimeterSize;
+    private legendClearance;
+    doLayout(): this;
+    render(): import("../../core/DOM.js").Handle;
+}
+declare const FieldSetCallable: import("../../core/Callable.js").Callable<typeof FieldSet>;
+type FieldSetCallable = FieldSet;
+export { FieldSet as _FieldSet, FieldSetCallable as FieldSet };

package/dist/lib/types/component/container/LabeledFieldSet.d.ts

@@ -0,0 +1,17 @@
+import { Component } from "../../core/Component.js";
+import { LabeledGrid, LabeledGridOptions, LabeledFieldDescriptor } from "../../component/container/LabeledGrid.js";
+import { _FieldSet, FieldSetOptions } from "../../component/container/FieldSet.js";
+export interface LabeledFieldSetOptions extends FieldSetOptions, LabeledGridOptions {
+}
+declare class LabeledFieldSet extends _FieldSet {
+    private _labeledGrid;
+    constructor(title?: string, options?: LabeledFieldSetOptions, subclassDefaults?: Partial<LabeledFieldSetOptions>);
+    addField(title: string, component: Component): this;
+    addRow(fields: LabeledFieldDescriptor[]): this;
+    addFullWidthRow(component: Component): this;
+    getColumns(): number;
+    getGrid(): LabeledGrid;
+}
+declare const LabeledFieldSetCallable: import("../../core/Callable.js").Callable<typeof LabeledFieldSet>;
+type LabeledFieldSetCallable = LabeledFieldSet;
+export { LabeledFieldSet as _LabeledFieldSet, LabeledFieldSetCallable as LabeledFieldSet };

package/dist/lib/types/component/container/LabeledGrid.d.ts

@@ -0,0 +1,34 @@
+import { Component } from "../../core/Component.js";
+import { Container, ContainerOptions } from "../../core/Container.js";
+export interface LabeledFieldDescriptor {
+    title: string;
+    component: Component;
+}
+export type LabeledRowDescriptor = LabeledFieldDescriptor[] | {
+    component: Component;
+    fullWidth: true;
+};
+export interface LabeledGridOptions extends ContainerOptions {
+    columns?: number;
+    fieldSpacing?: number;
+    rows?: LabeledRowDescriptor[];
+}
+declare class LabeledGrid extends Container<LabeledGridOptions> {
+    private _columns;
+    private _grid;
+    private _flowCol;
+    private _rowCount;
+    constructor(options?: LabeledGridOptions);
+    addField(title: string, component: Component): this;
+    addRow(fields: LabeledFieldDescriptor[]): this;
+    addFullWidthRow(component: Component): this;
+    getColumns(): number;
+    private buildColumnTracks;
+    private applyRows;
+    private openRow;
+    private finishRow;
+    private growRows;
+}
+declare const LabeledGridCallable: import("../../core/Callable.js").Callable<typeof LabeledGrid>;
+type LabeledGridCallable = LabeledGrid;
+export { LabeledGrid as _LabeledGrid, LabeledGridCallable as LabeledGrid };

package/dist/lib/types/component/container/Legend.d.ts

@@ -0,0 +1,12 @@
+import { Text, TextOptions } from "../../component/input/Text.js";
+import type { Handle } from "../../core/DOM.js";
+export interface LegendOptions extends TextOptions {
+}
+declare class Legend extends Text<LegendOptions> {
+    private static readonly LEFT_MARGIN;
+    constructor(options?: LegendOptions);
+    applyStyle(element: Handle): this;
+}
+declare const LegendCallable: import("../../core/Callable.js").Callable<typeof Legend>;
+type LegendCallable = Legend;
+export { Legend as _Legend, LegendCallable as Legend };

package/dist/lib/types/component/container/MenuItem.d.ts

@@ -0,0 +1,65 @@
+import { Component, ComponentOptions } from "../../core/Component.js";
+export interface MenuItemOptions extends ComponentOptions {
+    text?: string;
+    enabled?: boolean;
+    focused?: boolean;
+}
+export type MenuItemCSSVarPrefix = "menu-bar" | "context-menu";
+export interface MenuItemConfig {
+    text?: string;
+    action?: () => void;
+    enabled?: boolean;
+    shortcut?: string;
+    icon?: string;
+    glyph?: string;
+    glyphColor?: string;
+    submenu?: MenuConfig;
+    separator?: true;
+}
+export interface MenuConfig {
+    label: string;
+    items: MenuItemConfig[] | (() => MenuItemConfig[]);
+    glyph?: string;
+}
+declare class MenuItem extends Component {
+    static readonly HEIGHT: number;
+    private static readonly SEPARATOR_HEIGHT;
+    static readonly TEXT_INSET: number;
+    static readonly ICON_ZONE: number;
+    static readonly CHEVRON_ZONE: number;
+    static readonly RIGHT_PAD: number;
+    static readonly TEXT_GAP: number;
+    private readonly _config;
+    private readonly _onActivate;
+    private readonly _onOpenSubmenu;
+    private readonly _cssVarPrefix;
+    private _iconText;
+    private _iconGlyph;
+    private _titleText;
+    private _shortcutText;
+    private _chevronText;
+    private _iconStart;
+    private _titleColumn;
+    private _submenuTimer;
+    private readonly _onMouseOver;
+    private readonly _onMouseOut;
+    private readonly _onClick;
+    constructor(config: MenuItemConfig, onActivate: () => void, onOpenSubmenu: (item: MenuItem) => void, cssVarPrefix?: MenuItemCSSVarPrefix, options?: MenuItemOptions);
+    protected applyOptions(options: MenuItemOptions): this;
+    hasSubmenu(): boolean;
+    hasIcon(): boolean;
+    titleTextWidth(): number;
+    shortcutTextWidth(): number;
+    setColumns(iconStart: number, titleColumn: number): void;
+    getSubmenuConfig(): MenuConfig | null;
+    setFocused(focused: boolean): this;
+    isSeparator(): boolean;
+    isEnabled(): boolean;
+    activate(): void;
+    dispose(): void;
+    getBaseline(): number | null;
+    doLayout(): this;
+}
+declare const MenuItemCallable: import("../../core/Callable.js").Callable<typeof MenuItem>;
+type MenuItemCallable = MenuItem;
+export { MenuItem as _MenuItem, MenuItemCallable as MenuItem };

package/dist/lib/types/component/container/MenuSeparator.d.ts

@@ -0,0 +1,11 @@
+import { Component, ComponentOptions } from "../../core/Component.js";
+import type { MenuItemCSSVarPrefix } from "../../component/container/MenuItem.js";
+export interface MenuSeparatorOptions extends ComponentOptions {
+}
+declare class MenuSeparator extends Component<MenuSeparatorOptions> {
+    static readonly HEIGHT: number;
+    constructor(cssVarPrefix?: MenuItemCSSVarPrefix, options?: MenuSeparatorOptions);
+}
+declare const MenuSeparatorCallable: import("../../core/Callable.js").Callable<typeof MenuSeparator>;
+type MenuSeparatorCallable = MenuSeparator;
+export { MenuSeparator as _MenuSeparator, MenuSeparatorCallable as MenuSeparator };

package/dist/lib/types/component/container/ScrollStrip.d.ts

@@ -0,0 +1,58 @@
+import { Panel, PanelOptions } from "../../core/Panel.js";
+import { Component } from "../../core/Component.js";
+import type { Handle } from "../../core/DOM.js";
+export type ScrollStripOrientation = "horizontal" | "vertical";
+export interface ScrollStripOptions extends PanelOptions {
+    orientation?: ScrollStripOrientation;
+    scrollable?: boolean;
+    arrowBackground?: string;
+    arrowStep?: number;
+}
+declare class ScrollStrip extends Panel<ScrollStripOptions> {
+    private _orientation;
+    private _scrollable;
+    private _arrowBackground;
+    private _arrowStep;
+    private _stepProvider;
+    private _clip;
+    private _leadArrow;
+    private _trailArrow;
+    constructor(options?: ScrollStripOptions);
+    protected init(element?: Handle): this;
+    protected applyOptions(options: ScrollStripOptions): this;
+    private installBox;
+    private isVertical;
+    setOrientation(orientation: ScrollStripOrientation): this;
+    getOrientation(): ScrollStripOrientation;
+    setScrollable(value: boolean): this;
+    isScrollable(): boolean;
+    setArrowBackground(color: string): this;
+    setArrowStep(px: number): this;
+    setStepProvider(provider: (() => number) | null): this;
+    resolveStep(): number;
+    addItem(item: Component): this;
+    removeItem(item: Component): this;
+    moveItem(item: Component, toIndex: number): this;
+    getItems(): Array<Component>;
+    getContentBox(): ReturnType<Panel["getLayoutManager"]>;
+    layoutItems(): this;
+    getClipElement(forceCreate?: boolean): Handle | null;
+    arrowReserve(contentExtent: number, regionExtent: number): number;
+    private ensureArrows;
+    layoutContent(reserve: number, endGap: number): this;
+    private layoutArrows;
+    private hideArrows;
+    mainScroll(): number;
+    private mainScrollMax;
+    setMainScroll(value: number): void;
+    resetScroll(): this;
+    refreshArrows(): void;
+    private scrollBy;
+    private leadClicked;
+    private trailClicked;
+    revealItem(itemElement: Handle): void;
+    containsArrow(target: EventTarget | null): boolean;
+}
+declare const ScrollStripCallable: import("../../core/Callable.js").Callable<typeof ScrollStrip>;
+type ScrollStripCallable = ScrollStrip;
+export { ScrollStrip as _ScrollStrip, ScrollStripCallable as ScrollStrip, };

package/dist/lib/types/component/container/Scrollbar.d.ts

@@ -0,0 +1,60 @@
+import { Component, ComponentOptions } from "../../core/Component.js";
+import type { Handle } from "../../core/DOM.js";
+import type { AxisOrientation } from "../../primitive/Axis.js";
+export type ScrollbarEvent = "scroll";
+export type ScrollbarListener = (position: number) => void;
+export interface ScrollbarOptions extends ComponentOptions {
+    arrowsEnabled?: boolean;
+    arrowStep?: number;
+    listeners?: {
+        scroll?: ScrollbarListener;
+    };
+}
+declare class Scrollbar extends Component<ScrollbarOptions> {
+    private _orientation;
+    private _thumb;
+    private _viewportSize;
+    private _contentSize;
+    private _scrollPosition;
+    private _thumbSize;
+    private _thumbPos;
+    private _dragStartClient;
+    private _dragStartScroll;
+    private _listeners;
+    private _arrowsEnabled;
+    private _arrowStep;
+    private _arrowStart;
+    private _arrowEnd;
+    constructor(orientation?: AxisOrientation, options?: ScrollbarOptions);
+    private buildArrows;
+    private _onArrowStartTick;
+    private _onArrowEndTick;
+    private onArrowTick;
+    private disposeArrows;
+    private _onThumbMouseOver;
+    private _onThumbMouseOut;
+    protected init(element?: Handle): this;
+    on(event: "scroll", listener: ScrollbarListener): this;
+    off(event: ScrollbarEvent, listener: Function): this;
+    protected emit(event: "scroll", position: number): void;
+    setMetrics(viewportSize: number, contentSize: number, scrollPosition: number): this;
+    getTrackWidth(): number;
+    getOrientation(): AxisOrientation;
+    isArrowsEnabled(): boolean;
+    setArrowsEnabled(enabled: boolean): this;
+    getArrowStep(): number;
+    setArrowStep(px: number): this;
+    private isVertical;
+    private getTrackLength;
+    private getTrackOrigin;
+    private setThumbSize;
+    private setThumbPos;
+    private extractClientPrimary;
+    private _onDragStart;
+    private _onDragMove;
+    private _onDragEnd;
+    private _onTrackClick;
+}
+declare const ScrollbarCallable: import("../../core/Callable.js").Callable<typeof Scrollbar>;
+type ScrollbarCallable = Scrollbar;
+export { Scrollbar as _Scrollbar, ScrollbarCallable as Scrollbar };

package/dist/lib/types/component/container/Spacer.d.ts

@@ -0,0 +1,25 @@
+import { Component, ComponentOptions } from "../../core/Component.js";
+import type { Handle } from "../../core/DOM.js";
+export interface SpacerOptions extends ComponentOptions {
+    width?: number;
+    height?: number;
+    flex?: boolean;
+    flexWeight?: number;
+}
+declare class Spacer extends Component<SpacerOptions> {
+    private _flex;
+    private _flexWeight;
+    constructor(width: number, height?: number);
+    constructor(options?: SpacerOptions);
+    static flex(weight?: number): Spacer;
+    isFlex(): boolean;
+    setFlex(value: boolean): this;
+    getFlexWeight(): number;
+    setFlexWeight(weight: number): this;
+    private syncFlexConstraints;
+    protected applyOptions(options: SpacerOptions): this;
+    protected init(element?: Handle): this;
+}
+declare const SpacerCallable: import("../../core/Callable.js").Callable<typeof Spacer>;
+type SpacerCallable = Spacer;
+export { Spacer as _Spacer, SpacerCallable as Spacer };

package/dist/lib/types/component/container/SplitGutter.d.ts

@@ -0,0 +1,63 @@
+import { Component, ComponentOptions } from "../../core/Component.js";
+import type { Handle } from "../../core/DOM.js";
+import { CollapseDirection } from "../../component/container/CollapseButton.js";
+export type SplitGutterEvent = "dragstart" | "drag" | "dragend" | "collapse";
+export interface SplitGutterOptions extends ComponentOptions {
+    orientation?: string;
+    collapsible?: boolean;
+    movable?: boolean;
+    opaque?: boolean;
+    collapseDirection?: CollapseDirection;
+    expandedBackground?: string;
+    listeners?: {
+        dragstart?: (position: number) => void;
+        drag?: (position: number) => void;
+        dragend?: () => void;
+        collapse?: () => void;
+    };
+}
+declare class SplitGutter extends Component<SplitGutterOptions> {
+    private _direction;
+    private _collapsible;
+    private _movable;
+    private _collapseButton;
+    private _opaque;
+    private _collapseDirection;
+    private _expandedBackground;
+    private _tooltipText;
+    private _listeners;
+    constructor(direction: String, options?: SplitGutterOptions);
+    protected init(element?: Handle): this;
+    isCollapsible(): boolean;
+    setCollapsible(value: boolean): this;
+    protected applyOptions(options: SplitGutterOptions): this;
+    isMovable(): boolean;
+    setMovable(value: boolean): this;
+    isOpaque(): boolean;
+    setOpaque(value: boolean): this;
+    getCollapseDirection(): CollapseDirection;
+    setCollapseDirection(direction: CollapseDirection): this;
+    private updateTooltip;
+    getDirection(): String;
+    setDirection(direction?: String): this;
+    on(event: "dragstart", listener: (position: number) => void): this;
+    on(event: "drag", listener: (position: number) => void): this;
+    on(event: "dragend", listener: () => void): this;
+    on(event: "collapse", listener: () => void): this;
+    off(event: SplitGutterEvent, listener: Function): this;
+    protected emit(event: "dragstart", position: number): void;
+    protected emit(event: "drag", position: number): void;
+    protected emit(event: "dragend"): void;
+    protected emit(event: "collapse"): void;
+    destroy(): void;
+    private _dispatchDrag;
+    onDragStart(evnt: MouseEvent): void;
+    onDragStop(): void;
+    onDrag(evnt: MouseEvent): void;
+    private dragCursor;
+    private applyCursor;
+    render(): Handle;
+}
+declare const SplitGutterCallable: import("../../core/Callable.js").Callable<typeof SplitGutter>;
+type SplitGutterCallable = SplitGutter;
+export { SplitGutter as _SplitGutter, SplitGutterCallable as SplitGutter };

package/dist/lib/types/component/container/StatusBar.d.ts

@@ -0,0 +1,29 @@
+import { Component } from "../../core/Component.js";
+import { Container, ContainerOptions } from "../../core/Container.js";
+export declare const STATUS_BAR_HEIGHT: number;
+export interface StatusBarOptions extends ContainerOptions {
+    message?: string;
+    defaultMessage?: string;
+}
+declare class StatusBar extends Container<StatusBarOptions> {
+    private _message;
+    private _defaultMessage;
+    private _messageTimer;
+    private _messageText;
+    private _spacer;
+    constructor(options?: StatusBarOptions);
+    protected applyOptions(options: StatusBarOptions): this;
+    addLeft(component: Component): this;
+    addRight(component: Component): this;
+    removeLeft(component: Component): this;
+    removeRight(component: Component): this;
+    setMessage(text: string, timeoutMs?: number): this;
+    getMessage(): string;
+    clearMessage(): this;
+    setDefaultMessage(text: string): this;
+    getDefaultMessage(): string;
+    protected destructor(): void;
+}
+declare const StatusBarCallable: import("../../core/Callable.js").Callable<typeof StatusBar>;
+type StatusBarCallable = StatusBar;
+export { StatusBar as _StatusBar, StatusBarCallable as StatusBar, };

package/dist/lib/types/component/container/TabBar.d.ts

@@ -0,0 +1,189 @@
+import { Container, ContainerOptions } from "../../core/Container.js";
+import { Component } from "../../core/Component.js";
+import type { Handle } from "../../core/DOM.js";
+import { LayoutConstraints } from "../../layout/LayoutConstraints.js";
+import type { TabWidthMode, TabSide, TabOrientation } from "../../layout/Tab.js";
+import type { AxisPosition, AxisEnd } from "../../primitive/Axis.js";
+export type TabBarEvent = "tabpressed" | "reorder" | "tabclose" | "dockrequested" | "tabdragstart" | "tearoffrequested" | "detach" | "dockhover";
+export interface TabToolDescriptor {
+    label: string;
+    glyph?: string;
+    action: () => void;
+}
+export interface TabBarOptions extends ContainerOptions {
+    listeners?: {
+        tabpressed?: (id: string) => void;
+        reorder?: (fromId: string, toIndex: number) => void;
+        tabclose?: (id: string) => void;
+        dockrequested?: (componentId: string, slot: number) => void;
+        tabdragstart?: (id: string) => void;
+        tearoffrequested?: (id: string, clientX: number, clientY: number, forceBare: boolean) => void;
+        detach?: (id: string) => void;
+        dockhover?: () => void;
+    };
+    widthMode?: TabWidthMode;
+    maxWidth?: number | null;
+    fixedWidth?: number;
+    underBorderFullWidth?: boolean;
+    side?: TabSide;
+    align?: AxisEnd;
+    orientation?: TabOrientation;
+    scrollable?: boolean;
+    tools?: (Component | TabToolDescriptor)[];
+    compact?: boolean;
+    reorderable?: boolean;
+    textAlign?: AxisPosition;
+}
+declare class TabBar extends Container<TabBarOptions> {
+    private _tabClip;
+    private _entries;
+    private _buttonGroup;
+    private _rovingTabIndex;
+    private _activeId;
+    private _listeners;
+    private _widthMode;
+    private _maxWidth;
+    private _fixedWidth;
+    private _underBorderFullWidth;
+    private _underBorderFromTheme;
+    private _themeCleanup;
+    private _indicator;
+    private _side;
+    private _align;
+    private _orientation;
+    private _scrollable;
+    private _compact;
+    private _textAlign;
+    private _contextMenu;
+    private _tools;
+    private _toolMenuItems;
+    private _toolGroup;
+    private _leadGroup;
+    private _leadWidget;
+    private _scrollToSelected;
+    private _reorderable;
+    private _reorderBar;
+    private _dropTint;
+    private _dndTeardowns;
+    private _dragMouseTarget;
+    private _moveTriggerTeardown;
+    private _dragShiftHeld;
+    private _dragInsertIndex;
+    private _springRaiseTimer;
+    constructor(options?: TabBarOptions);
+    private dispatchBarOptions;
+    setBarSurfaceColor(color: string): this;
+    protected init(element?: Handle): this;
+    dispose(): this;
+    private applyUnderBorder;
+    setWidthMode(mode: TabWidthMode): this;
+    getWidthMode(): TabWidthMode;
+    setMaxWidth(px: number | null): this;
+    getMaxWidth(): number | null;
+    setFixedWidth(px: number): this;
+    getFixedWidth(): number;
+    setUnderBorderFullWidth(full: boolean): this;
+    isUnderBorderFullWidth(): boolean;
+    setSide(side: TabSide): this;
+    getSide(): TabSide;
+    setAlign(align: AxisEnd): this;
+    getAlign(): AxisEnd;
+    setOrientation(orientation: TabOrientation): this;
+    getOrientation(): TabOrientation;
+    setTextAlign(align: AxisPosition): this;
+    getTextAlign(): AxisPosition;
+    setScrollable(value: boolean): this;
+    isScrollable(): boolean;
+    setCompact(value: boolean): this;
+    isCompact(): boolean;
+    setReorderable(value: boolean): this;
+    isReorderable(): boolean;
+    addTool(button: Component): this;
+    addTool(descriptor: TabToolDescriptor): this;
+    private buildDescriptorTool;
+    removeTool(button: Component): this;
+    setLeadingWidget(widget: Component | null): this;
+    getLeadingWidget(): Component | null;
+    private isBarChromeTarget;
+    installMoveTrigger(onEmptyPress: (e: MouseEvent) => void, onEmptyDoubleClick?: (e: MouseEvent) => void): this;
+    getEntryIds(): string[];
+    getActiveEntryId(): string | null;
+    isEntryCloseable(id: string): boolean;
+    getEntryName(id: string): string;
+    setEntryContentId(id: string, contentId: string): this;
+    getEntryButtonId(id: string): string;
+    private entryById;
+    private activeEntry;
+    createBarEntry(id: string, name: string, constraints?: LayoutConstraints): this;
+    removeBarEntry(id: string): this;
+    moveBarEntry(id: string, toIndex: number): this;
+    setActiveEntry(id: string): this;
+    setActiveVisual(id: string): this;
+    private openTabMenu;
+    private bulkCloseItem;
+    private onTabPressed;
+    private computeTabButtonInsets;
+    private computeToolButtonInsets;
+    private clampWrapperMain;
+    private isRotatedText;
+    private buttonMainExtent;
+    private buttonCrossExtent;
+    stripThickness(): number;
+    private stripChrome;
+    private tabModeExtent;
+    private applyTabWidths;
+    private isVertical;
+    private syncToolbarOrientation;
+    private toolGroupMainExtent;
+    private leadWidgetMainExtent;
+    private predictTabsExtent;
+    private predictedTabExtent;
+    private positionClipFrame;
+    private applyTabButtonStyles;
+    private endAlignGap;
+    private positionToolGroup;
+    private positionLeadGroup;
+    private positionIndicator;
+    private positionCloseButtons;
+    private scrollStepExtent;
+    private revealSelectedIfRequested;
+    prepareStrip(): this;
+    placeStrip(x: number, y: number, width: number, height: number): this;
+    private layoutChrome;
+    private installTabDnD;
+    private makeTabDragSource;
+    private makeTabDropTarget;
+    private scheduleSpringRaise;
+    private clearSpringRaise;
+    private hideDropAffordance;
+    private isTabHeaderDrag;
+    private dropTabHeader;
+    private stripId;
+    private onTabDragEnd;
+    private updateReorderSlot;
+    private slotBoundary;
+    private dropReorder;
+    private reorderTab;
+    private teardownTabDnD;
+    private onToolbarKeyDown;
+    on(event: "tabpressed", listener: (id: string) => void): this;
+    on(event: "reorder", listener: (fromId: string, toIndex: number) => void): this;
+    on(event: "tabclose", listener: (id: string) => void): this;
+    on(event: "dockrequested", listener: (componentId: string, slot: number) => void): this;
+    on(event: "tabdragstart", listener: (id: string) => void): this;
+    on(event: "tearoffrequested", listener: (id: string, clientX: number, clientY: number, forceBare: boolean) => void): this;
+    on(event: "detach", listener: (id: string) => void): this;
+    on(event: "dockhover", listener: () => void): this;
+    off(event: TabBarEvent, listener: Function): this;
+    protected emit(event: "tabpressed", id: string): void;
+    protected emit(event: "reorder", fromId: string, toIndex: number): void;
+    protected emit(event: "tabclose", id: string): void;
+    protected emit(event: "dockrequested", componentId: string, slot: number): void;
+    protected emit(event: "tabdragstart", id: string): void;
+    protected emit(event: "tearoffrequested", id: string, clientX: number, clientY: number, forceBare: boolean): void;
+    protected emit(event: "detach", id: string): void;
+    protected emit(event: "dockhover"): void;
+}
+declare const TabBarCallable: import("../../core/Callable.js").Callable<typeof TabBar>;
+type TabBarCallable = TabBar;
+export { TabBar as _TabBar, TabBarCallable as TabBar };