@gjsify/adwaita-web 0.53.0 → 0.55.0

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

@@ -0,0 +1,59 @@
+import { type BoxOrientation } from '@gjsify/adwaita-core';
+/** `GtkLevelBarMode`, spelled as the GIR's enum nicks (:1004-1008). */
+type LevelBarMode = 'continuous' | 'discrete';
+export declare class GtkLevelBar extends HTMLElement {
+    private _trough;
+    private _initialized;
+    /** Offset name → value, kept sorted ascending exactly as the C's `GList` is. */
+    private _offsets;
+    static get observedAttributes(): string[];
+    /** `Gtk.LevelBar:value` — the filled level. */
+    get value(): number;
+    set value(v: number);
+    /** `Gtk.LevelBar:min-value` — the low end of the interval. Defaults to 0. */
+    get minValue(): number;
+    set minValue(v: number);
+    /** `Gtk.LevelBar:max-value` — the high end of the interval. Defaults to 1. */
+    get maxValue(): number;
+    set maxValue(v: number);
+    /** `Gtk.LevelBar:mode` — one filled block, or one per unit of the interval. */
+    get mode(): LevelBarMode;
+    set mode(v: LevelBarMode);
+    /** `Gtk.LevelBar:inverted` — grow from the far end. */
+    get inverted(): boolean;
+    set inverted(v: boolean);
+    /** `GtkOrientable:orientation` (gtklevelbar.c:825-835). Horizontal fills rightwards. */
+    get orientation(): BoxOrientation;
+    set orientation(v: BoxOrientation);
+    /**
+     * `setAttribute` runs the custom-element reaction for a write that changes nothing,
+     * while every GObject setter here returns early when the value is already right
+     * (gtklevelbar.c:1186-1187, :1224-1225, :1300-1301, :1260-1261). This is the guard
+     * that makes "notify only on a real change" true for the numeric and enum half.
+     */
+    private _write;
+    get disabled(): boolean;
+    set disabled(v: boolean);
+    /**
+     * `gtk_level_bar_add_offset_value` (gtklevelbar.c:1395-1411): replaces the value of
+     * an offset of the same name, keeps the list sorted, refuses a value outside the
+     * interval (`g_return_if_fail (gtk_level_bar_value_in_interval (…))`, :1403), and
+     * emits `offset-changed` — but only when the value actually moved (:259-260).
+     */
+    addOffsetValue(name: string, value: number): void;
+    /** `gtk_level_bar_remove_offset_value` (gtklevelbar.c:1362-1377). */
+    removeOffsetValue(name: string): void;
+    /** `gtk_level_bar_get_offset_value` (gtklevelbar.c:1423-1443) — `null` when absent. */
+    offsetValue(name: string): number | null;
+    connectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    private _notify;
+    /** One interval endpoint CLAMPS every offset into the new range — the other does not. */
+    private _clampOffsets;
+    /** The `notify::` detail for `name`: the PROPERTY, parsed, not the raw attribute. */
+    private _property;
+    private _render;
+    /** One `block` node, `filled` or `empty`, wearing the offset's class (:635-652). */
+    private _block;
+}
+export {};

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

@@ -0,0 +1,29 @@
+import { GtkButton } from './gtk-button.js';
+export declare class GtkLinkButton extends GtkButton {
+    private _wired;
+    static get observedAttributes(): string[];
+    /** `Gtk.LinkButton:uri` — the address this button points at. */
+    get uri(): string;
+    set uri(value: string);
+    /**
+     * `Gtk.LinkButton:visited` — whether the link has been followed. The state flag
+     * GTK swaps here is what the stylesheet paints as `:visited`, and the `VISITED`
+     * accessibility state beside it; see the header.
+     */
+    get visited(): boolean;
+    set visited(value: boolean);
+    connectedCallback(): void;
+    attributeChangedCallback(name?: string): void;
+    /**
+     * `::activate-link` — cancelable, because the signal is a boolean accumulator
+     * (gtklinkbutton.c:216-238) and `preventDefault()` is the DOM spelling of a handler
+     * returning TRUE. Nothing cancelled ⇒ the default handler runs.
+     */
+    private _activateLink;
+    /**
+     * The launcher call, on its own method so a caller (or a spec) can stand in for the
+     * window the desktop would have opened.
+     */
+    protected launch(uri: string): void;
+    protected decorate(button: HTMLButtonElement): void;
+}

