@gjsify/adwaita-nativescript 0.31.0 → 0.33.0

package/lib/types/widgets/adw-button-content.d.ts

@@ -1,23 +1,58 @@
-import { Label, StackLayout } from '@nativescript/core';
+import { Label, StackLayout, type View } from '@nativescript/core';
+import type { ButtonContentEllipsize } from '@gjsify/adwaita-core';
 import { AdwIcon } from './adw-icon.js';
 export declare class AdwButtonContent extends StackLayout {
-    /** The leading symbolic icon (lazily in the tree — only when an icon is set). */
+    /** The leading symbolic icon. Always parented — the C never hides the image. */
     protected readonly _icon: AdwIcon;
     /** The text label. */
     protected readonly _label: Label;
-    private _hasIcon;
-    private _iconSvg;
+    private readonly _props;
+    private _hostButton;
     constructor();
+    /**
+     * The button view this content styles — NS's stand-in for the `GtkButton`
+     * ancestor `adw_button_content_root` finds (:108).
+     *
+     * Setting it adds `image-text-button` (:115); clearing it, or replacing it,
+     * removes the class from the previous host first (:126), so a button that
+     * loses its content goes back to plain-button padding.
+     */
+    get hostButton(): View | null;
+    set hostButton(view: View | null);
     /**
      * A leading Adwaita symbolic SVG string (e.g. `folderDownloadSymbolic`).
-     * Setting a non-empty value inserts the icon before the label; empty removes it.
+     *
+     * An empty value shows the `image-missing` asset rather than hiding the icon:
+     * the C sets that fallback (:355-356) and never hides `self->icon`. The doc
+     * comments at :228/:343 say otherwise — see `buttonContentIconSvg`.
      */
     get icon(): string;
     set icon(svg: string);
+    /** Whether the icon currently shown is the empty-slot fallback. */
+    get iconIsFallback(): boolean;
     /** The icon fill colour (hex). Set to the button's foreground (e.g. white on suggested-action). */
     get iconColor(): string;
     set iconColor(value: string);
-    /** The button content text. */
+    /** The button content text. Empty collapses the label view (:398). */
     get label(): string;
     set label(value: string);
+    /**
+     * Whether an underline in {@link label} marks a mnemonic (:431-445).
+     * Defaults to FALSE (:253-256), so an underscore is a literal unless asked.
+     */
+    get useUnderline(): boolean;
+    set useUnderline(value: boolean);
+    /**
+     * Whether the label may be smaller than its natural size (:489-491).
+     *
+     * FIDELITY GAP: this is `PANGO_ELLIPSIZE_END` in GTK and the NS CSS subset
+     * has no ellipsize, so the property is held, reported through
+     * {@link ellipsize}, and reflected as a `can-shrink` class for the theme —
+     * but the truncation ellipsis is not available on this platform.
+     */
+    get canShrink(): boolean;
+    set canShrink(value: boolean);
+    /** The label's `PangoEllipsizeMode` for the current `canShrink` (:462). */
+    get ellipsize(): ButtonContentEllipsize;
+    private _renderLabel;
 }

package/lib/types/widgets/adw-button-row.d.ts

@@ -2,27 +2,49 @@ import { StackLayout } from '@nativescript/core';
 import { AdwActionRow } from './adw-action-row.js';
 import { AdwIcon } from './adw-icon.js';
 /** Event name emitted when the row is tapped. Mirrors `Adw.ButtonRow::activated`. */
