@gjsify/adwaita-web 0.54.0 → 0.56.0

package/lib/types/elements/gtk-graphics-offload.d.ts

@@ -0,0 +1,24 @@
+/** `GtkGraphicsOffloadEnabled`, spelled as the GIR's enum nicks. */
+type OffloadEnabled = 'enabled' | 'disabled';
+export declare class GtkGraphicsOffload extends HTMLElement {
+    private _childEl;
+    private _initialized;
+    static get observedAttributes(): string[];
+    /** `Gtk.GraphicsOffload:child` — the child widget, as the light-DOM node adopted. */
+    get child(): Element | null;
+    /**
+     * `Gtk.GraphicsOffload:enabled` — whether the widget ATTEMPTS to offload its child's
+     * contents. Defaults to `GTK_GRAPHICS_OFFLOAD_ENABLED` (`:267-273`).
+     */
+    get enabled(): OffloadEnabled;
+    set enabled(v: OffloadEnabled);
+    /** `Gtk.GraphicsOffload:black-background` — the black rect painted before the child. */
+    get blackBackground(): boolean;
+    set blackBackground(v: boolean);
+    connectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    /** `sync_subsurface` (:176-191): the subsurface exists while the widget is realized and offload is not disabled. */
+    private _render;
+    private _notify;
+}
+export {};

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

@@ -0,0 +1,39 @@
+import { GtkListView } from './gtk-list-view.js';
+export declare class GtkGridView extends GtkListView {
+    private _observer;
+    static get observedAttributes(): string[];
+    /** `GtkGridView:min-columns` — at least one, as the ParamSpec's range says. */
+    get minColumns(): number;
+    set minColumns(value: number);
+    /** `GtkGridView:max-columns` — `DEFAULT_MAX_COLUMNS` is 7 (gtkgridview.c:42). */
+    get maxColumns(): number;
+    set maxColumns(value: number);
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name?: string): void;
+    protected get _viewClass(): string;
+    protected get _rowClass(): string;
+    protected _renderRows(): void;
+    /** An attribute that is not a positive integer is the property's default, not NaN. */
+    private _columnBound;
+    /**
+     * Measure, count, and write the tracks.
+     *
+     * THE ITEM SIZE IS THE CELL'S `min-width`, NOT ITS RENDERED WIDTH, and the difference
+     * is the whole reason this is three lines rather than one. The tracks are written as
+     * `1fr`, so a rendered cell is as wide as the count made it: feeding that back in
+     * would measure the answer and converge on whatever the first frame happened to do.
+     * `min-width` is a fact about the CONTENT instead, declared by the stylesheet and
+     * overridable per cell — and it is the branch GTK itself takes under
+     * `GTK_SCROLL_MINIMUM` (gtkgridview.c:628-630). The natural-size branch needs a
+     * measurement a browser can only take by first undoing the layout the answer feeds.
+     *
+     * The gap is read the same way, off the container's own `column-gap`, so the two
+     * numbers the arithmetic takes come from ONE place — the stylesheet — and an author
+     * who widens the gap does not get a column count computed against the old one.
+     *
+     * An empty view keeps the tracks it had: there is nothing to measure, and no cell for
+     * the answer to be wrong about.
+     */
+    private _applyColumns;
+}

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

@@ -0,0 +1,27 @@
+import { type BoxOrientation } from '@gjsify/adwaita-core';
+export declare class GtkGrid extends HTMLElement {
+    static get observedAttributes(): string[];
+    /** `Gtk.Grid:column-spacing` — the gap between two consecutive columns. Defaults to 0. */
+    get columnSpacing(): number;
+    set columnSpacing(value: number);
+    /** `Gtk.Grid:row-spacing` — the gap between two consecutive rows. Defaults to 0. */
+    get rowSpacing(): number;
+    set rowSpacing(value: number);
+    /** `Gtk.Grid:column-homogeneous` — whether every column gets the same width. */
+    get columnHomogeneous(): boolean;
+    set columnHomogeneous(value: boolean);
+    /** `Gtk.Grid:row-homogeneous` — whether every row gets the same height. */
+    get rowHomogeneous(): boolean;
+    set rowHomogeneous(value: boolean);
+    /**
+     * `GtkOrientable:orientation` — the axis a child with no position of its own is
+     * attached along. `horizontal` (the default) appends each one to ROW 0 at the next
+     * free column, `vertical` to COLUMN 0 at the next free row.
+     */
+    get orientation(): BoxOrientation;
+    set orientation(value: BoxOrientation);
+    connectedCallback(): void;
+    attributeChangedCallback(name: string, old: string | null, value: string | null): void;
+    private _normalized;
+    private _sync;
+}

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

