@gjsify/adwaita-web 0.54.0 → 0.56.0

package/lib/types/elements/gtk-scrollbar.d.ts

@@ -0,0 +1,124 @@
+import { type AdwAdjustment, type AdwAdjustmentInput, type BoxOrientation } from '@gjsify/adwaita-core';
+/** `GtkScrollType`'s six kinds, which is what a `scroll-child` names. */
+export type GtkScrollType = 'step-backward' | 'step-forward' | 'page-backward' | 'page-forward' | 'start' | 'end';
+export declare class GtkScrollbar extends HTMLElement {
+    private _trough;
+    private _slider;
+    private _observer;
+    private _built;
+    private _adjustment;
+    /** `priv->slide_initial_slider_position` — the slider's position when the drag began. */
+    private _grabPosition;
+    /** `priv->slide_initial_coordinate_delta` — how far into the slider the pointer was. */
+    private _grabDelta;
+    /** `priv->zoom` — the fine adjustment, `.fine-tune` and all. */
+    private _zoom;
+    private _dragging;
+    static get observedAttributes(): string[];
+    /** `GtkOrientable:orientation` — HORIZONTAL in `gtk_scrollbar_init`; unknown is that. */
+    get orientation(): BoxOrientation;
+    set orientation(value: BoxOrientation);
+    /**
+     * `GtkScrollbar:adjustment` — the range this bar moves, as the portable value.
+     *
+     * NEVER `null`, which is the half of this property that is easy to get wrong: GTK's
+     * pspec default is NULL, but `gtk_range_set_adjustment` answers a NULL with the ZERO
+     * adjustment (gtkrange.c:687-688) and `gtk_range_get_adjustment` creates it on demand
+     * (gtkrange.c:658-659), so a bare `GtkScrollbar` reads back a real adjustment whose
+     * `upper` is 0. A read that could return null would be a property GTK's own does not
+     * have, and the slider geometry would have to carry a second "nothing here" case.
+     *
+     * A string is read as the JSON the attribute carries, so the property and the
+     * attribute are one write; a partial object MERGES, which is
+     * `gtk_adjustment_configure`'s own contract (gtkadjustment.c). Assigning `null` is
+     * `gtk_scrollbar_set_adjustment (self, NULL)`: the zero adjustment again, and the
+     * property is assigned rather than merged.
+     */
+    get adjustment(): AdwAdjustment;
+    set adjustment(value: AdwAdjustmentInput | string | null);
+    /** The position, which is the adjustment's own value (gtkrange.c:1168-1176). */
+    get value(): number;
+    /**
+     * `gtk_adjustment_set_value`: move the range, clamped, and announce it.
+     *
+     * A scrollbar is a VIEW of an adjustment it does not own, so the `value-changed`
+     * CustomEvent (bubbles, detail `{ adjustment }`) stands for `GtkAdjustment`'s signal —
+     * and `<gtk-scrolled-window>` is what listens, exactly as GTK reads the adjustment off
+     * the scrollbar it owns (`gtk_scrolled_window_scroll_child`, gtkscrolledwindow.c:3007).
+     *
+     * Over the zero adjustment `set_value` CLAMPS to 0 and reports no change, so a bar with
+     * no adjustment of its own is inert without being a special case anywhere.
+     */
+    set value(value: number);
+    /**
+     * The value one `GtkScrollType` moves by, which is `gtk_scrolled_window_scroll_child`'s
+     * switch.
+     *
+     * `scrollBy` is a platform method with a delta form, so both are here and the KIND of the
+     * argument decides — a `GtkScrollType` nick moves the adjustment, a number or a
+     * `ScrollToOptions` is the scrollport's own call, which a bar has none of (it is not a
+     * scrollport) and which therefore lands on no adjustment and does nothing.
+     */
+    scrollBy(kind: GtkScrollType): void;
+    scrollBy(options?: ScrollToOptions): void;
+    scrollBy(x: number, y: number): void;
+    /** How far a wheel detent moves the value: `scroll_delta_to_value` on a WHEEL unit. */
+    scrollByWheel(deltaY: number, deltaMode: number): void;
+    /**
+     * `gtk_range_get_range_area`-ish: the length of the trough, which is what the slider
+     * is a fraction of. Read on demand so a caller can scale with the same numbers.
+     */
+    private get _troughLength();
+    connectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    private _notify;
+    /**
+     * The trough's three rules and the slider's drag, at the settings default
+     * (`gtk_range_click_gesture_pressed`, gtkrange.c:2018-2138).
+     */
+    private _onPointerDown;
+    /**
+     * `update_slider_position`: the pointer's travel since the grab, scaled by the zoom,
+     * added to where the slider WAS — so the slider keeps the offset it was grabbed at.
+     */
+    private _onPointerMove;
+    private _onPointerEnd;
+    private _endDrag;
+    /**
+     * Keep the gesture alive past the bar's own edges, which is what `GtkGestureDrag` does
+     * upstream for as long as the button is held.
+     *
+     * `setPointerCapture` THROWS for a pointer id the platform is no longer tracking, and an
+     * exception here would abort the gesture before the warp or the page that follows it —
+     * which is not a state a scrollbar can be in. So a refused capture is a drag that ends at
+     * the bar's edge, and the synchronous move still happens.
+     */
+    private _capture;
+    /** The keys `GtkScrollbar`'s own doc names: the arrow keys step, Page Up/Down page. */
+    private _onKeyDown;
+    private _onWheel;
+    private _setZoom;
+    /** `update_slider_position`'s zoom: the trough per unit of range, or the fallback. */
+    private _zoomFactor;
+    /**
+     * `gtk_range_compute_slider_position`, in CSS pixels.
+     *
+     * The slider's length is a fraction of the WHOLE adjustment range and its position a
+     * fraction of the SCROLLABLE one, which is why the two denominators differ and why
+     * neither is a plain percentage of the trough. A range with nothing to scroll is the
+     * `trough_length == slider_length` case upstream and answers 1.0.
+     */
+    private _render;
+    /** Where the slider's START is along the trough, in pixels. */
+    private _sliderPosition;
+    /** The slider's own length, in pixels, from the last layout. */
+    private _sliderSize;
+    /**
+     * `coord_to_value` (gtkrange.c:1842-1886): a coordinate along the trough scaled by the
+     * FREE space — the trough less the slider — because the slider's centre has to reach
+     * both ends and not one of them twice over.
+     */
+    private _coordinateValue;
+    /** The pointer's coordinate along the trough, from the trough's own box. */
+    private _coordinate;
+}

