@gjsify/adwaita-web 0.54.0 → 0.56.0

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

package/lib/types/elements/gtk-page-setup-unix-dialog.d.ts

@@ -0,0 +1,87 @@
+import { type PageSetup, type PageUnit } from '../page-setup.js';
+import { AdwDialog } from './adw-dialog.js';
+/** One row of the "Format for:" drop down. */
+export interface PrinterInfo {
+    /** `gtk_printer_get_name` — what `format-for-printer` is compared against. */
+    readonly name: string;
+    /** `gtk_printer_get_location`, the dimmed second line of the row. */
+    readonly location?: string;
+}
+/** The one `GtkPrintSettings` key this dialog reads or writes. */
+export interface PrintSettingsData {
+    /** `format-for-printer` — the printer name the settings belong to. */
+    readonly 'format-for-printer'?: string;
+}
+export declare class GtkPageSetupUnixDialog extends AdwDialog {
+    private _built;
+    static get observedAttributes(): string[];
+    private _printerEl;
+    private _paperEl;
+    private _sizeLabelEl;
+    private _radios;
+    private _printers;
+    /** The setups in the drop-down, in the order the C appends them. */
+    private _setups;
+    /** `last_setup` — the size the drop down is put back to when a row is not a size. */
+    private _lastSetup;
+    private _printSettings;
+    private _unit;
+    /** The unit the two labels speak — `_gtk_print_get_default_user_units` is mm here. */
+    get unit(): PageUnit;
+    set unit(value: PageUnit);
+    /**
+     * The printer list GTK discovers through a print backend. A browser has no CUPS, so
+     * this is an INPUT; the row every dialog starts with is added by the element itself.
+     */
+    get printers(): PrinterInfo[];
+    set printers(value: readonly PrinterInfo[]);
+    /**
+     * The current page setup — `gtk_page_setup_unix_dialog_get_page_setup`, which returns
+     * the SELECTED setup with the orientation the radios hold.
+     */
+    get pageSetup(): PageSetup;
+    /**
+     * `gtk_page_setup_unix_dialog_set_page_setup`: select the matching row, appending the
+     * setup when no row matches (`set_paper_size` with `add_item` TRUE), then set the
+     * orientation radios.
+     */
+    set pageSetup(value: PageSetup);
+    /** `gtk_page_setup_unix_dialog_get_print_settings` — the object, not a copy of it. */
+    get printSettings(): PrintSettingsData | null;
+    /** Selects the printer named by `format-for-printer`, as the setter does. */
+    set printSettings(value: PrintSettingsData | null);
+    connectedCallback(): void;
+    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
+    private _build;
+    /** A `GtkDropDown` with its label as the accessible name, `column-span 3`. */
+    private _dropDown;
+    /** A grid label — right-aligned, `use-underline` in the `.ui`, no keyvals here. */
+    private _label;
+    /**
+     * The `.dialog-action-area` row: `_Cancel` (GTK_RESPONSE_CANCEL) and `_Apply`
+     * (GTK_RESPONSE_OK), which is the label `gtk_dialog_add_buttons` gives the OK response
+     * in this dialog. Escape is the close action the base class already binds.
+     */
+    private _actions;
+    private _respond;
+    /** The drop-down's rows: the pseudo printer first, then the caller's. */
+    private _printerRows;
+    /**
+     * `fill_paper_sizes_from_printer` (:470-491): with no printer — which includes the
+     * "Any Printer" row, because `printer_changed_callback` clears it before the call
+     * (:576-580) — the list is the twelve common sizes. A REAL printer would bring its
+     * own `gtk_printer_list_papers`, which needs the backend this port has not.
+     */
+    private _fillPaperSizes;
+    /** The selected setup, before the radios' orientation is folded in. */
+    private _current;
+    private _orientation;
+    private _setOrientation;
+    private _renderSetup;
+    /** `printer_changed_callback` (:557-609): the paper list follows the printer. */
+    private _printerChanged;
+    /** `paper_size_changed` (:635-758). */
+    private _paperChanged;
+    /** The radios' side of `get_orientation` — the label follows them. */
+    private _orientationChanged;
+}

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