@@ -0,0 +1,60 @@
+import './gtk-window-controls.js';
+export declare class GtkHeaderBar extends HTMLElement {
+    private _initialized;
+    private _handle;
+    private _box;
+    private _startBox;
+    private _endBox;
+    /** The two `GtkWindowControls`, present only while `show-title-buttons` is true (:798-826). */
+    private _startControls;
+    private _endControls;
+    /** The derived `GtkLabel`, or `null` while a `title-widget` holds the centre. */
+    private _titleLabel;
+    /** The child that took the centre — read back out of `_box`, never stored as truth. */
+    private _centre;
+    private _centreObserver;
+    static get observedAttributes(): string[];
+    /** `Gtk.HeaderBar:decoration-layout` — bound to both controls (:231-236, :240-245). */
+    get decorationLayout(): string | null;
+    set decorationLayout(value: string | null);
+    /** `Gtk.HeaderBar:show-title-buttons` — whether the standard frame controls are built. */
+    get showTitleButtons(): boolean;
+    set showTitleButtons(value: boolean);
+    /** `Gtk.HeaderBar:title-widget`, read as the element that holds the centre — or `null`. */
+    get titleWidget(): HTMLElement | null;
+    /** `setAttribute` for a write that changes nothing; every GObject setter here returns early. */
+    private _write;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    private _property;
+    /**
+     * `create_window_controls` and its inverse, `gtk_header_bar_set_show_title_buttons`
+     * (gtkheaderbar.c:198-249, :798-826): the start controls are PREPENDED into the start
+     * box, the end controls APPENDED into the end box, and setting the property false
+     * REMOVES both — which is why a bar with the property off has no controls at all rather
+     * than hidden ones.
+     */
+    private _renderTitleButtons;
+    /** The two `G_BINDING_SYNC_CREATE` bindings onto the controls (:229-247). */
+    private _bindDecorationLayout;
+    /**
+     * The two things `gtk_header_bar_root` connects to (gtkheaderbar.c:362-376): the centre
+     * either/or, which changes what belongs in the middle in BOTH directions — `set_title_widget`
+     * empties the bin before installing and rebuilds the derived label when it is handed back
+     * to NULL (:319-341) — and `notify::title` on the ROOT, which re-runs `update_title`.
+     */
+    private _followCentre;
+    /** The child of `_box` that is neither a side box nor the derived label. */
+    private _centreChild;
+    private _syncCentre;
+    /** `construct_title_label` (gtkheaderbar.c:274-290), with `width-chars=5` as CSS. */
+    private _constructTitleLabel;
+    /** `gtk_header_bar_set_title_widget`'s first act: the centre bin goes empty (:323). */
+    private _dropTitleLabel;
+    /**
+     * `update_title` (gtkheaderbar.c:250-271): the root window's title, then the two GLib
+     * process-name fallbacks — which is what the page's own `<title>` stands in for here.
+     */
+    private _updateTitle;
+}

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

