@gjsify/adwaita-web 0.54.0 → 0.55.0

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

@@ -0,0 +1,49 @@
+import './gtk-label.js';
+export declare class GtkExpander extends HTMLElement {
+    private _box;
+    private _titleEl;
+    private _arrowEl;
+    private _labelEl;
+    private _labelSection;
+    private _contentEl;
+    private _initialized;
+    static get observedAttributes(): string[];
+    /** `Gtk.Expander:expanded` — whether the child is revealed. */
+    get expanded(): boolean;
+    set expanded(value: boolean);
+    /** `Gtk.Expander:label` — the title TEXT, or `null` when a label widget is in its place. */
+    get label(): string | null;
+    set label(value: string | null);
+    /** `Gtk.Expander:use-markup` — whether the label is Pango markup. */
+    get useMarkup(): boolean;
+    set useMarkup(value: boolean);
+    /** `Gtk.Expander:use-underline` — whether `_` in the label marks a mnemonic. */
+    get useUnderline(): boolean;
+    set useUnderline(value: boolean);
+    /** `Gtk.Expander:resize-toplevel` — reflected, because a document reflows itself. */
+    get resizeToplevel(): boolean;
+    set resizeToplevel(value: boolean);
+    /** `Gtk.Expander:child` — the light-DOM node in the content row. */
+    get child(): Element | null;
+    /** `Gtk.Expander:label-widget` — the light-DOM node standing in for the label text. */
+    get labelWidget(): Element | null;
+    connectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    private _detail;
+    /** `gtk_expander_activate` (gtkexpander.c:786-792) — the one thing the widget does. */
+    private _activate;
+    /**
+     * `Alt`+the marked character, as `gtk_expander_new_with_mnemonic` documents
+     * (gtkexpander.c:856-860): "Pressing Alt and that key activates the button."
+     */
+    private readonly _onKeyDown;
+    /**
+     * The single character `use-underline` marks, or `null` when none does.
+     *
+     * The walk is `stripMnemonic`'s, for the reason that function gives: a `_` takes the
+     * character after it and is itself removed, `__` is an escaped literal underscore and
+     * marks nothing, and a trailing marker has no character to take.
+     */
+    private _mnemonic;
+    private _render;
+}

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

@@ -0,0 +1,13 @@
+export declare class GtkFixed extends HTMLElement {
+    private _resize;
+    private _mutations;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /** `gtk_fixed_put()` — a child and the position it sits at, both relative to the fixed. */
+    put(child: HTMLElement, x: number, y: number): void;
+    /** `gtk_fixed_move()` — the same position for a child already in this fixed. */
+    move(child: HTMLElement, x: number, y: number): void;
+    private _observeChildren;
+    /** `gtk_fixed_layout_measure`: the union of the children's rectangles, as one box. */
+    private _size;
+}

package/lib/types/elements/gtk-flow-box-child.d.ts

@@ -0,0 +1,14 @@
+export declare class GtkFlowBoxChild extends HTMLElement {
+    private _contentsEl;
+    private _initialized;
+    connectedCallback(): void;
+    /** `GtkFlowBoxChild:child`, as the light-DOM child it already is. */
+    get child(): Element | null;
+    /** Where this child sits in its box, or -1 while it has no box. */
+    get index(): number;
+    /**
+     * `gtk_flow_box_child_is_selected` — read over the class the box writes, so a cell moved
+     * between boxes never carries a stale answer.
+     */
+    get selected(): boolean;
+}

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

