@gjsify/adwaita-web 0.54.0 → 0.56.0

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

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

package/lib/types/adw-bin.spec.d.ts

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

package/lib/types/adw-breakpoint-bin.spec.d.ts

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

package/lib/types/adw-clamp-scrollable.spec.d.ts

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

package/lib/types/adw-multi-layout-view.spec.d.ts

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

package/lib/types/adw-preferences-row.spec.d.ts

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

package/lib/types/adw-shortcuts.spec.d.ts

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

package/lib/types/adw-status-page.spec.d.ts

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

package/lib/types/adw-tab-bar.spec.d.ts

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

package/lib/types/adw-tab-button.spec.d.ts

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

package/lib/types/adw-tab-overview.spec.d.ts

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

package/lib/types/adw-view-switcher-sidebar.spec.d.ts

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

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

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

package/lib/types/attributes.d.ts

@@ -0,0 +1,19 @@
+import { VALUE_BASED_BOOLEAN_ATTRS } from '@gjsify/adwaita-core/tags';
+/** Re-export for consumers that need the list (e.g. `shared-tree-builder.ts`). */
+export { VALUE_BASED_BOOLEAN_ATTRS };
+/**
+ * Whether an attribute spells a boolean property, defaulting to `whenAbsent`.
+ *
+ * Absent is the property's default; present, the literal `"false"` is FALSE and anything
+ * else is TRUE.
+ */
+export declare function booleanAttribute(value: string | null, whenAbsent: boolean): boolean;
+/**
+ * Write a value-based boolean attribute (GTK property defaulting to TRUE).
+ *
+ * `true`  → sets `attr="true"` (present, not "false", reads as true)
+ * `false` → sets `attr="false"` (present, reads as false)
+ * This avoids `toggleAttribute` which removes the attribute for `false`,
+ * causing value-based readers to fall back to the default (true).
+ */
+export declare function writeBooleanAttribute(el: HTMLElement, attr: string, value: boolean): void;

package/lib/types/breakpoints.d.ts

@@ -1,12 +1,23 @@
 import { AdwBreakpoint } from '@gjsify/adwaita-core';
+import type { BreakpointSize } from '@gjsify/adwaita-core';
 /**
- * Drive `breakpoints` from `element`'s own box, and return a dispose function.
+ * The SIZE SOURCE both adaptive shapes in this package share: a `ResizeObserver` on
+ * `element`, handing every delivery's BORDER box to `onSize`.
  *
- * `ResizeObserver` delivers an initial observation on `observe()`, so the breakpoints
- * settle on the correct state before first paint — no flash of the wrong layout, no
+ * Split out of {@link addBreakpoints} because a second consumer needs the box without
+ * the `AdwBreakpoint` state machine: `<adw-breakpoint-bin>` drives `BreakpointBinState`
+ * (core), which evaluates a LIST of breakpoints and answers with the writes to perform,
+ * so it cannot be handed one `AdwBreakpoint` per condition. Two readers of
+ * `borderBoxSize` would be two shapes of the fallback, and the fallback is the half that
+ * only matters on the engines that do not report `borderBoxSize` at all.
+ *
+ * `ResizeObserver` delivers an initial observation on `observe()`, so the caller
+ * settles on the correct state before first paint — no flash of the wrong layout, no
  * separate seeding pass. The size read is the BORDER box in CSS pixels, the browser's
  * counterpart to the `sp`/DIP units an Adwaita condition is written in.
  */
+export declare function observeAdaptiveSize(element: Element, onSize: (size: BreakpointSize) => void): () => void;
+/** Drive `breakpoints` from `element`'s own box, and return a dispose function. */
 export declare function addBreakpoints(element: Element, breakpoints: readonly AdwBreakpoint[]): () => void;
 /**
  * Wire a `breakpoint="<condition>"` attribute to a boolean setter, the browser equivalent

package/lib/types/construct-vectors.spec.d.ts

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

package/lib/types/elements/adw-action-row.d.ts

@@ -3,6 +3,8 @@ export declare class AdwActionRow extends HTMLElement {
     private _subtitleEl;
     private _suffixEl;
     private _prefixEl;
+    /** The label column — kept for `tooltip-text`, which the browser reads off a PART. */
+    private _textEl;
     /** The headless labels + activatable-widget coupling (ADR 0004). */
     private readonly _state;
     /** Watches the activatable widget's `disabled`/`aria-disabled` — the live binding. */