@@ -0,0 +1,64 @@
+import { type LabelWrapMode } from '@gjsify/adwaita-core';
+/** `GtkInscriptionOverflow`, in enum order (gtkinscription.h:44-48). */
+export declare const INSCRIPTION_OVERFLOW_MODES: readonly ["clip", "ellipsize-start", "ellipsize-middle", "ellipsize-end"];
+export type InscriptionOverflow = (typeof INSCRIPTION_OVERFLOW_MODES)[number];
+/** `GTK_INSCRIPTION_OVERFLOW_CLIP`, the pspec default (gtkinscription.c:728-733). */
+export declare const DEFAULT_INSCRIPTION_OVERFLOW: InscriptionOverflow;
+/**
+ * `PANGO_WRAP_WORD_CHAR`, the pspec's default — which is NOT GtkLabel's
+ * (gtkinscription.c:738-740). The nick set is shared; only the fallback differs, and it
+ * differs because this widget sizes itself in characters and lines and therefore has to be
+ * able to break a word inside the box it just reserved.
+ */
+export declare const DEFAULT_INSCRIPTION_WRAP_MODE: LabelWrapMode;
+/** `GtkInscription:text-overflow` from its nick, leaving an unknown nick at the default. */
+export declare function normalizeInscriptionOverflow(value: unknown): InscriptionOverflow;
+/** `GtkInscription:wrap-mode` from its nick, with {@link DEFAULT_INSCRIPTION_WRAP_MODE}. */
+export declare function normalizeInscriptionWrapMode(value: unknown): LabelWrapMode;
+export declare class GtkInscription extends HTMLElement {
+    private _initialized;
+    static get observedAttributes(): string[];
+    /** `GtkInscription:text` — the plain string to draw (gtkinscription.c:713-717). */
+    get text(): string;
+    set text(value: string);
+    /**
+     * `GtkInscription:markup` — a Pango-markup string (gtkinscription.c:617-622), reduced
+     * to its plain text by `labelDisplayText` rather than parsed. See the header for why
+     * that is the XSS answer and why {@link text} wins when both are present.
+     */
+    get markup(): string;
+    set markup(value: string);
+    /** `GtkInscription:min-chars` (gtkinscription.c:638-644). Defaults to 3. */
+    get minChars(): number;
+    set minChars(value: number);
+    /** `GtkInscription:nat-chars` (gtkinscription.c:680-686). Defaults to 0. */
+    get natChars(): number;
+    set natChars(value: number);
+    /** `GtkInscription:min-lines` (gtkinscription.c:660-666). Defaults to 1. */
+    get minLines(): number;
+    set minLines(value: number);
+    /** `GtkInscription:nat-lines` (gtkinscription.c:700-706). Defaults to 0. */
+    get natLines(): number;
+    set natLines(value: number);
+    /** `GtkInscription:text-overflow` (gtkinscription.c:726-732). Defaults to CLIP. */
+    get textOverflow(): InscriptionOverflow;
+    set textOverflow(value: InscriptionOverflow);
+    /** `GtkInscription:wrap-mode` (gtkinscription.c:741-746). Defaults to WORD_CHAR. */
+    get wrapMode(): LabelWrapMode;
+    set wrapMode(value: LabelWrapMode);
+    /**
+     * `GtkInscription:xalign` (gtkinscription.c:757-760). Defaults to 0.0
+     * (gtkinscription.c:67, :791) — start-aligned, unlike GtkLabel's 0.5.
+     */
+    get xalign(): number;
+    set xalign(value: number);
+    /** `GtkInscription:yalign` (gtkinscription.c:773-776). Defaults to 0.5. */
+    get yalign(): number;
+    set yalign(value: number);
+    private _write;
+    connectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    /** The `notify::` detail for `name`: the PROPERTY, parsed, not the raw attribute. */
+    private _property;
+    private _render;
+}

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

@@ -11,6 +11,9 @@ export declare class GtkLabel extends HTMLElement {
      */
     private _wrapSpan;
     private _resizes;
+    /** Whether `_sync` last wrote `min-width` / `max-width` itself, and so may clear them. */
+    private _wroteMinWidth;
+    private _wroteMaxWidth;
     static get observedAttributes(): ("label" | "use-markup" | "use-underline" | "justify" | "wrap" | "xalign" | "yalign" | "wrap-mode" | "ellipsize" | "lines" | "width-chars" | "max-width-chars" | "selectable")[];
     /** `Gtk.Label:label` — the text as written, before markup and the mnemonic come out. */
     get label(): string;

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