@galacean/effects-plugin-gui 2.10.0-alpha.5

package/dist/controls/popup.d.ts

@@ -0,0 +1,23 @@
+import type { Engine, EventEmitterListener, InputEventKey, math } from '@galacean/effects';
+import type { Control } from '../core/control';
+import { PanelContainer } from '../layout/panel-container';
+export type PopupEvent = {
+    popupOpened: [];
+    popupClosed: [];
+};
+export declare abstract class Popup extends PanelContainer {
+    static readonly themeType: string;
+    private readonly popupEventEmitter;
+    constructor(engine: Engine);
+    onPopup<E extends keyof PopupEvent>(eventName: E, listener: EventEmitterListener<PopupEvent[E]>): void;
+    offPopup<E extends keyof PopupEvent>(eventName: E, listener: EventEmitterListener<PopupEvent[E]>): void;
+    popup(position: math.Vector2, source?: Control | null): void;
+    hidePopup(): void;
+    onKeyDown(event: InputEventKey): void;
+    onPopupOpened(): void;
+    onPopupClosed(): void;
+    onDestroy(): void;
+}
+export declare class PopupPanel extends Popup {
+    static readonly themeType: string;
+}

package/dist/controls/progress-bar.d.ts

@@ -0,0 +1,19 @@
+import { math } from '@galacean/effects';
+import type { Engine } from '@galacean/effects';
+import { Range } from '../scroll/range';
+import { ProgressFillMode } from './enums';
+import type { ProgressBarData } from '../data';
+export declare class ProgressBar extends Range {
+    static readonly themeType: string;
+    private _showPercentage;
+    private _fillMode;
+    constructor(engine: Engine);
+    get showPercentage(): boolean;
+    set showPercentage(value: boolean);
+    get fillMode(): ProgressFillMode;
+    set fillMode(value: ProgressFillMode);
+    getMinimumSize(): math.Vector2;
+    getDesiredSize(): math.Vector2;
+    draw(): void;
+    fromData(data: ProgressBarData): void;
+}

package/dist/controls/slider.d.ts

@@ -0,0 +1,63 @@
+import { math } from '@galacean/effects';
+import type { Engine, EventEmitterListener, InputEventKey, InputEventMouseButton, InputEventMouseMotion, InputEventScreenDrag, InputEventScreenTouch } from '@galacean/effects';
+import type { RootControl } from '../core/control';
+import { Orientation } from '../layout/enums';
+import { Range } from '../scroll/range';
+import type { RangeEvent } from '../scroll/range';
+import type { SliderData } from '../data';
+export type SliderEvent = RangeEvent & {
+    dragStarted: [];
+    dragEnded: [valueChanged: boolean];
+};
+export declare class Slider extends Range {
+    static readonly themeType: string;
+    private readonly sliderEventEmitter;
+    private _orientation;
+    private _editable;
+    private dragging;
+    private hovered;
+    private dragPosition;
+    private dragRatio;
+    private dragInitialValue;
+    private touchIndex;
+    scrollable: boolean;
+    constructor(engine: Engine, orientation?: Orientation);
+    get orientation(): Orientation;
+    get editable(): boolean;
+    set editable(value: boolean);
+    set orientation(value: Orientation);
+    on<E extends keyof SliderEvent>(eventName: E, listener: EventEmitterListener<SliderEvent[E]>): void;
+    off<E extends keyof SliderEvent>(eventName: E, listener: EventEmitterListener<SliderEvent[E]>): void;
+    getMinimumSize(): math.Vector2;
+    draw(): void;
+    onMouseEnter(): void;
+    onMouseMove(event: InputEventMouseMotion): void;
+    onMouseLeave(): void;
+    onMouseDown(event: InputEventMouseButton): void;
+    onMouseUp(event: InputEventMouseButton): void;
+    onTouchDown(event: InputEventScreenTouch): void;
+    onTouchMove(event: InputEventScreenDrag): void;
+    onTouchUp(event: InputEventScreenTouch): void;
+    onMouseWheel(event: InputEventMouseButton): void;
+    onKeyDown(event: InputEventKey): void;
+    onScrollBegin(): void;
+    protected onRootChanged(previousRoot: RootControl | null, nextRoot: RootControl | null): void;
+    private beginDrag;
+    private updateDrag;
+    private endDrag;
+    private getAxis;
+    private getAxisSize;
+    private getUsableLength;
+    private getRatioAt;
+    private getIncrement;
+    private getGrabberRect;
+    fromData(data: SliderData): void;
+}
+export declare class HSlider extends Slider {
+    static readonly themeType: string;
+    constructor(engine: Engine);
+}
+export declare class VSlider extends Slider {
+    static readonly themeType: string;
+    constructor(engine: Engine);
+}

