@gjsify/adwaita-web 0.53.0 → 0.55.0

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

@@ -0,0 +1,97 @@
+/** The four overlay glyphs, in the order `update_overlay_icon` tests them (gtkvideo.c:626-646). */
+export type VideoOverlayIcon = 'media-eject-symbolic' | 'dialog-error-symbolic' | 'media-playlist-repeat-symbolic' | 'media-playback-start-symbolic';
+/**
+ * The glyph a video with NO stream draws — the FIRST arm of the four-way choice
+ * (gtkvideo.c:629), because "there is nothing here to play" is the state every GtkVideo
+ * starts in.
+ */
+export declare const NO_STREAM_ICON = "media-eject-symbolic";
+/** The glyph a stream that FAILED draws (gtkvideo.c:633) — tested before `ended`. */
+export declare const ERROR_ICON = "dialog-error-symbolic";
+/** The glyph a stream that has ENDED draws (gtkvideo.c:638-639). */
+export declare const ENDED_ICON = "media-playlist-repeat-symbolic";
+/** The glyph a READY stream draws (gtkvideo.c:645) — the arm everything else falls through to. */
+export declare const READY_ICON = "media-playback-start-symbolic";
+/** `gtk_video_reveal_controls`' timeout: 3 s (gtkvideo.c:130). */
+export declare const CONTROLS_HIDE_MS = 3000;
+export declare class GtkVideo extends HTMLElement {
+    private _initialized;
+    private _overlayIcon;
+    private _controlsRevealer;
+    private _media;
+    /** The listeners currently bound on `_media`, so `_detachMedia` removes the SAME ones. */
+    private mediaListeners;
+    private _hideTimer;
+    /** What the media element last told us, in the four fields the overlay choice reads. */
+    private _hasStream;
+    private _error;
+    private _ended;
+    private _playing;
+    static get observedAttributes(): string[];
+    /**
+     * `GtkVideo:autoplay` (gtkvideo.c:407-414). Defaults to FALSE. The C plays on the
+     * stream's `prepared` notification and not on this write — see the header — so this
+     * setter records the flag and lets the media's own readiness decide.
+     */
+    get autoplay(): boolean;
+    set autoplay(value: boolean);
+    /** `GtkVideo:loop` (gtkvideo.c:432-439). Defaults to FALSE. A plain `<video loop>`. */
+    get loop(): boolean;
+    set loop(value: boolean);
+    /**
+     * `GtkVideo:graphics-offload` (gtkvideo.c:400-406, :1010-1023). Defaults to FALSE — the
+     * template ships `<property name="enabled">disabled</property>` (ui/gtkvideo.ui), so the
+     * C starts with the offload OFF and an application has to ask for it.
+     *
+     * Stored, readable and class-flagged, and NOTHING ELSE HAPPENS: CSS has no way to move a
+     * subtree into a shared GPU texture, which is what `GtkGraphicsOffload` is. The class is
+     * `graphics-offload` so a page can still target it, and `KNOWN_GAPS` in
+     * `check-adwaita-element-properties.mjs` does not list it because the PROPERTY is
+     * observed — what it does not buy is a faster composite.
+     */
+    get graphicsOffload(): boolean;
+    set graphicsOffload(value: boolean);
+    /** The `<video>` this element drives — the browser's answer to a `GtkMediaStream`. */
+    get media(): HTMLVideoElement | null;
+    /** Whether the media reports itself playing — `GtkVideo:playing` (`gtk_video_get_playing`). */
+    get playing(): boolean;
+    /** The current position in SECONDS — the C's `timestamp`, in microseconds × 1000. */
+    get timestamp(): number;
+    /** The media's duration in SECONDS — the C's `duration`; 0 while it is unknown. */
+    get duration(): number;
+    /** Whether the overlay controls bar is currently revealed. */
+    get controlsRevealed(): boolean;
+    private _write;
+    connectedCallback(): void;
+    /**
+     * `ui/gtkvideo.ui` keeps the author's `<video>` as the MAIN child of the overlay and adds
+     * the two overlay children around it. Wrapping in place rather than re-creating is what
+     * lets the light DOM stay the API: a page writes `<gtk-video><video src=…></video></gtk-video>`
+     * and the element never has to be told where the media is.
+     */
+    private _wrap;
+    private _adoptMedia;
+    private _detachMedia;
+    /** `autoplay` and `loop` are declared PROPERTIES of the widget, so they are applied to
+     * the media rather than left to the author's markup — `ui/gtkvideo.ui` does the same by
+     * binding them on the template. */
+    private _syncMedia;
+    private _overlayClicked;
+    /**
+     * `gtk_video_reveal_controls` (gtkvideo.c:125-133): reveal, then arm a 3 s timeout that
+     * hides it again. Re-arming on every call is what makes it a "three seconds after the
+     * LAST movement" rather than a "three seconds after the first".
+     */
+    revealControls(): void;
+    private _hideControls;
+    /** `gtk_video_motion` (ui/gtkvideo.ui) — the motion controller's only job. */
+    private _onPointerMove;
+    attributeChangedCallback(name: string): void;
+    /** The `notify::` detail for `name`: the PROPERTY, parsed, not the raw attribute. */
+    private _property;
+    /** `gtk_video_update_playing` (gtkvideo.c:658-666) — VISIBILITY, not an icon swap. */
+    private _updatePlaying;
+    /** `gtk_video_update_overlay_icon` (gtkvideo.c:626-646), arm by arm. */
+    private _updateOverlayIcon;
+    disconnectedCallback(): void;
+}

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

