@gjsify/adwaita-web 0.53.0 → 0.55.0

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;
+}

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

@@ -0,0 +1,154 @@
+/** `GtkStackTransitionType`, spelled as the GIR's enum nicks (gtkstack.c:95-121). */
+export type StackTransitionType = 'none' | 'crossfade' | 'slide-right' | 'slide-left' | 'slide-up' | 'slide-down' | 'slide-left-right' | 'slide-up-down' | 'over-up' | 'over-down' | 'over-left' | 'over-right' | 'under-up' | 'under-down' | 'under-left' | 'under-right' | 'over-up-down' | 'over-down-up' | 'over-left-right' | 'over-right-left' | 'rotate-left' | 'rotate-right' | 'rotate-left-right';
+/** The browser's page descriptor — the stand-in for the `GtkStackPage` GObject. */
+export interface GtkStackPageInfo {
+    /** `GtkStackPage:name`, `''` for a page with no `name` attribute. */
+    name: string;
+    /** `GtkStackPage:title` — `null` when absent, which is C's NULL and means NO label. */
+    title: string | null;
+    /** `GtkStackPage:icon-name` — `null` when absent. */
+    iconName: string | null;
+    /** `GtkStackPage:needs-attention`. */
+    needsAttention: boolean;
+    /** `GtkStackPage:use-underline`. */
+    useUnderline: boolean;
+    /** `GtkStackPage:visible` AND `GtkWidget:visible` — the child's `hidden` attribute. */
+    visible: boolean;
+    /** `GtkStackPage:child`: the page's own node. */
+    child: HTMLElement;
+}
+export declare class GtkStack extends HTMLElement {
+    /** The child that is visible, or `null` — C's `priv->visible_child`. */
+    private _visible;
+    /** C's `priv->last_visible_child`: the page being animated away. */
+    private _lastVisible;
+    private _initialized;
+    private _initializedChildren;
+    private _observer;
+    private _timer;
+    private _running;
+    static get observedAttributes(): string[];
+    /** `Gtk.Stack:visible-child-name` — the name of the visible child. */
+    get visibleChildName(): string | null;
+    set visibleChildName(v: string | null);
+    /**
+     * `Gtk.Stack:visible-child` as the browser can spell it: the visible child ELEMENT
+     * (the C property takes a `Gtk.Widget`, which no attribute can carry). Writes go
+     * through the child's own `name`, so it is `visible-child-name` that is read back.
+     */
+    get visibleChild(): HTMLElement | null;
+    set visibleChild(child: HTMLElement | null);
+    /** `Gtk.Stack:transition-type`. An unknown nick reads as `none`, the GIR default. */
+    get transitionType(): StackTransitionType;
+    set transitionType(v: StackTransitionType);
+    /** `Gtk.Stack:transition-duration` in milliseconds. `0` disables the animation. */
+    get transitionDuration(): number;
+    set transitionDuration(v: number);
+    /**
+     * `Gtk.Stack:hhomogeneous` — the same width for every child. Defaults to TRUE
+     * (gtkstack.c:981-987), which is why this one is NOT a boolean attribute: an absent
+     * attribute already means true, so the spelling has to be able to say false.
+     */
+    get hhomogeneous(): boolean;
+    set hhomogeneous(v: boolean);
+    /** `Gtk.Stack:vhomogeneous` — the same height for every child. Defaults to TRUE. */
+    get vhomogeneous(): boolean;
+    set vhomogeneous(v: boolean);
+    /** `Gtk.Stack:interpolate-size` — let the size change smoothly too. */
+    get interpolateSize(): boolean;
+    set interpolateSize(v: boolean);
+    /** `Gtk.Stack:transition-running` — READ-ONLY; reflected for the stylesheet. */
+    get transitionRunning(): boolean;
+    /**
+     * `Gtk.Stack:pages` — the page descriptors in child order, the browser half of the
+     * `GtkStackPages` selection model (gtkstack.c:698-745).
+     */
+    get pages(): GtkStackPageInfo[];
+    /** `gtk_stack_get_child_by_name` (gtkstack.c:1889-1916), `null` when not found. */
+    getChildByName(name: string): HTMLElement | null;
+    /** `gtk_stack_get_page` (gtkstack.c:1870-1887) as a descriptor, `null` when absent. */
+    getPage(child: HTMLElement): GtkStackPageInfo | null;
+    /** `gtk_stack_pages_is_selected` (gtkstack.c:647-666) for the model this element is. */
+    isSelected(child: HTMLElement): boolean;
+    /** `gtk_stack_add_titled` (gtkstack.c:1644-1663) — append a named, titled child. */
+    addTitled(child: HTMLElement, name: string | null, title?: string | null): HTMLElement;
+    /** `gtk_stack_add_named` (gtkstack.c:1687-1696). */
+    addNamed(child: HTMLElement, name: string | null): HTMLElement;
+    /** `gtk_stack_add_child` (gtkstack.c:1665-1685) — the unnamed form. */
+    addChild(child: HTMLElement): HTMLElement;
+    /**
+     * `gtk_stack_remove` (gtkstack.c:1834-1868), named `removePage` because
+     * `HTMLElement.remove()` already occupies the short spelling — the same rename
+     * `Adw.ViewStack.remove` took in `adw-view-stack.ts`.
+     */
+    removePage(child: HTMLElement): void;
+    /**
+     * `gtk_stack_set_visible_child` (gtkstack.c:2244-2281), with `gtk_stack_set_visible_
+     * child_full`'s per-call transition (gtkstack.c:2306-2334). A child that is not in
+     * this stack, or whose page is not visible, changes nothing — C warns and returns.
+     */
+    setVisibleChild(child: HTMLElement | null, transitionType?: StackTransitionType): boolean;
+    /** `gtk_stack_set_visible_child_name` (gtkstack.c:2283-2304). */
+    setVisibleChildName(name: string | null): boolean;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    /**
+     * The `notify::` detail for `name`: the PROPERTY, parsed, not the raw attribute —
+     * `transition-type` in particular reads as `none` for an unknown nick.
+     */
+    private _property;
+    private _notify;
+    private _write;
+    /** A boolean property that DEFAULTS TO TRUE: absent means true, like C's spec. */
+    private _flag;
+    /**
+     * `Gtk.Stack:transition-duration`, the `g_param_spec_uint` default of 200
+     * (gtkstack.c:1024). An unparseable or negative value is the uint clamp to 0 that
+     * the property's own range produces (gtkstack.c:1051-1060), and 0 is what stops the
+     * transition from starting at all (gtkstack.c:1402-1403).
+     */
+    private _duration;
+    /** The pages, in child order — `priv->children`, never the shadow root. */
+    private _children;
+    /** The page descriptor of one child (gtkstack.c:499-573). */
+    private _page;
+    /** `set_visible_child`'s "pick first visible" scan (gtkstack.c:1437-1450). */
+    private _firstVisible;
+    private _initChild;
+    private _onChildMutations;
+    /** C's NULL page name is an ABSENT attribute, not the empty string (gtkstack.c:2216). */
+    private _nameOrNull;
+    /**
+     * `set_visible_child` (gtkstack.c:1428-1586) reduced to what a browser can decide,
+     * with the guards kept in C's order. Returns whether the visible child changed.
+     */
+    private _show;
+    /**
+     * `gtk_stack_start_transition` (gtkstack.c:1389-1426) with
+     * `get_effective_transition_type` (gtkstack.c:1320-1390) and, for a two-way type,
+     * `get_simple_transition_type` on the page ORDER (gtkstack.c:1539-1561,
+     * :1162-1200). The result is always a SIMPLE type, which is what the stylesheet
+     * keys on — C resolves the two-way pair into one of the one-directional types
+     * before the animation starts, and so does this.
+     */
+    private _startTransition;
+    /**
+     * `i_first` (gtkstack.c:1548-1557): whether the incoming page was ADDED EARLIER than
+     * the outgoing one. C walks the children from the start and breaks on whichever it
+     * meets first, so the answer is a comparison of positions.
+     */
+    private _newChildFirst;
+    /** `get_effective_transition_type` (gtkstack.c:1320-1390): reduced motion, then RTL. */
+    private _effectiveType;
+    /** `gtk_widget_get_settings`'s `gtk-interface-reduced-motion`, read from the media query. */
+    private _reducedMotion;
+    /**
+     * The render pass: which page is visible, which is animating out, and the two
+     * `aria-hidden` states GTK raises on the PAGES (gtkstack.c:1526-1532, :1543-1547,
+     * :1610-1613). `hidden` is never written — it is the author's own
+     * `GtkStackPage:visible`, and overwriting it would destroy the distinction C keeps
+     * between the page flag and the widget's own visibility.
+     */
+    private _render;
+}

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