@@ -0,0 +1,121 @@
+import { type BoxOrientation } from '@gjsify/adwaita-core';
+/** The inputs of `gtk_paned_compute_position`, one per field it reads. */
+export interface PanedPositionInput {
+    /** The paned's own allocation along the axis, minus the handle — its `allocation`. */
+    allocation: number;
+    /** The start child's size REQUEST along the axis. */
+    startRequest: number;
+    /** The end child's size REQUEST along the axis. */
+    endRequest: number;
+    resizeStart: boolean;
+    resizeEnd: boolean;
+    shrinkStart: boolean;
+    shrinkEnd: boolean;
+    /** `position_set` — whether the app or the user has placed the divider. */
+    positionSet: boolean;
+    /** `start_child_size` — the divider as last allocated or set; `0` when unset. */
+    startChildSize: number;
+    /** `last_allocation` — what `startChildSize` was measured against. */
+    lastAllocation: number;
+}
+/** What `gtk_paned_compute_position` writes back through its three out-parameters. */
+export interface PanedPosition {
+    min: number;
+    max: number;
+    position: number;
+}
+/**
+ * `gtk_paned_compute_position` (gtkpaned.c:1092-1146), statement for statement.
+ *
+ * Exported so a spec can pin the arithmetic without a layout. The branch keyed on
+ * `lastAllocation` is the one a browser cannot reach on its own — there is no "position was
+ * set before the first allocation" moment in a flex layout — so it is the piece only a table
+ * of inputs can hold.
+ */
+export declare function computePanedPosition(input: PanedPositionInput): PanedPosition;
+export declare class GtkPaned extends HTMLElement {
+    private _startEl;
+    private _handleEl;
+    private _endEl;
+    private _initialized;
+    /** `start_child_size` — the divider. `-1` is GTK's "unset". */
+    private _position;
+    /** `position_set` — GTK's read-only flag; see the header. */
+    private _positionSet;
+    /** What `gtk_paned_compute_position` last produced for `min_position`. */
+    private _minPosition;
+    /** …and for `max_position`. */
+    private _maxPosition;
+    /** `last_allocation` — the allocation the current position was computed against. */
+    private _lastAllocation;
+    /** `drag_pos` — where inside the handle the gesture began (gtkpaned.c:930-940). */
+    private _dragPos;
+    private _dragging;
+    private _resize;
+    static get observedAttributes(): string[];
+    /** `GtkOrientable:orientation` — which way the divider runs. */
+    get orientation(): BoxOrientation;
+    set orientation(value: BoxOrientation);
+    /** `Gtk.Paned:position` — the divider in pixels; `-1` puts it back to derived. */
+    get position(): number;
+    set position(value: number);
+    /** `Gtk.Paned:position-set` — read-only in GTK; only `position` moves it. */
+    get positionSet(): boolean;
+    /** `Gtk.AccessibleRange:min-position` as the last computation left it. */
+    get minPosition(): number;
+    /** `Gtk.AccessibleRange:max-position` as the last computation left it. */
+    get maxPosition(): number;
+    /** `Gtk.Paned:wide-handle` — the stronger visual separation. */
+    get wideHandle(): boolean;
+    set wideHandle(value: boolean);
+    /** `Gtk.Paned:start-child` — the light-DOM node in the leading pane. */
+    get startChild(): Element | null;
+    /** `Gtk.Paned:end-child` — the light-DOM node in the trailing pane. */
+    get endChild(): Element | null;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    private _property;
+    private _observe;
+    /** `gtk_paned_set_position` (gtkpaned.c:1874-1910), with its two notifications. */
+    private setPosition;
+    /** `gtk_paned_calc_position` (gtkpaned.c:1021-1053): compute, place, notify, remember. */
+    private _layout;
+    /**
+     * A child's SIZE REQUEST — what `gtk_widget_measure` answers with.
+     *
+     * `flex: none` pins the item to its content size, which is exactly a GTK size request,
+     * and the read is one forced reflow. It has to be a separate pass: the laid-out size of a
+     * pane that is currently `flex-grow: 1` is its ALLOCATION, and feeding that back as a
+     * request is how a paned ends up re-deriving its own divisor.
+     */
+    private _sizeRequest;
+    /**
+     * `shrink-*` is "can this child be made smaller than its requisition", which in CSS is
+     * whether the AUTOMATIC minimum applies — `min-width: auto` is the flex automatic
+     * minimum, so `min-width: 0` is the permission and leaving the longhand alone is the
+     * prohibition.
+     */
+    private _applyMinimum;
+    /**
+     * `notify::<property>`, with the DETAIL keyed by the JS property name — the spelling
+     * `<adw-expander-row>`, `<adw-entry-row>` and `<gtk-switch>` use, and the one a caller
+     * destructures. `notify::position-set` therefore carries `{ positionSet }`.
+     */
+    private _notify;
+    /** `is_rtl` (gtkpaned.c:1533-1536): only a horizontal paned mirrors. */
+    private get _isRtl();
+    /** `gesture_drag_begin_cb` (gtkpaned.c:915-955) — the capture and `drag_pos`. */
+    private readonly _onPointerDown;
+    /** `update_drag` (gtkpaned.c:1538-1573), from the capture phase. */
+    private readonly _onPointerMove;
+    private readonly _onPointerUp;
+    /**
+     * `gtk_paned_move_handle` (gtkpaned.c:2286-2353) over `add_move_binding`'s key list
+     * (gtkpaned.c:768-785). `Escape` and `Return`/Space are `cancel-position` /
+     * `accept-position`, which GTK binds to no handler of its own — they are the signals an
+     * embedding application listens for — so they are dispatched as events and left to
+     * bubble rather than swallowed here.
+     */
+    private readonly _onKeyDown;
+}

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