@@ -0,0 +1,84 @@
+import { type AdwAdjustment } from '@gjsify/adwaita-core';
+/** The two axes a scrollport reports numbers for, in the order GTK declares them. */
+declare const AXES: readonly ["horizontal", "vertical"];
+type Axis = (typeof AXES)[number];
+export declare class GtkViewport extends HTMLElement {
+    private _observer;
+    private _watch;
+    static get observedAttributes(): string[];
+    /**
+     * `GtkScrollable:hadjustment` — the horizontal position, as the portable value.
+     *
+     * Computed on read rather than stored: `viewport_set_adjustment_values` reconfigures both
+     * axes on every allocation, so there is no state to cache and nothing an author can write.
+     */
+    get hadjustment(): AdwAdjustment;
+    /** `GtkScrollable:vadjustment` — the vertical position, as the portable value. */
+    get vadjustment(): AdwAdjustment;
+    /**
+     * `GtkViewport:scroll-to-focus` — whether the viewport keeps the focus widget in view.
+     * TRUE in the pspec (gtkviewport.c:338-340), and an unknown value is the DEFAULT rather
+     * than "off": only the literal `false` turns it off, which is what FALSE in a construct
+     * bag means and what a boolean attribute has to spell out to be read at all.
+     */
+    get scrollToFocus(): boolean;
+    set scrollToFocus(value: boolean);
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /**
+     * Announce whenever a number the adjustments are made of has changed.
+     *
+     * GTK reconfigures both axes on every allocation — `viewport_set_adjustment_values` runs
+     * out of `size_allocate`, and `gtk_adjustment_configure` compresses the notifications into
+     * one. A browser reports the same event as the scrollport's own box changing (this
+     * element) and its CONTENT changing (the children), and neither is the other's: a child
+     * that grows leaves the viewport's box exactly where it was, which is why BOTH are watched.
+     * The content watcher is what makes a scrolled window's bars appear the moment content
+     * lands in it, and it is `gtk_widget_queue_resize` on the child propagating upward.
+     */
+    private _observe;
+    attributeChangedCallback(name: string): void;
+    /**
+     * `gtk_adjustment_set_value` on one of the viewport's OWN adjustments — the half of a
+     * scrolled window's job that moves content rather than deciding whether to.
+     *
+     * The value is clamped first, which is `set_value`'s documented behaviour ("The value is
+     * clamped to lie between lower and upper") and the reason a bar may ask for a position its
+     * own range has just outgrown.
+     */
+    scrollAxis(axis: Axis, value: number): void;
+    /**
+     * `gtk_viewport_scroll_to` — move the position so `descendant` is inside the window.
+     * `null` asks only for the position to be CLAMPED, which is what a content that shrank
+     * needs from a value that was legal a moment ago.
+     *
+     * GTK animates the move (`gtk_adjustment_animate_to_value`, gtkviewport.c:757-758) for
+     * `ANIMATION_DURATION` unless the widget should not animate — the browser's spelling of
+     * that setting is `prefers-reduced-motion`, and `scrollIntoView`'s own `behavior` is where
+     * the choice belongs.
+     *
+     * `scrollTo` IS a platform method with an options form, so both are here and the KIND of
+     * the argument decides: a node is GTK's `scroll_to(descendant)` and anything else is the
+     * scrollport's own `scrollTo(options)`, which this element is (one element for the two
+     * GTK nodes is the port's own decision, see the header).
+     */
+    scrollTo(descendant: Element | null): void;
+    scrollTo(options?: ScrollToOptions): void;
+    scrollTo(x: number, y: number): void;
+    /** The adjustments of both axes, as the detail of the `value-changed` event. */
+    get adjustments(): {
+        hadjustment: AdwAdjustment;
+        vadjustment: AdwAdjustment;
+    };
+    /**
+     * One event for both adjustments: a browser scroll moves them together, and the C's
+     * `GtkAdjustment::value-changed` is a signal of the ADJUSTMENT rather than of the viewport
+     * that reads it. Bubbling, so `<gtk-scrolled-window>` hears it without holding a reference
+     * to anything in here.
+     */
+    private _announce;
+    /** `setup_focus_change_handler` / `clear_focus_change_handler`, on one event instead of a root signal. */
+    private _bindFocus;
+    private _onFocusIn;
+}
+export {};

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