@@ -0,0 +1,87 @@
+import { type AdwBoxSelectionMode } from '@gjsify/adwaita-core';
+import type { GtkFlowBoxChild } from './gtk-flow-box-child.js';
+import './gtk-flow-box-child.js';
+/** `GtkFlowBox:max-children-per-line`'s default — `DEFAULT_MAX_CHILDREN_PER_LINE` (:728). */
+export declare const ADW_FLOW_BOX_MAX_CHILDREN_PER_LINE = 7;
+/** `GtkFlowBox:orientation` — HORIZONTAL by default here, unlike a `GtkListBase` (:3981). */
+export type AdwFlowBoxOrientation = 'horizontal' | 'vertical';
+export declare class GtkFlowBox extends HTMLElement {
+    private _children;
+    private _selection;
+    /** `priv->selected_child`, `-1` for the C's NULL. */
+    private _anchor;
+    private _initialized;
+    static get observedAttributes(): string[];
+    get selectionMode(): AdwBoxSelectionMode;
+    set selectionMode(value: AdwBoxSelectionMode);
+    /** Default TRUE (gtkflowbox.c:3723), so the attribute is the OFF switch. */
+    get activateOnSingleClick(): boolean;
+    set activateOnSingleClick(value: boolean);
+    /** Default FALSE (gtkflowbox.c:3731). Read as boolean because a browser always pairs a
+     * click's halves somewhere; see `<gtk-list-box>`'s header for the rest. */
+    get acceptUnpairedRelease(): boolean;
+    set acceptUnpairedRelease(value: boolean);
+    get homogeneous(): boolean;
+    set homogeneous(value: boolean);
+    /** `GtkFlowBox:min-children-per-line` — 0 is the ParamSpec default (:3758). */
+    get minChildrenPerLine(): number;
+    set minChildrenPerLine(value: number);
+    /** `GtkFlowBox:max-children-per-line` — 7 is the default, and the ParamSpec's MINIMUM is 1. */
+    get maxChildrenPerLine(): number;
+    set maxChildrenPerLine(value: number);
+    get rowSpacing(): number;
+    set rowSpacing(value: number);
+    get columnSpacing(): number;
+    set columnSpacing(value: number);
+    get orientation(): AdwFlowBoxOrientation;
+    set orientation(value: AdwFlowBoxOrientation);
+    /**
+     * The cells, in document order — GTK's `children` sequence.
+     *
+     * NOT spelled `children`: that name is `HTMLElement.children`, an `HTMLCollection`, and
+     * shadowing it on an element that HAS children would break `firstElementChild` consumers
+     * and the DOM's own `[...el.children]` idiom everywhere else in this package.
+     */
+    get cells(): readonly GtkFlowBoxChild[];
+    /** The selected positions, ascending. A method upstream (`get_selected_children`). */
+    get selectedChildren(): number[];
+    set selectedChildren(value: Iterable<number> | number | null);
+    get selectedChildElements(): GtkFlowBoxChild[];
+    connectedCallback(): void;
+    attributeChangedCallback(): void;
+    /** `gtk_flow_box_select_child` (gtkflowbox.c:4731-4739). `null` is the C's unselect-all. */
+    selectChild(child: GtkFlowBoxChild | null): void;
+    /** `gtk_flow_box_unselect_child` (gtkflowbox.c:4749-4756). */
+    unselectChild(child: GtkFlowBoxChild): void;
+    /** `gtk_flow_box_select_all` — refused unless the mode is `multiple` (:4770-4771). */
+    selectAll(): void;
+    /** `gtk_flow_box_unselect_all` — refused in `browse` (:4792-4793). */
+    unselectAll(): void;
+    /**
+     * The properties, as inline custom properties, so the flex rules in `_flow_box.scss` stay
+     * declarative and a `homogeneous` write is one class flip.
+     */
+    private _applyAttributes;
+    private _collectChildren;
+    /**
+     * The `GTK_STATE_FLAG_SELECTED` each selected cell raises and the accessible state that
+     * goes with it (`gtk_flow_box_child_set_selected`, gtkflowbox.c:943-962). The accessible
+     * state is published ONLY while the box can select, which is the same reset the list box
+     * does (:3617-3623).
+     */
+    private _syncChildren;
+    private _onClick;
+    private _onDoubleClick;
+    /**
+     * `Ctrl`+Space is `toggle-cursor-child` (gtkflowbox.c:3957-3959); Enter and Space are the
+     * CELL's, via `activate-cursor-child` (:3836) and `GtkFlowBoxChild`'s own `activate`.
+     */
+    private _onKeyDown;
+    private _childAt;
+    /** One click or `Ctrl`+Space — `gtk_flow_box_update_selection` (:1077-1131). */
+    private _updateSelection;
+    /** `gtk_flow_box_select_and_activate` (:1136-1148) — the `child-activated` signal. */
+    private _activate;
+    /** `child-activated`'s companion `selected-children-changed` (:3820-3826) plus the notify. */
+    private _emitSelection;
+}

