@gjsify/adwaita-nativescript 0.53.0 → 0.55.0

package/lib/types/widgets/gtk-button.d.ts

@@ -19,6 +19,16 @@ declare const GtkButton_base: (abstract new (...args: any[]) => {
     set marginStart(value: number | string);
     get marginEnd(): number;
     set marginEnd(value: number | string);
+    get visible(): boolean;
+    set visible(value: boolean | string);
+    get sensitive(): boolean;
+    set sensitive(value: boolean | string);
+    get name(): string;
+    set name(value: string | null);
+    get widthRequest(): number;
+    set widthRequest(value: number | string);
+    get heightRequest(): number;
+    set heightRequest(value: number | string);
     _emit(eventName: string): void;
     addEventListener(eventName: string, callback: (data: import("@nativescript/core").EventData) => void, thisArg?: unknown, once?: boolean): void;
     removeEventListener(eventName: string, callback?: (data: import("@nativescript/core").EventData) => void, thisArg?: unknown): void;
@@ -28,6 +38,8 @@ declare const GtkButton_base: (abstract new (...args: any[]) => {
     get(name: string): unknown;
 }) & typeof GridLayout;
 export declare class GtkButton extends GtkButton_base {
+    /** The GTK signals this widget emits through `connect` — read by the shared-tree builder (ADR 0093). */
+    static readonly emittedSignals: readonly string[];
     /**
      * The names this widget's `_addChildFromBuilder` honours — see `./builder-slots.ts`.
      * `Gtk.Button:child` is the property a `.blp` writes as `child: Adw.ButtonContent { … }`,
@@ -127,6 +139,14 @@ export declare class GtkButton extends GtkButton_base {
     /** `gtk_widget_set_css_classes` — REPLACES the list, as in C. */
     set_css_classes(names: readonly string[]): void;
     private _setClasses;
+    /**
+     * Rewrite `className` from the base class, the caller's list and whatever state classes a
+     * subclass adds (`Gtk.ToggleButton`'s `checked`) — which are NOT in `styleClasses`, as
+     * GTK's `:checked` is a state and never a member of `css-classes`.
+     */
+    protected _restyle(): void;
+    /** The state classes a subclass wears beside the caller's list. A plain button has none. */
+    protected _stateClasses(): readonly string[];
     /**
      * Put `value` in the single cell under `wrote`'s slot, detaching whatever the previous
      * slot had parented.

package/lib/types/widgets/gtk-check-button.d.ts

@@ -0,0 +1,51 @@
+import { type View } from '@nativescript/core';
+import { type ConstructProps } from './construct-props.js';
+import { AdwStyledLayoutBase } from './styled-layout-base.js';
+/** Event name emitted when `active` changes. Mirrors `Gtk.CheckButton::toggled`. */
+export declare const GTK_CHECK_BUTTON_TOGGLED = "toggled";
+/** Event name emitted when the button is activated. Mirrors `Gtk.CheckButton::activate`. */
+export declare const GTK_CHECK_BUTTON_ACTIVATE = "activate";
+/** Event name emitted when `active` changes. Mirrors GObject `notify::active`. */
+export declare const NOTIFY_CHECK_ACTIVE = "notify::active";
+/** The state classes the button wears, which the theme turns into the filled indicator. */
+export declare const GTK_CHECK_BUTTON_CHECKED_CLASS = "checked";
+export declare const GTK_CHECK_BUTTON_INCONSISTENT_CLASS = "inconsistent";
+export declare class GtkCheckButton extends AdwStyledLayoutBase {
+    static readonly builderSlots: readonly string[];
+    private readonly _indicator;
+    private readonly _mark;
+    private readonly _text;
+    private _active;
+    private _inconsistent;
+    private _label;
+    private _useUnderline;
+    private _child;
+    constructor(props?: ConstructProps<GtkCheckButton>);
+    /** `Gtk.CheckButton:active` — whether the box is ticked. Defaults to `false`. */
+    get active(): boolean;
+    set active(raw: boolean | string);
+    /** `Gtk.CheckButton:inconsistent` — the "partly on" dash. Defaults to `false`. */
+    get inconsistent(): boolean;
+    set inconsistent(raw: boolean | string);
+    /** `Gtk.CheckButton:label` — the text beside the box, `null` for none. */
+    get label(): string | null;
+    set label(value: string | null);
+    /** `Gtk.CheckButton:use-underline` — an `_` in the label marks a mnemonic, which is not drawn. */
+    get useUnderline(): boolean;
+    set useUnderline(raw: boolean | string);
+    private _paintLabel;
+    /** `Gtk.CheckButton:child` — a widget in place of the text label. */
+    get child(): View | null;
+    set child(view: View | null);
+    set_child(view: View | null): void;
+    get_child(): View | null;
+    /** `gtk_check_button_get_active`. */
+    get_active(): boolean;
+    /** `gtk_check_button_set_active`. */
+    set_active(active: boolean): void;
+    _addChildFromBuilder(_name: string, view: View): void;
+    /** The text shows only while there is a label and no child widget replacing it. */
+    private _syncContent;
+    protected get _ownClass(): string;
+    protected _restyle(): void;
+}

package/lib/types/widgets/gtk-drawing-area.d.ts

@@ -0,0 +1,19 @@
+import { type ConstructProps } from './construct-props.js';
+import { AdwStyledLayoutBase } from './styled-layout-base.js';
+/** What `set_draw_func` says; exported so a caller (and a spec) can recognise it. */
+export declare const DRAWING_AREA_REFUSAL: string;
+export declare class GtkDrawingArea extends AdwStyledLayoutBase {
+    private _contentWidth;
+    private _contentHeight;
+    constructor(props?: ConstructProps<GtkDrawingArea>);
+    /** `Gtk.DrawingArea:content-width` — the requested width, `0` for none. */
+    get contentWidth(): number;
+    set contentWidth(raw: number | string);
+    /** `Gtk.DrawingArea:content-height` — the requested height, `0` for none. */
+    get contentHeight(): number;
+    set contentHeight(raw: number | string);
+    /** `gtk_drawing_area_set_draw_func` — refused, see the header. */
+    set_draw_func(_drawFunc: unknown): void;
+    /** `gtk_widget_queue_draw` — nothing is ever drawn, so there is nothing to redraw. */
+    queue_draw(): void;
+}

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

@@ -28,6 +28,16 @@ declare const GtkDropDown_base: (abstract new (...args: any[]) => {
     set marginStart(value: number | string);
     get marginEnd(): number;
     set marginEnd(value: number | string);
+    get visible(): boolean;
+    set visible(value: boolean | string);
+    get sensitive(): boolean;
+    set sensitive(value: boolean | string);
+    get name(): string;
+    set name(value: string | null);
+    get widthRequest(): number;
+    set widthRequest(value: number | string);
+    get heightRequest(): number;
+    set heightRequest(value: number | string);
     _emit(eventName: string): void;
     addEventListener(eventName: string, callback: (data: EventData) => void, thisArg?: unknown, once?: boolean): void;
     removeEventListener(eventName: string, callback?: (data: EventData) => void, thisArg?: unknown): void;

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

@@ -26,6 +26,16 @@ declare const GtkEntry_base: (abstract new (...args: any[]) => {
     set marginStart(value: number | string);
     get marginEnd(): number;
     set marginEnd(value: number | string);
+    get visible(): boolean;
+    set visible(value: boolean | string);
+    get sensitive(): boolean;
+    set sensitive(value: boolean | string);
+    get name(): string;
+    set name(value: string | null);
+    get widthRequest(): number;
+    set widthRequest(value: number | string);
+    get heightRequest(): number;
+    set heightRequest(value: number | string);
     _emit(eventName: string): void;
     addEventListener(eventName: string, callback: (data: EventData) => void, thisArg?: unknown, once?: boolean): void;
     removeEventListener(eventName: string, callback?: (data: EventData) => void, thisArg?: unknown): void;

package/lib/types/widgets/gtk-frame.d.ts

@@ -0,0 +1,25 @@
+import { type View } from '@nativescript/core';
+import { type ConstructProps } from './construct-props.js';
+import { AdwStyledLayoutBase } from './styled-layout-base.js';
+export declare class GtkFrame extends AdwStyledLayoutBase {
+    static readonly builderSlots: readonly string[];
+    private readonly _labelCell;
+    private _labelWidget;
+    private _label;
+    private _child;
+    constructor(props?: ConstructProps<GtkFrame>);
+    /** `Gtk.Frame:label` — the text above the border, `null` for none. */
+    get label(): string | null;
+    set label(value: string | null);
+    /** `Gtk.Frame:label-widget` — a widget in place of the text label. */
+    get labelWidget(): View | null;
+    set labelWidget(view: View | null);
+    set_label_widget(view: View | null): void;
+    /** `Gtk.Frame:child`. */
+    get child(): View | null;
+    set child(view: View | null);
+    set_child(view: View | null): void;
+    get_child(): View | null;
+    _addChildFromBuilder(name: string, view: View): void;
+    protected get _ownClass(): string;
+}

package/lib/types/widgets/gtk-grid.d.ts

@@ -0,0 +1,57 @@
+import { type View } from '@nativescript/core';
+import { type ConstructProps } from './construct-props.js';
+import { AdwStyledLayoutBase } from './styled-layout-base.js';
+export declare class GtkGrid extends AdwStyledLayoutBase {
+    private _rowSpacing;
+    private _columnSpacing;
+    private _rowHomogeneous;
+    private _columnHomogeneous;
+    private _columnKey;
+    private _rowKey;
+    private readonly _gaps;
+    private readonly _followers;
+    constructor(props?: ConstructProps<GtkGrid>);
+    /**
+     * Put `child` in the grid at `(column, row)`, spanning `width` columns and `height` rows
+     * — `gtk_grid_attach`.
+     */
+    attach(child: View, column: number, row: number, width?: number, height?: number): void;
+    /** `gtk_grid_remove`. */
+    remove(child: View): void;
+    /** `gtk_grid_get_child_at` — the child covering `(column, row)`, or `null`. */
+    get_child_at(column: number, row: number): View | null;
+    /**
+     * Every path a child can enter by — `attach()`, a direct `addChild()`, and XML
+     * inflation through `_addChildFromBuilder` — ends here, so the tracks and the gaps
+     * are derived here.
+     */
+    addChild(view: View): void;
+    insertChild(child: View, atIndex: number): void;
+    removeChild(view: View): void;
+    /** `Gtk.Grid:row-spacing` — the gap between rows, in DIPs. */
+    get rowSpacing(): number;
+    set rowSpacing(value: number | string);
+    /** `Gtk.Grid:column-spacing` — the gap between columns, in DIPs. */
+    get columnSpacing(): number;
+    set columnSpacing(value: number | string);
+    /** `Gtk.Grid:row-homogeneous` — every row the same height (`*` tracks). */
+    get rowHomogeneous(): boolean;
+    set rowHomogeneous(value: boolean | string);
+    /** `Gtk.Grid:column-homogeneous` — every column the same width (`*` tracks). */
+    get columnHomogeneous(): boolean;
+    set columnHomogeneous(value: boolean | string);
+    private _childViews;
+    private _placementOf;
+    private _placed;
+    /** Re-derive the tracks when a child moves after it was added. */
+    private _follow;
+    private _unfollow;
+    /** Make the margin carry `next` of this grid's gap, in place of whatever share it had. */
+    private _withGap;
+    private _relayout;
+    /**
+     * Rebuild a track list only when it differs: removing and re-adding every `ItemSpec`
+     * makes the platform re-measure, which is wasted on a grid that did not change shape.
+     */
+    private _syncTracks;
+}

package/lib/types/widgets/gtk-image.d.ts

@@ -26,6 +26,16 @@ declare const GtkImage_base: (abstract new (...args: any[]) => {
     set marginStart(value: number | string);
     get marginEnd(): number;
     set marginEnd(value: number | string);
+    get visible(): boolean;
+    set visible(value: boolean | string);
+    get sensitive(): boolean;
+    set sensitive(value: boolean | string);
+    get name(): string;
+    set name(value: string | null);
+    get widthRequest(): number;
+    set widthRequest(value: number | string);
+    get heightRequest(): number;
+    set heightRequest(value: number | string);
     _emit(eventName: string): void;
     addEventListener(eventName: string, callback: (data: import("@nativescript/core").EventData) => void, thisArg?: unknown, once?: boolean): void;
     removeEventListener(eventName: string, callback?: (data: import("@nativescript/core").EventData) => void, thisArg?: unknown): void;

package/lib/types/widgets/gtk-label.d.ts

@@ -16,6 +16,16 @@ declare const GtkLabel_base: (abstract new (...args: any[]) => {
     set marginStart(value: number | string);
     get marginEnd(): number;
     set marginEnd(value: number | string);
+    get visible(): boolean;
+    set visible(value: boolean | string);
+    get sensitive(): boolean;
+    set sensitive(value: boolean | string);
+    get name(): string;
+    set name(value: string | null);
+    get widthRequest(): number;
+    set widthRequest(value: number | string);
+    get heightRequest(): number;
+    set heightRequest(value: number | string);
     _emit(eventName: string): void;
     addEventListener(eventName: string, callback: (data: import("@nativescript/core").EventData) => void, thisArg?: unknown, once?: boolean): void;
     removeEventListener(eventName: string, callback?: (data: import("@nativescript/core").EventData) => void, thisArg?: unknown): void;

package/lib/types/widgets/gtk-list-box.d.ts

@@ -0,0 +1,73 @@
+import { type EventData, type View } from '@nativescript/core';
+import { type ConstructProps } from './construct-props.js';
+import { type GtkSelectionModeNick } from './list-box-state.js';
+import { AdwStyledLayoutBase } from './styled-layout-base.js';
+/** `GtkListBox::row-activated`, payload `{ row }`. */
+export declare const LIST_BOX_ROW_ACTIVATED = "row-activated";
+/** `GtkListBox::row-selected`, payload `{ row }` — the first selected row, or `null`. */
+export declare const LIST_BOX_ROW_SELECTED = "row-selected";
+/** The class a selected row wears. */
+export declare const LIST_ROW_SELECTED_CLASS = "adw-list-row-selected";
+/** What `row-activated` / `row-selected` carry beside the usual event fields. */
+export interface ListBoxRowEventData extends EventData {
+    row: View | null;
+}
+export declare class GtkListBox extends AdwStyledLayoutBase {
+    private _selectionMode;
+    private _activateOnSingleClick;
+    private _showSeparators;
+    private _acceptUnpairedRelease;
+    private _selected;
+    private readonly _listeners;
+    constructor(props?: ConstructProps<GtkListBox>);
+    /** Add a row at the end — `gtk_list_box_append`. */
+    append(row: View): void;
+    /** Add a row at the start — `gtk_list_box_prepend`. */
+    prepend(row: View): void;
+    /** Add a row at `position`; a negative or too-large one appends — `gtk_list_box_insert`. */
+    insert(row: View, position: number): void;
+    /** `gtk_list_box_remove`. */
+    remove(row: View): void;
+    /** `gtk_list_box_remove_all`. */
+    remove_all(): void;
+    /** `gtk_list_box_get_row_at_index`, or `null` past either end. */
+    get_row_at_index(index: number): View | null;
+    /** Every path a row can enter by ends here, so the rows are numbered here. */
+    addChild(view: View): void;
+    insertChild(child: View, atIndex: number): void;
+    removeChild(view: View): void;
+    /** XML inflation — every child is a row, whatever slot it names. */
+    _addChildFromBuilder(_name: string, view: View): void;
+    /** `gtk_list_box_get_selected_row` — the first selected row, or `null`. */
+    get_selected_row(): View | null;
+    /** `gtk_list_box_get_selected_rows`, in list order. */
+    get_selected_rows(): View[];
+    /** `gtk_list_box_select_row`; `null` unselects everything, as in C. */
+    select_row(row: View | null): void;
+    /** `gtk_list_box_unselect_row`. */
+    unselect_row(row: View): void;
+    /** `gtk_list_box_select_all` — only in `multiple`, as C warns otherwise. */
+    select_all(): void;
+    /** `gtk_list_box_unselect_all`. */
+    unselect_all(): void;
+    /** `Gtk.ListBox:selection-mode` — a `Gtk.SelectionMode` nick, default `single`. */
+    get selectionMode(): GtkSelectionModeNick;
+    set selectionMode(value: GtkSelectionModeNick);
+    /** `Gtk.ListBox:activate-on-single-click` — held; see the file header. */
+    get activateOnSingleClick(): boolean;
+    set activateOnSingleClick(value: boolean | string);
+    /** `Gtk.ListBox:show-separators` — held; the boxed list's rows draw their own. */
+    get showSeparators(): boolean;
+    set showSeparators(value: boolean | string);
+    /** `Gtk.ListBox:accept-unpaired-release` — held; a touch platform has no unpaired release. */
+    get acceptUnpairedRelease(): boolean;
+    set acceptUnpairedRelease(value: boolean | string);
+    private _rowViews;
+    /** Number the rows, one `auto` track each, and flag the first. */
+    private _renumber;
+    private _adopt;
+    private _release;
+    private _tapped;
+    private _activated;
+    private _setSelected;
+}

package/lib/types/widgets/gtk-overlay.d.ts

@@ -0,0 +1,17 @@
+import { type View } from '@nativescript/core';
+import { type ConstructProps } from './construct-props.js';
+import { AdwSingleChildBase } from './single-child-base.js';
+export declare class GtkOverlay extends AdwSingleChildBase {
+    /** `child` and the `[overlay]` internal-child type; a bare child is the main child. */
+    static readonly builderSlots: readonly string[];
+    private readonly _overlays;
+    constructor(props?: ConstructProps<GtkOverlay>);
+    /** Stack `view` above everything already in the overlay — `gtk_overlay_add_overlay`. */
+    add_overlay(view: View): void;
+    /** `gtk_overlay_remove_overlay`. A view that is not an overlay of this one is left alone. */
+    remove_overlay(view: View): void;
+    /** The overlays, bottom to top. */
+    get overlays(): readonly View[];
+    /** XML inflation — `overlay` stacks the view, anything else is the main child. */
+    _addChildFromBuilder(name: string, view: View): void;
+}

package/lib/types/widgets/gtk-revealer.d.ts

@@ -0,0 +1,30 @@
+import type { View } from '@nativescript/core';
+import { type ConstructProps } from './construct-props.js';
+import { AdwSingleChildBase } from './single-child-base.js';
+import { type GtkRevealerTransitionNick } from './transition-type.js';
+/** Event name emitted when `reveal-child` changes. Mirrors GObject `notify::reveal-child`. */
+export declare const NOTIFY_REVEAL_CHILD = "notify::reveal-child";
+export declare class GtkRevealer extends AdwSingleChildBase {
+    /** `Gtk.Revealer:child` is the one destination, so it is also the fallback. */
+    static readonly builderSlots: readonly string[];
+    private _revealChild;
+    private _transitionType;
+    private _transitionDuration;
+    constructor(props?: ConstructProps<GtkRevealer>);
+    /** `Gtk.Revealer:reveal-child` — whether the child is shown. Defaults to `false`, as in C. */
+    get revealChild(): boolean;
+    set revealChild(raw: boolean | string);
+    /**
+     * `Gtk.Revealer:child-revealed` — whether the child is FULLY shown. With no animation
+     * there is no in-between, so it answers {@link revealChild} at once.
+     */
+    get childRevealed(): boolean;
+    /** `Gtk.Revealer:transition-type` — held and validated, never rendered (see the header). */
+    get transitionType(): GtkRevealerTransitionNick;
+    set transitionType(value: GtkRevealerTransitionNick);
+    /** `Gtk.Revealer:transition-duration`, in ms — held, never rendered. */
+    get transitionDuration(): number;
+    set transitionDuration(raw: number | string);
+    protected _adopt(view: View): void;
+    private _applyReveal;
+}

package/lib/types/widgets/gtk-scrolled-window.d.ts

@@ -0,0 +1,25 @@
+import { type View } from '@nativescript/core';
+import { type ConstructProps } from './construct-props.js';
+import { type GtkPolicyNick } from './scrolled-window-policy.js';
+import { AdwSingleChildBase } from './single-child-base.js';
+export declare class GtkScrolledWindow extends AdwSingleChildBase {
+    /** `Gtk.ScrolledWindow:child` is the one destination, so it is also the fallback. */
+    static readonly builderSlots: readonly string[];
+    private readonly _scroll;
+    private _hscrollbarPolicy;
+    private _vscrollbarPolicy;
+    private _hasFrame;
+    constructor(props?: ConstructProps<GtkScrolledWindow>);
+    /** `Gtk.ScrolledWindow:hscrollbar-policy` — a `Gtk.PolicyType`; defaults to `automatic`. */
+    get hscrollbarPolicy(): GtkPolicyNick;
+    set hscrollbarPolicy(value: GtkPolicyNick);
+    /** `Gtk.ScrolledWindow:vscrollbar-policy` — a `Gtk.PolicyType`; defaults to `automatic`. */
+    get vscrollbarPolicy(): GtkPolicyNick;
+    set vscrollbarPolicy(value: GtkPolicyNick);
+    /** `Gtk.ScrolledWindow:has-frame` — held and read back; no frame is drawn (see the header). */
+    get hasFrame(): boolean;
+    set hasFrame(raw: boolean | string);
+    protected _adopt(view: View): void;
+    protected _release(_view: View): void;
+    private _applyOrientation;
+}

package/lib/types/widgets/gtk-separator.d.ts

@@ -0,0 +1,11 @@
+import { type ConstructProps } from './construct-props.js';
+import type { BoxOrientation } from './box-layout.js';
+import { AdwStyledLayoutBase } from './styled-layout-base.js';
+export declare class GtkSeparator extends AdwStyledLayoutBase {
+    private _orientation;
+    constructor(props?: ConstructProps<GtkSeparator>);
+    /** `Gtk.Orientable:orientation` — `horizontal` (the default) or `vertical`. */
+    get orientation(): BoxOrientation;
+    set orientation(value: BoxOrientation);
+    protected get _ownClass(): string;
+}

package/lib/types/widgets/gtk-stack.d.ts

@@ -0,0 +1,124 @@
+import { GridLayout, type EventData, type View } from '@nativescript/core';
+import { type ConstructProps } from './construct-props.js';
+import { GtkStackPage } from './stack-page.js';
+import { type AdwStyleClassesInput } from './style-classes.js';
+import { type GtkStackTransitionNick } from './transition-type.js';
+import { type AdwViewStackPageInfo, type ViewStackNotifyPayload } from './view-stack-state.js';
+/** Event name emitted when the visible child changes. Mirrors GObject `notify::visible-child`. */
+export declare const NOTIFY_STACK_VISIBLE_CHILD = "notify::visible-child";
+/** Mirrors GObject `notify::visible-child-name`; fired together with the one above. */
+export declare const NOTIFY_STACK_VISIBLE_CHILD_NAME = "notify::visible-child-name";
+/** Payload of both events. `index` is `-1` and `name`/`title` are `''` when nothing is selected. */
+export interface NotifyStackVisibleChildEventData extends EventData, ViewStackNotifyPayload {
+}
+declare const GtkStack_base: (abstract new (...args: any[]) => {
+    connect(eventName: string, callback: (self: /*elided*/ any, data: EventData) => void): number;
+    disconnect(handlerId: number): void;
+    get halign(): string;
+    set halign(value: string | number);
+    get valign(): string;
+    set valign(value: string | number);
+    get hexpand(): boolean;
+    set hexpand(value: boolean | string);
+    get vexpand(): boolean;
+    set vexpand(value: boolean | string);
+    get marginStart(): number;
+    set marginStart(value: number | string);
+    get marginEnd(): number;
+    set marginEnd(value: number | string);
+    get visible(): boolean;
+    set visible(value: boolean | string);
+    get sensitive(): boolean;
+    set sensitive(value: boolean | string);
+    get name(): string;
+    set name(value: string | null);
+    get widthRequest(): number;
+    set widthRequest(value: number | string);
+    get heightRequest(): number;
+    set heightRequest(value: number | string);
+    _emit(eventName: string): void;
+    addEventListener(eventName: string, callback: (data: EventData) => void, thisArg?: unknown, once?: boolean): void;
+    removeEventListener(eventName: string, callback?: (data: EventData) => void, thisArg?: unknown): void;
+    notify<T extends EventData>(data: T): void;
+    notifyPropertyChange(name: string, value: unknown, oldValue?: unknown): void;
+    set(name: string, value: unknown): void;
+    get(name: string): unknown;
+}) & typeof GridLayout;
+export declare class GtkStack extends GtkStack_base {
+    /**
+     * No named placement: a stack's XML children are its pages, in order, as GtkBuildable's
+     * untyped `<child>` is. An empty list so the builder refuses an authored slot by name.
+     */
+    static readonly builderSlots: readonly string[];
+    private readonly _state;
+    private readonly _style;
+    private _transitionType;
+    private _transitionDuration;
+    private _hhomogeneous;
+    private _vhomogeneous;
+    private _interpolateSize;
+    constructor(props?: ConstructProps<GtkStack>);
+    /** `gtk_stack_add_named` — a page with a name. Returns the page handle. */
+    add_named(child: View, name: string | null): AdwViewStackPageInfo;
+    /** `gtk_stack_add_titled`. */
+    add_titled(child: View, name: string | null, title: string): AdwViewStackPageInfo;
+    /** `gtk_stack_add_child` — a page with no name. */
+    add_child(child: View): AdwViewStackPageInfo;
+    /**
+     * `gtk_stack_remove`. Returns whether anything was removed. A removed visible page leaves
+     * the stack showing nothing and emits no event (`gtk_stack_remove` clears the visible
+     * child without re-picking).
+     */
+    remove(child: View): boolean;
+    /** `gtk_stack_get_child_by_name` — the child of the page called `name`, or `null`. */
+    get_child_by_name(name: string): View | null;
+    /**
+     * Show or hide a page (`GtkStackPage:visible`). Returns whether the SELECTION moved:
+     * hiding the visible page falls back to the next visible one.
+     */
+    setPageVisible(name: string, visible: boolean): boolean;
+    /**
+     * An XML child — a {@link GtkStackPage} record adds its child under the record's name and
+     * title; any other view is a page with no name (`gtk_stack_buildable_add_child`).
+     */
+    _addChildFromBuilder(_name: string, view: View | GtkStackPage): void;
+    /** `Gtk.Stack:visible-child-name` — the visible page's name; `null` for none or an unnamed page. */
+    get visibleChildName(): string | null;
+    set visibleChildName(name: string | null | undefined);
+    /** `Gtk.Stack:visible-child` — the visible page's child, or `null`. */
+    get visibleChild(): View | null;
+    set visibleChild(child: View | null);
+    /** `Gtk.Stack:transition-type` — held and validated, never rendered. */
+    get transitionType(): GtkStackTransitionNick;
+    set transitionType(value: GtkStackTransitionNick);
+    /** `Gtk.Stack:transition-duration`, in ms — held, never rendered. */
+    get transitionDuration(): number;
+    set transitionDuration(raw: number | string);
+    /** `Gtk.Stack:hhomogeneous`. */
+    get hhomogeneous(): boolean;
+    set hhomogeneous(raw: boolean | string);
+    /** `Gtk.Stack:vhomogeneous`. */
+    get vhomogeneous(): boolean;
+    set vhomogeneous(raw: boolean | string);
+    /** `Gtk.Stack:interpolate-size`. */
+    get interpolateSize(): boolean;
+    set interpolateSize(raw: boolean | string);
+    /** `GtkWidget:css-classes`, spelled `styleClasses` (`style-classes.ts`). */
+    get styleClasses(): string[];
+    set styleClasses(value: AdwStyleClassesInput);
+    /** `gtk_widget_add_css_class`. */
+    add_css_class(name: string): void;
+    /** `gtk_widget_remove_css_class`. */
+    remove_css_class(name: string): void;
+    /** `gtk_widget_has_css_class`. */
+    has_css_class(name: string): boolean;
+    /** `gtk_widget_get_css_classes`. */
+    get_css_classes(): string[];
+    /** `gtk_widget_set_css_classes` — REPLACES the list. */
+    set_css_classes(names: readonly string[]): void;
+    private _restyle;
+    private _add;
+    /** Put a page's view into the one cell and let the selection decide what shows. */
+    private _place;
+}
+export {};

package/lib/types/widgets/gtk-text-view.d.ts

@@ -0,0 +1,63 @@
+import { GridLayout, TextView, type EventData } from '@nativescript/core';
+import { type ConstructProps } from './construct-props.js';
+/** Event name emitted when {@link GtkTextView.text} changes. Mirrors `notify::text`. */
+export declare const NOTIFY_TEXT_VIEW_TEXT = "notify::text";
+/** `Gtk.WrapMode`'s nicks, in the enum's order (NONE=0 … WORD_CHAR=3). */
+export declare const GTK_WRAP_MODES: readonly ["none", "char", "word", "word-char"];
+export type GtkWrapModeNick = (typeof GTK_WRAP_MODES)[number];
+declare const GtkTextView_base: (abstract new (...args: any[]) => {
+    connect(eventName: string, callback: (self: /*elided*/ any, data: EventData) => void): number;
+    disconnect(handlerId: number): void;
+    get halign(): string;
+    set halign(value: string | number);
+    get valign(): string;
+    set valign(value: string | number);
+    get hexpand(): boolean;
+    set hexpand(value: boolean | string);
+    get vexpand(): boolean;
+    set vexpand(value: boolean | string);
+    get marginStart(): number;
+    set marginStart(value: number | string);
+    get marginEnd(): number;
+    set marginEnd(value: number | string);
+    get visible(): boolean;
+    set visible(value: boolean | string);
+    get sensitive(): boolean;
+    set sensitive(value: boolean | string);
+    get name(): string;
+    set name(value: string | null);
+    get widthRequest(): number;
+    set widthRequest(value: number | string);
+    get heightRequest(): number;
+    set heightRequest(value: number | string);
+    _emit(eventName: string): void;
+    addEventListener(eventName: string, callback: (data: EventData) => void, thisArg?: unknown, once?: boolean): void;
+    removeEventListener(eventName: string, callback?: (data: EventData) => void, thisArg?: unknown): void;
+    notify<T extends EventData>(data: T): void;
+    notifyPropertyChange(name: string, value: unknown, oldValue?: unknown): void;
+    set(name: string, value: unknown): void;
+    get(name: string): unknown;
+}) & typeof GridLayout;
+export declare class GtkTextView extends GtkTextView_base {
+    protected readonly _field: TextView;
+    private _text;
+    private _monospace;
+    private _wrapMode;
+    constructor(props?: ConstructProps<GtkTextView>);
+    private _applyText;
+    /** The whole text — the port's stand-in for the `Gtk.TextBuffer`. */
+    get text(): string;
+    set text(value: string);
+    /** `Gtk.TextView:editable`. */
+    get editable(): boolean;
+    set editable(raw: boolean | string);
+    /** `Gtk.TextView:monospace`. */
+    get monospace(): boolean;
+    set monospace(raw: boolean | string);
+    /** `Gtk.TextView:wrap-mode` — held and read back; the platform always wraps. */
+    get wrapMode(): GtkWrapModeNick;
+    set wrapMode(value: GtkWrapModeNick);
+    /** The inner `TextView` — for focus, selection and host-specific keyboard options. */
+    get field(): TextView;
+}
+export {};

package/lib/types/widgets/gtk-toggle-button.d.ts

@@ -0,0 +1,33 @@
+import { type ConstructProps } from './construct-props.js';
+import { GtkButton } from './gtk-button.js';
+/** Event name emitted when `active` changes. Mirrors `Gtk.ToggleButton::toggled`. */
+export declare const GTK_TOGGLE_BUTTON_TOGGLED = "toggled";
+/** Event name emitted when `active` changes. Mirrors GObject `notify::active`. */
+export declare const NOTIFY_TOGGLE_ACTIVE = "notify::active";
+/** The class a pressed-in toggle button wears, which the theme gives the pressed shade. */
+export declare const GTK_TOGGLE_BUTTON_CHECKED_CLASS = "checked";
+/** Event name emitted when `group` changes. Mirrors GObject `notify::group`. */
+export declare const NOTIFY_TOGGLE_GROUP = "notify::group";
+export declare class GtkToggleButton extends GtkButton {
+    static readonly emittedSignals: readonly string[];
+    private _active;
+    private _groupNext;
+    private _groupPrev;
+    constructor(props?: ConstructProps<GtkToggleButton>);
+    /** `Gtk.ToggleButton:active` — whether the button is pressed in. Defaults to `false`. */
+    get active(): boolean;
+    set active(raw: boolean | string);
+    /**
+     * `Gtk.ToggleButton:group` — the button this one joins, or `null` to leave the group.
+     * Write-only, as `G_PARAM_WRITABLE` has it.
+     */
+    set group(value: GtkToggleButton | null);
+    private get _grouped();
+    /** `gtk_toggle_button_set_group` — insert this button directly BEFORE `group`, or unlink it. */
+    private _setGroup;
+    /** Release every OTHER member: walk back to the first, then forwards (:426-434). */
+    private _clearGroup;
+    /** Walk back to the first member of a toggle group, bounded like GTK. */
+    private static _groupHead;
+    protected _stateClasses(): readonly string[];
+}