package/lib/types/elements/gtk-list-box-row.d.ts

@@ -0,0 +1,54 @@
+export declare class GtkListBoxRow extends HTMLElement {
+    private _contentsEl;
+    private _activation?;
+    private _initialized;
+    static get observedAttributes(): string[];
+    /**
+     * `GtkListBoxRow:activatable` — TRUE by default (gtklistbox.c:3961), so this is the OFF
+     * switch and the attribute is read as `activatable="false"`.
+     */
+    get activatable(): boolean;
+    set activatable(value: boolean);
+    /**
+     * `GtkListBoxRow:selectable` — TRUE by default (gtklistbox.c:3962), read the same way as
+     * `activatable`.
+     */
+    get selectable(): boolean;
+    set selectable(value: boolean);
+    /** Where this row sits in its box, or -1 while it has no box. */
+    get index(): number;
+    /**
+     * Whether this row is selected — `gtk_list_box_row_is_selected`, answered by the parent so
+     * a row moved between boxes never carries a stale answer.
+     */
+    get selected(): boolean;
+    /** `GtkListBoxRow:child`, as the light-DOM child it already is. */
+    get child(): Element | null;
+    connectedCallback(): void;
+    /**
+     * Hand this row's `.activatable` class and tab stop to its box.
+     *
+     * Both are the box's to derive and neither is derivable here: `can_select` is the BOX's
+     * `selection-mode` (gtklistbox.c:3606-3609) and the tab stop is `GtkListBox:tab-behavior`,
+     * where `all` gives every activatable row its own stop and `item`/`cell` hand out a
+     * roving one — the split `gtk_list_box_focus` draws by walking rows between Tab presses
+     * only under `GTK_LIST_TAB_ALL` (gtklistbox.c:2037, :2067). The keys stay the row's:
+     * Enter and Space are `GtkListBoxRow`'s own (see `row-activation.ts`).
+     */
+    claim(): void;
+    /** Give the row back to itself, for a box that no longer manages it. */
+    release(): void;
+    /** What the box last said about itself; TRUE until a box narrows it. */
+    private _canSelect;
+    /** Set by {@link claim}. While it is set the row derives neither class nor tab stop. */
+    private _claimed;
+    attributeChangedCallback(): void;
+    /**
+     * Re-derive the tab stop and the `.activatable` class.
+     *
+     * Public because the box owns the second half of the class rule — it knows
+     * `selection-mode`, this row does not — and calls this for every row when that changes.
+     */
+    syncClasses(canSelect: boolean): void;
+    private _syncActivation;
+}

package/lib/types/elements/gtk-list-box.d.ts