package/lib/types/elements/gtk-scrolled-window.d.ts

@@ -0,0 +1,129 @@
+import type { GtkViewport } from './gtk-viewport.js';
+/** `GtkPolicyType`'s four nicks; `automatic` is the pspec's default for both bars. */
+export type GtkPolicyType = 'always' | 'never' | 'automatic' | 'external';
+/** `GtkCornerType`'s four corners, `top-left` being the pspec's default. */
+export type GtkCornerType = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+/** `Gtk.PositionType`'s four edges, as `edge-reached` and `edge-overshot` name them. */
+export type GtkPositionType = 'left' | 'right' | 'top' | 'bottom';
+/** `Gtk.DirectionType`'s two, as `move-focus-out` names them. */
+export type GtkDirectionType = 'forward' | 'backward';
+export declare class GtkScrolledWindow extends HTMLElement {
+    private _viewport;
+    private _bars;
+    /** The size clamps `_writeSize` last wrote, which are the only ones it may clear. */
+    private readonly _wroteSizes;
+    private _shading;
+    private _observer;
+    private _hoverable;
+    private _fadeTimer;
+    private _built;
+    static get observedAttributes(): string[];
+    /** `GtkScrolledWindow:hscrollbar-policy` — `automatic` in the pspec. */
+    get hscrollbarPolicy(): GtkPolicyType;
+    set hscrollbarPolicy(value: GtkPolicyType);
+    /** `GtkScrolledWindow:vscrollbar-policy` — `automatic` in the pspec. */
+    get vscrollbarPolicy(): GtkPolicyType;
+    set vscrollbarPolicy(value: GtkPolicyType);
+    /** `GtkScrolledWindow:window-placement` — where the contents sit against the bars. */
+    get windowPlacement(): GtkCornerType;
+    set windowPlacement(value: GtkCornerType);
+    /** `GtkScrolledWindow:has-frame` — the `.frame` style class on the node, and nothing more. */
+    get hasFrame(): boolean;
+    set hasFrame(value: boolean);
+    /** `GtkScrolledWindow:overlay-scrolling` — TRUE in the pspec, and unknown is that. */
+    get overlayScrolling(): boolean;
+    set overlayScrolling(value: boolean);
+    /** `GtkScrolledWindow:min-content-width`, in px, or `null` for the pspec's -1. */
+    get minContentWidth(): number | null;
+    set minContentWidth(value: number | null);
+    /** `GtkScrolledWindow:min-content-height`, in px, or `null` for the pspec's -1. */
+    get minContentHeight(): number | null;
+    set minContentHeight(value: number | null);
+    /** `GtkScrolledWindow:max-content-width`, in px, or `null` for the pspec's -1. */
+    get maxContentWidth(): number | null;
+    set maxContentWidth(value: number | null);
+    /** `GtkScrolledWindow:max-content-height`, in px, or `null` for the pspec's -1. */
+    get maxContentHeight(): number | null;
+    set maxContentHeight(value: number | null);
+    /** `GtkScrolledWindow:propagate-natural-width` — FALSE in the pspec, so absent is that. */
+    get propagateNaturalWidth(): boolean;
+    set propagateNaturalWidth(value: boolean);
+    /** `GtkScrolledWindow:propagate-natural-height` — FALSE in the pspec, so absent is that. */
+    get propagateNaturalHeight(): boolean;
+    set propagateNaturalHeight(value: boolean);
+    /**
+     * `gtk_scrolled_window_get_hscrollbar` / `get_vscrollbar`, as METHODS and not getters.
+     *
+     * `connect-lifecycle.spec.ts` reads a get-only accessor returning an element as an
+     * invitation to append into it, and a scrollbar that is not visible is not an append
+     * point — which is the whole of what a getter here would be asking for.
+     */
+    hscrollbar(): HTMLElement | null;
+    vscrollbar(): HTMLElement | null;
+    /** The `<gtk-viewport>` the child sits in — the one GTK's `set_child` builds for itself. */
+    get viewport(): GtkViewport;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    /** The NORMALISED value a notify carries, which is the property and not the raw attribute. */
+    private _normalized;
+    private _writeSizeRequest;
+    /**
+     * `priv->use_indicators` — the AND of the property with the `gtk-overlay-scrolling`
+     * setting, whose browser spelling is whether a pointer that can hover exists at all.
+     */
+    private get _useIndicators();
+    /** Everything the pspec's own state decides: the classes, the bars, the sizes. */
+    private _sync;
+    /**
+     * One of the four clamps as inline style. An unwritten clamp clears only what THIS element
+     * wrote: `min-width` / `min-height` are also where a tree's `width-request` /
+     * `height-request` land (`GTK_WIDGET_SIZE_CSS`), and assigning '' unconditionally erased it.
+     * Where both are set the content clamp wins, which is the one the widget measures itself.
+     */
+    private _writeSize;
+    /** The viewport's adjustment for one axis, which is where GTK reads the scrollbar's. */
+    private _adjustment;
+    /**
+     * `may_hscroll` / `may_vscroll`: a bar that is DRAWN, or an EXTERNAL policy, which is a
+     * scrollbar this window does not show but can still be driven with.
+     */
+    private _mayScroll;
+    /**
+     * The viewport moved: hand the position to the bars, ask whether an edge was REACHED
+     * (`maybe_emit_edge_reached` fires whenever the adjustment lands exactly on `lower` or
+     * `upper - page_size`, gtkscrolledwindow.c:3629-3661) and fade the indicators in.
+     */
+    private _onViewportValue;
+    /**
+     * A bar moved: move the scrollport. GTK's direction is the other way round — the
+     * adjustment belongs to the scrollbar and the scrolled window reads it — which is why
+     * the bar is given the adjustment here instead of owning it: the numbers are the same
+     * either way, and one writer per side is what keeps them from fighting.
+     */
+    private _onBarValue;
+    private _edgeReached;
+    /**
+     * `_gtk_scrolled_window_set_adjustment_value`'s `EDGE_OVERSHOT`, from the shading
+     * controller's unclamped position: negative is the near edge, positive the far one,
+     * and `0` is the settled case the C returns without emitting — it is the value CLAMPED
+     * to `lower - MAX_OVERSHOOT_DISTANCE` and `upper - page_size + MAX_OVERSHOOT_DISTANCE`
+     * that the signal compares (gtkscrolledwindow.c:3306-3352).
+     */
+    private _edgeOvershot;
+    /** The keys of `gtk_scrolled_window_class_init`, and the two signals they emit. */
+    private _onKeyDown;
+    /**
+     * `indicator_start_fade(indicator, 1.0)` on every value change, and
+     * `maybe_hide_indicator`'s check `INDICATOR_FADE_OUT_DELAY` after the last one — a poll
+     * upstream, one timer here, and `!indicator->over` is the `.hovering` class (a pointer
+     * over the indicator holds it open).
+     */
+    private _fadeIn;
+    private _fadeOut;
+    private _clearFade;
+    private _onIndicatorOver;
+    private _onIndicatorOut;
+    private _onHoverableChange;
+    private _releaseHoverable;
+}