@@ -0,0 +1,80 @@
+/** `Gtk.PackType`, spelled as the GIR's enum nicks (gtkwindowcontrols.c:68). */
+type PackSide = 'start' | 'end';
+/** What a press asks for: the `GtkActionable` action name minus its `window.` prefix. */
+export type WindowAction = 'minimize' | 'toggle-maximized' | 'close';
+export declare class GtkWindowControls extends HTMLElement {
+    private _initialized;
+    private _empty;
+    /** The frame this controls answers to, or `null` outside one (`:257-263`). */
+    private _window;
+    private _windowObserver;
+    static get observedAttributes(): string[];
+    /** `Gtk.WindowControls:side` — which half of the decoration layout to build. */
+    get side(): PackSide;
+    set side(value: PackSide);
+    /** `Gtk.WindowControls:use-native-controls` — a macOS-only branch; see KNOWN_GAPS. */
+    get useNativeControls(): boolean;
+    /**
+     * `Gtk.WindowControls:empty` (read-only in GIR). TRUE — the GIR default (:618) — until a
+     * render finds a button, which is what happens outside a window.
+     */
+    get empty(): boolean;
+    /** `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;
+    /**
+     * Bind to the frame above, the way `gtk_window_controls_root` binds to the settings and
+     * to `notify` on the window (:443-462) — then run the build, which is that handler's
+     * first act. Re-established on every connect: a bar moved into another window has a new
+     * ancestor, which is why C does it in `root` and drops it in `unroot`.
+     */
+    private _followWindow;
+    /** `is_sovereign_window` (gtkwindowcontrols.c:272-273): neither modal nor transient. */
+    private _isSovereign;
+    /**
+     * The window property, in ITS polarity. `resizable` and `deletable` default TRUE
+     * (gtkwindow.c:893, :1024) and `maximized` defaults FALSE (:1044), so one helper reading
+     * them alike would put a maximize button on a window that cannot be maximized — and a
+     * restore glyph on every window there is.
+     */
+    private _windowFlag;
+    /**
+     * `get_layout` (gtkwindowcontrols.c:120-176), reduced to what a page can answer: this
+     * widget's own value, then the frame's, then GNOME's default. The first ':' splits the
+     * layout in two, and a layout with no ':' is the same half on both sides.
+     */
+    private _layoutHalf;
+    /** `update_window_buttons` (gtkwindowcontrols.c:247-426), token for token. */
+    private _render;
+    /** Every render writes the class, whether the VALUE moved or not — see {@link _setEmpty}. */
+    private _applyEmptyClass;
+    /** The one child a token builds, or `null` for the tokens that build nothing here. */
+    private _buttonFor;
+    /**
+     * `update_window_icon` (gtkwindowcontrols.c:187-210): the icon node is `presentation` to
+     * an accessibility tree, and it is dropped when the window has no icon — which for a
+     * frame means no `icon-name`, the analogue of a window with no `GdkPaintable`.
+     */
+    private _windowIcon;
+    /**
+     * One `GtkButton` with its `GtkImage` child. A plain `<button>` rather than
+     * `<gtk-button>`: libadwaita's own rules select `windowcontrols > button > image`
+     * (refs/libadwaita/src/stylesheet/widgets/_header-bar.scss:178-202), so the button IS
+     * the widget node here, and `<gtk-button>` would wrap a second one inside it.
+     */
+    private _controlButton;
+    /**
+     * `set_empty` (gtkwindowcontrols.c:216-230): a style class, and a notify of its own.
+     *
+     * The early return is about the NOTIFY, and it is the whole of C's `if (empty ==
+     * self->empty) return;`. The CLASS is not part of that comparison here: `empty` starts
+     * TRUE, so the first render outside a window is a no-op against C and the widget was
+     * left wearing nothing at all — a property whose style class only appears once it has
+     * been wrong and then right again.
+     */
+    private _setEmpty;
+}
+export {};