@@ -0,0 +1,100 @@
+import { type AdwBoxSelectionMode } from '@gjsify/adwaita-core';
+import type { GtkListBoxRow } from './gtk-list-box-row.js';
+import './gtk-list-box-row.js';
+/** `GtkListTabBehavior`'s nicks — `cell` behaves as `item` outside a cell-based box. */
+export type GtkListTabBehavior = 'all' | 'item' | 'cell';
+/** An unknown nick is `all`, the ParamSpec's default (gtklistbox.c:574-578). */
+export declare function normalizeListTabBehavior(raw: string | null | undefined): GtkListTabBehavior;
+export declare class GtkListBox extends HTMLElement {
+    private _rows;
+    private _selection;
+    /** `box->selected_row`, `-1` for the C's NULL. */
+    private _anchor;
+    private _initialized;
+    static get observedAttributes(): string[];
+    /** `GtkListBox:selection-mode` — the four `Gtk.SelectionMode` values. */
+    get selectionMode(): AdwBoxSelectionMode;
+    set selectionMode(value: AdwBoxSelectionMode);
+    /** Default TRUE (gtklistbox.c:543), so the attribute is the OFF switch. */
+    get activateOnSingleClick(): boolean;
+    set activateOnSingleClick(value: boolean);
+    /**
+     * `GtkListBox:accept-unpaired-release` — FALSE by default (gtklistbox.c:552-553).
+     *
+     * Upstream this decides whether a press followed by a release somewhere else still
+     * activates the row under the press (:1922-1935). A browser delivers `click` on the
+     * NEAREST COMMON ANCESTOR of the press and the release, so a release outside the row
+     * reaches this box rather than the row — and this attribute says whether that box-level
+     * click selects the row the press started on or is dropped.
+     */
+    get acceptUnpairedRelease(): boolean;
+    set acceptUnpairedRelease(value: boolean);
+    get showSeparators(): boolean;
+    set showSeparators(value: boolean);
+    /** `GtkListBox:tab-behavior` (4.18) — `all` | `item` | `cell`. */
+    get tabBehavior(): GtkListTabBehavior;
+    set tabBehavior(value: GtkListTabBehavior);
+    /** The rows, in order. */
+    get rows(): readonly GtkListBoxRow[];
+    /**
+     * The selected positions, ascending.
+     *
+     * NOT a GIR property: `GtkListBox` exposes its selection through the `row-selected` /
+     * `selected-rows-changed` SIGNALS and the `get_selected_rows()` METHOD, and this element
+     * spells the signal as `notify::selected-rows` so a `notify::` listener finds the shape it
+     * expects everywhere else in the package.
+     */
+    get selectedRows(): number[];
+    set selectedRows(value: Iterable<number> | number | null);
+    /** `gtk_list_box_selected_foreach`, as the rows themselves. */
+    get selectedRowElements(): GtkListBoxRow[];
+    connectedCallback(): void;
+    attributeChangedCallback(name?: string): void;
+    /** `gtk_list_box_select_row` (gtklistbox.c:915-933). `null` is the C's unselect-all (:926). */
+    selectRow(row: GtkListBoxRow | null): void;
+    /** `gtk_list_box_unselect_row` (gtklistbox.c:943-950). */
+    unselectRow(row: GtkListBoxRow): void;
+    /** `gtk_list_box_select_all` — refused unless the mode is `multiple` (:963-964). */
+    selectAll(): void;
+    /** `gtk_list_box_unselect_all` — refused in `browse`, a no-op on an empty selection. */
+    unselectAll(): void;
+    /** The classes and ARIA that follow directly from the attributes. */
+    private _applyAttributes;
+    /** Re-read the children and re-derive everything that follows from them. */
+    private _collectRows;
+    /**
+     * Re-derive every row's `.activatable` class, its `aria-selected` and the roving tabindex.
+     *
+     * Called on connect, on `selection-mode`, and from the childList observer, so a row
+     * appended after connect is in the selection from its first frame.
+     */
+    private _syncRows;
+    /** The tab stops `tab-behavior` hands out: one per row, or one for the whole box. */
+    private _syncTabIndexes;
+    /**
+     * One click. Selection always follows; activation depends on the click COUNT, which a
+     * plain `click` cannot say — so the count comes from `detail` and a second click arrives
+     * here too.
+     */
+    private _onClick;
+    /** The double-click arm, for the browser that reports the second click as `detail === 2`. */
+    private _onDoubleClick;
+    /**
+     * `Ctrl`+Space is `toggle-cursor-row` (gtklistbox.c:753-755) and nothing else is: Enter and
+     * Space reach the ROW, which `attachRowActivation` owns, and this box must not answer the
+     * same key twice.
+     */
+    private _onKeyDown;
+    /** The row a click or key landed in, or null. */
+    private _rowAt;
+    /** One click or `Ctrl`+Space — `gtk_list_box_update_selection_full` (:1799-1871). */
+    private _updateSelection;
+    /** `gtk_list_box_activate` (:1873-1884) — an unactivatable row emits nothing. */
+    private _activate;
+    /**
+     * The two signals GObject emits for every selection change (:594-616) plus the notify a
+     * declarative port owes. `selected-rows-changed` is `RUN_FIRST` upstream and carries
+     * nothing, so its `detail` stays empty.
+     */
+    private _emitSelection;
+}

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