-export declare const ACTIVATED = "activated";
+export { ACTIVATED } from './adw-action-row.js';
 export declare class AdwButtonRow extends AdwActionRow {
-    /** The horizontal content box (leading icon + centered title). */
+    /** `AdwButtonRow` derives from `AdwPreferencesRow` in C
+     *  (adw-button-row.c:74), so the search does not consult a subtitle here. */
+    readonly isActionRow: boolean;
+    /** The horizontal content box (leading icon + centered title + trailing icon). */
     protected readonly _contentBox: StackLayout;
-    /** The leading symbolic icon (lazily added — only when an icon is set). */
+    /** The leading symbolic icon. */
     protected readonly _startIcon: AdwIcon;
-    private _hasStartIcon;
-    private _startIconSvg;
+    /** The trailing symbolic icon. */
+    protected readonly _endIcon: AdwIcon;
+    /**
+     * The headless start/end icon state (ADR 0004).
+     *
+     * ICONS ONLY. `ButtonRowState` also carries the title, and the browser
+     * renderer uses that half — but here the title is the action row's inherited
+     * `Label`, painted from the action row's own state, and feeding it into a
+     * second state object would give one label two sources of truth.
+     */
+    private readonly _buttonState;
     constructor();
+    /** A centered, accent-coloured symbolic icon, collapsed until it has content. */
+    private static _makeIcon;
     /**
      * A leading Adwaita symbolic SVG string before the centered title (e.g.
-     * `listAddSymbolic`). Setting a non-empty value inserts it; empty removes it.
+     * `listAddSymbolic`). Empty collapses the icon.
      */
     get startIcon(): string;
     set startIcon(value: string);
     /**
-     * The start icon's fill colour (hex). Defaults to the Adwaita accent; callers
-     * set the destructive red when the row carries `destructive-action` so the
-     * symbolic icon matches the title colour (the icon bitmap is pre-coloured, so
+     * A trailing Adwaita symbolic SVG string after the centered title (e.g.
+     * `goNextSymbolic`) — `Adw.ButtonRow:end-icon-name`. Empty collapses it.
+     */
+    get endIcon(): string;
+    set endIcon(value: string);
+    /**
+     * The icons' fill colour (hex). Defaults to the Adwaita accent; callers set
+     * the destructive red when the row carries `destructive-action` so the
+     * symbolic icons match the title colour (the icon bitmap is pre-coloured, so
      * CSS cannot recolour it).
      */
     get startIconColor(): string;
     set startIconColor(value: string);
+    /** Push the derived icon payload + visibility onto the two `AdwIcon`s. */
+    private _applyIcons;
 }

package/lib/types/widgets/adw-carousel.d.ts

@@ -1,36 +1,74 @@
 import { GridLayout, ScrollView, StackLayout, View, type EventData } from '@nativescript/core';
+import { DEFAULT_CAROUSEL_PAGE_WIDTH, type CarouselNotifyPayload } from './carousel-state.js';
+export { DEFAULT_CAROUSEL_PAGE_WIDTH };
 /** Event name emitted when {@link AdwCarousel.position} changes. Mirrors GObject `notify::position`. */
 export declare const NOTIFY_POSITION = "notify::position";