package/lib/types/elements/gtk-font-dialog-button.d.ts

@@ -0,0 +1,83 @@
+import { type PangoFontDescription } from '../font-description.js';
+import './gtk-popover.js';
+import './gtk-separator.js';
+/** `GtkFontLevel`'s four values, under the nicks a string property carries. */
+export type FontLevel = 'family' | 'face' | 'font' | 'features';
+/** `GtkFontDialog`'s own parameters; `font-map` has no browser counterpart and is absent. */
+export interface FontDialogParameters {
+    /** Whether the chooser is modal. Default `TRUE`, as in the GIR. */
+    modal?: boolean;
+    /** The chooser's title. Default `null`. */
+    title?: string | null;
+    /** The language font features are resolved against. Default `null`. */
+    language?: string | null;
+    /** Whether only scalable fonts are offered. */
+    filter?: number;
+}
+export declare class GtkFontDialogButton extends HTMLElement {
+    private _buttonEl;
+    private _labelEl;
+    private _sizeBoxEl;
+    private _sizeLabelEl;
+    private _dockEl;
+    private _selectEl;
+    private _desc;
+    private _dialog;
+    private _features;
+    private _language;
+    private _pending;
+    private _initialized;
+    static get observedAttributes(): string[];
+    /** `GtkFontDialogButton:font-desc` — the selected font, as a plain value. */
+    get fontDesc(): PangoFontDescription;
+    set fontDesc(value: PangoFontDescription | string);
+    /** `GtkFontDialogButton:font-features` — Pango's comma-separated feature list. */
+    get fontFeatures(): string;
+    set fontFeatures(value: string);
+    /** `GtkFontDialogButton:language` — the language font features resolve against. */
+    get language(): string | null;
+    set language(value: string | null);
+    /** `GtkFontDialogButton:level` — how much of the font the chooser offers. */
+    get level(): FontLevel;
+    set level(value: FontLevel);
+    /** `GtkFontDialogButton:use-font` — draw the family label in the selected font. */
+    get useFont(): boolean;
+    set useFont(value: boolean);
+    /** `GtkFontDialogButton:use-size` — draw the selected SIZE in the label too. */
+    get useSize(): boolean;
+    set useSize(value: boolean);
+    /** `GtkFontDialogButton:dialog` — the chooser this button opens, or `null` for none. */
+    get dialog(): FontDialogParameters | null;
+    set dialog(value: FontDialogParameters | null);
+    connectedCallback(): void;
+    attributeChangedCallback(name?: string): void;
+    /**
+     * The `::activate` action signal (:405-418), bound to `gtk_widget_activate (self->button)`
+     * (:540-546): activating the widget and pressing the button are the same thing, and
+     * both present the chooser.
+     */
+    activate(): void;
+    /** `button_clicked` (:548-585), with the level deciding which C handler would answer. */
+    private _openChooser;
+    /**
+     * The combinations this page can actually render, plus the one already held.
+     *
+     * `FontFaceSet.check()` is the browser's font map in one call, and it is a QUESTION
+     * ABOUT A DESCRIPTION, which is exactly the shape of Pango's face walk: the family is
+     * the outer loop, the face the inner one, and a combination that does not render is
+     * the face the family does not have.
+     */
+    private _options;
+    /** The four `*_chosen` handlers (:441-538), by level. */
+    private _choose;
+    /** `update_button_sensitivity` (:433-439), as the colour button's is (:380-391). */
+    private _renderSensitivity;
+    /** `update_font_info` (:649-687) plus `apply_use_font` (:689-720). */
+    private _render;
+    /**
+     * `font_description_style_equal` against the faces the page declares — the stand-in for
+     * the font-map walk `update_font_data` performs, and the name it prints when there is
+     * one.
+     */
+    private _faceName;
+}

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