package/lib/types/elements/gtk-window-handle.d.ts

@@ -0,0 +1,39 @@
+/** `GtkTitlebarGesture`'s three gestures, as `perform_titlebar_action` decides them. */
+export type GtkTitlebarGesture = 'double-click' | 'middle-click' | 'right-click';
+/** The settings' own vocabulary, `none` included: "the compositor declined" is one. */
+export type GtkTitlebarAction = 'toggle-maximize' | 'lower' | 'minimize' | 'menu' | 'none';
+export declare class GtkWindowHandle extends HTMLElement {
+    /** The gesture in progress, as `priv->drag_start_x` / `_y` are in the C. */
+    private _drag;
+    /**
+     * The three gesture SETTINGS, spelled out.
+     *
+     * `GESTURES` above names the same three, and the list is written rather than computed
+     * from it because `scripts/adwaita-elements.mjs` reads `observedAttributes` as an array
+     * LITERAL: a `.map()` over a table reads as an unreadable element there, which is
+     * reported as "this reader cannot tell" rather than as the three attributes it is.
+     */
+    static get observedAttributes(): string[];
+    /** The action one gesture is set to, as the settings are read in C. */
+    actionFor(gesture: GtkTitlebarGesture): GtkTitlebarAction;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /**
+     * `perform_titlebar_action_fallback`: raise the action GTK would have activated, and
+     * then the event NAMED for it.
+     *
+     * Both fire for every gesture, `none` included: the first is what a consumer reads to
+     * know a titlebar was clicked at all — the C's `retval = FALSE`, where the compositor
+     * declined, is a fact worth reporting — and the second is what a window host binds to.
+     */
+    private _perform;
+    private _onClick;
+    private _onPointerDown;
+    /**
+     * `drag_gesture_update_cb`: past the threshold the WINDOW moves, and the sequence is
+     * reset so the gesture does not repeat. The move is a compositor operation, so what is
+     * emitted is the INTENT, with the pointer's position where GTK hands `begin_move` its
+     * own surface coordinates.
+     */
+    private _onPointerMove;
+}

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