-/** Payload of the `notify::position` event. */
-export interface NotifyPositionEventData extends EventData {
-    /** The new page index. */
-    position: number;
+/** Event name emitted when the page count changes. Mirrors GObject `notify::n-pages`. */
+export declare const NOTIFY_N_PAGES = "notify::n-pages";
+/** Event name emitted after a completed scroll. Mirrors the `AdwCarousel::page-changed` signal. */
+export declare const PAGE_CHANGED = "page-changed";
+/** Payload of the {@link NOTIFY_POSITION} and {@link NOTIFY_N_PAGES} events. */
+export interface NotifyPositionEventData extends EventData, CarouselNotifyPayload {
+}
+/** Payload of the {@link PAGE_CHANGED} event. `index` is `-1` for an empty carousel. */
+export interface PageChangedEventData extends EventData {
+    /** The page the carousel came to rest on, `-1` when it has none. */
+    index: number;
 }
-/** Default page width (DIPs) used for offset math until the consumer sets `pageWidth`. */
-export declare const DEFAULT_CAROUSEL_PAGE_WIDTH = 320;
 export declare class AdwCarousel extends GridLayout {
     /** The horizontal scroller holding the pages. */
     protected readonly _scroller: ScrollView;
-    /** The horizontal track inside the scroller (holds full-width pages). */
+    /** The horizontal track inside the scroller (holds fixed-width pages). */
     protected readonly _track: StackLayout;
     /** The dot-indicator row. */
     protected readonly _dots: StackLayout;
-    private readonly _pages;
-    private readonly _dotLabels;
-    private _position;
+    private readonly _state;
+    private readonly _sync;
+    /** Page id → its content view, so a DOM-free model can still be projected. */
+    private readonly _views;
+    /** Page id → its dot. Keyed by ID, not by index: an insert or a reorder renumbers every page after it. */
+    private readonly _dotsById;
+    private _nextPageId;
     private _pageWidth;
     constructor();
-    /** Append a page. The page is forced to the current `pageWidth`. */
+    /** Append a page — `adw_carousel_append` (adw-carousel.c:1348-1357). */
     addPage(view: View): void;
-    /** Scroll to a page by index (clamped) and update the position. */
+    /**
+     * Insert a page at `position` — `adw_carousel_insert` (adw-carousel.c:1370-1407).
+     * `-1` or a position past the end appends. Returns whether it was added.
+     */
+    insertPage(view: View, position?: number): boolean;
+    /** Remove a page — `adw_carousel_remove` (adw-carousel.c:1508-1532). */
+    removePage(view: View): boolean;
+    /** Move a page — `adw_carousel_reorder` (adw-carousel.c:1419-1499). */
+    reorderPage(view: View, position: number): boolean;
+    /**
+     * Scroll to a page by index. Out-of-range, fractional and NaN indices are
+     * refused rather than clamped, matching `adw_carousel_get_nth_page`'s
+     * precondition (adw-carousel.c:1616) — `scrollToPage(NaN)` used to set the
+     * position to NaN and leave no dot selected.
+     */
     scrollToPage(index: number): void;
-    private _setPosition;
-    private _applyDots;
+    /** One keynav step — `navigate_to_direction` (adw-carousel.c:475-508). */
+    navigate(direction: 'back' | 'forward'): boolean;
     /** The number of pages. */
     get nPages(): number;
-    /** The current page index. Setting it scrolls to that page. */
+    /** The fractional scroll position; 1 matches 1 page. */
     get position(): number;
+    /**
+     * Scroll to the page this position settles on.
+     *
+     * `AdwCarousel:position` is READ-ONLY in C (adw-carousel.c:1036-1041) — the
+     * setter is a port convenience, and it resolves the value with the same
+     * `get_page_at_position` rule used everywhere else, so 0.5 lands on page 0
+     * where the old `Math.round` picked page 1.
+     */
     set position(value: number);
+    /** The page the current position settles on, `-1` when the carousel is empty. */
+    get currentPage(): number;
+    /** Whether the carousel can be navigated (`AdwCarousel:interactive`, default TRUE). */
+    get interactive(): boolean;
+    set interactive(value: boolean);
     /**
      * The per-page width in DIPs used for scroll-offset math. Set this to the
      * carousel's on-screen width so `scrollToPage` lands cleanly. Re-applies to
@@ -38,4 +76,21 @@ export declare class AdwCarousel extends GridLayout {
      */
     get pageWidth(): number;
     set pageWidth(value: number);
+    /** The px pitch between two page origins — `self->distance` (adw-carousel.c:767). */
+    private _distance;
+    /** The state's id for a page view, or `null` when it is not one of ours. */
+    private _idOf;
+    /** Run the scroll the state asked for. */
+    private _performScroll;
+    /** The dots in page order — the order `applyCarouselDots` indexes by. */
+    private _orderedDots;
+    /**
+     * Make both native child lists match the model order.
+     *
+     * Detach-then-reattach rather than a positional patch: NS has no "move
+     * child", `insertChild` on an already-parented view double-parents it, and
+     * the page counts here are small enough that the simple version is the one
+     * that cannot be subtly wrong after a reorder.
+     */
+    private _syncTrack;
 }

package/lib/types/widgets/adw-clamp.d.ts

@@ -1,15 +1,32 @@
 import { GridLayout, View } from '@nativescript/core';
-/** Adwaita's `AdwClamp` default `maximum-size`, in DIPs. */
-export declare const DEFAULT_CLAMP_MAX_SIZE = 600;
+import { DEFAULT_CLAMP_MAX_SIZE, DEFAULT_CLAMP_TIGHTENING_THRESHOLD } from './chrome.js';
+export { DEFAULT_CLAMP_MAX_SIZE, DEFAULT_CLAMP_TIGHTENING_THRESHOLD };
 export declare class AdwClamp extends GridLayout {
-    private _maximumSize;
+    private _props;
     private _child;
+    /** The container width the child was last clamped against, in DIPs. */
+    private _measuredWidth;
     constructor();
     /** Set (or replace) the clamped, centered child. Pass `null` to clear it. */
     setChild(view: View | null): void;
     /** The currently-clamped child, or `null`. */
     get child(): View | null;
-    /** The maximum width the child is capped to, in DIPs. */
+    /** `Adw.Clamp:maximum-size` — the widest the child may ever get, in DIPs. */
     get maximumSize(): number;
     set maximumSize(value: number);
+    /**
+     * `Adw.Clamp:tightening-threshold` — the width above which the clamp starts
+     * tightening its grip, easing the child toward {@link maximumSize} instead of
+     * snapping to it. The storybook has exposed this control all along; until now
+     * only the GTK pane responded to it.
+     */
+    get tighteningThreshold(): number;
+    set tighteningThreshold(value: number);
+    /**
+     * Re-run libadwaita's allocation against the container's current width.
+     *
+     * The class assignment is guarded on a real change: this runs from
+     * `layoutChanged`, and re-styling a view can schedule another layout pass.
+     */
+    private _allocate;
 }

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

@@ -21,6 +21,15 @@ export declare class AdwComboRow extends AdwActionRow {
     /** The headless options list + selectedIndex↔selectedValue state machine (ADR 0004). */
     private readonly _state;
     constructor();
+    /**
+     * `model_changed` (adw-combo-row.c:187-195) — one option or none is not a
+     * choice, so the chevron goes and the row stops being activatable.
+     *
+     * Both halves matter. Hiding the chevron alone would leave a row that still
+     * opens a one-entry `action()` sheet on tap; the tap guard is in
+     * {@link _openChooser}, which reads the same predicate.
+     */
+    private _syncChooser;
     /** Open the native action chooser and apply the picked option. */
     private _openChooser;
     /** The selectable options. Updates the inline value label. */

package/lib/types/widgets/adw-data-grid.d.ts

@@ -0,0 +1,73 @@
+import { GridLayout, type EventData } from '@nativescript/core';
+import type { AdwDataGridColumn, AdwDataGridRow } from '@gjsify/adwaita-core';
+/** Event name emitted when an interactive row is tapped. Mirrors the browser's `row-activated`. */
+export declare const ROW_ACTIVATED = "row-activated";
+/** Payload of the `row-activated` event. */
+export interface RowActivatedEventData extends EventData {
+    /** The row's index in the `rows` array. */
+    index: number;
+    /** The row object that was activated. */
+    row: AdwDataGridRow;
+}
+export declare class AdwDataGrid extends GridLayout {
+    private _columns;
+    private _rows;
+    private _interactive;
+    /** The header row's nodes, or `null` while there are no columns. */
+    private _header;
+    /** One entry per data row, index-aligned with {@link _rows}. */
+    private _rowNodes;
+    /** The tracks the declared columns were built from — the re-declare guard. */
+    private _trackKey;
+    /** The columns×rows the views were built for — the rebuild guard. */
+    private _shapeKey;
+    constructor();
+    /** The column descriptors. Setting them re-derives the tracks. */
+    get columns(): AdwDataGridColumn[];
+    set columns(value: ReadonlyArray<AdwDataGridColumn>);
+    /** The row objects (copied, like the browser element does). */
+    get rows(): AdwDataGridRow[];
+    set rows(value: ReadonlyArray<AdwDataGridRow>);
+    /**
+     * Whether every `normal` row is tappable (a row may still opt out with
+     * `interactive: false`). Section / subtotal / total rows never activate.
+     *
+     * A REPAINT, not a rebuild: the flag changes which rows carry the
+     * `interactive` class and answer a tap, and nothing about the layout.
+     */
+    get interactive(): boolean;
+    set interactive(value: boolean);
+    private _render;
+    /**
+     * (Re)declare the column tracks from the descriptors.
+     *
+     * Guarded on the derived tracks rather than run on every render: re-declaring
+     * invalidates the layout, and a data change must not move the columns. The
+     * precedent is `AdwViewSwitcherBar`, which rebuilds only when the page count
+     * moves; the key generalises that, because a column list can change without
+     * changing length (`data-grid-model.ts` says why).
+     */
+    private _syncColumns;
+    /**
+     * Rebuild the cell views when the grid's SHAPE moves, and only then.
+     *
+     * A repaint keeps the views: replacing the row under the user's finger on
+     * every data update is what the view-switcher bar's count guard exists to
+     * avoid, and here it would also drop the press state mid-touch.
+     */
+    private _syncNodes;
+    /** Build one row: the spanning background first, then a cell per column. */
+    private _buildRow;
+    /** Repaint text + classes from the current data. Never structural. */
+    private _paint;
+    /** Un-collapse a cell and set its span — the inverse of the section branch. */
+    private _showCell;
+    /**
+     * Emit `row-activated` for a tapped row — if it activates at all.
+     *
+     * The gate is re-evaluated here rather than at wiring time, and it reads the
+     * CURRENT row object: the listener outlives a `rows` assignment of the same
+     * length, so a captured row would be the previous data set's.
+     */
+    private _activate;
+}

package/lib/types/widgets/adw-drop-down.d.ts

@@ -0,0 +1,45 @@
+import { Label, StackLayout, type EventData } from '@nativescript/core';
+import type { AdwComboOption } from '@gjsify/adwaita-core';
+import { AdwIcon } from './adw-icon.js';
+/** Event name emitted when {@link AdwDropDown.selected} changes through a pick. Mirrors GObject `notify::selected`. */
+export declare const NOTIFY_SELECTED = "notify::selected";
+/** Payload of the `notify::selected` event. */
+export interface NotifyDropDownSelectedEventData extends EventData {
+    /** The newly-selected index. */
+    selected: number;
+    /** The newly-selected option's `value`. */
+    value: string;
+    /** The newly-selected option's `label` — what the button now shows. */
+    label: string;
+}
+export declare class AdwDropDown extends StackLayout {
+    /** The button label — the selected option. */
+    protected readonly _label: Label;
+    /** The down-chevron — a real Adwaita `pan-down-symbolic` icon. */
+    protected readonly _chevron: AdwIcon;
+    /** The headless options list + selectedIndex↔selectedValue state machine (ADR 0004). */
+    private readonly _state;
+    /** Title shown atop the substituted `action()` sheet. */
+    private _chooserTitle;
+    constructor();
+    /** Open the native chooser and apply the picked option. */
+    private _openChooser;
+    /** The selectable options. Updates the button label. */
+    get options(): AdwComboOption[];
+    set options(value: AdwComboOption[]);
+    /** The selected option index (`Gtk.DropDown:selected`). */
+    get selected(): number;
+    set selected(value: number);
+    /** The selected option's `value`, or `''` when out of range. */
+    get selectedValue(): string;
+    set selectedValue(value: string);
+    /** The selected option descriptor, or `null` when out of range (`Gtk.DropDown:selected-item`). */
+    get selectedItem(): AdwComboOption | null;
+    /**
+     * Optional title shown atop the chooser sheet. A SUBSTITUTION affordance:
+     * GTK's popover has no title, but a bare native sheet gives no clue what is
+     * being chosen — the same reason `AdwMenuButton` carries `menuTitle`.
+     */
+    get chooserTitle(): string;
+    set chooserTitle(value: string);
+}

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

@@ -1,17 +1,113 @@
-import { TextField, type EventData } from '@nativescript/core';
+import { Label, StackLayout, TextField, type EventData, type View } from '@nativescript/core';
+import { EntryRowState, type EntryRowRenderState } from '@gjsify/adwaita-core';
 import { AdwActionRow } from './adw-action-row.js';
+import { AdwIcon } from './adw-icon.js';
+import { AdwImageButton } from './adw-image-button.js';
+export { EntryRowState } from '@gjsify/adwaita-core';
+export type { EntryRowRenderState, EntryRowActivation } from '@gjsify/adwaita-core';
 /** Event name emitted when {@link AdwEntryRow.text} changes. Mirrors GObject `notify::text`. */
 export declare const NOTIFY_TEXT = "notify::text";
+/** Event name emitted when the character count changes — `on_length_changed` (adw-entry-row.c:268-273). */
+export declare const NOTIFY_TEXT_LENGTH = "notify::text-length";
+/** Event name emitted by the apply button, or by the return key while it shows — `AdwEntryRow::apply` (C:240). */
+export declare const SIGNAL_APPLY = "apply";
+/** Event name emitted by the return key when there is nothing to apply — `AdwEntryRow::entry-activated` (C:256). */
+export declare const SIGNAL_ENTRY_ACTIVATED = "entry-activated";
 /** Payload of the `notify::text` event. */
 export interface NotifyTextEventData extends EventData {
     /** The new text value. */
     text: string;
 }
+/** Payload of the `notify::text-length` event. */
+export interface NotifyTextLengthEventData extends EventData {
+    /** The new number of CHARACTERS (not UTF-16 units). */
+    textLength: number;
+}
+/** Payload of the `entry-activated` event. */
+export interface EntryActivatedEventData extends EventData {
+    /**
+     * Whether the host must activate its default action FIRST — the C calls
+     * `gtk_widget_activate_default` on line 254 and emits the signal on line 256,
+     * and NS has no default-widget concept, so the ordering becomes the host's.
+     */
+    activateDefault: boolean;
+}
 export declare class AdwEntryRow extends AdwActionRow {
+    /** `AdwEntryRow` derives from `AdwPreferencesRow` in C (adw-entry-row.c:90), so
+     *  the preferences search must NOT read the text typed into it. */
+    readonly isActionRow: boolean;
+    /** The headless `update_empty` derivation + apply latch (ADR 0004). */
+    protected readonly _state: EntryRowState;
     /** The TextField stacked below the title in column 0. */
     protected readonly _field: TextField;
+    /** The large placeholder title (`empty_title` in adw-entry-row.ui). */
+    protected readonly _emptyTitle: Label;
+    /** The trailing affordance box — `Adw.EntryRow`'s suffixes BOX, not a slot. */
+    protected readonly _suffixes: StackLayout;
+    /** The pencil (`edit_icon`). Non-interactive, like its `can-target=False` original. */
+    protected readonly _editIcon: AdwIcon;
+    /** The caps-lock warning slot (`indicator`). */
+    protected readonly _indicator: AdwIcon;
+    /** The apply button. */
+    protected readonly _applyButton: AdwImageButton;
+    /** The suffix installed through the inherited single-slot {@link setSuffix}. */
+    private _slotSuffix;
+    private _lastText;
+    private _lastLength;
     constructor();
-    /** The editable text. Two-way bound to the suffix `TextField.text`. */
+    /** The editable text. */
     get text(): string;
     set text(value: string);
+    /** `Adw.EntryRow:text-length` — the number of CHARACTERS, not UTF-16 units. */
+    get textLength(): number;
+    /** `Adw.EntryRow:max-length` — maximum number of characters, `0` = unlimited. */
+    get maxLength(): number;
+    set maxLength(value: number);
+    /** Whether the entry accepts edits (`GtkEditable:editable`). */
+    get editable(): boolean;
+    set editable(value: boolean);
+    /** `Adw.EntryRow:show-apply-button` — typing reveals an apply button. */
+    get showApplyButton(): boolean;
+    set showApplyButton(value: boolean);
+    /** `Adw.EntryRow:activates-default` — reported on `entry-activated`, acted on by the host. */
+    get activatesDefault(): boolean;
+    set activatesDefault(value: boolean);
+    /** Whether the field currently has focus. */
+    get editing(): boolean;
+    /**
+     * Append a suffix — `adw_entry_row_add_suffix` (adw-entry-row.c:885-899),
+     * which appends into a BOX so suffixes COEXIST.
+     */
+    addSuffix(view: View): void;
+    /**
+     * The inherited single-slot API, kept working for existing consumers: it
+     * replaces only the suffix a previous `setSuffix` installed.
+     *
+     * `AdwActionRow.setSuffix` removes whatever sat in the slot, which detached
+     * the password row's own peek toggle the moment a consumer set a suffix —
+     * while `_peekButton` kept pointing at the detached view, so the row could
+     * never be revealed again. Upstream has no such conflict because there is no
+     * single slot: `add_suffix` appends.
+     */
+    setSuffix(view: View | null): void;
+    /** The suffix installed through {@link setSuffix}, or `null`. */
+    get suffix(): View | null;
+    /**
+     * Drive the trailing indicator — `adw_entry_row_set_show_indicator`
+     * (adw-entry-row-private.h, C:1281-1296). Private-to-the-library upstream,
+     * public here because `AdwPasswordEntryRow` composes rather than reaching
+     * into a private header.
+     */
+    setShowIndicator(show: boolean): void;
+    /** `adw_entry_row_set_indicator_icon_name` (C:1263-1273), as an Adwaita symbolic SVG. */
+    setIndicatorIcon(svg: string): void;
+    /** Apply the pending edit — the apply button tap (C:229-241). */
+    apply(): void;
+    /** `text_activated_cb` (C:243-266) — exactly one of the two signals. */
+    private _activate;
+    /** Paint one render snapshot through the shared (spec-driven) painter. */
+    protected _render(state: EntryRowRenderState): void;
+    /** Base class list this row paints its state classes onto. */
+    protected get _baseClassName(): string;
+    private _onStateChanged;
 }

package/lib/types/widgets/adw-entry.d.ts

@@ -0,0 +1,43 @@
+import { GridLayout, TextField, type EventData } from '@nativescript/core';
+/** Event name emitted when {@link AdwEntry.text} changes. Mirrors GObject `notify::text`. */
+export declare const NOTIFY_TEXT = "notify::text";
+/** Event name emitted when the return key is pressed — `Gtk.Entry::activate`. */
+export declare const ACTIVATE = "activate";
+/** Payload of the `notify::text` event. */
+export interface NotifyEntryTextEventData extends EventData {
+    /** The new text value (already truncated to `maxLength`). */
+    text: string;
+    /** The new number of CHARACTERS (not UTF-16 units). */
+    textLength: number;
+}
+export declare class AdwEntry extends GridLayout {
+    /** The real input. Chrome-less: the box around it paints the Adwaita surface. */
+    protected readonly _field: TextField;
+    private _text;
+    private _maxLength;
+    constructor();
+    /**
+     * Truncate, write the field, and notify on a real change.
+     *
+     * Writing the field re-enters through `textChange`; the nested call finds the
+     * text already applied and settles it, and the outer one then sees its own
+     * value in `_text` and stops — so a truncated keystroke notifies exactly once.
+     */
+    private _applyText;
+    /** The editable text. */
+    get text(): string;
+    set text(value: string);
+    /** The number of CHARACTERS in {@link text}, not UTF-16 units. */
+    get textLength(): number;
+    /** Maximum number of characters, `0` = unlimited. */
+    get maxLength(): number;
+    set maxLength(value: number);
+    /** Placeholder shown while the entry is empty (`Gtk.Entry:placeholder-text`). */
+    get placeholder(): string;
+    set placeholder(value: string);
+    /** Whether the entry accepts edits (`GtkEditable:editable`). */
+    get editable(): boolean;
+    set editable(value: boolean);
+    /** The inner `TextField` — for focus, selection and host-specific keyboard options. */
+    get field(): TextField;
+}

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

@@ -11,6 +11,9 @@ export interface NotifyExpandedEventData extends EventData {
     expanded: boolean;
 }
 export declare class AdwExpanderRow extends AdwActionRow {
+    /** `AdwExpanderRow` derives from `AdwPreferencesRow` in C
+     *  (adw-expander-row.c:72), so the search does not consult a subtitle here. */
+    readonly isActionRow: boolean;
     /** The disclosure chevron (suffix) — a plain symbolic icon, like Adw.ExpanderRow. */
     protected readonly _toggle: AdwIcon;
     /** The container of revealed child rows (second grid row). */

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

@@ -20,9 +20,18 @@ export declare class AdwHeaderBar extends GridLayout {
      */
     get flat(): boolean;
     set flat(value: boolean);
-    /** Append a widget to the start (left) slot. */
+    /** Pack a widget at the start (left) of the bar — `gtk_box_append`. */
     packStart(view: View): void;
-    /** Append a widget to the end (right) slot. */
+    /**
+     * Pack a widget at the end (right) of the bar.
+     *
+     * `adw_header_bar_pack_end` PREPENDS (`gtk_box_prepend`,
+     * adw-header-bar.c:1106): "packed with reference to the end" means the FIRST
+     * widget packed is the one nearest the end of the bar, and each later one
+     * goes in front of it. The port appended instead, so every end slot came out
+     * mirrored — `packEnd(menu); packEnd(search)` drew `menu | search` where
+     * libadwaita draws `search | menu`, with the menu button in the corner.
+     */
     packEnd(view: View): void;
     /** Replace the centered title widget with a custom one (e.g. a URL entry). */
     setTitleWidget(view: View): void;

package/lib/types/widgets/adw-inline-view-switcher.d.ts

@@ -1,6 +1,32 @@
+import type { AdwInlineViewSwitcherDisplayMode } from '@gjsify/adwaita-core';
 import { AdwViewSwitcherBase } from './view-switcher-base.js';
+import type { ViewSwitcherKind } from './view-switcher-model.js';
 export declare class AdwInlineViewSwitcher extends AdwViewSwitcherBase {
+    private _displayMode;
     constructor();
     protected get barClass(): string;
     protected get buttonClass(): string;
+    protected get buttonDisplayMode(): AdwInlineViewSwitcherDisplayMode;
+    /**
+     * `populate_group` gates on the page's `visible` ALONE
+     * (adw-inline-view-switcher.c:370-378) — the title-or-icon rule the base
+     * follows belongs to `AdwViewSwitcher.update_button`
+     * (adw-view-switcher.c:178) and has no counterpart here, so a page with
+     * neither title nor icon still gets an (empty) toggle.
+     *
+     * Inheriting the stricter rule made this switcher drop toggles libadwaita
+     * draws. The rule itself lives in {@link switcherButtonVisible}, where a
+     * spec can reach it.
+     */
+    protected get switcherKind(): ViewSwitcherKind;
+    /** What the toggles display: `'labels'` (default), `'icons'` or `'both'`. */
+    get displayMode(): AdwInlineViewSwitcherDisplayMode;
+    /**
+     * Set the display mode. An unrecognised value is REJECTED and leaves the
+     * current mode alone — `g_return_if_fail (mode <= ADW_INLINE_VIEW_SWITCHER_BOTH)`
+     * returns before `self->display_mode` is touched
+     * (adw-inline-view-switcher.c:819). The browser port used to replace the
+     * current mode with `'both'` there.
+     */
+    set displayMode(value: AdwInlineViewSwitcherDisplayMode);
 }