@@ -13,9 +13,12 @@ export declare class GtkSwitch extends HTMLElement {
      */
     get unfocusable(): boolean;
     set unfocusable(value: boolean);
-    /** Whether the switch is on. */
+    /** Whether the user put the switch ON. Drives the knob. */
     get active(): boolean;
     set active(value: boolean);
+    /** `Gtk.Switch:state` — what the switched thing currently is. Drives the trough. */
+    get state(): boolean;
+    set state(value: boolean);
     /** Whether the switch is inert. */
     get disabled(): boolean;
     set disabled(value: boolean);

package/lib/types/elements/gtk-text-view.d.ts

@@ -0,0 +1,62 @@
+import { type LabelJustification } from '@gjsify/adwaita-core';
+/** `Gtk.WrapMode`'s four nicks, in enum order — Pango's enum, and the DEFAULT is `none`. */
+declare const WRAP_MODES: readonly ["none", "char", "word", "word-char"];
+type TextViewWrapMode = (typeof WRAP_MODES)[number];
+export declare class GtkTextView extends HTMLElement {
+    private _area;
+    private _initialized;
+    static get observedAttributes(): string[];
+    /** The buffer's text — the light-DOM text of the element, then whatever is typed. */
+    get text(): string;
+    set text(value: string);
+    /** `Gtk.TextView:editable` — defaults TRUE, so the attribute carries a VALUE. */
+    get editable(): boolean;
+    set editable(value: boolean);
+    /** `Gtk.TextView:wrap-mode` — where a line may break. Defaults to `none`, no wrapping. */
+    get wrapMode(): TextViewWrapMode;
+    set wrapMode(value: TextViewWrapMode);
+    /** `Gtk.TextView:justification` — how the lines align with each other. Defaults `left`. */
+    get justification(): LabelJustification;
+    set justification(value: LabelJustification);
+    /** `Gtk.TextView:monospace` — whether the text is drawn in a monospace font. */
+    get monospace(): boolean;
+    set monospace(value: boolean);
+    /** `Gtk.TextView:accepts-tab` — whether Tab inserts a tab character. Defaults TRUE. */
+    get acceptsTab(): boolean;
+    set acceptsTab(value: boolean);
+    /** `Gtk.TextView:cursor-visible` — whether the insertion cursor is drawn. Defaults TRUE. */
+    get cursorVisible(): boolean;
+    set cursorVisible(value: boolean);
+    /** `Gtk.TextView:top-margin` — pixels of blank space above the text, in `padding`. */
+    get topMargin(): number;
+    set topMargin(value: number);
+    /** `Gtk.TextView:bottom-margin` — pixels of blank space below the text. */
+    get bottomMargin(): number;
+    set bottomMargin(value: number);
+    /** `Gtk.TextView:left-margin` — pixels of blank space to the left of the text. */
+    get leftMargin(): number;
+    set leftMargin(value: number);
+    /** `Gtk.TextView:right-margin` — pixels of blank space to the right of the text. */
+    get rightMargin(): number;
+    set rightMargin(value: number);
+    /** The inner native textarea, for focus and selection. */
+    get textarea(): HTMLTextAreaElement;
+    connectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    private _render;
+    /** The buffer's text before the inner control exists: the light-DOM text, or the attribute. */
+    private _seedText;
+    /**
+     * `Gtk.TextBuffer:changed`, the signal a text view's edits travel on. The buffer is a
+     * separate GObject here (its text is the element's), so its `changed` is the one event
+     * this widget has to re-emit.
+     */
+    private _emitChanged;
+    /** A boolean pspec read the way its default decides an attribute can spell it. */
+    private _bool;
+    /** {@link _bool}'s writer: the pspec default is left unwritten, anything else is written. */
+    private _setBool;
+    /** A pixel margin, floored at 0 like every `g_param_spec_int` with a zero minimum. */
+    private _margin;
+}
+export {};

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

@@ -0,0 +1,45 @@
+export declare class GtkText extends HTMLElement {
+    private _input;
+    private _initialized;
+    private _maxLength;
+    static get observedAttributes(): string[];
+    /** `Gtk.Editable:text` — the buffer's contents, which is what the field shows. */
+    get text(): string;
+    set text(value: string);
+    /** `Gtk.Editable:editable` — defaults TRUE, so the attribute carries a VALUE. */
+    get editable(): boolean;
+    set editable(value: boolean);
+    /** `Gtk.Text:placeholder-text` — shown while the field is empty and unfocused. */
+    get placeholderText(): string;
+    set placeholderText(value: string);
+    /** `Gtk.Text:max-length` — 0 means unlimited. Counted in CODE POINTS. */
+    get maxLength(): number;
+    set maxLength(value: number);
+    /** `Gtk.Text:visibility` — FALSE masks the contents (the "password mode"). Defaults TRUE. */
+    get visibility(): boolean;
+    set visibility(value: boolean);
+    /**
+     * `Gtk.Text:propagate-text-width` — whether the widget grows and shrinks with its
+     * content. GTK re-measures the Pango layout on every insertion and deletion while it
+     * is set (gtktext.c:2588-2600,3605-3607,3639-3640); a native input has the same
+     * mechanism, its `size`, which is why this is a real mapping and not a measurement.
+     */
+    get propagateTextWidth(): boolean;
+    set propagateTextWidth(value: boolean);
+    /** `gtk_text_get_text_length` — code points, not UTF-16 units. */
+    get textLength(): number;
+    /** The inner native input, for focus and selection. */
+    get input(): HTMLInputElement;
+    connectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    private _render;
+    /**
+     * `text[.read-only]` (gtktext.c:155-167) is the node class a read-only text carries,
+     * and libadwaita never styles it — it is a selector hook. GTK's own `set_editable`
+     * adds the class on the way TO editable (gtktext.c:5762-5767), which is the inverse of
+     * what the node documentation above it describes; the DOCUMENTED rule is what a node
+     * author can rely on, so that is the one applied here.
+     */
+    private _reflectReadOnly;
+    private _resizeToText;
+}

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

@@ -0,0 +1,45 @@
+import type { DispatchedSignals } from '../signals.js';
+import { GtkButton } from './gtk-button.js';
+export declare class GtkToggleButton extends GtkButton {
+    static readonly signals: DispatchedSignals;
+    private _wired;
+    /** The other end of the group link, both halves of `GtkToggleButtonPrivate`. */
+    private _groupNext;
+    private _groupPrev;
+    /** Guards the `group` property ↔ attribute loop, as `gtk-popover` guards its `open`. */
+    private _reflectingGroup;
+    static get observedAttributes(): string[];
+    /** Whether the button is pressed in. */
+    get active(): boolean;
+    set active(value: boolean);
+    /**
+     * `Gtk.ToggleButton:group` — the button this one joins, or `null` to leave the group.
+     *
+     * `G_PARAM_WRITABLE` upstream (:310-313), so there is deliberately NO getter: the
+     * member's own links are the state, and reading them back is not what GTK offers.
+     */
+    set group(value: GtkToggleButton | null);
+    /** Whether this button has at least one group link — `group_prev || group_next`. */
+    private get _grouped();
+    connectedCallback(): void;
+    attributeChangedCallback(name?: string): void;
+    /**
+     * `gtk_toggle_button_set_group` — insert this button DIRECTLY BEFORE `group`, or
+     * unlink it when `group` is null. The three arms are the C's, in order.
+     */
+    private _setGroup;
+    /**
+     * Release every OTHER member of the group — `get_group_first()` walked backwards,
+     * then the chain forwards, skipping this one (:426-434).
+     */
+    private _clearGroup;
+    /**
+     * `get_group_first` (:242-262) — the walk backwards along `group_prev`.
+     *
+     * Written as recursion rather than a loop accumulator so no local ever holds `this`,
+     * which the walk does not need: the C's `g_assert (group_first)` is its proof that the
+     * walk terminates on a member, and the same proof is the `depth` guard here.
+     */
+    private _groupFirst;
+    protected decorate(button: HTMLButtonElement): void;
+}

package/lib/types/elements/gtk-tree-expander.d.ts

@@ -0,0 +1,38 @@
+import { type AdwTreeExpanderLayout } from '@gjsify/adwaita-core';
+export declare class GtkTreeExpander extends HTMLElement {
+    private _ornaments;
+    private _expandTimer;
+    private _initialized;
+    static get observedAttributes(): string[];
+    get hideExpander(): boolean;
+    set hideExpander(value: boolean);
+    /** Default TRUE (gtktreeexpander.c:750), so only the literal `false` turns it off. */
+    get indentForDepth(): boolean;
+    set indentForDepth(value: boolean);
+    /** Default TRUE (gtktreeexpander.c:749), read the same way as `indent-for-depth`. */
+    get indentForIcon(): boolean;
+    set indentForIcon(value: boolean);
+    /** The row's depth — 0 at the root, as `gtk_tree_list_row_get_depth` reports it. */
+    get depth(): number;
+    set depth(value: number);
+    get expandable(): boolean;
+    set expandable(value: boolean);
+    get expanded(): boolean;
+    set expanded(value: boolean);
+    /** What this expander draws, as counts — `treeExpanderLayout`'s answer for it. */
+    get layout(): AdwTreeExpanderLayout;
+    connectedCallback(): void;
+    /** The listeners, installed once — they sit on the element, so a re-parent keeps them. */
+    private _wire;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name?: string): void;
+    private _cancelExpandTimer;
+    /**
+     * Rebuild the indents and the expander in front of the child.
+     *
+     * Every ornament is dropped and rebuilt rather than diffed: there are at most
+     * depth + 1 of them, they hold no state and no focus, and a diff over two kinds of
+     * node is where the leaf/expandable transition would go wrong.
+     */
+    private _render;
+}