@@ -0,0 +1,97 @@
+import { type AdwSlot } from '../slotted-children.js';
+import './gtk-window-controls.js';
+export declare class GtkWindow extends HTMLElement {
+    private _initialized;
+    /** The `titlebar` strip — `protected` so a subclass can place its own strips around it. */
+    protected _titlebar: HTMLDivElement;
+    /** Every child the window has no slot name for. */
+    protected _content: HTMLDivElement;
+    /** The SSD controls the strip draws when the window has no titlebar of its own. */
+    private _startControls;
+    private _endControls;
+    /** The window's own title in the strip, or `null` when a titlebar holds it. */
+    private _titleLabel;
+    /** Watches the strip for an author's titlebar arriving after the build. */
+    private _titlebarObserver;
+    static get observedAttributes(): string[];
+    /** `Gtk.Window:title` — the window's title. */
+    get title(): string | null;
+    set title(value: string | null);
+    /** `Gtk.Window:decorated` — whether the frame and its titlebar strip are drawn at all. */
+    get decorated(): boolean;
+    set decorated(value: boolean);
+    /** `Gtk.Window:maximized` — square corners and the restore glyph. */
+    get maximized(): boolean;
+    set maximized(value: boolean);
+    /** `Gtk.Window:resizable` — whether the maximize button may appear. */
+    get resizable(): boolean;
+    set resizable(value: boolean);
+    /** `Gtk.Window:deletable` — whether the close button may appear. */
+    get deletable(): boolean;
+    set deletable(value: boolean);
+    /**
+     * `setAttribute` for a write that changes nothing. Every GObject setter here returns
+     * early when the value is already right (gtkwindow.c:1015-1017, :1045-1046, :894-895),
+     * and a boolean property whose value did not move must not notify.
+     */
+    protected _write(name: string, value: string | null): void;
+    /**
+     * The two default polarities, because one of them is wrong for half of this widget.
+     *
+     * `decorated`, `resizable` and `deletable` default TRUE (gtkwindow.c:1014, :893, :1024)
+     * and `maximized`, `fullscreened`, `modal` and `hide-on-close` default FALSE (:1044,
+     * :1060, :903, :945). Reading them all through one helper is how a bare `<gtk-window>`
+     * ended up wearing `.maximized` and `.fullscreen` — square corners and no shadow, on a
+     * window that had never been maximized.
+     */
+    private _onByDefault;
+    private _offByDefault;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /**
+     * A `slot="titlebar"` child adopted AFTER the build has to take the strip over from the
+     * server-side decoration, and `_render` is the one that notices — nothing else here runs
+     * when a child lands. Observed on `_titlebar`, which is where the adopted child goes,
+     * because `bindSlottedChildren` already watches the host for it.
+     *
+     * Re-established on every connect, so a window moved between parents keeps it.
+     */
+    private _watchTitlebar;
+    /**
+     * The strips the frame is built from, in order. A subclass with a strip of its own —
+     * `<gtk-application-window>`'s menubar — adds it here, which is the only reason this pair
+     * exists: `install()` takes the structure and the slots at once, and the ORDER is that
+     * call's invariant (see `slotted-children.ts`).
+     */
+    protected strips(): Node[];
+    /** The slots a subclass adds beside `titlebar`; none by default. */
+    protected extraSlots(): AdwSlot[];
+    attributeChangedCallback(name: string): void;
+    private _property;
+    private _render;
+    /**
+     * The strip, in the two shapes a window can be in. With a `titlebar` child the strip
+     * holds exactly that — GTK hands the whole titlebar to the bar, decorations and all. With
+     * none it holds the two `<gtk-window-controls>` and the window's title, which is the
+     * server-side decoration GTK would otherwise have asked the window manager to draw and
+     * which a page has to draw for itself.
+     */
+    private _renderTitlebar;
+    /** The frame controls' `GtkActionable` names, answered here — gtkwindow.c:1274-1287. */
+    private _onWindowAction;
+    /**
+     * `gtk_window_close` (gtkwindow.c:1274-1287): emit `close-request` and, if nothing handled
+     * it, hide the window when `hide-on-close` is set and DESTROY it otherwise. "Destroy" is
+     * the one word this port cannot mean — a page has no unref — so the default detaches the
+     * frame, which is the same observable outcome for everything above it.
+     */
+    close(): boolean;
+    /**
+     * `gtk_window_maximize`. ASYNCHRONOUS in GTK — the GIR says so at gtkwindow.c:1044 — so
+     * the property is the thing a caller watches, and this writes it directly rather than
+     * pretending to round-trip a compositor.
+     */
+    maximize(): void;
+    /** `gtk_window_unmaximize`, with the same caveat as {@link maximize}. */
+    unmaximize(): void;
+}

package/lib/types/elements/justification.d.ts

@@ -0,0 +1,2 @@
+import type { LabelJustification } from '@gjsify/adwaita-core';
+export declare const JUSTIFY_TEXT_ALIGN: Record<LabelJustification, string>;

package/lib/types/elements/popover-menu.d.ts