package/lib/types/elements/gtk-search-bar.d.ts

@@ -0,0 +1,39 @@
+export declare class GtkSearchBar extends HTMLElement {
+    private _box;
+    private _center;
+    private _close;
+    private _initialized;
+    private _capture;
+    private readonly _onCapturedKey;
+    private readonly _onInput;
+    static get observedAttributes(): string[];
+    /** `Gtk.SearchBar:search-mode-enabled` — the revealer's `reveal-child`. Defaults FALSE. */
+    get searchModeEnabled(): boolean;
+    set searchModeEnabled(value: boolean);
+    /** `Gtk.SearchBar:show-close-button` — the `.close` button at the end of the box. */
+    get showCloseButton(): boolean;
+    set showCloseButton(value: boolean);
+    /** `Gtk.SearchBar:key-capture-widget` — where printable keys start a search. */
+    get keyCaptureWidget(): HTMLElement | null;
+    set keyCaptureWidget(widget: HTMLElement | null);
+    /** The editable the C's `connect_entry` would have bound: the first field inside the bar. */
+    get entry(): HTMLInputElement | HTMLTextAreaElement | null;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, _value: string | null): void;
+    private _render;
+    /**
+     * `reveal_child_changed_cb` (gtksearchbar.c:183-205): revealing focuses the entry,
+     * hiding clears it. Run on a real CHANGE only — at init the C's own notify fires before
+     * the handler is connected, so a child that arrives with the bar is left alone.
+     */
+    private _applyReveal;
+    private _revealFromTyping;
+    /**
+     * The key-capture path (gtksearchbar.c:525-556): a printable key on the capture widget
+     * opens the bar and goes into the entry, which is what forwarding the event does in the C.
+     * Modified keys and the functional keys are left alone — GTK forwards them, but a bar
+     * that opened on every arrow key would not be a search bar.
+     */
+    private _captureKey;
+}

