@gjsify/adwaita-web 0.54.0 → 0.56.0

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

@@ -0,0 +1,103 @@
+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.
+     *
+     * The getter answers `''` for no title, not `null`: a `string | null` getter is not assignable to
+     * `HTMLElement.title`, and the emitted `.d.ts` then fails every consumer that does not set
+     * `skipLibCheck`. The setter still takes `null` to clear it, as GTK does.
+     */
+    get title(): string;
+    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>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/lib/types/gtk-popover-bin.spec.d.ts

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

package/lib/types/gtk-popover-menu-bar.spec.d.ts

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

package/lib/types/gtk-popover-menu.spec.d.ts

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

package/lib/types/gtk-popover-role.spec.d.ts

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

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

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

package/lib/types/gtk-print-dialogs.spec.d.ts

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

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

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

package/lib/types/gtk-scale-button.spec.d.ts

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

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

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

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

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

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

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

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

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

package/lib/types/gtk-search-entry.spec.d.ts

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

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

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

package/lib/types/gtk-spin-button.spec.d.ts

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

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

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

package/lib/types/gtk-stack-sidebar.spec.d.ts

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

package/lib/types/gtk-stack-switcher.spec.d.ts

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

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

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

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

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

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

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

package/lib/types/gtk-toggle-button.spec.d.ts

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

package/lib/types/gtk-tree-expander.spec.d.ts

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

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

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

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

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

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

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

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

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

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

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

package/lib/types/index.d.ts

@@ -6,7 +6,8 @@ export type { AdwAccentSource } from './appearance.js';
 export { AdwScrollShading } from './scroll-shading.js';
 export type { AdwUndershootEdges } from './scroll-shading.js';
 export { buildSharedTree, mountSharedTree } from './shared-tree-builder.js';
-export type { MountedSharedTree } from './shared-tree-builder.js';
+export type { MountOptions, MountedSharedTree, SizeSource } from './shared-tree-builder.js';
+export { registerTemplateClass } from './template-classes.js';
 export { isIconAvailable, registerIcon } from './icon-registry.js';
 export * as Adw from './namespace/adw.js';
 export * as Gtk from './namespace/gtk.js';
@@ -20,6 +21,8 @@ export { AdwTabPage } from './elements/adw-tab-view.js';
 export { AdwViewSwitcherPage } from './elements/adw-view-switcher.js';
 export { AdwViewStackPage } from './elements/adw-inline-view-switcher.js';
 export { AdwSidebarItem, AdwSidebarSection } from './elements/adw-sidebar.js';
+export { AdwShortcutsSection } from './elements/adw-shortcuts-section.js';
+export { AdwShortcutsItem } from './elements/adw-shortcuts-item.js';
 export { AdwBottomSheetBottomBar, AdwBottomSheetContent, AdwBottomSheetSheet } from './elements/adw-bottom-sheet.js';
 export { AdwAlertResponse } from './elements/adw-alert-dialog.js';
 export type { GtkPopoverAlign, GtkPopoverPosition, GtkPopoverRole } from './elements/gtk-popover.js';

package/lib/types/list-view-dom.d.ts

@@ -0,0 +1,44 @@
+import type { AdwListItemFactory } from '@gjsify/adwaita-core';
+/** The class every row/cell label carries, so one stylesheet rule reaches all three views. */
+export declare const LIST_ITEM_LABEL_CLASS = "adw-list-item-label";
+/**
+ * What a view draws for an item when no `factory` was set.
+ *
+ * GTK HAS NO DEFAULT FACTORY — `gtk_list_view_new (model, NULL)` is legal and draws empty
+ * rows, which on a documentation surface is indistinguishable from a broken widget. So
+ * the port's default is the factory every upstream example writes by hand: a label bound
+ * to the item. Setting `factory` replaces it, and that is the only way to get GTK's own
+ * answer back.
+ */
+export declare const defaultListItemFactory: AdwListItemFactory<Node>;
+/** What {@link attachRubberBand} needs to know about the view it bands. */
+export interface AdwRubberBandInit {
+    /** The element the pointer listeners sit on. */
+    host: HTMLElement;
+    /** The positioned box the band is drawn inside — the row container. */
+    surface: HTMLElement;
+    /** Whether a drag may start right now: `enable-rubberband` AND a multiple selection. */
+    enabled: () => boolean;
+    /** The row elements, in model order. */
+    rows: () => readonly HTMLElement[];
+    /** Select every position the band covers, replacing the selection. */
+    selectPositions: (positions: readonly number[]) => void;
+}
+/**
+ * Rubberband selection — drag on the view's background to select what the rectangle
+ * covers.
+ *
+ * GTK runs this as a drag gesture on `GtkListBase` and draws a `rubberband` CSS node,
+ * which libadwaita styles as an accent border over a 20% accent fill
+ * (`_views.scss:47-50`); this builds the same node and lets that rule reach it.
+ *
+ * THE DRAG MUST START ON THE BACKGROUND. A press that lands on a row is that row's click
+ * — GTK's row gesture claims the sequence — so starting a band there would make every
+ * click a one-pixel drag and swallow the row's own selection step.
+ *
+ * The hit test is `getBoundingClientRect` per row against the band, which is the same
+ * question GTK answers against its tile areas. It is recomputed per pointermove rather
+ * than cached: a row's box can change mid-drag (a scroll, a factory that lays out late),
+ * and a cached rectangle would select the wrong rows without anything looking wrong.
+ */
+export declare function attachRubberBand(init: AdwRubberBandInit): void;