package/dist/controls/text-edit.d.ts

@@ -0,0 +1,21 @@
+import { math } from '@galacean/effects';
+import type { Engine, InputEventKey, InputEventMouseButton } from '@galacean/effects';
+import type { TextEditData } from '../data';
+import { TextInput } from './text-input';
+export declare class TextEdit extends TextInput {
+    static readonly themeType: string;
+    protected readonly multiline = true;
+    private scrollLine;
+    constructor(engine: Engine, text?: string);
+    getMinimumSize(): math.Vector2;
+    getDesiredSize(): math.Vector2;
+    draw(): void;
+    onMouseWheel(event: InputEventMouseButton): void;
+    onKeyDown(event: InputEventKey): void;
+    protected getCharacterIndex(position: math.Vector2): number;
+    private measureLine;
+    private getVerticalCaretIndex;
+    private ensureCaretLineVisible;
+    protected onTextValueChanged(): void;
+    fromData(data: TextEditData): void;
+}

package/dist/controls/text-input.d.ts

@@ -0,0 +1,92 @@
+import type { Engine, EventEmitterListener, InputEventKey, InputEventMouseButton, InputEventMouseMotion, math } from '@galacean/effects';
+import { Control } from '../core/control';
+import type { ControlEvent } from '../core/control';
+export type TextInputEvent = ControlEvent & {
+    textChanged: [text: string];
+    textSubmitted: [text: string];
+};
+export declare abstract class TextInput extends Control {
+    static readonly themeType: string;
+    protected abstract readonly multiline: boolean;
+    private readonly textEventEmitter;
+    private _text;
+    private _placeholderText;
+    private _editable;
+    private _maxLength;
+    private selectionStart;
+    private selectionEnd;
+    private selectionAnchor;
+    private selecting;
+    private selectingWords;
+    private wordSelectionStart;
+    private wordSelectionEnd;
+    private textarea;
+    private textareaFocusTimer;
+    private composing;
+    private readonly undoStack;
+    private readonly redoStack;
+    constructor(engine: Engine);
+    get text(): string;
+    set text(value: string);
+    get placeholderText(): string;
+    set placeholderText(value: string);
+    get editable(): boolean;
+    set editable(value: boolean);
+    get maxLength(): number;
+    set maxLength(value: number);
+    get caretColumn(): number;
+    set caretColumn(value: number);
+    get hasSelection(): boolean;
+    on<E extends keyof TextInputEvent>(eventName: E, listener: EventEmitterListener<TextInputEvent[E]>): void;
+    off<E extends keyof TextInputEvent>(eventName: E, listener: EventEmitterListener<TextInputEvent[E]>): void;
+    selectAll(): void;
+    deselect(): void;
+    getSelectedText(): string;
+    setSelection(start: number, end?: number): void;
+    onMouseDown(event: InputEventMouseButton): void;
+    onMouseMove(event: InputEventMouseMotion): void;
+    onMouseUp(event: InputEventMouseButton): void;
+    onKeyDown(event: InputEventKey): void;
+    onGotFocus(): void;
+    onLostFocus(): void;
+    onDestroy(): void;
+    protected getDisplayText(): string;
+    protected getSelectionRange(): [number, number];
+    protected moveCaret(index: number, extendSelection: boolean): void;
+    protected getTextFont(): import("@galacean/effects-plugin-gui").ThemeFont;
+    protected getTextFontSize(): number;
+    protected getTextColor(): math.Color;
+    protected getTextStyleBox(): import("@galacean/effects-plugin-gui").StyleBox;
+    protected drawTextBackground(): void;
+    protected drawSelection(x: number, y: number, width: number, height: number): void;
+    protected drawCaret(x: number, y: number, height: number): void;
+    protected abstract getCharacterIndex(position: math.Vector2): number;
+    protected onTextValueChanged(): void;
+    private setText;
+    private replaceSelection;
+    private erase;
+    private getLineStart;
+    private getLineEnd;
+    private submit;
+    private pushUndo;
+    private undo;
+    private redo;
+    private snapshot;
+    private restore;
+    private copySelection;
+    private pasteClipboard;
+    private getWordRange;
+    private activateTextarea;
+    private removeTextarea;
+    private syncTextareaSelection;
+    private scheduleTextareaFocus;
+    private cancelTextareaFocus;
+    private focusTextarea;
+    private readonly onBeforeInput;
+    private readonly onTextareaInput;
+    private readonly onTextareaSelect;
+    private readonly onCompositionStart;
+    private readonly onCompositionEnd;
+    private readonly onTextareaKeyDown;
+    private readonly onTextareaBlur;
+}