@@ -46,4 +48,6 @@ export declare class AdwActionRow extends HTMLElement {
     /** Reflect the state's `activatable` back onto the attribute + class. */
     private _syncActivatable;
     private _render;
+    /** Apply CSS line-clamping based on title-lines/subtitle-lines attributes. */
+    private _applyLineClamping;
 }

package/lib/types/elements/adw-application-window.d.ts

@@ -0,0 +1,27 @@
+import { type AdwMenuInput, type AdwMenuModel } from '@gjsify/adwaita-core';
+import { AdwWindow } from './adw-window.js';
+export declare class AdwApplicationWindow extends AdwWindow {
+    private _menubarEl;
+    private _model;
+    static get observedAttributes(): string[];
+    /** Whether this window shows the application's menubar (Gtk.ApplicationWindow:show-menubar). */
+    get showMenubar(): boolean;
+    set showMenubar(value: boolean);
+    /** The menubar's model — what a GtkApplication would own here. */
+    get menuModel(): AdwMenuModel;
+    set menuModel(value: AdwMenuInput);
+    /** The menubar strip, or null before the window is connected. */
+    get menubar(): HTMLDivElement | null;
+    connectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    /**
+     * The menubar, INSIDE the content area rather than beside it.
+     *
+     * `bindSlottedChildren` watches the host and moves every child it does not claim
+     * into the content area, so a sibling would be re-homed into it one tick later. The
+     * content area's own children are not watched, so prepending here is stable — and
+     * it is also where the bar belongs: above the toolbar view, inside the window box.
+     */
+    private _buildMenubar;
+    private _renderMenubar;
+}

package/lib/types/elements/adw-bin.d.ts

@@ -0,0 +1,17 @@
+export declare class AdwBin extends HTMLElement {
+    private _observer;
+    /** `Adw.Bin:child` — the one child, or `null`. The last one appended is the one that stays. */
+    get child(): Element | null;
+    /** `adw_bin_set_child`: replace the current child, unparenting it. */
+    set child(value: Element | null);
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /**
+     * `adw_bin_set_child` — the LAST child wins, and the one it replaces leaves.
+     *
+     * A removal, not a move: C unparents the child it replaces.
+     */
+    private _enforceSingleChild;
+    /** `adw_bin_set_child`, including its refusal of a child that already has a parent. */
+    setChild(value: Element | null): void;
+}

package/lib/types/elements/adw-breakpoint-bin.d.ts

@@ -0,0 +1,67 @@
+export declare class AdwBreakpointBin extends HTMLElement {
+    /** The C's own structure: a list of breakpoints, and at most one picked. */
+    private _state;
+    private _dispose;
+    /**
+     * What the last binding applied, carried across every rebind.
+     *
+     * `BreakpointBinState.inherit` exists for exactly this and its docblock records the
+     * measurement: a browser element rebinds on every `connectedCallback`, and a bin that
+     * restarts at "none applied" reads the size that LEFT the old breakpoint's range as
+     * no change at all and leaves the child holding what the old bin wrote.
+     */
+    private _applied;
+    /** Registration is deferred to the first allocation; see `_observe`. */
+    private _pendingSync;
+    /**
+     * What each setter's target held when the setter was FIRST registered, keyed by
+     * target + property + value.
+     *
+     * Carried across a REBIND because a rebind is not a re-registration. Upstream
+     * `adw_breakpoint_add_setter` captures the original once, at the call
+     * (`g_object_get_property`, adw-breakpoint.c:1627), and the widget outlives every
+     * resize; a browser element rebinds on every connect, and re-reading the original
+     * then would capture the value the OUTGOING breakpoint had already written — so the
+     * restore would write back the applied value and the widget would never recover.
+     * Measured: a bin applied at 400px, moved to a 500px parent and widened to 900px
+     * kept its narrow label for good.
+     *
+     * Cleared when the AUTHOR rewrites `breakpoints`, which is a new
+     * `add_breakpoint`/`add_setters` sequence and captures new originals.
+     */
+    private _originals;
+    static get observedAttributes(): string[];
+    /** `Adw.BreakpointBin:current-breakpoint` — the picked index, or null. Read-only. */
+    get currentBreakpoint(): number | null;
+    /** `adw_breakpoint_bin_get_current_breakpoint()` (:841), under its property name. */
+    get currentBreakpointAttribute(): string | null;
+    /** `Adw.BreakpointBin:child` — the bin has one child, the one every breakpoint writes. */
+    get child(): Element | null;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name?: string): void;
+    /**
+     * Rebuild the state from the attribute, keeping the applied breakpoint.
+     *
+     * The originals are read on the way, because `inherit` restores what the NEW
+     * definitions captured: a restore read off a child the outgoing breakpoint already
+     * changed would restore it to the applied value, which is no restore at all.
+     */
+    private _syncBreakpoints;
+    /**
+     * The size source. `ResizeObserver` delivers an initial observation, so the pick is
+     * settled before first paint — the same seam `src/breakpoints.ts` gives every other
+     * adaptive element, re-created on every connect so a widget MOVED between parents
+     * tracks its conditions again.
+     *
+     * The CHILD is read here rather than cached, because
+     * `adw_breakpoint_bin_size_allocate` tests it on every allocation (:427) and a child
+     * appended after connect is then a child.
+     */
+    private _observe;
+    private _perform;
+    private _write;
+    private _emit;
+    /** The measure rules of a bin that holds breakpoints (:356, :388, :669). */
+    private _syncSizing;
+}