package/lib/types/elements/gtk-search-entry.d.ts

@@ -0,0 +1,27 @@
+import { GtkEntry } from './gtk-entry.js';
+export declare class GtkSearchEntry extends GtkEntry {
+    private _searchIcon;
+    private _clear;
+    private _clearIcon;
+    private _timeout;
+    static get observedAttributes(): string[];
+    /** `GtkSearchEntry:search-delay` — ms from the last keypress to `search-changed`. */
+    get searchDelay(): number;
+    set searchDelay(value: number);
+    /** Whether there is text, which is what decides the two icons. */
+    private get _empty();
+    connectedCallback(): void;
+    attributeChangedCallback(name: string, oldValue: string | null, value: string | null): void;
+    disconnectedCallback(): void;
+    /**
+     * `gtk_search_entry_changed` (gtksearchentry.c:776-803) over `reset_timeout`.
+     *
+     * Empty is immediate and cancels; non-empty replaces the queue. `clearTimeout` before
+     * arming is `reset_timeout`'s `g_source_remove`, and without it two keystrokes would
+     * fire the signal twice.
+     */
+    private _onChanged;
+    private _cancel;
+    private _onKeyDown;
+    private _render;
+}

package/lib/types/elements/gtk-separator.d.ts

@@ -0,0 +1,10 @@
+import { type BoxOrientation } from '@gjsify/adwaita-core';
+export declare class GtkSeparator extends HTMLElement {
+    static get observedAttributes(): string[];
+    /** `GtkOrientable:orientation` — `horizontal` (the default) or `vertical`. */
+    get orientation(): BoxOrientation;
+    set orientation(value: BoxOrientation);
+    connectedCallback(): void;
+    attributeChangedCallback(): void;
+    private _render;
+}

package/lib/types/elements/gtk-spin-button.d.ts