@@ -0,0 +1,73 @@
+import { ListViewState, type AdwComboOption, type AdwListItemFactory, type AdwListModelInput, type AdwListSelectionMode, type BoxOrientation } from '@gjsify/adwaita-core';
+/** `GtkListTabBehavior`'s nicks — `cell` behaves as `item` outside a cell-based view. */
+export type GtkListTabBehavior = 'all' | 'item' | 'cell';
+/** An unknown nick is `all`, the ParamSpec's default (gtklistview.c:965-969). */
+export declare function normalizeListTabBehavior(raw: string | null | undefined): GtkListTabBehavior;
+export declare class GtkListView extends HTMLElement {
+    protected _listEl: HTMLDivElement;
+    protected _rows: HTMLElement[];
+    /** The model + selection machine all three views share (ADR 0004, ADR 0089). */
+    protected readonly _state: ListViewState;
+    protected _factory: AdwListItemFactory<Node>;
+    private _initialized;
+    static get observedAttributes(): string[];
+    /** The list model (`Gtk.ListView:model`, minus the selection ADR 0046 declined). */
+    get model(): AdwComboOption[];
+    set model(value: AdwListModelInput);
+    /** The per-item renderer — `Gtk.ListView:factory`, as one function. */
+    get factory(): AdwListItemFactory<Node>;
+    set factory(value: AdwListItemFactory<Node> | null);
+    /** The selected positions, ascending. Assigning replaces the selection. */
+    get selected(): number[];
+    set selected(value: Iterable<number> | number | null);
+    get selectionMode(): AdwListSelectionMode;
+    set selectionMode(value: AdwListSelectionMode);
+    get showSeparators(): boolean;
+    set showSeparators(value: boolean);
+    get singleClickActivate(): boolean;
+    set singleClickActivate(value: boolean);
+    get enableRubberband(): boolean;
+    set enableRubberband(value: boolean);
+    get tabBehavior(): GtkListTabBehavior;
+    set tabBehavior(value: GtkListTabBehavior);
+    /**
+     * `GtkOrientable:orientation` — which way the rows run.
+     *
+     * VERTICAL by default, and NOT through `normalizeBoxOrientation`: that helper is
+     * `GtkBox`'s parser and answers the interface default, horizontal. `GtkListBase` sets
+     * `priv->orientation = GTK_ORIENTATION_VERTICAL` in its own init
+     * (gtklistbase.c:2070), which is why every GTK list view scrolls DOWN out of the box.
+     * Taking the shared helper's default here put `.horizontal` on every list view,
+     * flowed the rows across, pointed the arrow keys at the wrong axis and stopped the
+     * `show-separators` rule matching — one wrong default, three symptoms.
+     */
+    get orientation(): BoxOrientation;
+    set orientation(value: BoxOrientation);
+    connectedCallback(): void;
+    attributeChangedCallback(name?: string): void;
+    /** The classes and ARIA that follow directly from the attributes. */
+    protected _applyAttributes(): void;
+    /**
+     * The class the HOST wears. GTK names its views by CSS node — `listview`, `gridview`,
+     * `columnview` — and the three partials select on the tag, so this is what a consumer
+     * or a page rule has to spell; a subclass wearing the base's class would offer one
+     * name for two widgets.
+     */
+    protected get _viewClass(): string;
+    /** The CSS node name GTK gives each child — `row` here, `child` in a grid view. */
+    protected get _rowClass(): string;
+    /** Build every row from scratch — the factory changed, or the view did. */
+    protected _renderRows(): void;
+    /** One row: the factory's node inside the element GTK calls `row`. */
+    protected _createRow(position: number): HTMLElement | null;
+    private _selectRow;
+    private _activateRow;
+    private _onSelectionChanged;
+    /** The per-row selected state, and the one tab stop a roving tabindex leaves open. */
+    protected _syncSelectedStates(): void;
+    /**
+     * Apply one `items-changed` — remove `removed` rows at `position`, insert `added`
+     * fresh ones there, leave every other row standing.
+     */
+    private _applyItemsChanged;
+}

package/lib/types/elements/gtk-media-controls.d.ts