package/lib/types/elements/adw-clamp-scrollable.d.ts

@@ -0,0 +1,38 @@
+import { type AdwLengthUnit, type BoxOrientation } from '@gjsify/adwaita-core';
+/** `Gtk.ScrollablePolicy`'s three nicks, in enum order. */
+export type ScrollPolicy = 'automatic' | 'always' | 'never';
+export declare class AdwClampScrollable extends HTMLElement {
+    private _resize;
+    private _mutations;
+    static get observedAttributes(): string[];
+    /** `AdwClampScrollable:maximum-size` — the cap, in `unit`. Default 600. */
+    get maximumSize(): number;
+    set maximumSize(value: number);
+    /** `AdwClampScrollable:tightening-threshold` — where the easing starts. Default 400. */
+    get tighteningThreshold(): number;
+    set tighteningThreshold(value: number);
+    /** `AdwClampScrollable:unit` — the length unit both sizes are written in. Default `sp`. */
+    get unit(): AdwLengthUnit;
+    set unit(value: AdwLengthUnit);
+    /** `GtkOrientable:orientation`, which this class overrides. Default horizontal. */
+    get orientation(): BoxOrientation;
+    set orientation(value: BoxOrientation);
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(): void;
+    /**
+     * `Gtk.Scrollable:hscroll-policy` / `vscroll-policy` — the two overrides the class
+     * re-declares (adw-clamp-scrollable.c:118-141) and then binds onto the child. They
+     * decide here whether this element scrolls at all, which is the question they answer
+     * in C.
+     */
+    private _applyOverflow;
+    /**
+     * `adw_clamp_layout_allocate`, against the AVAILABLE size on the clamped axis.
+     *
+     * The cap sits on the CHILD, never here: this element is the scrollport, so a cap on
+     * itself would feed its own capped width back into its ResizeObserver — a feedback
+     * loop rather than a measurement (the reasoning `<adw-clamp>` carries in full).
+     */
+    private _allocate;
+}

package/lib/types/elements/adw-combo-row.d.ts

