@gjsify/adwaita-web 0.31.0 → 0.33.0

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

@@ -3,6 +3,30 @@ export declare class AdwOverlaySplitView extends HTMLElement {
     private _sidebarEl;
     private _contentEl;
     private _backdropEl;
+    private _disposeBreakpoint;
+    /**
+     * The single source of truth for the property interplay, shared with the
+     * NativeScript renderer (ADR 0004). The element owns the attributes and the
+     * painting; every rule about what `collapsed` + `show-sidebar` + `pin-sidebar`
+     * MEAN together lives in core, held to `OVERLAY_COLLAPSE_VECTORS`.
+     */
+    private _state;
+    /** Re-entrancy guard for {@link _reflectShowSidebar}. */
+    private _reflecting;
+    /** The view's own width in CSS px — the size the sidebar fraction is OF. */
+    private _measuredWidth;
+    private _resizeObserver;
+    /** The pointer currently panning the sidebar, if any. */
+    private _swipePointer;
+    /** Where the pan started, and the progress it started from. */
+    private _swipeOrigin;
+    /**
+     * Every attribute {@link _readAttribute} handles must be listed here — an
+     * unobserved attribute never reaches `attributeChangedCallback`, so its branch
+     * is DEAD after construction. `pin-sidebar` was missing, which made the
+     * property that suppresses the collapse coupling settable only in the markup
+     * a parser saw: `view.setAttribute('pin-sidebar', '')` did nothing at all.
+     */
     static get observedAttributes(): string[];
     get showSidebar(): boolean;
     set showSidebar(v: boolean);
@@ -12,10 +36,80 @@ export declare class AdwOverlaySplitView extends HTMLElement {
     get maxSidebarWidth(): number;
     get sidebarWidthFraction(): number;
     connectedCallback(): void;
+    /** The DOM surgery and the state, which happen once per element lifetime. */
+    private _buildOnce;
+    /**
+     * Everything that must be re-established every time the element enters a
+     * document — NOT once per lifetime.
+     *
+     * `connectedCallback` returns early on the second connect (the DOM is
+     * already built), so anything torn down in `disconnectedCallback` used to be
+     * gone for good: moving the view between parents — which is what a slideshow
+     * or a client-side route change does — killed the ResizeObserver and left
+     * `_measuredWidth` frozen at whatever it last saw, or at 0 if the view had
+     * never been visible. That is the other half of the docs-site regression.
+     */
+    private _bindToDocument;
+    disconnectedCallback(): void;
+    /** `escape_shortcut_cb` — only a COLLAPSED view with a revealed sidebar consumes it. */
+    private readonly _onKeyDown;
     attributeChangedCallback(_name: string, _old: string | null, _val: string | null): void;
+    /**
+     * Push ONE attribute into the state, then reflect back what the state made
+     * of it.
+     *
+     * Per-attribute rather than a re-read of all of them, because `show-sidebar`
+     * is a value the state ALSO owns: collapsing auto-hides an unpinned sidebar,
+     * and a blanket re-read would immediately clobber that decision with the
+     * stale attribute.
+     */
+    private _readAttribute;
+    /**
+     * Mirror the state's `showSidebar` back onto the attribute, so the DOM keeps
+     * telling the truth after an auto-hide.
+     *
+     * Guarded: writing the attribute re-enters `attributeChangedCallback`, and
+     * without the flag that is an infinite reflection loop rather than a render.
+     */
+    private _reflectShowSidebar;
+    /** (Re)bind the `breakpoint` condition to `collapsed`. */
+    private _syncBreakpoint;
     openSidebar(): void;
     hideSidebar(): void;
     toggleSidebar(): void;
+    /**
+     * The reading direction `start` / `end` are resolved against.
+     *
+     * `get_start_or_end` (adw-overlay-split-view.c:227-234) returns
+     * `GTK_PACK_END` under RTL, so a `start` sidebar is drawn on the RIGHT.
+     * Neither renderer mirrored any of it; the browser has the direction for
+     * free and only had to read it.
+     */
+    private get _direction();
+    /** The sizing properties as the core takes them. */
+    private get _widthSpec();
+    /** The sidebar's allocated width in px — `get_sidebar_width` (:441-466). */
+    private get _sidebarWidth();
     private _syncClasses;
+    /**
+     * Place the sidebar for the current progress — `allocate_uncollapsed`
+     * (:572-610) and `allocate_collapsed` (:653-703), through the core.
+     *
+     * The slide used to be `marginRight: -offsetWidth` REGARDLESS of which edge
+     * the sidebar is on, so an `end` sidebar slid the wrong way; and it was only
+     * two states, so a swipe had nothing to drive. `layoutOverlaySplitView`
+     * returns the pane rect for any progress including the overshoot, which is
+     * what makes a continuous gesture expressible at all.
+     */
+    private _syncGeometry;
     private _syncSidebarWidth;
+    /**
+     * The pan gesture the five `OVERLAY_SWIPE_*` tables describe.
+     *
+     * There was no gesture code in either renderer — grep for `pan` in both
+     * split views returned zero — so `showProgress` was only ever 0 or 1 and the
+     * tables shipped unexercised. Pointer events give the browser the whole
+     * gesture in three handlers; every DECISION in them is core's.
+     */
+    private _bindSwipe;
 }

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

@@ -1,16 +1,25 @@
-export declare class AdwPasswordEntryRow extends HTMLElement {
-    private _input;
-    private _titleEl;
+import { AdwEntryRow } from './adw-entry-row.js';
+export declare class AdwPasswordEntryRow extends AdwEntryRow {
+    /** The headless peek + caps-lock derivation, composing the parent row's state. */
+    private readonly _password;
     private _toggle;
     private _toggleIcon;
-    private _initialized;
     static get observedAttributes(): string[];
-    get text(): string;
-    set text(value: string);
-    /** Whether the contents are shown in clear text (peek toggle is engaged). */
+    protected get _classPrefix(): string;
+    /** Whether the contents are shown in clear text (`GtkText:visibility`). */
     get revealed(): boolean;
     set revealed(value: boolean);
-    connectedCallback(): void;
-    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
-    private _renderRevealed;
+    /** Whether Caps Lock is engaged, as last observed from a keyboard event. */
+    get capsLockOn(): boolean;
+    /**
+     * Feed the platform's Caps Lock state in — GDK gets it from the keyboard
+     * device (adw-password-entry-row.c:111-115). Public because a host that
+     * knows better than `KeyboardEvent.getModifierState` (a virtual keyboard, a
+     * test) can drive it directly.
+     */
+    setCapsLockOn(on: boolean): void;
+    protected _onConnected(): void;
+    attributeChangedCallback(name: string, oldValue: string | null, value: string | null): void;
+    /** `notify_visibility_cb` (C:62-81), applied to the DOM. */
+    private _renderPassword;
 }

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

@@ -0,0 +1,58 @@
+/** Which side of the anchor the surface sits on. */
+export type AdwPopoverPosition = 'bottom' | 'top' | 'start' | 'end';
+/** Which edge of the anchor the surface lines up with. */
+export type AdwPopoverAlign = 'start' | 'end';
+/** The ARIA role of the surface — it decides the row role consumers give their items. */
+export type AdwPopoverRole = 'menu' | 'listbox';
+export declare class AdwPopover extends HTMLElement {
+    private readonly _state;
+    private _anchor;
+    private _initialized;
+    /** Guards the `open` attribute↔property loop, which would otherwise recurse. */
+    private _reflecting;
+    private _onDocumentPointerDown;
+    private _onDocumentKeyDown;
+    static get observedAttributes(): string[];
+    /** Whether the popover is showing. */
+    get open(): boolean;
+    set open(value: boolean);
+    /**
+     * The element the surface is positioned against and hands focus back to.
+     * Defaults to `parentElement`, which is the common case: the popover is the
+     * last child of the widget that owns it.
+     */
+    get anchor(): HTMLElement | null;
+    set anchor(value: HTMLElement | null);
+    /** Which side of the anchor the surface sits on. */
+    get position(): AdwPopoverPosition;
+    set position(value: AdwPopoverPosition);
+    /** Which edge of the anchor the surface lines up with. */
+    get align(): AdwPopoverAlign;
+    set align(value: AdwPopoverAlign);
+    /** The surface's ARIA role. */
+    get popoverRole(): AdwPopoverRole;
+    /** The navigable rows, in DOM order. Hidden rows are skipped — a filtered list navigates what it shows. */
+    get items(): HTMLElement[];
+    /** Show the popover — `gtk_popover_popup()`. */
+    popup(): void;
+    /** Hide the popover — `gtk_popover_popdown()`. */
+    popdown(): void;
+    /** Subscribe to open-state changes. Returns an unsubscribe function. */
+    subscribe(listener: (open: boolean) => void): () => void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, _previous: string | null, value: string | null): void;
+    private _onStateChange;
+    private _bindDocument;
+    private _unbindDocument;
+    private _render;
+    /**
+     * Arrow/Home/End/Enter/Space inside the surface. The arithmetic is core's
+     * ({@link resolvePopoverKey}); this only maps its answer onto the DOM.
+     *
+     * Escape is NOT handled here — it is bound at the document in capture phase
+     * so it works no matter where focus sits, including a search entry inside
+     * the popover.
+     */
+    private _onKeyDown;
+}

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

@@ -1,10 +1,28 @@
+import type { PreferencesSearchResult, SearchPreferencesOptions } from '@gjsify/adwaita-core';
 /**
- * A single preferences page. Child of <adw-preferences-dialog>; consumed at
- * connect time. Carries optional `title` / `icon-name` attributes and any
+ * A single preferences page. Child of <adw-preferences-dialog>. Carries optional
+ * `title` / `icon-name` / `name` / `use-underline` attributes and any
  * <adw-preferences-group> content — mirrors Adw.PreferencesPage.
+ *
+ * The dialog keeps the page ELEMENT rather than hoisting its children out,
+ * because the page's identity is load-bearing: `adw_preferences_dialog_add`
+ * binds title / icon-name / name / use-underline / visible onto the view-stack
+ * page (adw-preferences-dialog.c:707-711), and `create_search_row_subtitle`
+ * needs the title back the moment a second page is visible.
  */
 export declare class AdwPreferencesPage extends HTMLElement {
     static get observedAttributes(): string[];
+    /** `adw_preferences_page_get_name` — the view-stack child name. */
+    get name(): string;
+    set name(value: string);
+    /** `AdwPreferencesPage:icon-name`, shown by a view switcher. */
+    get iconName(): string;
+    set iconName(value: string);
+    /** `AdwPreferencesPage:use-underline` — the title carries a mnemonic. */
+    get useUnderline(): boolean;
+    set useUnderline(value: boolean);
+    /** The page's groups, in document order. */
+    get groups(): HTMLElement[];
 }
 export declare class AdwPreferencesDialog extends HTMLElement {
     private _initialized;
@@ -12,6 +30,7 @@ export declare class AdwPreferencesDialog extends HTMLElement {
     private _dialogEl;
     private _titleEl;
     private _bodyEl;
+    private _pagesEl;
     private _closeBtn;
     static get observedAttributes(): string[];
     /** Whether the dialog is revealed. */
@@ -29,6 +48,42 @@ export declare class AdwPreferencesDialog extends HTMLElement {
     close(): void;
     /** Dismiss the dialog regardless of `can-close` (mirrors Adw.Dialog.force_close). */
     forceClose(): void;
+    /**
+     * `adw_preferences_dialog_add` (adw-preferences-dialog.c:693-716) — add a
+     * page at ANY time.
+     *
+     * Before this the pages were snapshotted once, in `connectedCallback`; a
+     * page appended later stayed a sibling of the scrim and rendered OUTSIDE
+     * the dialog card. GTK and the NativeScript port both accept a page
+     * whenever it arrives.
+     */
+    add(page: AdwPreferencesPage): void;
+    /**
+     * `adw_preferences_dialog_remove` (:723-745). C logs
+     * `ADW_CRITICAL_CANNOT_REMOVE_CHILD` and no-ops for a page it does not own;
+     * returning `false` is the same contract without a console write.
+     *
+     * NOT named `remove`: `ChildNode.remove()` already exists on every element
+     * and takes no arguments, so overriding it with a different signature makes
+     * the class un-assignable to `HTMLElement` — which `customElements.define`
+     * requires.
+     */
+    removePage(page: AdwPreferencesPage): boolean;
+    /** The dialog's pages, in add order. */
+    get pages(): AdwPreferencesPage[];
+    /**
+     * The preferences search (`filter_search_results` +
+     * `create_search_row_subtitle`), over this dialog's live page subtree.
+     *
+     * The whole pipeline is `@gjsify/adwaita-core`'s, so this dialog and the
+     * NativeScript one answer identically for the same tree — including the
+     * three corpus filters (visible page → visible group → titled visible row)
+     * and the case fold that makes `strasse` find `Straße`.
+     *
+     * An empty query returns the WHOLE corpus, which is what C does and what
+     * makes the results list non-empty before the user types.
+     */
+    search(query: string, options?: SearchPreferencesOptions): PreferencesSearchResult<Element>[];
     connectedCallback(): void;
     attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
     private _attemptClose;

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

@@ -1,12 +1,43 @@
 export declare class AdwPreferencesGroup extends HTMLElement {
+    private _headerEl;
     private _titleEl;
     private _descriptionEl;
     private _suffixEl;
+    private _listboxEl;
     private _initialized;
+    private _observer;
     static get observedAttributes(): string[];
     get description(): string;
     set description(value: string);
+    /**
+     * `adw_preferences_group_add` (adw-preferences-group.c:396-411): a row goes
+     * into the boxed list, a `header-suffix` child into the header.
+     *
+     * Exposed as a method AND wired to a `MutationObserver` on the host, because
+     * both spellings occur: `group.addRow(row)` in code, `group.append(row)` in
+     * a framework's rendering. Before this, a child appended after connect
+     * stayed a bare child of the host — outside the card, and invisible to the
+     * row count that decides whether the card is painted at all.
+     */
+    addRow(child: Node): void;
+    /**
+     * `adw_preferences_group_remove` (:421-440). C logs
+     * `ADW_CRITICAL_CANNOT_REMOVE_CHILD` and no-ops for a child it does not
+     * own; returning `false` is the same contract without a console write.
+     */
+    removeRow(child: Node): boolean;
     connectedCallback(): void;
+    disconnectedCallback(): void;
     attributeChangedCallback(): void;
+    /**
+     * Adopt children appended to the HOST after the subtree was built, so
+     * `group.append(row)` behaves like `adw_preferences_group_add`.
+     *
+     * C gets this for free — `gtk_widget_observe_children` on the listbox drives
+     * `update_listbox_visibility` through `items-changed`
+     * (adw-preferences-group.c:335-339) — and a DOM element needs the observer
+     * to have the same rule hold over time rather than only at connect.
+     */
+    private _observeHost;
     private _renderHeader;
 }

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

@@ -0,0 +1,38 @@
+export declare class AdwProgressBar extends HTMLElement {
+    private _trough;
+    private _progress;
+    private _text;
+    private _initialized;
+    static get observedAttributes(): string[];
+    /** How much of the bar is filled, 0…1. Always the CLAMPED value. */
+    get fraction(): number;
+    set fraction(value: number);
+    /** Whether the bar is indeterminate. */
+    get pulsing(): boolean;
+    set pulsing(value: boolean);
+    /** Whether the text node is shown. */
+    get showText(): boolean;
+    set showText(value: boolean);
+    /** The shown text. Falls back to the fraction as a percentage. */
+    get text(): string;
+    set text(value: string);
+    /** Whether the bar fills from the far end. */
+    get inverted(): boolean;
+    set inverted(value: boolean);
+    /** Whether the `.osd` hairline variant is used. */
+    get osd(): boolean;
+    set osd(value: boolean);
+    /** Whether the widget is dimmed. */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    /**
+     * Switch the bar to indeterminate — GtkProgressBar's method name for the
+     * same intent. See the module header: the bouncing block is a CSS animation
+     * here, so this ENTERS the state and repeat calls are no-ops; GTK's
+     * `pulse-step` arithmetic is not verifiable in this tree and is not faked.
+     */
+    pulse(): void;
+    connectedCallback(): void;
+    attributeChangedCallback(): void;
+    private _render;
+}

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

@@ -1,29 +1,61 @@
+import { type AdwSidebarItemSpec, type AdwSidebarSectionSpec, type SidebarItemFilter } from '@gjsify/adwaita-core';
 /** A single sidebar item. Child of <adw-sidebar-section>; consumed at connect time. */
 export declare class AdwSidebarItem extends HTMLElement {
     static get observedAttributes(): string[];
+    attributeChangedCallback(name: string, _oldValue: string | null, newValue: string | null): void;
 }
 /** A titled group of items. Child of <adw-sidebar>; consumed at connect time. */
 export declare class AdwSidebarSection extends HTMLElement {
     static get observedAttributes(): string[];
+    attributeChangedCallback(_name: string, _oldValue: string | null, newValue: string | null): void;
 }
 export declare class AdwSidebar extends HTMLElement {
+    private readonly _state;
     private _listEl;
     private _rows;
-    private _selected;
-    private _mode;
     private _initialized;
+    /** Guards the `selected` attribute write we make ourselves from re-entering. */
+    private _reflecting;
     static get observedAttributes(): string[];
     /** Zero-based flat index of the selected item, or -1 for no selection. */
     get selected(): number;
     set selected(value: number);
+    /** The selected item's spec, or undefined — Adw.Sidebar:selected-item. */
+    get selectedItem(): AdwSidebarItemSpec | undefined;
     /** 'sidebar' (flat navigation list) or 'page' (boxed lists). */
     get mode(): 'sidebar' | 'page';
     set mode(value: 'sidebar' | 'page');
+    /** The section/item model. Assigning replaces it, the way adw_sidebar_remove_all + append would. */
+    get sections(): readonly AdwSidebarSectionSpec[];
+    set sections(value: readonly AdwSidebarSectionSpec[]);
+    /** Adw.Sidebar:filter — decides which rows render, never the selection index space. */
+    get filter(): SidebarItemFilter | null;
+    set filter(value: SidebarItemFilter | null);
     connectedCallback(): void;
     attributeChangedCallback(name: string): void;
+    /**
+     * Re-derive after a declared `<adw-sidebar-item>` / `<adw-sidebar-section>`
+     * attribute changed. The item model keeps its shape, so the selection cannot
+     * move — exactly like the GObject property bindings this stands in for.
+     */
+    refresh(): void;
+    /** Snapshot the declared children into specs, and bind them for live updates. */
+    private _readDeclaredSections;
     private _readModeAttr;
+    /**
+     * `parseFloat`, not `parseInt`: the core rejects a fractional position, and
+     * truncating `"1.5"` to row 1 here would hide that from it. An unparseable
+     * value is NaN, which the core turns into "no selection".
+     */
     private _readSelectedAttr;
-    /** Click handler — selects the row (if changed) and always emits `activated`. */
-    private _activateIndex;
-    private _render;
+    private _reflectSelected;
+    private _onSelectionChanged;
+    /** Click handler — the core applies the selection, then `activated` fires. */
+    private _activate;
+    /** Rebuild the rendered rows + headers from the core's derived model. */
+    private _rebuild;
+    private _createHeader;
+    private _createRow;
+    private _applyMode;
+    private _applySelection;
 }

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

@@ -1,6 +1,29 @@
 export declare class AdwSpinner extends HTMLElement {
     static get observedAttributes(): string[];
+    private _svg;
+    private _track;
+    private _arc;
+    /** Path length of the ring, so the dash arithmetic is done once per resize. */
+    private _circumference;
+    /** Ring radius in px — the dash lengths are arc-length, i.e. radians × r. */
+    private _radius;
+    /** The timestamp this spinner was mapped at, so its progress starts at 0. */
+    private _origin;
     connectedCallback(): void;
+    disconnectedCallback(): void;
     attributeChangedCallback(): void;
+    /**
+     * Draw the frame for `now`, in `requestAnimationFrame` timebase.
+     *
+     * Public because the shared ticker is a module-level function rather than a
+     * method — and because a test needs to place the spinner at a known moment
+     * without waiting for real frames.
+     */
+    drawAt(now: number): void;
+    private _build;
+    /** Re-derive the box, the ring and the stroke from the `size` attribute. */
     private _sync;
+    /** The progress the last painted frame used, so a resize can repaint it. */
+    private _lastProgress;
+    private _paint;
 }

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

@@ -1,18 +1,64 @@
+import type { AdwMenuEntry, SplitButtonDirection } from '@gjsify/adwaita-core';
+import './adw-popover.js';
 export declare class AdwSplitButton extends HTMLElement {
+    private readonly _state;
     private _actionEl;
     private _dropdownEl;
+    private _arrowEl;
     private _menuEl;
-    private _label;
-    private _active;
+    /** Inline text content, captured before we take over the subtree. */
+    private _inlineLabel;
+    /** Last `open` value reflected as `notify::active`, so the event fires once per flip. */
+    private _openReflected;
     private _initialized;
-    private _onDocumentPointerDown;
     static get observedAttributes(): string[];
     /** Whether the dropdown menu is currently open. */
     get active(): boolean;
+    /** Whether the dropdown half is live (there is a menu to show). */
+    get dropdownEnabled(): boolean;
+    /** The action label, or `null` when the action half shows an icon or nothing. */
+    get label(): string | null;
+    set label(value: string);
+    /** The symbolic icon name, or `null` when the action half shows a label or nothing. */
+    get iconName(): string | null;
+    set iconName(value: string);
+    /** The dropdown menu entries. */
+    get menuItems(): readonly AdwMenuEntry[];
+    set menuItems(value: readonly AdwMenuEntry[]);
+    /** The dropdown tooltip as set — `''` while unset. */
+    get dropdownTooltip(): string;
+    set dropdownTooltip(value: string);
+    /** The direction the popup opens in, and the arrow points. */
+    get direction(): SplitButtonDirection;
+    set direction(value: SplitButtonDirection);
+    /** Whether an underline in the label marks a mnemonic. */
+    get useUnderline(): boolean;
+    set useUnderline(value: boolean);
+    /** Pop the menu up — `adw_split_button_popup()`. */
+    popup(): void;
+    /** Dismiss the menu — `adw_split_button_popdown()`. */
+    popdown(): void;
     connectedCallback(): void;
-    disconnectedCallback(): void;
-    attributeChangedCallback(): void;
-    private _setActive;
-    private _parseMenu;
+    attributeChangedCallback(name: string, _previous: string | null, value: string | null): void;
+    /** Seed label/icon/menu/direction/tooltip from the attributes present at connect time. */
+    private _syncStateFromAttributes;
+    /**
+     * Route a `label` / `icon-name` attribute mutation into the content machine.
+     *
+     * C has no independent "unset" for either slot — clearing one is a side
+     * effect of setting another — so a REMOVED attribute falls back to whichever
+     * sibling is still present, and to the empty child otherwise. That fallback
+     * is what makes `removeAttribute('label')` actually drop the label; it used
+     * to be a silent no-op, so the storybook's icon-only mode rendered the icon
+     * next to a stale "Save".
+     */
+    private _applyContentAttribute;
+    private _onStateChange;
     private _render;
+    /** The action half + the root style classes libadwaita derives from it. */
+    private _renderContent;
+    /** The dropdown half: arrow glyph, tooltip/accessible name, expanded state. */
+    private _renderDropdown;
+    /** The popover contents, one button per menu entry, dispatched BY POSITION. */
+    private _renderMenu;
 }

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

@@ -1,12 +1,21 @@
+import './adw-switch.js';
 export declare class AdwSwitchRow extends HTMLElement {
-    private _checkbox;
+    private _switchEl;
     private _titleEl;
     private _subtitleEl;
+    /** The headless active flag + its notify rule (ADR 0004). */
+    private readonly _state;
     private _initialized;
     static get observedAttributes(): string[];
     get active(): boolean;
     set active(value: boolean);
     connectedCallback(): void;
-    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    attributeChangedCallback(name: string): void;
+    /**
+     * Push a state transition out to the DOM and emit `notify::active` — but
+     * only when something actually changed, which is the `g_object_notify`
+     * gate libadwaita puts on the same transition (C:224-225 → :76).
+     */
+    private _apply;
     private _renderText;
 }

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

@@ -0,0 +1,15 @@
+export declare class AdwSwitch extends HTMLElement {
+    private _input;
+    private _slider;
+    private _initialized;
+    static get observedAttributes(): string[];
+    /** Whether the switch is on. */
+    get active(): boolean;
+    set active(value: boolean);
+    /** Whether the switch is inert. */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    connectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    private _render;
+}