@@ -0,0 +1,94 @@
+import type { AdwAdjustment, AdwAdjustmentInput } from '@gjsify/adwaita-core';
+/** `Gtk.SpinButtonUpdatePolicy` nicks; `always` is the pspec default (gtkspinbutton.c:472-475). */
+declare const UPDATE_POLICIES: readonly ["always", "if-valid"];
+export declare class GtkSpinButton extends HTMLElement {
+    private readonly _range;
+    private _input;
+    private _down;
+    private _up;
+    private _initialized;
+    private _edited;
+    /** The orientation the children are CURRENTLY arranged for — see `_render`. */
+    private _vertical;
+    private _initialTimer;
+    private _repeatTimer;
+    private _timerCalls;
+    private _timerStep;
+    static get observedAttributes(): string[];
+    /** The numeric range — `Gtk.SpinButton:adjustment`, as the portable value. Writes MERGE. */
+    get adjustment(): AdwAdjustment;
+    set adjustment(value: AdwAdjustmentInput | string);
+    /** `Gtk.SpinButton:value` — always inside `adjustmentRange`. */
+    get value(): number;
+    set value(v: number);
+    /** `Gtk.SpinButton:digits` — `gtk_spin_button_init` starts it at 0. */
+    get digits(): number;
+    set digits(value: number);
+    /** `Gtk.SpinButton:numeric` — "whether non-numeric characters should be ignored". */
+    get numeric(): boolean;
+    set numeric(value: boolean);
+    /** `Gtk.SpinButton:snap-to-ticks`. */
+    get snapToTicks(): boolean;
+    set snapToTicks(value: boolean);
+    /** `Gtk.SpinButton:wrap` — whether the value wraps at either bound. */
+    get wrap(): boolean;
+    set wrap(value: boolean);
+    /** `Gtk.SpinButton:update-policy` — `always` (the default) or `if-valid`. */
+    get updatePolicy(): (typeof UPDATE_POLICIES)[number];
+    set updatePolicy(value: (typeof UPDATE_POLICIES)[number]);
+    /** `Gtk.SpinButton:climb-rate` — the acceleration of a held arrow. */
+    get climbRate(): number;
+    set climbRate(value: number);
+    /** The inner text node, for a consumer that needs to place a caret in it. */
+    get text(): HTMLInputElement;
+    connectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    /**
+     * `gtk_spin_button_real_spin` (gtkspinbutton.c:1666-1711), the whole of it: the two wrap
+     * branches, the two clamp branches and the `wrapped` signal.
+     *
+     * The clamp itself is `SpinState`'s; what is here is that `wrap` REPLACES it, which is
+     * why this is a method and not `increment()`/`decrement()` on the core state.
+     */
+    private _spin;
+    /**
+     * `gtk_spin_button_update` (gtkspinbutton.c:1795-1832) over
+     * `gtk_spin_button_default_input` (gtkspinbutton.c:1673-1752).
+     *
+     * `update-policy` is the two branches that decide what a bad entry does: `always`
+     * clamps, `if-valid` leaves the field ALONE and re-formats the committed value — which
+     * is the `value_changed` call plus the early return C does at :1820-1824.
+     */
+    private _update;
+    private _commit;
+    /**
+     * `gtk_spin_button_insert_text`'s `numeric` filter (gtkspinbutton.c:1589-1649), applied to
+     * the field's whole text rather than to one insertion — a browser input hands over the
+     * result, not the keystroke. The three refusals C has are the three here: a sign after
+     * the first character, a decimal point when `digits` is 0 or one is already there, and
+     * anything that is not a digit.
+     */
+    private _rejectNonNumeric;
+    /** A refused character drops the WHOLE edit and restores the formatted value, as C does. */
+    private _resetText;
+    /**
+     * The held-arrow repeat, `gtk_spin_button_timer` (gtkspinbutton.c:1374-1407) with the
+     * two constants that shape it.
+     *
+     * The ramp is C's exactly: the step grows by `climb-rate` once every `MAX_TIMER_CALLS`
+     * ticks, and only while it is still below `page-increment`.
+     */
+    private _hold;
+    private _tick;
+    private _stopHold;
+    /**
+     * The keys `GtkSpinButton` takes on the entry (gtkspinbutton.c:1495-1525): the arrows and
+     * Page Up/Down move by the step and the page, and the vertical pair is bound on the
+     * SCROLL controller rather than the keyboard — which is the same "arrows step whatever way
+     * the widget runs" rule `GtkScale` states in its own words.
+     */
+    private _onKeyDown;
+    private _formatted;
+    private _render;
+}
+export {};

package/lib/types/elements/gtk-spinner.d.ts

@@ -0,0 +1,14 @@
+export declare class GtkSpinner extends HTMLElement {
+    private _initialized;
+    static get observedAttributes(): string[];
+    /** `Gtk.Spinner:spinning` — whether the animation runs. Defaults to FALSE (:338-340). */
+    get spinning(): boolean;
+    set spinning(v: boolean);
+    /** `gtk_spinner_start` (gtkspinner.c:373-383): spin, and announce the busy state. */
+    start(): void;
+    /** `gtk_spinner_stop` (gtkspinner.c:391-400). */
+    stop(): void;
+    connectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    private _render;
+}