@@ -0,0 +1,142 @@
+/**
+ * The four `audio-volume-*` names `GtkVolumeButton` derives from a 0…1 level, one constant
+ * each rather than an array of them, in the ORDER `icons_symbolic` holds them
+ * (gtkvolumebutton.c:74-77) — which is muted, HIGH, low, medium, and not the order of the
+ * levels.
+ *
+ * The shape is load-bearing, not stylistic. `check-adwaita-icon-masks.mjs` reads an emitted
+ * icon name out of the SOURCE with a regex for a SCREAMING_SNAKE constant whose name ends in
+ * `ICON` or `ICON_NAME` and whose value is a plain string literal — that is how
+ * `PASSWORD_REVEAL_ICON_NAME` and the about dialog's glyph are found. Four literals inside an
+ * array are invisible to it, so its second arm would report four ICONS entries nothing emits
+ * while all four really are emitted. The `-symbolic` suffix is likewise kept on the value:
+ * `normalizeIconName` accepts either spelling, and dropping it buys nothing.
+ */
+export declare const VOLUME_MUTED_ICON = "audio-volume-muted-symbolic";
+/** The FULL-SCALE name — `[1]` in the list, so only the exact `upper` reaches it. */
+export declare const VOLUME_HIGH_ICON = "audio-volume-high-symbolic";
+/** Below a half — `[2]`, the lower of the two middle names. */
+export declare const VOLUME_LOW_ICON = "audio-volume-low-symbolic";
+/** From a half up to — but not at — full scale — `[3]`. */
+export declare const VOLUME_MEDIUM_ICON = "audio-volume-medium-symbolic";
+/**
+ * The icon `GtkVolumeButton` shows at `volume` (0…1), as `gtk_scale_button_update_icon`
+ * derives it (gtkscalebutton.c:1086-1104): the exact `lower` is `[0]` (muted), the exact
+ * `upper` is `[1]` (high), and a value between them indexes `[2]`/`[3]` by
+ * `(guint)((value − lower) / step) + 2` with `step = (upper − lower) / (num_icons − 2)` — a
+ * HALF for a 0…1 adjustment over four icons.
+ */
+export declare function volumeIconFor(volume: number): string;
+/**
+ * `totem_time_to_string` (gtkmediacontrols.c:75-132), in seconds.
+ *
+ * The `remaining` bump is the C's own (`:81-82`) and it is not a rounding fudge: the C
+ * computes the remaining time as `duration - timestamp` and then increments `_time` — the
+ * WHOLE TOTAL, not the seconds field — so that `current + remaining = total` holds for a
+ * whole second of playback rather than being one second short at every boundary. That is why
+ * 300 s of remaining time reads `-5:01` and not `-5:00`: the seconds field only appears to
+ * move when the input's own seconds are zero, and the increment carries at 59.
+ *
+ * NOTHING HERE FLOORS A NEGATIVE, because the C does not. `_time % 60` in C99 keeps the sign
+ * of the dividend, so five seconds negative is zero minutes and `-5` seconds and the
+ * function returns the nonsense `0:-5`; the C's CALLERS guard the subtraction instead
+ * (`duration > timestamp ? duration - timestamp : 0`, :364), and so does every call site
+ * here. The C's arithmetic is transcribed rather than repaired, so a caller that skips the
+ * guard sees what GTK would have shown.
+ *
+ * The hour branch is `hour > 0 || force_hour` — an ELEVEN-MINUTE video is `11:03`, not
+ * `0:11:03` — and `force_hour` is FALSE at every call site in the C (`:358, :364, :389`).
+ * It stays a parameter because it is part of the function's contract, not because anything
+ * here passes it.
+ *
+ * @param seconds total or remaining time, in seconds; a negative is NOT floored here, exactly
+ *   as it is not in the C — see above.
+ */
+export declare function mediaTimeToString(seconds: number, remaining?: boolean, forceHour?: boolean): string;
+export declare class GtkMediaControls extends HTMLElement {
+    private _initialized;
+    private _playButton;
+    private _timeLabel;
+    private _seekScale;
+    private _durationLabel;
+    private _volumeButton;
+    /** The icon node INSIDE the volume button — the popover is its sibling child. */
+    private _volumeIcon;
+    private _volumePopover;
+    private _volumeScale;
+    private _media;
+    /** Whether the user is dragging the seek scale — the C's own re-entrancy guard. */
+    private _seeking;
+    private _volume;
+    connectedCallback(): void;
+    /** The `<video>` these controls drive — the browser's answer to a `GtkMediaStream`. */
+    get media(): HTMLVideoElement | null;
+    /** The current position in seconds. */
+    get timestamp(): number;
+    /** The media's duration in seconds, or 0 while unknown. */
+    get duration(): number;
+    /** The volume level, 0…1, matching `volume_adjustment`'s range. */
+    get volume(): number;
+    set volume(value: number);
+    /**
+     * Whether the bar is live — the C's `gtk_media_controls_set_sensitive`.
+     *
+     * Loosely typed on purpose: `_adoptMedia` coerces its optional chain to `null`, and this
+     * answers "is there a stream" for any field state rather than only the two the coercion
+     * produces. A `!== null` test here read `undefined` as a stream.
+     */
+    get sensitive(): boolean;
+    /** `play_button_clicked` (ui/gtkmediacontrols.ui) — the button's only action. */
+    private _togglePlay;
+    /**
+     * `time_adjustment_changed` (ui/gtkmediacontrols.ui): the scale's value IS the position,
+     * in seconds. The `_seeking` guard is the C's own — `update_timestamp` writes the scale
+     * from the stream, so without it a drag would fight the playback it is dragging through.
+     */
+    private _onSeekInput;
+    private _onVolumeInput;
+    private _setVolume;
+    private _renderVolume;
+    private _toggleVolumePopover;
+    /**
+     * The media element these controls drive. A `<gtk-media-controls>` normally sits INSIDE a
+     * `<gtk-video>` (the template's `controls_revealer` child), so the nearest ancestor video
+     * is the stream — and a controls bar used on its own names one with a `for` attribute
+     * holding an id.
+     *
+     * The optional chain's `undefined` IS COERCED TO `null`, and that is not tidiness: `?? null`
+     * is what keeps `_media` in the domain `sensitive` and `_render` compare against. A bar with
+     * no enclosing video used to store `undefined` here, `undefined !== null` then reported the
+     * template's `sensitive` 0 bar as LIVE, and the `!this._media.paused` at the end of
+     * `_render` threw `can't access property "paused", this._media is undefined` — which is the
+     * uncaught error `tests/browser/specs/adwaita-upgrade-order.spec.ts` fails on. `null` is
+     * what `gtk_media_controls_new()` leaves behind: the template has no stream at all, and
+     * `sensitive` is 0 until one is set (ui/gtkmediacontrols.ui).
+     */
+    private _adoptMedia;
+    /** The listeners bound on `_media`, so `_detachMedia` removes the SAME ones. */
+    private _mediaListeners;
+    private _detachMedia;
+    /**
+     * `update_timestamp` (gtkmediacontrols.c:352-366). TWO cases and they are not
+     * symmetric: with no duration, the POSITION label shows the elapsed time and the
+     * DURATION label is hidden (`:358-359`); with a duration, the DURATION label shows the
+     * NEGATIVE remaining time and is visible only when the duration is greater than zero
+     * (`:389-391`).
+     */
+    private _updateTimestamp;
+    /** `gtk_media_controls_set_duration` (gtkmediacontrols.c:380-392): the scale's range is
+     * the media's own duration, and the `upper` 10 of the template is only the pre-stream
+     * placeholder. */
+    private _updateDuration;
+    /** The play button's icon, `play_button_clicked`'s counterpart in `ui/gtkvideo.ui`'s
+     * `gtk_video_update_playing`: `media-playback-start-symbolic` stopped,
+     * `media-playback-pause-symbolic` playing. */
+    private _updatePlaying;
+    /**
+     * The whole bar's sensitivity. The template ships `sensitive` 0
+     * (ui/gtkmediacontrols.ui), so an unattached bar is inert — which is what `insensitive`
+     * carries here, and why the spec can assert it before any media is adopted.
+     */
+    private _render;
+}

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