@@ -0,0 +1,27 @@
+import { GtkEntry } from './gtk-entry.js';
+export declare class GtkPasswordEntry extends GtkEntry {
+    /** The headless peek + caps-lock derivation, composing the entry's own state. */
+    private readonly _entry;
+    private readonly _password;
+    private _toggle;
+    private _peekIcon;
+    private _capsLock;
+    static get observedAttributes(): string[];
+    /** Whether the contents are shown in clear text (`GtkText:visibility`). */
+    get revealed(): boolean;
+    set revealed(value: boolean);
+    /** Whether Caps Lock is engaged, as last observed from a keyboard event. */
+    get capsLockOn(): boolean;
+    /**
+     * Feed the platform's Caps Lock state in — GDK reads it off the keyboard device
+     * (`gdk_device_get_caps_lock_state`), which a browser exposes only on keyboard events.
+     * Public so a host that knows better (a virtual keyboard, a test) can drive it directly.
+     */
+    setCapsLockOn(on: boolean): void;
+    connectedCallback(): void;
+    attributeChangedCallback(name: string, oldValue: string | null, value: string | null): void;
+    /** A focus change re-derives, because the warning's visibility is `editing && …`. */
+    private _passwordChanged;
+    /** `notify_visibility_cb`, applied to the DOM. */
+    private _applyPassword;
+}

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

@@ -0,0 +1,66 @@
+/** `GtkContentFit`, in enum order — the four nicks the GIR and CSS share. */
+export declare const PICTURE_CONTENT_FIT_MODES: readonly ["fill", "contain", "cover", "scale-down"];
+export type PictureContentFit = (typeof PICTURE_CONTENT_FIT_MODES)[number];
+/** `GTK_CONTENT_FIT_CONTAIN`, the default the C installs (gtkpicture.c:530, :555). */
+export declare const DEFAULT_PICTURE_CONTENT_FIT: PictureContentFit;
+/**
+ * `GtkPicture:content-fit` from its nick, with the C's own guard: an unknown nick is left
+ * to the default rather than coerced to `fill`, which is the one value that would silently
+ * distort every picture a page writes.
+ */
+export declare function normalizePictureContentFit(value: unknown): PictureContentFit;
+export declare class GtkPicture extends HTMLElement {
+    private _initialized;
+    static get observedAttributes(): string[];
+    /**
+     * `GtkPicture:alternative-text` (gtkpicture.c:474-483) — the accessible NAME of the
+     * picture. It is NOT `alt`: the GIR property is `alternative-text`, and the element
+     * carries that spelling so the attribute and the property are one write.
+     */
+    get alternativeText(): string;
+    set alternativeText(value: string);
+    /** `GtkPicture:can-shrink` (gtkpicture.c:486-497). Defaults to TRUE (gtkpicture.c:554). */
+    get canShrink(): boolean;
+    set canShrink(value: boolean);
+    /** `GtkPicture:content-fit` (gtkpicture.c:520-531). Defaults to CONTAIN. */
+    get contentFit(): PictureContentFit;
+    set contentFit(value: PictureContentFit);
+    /**
+     * `GtkPicture:isolate-contents` (gtkpicture.c:538-549). Defaults to TRUE
+     * (gtkpicture.c:555) — the same absent-is-true rule {@link canShrink} follows, and for
+     * the same reason: the C installs the value in `init`, before any attribute is read.
+     */
+    get isolateContents(): boolean;
+    set isolateContents(value: boolean);
+    /**
+     * `GtkPicture:keep-aspect-ratio` — DEPRECATED in 4.8, and implemented rather than
+     * dropped, because the C did not drop it (gtkpicture.c:1006-1040).
+     *
+     * The setter is a MAPPING, not a stored boolean (gtkpicture.c:1017-1021): TRUE sets
+     * `content-fit` to CONTAIN, FALSE sets it to FILL. The getter is the INVERSE test over
+     * the live `content-fit` (gtkpicture.c:1040), so a picture authored as `cover` or
+     * `scale-down` reads `true` back — those two preserve the ratio, exactly as CONTAIN
+     * does, and returning `false` for them would contradict the property's own definition.
+     */
+    get keepAspectRatio(): boolean;
+    set keepAspectRatio(value: boolean);
+    /**
+     * `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
+     * (gtkpicture.c:1111-1112). This is the guard that makes "notify only on a real
+     * change" true.
+     */
+    private _write;
+    /**
+     * A boolean whose GIR default is TRUE needs three states, not two: absent means TRUE
+     * (the default the C installs in `init`), `=""` means TRUE, and `="false"` means FALSE.
+     * `toggleAttribute` alone would make absent and empty the same state, which is right for
+     * a FALSE-defaulted property and wrong for every one of these three.
+     */
+    private _toggle;
+    connectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    /** The `notify::` detail for `name`: the PROPERTY, parsed, not the raw attribute. */
+    private _property;
+    private _render;
+}