package/dist/controls/texture-rect.d.ts

@@ -0,0 +1,30 @@
+import { math } from '@galacean/effects';
+import type { Engine, Texture } from '@galacean/effects';
+import { Control } from '../core/control';
+import type { TextureRectData } from '../data';
+import { TextureExpandMode, TextureStretchMode } from './enums';
+export declare class TextureRect extends Control {
+    static readonly themeType: string;
+    private _texture;
+    private _expandMode;
+    private _stretchMode;
+    flipH: boolean;
+    flipV: boolean;
+    tint: math.Color;
+    constructor(engine: Engine, texture?: Texture | null);
+    get texture(): Texture | null;
+    set texture(value: Texture | null);
+    get expandMode(): TextureExpandMode;
+    set expandMode(value: TextureExpandMode);
+    get stretchMode(): TextureStretchMode;
+    set stretchMode(value: TextureStretchMode);
+    getMinimumSize(): math.Vector2;
+    getDesiredSize(): math.Vector2;
+    draw(): void;
+    private drawAspect;
+    private drawCovered;
+    private drawTiled;
+    private drawRegion;
+    private controlSizeChanged;
+    fromData(data: TextureRectData): void;
+}

package/dist/core/control.d.ts

@@ -0,0 +1,379 @@
+import { math } from '@galacean/effects';
+import type { Engine, EventEmitterListener, FontStyle, FontWeight, InputEventKey, InputEventMouseButton, InputEventMouseMotion, InputEventScreenDrag, InputEventScreenTouch, NinePatchDrawOptions, TextMeasurement, Texture, TextureRegion, VFXItem } from '@galacean/effects';
+import { EventEmitter } from '@galacean/effects';
+import type { UIControl } from '../components/ui-control';
+import type { ControlData } from './data';
+import type { CursorStyle } from './enums';
+import { FocusBehaviorRecursive, FocusMode, MouseBehaviorRecursive, MouseFilter } from './enums';
+import { StyleBox } from './theme';
+import type { Theme, ThemeFont } from './theme';
+type Color = math.Color;
+type Matrix3 = math.Matrix3;
+type Vector2 = math.Vector2;
+declare const Color: typeof math.Color;
+declare const Matrix3: typeof math.Matrix3;
+declare const Vector2: typeof math.Vector2;
+export type Rect = {
+    position: Vector2;
+    size: Vector2;
+};
+/** Bit flags that describe how a Control uses space assigned by a Container. */
+export declare enum SizeFlags {
+    ShrinkBegin = 0,
+    Fill = 1,
+    Expand = 2,
+    ShrinkCenter = 4,
+    ShrinkEnd = 8,
+    ExpandFill = 3
+}
+/** Direction in which a Control grows when a minimum size makes its requested rectangle larger. */
+export declare enum GrowDirection {
+    Begin = 0,
+    End = 1,
+    Both = 2
+}
+export type LayoutPreset = 'topLeft' | 'topRight' | 'bottomLeft' | 'bottomRight' | 'centerLeft' | 'centerTop' | 'centerRight' | 'centerBottom' | 'center' | 'leftWide' | 'topWide' | 'rightWide' | 'bottomWide' | 'vcenterWide' | 'hcenterWide' | 'fullRect';
+export type ControlEvent = {
+    locationChanged: [control: Control];
+    sizeChanged: [control: Control];
+    parentChanged: [control: Control];
+    minimumSizeChanged: [control: Control];
+    desiredSizeChanged: [control: Control];
+    maximumSizeChanged: [control: Control];
+    sizeFlagsChanged: [control: Control];
+    visibilityChanged: [control: Control];
+    enabledChanged: [control: Control];
+    themeChanged: [control: Control, affectsLayout: boolean];
+};
+export type RootControlEvent = ControlEvent & {
+    guiFocusChanged: [control: Control | null];
+};
+/**
+ * A drawable GUI object. Controls form a tree independent from the VFXItem
+ * scene tree. UIControl is the bridge between both trees.
+ */
+export declare class Control {
+    static readonly themeType: string;
+    readonly engine: Engine;
+    /** Scene-tree bridge that owns this GUI object, if any. */
+    owner: UIControl | null;
+    readonly children: Control[];
+    readonly position: math.Vector2;
+    readonly size: math.Vector2;
+    readonly anchorMin: math.Vector2;
+    readonly anchorMax: math.Vector2;
+    readonly offsetMin: math.Vector2;
+    readonly offsetMax: math.Vector2;
+    readonly pivot: math.Vector2;
+    readonly scale: math.Vector2;
+    readonly shear: math.Vector2;
+    mouseForcePassScrollEvents: boolean;
+    clipContents: boolean;
+    private _parent;
+    private _visible;
+    private _enabled;
+    private _mouseFilter;
+    private _mouseBehaviorRecursive;
+    private _focusMode;
+    private _focusBehaviorRecursive;
+    private _defaultCursorShape;
+    private _rotation;
+    private transformDirty;
+    private readonly cachedTransform;
+    private readonly eventEmitter;
+    private disposed;
+    private readonly customMinimumSize;
+    private readonly customMaximumSize;
+    private minimumSizeCache;
+    private desiredSizeCache;
+    private maximumSizeCache;
+    private pendingMeasurementChanges;
+    private _horizontalSizeFlags;
+    private _verticalSizeFlags;
+    private _stretchRatio;
+    private _horizontalGrowDirection;
+    private _verticalGrowDirection;
+    private _theme;
+    private themeOwnerNode;
+    private _themeTypeVariation;
+    private readonly themeOverrides;
+    private readonly themeCache;
+    private readonly overrideStyleBoxReferences;
+    private readonly attachedThemeChanged;
+    private readonly overrideStyleBoxChanged;
+    constructor(engine: Engine);
+    get parent(): Control | null;
+    set parent(value: Control | null);
+    /** Scene item exposed through the optional UIControl bridge. */
+    get item(): VFXItem | null;
+    get indexInParent(): number;
+    set indexInParent(value: number);
+    get visible(): boolean;
+    set visible(value: boolean);
+    get visibleInHierarchy(): boolean;
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    get enabledInHierarchy(): boolean;
+    get mouseFilter(): MouseFilter;
+    set mouseFilter(value: MouseFilter);
+    get mouseBehaviorRecursive(): MouseBehaviorRecursive;
+    set mouseBehaviorRecursive(value: MouseBehaviorRecursive);
+    get focusMode(): FocusMode;
+    set focusMode(value: FocusMode);
+    get focusBehaviorRecursive(): FocusBehaviorRecursive;
+    set focusBehaviorRecursive(value: FocusBehaviorRecursive);
+    get defaultCursorShape(): CursorStyle;
+    set defaultCursorShape(value: CursorStyle);
+    get location(): Vector2;
+    set location(value: Vector2);
+    get rotation(): number;
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get width(): number;
+    set width(value: number);
+    get height(): number;
+    set height(value: number);
+    get horizontalSizeFlags(): SizeFlags;
+    set horizontalSizeFlags(value: SizeFlags);
+    get verticalSizeFlags(): SizeFlags;
+    set verticalSizeFlags(value: SizeFlags);
+    get stretchRatio(): number;
+    set stretchRatio(value: number);
+    get horizontalGrowDirection(): GrowDirection;
+    set horizontalGrowDirection(value: GrowDirection);
+    get verticalGrowDirection(): GrowDirection;
+    set verticalGrowDirection(value: GrowDirection);
+    get root(): RootControl | null;
+    get isDisposed(): boolean;
+    /** Theme applied to this Control and inherited by its descendants. */
+    get theme(): Theme | null;
+    set theme(value: Theme | null);
+    /** Returns the nearest Theme currently inherited by this Control. */
+    getInheritedTheme(): Theme | null;
+    /** Returns the Control that owns the first Theme in this Control's inheritance chain. */
+    getThemeOwnerNode(): Control | null;
+    /** Returns whether this Control is affected by a Theme in its Control ancestry. */
+    hasThemeOwnerNode(): boolean;
+    /** Optional named type variation resolved before this Control's native theme type. */
+    get themeTypeVariation(): string;
+    set themeTypeVariation(value: string);
+    /** Stable theme type declared by the closest Control class that provides one. */
+    getThemeType(): string;
+    getThemeColor(name: string, themeType?: string): Color;
+    getThemeConstant(name: string, themeType?: string): number;
+    getThemeFont(name: string, themeType?: string): ThemeFont;
+    getThemeFontSize(name: string, themeType?: string): number;
+    getThemeIcon(name: string, themeType?: string): Texture | null;
+    getThemeStyleBox(name: string, themeType?: string): StyleBox;
+    hasThemeColor(name: string, themeType?: string): boolean;
+    hasThemeConstant(name: string, themeType?: string): boolean;
+    hasThemeFont(name: string, themeType?: string): boolean;
+    hasThemeFontSize(name: string, themeType?: string): boolean;
+    hasThemeIcon(name: string, themeType?: string): boolean;
+    hasThemeStyleBox(name: string, themeType?: string): boolean;
+    setThemeColorOverride(name: string, value: Color): void;
+    setThemeConstantOverride(name: string, value: number): void;
+    setThemeFontOverride(name: string, value: ThemeFont): void;
+    setThemeFontSizeOverride(name: string, value: number): void;
+    setThemeIconOverride(name: string, value: Texture | null): void;
+    setThemeStyleBoxOverride(name: string, value: StyleBox): void;
+    removeThemeColorOverride(name: string): void;
+    removeThemeConstantOverride(name: string): void;
+    removeThemeFontOverride(name: string): void;
+    removeThemeFontSizeOverride(name: string): void;
+    removeThemeIconOverride(name: string): void;
+    removeThemeStyleBoxOverride(name: string): void;
+    hasThemeColorOverride(name: string): boolean;
+    hasThemeConstantOverride(name: string): boolean;
+    hasThemeFontOverride(name: string): boolean;
+    hasThemeFontSizeOverride(name: string): boolean;
+    hasThemeIconOverride(name: string): boolean;
+    hasThemeStyleBoxOverride(name: string): boolean;
+    clearThemeOverrides(): void;
+    hasFocus(visibleOnly?: boolean): boolean;
+    drawStyleBox(styleBox: StyleBox, x: number, y: number, width: number, height: number): void;
+    on<E extends keyof ControlEvent>(eventName: E, listener: EventEmitterListener<ControlEvent[E]>): void;
+    off<E extends keyof ControlEvent>(eventName: E, listener: EventEmitterListener<ControlEvent[E]>): void;
+    addChild<T extends Control>(child: T): T;
+    removeChild(child: Control): void;
+    getChildIndex(child: Control): number;
+    setPosition(x: number, y: number, keepOffsets?: boolean): void;
+    setSize(width: number, height: number): void;
+    /** Atomically replaces the local rectangle while preserving the current anchors. */
+    setRect(rect: Rect): void;
+    setSizeFlags(horizontal: SizeFlags, vertical: SizeFlags): void;
+    /** Intrinsic minimum size supplied by a subclass. */
+    getMinimumSize(): Vector2;
+    /** Intrinsic preferred size supplied by a subclass. */
+    getDesiredSize(): Vector2;
+    /** Intrinsic maximum size supplied by a subclass. Negative components are unbounded. */
+    getMaximumSize(): Vector2;
+    getCombinedMinimumSize(): Vector2;
+    getCombinedMaximumSize(): Vector2;
+    /** Minimum size after resolving a conflicting maximum; the maximum wins. */
+    getBoundMinimumSize(): Vector2;
+    /** Desired size clamped to the resolved minimum and maximum constraints. */
+    getBoundDesiredSize(): Vector2;
+    setCustomMinimumSize(width: number, height: number): void;
+    setCustomMaximumSize(width: number, height: number): void;
+    updateMinimumSize(): void;
+    updateDesiredSize(): void;
+    updateMaximumSize(): void;
+    protected invalidateMeasurementChanges(changes: number): void;
+    setScale(x: number, y: number): void;
+    setRotation(degrees: number): void;
+    setShear(x: number, y: number): void;
+    setPivot(x: number, y: number): void;
+    setAnchorMin(x: number, y: number): void;
+    setAnchorMax(x: number, y: number): void;
+    setOffsetMin(x: number, y: number): void;
+    setOffsetMax(x: number, y: number): void;
+    getRect(): Rect;
+    getTransform2D(): Matrix3;
+    setAnchorsPreset(preset: LayoutPreset, keepOffsets?: boolean): void;
+    setOffsetsPreset(preset: LayoutPreset, margin?: number): void;
+    setAnchorsAndOffsetsPreset(preset: LayoutPreset, margin?: number): void;
+    getGlobalTransform2D(): Matrix3;
+    hasPoint(point: Vector2): boolean;
+    /** Whether input at a position in this Control's space may reach a direct child. */
+    intersectsChildContent(child: Control, position: Vector2): boolean;
+    getEffectiveMouseFilter(): MouseFilter;
+    getFocusModeWithOverride(): FocusMode;
+    getCursorShape(position: Vector2): CursorStyle;
+    focus(hideFocus?: boolean): void;
+    grabFocus(hideFocus?: boolean): void;
+    grabClickFocus(): void;
+    releaseFocus(): void;
+    warpMouse(position: Vector2): void;
+    /** Converts a window-space position into this control's local coordinates. */
+    makePositionLocal(position: Vector2): Vector2;
+    /** Gets the current mouse position transformed into this control's coordinates. */
+    getLocalMousePosition(): Vector2;
+    update(deltaTime: number): void;
+    draw(): void;
+    onDestroy(): void;
+    drawInternal(): void;
+    drawLine(x1: number, y1: number, x2: number, y2: number, color?: Color, thickness?: number): void;
+    drawPolyline(points: number[], color?: Color, thickness?: number): void;
+    drawBezier(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number, color?: Color, thickness?: number): void;
+    drawTriangle(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, color?: Color, thickness?: number): void;
+    drawRect(x: number, y: number, width: number, height: number, color?: Color, thickness?: number): void;
+    drawCircle(cx: number, cy: number, radius: number, color?: Color, thickness?: number): void;
+    fillTriangle(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, color?: Color): void;
+    fillRect(x: number, y: number, width: number, height: number, color?: Color): void;
+    fillCircle(cx: number, cy: number, radius: number, color?: Color): void;
+    drawTexture(x: number, y: number, width: number, height: number, texture: Texture, region?: TextureRegion, color?: Color): void;
+    drawNinePatch(x: number, y: number, width: number, height: number, texture: Texture, options: NinePatchDrawOptions, color?: Color): void;
+    drawText(x: number, y: number, text: string, fontSize: number, color?: Color, fontFamily?: string, fontWeight?: FontWeight, fontStyle?: FontStyle): void;
+    measureText(text: string, fontSize: number, fontFamily?: string, fontWeight?: FontWeight, fontStyle?: FontStyle): TextMeasurement;
+    onMouseEnter(location: Vector2): void;
+    onMouseMove(event: InputEventMouseMotion): void;
+    onMouseLeave(): void;
+    onMouseWheel(event: InputEventMouseButton): void;
+    onMouseDown(event: InputEventMouseButton): void;
+    onMouseUp(event: InputEventMouseButton): void;
+    onTouchDown(event: InputEventScreenTouch): void;
+    onTouchMove(event: InputEventScreenDrag): void;
+    onTouchUp(event: InputEventScreenTouch): void;
+    onKeyDown(event: InputEventKey): void;
+    onKeyUp(event: InputEventKey): void;
+    onGotFocus(): void;
+    onLostFocus(): void;
+    onScrollBegin(): void;
+    onScrollEnd(): void;
+    dispose(): void;
+    protected drawChildren(): void;
+    protected onThemeChanged(affectsLayout: boolean): void;
+    protected onRootChanged(previousRoot: RootControl | null, nextRoot: RootControl | null): void;
+    protected getDragData(position: Vector2): unknown;
+    protected canDropData(position: Vector2, data: unknown): boolean;
+    protected dropData(position: Vector2, data: unknown): void;
+    private getThemeDependencies;
+    private getFallbackThemeDependencies;
+    private resolveThemeItem;
+    private getThemeFallback;
+    private setThemeOverride;
+    private removeThemeOverride;
+    private hasThemeOverride;
+    private retainOverrideStyleBox;
+    private releaseOverrideStyleBox;
+    private propagateThemeChanged;
+    private propagateThemeOwner;
+    private scheduleMeasurementChanges;
+    private applyBounds;
+    private markTransformDirty;
+    private getCachedMinimumSize;
+    private getCachedDesiredSize;
+    private getCachedMaximumSize;
+    private resolveBoundedAxis;
+    private assertGrowDirection;
+    private queuePendingLayouts;
+    private queuePendingMeasurements;
+    private notifyRootChanged;
+    private getParentRect;
+    private computeOffsets;
+    private computeAnchors;
+    private isMouseRecursiveEnabled;
+    private isFocusRecursiveEnabled;
+    fromData(data: ControlData): void;
+    private applyThemeOverridesFromData;
+}
+/**
+ * A Control that automatically measures and arranges its child Controls.
+ * Concrete layout algorithms live in GUI plugin packages.
+ */
+export declare class Container extends Control {
+    static readonly themeType: string;
+    private sortPending;
+    private readonly childLayoutChanged;
+    private readonly ownSizeChanged;
+    constructor(engine: Engine);
+    /** Defers and coalesces a layout pass until the GUI update phase. */
+    queueSort(): void;
+    changeChildIndex(child: Control, newIndex: number): void;
+    addChildInternal(child: Control): void;
+    removeChildInternal(child: Control): void;
+    dispose(): void;
+    /**
+     * Applies size flags and strict container geometry to a child. Automatic
+     * layout owns anchors, rotation, scale and shear; pivot is intentionally kept.
+     */
+    fitChildInRect(child: Control, rect: Rect): void;
+    /** Returns direct children that participate in layout. Disabled children still participate. */
+    protected getLayoutChildren(): Control[];
+    protected sortChildren(): void;
+    private bindChild;
+    private unbindChild;
+    private invalidateMeasurementsAndQueueSort;
+    private fitAxis;
+}
+/** Base class for GUI tree roots and input dispatchers. */
+export declare abstract class RootControl extends Control {
+    protected readonly rootEventEmitter: EventEmitter<RootControlEvent>;
+    on<E extends keyof RootControlEvent>(eventName: E, listener: EventEmitterListener<RootControlEvent[E]>): void;
+    off<E extends keyof RootControlEvent>(eventName: E, listener: EventEmitterListener<RootControlEvent[E]>): void;
+    abstract queueLayout(container: Container): void;
+    abstract queueMeasurementChange(control: Control): void;
+    abstract getMousePosition(): Vector2;
+    abstract guiGetFocusOwner(): Control | null;
+    abstract guiControlHasFocus(control: Control, visibleOnly?: boolean): boolean;
+    abstract guiIsDragging(): boolean;
+    abstract guiGetDragData(): unknown;
+    abstract guiIsDragSuccessful(): boolean;
+    abstract guiCancelDrag(): void;
+    abstract cancelPointerInput(): void;
+    abstract cancelPointerPress(control: Control, touchIndex: number): void;
+    abstract grabControlFocus(control: Control, hideFocus?: boolean): void;
+    abstract grabControlClickFocus(control: Control): void;
+    abstract releaseControlFocus(control?: Control): void;
+    abstract warpControlMouse(position: Vector2): void;
+    abstract updateMouseCursorState(): void;
+    abstract controlStateChanged(control: Control): void;
+    abstract controlRemoved(control: Control): void;
+    abstract controlTreeChanged(): void;
+    abstract popupControl(control: Control, source: Control | null, position: Vector2): void;
+    abstract closePopupControl(control: Control): void;
+}
+export {};