@@ -45,6 +45,24 @@ export declare class PopoverMenuView {
     private _onKeyDown;
     /** Every row of the open page, in order — including the ones no key can reach. */
     get rows(): readonly HTMLButtonElement[];
+    /**
+     * The path of the page showing; `[]` is the root.
+     *
+     * Public because `GtkPopoverMenu:visible-submenu` IS this: GTK's value is the
+     * `GtkStack` child's name (gtkpopovermenu.c:755-757), and the stack child's identity
+     * here is the path that leads to it. Reading it is how the element answers the
+     * property without keeping a second copy of the open page beside this one.
+     */
+    get page(): AdwMenuPath;
+    /**
+     * Point the view at `path` without rendering — {@link render} does that, and doing it
+     * here as well would rebuild the rows twice per change.
+     *
+     * Distinct from {@link reset} because it NAMES the destination: a popover menu can be
+     * opened straight into a submenu, and a caller that had to open the parent first and
+     * then click into it would be reporting the reader's journey as the widget's state.
+     */
+    showPage(path: AdwMenuPath): void;
     /**
      * The rows a key can actually REACH, which is the only list worth focusing into.
      *

package/lib/types/elements/roving-focus.d.ts

@@ -1,12 +1,28 @@
 /** Which axis the items are laid out along — it decides which arrow keys move. */
 export type AdwRovingOrientation = 'horizontal' | 'vertical';
+/**
+ * Where one key lands, given where the cursor is.
+ *
+ * The DEFAULT is the neighbouring index, which is what a single run of items means. A widget
+ * whose two axes do NOT both mean "one along" supplies its own: `Gtk.FlowBox` binds
+ * `GTK_MOVEMENT_VISUAL_POSITIONS` sideways and `GTK_MOVEMENT_DISPLAY_LINES` vertically
+ * (gtkflowbox.c:3944-3951), and against a grid those differ — from the last cell of a full
+ * line, "left" is the first cell of the next one by INDEX and one row UP by POSITION.
+ */
+export type AdwRovingStep = (items: readonly HTMLElement[], from: number, direction: -1 | 1) => number | null;
 export interface AdwRovingFocusInit {
     /**
      * The element the listener sits on — the custom element itself, so items rebuilt at
      * any time are still covered.
      */
     host: HTMLElement;
-    orientation: AdwRovingOrientation;
+    /**
+     * Which axis the arrows move along. A FUNCTION where the widget is a `GtkOrientable`
+     * and can be turned after the listener is installed — `<gtk-list-view>` and
+     * `<gtk-flow-box>` are, and a value read once at install time pointed its arrow keys at
+     * the axis it had at connect for the rest of its life.
+     */
+    orientation: AdwRovingOrientation | (() => AdwRovingOrientation);
     /**
      * The items a key may land on, in visual order. The widget filters: a `hidden` or
      * `disabled` item is not navigable, and leaving one in would strand the user on a
@@ -18,6 +34,18 @@ export interface AdwRovingFocusInit {
      * focus travels with the key either way ({@link attachRovingFocus}).
      */
     select: (item: HTMLElement) => void;
+    /** Where a previous/next key lands. Defaults to the neighbouring index. */
+    step?: AdwRovingStep;
+    /**
+     * A SECOND pair of arrows, for the one widget GTK gives both. It contributes those two
+     * keys ONLY — never `Home` and `End`, which name the two ENDS of the box and stay one
+     * answer however many axes ask.
+     */
+    crossAxis?: {
+        orientation: AdwRovingOrientation | (() => AdwRovingOrientation);
+        /** Required here, unlike on the primary axis: a second axis is a grid, not a run. */
+        step: AdwRovingStep;
+    };
 }
 /**
  * Make a roving tabindex navigable: arrows step, Home/End jump, and focus travels with

package/lib/types/emoji-data.d.ts

@@ -0,0 +1,38 @@
+/** One emoji entry: the code points and the words the search reads. */
+export interface EmojiEntry {
+    /** The code points, as one string — a ZWJ sequence is already spelled out. */
+    readonly text: string;
+    /** The English name — `filter_func`'s second list. */
+    readonly name: string;
+    /** Search keywords, one word each — `filter_func`'s third list. */
+    readonly keywords: readonly string[];
+}
+/** One `EmojiSection`, with the heading and the toolbar button's own label. */
+export interface EmojiCategory {
+    /** The section key: `recent`, `people`, … */
+    readonly id: string;
+    /** The heading above the section, `''` for the one without (recent). */
+    readonly heading: string;
+    /** The `.ui` tooltip of the toolbar button, which for every section but recent is its heading. */
+    readonly tooltip: string;
+    /** The emoji, in the order GTK appends them. */
+    readonly entries: readonly EmojiEntry[];
+}
+/** `MAX_RECENT` — 7 columns by 3 rows (gtkemojichooser.c:363). */
+export declare const EMOJI_MAX_RECENT: number;
+/** `EMOJI_SKIN_TONES` — `1F3FB`…`1F3FF`, the five modifiers (gtkemojichooser.c:530). */
+export declare const EMOJI_SKIN_TONES: readonly string[];
+/** `has_variations` (gtkemojichooser.c:489-508) — whether an entry carries a skin slot. */
+export declare function hasVariations(entry: EmojiEntry): boolean;
+/**
+ * The nine category sections, in `setup_section`'s registration order. `recent` is NOT
+ * here: its emoji come from `GSettings` (`recently-used-emoji`), so the element owns
+ * that list and this table does not know about it.
+ */
+export declare const EMOJI_CATEGORIES: readonly EmojiCategory[];
+/** The section ids in order, `recent` FIRST — the struct order of `GtkEmojiChooser`. */
+export declare const EMOJI_SECTION_IDS: readonly string[];
+/** The heading of a section, `''` for `recent` — the one with no heading widget at all. */
+export declare function emojiHeading(id: string): string;
+/** The toolbar button's tooltip for a section: its heading, or `Recent` for the first. */
+export declare function emojiTooltip(id: string): string;

package/lib/types/font-description.d.ts

@@ -0,0 +1,96 @@
+/** The horizontal slant Pango spells. CSS has `italic` and `oblique`, and so does this. */
+export type FontSlant = 'normal' | 'italic' | 'oblique';
+/** The four widths Pango distinguishes; CSS `font-stretch` names the same three. */
+export type FontWidth = 'normal' | 'condensed' | 'expanded';
+/**
+ * The fields `GtkFontDialogButton` reads. `variant` and the exact family/face are
+ * deliberately absent: the C compares them in `font_description_style_equal`
+ * (gtkfontdialogbutton.c:586-592) to pick a face out of a font map, and a browser page
+ * has no font map — see `font-button`'s header for what stands in for it.
+ */
+export interface PangoFontDescription {
+    /** The family name, or `''` for the "unset" a fresh description carries. */
+    family: string;
+    slant: FontSlant;
+    /** Pango's numeric weight, which is also CSS's `font-weight` number. */
+    weight: number;
+    width: FontWidth;
+    /** The size as written. `unit` says what it is counted in. */
+    size: number;
+    /** `pango_font_description_set_size_is_absolute` — `true` means the size is pixels. */
+    absolute: boolean;
+}
+/** The description `gtk_font_dialog_button_init` builds: `pango_font_description_from_string ("Sans 12")`. */
+export declare const PANGO_FONT_DESCRIPTION_DEFAULT: PangoFontDescription;
+/**
+ * `pango_font_description_from_string` — family, style words and a trailing size, in any
+ * order.
+ *
+ * Total, like the C: an unrecognised word is not a style, and a family is whatever is
+ * left over once the styles and the size are gone — which is why the tokens are consumed
+ * from the END, where Pango reads the size, and a token that matches no style word stays
+ * in the family.
+ */
+export declare function parseFontDescription(text: string): PangoFontDescription;
+/** `pango_font_description_to_string` — the same words, in the same order. */
+export declare function formatFontDescription(description: PangoFontDescription): string;
+/**
+ * `pango_font_description_equal` — every field, as Pango's own comparison is. `font-desc`
+ * is `G_PARAM_EXPLICIT_NOTIFY` (:345), so a write of the description already held must be
+ * the write that changes nothing (gtkfontdialogbutton.c:869-871).
+ */
+export declare function fontDescriptionEqual(a: PangoFontDescription, b: PangoFontDescription): boolean;
+/**
+ * `update_font_info`'s size format, `g_strdup_printf ("%2.4g%s", size / PANGO_SCALE, …)`
+ * (gtkfontdialogbutton.c:669-673) — four significant digits with the zeros stripped, and
+ * `px` when the size is absolute. `%g` is what `Number#toPrecision` computes and
+ * `Number#toString` then tidies, which is the whole of the difference between `12` and
+ * `12.00`.
+ */
+export declare function formatFontSize(size: number, absolute: boolean): string;
+/**
+ * The CSS projection of a description — `apply_use_font`'s attribute list
+ * (gtkfontdialogbutton.c:689-720), as the four LONGHANDS Pango's own attribute list sets.
+ *
+ * `use_size` is the one field `apply_use_font` may unset, and it is a parameter here for
+ * that reason: `PANGO_FONT_MASK_SIZE` goes only when the size is not wanted.
+ *
+ * The longhands rather than the `font` SHORTHAND, because the shorthand is all-or-nothing:
+ * one rejected token discards the family with it, and a description is half its fields.
+ * `cssFontShorthand` is the same projection for the one caller that needs a string —
+ * `FontFaceSet.check()`, which takes nothing else.
+ *
+ * THE SIZE CARRIES A UNIT, and Pango's own string does not — which is the one place this
+ * projection is not a rename. A bare `12` is a size in Pango (points, because
+ * `PangoFontDescription`'s size is divided by `PANGO_SCALE` and Pango's renderer reads
+ * points) and a length a CSS declaration REJECTS. `pt` is the unit Pango means — one point
+ * is 1/72 inch in both — so an absolute size keeps `px` and everything else becomes `pt`.
+ */
+export interface CssFontParts {
+    fontFamily: string;
+    fontWeight: string;
+    fontStyle: string;
+    fontStretch: string;
+    fontSize: string;
+}
+/** An unset family is "None" as a LABEL, not a font to render in — so the generic is. */
+export declare function cssFontParts(description: PangoFontDescription, useSize: boolean): CssFontParts;
+/** {@link cssFontParts} as one `font` shorthand, for the string-shaped caller. */
+export declare function cssFontShorthand(description: PangoFontDescription, useSize: boolean): string;
+/**
+ * Pango's feature list as the TAGS a CSS `font-feature-settings` value is built from — the
+ * one place this module translates rather than renames.
+ *
+ * `pango_font_features_to_string` writes a comma-separated list of bare tags with `-` for
+ * off, which is the same LIST and not the same SYNTAX: CSS wants each tag quoted (`"liga"`).
+ *
+ * The tags come back as a LIST on purpose. `font-feature-settings` is all-or-nothing, and
+ * MEASURED in Firefox: the declaration `"liga", "-kern"` is DROPPED WHOLE — an unknown tag
+ * invalidates the value, not just itself — while `"liga"` alone stands. A single joined
+ * string would therefore lose every tag the browser does not know, which is a silent
+ * difference from Pango's "keep what you recognise". The caller applies the tags one at a
+ * time so a rejection costs one feature.
+ *
+ * `tnum=1` keeps its `=1`, which is Pango's own spelling for "on with a value".
+ */
+export declare function cssFontFeatureTags(features: string): string[];

package/lib/types/gtk-about-dialog.spec.d.ts

@@ -0,0 +1 @@
+export declare const GtkAboutDialogTest: () => Promise<void>;

package/lib/types/gtk-action-bar.spec.d.ts

@@ -0,0 +1 @@
+export declare const GtkActionBarTest: () => Promise<void>;

package/lib/types/gtk-application-window.spec.d.ts

@@ -0,0 +1 @@
+export declare const GtkApplicationWindowTest: () => Promise<void>;

package/lib/types/gtk-aspect-frame.spec.d.ts

@@ -0,0 +1 @@
+export declare const GtkAspectFrameTest: () => Promise<void>;

package/lib/types/gtk-calendar.spec.d.ts

@@ -0,0 +1 @@
+export declare const GtkCalendarTest: () => Promise<void>;

package/lib/types/gtk-center-box.spec.d.ts

@@ -0,0 +1 @@
+export declare const GtkCenterBoxTest: () => Promise<void>;

package/lib/types/gtk-color-dialog-button.spec.d.ts

@@ -0,0 +1 @@
+export declare const GtkColorDialogButtonTest: () => Promise<void>;

package/lib/types/gtk-column-view.spec.d.ts

@@ -0,0 +1 @@
+export declare const GtkColumnViewTest: () => Promise<void>;

package/lib/types/gtk-drag-icon.spec.d.ts

@@ -0,0 +1 @@
+export declare const GtkDragIconTest: () => Promise<void>;

package/lib/types/gtk-drawing-area.spec.d.ts

@@ -0,0 +1 @@
+export declare const GtkDrawingAreaTest: () => Promise<void>;

package/lib/types/gtk-editable-label.spec.d.ts

@@ -0,0 +1 @@
+export declare const GtkEditableLabelTest: () => Promise<void>;

package/lib/types/gtk-emoji-chooser.spec.d.ts

@@ -0,0 +1 @@
+export declare const GtkEmojiChooserTest: () => Promise<void>;