@gjsify/adwaita-web 0.54.0 → 0.55.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-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/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-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-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-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-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

@@ -61,6 +61,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-switch-row.d.ts

@@ -1,12 +1,15 @@
 import './gtk-switch.js';
 export declare class AdwSwitchRow extends HTMLElement {
     private _switchEl;
+    private _prefixEl;
     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;

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