@gjsify/adwaita-web 0.54.0 → 0.56.0

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

@@ -1,12 +1,17 @@
 import './gtk-switch.js';
 export declare class AdwSwitchRow extends HTMLElement {
     private _switchEl;
+    private _prefixEl;
+    /** The label column — kept for `tooltip-text`, which the browser reads off a PART. */
+    private _textEl;
     private _titleEl;
     private _subtitleEl;
     /** The headless active flag + its notify rule (ADR 0004). */
     private readonly _state;
     private _initialized;
     static get observedAttributes(): string[];
+    /** The start (prefix) section — append icons/widgets here imperatively. */
+    get prefixSection(): HTMLDivElement;
     get active(): boolean;
     set active(value: boolean);
     connectedCallback(): void;
@@ -18,4 +23,6 @@ export declare class AdwSwitchRow extends HTMLElement {
      */
     private _apply;
     private _renderText;
+    /** Apply CSS line-clamping based on title-lines/subtitle-lines attributes. */
+    private _applyLineClamping;
 }

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

@@ -0,0 +1,108 @@
+import type { AdwTabView } from './adw-tab-view.js';
+/** The CSS classes a chip's own layout reads — the states C puts on the widget. */
+export declare class AdwTabBar extends HTMLElement {
+    private _boxEl;
+    private _startEl;
+    private _endEl;
+    private _indicatorEl;
+    private _chips;
+    private _hovered;
+    private _view;
+    private _initialized;
+    private _preferredAction;
+    private _dropTypes;
+    private _dropActions;
+    private _dropArmed;
+    static get observedAttributes(): string[];
+    /** `Adw.TabBar:view` — the tab view this bar controls. */
+    get view(): AdwTabView | null;
+    set view(value: AdwTabView | string | null);
+    /**
+     * `Adw.TabBar:start-action-widget` — the widget shown BEFORE the tabs.
+     *
+     * READ OUT OF THE BIN rather than remembered: a `slot="start-action-widget"` child and
+     * this setter are two spellings of one property, and a second copy of the truth is where
+     * they drift apart. `bindSlottedChildren` moves the node; the bin holds it.
+     */
+    get startActionWidget(): HTMLElement | null;
+    set startActionWidget(widget: HTMLElement | null);
+    /** `Adw.TabBar:end-action-widget` — the widget shown AFTER the tabs. */
+    get endActionWidget(): HTMLElement | null;
+    set endActionWidget(widget: HTMLElement | null);
+    /**
+     * `Adw.TabBar:autohide` — whether the strip hides itself when it has nothing to show.
+     * TRUE upstream, opt-in here; see the header.
+     */
+    get autohide(): boolean;
+    set autohide(value: boolean);
+    /** `Adw.TabBar:expand-tabs` — chips fill the strip instead of sitting at minimum size. */
+    get expandTabs(): boolean;
+    set expandTabs(value: boolean);
+    /** `Adw.TabBar:inverted` — close button first, indicator last. */
+    get inverted(): boolean;
+    set inverted(value: boolean);
+    /** `Adw.TabBar:extra-drag-preload` — see the header for the half a browser cannot do. */
+    get extraDragPreload(): boolean;
+    set extraDragPreload(value: boolean);
+    /** `Adw.TabBar:tabs-revealed` — read-only, and `tabsRevealed`'s answer. */
+    get tabsRevealed(): boolean;
+    /** `Adw.TabBar:is-overflowing` — read-only, measured off the strip's own scroll window. */
+    get isOverflowing(): boolean;
+    /** `Adw.TabBar:extra-drag-preferred-action` — read-only, set by a drag handler. */
+    get extraDragPreferredAction(): string | null;
+    /** `adw_tab_bar_set_view`: rebind, then redraw every chip from the new view's pages. */
+    setView(view: AdwTabView | null): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    /**
+     * `adw_tab_bar_setup_extra_drop_target`: the DOM half of an extra drop target.
+     *
+     * `types` is the list of MIME types the widget accepts and `actions` the list of drop
+     * effects it will let through, which is the pair the C call takes. A drop of any other
+     * type is not ours and is left to the page.
+     */
+    setupExtraDropTarget(types: readonly string[], actions?: readonly string[]): void;
+    private _resolveView;
+    /** `set_view`'s connections, as the view's own events rather than GObject notifications. */
+    private _bindView;
+    private _unbindView;
+    private _onViewChange;
+    /**
+     * The whole strip, rebuilt in place: the page list is the model, and C edits the box
+     * rather than rebuilding it, so a chip that survives keeps its node, its hover state and
+     * its focus.
+     */
+    private _syncChips;
+    private _refreshOne;
+    /**
+     * `update_selected_tab`: the selected chip takes the `:selected` state, the roving
+     * tabindex follows it, and the strip scrolls it into view the way C does on EVERY
+     * selection (`adw-tab-bar.c:934` -> `adw-tab-box.c:1728`).
+     */
+    private _applyActiveState;
+    /** `update_tabs_revealed`: the strip is up or it is not. */
+    private _applyRevealed;
+    /**
+     * `is-overflowing`, and the revealer over the box that reads it
+     * (`tabbox > revealer > indicator`, _tab-view.scss:44-55): a two-pixel accent bar under
+     * the chips, shown exactly while the strip cannot show them all.
+     */
+    private _applyOverflow;
+    /**
+     * `Adw.TabView`'s shortcut table as the BAR sees it (`adw-tab-bar.c` connects the same
+     * moves), plus the ArrowLeft/ArrowRight movement `role=tablist` promises. Ctrl+Tab WRAPS
+     * and Ctrl+Page-Up/Down does not — the same `last` flag that separates them in C.
+     */
+    private _onKeyDown;
+    private _onDragOver;
+    private _onDrop;
+    /** `dropEffect` is the DOM's own name for `Gdk.DragAction`, and it takes the same words. */
+    private _dropEffects;
+    /**
+     * `extra-drag-value` on hover-start with a `NULL` action (adw-tab-bar.c: the signal is
+     * emitted whenever an item starts hovering, whatever `extra-drag-preload` says), and
+     * `extra-drag-preferred-action` is whatever the handler answered with.
+     */
+    private _armHoverValue;
+}

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

@@ -0,0 +1,32 @@
+import type { AdwTabView } from './adw-tab-view.js';
+export declare class AdwTabButton extends HTMLElement {
+    private _button;
+    private _binEl;
+    private _labelEl;
+    private _indicatorEl;
+    private _view;
+    private _initialized;
+    static get observedAttributes(): string[];
+    /** `Adw.TabButton:view` — the tab view this button counts. */
+    get view(): AdwTabView | null;
+    set view(value: AdwTabView | string | null);
+    /** `adw_tab_button_set_view`: rebind, then re-derive the icon and the indicator. */
+    setView(view: AdwTabView | null): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    private _resolveView;
+    private _onViewChange;
+    /**
+     * `set_view`'s four connections (adw-tab-button.c:`set_view`), as the view's own events.
+     *
+     * `notify::n-pages`, `page-attached` and `page-detached` all arrive as `page-attached`
+     * / `page-detached`; `notify::selected-page` is itself; and what C reads off each PAGE
+     * (`notify::needs-attention`) reaches the view as `page-updated`, whichever page it
+     * is on and whether an attribute or `setPageNeedsAttention` changed it.
+     */
+    private _bindView;
+    private _unbindView;
+    /** `update_icon` and `update_needs_attention`, in that order. */
+    private _render;
+}

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

@@ -0,0 +1,199 @@
+import { type AdwMenuInput, type AdwMenuModel } from '@gjsify/adwaita-core';
+import type { AdwTabView } from './adw-tab-view.js';
+export declare class AdwTabOverview extends HTMLElement {
+    private _childEl;
+    private _overviewEl;
+    private _headerEl;
+    private _startButtonsEl;
+    private _endButtonsEl;
+    private _titleEl;
+    private _searchBtn;
+    private _searchEntry;
+    private _searchClamp;
+    private _searchBar;
+    private _menuBtn;
+    private _gridEl;
+    private _pinnedGridEl;
+    private _emptyState;
+    private _searchEmptyState;
+    private _newTabBtn;
+    private readonly _thumbs;
+    private _view;
+    private _model;
+    private _searchActive;
+    private _initialized;
+    /** The last visibility actually painted, so `notify::open` fires on a real change. */
+    private _appliedOpen;
+    /** Guards the `open` attribute we write ourselves from re-entering `setOpen`. */
+    private _reflecting;
+    static get observedAttributes(): string[];
+    /** `Adw.TabOverview:view` — the tab view the overview controls. */
+    get view(): AdwTabView | null;
+    set view(value: AdwTabView | string | null);
+    /**
+     * `adw_tab_overview_set_view`: rebind the view's five signals, then repopulate.
+     * The view must be INSIDE the overview (adw-tab-overview.c:1090-1093 refuses
+     * otherwise), which the element enforces by looking the view up among its own
+     * children when the reference is not a live element.
+     */
+    setView(view: AdwTabView | null): void;
+    /**
+     * `Adw.TabOverview:child` — the widget the overview covers. Declared children are
+     * it: there is one slot in the template and it holds whatever the author wrote.
+     */
+    get child(): HTMLElement | null;
+    /** `Adw.TabOverview:open` — whether the overview is showing. */
+    get open(): boolean;
+    set open(value: boolean);
+    /**
+     * Whether the thumbnails use the INVERTED layout: the close/unpin button at the
+     * START and the indicator at the END, rather than the other way round
+     * (adw-tab-overview.c:1626-1634).
+     */
+    get inverted(): boolean;
+    set inverted(value: boolean);
+    /**
+     * `Adw.TabOverview:enable-search`, TRUE upstream — and so `="false"` is the off
+     * switch, absent meaning on. The same MODIFICATION `<adw-carousel>` makes for
+     * `allow-scroll-wheel`: an HTML boolean attribute can only mean TRUE.
+     */
+    get enableSearch(): boolean;
+    set enableSearch(value: boolean);
+    /** `Adw.TabOverview:search-active` — read-only upstream, and read-only here. */
+    get searchActive(): boolean;
+    /** `Adw.TabOverview:enable-new-tab`. */
+    get enableNewTab(): boolean;
+    set enableNewTab(value: boolean);
+    /** `Adw.TabOverview:secondary-menu` — the portal menu of extra actions. */
+    get secondaryMenu(): AdwMenuModel;
+    set secondaryMenu(value: AdwMenuInput);
+    /** `Adw.TabOverview:show-start-title-buttons`, TRUE upstream, so `="false"` turns it off. */
+    get showStartTitleButtons(): boolean;
+    set showStartTitleButtons(value: boolean);
+    /** `Adw.TabOverview:show-end-title-buttons`, TRUE upstream, so `="false"` turns it off. */
+    get showEndTitleButtons(): boolean;
+    set showEndTitleButtons(value: boolean);
+    /**
+     * `Adw.TabOverview:extra-drag-preload`. Stored and reported; it gates the GDK drag
+     * protocol this port does not have (see the header).
+     */
+    get extraDragPreload(): boolean;
+    set extraDragPreload(value: boolean);
+    /** `Adw.TabOverview:extra-drag-preferred-action` — always 0 here, for the same reason. */
+    get extraDragPreferredAction(): number;
+    /**
+     * The `overview.open` action (`overview_open_cb`, adw-tab-overview.c:1517-1521),
+     * with `update_actions`' enabled rule: closed AND holding a view (:816-826).
+     */
+    activateOverviewOpen(): boolean;
+    /**
+     * The `overview.close` action (`overview_close_cb`, :1523-1527): open, holding a
+     * view, and holding at least one page — an empty overview has nothing to close to.
+     */
+    activateOverviewClose(): boolean;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    private _resolveView;
+    /** The `AdwTabView` among our own children — the only place the C allows one. */
+    private _findView;
+    /**
+     * `set_view`'s five connections (adw-tab-overview.c:1140-1209), read off the view's
+     * own events: the page list's attach/detach/reorder, each page's `pinned` change,
+     * the selection, and the page COUNT (which the title and the actions are derived
+     * from). The pinned page change arrives as `page-updated` / `page-pinned`.
+     */
+    private _bindView;
+    private _unbindView;
+    private _onViewChange;
+    private _syncAll;
+    /**
+     * `notify_n_pages_cb`: `dngettext ("%u Tab", "%u Tabs", n_pages)` — the count is
+     * the number of pages, and the singular is only for exactly one. No view means an
+     * EMPTY title, which is the C's own branch before the format string (:955-958).
+     */
+    private _applyTitle;
+    /**
+     * The two grids, split the way `populate_sidebar`-shaped code splits them: pinned
+     * pages in `pinned_grid` in view order, the rest in `grid`, each filtered by the
+     * current search terms. Thumbnails are edited in place; a page that left either
+     * grid loses its node.
+     */
+    private _syncGrids;
+    /**
+     * `empty_changed_cb`: EMPTY is BOTH grids empty, and which of the two status pages
+     * shows is the search — `empty_state` when it is off, `search_empty_state` when on.
+     */
+    private _applyEmptyStates;
+    /** `update_new_tab_button`: the button hides while the search is running. */
+    private _applyNewTabButton;
+    /**
+     * `update_header_bar`: the bar shows when search is on, or a secondary menu is set,
+     * or either side wants its title buttons. The two sides are drawn as the slots C
+     * puts the window buttons in — this renderer has no window chrome to move, so the
+     * slot is where an application puts its own controls.
+     */
+    private _applyHeaderBar;
+    private _applyMenu;
+    /** `set_open` + `set_overview_visible` (:916-939): one visibility, two surfaces. */
+    private _applyOpen;
+    /** `adw_tab_overview_set_open`, the setter the actions and the grid both call. */
+    setOpen(open: boolean): void;
+    private _searchMode;
+    /** The template's `search-mode-enabled` binding: the search BUTTON's own state. */
+    private _toggleSearchMode;
+    /**
+     * `search_changed_cb`: the terms go to BOTH grids and `search-active` is just
+     * "the entry is non-empty" — there is no separate mode to keep in step, which is why
+     * `stop_search_cb` has to clear the entry itself before reporting FALSE.
+     */
+    private _onSearchChanged;
+    private _stopSearch;
+    /** `set_search_active` (:838-852): assign, re-derive, and notify only on a change. */
+    private _setSearchActive;
+    /**
+     * `search_activated_cb` (:884-893): Enter in the entry moves into the grid, and it
+     * is the PINNED grid first, because it sits above `grid` in the scrolled window.
+     */
+    private _onSearchKeyDown;
+    /**
+     * `adw_tab_overview_focus` (:1343-1405), the parts the DOM can honour: the search
+     * button and the entry go DOWN into the first row, the secondary-menu button goes
+     * down to the LAST row, and the new-tab button goes UP to the last row of `grid`
+     * first. GTK's focus is a widget returning TRUE for a direction; a browser moves the
+     * focus itself, so this only names the destination.
+     */
+    private _onKeyDown;
+    /**
+     * The thumbnail grids are `GtkGridView`s: arrows move a cursor in two dimensions over
+     * a column count the layout decides (the grid reflows), Home/End jump, and nothing
+     * wraps. Selection follows focus; Enter and Space activate like a click, because a
+     * thumbnail is a `div` with no activation of its own. A move that would leave the
+     * grid is not claimed for Up/Down, so `_onKeyDown` can still hand focus to the
+     * new-tab button.
+     */
+    private _onGridKey;
+    private _focusFirstRow;
+    private _focusLastRow;
+    /**
+     * `create_tab` (:895-909) and `new_tab_clicked_cb` (:911-926).
+     *
+     * `create-tab`'s handler RETURNS a page, which a DOM event cannot do: `detail.page`
+     * is the return slot, and a listener fills it (usually by appending to the view).
+     * Nothing filled is C's `g_critical ("AdwTabOverview::create-tab handler must not
+     * return NULL")`, reported on `console.error` because the click cannot be abandoned.
+     */
+    private _requestCreateTab;
+    private _createGrid;
+    /**
+     * adw-tab-thumbnail.ui, node for node: the `.thumbnail` overlay over a `.card`
+     * overlay holding the PICTURE, the close button, the unpin icon and the indicator
+     * button, with the attention dot over that and the icon/title box underneath.
+     */
+    private _thumbFor;
+    /**
+     * `update_tooltip`, `update_icon`, `update_indicator`, `update_loading` and the
+     * needs-attention revealer, in that order (adw-tab-thumbnail.c:82-152).
+     */
+    private _refreshThumb;
+}

package/lib/types/elements/adw-tab-view.d.ts

@@ -19,6 +19,8 @@ export declare class AdwTabView extends HTMLElement {
     private readonly _pagesEl;
     /** Tab chips keyed by page id — the bar is edited in place, never rebuilt. */
     private readonly _tabs;
+    /** The same chips as {@link _tabs}, held as the shared builder's parts for a refresh. */
+    private readonly _chips;
     /** Page panels keyed by page id; kept so a DETACHED page's node is still reachable. */
     private readonly _panels;
     private readonly _hovered;
@@ -103,7 +105,16 @@ export declare class AdwTabView extends HTMLElement {
     reorderLast(id: string): boolean;
     setPageTitle(id: string, title: string | null): boolean;
     setPageTooltip(id: string, tooltip: string | null): boolean;
+    /**
+     * Set a page's search keyword (`AdwTabPage:keyword`) — the string the tab overview's
+     * search matches on beside the title and the tooltip ("Use keywords to search in
+     * e.g. page URLs in a web browser", adw-tab-overview.c:1646-1648).
+     */
+    setPageKeyword(id: string, keyword: string | null): boolean;
+    /** Set a page's icon name (`adw_tab_page_set_icon`). */
     setPageIcon(id: string, icon: string | null): boolean;
+    /** Set a page's indicator icon (`adw_tab_page_set_indicator_icon`). */
+    setPageIndicatorIcon(id: string, indicatorIcon: string | null): boolean;
     setPageLoading(id: string, loading: boolean): boolean;
     setPageNeedsAttention(id: string, needsAttention: boolean): boolean;
     /** Every precondition the model refused, as C would have warned about it. */
@@ -117,35 +128,20 @@ export declare class AdwTabView extends HTMLElement {
     private _moveTab;
     private _refreshTab;
     /**
-     * `get_tab_position` in the BAR's scroll space: how far the chip sits from the
-     * strip's scroll origin, the one coordinate both `scroll_to_tab_full` and
-     * `update_visible` compare against the adjustment.
-     *
-     * Never `offsetLeft`. Nothing in this widget is positioned, so a chip's offsetParent
-     * is whichever positioned ancestor the HOST page happens to have; a tab view that
-     * merely sits indented then measured every chip against the wrong origin and
-     * reported all of them clipped.
-     */
-    private _tabPosition;
-    /**
-     * `tabCloseVisible`, with its pinned gate. `dragging` is constantly false — tab
-     * drag-and-drop is compositor work and is not modelled — and `fullyVisible` is
-     * measured against the bar's scroll window, which is what the C term means for a
-     * horizontally scrolled bar.
+     * The close affordance's visibility, and both halves of it now live in `../tab-chip.js`
+     * — `tabCloseVisible` and the geometry it is measured with, in the BAR's own scroll
+     * space. The incident that moved them there is recorded beside `chipPosition`: the
+     * measurement once used `offsetLeft`, which is relative to whichever positioned ancestor
+     * the HOST page happens to have, so a tab view that merely sat indented reported every
+     * chip clipped and swallowed the close button on hover.
      */
     private _refreshCloseVisibility;
     private _onSelectionChange;
     private _applyActiveState;
     /**
      * `scroll_to_tab_full` (adw-tab-box.c:928-961), called on every selection the way
-     * `select_page` calls it (:1728): bring the selected chip inside the BAR's own
-     * scroll window, padded by half of whichever is smaller, the chip or the leftover.
-     *
-     * The bar is the only thing C ever scrolls for a tab: `scroll_to_tab_full` writes
-     * `self->adjustment`, the strip's own adjustment, and nothing else. The DOM has no
-     * such narrow API: `focus()` and `scrollIntoView()` both walk EVERY scrollable
-     * ancestor up to the window. So this moves `scrollLeft` by hand, and the focus call
-     * below passes `preventScroll`.
+     * `select_page` calls it (:1728) — `scrollChipIntoBar` in `../tab-chip.js`, with the
+     * reasoning and the SPACING slack that is deliberately not transplanted.
      */
     private _scrollSelectedTabIntoBar;
     private _applyBarVisibility;

package/lib/types/elements/adw-toggle-group.d.ts

@@ -1,6 +1,7 @@
 /** A single toggle. Children of <adw-toggle-group>; consumed at connect time. */
 export declare class AdwToggle extends HTMLElement {
     static get observedAttributes(): string[];
+    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
 }
 export declare class AdwToggleGroup extends HTMLElement {
     private _innerEl;
@@ -12,7 +13,21 @@ export declare class AdwToggleGroup extends HTMLElement {
     private _stateAttr;
     /** Each toggle's `name`, in order — what `active-name` resolves against. */
     private _names;
+    /** `AdwToggle:enabled` per rendered button, in order — `add_toggle` spends this at add time. */
+    private _enabled;
+    /** The authored <adw-toggle> elements, kept to observe live `enabled` changes. */
+    private _toggles;
     static get observedAttributes(): string[];
+    /**
+     * `GtkWidget:sensitive` — whether the whole group is insensitive.
+     *
+     * TRUE unless the attribute says `false`, because the property defaults to TRUE and a
+     * boolean attribute read by PRESENCE would leave every group on a page insensitive.
+     */
+    get sensitive(): boolean;
+    set sensitive(value: boolean);
+    /** Whether the toggle at `index` is enabled (`AdwToggle:enabled`) — false once disabled. */
+    isToggleEnabled(index: number): boolean;
     /** Zero-based index of the active toggle. */
     get active(): number;
     set active(value: number);
@@ -30,4 +45,6 @@ export declare class AdwToggleGroup extends HTMLElement {
     private _readActiveAttr;
     private _selectIndex;
     private _render;
+    /** Select the first enabled toggle, if there is one — the C's "no active" repair. */
+    private _activateFirstEnabled;
 }

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

@@ -0,0 +1,84 @@
+import type { SidebarItemFilter } from '@gjsify/adwaita-core';
+import type { AdwViewStack } from './adw-view-stack.js';
+export declare class AdwViewSwitcherSidebar extends HTMLElement {
+    private _sidebar;
+    private _placeholderEl;
+    private _prefixEl;
+    private _suffixEl;
+    private _stack;
+    private _filter;
+    private _initialized;
+    static get observedAttributes(): string[];
+    /** `AdwViewSwitcherSidebar:stack` — the stack the sidebar controls. */
+    get stack(): AdwViewStack | null;
+    set stack(value: AdwViewStack | string | null);
+    /**
+     * `adw_view_switcher_sidebar_set_stack`: unbind the old stack's four connections, bind
+     * the new one's, and populate. A NULL stack is refused, exactly as C is
+     * (`g_return_if_fail (!stack)`, :284) — an overview-less sidebar is not a state the C
+     * has, and inventing one here would give a reader a widget libadwaita cannot build.
+     */
+    setStack(stack: AdwViewStack | null): void;
+    /** `AdwViewSwitcherSidebar:mode` — `sidebar` (default) or `page`. */
+    get mode(): 'sidebar' | 'page';
+    set mode(value: 'sidebar' | 'page');
+    /**
+     * `AdwViewSwitcherSidebar:filter` — a `GtkFilter`, which on this renderer is the
+     * sidebar's own predicate. A property and not an attribute: it is a FUNCTION, and
+     * markup cannot carry one.
+     */
+    get filter(): SidebarItemFilter | null;
+    set filter(value: SidebarItemFilter | null);
+    /** `AdwViewSwitcherSidebar:placeholder` — shown when no item survives. */
+    get placeholder(): HTMLElement | null;
+    set placeholder(value: HTMLElement | null);
+    /**
+     * `AdwViewSwitcherSidebar:prefix` (1.10) — shown above the items.
+     *
+     * NOT `prefix`. `HTMLElement.prefix` is the RDFa attribute and a STRING, and a
+     * property of a different type cannot shadow it (TS2416). The GIR name is kept in the
+     * SLOT (`slot="prefix"`, what a `.blp`'s `prefix: …` authors) and here in the header.
+     */
+    get prefixWidget(): HTMLElement | null;
+    set prefixWidget(value: HTMLElement | null);
+    /** `AdwViewSwitcherSidebar:suffix` (1.10) — shown below the items. `suffixWidget`, as `prefixWidget`. */
+    get suffixWidget(): HTMLElement | null;
+    set suffixWidget(value: HTMLElement | null);
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    private _resolveStack;
+    /** The stack this sidebar is next to, when the author named no id. */
+    private _findStack;
+    /** `set_stack`'s four connections (:270-282), read off the stack's own events. */
+    private _bindStack;
+    private _unbindStack;
+    private _onStackChange;
+    /**
+     * `activated_cb` (:104-112) — the row's index is the stack's index, so the two lists
+     * are kept one for one. The selection moves FIRST: `activated` is the signal a split
+     * view reveals its content pane on, and a handler that read the stack in that callback
+     * would otherwise see the page the user was leaving.
+     */
+    private _onSidebarActivated;
+    /**
+     * `populate_sidebar` (:225-249) — one `AdwSidebarSection` per group of pages, each
+     * holding one `AdwSidebarItem` per page. The grouping is core's, so the browser and
+     * any second renderer derive the sections from the same table.
+     */
+    private _populate;
+    private _toSectionSpec;
+    /**
+     * `selection_changed_cb` (:258-271) — the row follows the stack's visible page. Read as
+     * the INDEX, because the sidebar's flat index space is the unfiltered one (ADR 0004),
+     * so page position and row position are the same number.
+     */
+    private _syncSelection;
+    private _applyMode;
+    /**
+     * `placeholder` (:449-460) — shown when the sidebar has no items, or when the filter
+     * took them all. The `<adw-sidebar>` knows the filtered list (`visibleItems` is empty),
+     * which is the C condition in `AdwSidebar`'s own words.
+     */
+    private _applyEmptyState;
+}

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

@@ -1,3 +1,43 @@
+import { AdwBreakpoint } from '@gjsify/adwaita-core';
 export declare class AdwWindow extends HTMLElement {
+    private _initialized;
+    private _contentEl;
+    private _breakpoints;
+    private _disposeBreakpoints;
+    private _openDialogs;
+    static get observedAttributes(): string[];
+    /** The content area — the Adw.Window:content property. */
+    get contentArea(): HTMLDivElement;
+    /** The content widget — the first child of the content area. */
+    get content(): HTMLElement | null;
+    set content(value: HTMLElement | null);
+    /** The breakpoints added to this window. */
+    get breakpoints(): readonly AdwBreakpoint[];
+    /** The currently applied breakpoint, or null when none is. */
+    get currentBreakpoint(): AdwBreakpoint | null;
+    /** The open dialogs presented inside this window (Adw.Window:dialogs). */
+    get dialogs(): readonly HTMLElement[];
+    /** The currently visible dialog, or null when none is (Adw.Window:visible-dialog). */
+    get visibleDialog(): HTMLElement | null;
+    /**
+     * Add a breakpoint to this window (adw_window_add_breakpoint).
+     * The breakpoint evaluates against the window's own box and sets a
+     * `data-breakpoint` attribute when applied.
+     */
+    addBreakpoint(condition: string): AdwBreakpoint;
     connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    private _buildOnce;
+    /**
+     * Bind the breakpoints to THIS box.
+     *
+     * NOT once per lifetime: `disconnectedCallback` releases the disposer, so a
+     * window moved between parents would come back deaf — and a window is exactly
+     * the thing a client-side route change re-parents. Re-binding is cheap and
+     * idempotent, and it re-measures the new box on the way.
+     */
+    private _bindBreakpoints;
+    /** The window's size request — GTK's, not CSS's, so an absent attribute means the default. */
+    private _applySizeRequest;
 }