@@ -2,6 +2,8 @@ import type { AdwComboOption, AdwListModelInput } from '@gjsify/adwaita-core';
 export declare class AdwComboRow extends HTMLElement {
     private _select;
     private _valueEl;
+    /** The label column — kept for `tooltip-text`, which the browser reads off a PART. */
+    private _textEl;
     private _titleEl;
     private _subtitleEl;
     /** The headless options list + selectedIndex↔selectedValue state machine (ADR 0004). */
@@ -78,4 +80,6 @@ export declare class AdwComboRow extends HTMLElement {
      */
     private _syncChooser;
     private _renderText;
+    /** Apply CSS line-clamping based on title-lines/subtitle-lines attributes. */
+    private _applyLineClamping;
 }

package/lib/types/elements/adw-dialog.d.ts

@@ -42,5 +42,15 @@ export declare class AdwDialog extends HTMLElement {
     private _attemptClose;
     /** On close: emit `closed`, then let the surface return focus to where it was. */
     private _onClosed;
+    /**
+     * Add to the header bar, called at the end of every render.
+     *
+     * The hook is for a DIALOG whose header is not a title plus a close button, which is
+     * what `<gtk-about-dialog>` needs: `gtkaboutdialog.ui` puts a `GtkStackSwitcher` in
+     * the titlebar's title-widget position and no title text at all. An empty body is the
+     * default, so every other dialog is unaffected — and the header element is the one
+     * the base already owns, so a subclass never reaches into private state to get it.
+     */
+    protected decorateHeader(_header: HTMLElement): void;
     private _render;
 }

package/lib/types/elements/adw-entry-row.d.ts

@@ -49,6 +49,12 @@ export declare class AdwEntryRow extends HTMLElement {
     get editing(): boolean;
     connectedCallback(): void;
     attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    /**
+     * The parts `tooltip-text` lands on: the two slots and the editable area — NOT the
+     * apply button or the indicator, which carry tooltips of their own that the consumer
+     * reads for what they are.
+     */
+    private _tooltipParts;
     /**
      * Add a widget after the editable area — `adw_entry_row_add_suffix`, which APPENDS
      * into a box, so several suffixes coexist and the password row's own peek toggle

package/lib/types/elements/adw-expander-row.d.ts

@@ -32,4 +32,6 @@ export declare class AdwExpanderRow extends HTMLElement {
     connectedCallback(): void;
     attributeChangedCallback(name: string): void;
     private _render;
+    /** Apply CSS line-clamping based on title-lines/subtitle-lines attributes. */
+    private _applyLineClamping;
 }

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

@@ -18,6 +18,12 @@ export declare class AdwHeaderBar extends HTMLElement {
      * bare `Adw.HeaderBar {}` in a `.blp` page shows "Mailboxes" with no title of its own.
      */
     private _page;
+    /**
+     * The window the bar sits in: `update_title`'s last stop before the application name
+     * (`gtk_window_get_title` of the root), so a bar with no title of its own, under no titled
+     * page, shows the window's.
+     */
+    private _window;
     private _pageObserver;
     static get observedAttributes(): string[];
     /** The start (left) section container — append buttons/widgets here. */

package/lib/types/elements/adw-layout-slot.d.ts

@@ -0,0 +1,19 @@
+export declare class AdwLayoutSlot extends HTMLElement {
+    private _registered;
+    static get observedAttributes(): string[];
+    /** `adw_layout_slot_get_slot_id()` (:184), read under its property's name. */
+    get slotId(): string | null;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name?: string): void;
+    /**
+     * Hand this slot to the nearest `<adw-multi-layout-view>` ancestor.
+     *
+     * `adw_layout_slot_root` walks up for the view and calls
+     * `adw_multi_layout_view_register_slot` (adw-layout-slot.c:55). The view's own
+     * mount path is the authority — it registers only while it is building a layout —
+     * so a call arriving outside that window is refused there, exactly as
+     * `accepting_slots` refuses it upstream.
+     */
+    private _register;
+}

package/lib/types/elements/adw-multi-layout-view.d.ts

@@ -0,0 +1,101 @@
+import type { AdwLayoutSlot } from './adw-layout-slot.js';
+export declare class AdwMultiLayoutView extends HTMLElement {
+    /** The C's own tables: layouts in order, children by id, and the current layout. */
+    private _layouts;
+    private _children;
+    /** `slots` — the current layout's holes, which are cleared on every rebuild. */
+    private _slots;
+    private _current;
+    /** `accepting_slots` — only TRUE while a layout is being mounted (:116, :690). */
+    private _acceptingSlots;
+    private _observer;
+    static get observedAttributes(): string[];
+    /** `adw_multi_layout_view_get_layout_name()` (:485), read under its property's name. */
+    get layoutName(): string | null;
+    /**
+     * `adw_multi_layout_view_set_layout_name()` (:507) — writable, unlike `layout`.
+     *
+     * The property is written, not the layout: the C looks the name up and refuses a
+     * name no layout carries, and the lookup is what makes the ORDER of declaration
+     * irrelevant here.
+     */
+    set layoutName(value: string | null);
+    /** The element `Adw.MultiLayoutView:layout` points at, or null. */
+    get layout(): Element | null;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name?: string): void;
+    /** `adw_multi_layout_view_get_child(id)` (:635). */
+    getChild(id: string): Element | null;
+    /** `adw_multi_layout_view_get_layout_by_name(name)` (:605). */
+    getLayoutByName(name: string): Element | null;
+    /**
+     * `adw_multi_layout_view_add_layout()` (:538), over the declared children.
+     *
+     * The rules it carries are the ones a reader of the markup would otherwise have to
+     * infer: the FIRST layout becomes current when the list is built (:553), and a
+     * duplicate name is a warning rather than a shadowed entry (:549).
+     */
+    /**
+     * `adw_multi_layout_view_register_slot()` (:682), called by every `<adw-layout-slot>`
+     * that becomes rooted.
+     *
+     * Refused outside a mount, which is what `accepting_slots` is for: a slot in a layout
+     * that is not current has no business in the table.
+     *
+     * A REPEAT registration by the SAME element is not a duplicate and says nothing. A DOM
+     * move fires `connectedCallback` again — and moving a slot is ordinary here, because
+     * the container it sits in re-homes its own slotted children when it builds its
+     * internals. `g_hash_table_insert` upstream would overwrite with the same pointer, so
+     * the C never notices; the warning is for two DIFFERENT slots under one ID, and
+     * reporting a re-registration would train a reader to ignore it (adw-multi-layout-view.c:693).
+     */
+    registerSlot(id: string, slot: AdwLayoutSlot): void;
+    /**
+     * Read the authored tree and mount the layout it names.
+     *
+     * A direct child with `name` is a layout; anything else is a child, keyed by `slot`.
+     * Reading it from the DOM rather than from a list is what makes a child appended
+     * after connect work, which is the whole of `bindSlottedChildren`'s contract for the
+     * elements that use it.
+     */
+    private _rebuild;
+    /** The C's three tables, read off the declared children. */
+    private _readAuthoredTree;
+    /** `set_layout()` (:252): the same layout is not a change, and both properties notify. */
+    private _setLayout;
+    /**
+     * `set_layout_name()` (:507): look the name up, refuse an unknown one, then switch.
+     *
+     * The refusal is C's, in its own shape — `g_critical` and `return`, with no call to
+     * `set_layout` at all (:519), so the current layout is UNCHANGED rather than emptied.
+     * That is why the lookup is not folded into `_setLayout`: it answers the question
+     * first, and an unknown name is not a switch to nothing.
+     */
+    private _setLayoutByName;
+    /**
+     * `destroy_current_layout()` (:192): forget every slot and unparent the content.
+     *
+     * The children are simply LEFT, which is what upstream does: a child whose id the
+     * OUTGOING layout had no slot for is not unparented by `unparent_child`
+     * (adw-multi-layout-view.c:175) and rides out with the content it was in. They stay
+     * alive in `_children`, which is where this port remembers the declaration.
+     */
+    private _destroy;
+    /**
+     * `rebuild_current_layout()` (:200), minus the render-node snapshot.
+     *
+     * The do/while is C's own: parenting a child can root a slot of its own, which grows
+     * the table, which may make another child land. `slotCount` is what the loop compares
+     * against — the C's `g_hash_table_size`.
+     */
+    private _mount;
+    /** `parent_child()` (:136): bind `visible`, then insert. */
+    private _parent;
+    /**
+     * The one-way `visible` binding (:151), which CSS cannot express: the SLOT follows
+     * the CHILD. `hidden` is observed rather than polled so a child hidden AFTER it
+     * landed still hides the hole.
+     */
+    private _mirrorVisible;
+}