@@ -0,0 +1,24 @@
+export declare class GtkFrame extends HTMLElement {
+    private _mutations;
+    static get observedAttributes(): string[];
+    /** The element's own `<gtk-label>`, built from `label` — null while no string is set. */
+    private _labelEl;
+    /** True while {@link _sync} writes `label` onto that widget, so its notify does not escape. */
+    private _writingLabel;
+    /** `Gtk.Frame:label` — the frame's label text, or null when it carries no label. */
+    get label(): string | null;
+    set label(value: string | null);
+    /**
+     * `Gtk.Frame:label-xalign` — where the label sits across the frame's width.
+     * `0` (the pspec default) puts it at the start, `1` at the end, `0.5` centred.
+     */
+    get labelXalign(): number;
+    set labelXalign(value: number);
+    /** The child in GTK's `label-widget` slot — the widget drawn in place of the text. */
+    get labelWidget(): HTMLElement | null;
+    set labelWidget(value: HTMLElement | null);
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, old: string | null, value: string | null): void;
+    private _sync;
+}

package/lib/types/elements/gtk-gl-area.d.ts

@@ -0,0 +1,136 @@
+/** `GdkGLAPI`'s nicks, as `GdkGLAPINickSet` spells them. */
+declare const APIS: readonly ["gl", "gles"];
+type GlApi = (typeof APIS)[number];
+/** A WebGL context, whichever version the browser handed out. */
+type GlContext = WebGLRenderingContext | WebGL2RenderingContext;
+export declare class GtkGLArea extends HTMLElement {
+    private _canvas;
+    private _messageEl;
+    private _initialized;
+    private _context;
+    private _error;
+    /** `gtk_gl_area_resize` is called from here, so `needs_resize` is a C field too. */
+    private _needsResize;
+    /** `priv->needs_render`, TRUE from `gtk_gl_area_init` (:1104). */
+    /** `priv->allowed_apis`, default `GDK_GL_API_GL | GDK_GL_API_GLES` (:1100). */
+    private _allowedApis;
+    private _needsRender;
+    /** `priv->have_buffers` (:392), dropped by the two buffer setters. */
+    private _haveBuffers;
+    private _width;
+    private _height;
+    private _scale;
+    private _resize;
+    private _frame;
+    static get observedAttributes(): string[];
+    /**
+     * `GtkGLArea:auto-render` — whether `::render` is emitted every time the widget draws.
+     * Defaults to TRUE (:1102, and `g_param_spec_boolean` at :924).
+     */
+    get autoRender(): boolean;
+    set autoRender(v: boolean);
+    /**
+     * `GtkGLArea:has-depth-buffer` — whether a depth buffer is allocated and the depth
+     * test enabled (:782-785, :408-417). Defaults to FALSE (:941).
+     */
+    get hasDepthBuffer(): boolean;
+    set hasDepthBuffer(v: boolean);
+    /** `GtkGLArea:has-stencil-buffer` — the stencil half of the same renderbuffer (:954). */
+    get hasStencilBuffer(): boolean;
+    set hasStencilBuffer(v: boolean);
+    /**
+     * `GtkGLArea:allowed-apis` — the APIs a created context may use (:983, :1100).
+     *
+     * The value lives in a field, not in the attribute, because the setter REFUSES a
+     * realized area and a refused write in a custom element has already moved the
+     * attribute — the C keeps the property and drops the call, this keeps the property and
+     * puts the attribute back.
+     */
+    get allowedApis(): GlApi[];
+    set allowedApis(v: GlApi[]);
+    /**
+     * The guard that makes "notify only on a real change" true: `setAttribute` runs the
+     * custom-element reaction for a write that changes nothing, while GTK's setters
+     * return early (:1522, :1197).
+     */
+    private _write;
+    /**
+     * `GtkGLArea:api` — the API in use, read-only in the GIR and defaulting to 0, which
+     * is `GDK_GL_API_GL`. A context in a browser is WebGL or WebGL2, both ES, so a
+     * realized area reports `gles` and an unrealized one the pspec's `0` — see the header.
+     */
+    get api(): GlApi;
+    /** `gtk_gl_area_get_context` (:1495-1508) — the context, or `null` when there is none. */
+    get context(): GlContext | null;
+    /** `gtk_gl_area_get_error` (:1533-1543) — the error set on the area, if any. */
+    get error(): string | null;
+    /** `gtk_gl_area_set_error` (:1545-1558). `null` clears it, which restores drawing. */
+    setError(error: Error | string | null): void;
+    /**
+     * `gtk_gl_area_make_current` (:1563-1572). A WebGL context is current for its own
+     * canvas and nowhere else, so there is nothing to switch — the method exists
+     * because the C's callers expect it to.
+     */
+    makeCurrent(): GlContext | null;
+    /**
+     * `gtk_gl_area_queue_render` (:1465-1474) — the render flag plus `queue_draw`.
+     *
+     * AND WHY THE DRAW IS NOT SYNCHRONOUS. `gtk_widget_queue_draw` marks the window dirty
+     * and the frame clock draws it LATER, so an application that queues per tick animates
+     * instead of recursing; a 2D-style synchronous draw would make the same application a
+     * stack overflow. An animation frame is the browser's frame clock, and coalescing
+     * through one keeps "ask for a frame" a scheduler.
+     *
+     * NOTE WHAT THE FLAG DOES NOT SURVIVE: `needs_render` is cleared AFTER the `::render`
+     * emit (:811), so a `queue_render()` from inside the handler has its flag overwritten
+     * and only the queued frame remains. That is the C's own behaviour, and it is why an
+     * animation asks from a tick callback rather than from the handler.
+     */
+    queueRender(): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /** `gtk_widget_queue_draw`: one frame, however many requests arrived before it. */
+    private _queueDraw;
+    attributeChangedCallback(name: string): void;
+    /** The `notify::` detail for `name`: the PROPERTY, parsed, not the raw attribute. */
+    private _notify;
+    private _observe;
+    /**
+     * The snapshot, in the C's order (gtkglarea.c:757-812). One pass, four early exits,
+     * and the two flags cleared only after the signals — see the header.
+     */
+    private _draw;
+    /**
+     * `gtk_gl_area_attach_buffers` (:583-618): the depth/stencil renderbuffer is created
+     * when either buffer is asked for and deleted when neither is — and `have_buffers`
+     * says which, so a redraw after one of the two setters is the frame that allocates
+     * it (:408-417). WebGL's equivalent is the depth and stencil TESTS plus the
+     * `depth`/`stencil` context attributes the element created the context with: a context
+     * cannot gain a buffer afterwards, which is why `_createContext` reads both properties
+     * before asking, and why the flag is what decides the tests are re-applied.
+     */
+    attachBuffers(context?: GlContext | null): void;
+    /**
+     * `::create-context` (:1086-1109) lets a handler supply the context, and GTK's handler
+     * RETURNS one. A browser event has no return channel, so the detail object is the
+     * channel: a handler that sets `detail.context` wins, and the element asks the
+     * browser only when nobody did.
+     */
+    private _createContext;
+    /**
+     * `gtk_gl_area_draw_error_screen` (:701-723): the message over the whole widget, at
+     * its own font, vertically centred. The canvas stays where it is — GTK's error screen
+     * replaces what a frame would have drawn, not the widget's own node — and the message
+     * node is removed again when the error clears, which is the redraw the C's setter
+     * queues (:1552-1556).
+     */
+    private _renderMessage;
+    /** The device-pixel viewport, for a spec that checks `::resize`. */
+    get viewport(): {
+        width: number;
+        height: number;
+    };
+    /** The scale factor the viewport is multiplied by (gtkglarea.c:761-763). */
+    get pixelScale(): number;
+}
+export {};

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;