package/lib/types/elements/gtk-stack-sidebar.d.ts

@@ -0,0 +1,43 @@
+import type { GtkStack } from './gtk-stack.js';
+export declare class GtkStackSidebar extends HTMLElement {
+    private _stack;
+    private _list;
+    private _initialized;
+    private _rows;
+    private readonly _onStackChange;
+    static get observedAttributes(): string[];
+    /** `Gtk.StackSidebar:stack` — the stack this sidebar drives, or null. */
+    get stack(): GtkStack | null;
+    set stack(value: GtkStack | string | null);
+    /** Rebuild the rows by hand, for a consumer that mutated a page in place. */
+    refresh(): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    /** Bind to a stack element (or null). Unbinds the previous one, as `set_stack` does. */
+    setStack(stack: GtkStack | null): void;
+    private _resolve;
+    private _bindStack;
+    private _unbindStack;
+    private _pages;
+    /**
+     * `update_row`'s visibility rule (gtkstacksidebar.c:186): the page is visible AND
+     * carries a title. There is no icon fallback — `update_row` never reads `icon-name`,
+     * which is the one rule where this sidebar and the switcher disagree.
+     */
+    private _visible;
+    private _selectedIndex;
+    /**
+     * An `items-changed` rebuilds the list wholesale (gtkstacksidebar.c:307-311) and a
+     * `selection-changed` does not (:317-338), so the rows are recreated ONLY when the
+     * page COUNT moves.
+     */
+    private _rebuild;
+    private _buildRow;
+    /**
+     * `gtk_stack_sidebar_row_selected` (gtkstacksidebar.c:130-143): a selected row
+     * selects its page. An UNSELECTION is not driven from here — the model is the
+     * authority, exactly as in the switcher.
+     */
+    private _onRowActivated;
+}

package/lib/types/elements/gtk-stack-switcher.d.ts

@@ -0,0 +1,58 @@
+import { type BoxOrientation } from '@gjsify/adwaita-core';
+import type { GtkStack } from './gtk-stack.js';
+export declare class GtkStackSwitcher extends HTMLElement {
+    private _stack;
+    private _initialized;
+    private _nodes;
+    private readonly _onStackChange;
+    static get observedAttributes(): string[];
+    /** `Gtk.StackSwitcher:stack` — the stack this switcher drives, or null. */
+    get stack(): GtkStack | null;
+    set stack(value: GtkStack | string | null);
+    /** `GtkOrientable:orientation` (gtkstackswitcher.c:47). */
+    get orientation(): BoxOrientation;
+    set orientation(v: BoxOrientation);
+    /**
+     * Rebuild the buttons by hand, for a consumer that mutated a page in place. Not
+     * the only path: the stack emits `page-updated` and `items-changed`, and this
+     * element binds both, which is the mechanism C uses (`:311-321`, `:347-355`).
+     */
+    refresh(): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    /** Bind to a stack element (or null). Unbinds the previous one, as `set_stack` does. */
+    setStack(stack: GtkStack | null): void;
+    private _resolve;
+    private _bindStack;
+    private _unbindStack;
+    /**
+     * A button is visible when its page is visible AND the page carries a title or an
+     * icon (gtkstackswitcher.c:200). `visible` false must hide the row, and an absent
+     * title with no icon leaves the button childless — `rebuild_child` builds nothing
+     * for it (`:158-176`).
+     */
+    private _visible;
+    /**
+     * The pages, in the order the stack holds them. A stack that is not upgraded has no
+     * `pages` getter, which is why it is read defensively.
+     */
+    private _pages;
+    /** Which page the stack has selected, by position, `-1` for none. */
+    private _selectedIndex;
+    /**
+     * `items_changed_cb` rebuilds everything (gtkstackswitcher.c:347-355) and a
+     * `selection_changed_cb` does not — so the nodes are recreated ONLY when the page
+     * COUNT moves, and a selection change re-marks them in place (:359-381). Replacing
+     * a button mid-interaction would also drop keyboard focus.
+     */
+    private _rebuild;
+    private _buildButton;
+    private _onToggled;
+    /**
+     * The orientation attribute is the GIR property's own spelling (gtkstackswitcher.c:47)
+     * and the stylesheet selects on it directly, so there is nothing to mirror onto a
+     * second attribute; this hook exists so the render pass has one entry point.
+     */
+    private _render;
+}