@@ -0,0 +1,148 @@
+/** `GtkPositionType`, spelled as the GIR's enum nicks. `top` is the property default. */
+export type NotebookTabPos = 'top' | 'bottom' | 'left' | 'right';
+/** The browser's page descriptor — the stand-in for the `GtkNotebookPage` GObject. */
+export interface NotebookPageInfo {
+    /** `GtkNotebookPage:tab-label` — the tab's text. `null` when absent. */
+    tabLabel: string | null;
+    /** `GtkNotebookPage:menu-label` — the text of the menu entry. `null` when absent. */
+    menuLabel: string | null;
+    /** `GtkNotebookPage:tab-fill` — the tab fills its allocation. Defaults to TRUE. */
+    tabFill: boolean;
+    /** `GtkNotebookPage:tab-expand` — the tab expands. Defaults to false. */
+    tabExpand: boolean;
+    /** `GtkNotebookPage:reorderable` — the user may drag the tab. */
+    reorderable: boolean;
+    /** `GtkNotebookPage:detachable` — read and reflected; the drag itself is not ported. */
+    detachable: boolean;
+    /** `GtkWidget:visible` on the child, as the DOM's `hidden`. */
+    visible: boolean;
+    /** `GtkNotebookPage:child`. */
+    child: HTMLElement;
+}
+export declare class GtkNotebook extends HTMLElement {
+    private _current;
+    private _initialized;
+    private _initializedChildren;
+    private _header;
+    private _tabs;
+    private _observer;
+    private _tabNodes;
+    private _menu;
+    static get observedAttributes(): string[];
+    /**
+     * `Gtk.Notebook:page` — the index of the current page, `-1` when there is none.
+     *
+     * LIVE rather than the value last written: `get_property` returns
+     * `gtk_notebook_get_current_page (notebook)` (gtknotebook.c:1977-1979), so the
+     * attribute is an INPUT and this is the answer — a switch reached by clicking a tab
+     * is visible through the property without anything having written it. A negative
+     * WRITE means the LAST page (gtknotebook.c:6054).
+     */
+    get page(): number;
+    set page(v: number);
+    /** `Gtk.Notebook:tab-pos` — which edge the tabs are on. Defaults to `top`. */
+    get tabPos(): NotebookTabPos;
+    set tabPos(v: NotebookTabPos);
+    /** `Gtk.Notebook:show-tabs` — the tab strip itself. Defaults to true. */
+    get showTabs(): boolean;
+    set showTabs(v: boolean);
+    /** `Gtk.Notebook:show-border` — the border around the tab strip. Defaults to true. */
+    get showBorder(): boolean;
+    set showBorder(v: boolean);
+    /** `Gtk.Notebook:scrollable` — GTK's scroll arrows. Defaults to false. */
+    get scrollable(): boolean;
+    set scrollable(v: boolean);
+    /** `Gtk.Notebook:enable-popup` — the right-click page menu. Defaults to false. */
+    get enablePopup(): boolean;
+    set enablePopup(v: boolean);
+    /** `Gtk.Notebook:group-name` — the drag-and-drop group. Defaults to `null`. */
+    get groupName(): string | null;
+    set groupName(v: string | null);
+    /** The current page's child, or `null` — `gtk_notebook_get_nth_page` at `page`. */
+    get currentPage(): HTMLElement | null;
+    /** `gtk_notebook_get_n_pages` as the browser spells it. */
+    get nPages(): number;
+    /** `gtk_notebook_get_nth_page` (gtknotebook.c:5956-5977): a child, or null. */
+    getNthPage(n: number): HTMLElement | null;
+    /** `gtk_notebook_page_num` (gtknotebook.c:6006-6020): an index, `-1` when absent. */
+    pageNum(child: HTMLElement): number;
+    /** The descriptor of one child, `null` when it is not a page of this notebook. */
+    getPage(child: HTMLElement): NotebookPageInfo | null;
+    /** `By CHILD rather than by index — `gtk_notebook_page_num` for the index and
+     * `gtk_notebook_set_current_page` for the switch (gtknotebook.c:6006, :6046). There is
+     * no `gtk_notebook_set_page` to transcribe: GTK 4 dropped it. */
+    setPage(child: HTMLElement): boolean;
+    /**
+     * `gtk_notebook_next_page` (gtknotebook.c:6070-6088) — which searches with
+     * `gtk_notebook_search_page (…, STEP_NEXT, TRUE)`, so a HIDDEN page is stepped over
+     * rather than ending the walk, and the end of the notebook is simply nothing
+     * (:6079-6080).
+     */
+    nextPage(): boolean;
+    /** `gtk_notebook_prev_page` (gtknotebook.c:6096-6113), the same search backwards. */
+    prevPage(): boolean;
+    /**
+     * `gtk_notebook_set_current_page` (gtknotebook.c:6046-6060) into
+     * `real_switch_page` (gtknotebook.c:5436-5498): a negative index is the last page,
+     * an out-of-range one does nothing, and a page whose child is hidden is refused.
+     */
+    setCurrentPage(index: number): boolean;
+    /** `gtk_notebook_append_page` (gtknotebook.c:5807-5870) — the child is the page. */
+    appendPage(child: HTMLElement, tabLabel?: string | null): number;
+    /**
+     * `gtk_notebook_insert_page` (gtknotebook.c:5807-5870). A negative `position` means
+     * the end, which is what `append_page` passes.
+     */
+    insertPage(child: HTMLElement, position: number, tabLabel?: string | null): number;
+    /** `gtk_notebook_remove_page` (gtknotebook.c:5899-5932). */
+    removePage(child: HTMLElement): boolean;
+    /** Rebuild the tabs by hand, for a consumer that mutated a page in place. */
+    refresh(): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    /**
+     * `switch-page` is emitted BEFORE the switch (gtknotebook.c:5518-5523) and
+     * `real_switch_page` runs after it, so a listener sees the page being switched TO
+     * while `page` still reads the old one — the order C's own handlers rely on.
+     */
+    private _switchTo;
+    private _notify;
+    private _property;
+    private _write;
+    /** A boolean property with a non-false default: absent means the default. */
+    private _flag;
+    /** The children, in page order — the header is the widget's own, never a page. */
+    private _pages;
+    private _page;
+    private _initChild;
+    private _firstVisible;
+    /**
+     * `gtk_notebook_search_page` with `find_visible` TRUE (gtknotebook.c:4412-4470): walk
+     * from the current page in `direction`, skipping every page whose child is hidden, and
+     * switch to the first one that takes. Off either end there is nothing, which is the
+     * FALSE both `next_page` and `prev_page` return.
+     */
+    private _searchPage;
+    /**
+     * The neighbour a REMOVAL hands the notebook to: the pages that followed the removed
+     * one, then the pages that came before it — `search_page (…, STEP_NEXT, TRUE)` and
+     * then `search_page (…, STEP_PREV, TRUE)` (gtknotebook.c:4281-4282), which is a wrap
+     * rather than a one-way walk. `position` is where the removed page WAS.
+     */
+    private _takeOver;
+    private _onMutations;
+    /** Which edge the tabs are on, with RTL's left/right swap (gtknotebook.c:1741-1757). */
+    private _effectiveTabPos;
+    private _render;
+    private _buildTab;
+    /**
+     * `enable-popup`'s right-click menu (`gtk_notebook_popup_enable`,
+     * gtknotebook.c:6420-6462 builds it and `gtk_notebook_popup_menu` at :2684-2692 pops
+     * it up) as a DOM listbox of
+     * the same pages. C builds it with `gtk_menu_model` and a GtkPopover; the page set
+     * and the selection are the same, the widget is not.
+     */
+    private readonly _onContextMenu;
+    private _closeMenu;
+}

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

@@ -0,0 +1,22 @@
+export declare class GtkOverlay extends HTMLElement {
+    private _childEl;
+    private _layerEl;
+    private _initialized;
+    /**
+     * GTK recomputes the edge classes on every allocation of an overlay child, which is a
+     * frame-clock fact this renderer does not have; a ResizeObserver on the layer is the
+     * honest substitute — it fires on the changes the C would answer to.
+     */
+    private _resize;
+    /** The two things a child can do that change which edge it is pinned to. */
+    private _mutations;
+    static get observedAttributes(): any[];
+    /** `Gtk.Overlay:child` — the main child, as the light-DOM node the host adopted. */
+    get child(): Element | null;
+    /** The absolutely-positioned layer every `slot="overlay"` child lands in. */
+    get overlayLayer(): HTMLDivElement;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private _observe;
+    private _syncEdgeClasses;
+}