package/lib/types/elements/adw-overlay-split-view.d.ts

@@ -1,4 +1,7 @@
+import type { DispatchedSignals } from '../signals.js';
 export declare class AdwOverlaySplitView extends HTMLElement {
+    /** The GTK signals this element dispatches, which is what a `.blp` `bind` of `show-sidebar` follows. */
+    static readonly signals: DispatchedSignals;
     private _initialized;
     private _sidebarEl;
     private _contentEl;
@@ -16,6 +19,8 @@ export declare class AdwOverlaySplitView extends HTMLElement {
      * `show-sidebar` + `pin-sidebar` mean together, held to `OVERLAY_COLLAPSE_VECTORS`.
      */
     private _state;
+    /** The `show-sidebar` the last `notify::show-sidebar` (or the first read) settled on. */
+    private _notifiedShowSidebar;
     /** Re-entrancy guard for {@link _reflectShowSidebar}. */
     private _reflecting;
     /** The view's own width in CSS px — the size the sidebar fraction is OF. */
@@ -66,6 +71,14 @@ export declare class AdwOverlaySplitView extends HTMLElement {
      * loop rather than a render.
      */
     private _reflectShowSidebar;
+    /**
+     * `notify::show-sidebar`, raised on the EFFECTIVE value — the state's, after an auto-hide on
+     * collapse — and only when it changed, the way GObject notifies. Every path that moves it
+     * (the attribute, the property, a breakpoint, a gesture) ends in {@link _reflectShowSidebar},
+     * so this is the one place it is raised. The first read only records the baseline: a bind
+     * reads the current value itself.
+     */
+    private _notifyShowSidebar;
     private _syncBreakpoint;
     openSidebar(): void;
     hideSidebar(): void;

package/lib/types/elements/adw-preferences-row.d.ts

@@ -0,0 +1,31 @@
+export declare class AdwPreferencesRow extends HTMLElement {
+    private _titleEl;
+    private _contentEl;
+    private _initialized;
+    static get observedAttributes(): string[];
+    /** `Adw.PreferencesRow:title` — Pango markup unless {@link useMarkup} is false. */
+    get title(): string;
+    set title(value: string);
+    /** `Adw.PreferencesRow:title-selectable` — the user may copy the title. Default false. */
+    get titleSelectable(): boolean;
+    set titleSelectable(value: boolean);
+    /** `Adw.PreferencesRow:use-markup` — the title is Pango markup, reduced to its text. */
+    get useMarkup(): boolean;
+    set useMarkup(value: boolean);
+    /** `Adw.PreferencesRow:use-underline` — `_` marks a mnemonic. Default false. */
+    get useUnderline(): boolean;
+    set useUnderline(value: boolean);
+    /** `Adw.PreferencesRow:child` (inherited from `Gtk.ListBoxRow`) — the row's content. */
+    get child(): Element | null;
+    set child(value: Element | null);
+    connectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    /**
+     * The title label and the copy permission.
+     *
+     * `labelDisplayText` reduces Pango markup to its text and strips the mnemonic marker
+     * in C's order (markup first, `_` second) — the same reduction `<gtk-label>` uses, so
+     * a title written once reads the same in both.
+     */
+    private _render;
+}

package/lib/types/elements/adw-shortcuts-dialog.d.ts

@@ -0,0 +1,13 @@
+import { AdwDialog } from './adw-dialog.js';
+export declare class AdwShortcutsDialog extends AdwDialog {
+    /**
+     * The sections in this dialog, in document order (AdwShortcutsDialog:add, in markup).
+     *
+     * READ OFF THE CONTENT AREA rather than off a wrapper this class builds, because the
+     * base routes every child there through its own LIVE `bindSlottedChildren` and a
+     * wrapper of our own would be a second destination the routing knows nothing about:
+     * a section appended after connect would land beside the wrapper, not inside it.
+     */
+    get sections(): readonly HTMLElement[];
+    connectedCallback(): void;
+}

package/lib/types/elements/adw-shortcuts-item.d.ts

@@ -0,0 +1,36 @@
+/**
+ * `AdwShortcutsItem:direction` is a `GtkTextDirection`, so it carries `none` beside the
+ * two directions — and `none` is the default, meaning "show this row either way".
+ *
+ * NOT `AdwTextDirection` from core: that one is the split views' pair (`'ltr' | 'rtl'`,
+ * split-view.ts:41), which cannot hold the value the C defaults this property to.
+ */
+export type AdwShortcutsItemDirection = 'ltr' | 'rtl' | 'none';
+export declare class AdwShortcutsItem extends HTMLElement {
+    private _initialized;
+    private _titleEl;
+    private _subtitleEl;
+    private _labelEl;
+    static get observedAttributes(): string[];
+    /** The row's title (AdwShortcutsItem:title). */
+    get title(): string;
+    set title(value: string);
+    /** The row's subtitle (AdwShortcutsItem:subtitle). */
+    get subtitle(): string;
+    set subtitle(value: string);
+    /** The accelerator, in `<adw-shortcut-label>`'s grammar (AdwShortcutsItem:accelerator). */
+    get accelerator(): string;
+    set accelerator(value: string);
+    /** The action this row stands for; resolved by a GtkApplication on GTK. */
+    get actionName(): string;
+    set actionName(value: string);
+    /** The text direction this row belongs to (AdwShortcutsItem:direction). */
+    get direction(): AdwShortcutsItemDirection;
+    set direction(value: AdwShortcutsItemDirection);
+    /** Whether a row carries an accelerator or stands for an action alone. */
+    get hasAccelerator(): boolean;
+    connectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    private _render;
+    private _renderSubtitle;
+}

package/lib/types/elements/adw-shortcuts-section.d.ts

@@ -0,0 +1,14 @@
+export declare class AdwShortcutsSection extends HTMLElement {
+    private _initialized;
+    private _bodyEl;
+    private _titleEl;
+    static get observedAttributes(): string[];
+    /** The section title (AdwShortcutsSection:title). */
+    get title(): string;
+    set title(value: string);
+    /** The shortcuts in this section, in document order (AdwShortcutsSection:n-items' list). */
+    get items(): readonly HTMLElement[];
+    connectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    private _render;
+}

package/lib/types/elements/adw-sidebar.d.ts

@@ -3,9 +3,10 @@ import { type AdwSidebarItemSpec, type AdwSidebarSectionSpec, type SidebarItemFi
 export declare class AdwSidebarItem extends HTMLElement {
     static get observedAttributes(): string[];
     /**
-     * `AdwSidebarItem:enabled`, under the GIR name — the `disabled` attribute inverted. The
-     * property is what lets an authored `enabled: false` reach this item through the
+     * `AdwSidebarItem:enabled`, under the GIR name — the `disabled` attribute inverted.
+     * The property is what lets an authored `enabled: false` reach this item through the
      * shared-tree builder, which writes a `false` through the element's own property.
+     * Reads both the presence-based `disabled` and value-based `enabled` attributes.
      */
     get enabled(): boolean;
     set enabled(value: boolean);
@@ -61,6 +62,11 @@ export declare class AdwSidebar extends HTMLElement {
     private _rebuild;
     private _createHeader;
     private _createRow;
+    /**
+     * The item's INDICATOR bin — C's `AdwBin` with `.indicator`, `.dot` and the
+     * optional `.needs-attention`, holding an `AdwFadingLabel`'s worth of text.
+     */
+    private _createIndicator;
     private _applyMode;
     private _applySelection;
 }

package/lib/types/elements/adw-spin-row.d.ts

@@ -1,6 +1,10 @@
 import type { AdwAdjustment, AdwAdjustmentInput } from '@gjsify/adwaita-core';
 export declare class AdwSpinRow extends HTMLElement {
     private _input;
+    /** The label column — kept for `tooltip-text`, which the browser reads off a PART. */
+    private _textEl;
+    /** The −/input/+ box — the other half of the row's surface. */
+    private _controlEl;
     private _titleEl;
     private _subtitleEl;
     /** The headless adjustment: the range, the clamp and the two signals (ADR 0004, ADR 0047). */
@@ -21,6 +25,8 @@ export declare class AdwSpinRow extends HTMLElement {
     connectedCallback(): void;
     attributeChangedCallback(name: string, _old: string | null, val: string | null): void;
     private _renderText;
+    /** Apply CSS line-clamping based on title-lines/subtitle-lines attributes. */
+    private _applyLineClamping;
     /** A stepper press — the interactive path, so it emits `notify::value`. */
     private _adjust;
     private _emitChange;