@gjsify/adwaita-nativescript 0.54.0 → 0.55.0

package/lib/types/widgets/index.d.ts

@@ -22,8 +22,44 @@ export { GtkButton, GTK_BUTTON_CLICKED, GTK_BUTTON_LABEL_CLASS } from './gtk-but
 export { buttonSlotAfterWrite, buttonSlotDetaches } from './button-slot.js';
 export type { ButtonSlot, ButtonSlotWrite } from './button-slot.js';
 export { GtkBox, DEFAULT_BOX_SPACING } from './gtk-box.js';
+export { GtkGrid } from './gtk-grid.js';
+export { gridChildAt, gridGap, gridSpacing, gridTrackCounts } from './grid-state.js';
+export type { GridPlacement } from './grid-state.js';
+export { GtkListBox, LIST_BOX_ROW_ACTIVATED, LIST_BOX_ROW_SELECTED, LIST_ROW_SELECTED_CLASS } from './gtk-list-box.js';
+export type { ListBoxRowEventData } from './gtk-list-box.js';
+export { DEFAULT_LIST_SELECTION_MODE, GTK_SELECTION_MODES, selectionAfterModeChange, selectionAfterTap, selectionMode, } from './list-box-state.js';
+export type { GtkSelectionModeNick } from './list-box-state.js';
+export { AdwWindow } from './adw-window.js';
+export { AdwApplicationWindow } from './adw-application-window.js';
+export { AdwWindowBase, ADW_WINDOW_CLASS } from './window-base.js';
+export { AdwDialog, ADW_DIALOG_CLASS, ADW_DIALOG_CLOSED, ADW_DIALOG_CLOSE_ATTEMPT } from './adw-dialog.js';
+export { ADW_DIALOG_PRESENTATION_MODES, DEFAULT_DIALOG_PRESENTATION_MODE, dialogPresentationMode, findDialogHost, surfaceSize, } from './window-state.js';
+export type { AdwDialogPresentationNick, DialogHost } from './window-state.js';
+export { NOTIFY_HEXPAND, NOTIFY_VEXPAND } from './widget-layout.js';
+export { lengthValue } from './ns-length.js';
+export type { NsLength } from './ns-length.js';
 export { GtkActionBar } from './gtk-action-bar.js';
-export { boxChildMargin, boxSpacingChanges, normalizeBoxSpacing } from './box-layout.js';
+export { AdwBin } from './adw-bin.js';
+export { GtkOverlay } from './gtk-overlay.js';
+export { GtkRevealer, NOTIFY_REVEAL_CHILD } from './gtk-revealer.js';
+export { revealerChildVisibility } from './revealer-state.js';
+export type { RevealerChildVisibility } from './revealer-state.js';
+export { GtkScrolledWindow } from './gtk-scrolled-window.js';
+export { DEFAULT_SCROLLBAR_POLICY, GTK_POLICY_TYPES, normalizePolicy, policyScrolls, scrollOrientationFor, } from './scrolled-window-policy.js';
+export type { GtkPolicyNick } from './scrolled-window-policy.js';
+export { GtkStack, NOTIFY_STACK_VISIBLE_CHILD, NOTIFY_STACK_VISIBLE_CHILD_NAME } from './gtk-stack.js';
+export type { NotifyStackVisibleChildEventData } from './gtk-stack.js';
+export { GtkStackPage } from './stack-page.js';
+export { DEFAULT_REVEALER_TRANSITION_DURATION, DEFAULT_STACK_TRANSITION_DURATION, GTK_REVEALER_TRANSITIONS, GTK_STACK_TRANSITIONS, transitionNick, } from './transition-type.js';
+export type { GtkRevealerTransitionNick, GtkStackTransitionNick } from './transition-type.js';
+export { GtkToggleButton, GTK_TOGGLE_BUTTON_CHECKED_CLASS, GTK_TOGGLE_BUTTON_TOGGLED, NOTIFY_TOGGLE_ACTIVE, } from './gtk-toggle-button.js';
+export { GtkCheckButton, GTK_CHECK_BUTTON_ACTIVATE, GTK_CHECK_BUTTON_CHECKED_CLASS, GTK_CHECK_BUTTON_INCONSISTENT_CLASS, GTK_CHECK_BUTTON_TOGGLED, NOTIFY_CHECK_ACTIVE, } from './gtk-check-button.js';
+export { GtkDrawingArea, DRAWING_AREA_REFUSAL } from './gtk-drawing-area.js';
+export { GtkFrame } from './gtk-frame.js';
+export { GtkSeparator } from './gtk-separator.js';
+export { GtkTextView, GTK_WRAP_MODES, NOTIFY_TEXT_VIEW_TEXT } from './gtk-text-view.js';
+export type { GtkWrapModeNick } from './gtk-text-view.js';
+export { boxChildTrack, boxSpacingChanges, boxTrackPlan, normalizeBoxSpacing } from './box-layout.js';
 export type { BoxOrientation } from './box-layout.js';
 export { GtkLabel } from './gtk-label.js';
 export { labelDisplayText, labelMarkupIsUnparseable } from '@gjsify/adwaita-core';
@@ -112,7 +148,7 @@ export { ADWAITA_ICON_GRID, DEFAULT_ICON_COLOR, DEFAULT_ICON_COLOR_DARK, extract
 export type { IconPath, SymbolicIconOptions } from './icons.js';
 export { adwaitaColorScheme, isThemeIconColor, onAdwaitaColorSchemeChanged, setAdwaitaColorScheme, themeIconColor, toggleAdwaitaColorScheme, } from './color-scheme.js';
 export type { AdwColorScheme } from './color-scheme.js';
-export { AdwBreakpoint, addBreakpoints, evaluateBreakpointCondition, parseBreakpointCondition } from './breakpoint.js';
+export { AdwBreakpoint, addBreakpoints, evaluateBreakpointCondition, observeViewSize, parseBreakpointCondition, } from './breakpoint.js';
 export type { AdwBreakpointHandlers, BreakpointBound, BreakpointConditionGroup, BreakpointConditionLeaf, BreakpointConditionNode, BreakpointDimension, BreakpointSize, } from './breakpoint.js';
 /**
  * Register all Adwaita widgets as UNPREFIXED NativeScript XML elements, where a
@@ -131,3 +167,5 @@ export type { AdwBreakpointHandlers, BreakpointBound, BreakpointConditionGroup,
  * does before writing `<AdwSwitchRow>` in markup.
  */
 export declare function registerAdwaitaElements(): void;
+export { configureSystemBars, systemBarsConfig, WINDOW_BACKGROUND } from './system-bars.js';
+export type { BarIcons, SystemBarEdges, SystemBarsOptions, ResolvedSystemBars } from './system-bars.js';

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

@@ -0,0 +1,19 @@
+export declare const GTK_SELECTION_MODES: readonly ["none", "single", "browse", "multiple"];
+export type GtkSelectionModeNick = (typeof GTK_SELECTION_MODES)[number];
+/** `GtkListBox:selection-mode` default. */
+export declare const DEFAULT_LIST_SELECTION_MODE: GtkSelectionModeNick;
+/** The selection mode a write means — a nick or the constant — or throw naming the members. */
+export declare function selectionMode(value: unknown): GtkSelectionModeNick;
+/**
+ * The rows selected after `row` was tapped.
+ *
+ * `none` selects nothing; `single` and `browse` select the tapped row and drop the rest
+ * (`browse` additionally never lets the last one go, which a tap cannot do anyway);
+ * `multiple` toggles it, which is what a click on an already-selected row does there.
+ */
+export declare function selectionAfterTap<Row>(mode: GtkSelectionModeNick, selected: readonly Row[], row: Row): Row[];
+/**
+ * The rows still selected after the mode changed — `gtk_list_box_set_selection_mode` drops
+ * every selection for `none`, and for a mode that holds one row when several were selected.
+ */
+export declare function selectionAfterModeChange<Row>(mode: GtkSelectionModeNick, selected: readonly Row[]): Row[];

package/lib/types/widgets/ns-length.d.ts

@@ -0,0 +1,10 @@
+/** A length as NativeScript hands it back: a number, a CSS-ish string, or `{ value, unit }`. */
+export type NsLength = number | string | {
+    value: number;
+    unit?: string;
+} | null | undefined;
+/**
+ * The number of DIPs `length` is, or `null` when it is not a plain length — `auto`, a
+ * percentage, an unparseable string, nothing.
+ */
+export declare function lengthValue(length: NsLength): number | null;

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

@@ -0,0 +1,7 @@
+/** The two `View.visibility` values a revealed child ever takes. */
+export type RevealerChildVisibility = 'visible' | 'collapse';
+/**
+ * The `visibility` a child takes for `reveal-child`. `collapse`, not `hidden`: GTK's
+ * unrevealed child contributes zero size, and `hidden` keeps the view's space.
+ */
+export declare function revealerChildVisibility(revealChild: boolean): RevealerChildVisibility;

package/lib/types/widgets/row-state.d.ts

@@ -11,6 +11,12 @@ export type NsVisibility = 'visible' | 'collapse';
  * behind — the one thing the binding exists to prevent.
  */
 export declare function nsVisibility(shown: boolean): NsVisibility;
+/**
+ * The `className` of a row's Switch for its state. NativeScript's `color` tints the
+ * thumb in BOTH states, so the theme needs the `.off` hook to give an unchecked
+ * thumb a neutral colour (`.adw-switch.off` in theme/adwaita.css).
+ */
+export declare function switchClassName(checked: boolean): string;
 /** The NativeScript form of a title/subtitle label pair. */
 export interface NsRowLabelVisuals {
     title: string;

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

@@ -0,0 +1,17 @@
+export declare const GTK_POLICY_TYPES: readonly ["always", "automatic", "never", "external"];
+export type GtkPolicyNick = (typeof GTK_POLICY_TYPES)[number];
+/** `gtk_scrolled_window_init`: both policies start `automatic`. */
+export declare const DEFAULT_SCROLLBAR_POLICY: GtkPolicyNick;
+/** The nick a policy write means — a nick or the constant — or throw, naming the members. */
+export declare function normalizePolicy(value: unknown, property: 'hscrollbar-policy' | 'vscrollbar-policy'): GtkPolicyNick;
+/** Whether an axis under `policy` scrolls at all. */
+export declare function policyScrolls(policy: GtkPolicyNick): boolean;
+/**
+ * The one axis the `ScrollView` scrolls on, for a pair of policies.
+ *
+ * Vertical wins a tie, because that is the axis a page of content grows on; a window that
+ * scrolls ONLY horizontally is the one case that flips it. Neither axis scrolling still
+ * answers `vertical` — a `ScrollView` cannot refuse to scroll, so the child is simply held
+ * at its natural size by the surrounding layout.
+ */
+export declare function scrollOrientationFor(hscrollbarPolicy: GtkPolicyNick, vscrollbarPolicy: GtkPolicyNick): 'horizontal' | 'vertical';

package/lib/types/widgets/signals.d.ts

@@ -43,6 +43,16 @@ export declare function withSignals<TBase extends ObservableConstructor>(Base: T
     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/single-child-base.d.ts

@@ -0,0 +1,22 @@
+import { type View } from '@nativescript/core';
+import { AdwStyledLayoutBase } from './styled-layout-base.js';
+export declare abstract class AdwSingleChildBase extends AdwStyledLayoutBase {
+    private _child;
+    constructor();
+    /** The child, or `null`. */
+    get child(): View | null;
+    set child(view: View | null);
+    /** `gtk_*_set_child` — the method spelling of {@link child}. */
+    set_child(view: View | null): void;
+    /** `gtk_*_get_child`. */
+    get_child(): View | null;
+    /**
+     * XML inflation — a bare child and `child:` mean the same thing, so every child a
+     * template declares is THE child. A widget with a second destination overrides this.
+     */
+    _addChildFromBuilder(_name: string, view: View): void;
+    /** Put the child where this widget shows it. The default is the one cell, at the bottom. */
+    protected _adopt(view: View): void;
+    /** Take the child back out of wherever {@link _adopt} put it. */
+    protected _release(view: View): void;
+}

package/lib/types/widgets/split-view-base.d.ts

@@ -25,6 +25,16 @@ declare const AdwSplitViewBase_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/stack-page.d.ts

@@ -0,0 +1,93 @@
+import { Observable, type View } from '@nativescript/core';
+import { type ConstructProps } from './construct-props.js';
+/** The one stack call a record needs once adopted — `GtkStack.setPageVisible`. */
+interface AdoptingStack {
+    setPageVisible(name: string, visible: boolean): boolean;
+}
+/** A stack this record was handed to before it had a child — see {@link GtkStackPage._awaitChild}. */
+interface AwaitingStack {
+    _addChildFromBuilder(name: string, view: GtkStackPage): void;
+}
+declare const GtkStackPage_base: (abstract new (...args: any[]) => {
+    connect(eventName: string, callback: (self: /*elided*/ any, data: import("@nativescript/core").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: import("@nativescript/core").EventData) => void, thisArg?: unknown, once?: boolean): void;
+    removeEventListener(eventName: string, callback?: (data: import("@nativescript/core").EventData) => void, thisArg?: unknown): void;
+    notify<T extends import("@nativescript/core").EventData>(data: T): void;
+    notifyPropertyChange(name: string, value: unknown, oldValue?: unknown): void;
+    set(name: string, value: unknown): void;
+    get(name: string): unknown;
+}) & typeof Observable;
+export declare class GtkStackPage extends GtkStackPage_base {
+    /** `child:` in a `.blp` — the page itself. The fallback too: a bare child IS the page. */
+    static readonly builderSlots: readonly string[];
+    private _child;
+    private _name;
+    private _title;
+    private _iconName;
+    private _needsAttention;
+    private _visible;
+    private _useUnderline;
+    /** The stack that adopted this record, or `null` while it is still being authored. */
+    private _stack;
+    /** The stack waiting for this record's child, while it has none. */
+    private _awaiting;
+    constructor(props?: ConstructProps<GtkStackPage>);
+    /** `GtkStackPage:child` — the view the stack shows for this page. */
+    get child(): View | null;
+    set child(view: View | null);
+    /** `GtkStackPage:name` — what `visible-child-name` selects by. */
+    get name(): string;
+    set name(value: string | null);
+    /** `GtkStackPage:title`. */
+    get title(): string | null;
+    set title(value: string | null);
+    /** `GtkStackPage:icon-name`. */
+    get iconName(): string | null;
+    set iconName(value: string | null);
+    /** `GtkStackPage:needs-attention`. */
+    get needsAttention(): boolean;
+    set needsAttention(raw: boolean | string);
+    /** `GtkStackPage:use-underline`. */
+    get useUnderline(): boolean;
+    set useUnderline(raw: boolean | string);
+    /** `GtkStackPage:visible` — the one property that still reaches the stack after adoption. */
+    get visible(): boolean;
+    set visible(raw: boolean | string);
+    /** An XML child is the page's `child` — there is nothing else a record holds. */
+    _addChildFromBuilder(_name: string, view: View): void;
+    /** Called by the stack that takes this record; a record adopted twice is refused. */
+    _adoptBy(stack: AdoptingStack): void;
+    /**
+     * Called by a stack handed this record while it has no child yet. NativeScript's XML
+     * builder hands a child to its parent at the child's START tag, so a template's
+     * `<gtk:StackPage>` reaches the stack before its own `<gtk:StackPage.child>` has been
+     * read; the stack takes the record when the child arrives, which keeps document order.
+     */
+    _awaitChild(stack: AwaitingStack): void;
+    private _refuseAfterAdoption;
+}
+export {};

package/lib/types/widgets/style-classes.d.ts

@@ -59,3 +59,31 @@ export declare function classNameWith(base: string, classes: readonly string[]):
 export declare function withCssClass(classes: readonly string[], name: string): string[];
 /** The list after `gtk_widget_remove_css_class(name)`. Absent is a no-op, as in C. */
 export declare function withoutCssClass(classes: readonly string[], name: string): string[];
+/**
+ * The `styleClasses` list of ONE widget, with GTK's `css-classes` verbs over it.
+ *
+ * `GtkBox` and `GtkButton` each carry their own copy of this bookkeeping; a container that
+ * is only a pass-through (`Adw.Bin`, `Gtk.Overlay`, `Gtk.Stack` …) needs the same five verbs
+ * and nothing else, so the list lives here once and a widget keeps one of these. The widget
+ * still declares the accessors itself — a `Property` of the platform base must not be
+ * shadowed by a mixin, and the coverage gates read the members off the class body.
+ *
+ * `base` is the class the widget wears of its own accord, `''` for the transparent ones (see
+ * {@link classNameWith}); {@link className} is what to write onto the view after a change.
+ */
+export declare class StyleClassList {
+    private readonly _base;
+    private _classes;
+    constructor(_base?: string);
+    /** The classes, without the widget's own base class. */
+    get classes(): string[];
+    /** The `className` the widget must carry for the current list. */
+    get className(): string;
+    /** `styleClasses = '…'` — the string door, REPLACES the list. */
+    replace(value: AdwStyleClassesInput): void;
+    /** `gtk_widget_set_css_classes` — REPLACES the list from names. */
+    replaceAll(names: readonly string[]): void;
+    add(name: string): void;
+    remove(name: string): void;
+    has(name: string): boolean;
+}

package/lib/types/widgets/styled-layout-base.d.ts

@@ -0,0 +1,63 @@
+import { GridLayout } from '@nativescript/core';
+import { type AdwStyleClassesInput } from './style-classes.js';
+declare const AdwStyledLayoutBase_base: (abstract new (...args: any[]) => {
+    connect(eventName: string, callback: (self: /*elided*/ any, data: import("@nativescript/core").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: import("@nativescript/core").EventData) => void, thisArg?: unknown, once?: boolean): void;
+    removeEventListener(eventName: string, callback?: (data: import("@nativescript/core").EventData) => void, thisArg?: unknown): void;
+    notify<T extends import("@nativescript/core").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 abstract class AdwStyledLayoutBase extends AdwStyledLayoutBase_base {
+    private readonly _style;
+    constructor();
+    /**
+     * `GtkWidget:css-classes`, spelled `styleClasses` — `cssClasses` is the platform's own
+     * live `Set` (`style-classes.ts`). From XML it is a space-separated list.
+     */
+    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;
+    /**
+     * The class the widget wears for what it IS, before any `css-classes`. Empty for the
+     * transparent containers; a window or a dialog overrides it, because those have a
+     * background GTK's `.background` gives them.
+     */
+    protected get _ownClass(): string;
+    protected _restyle(): void;
+}
+export {};

package/lib/types/widgets/system-bars-source.android.d.ts

@@ -0,0 +1,2 @@
+/** Apply now and again on every change. Reference-counted: one subscription for many views. */
+export declare function observeSystemBars(): () => void;

package/lib/types/widgets/system-bars-source.d.ts

@@ -0,0 +1,2 @@
+/** Keep the bars' icon colour and backdrop in step with the colour scheme. Returns the stop. */
+export declare function observeSystemBars(): () => void;

package/lib/types/widgets/system-bars-source.ios.d.ts

@@ -0,0 +1,2 @@
+/** Keep the bars' icon colour and backdrop in step with the colour scheme. Returns the stop. */
+export declare function observeSystemBars(): () => void;

package/lib/types/widgets/system-bars.d.ts

@@ -0,0 +1,71 @@
+import type { AdwColorScheme } from '@gjsify/adwaita-core';
+import type { WindowInsets } from './window-insets.js';
+/** The colour of a bar's icons: follow the colour scheme, or force one. */
+export type BarIcons = 'auto' | 'light' | 'dark';
+/** Which edges get padding for their system bar. */
+export interface SystemBarEdges {
+    readonly top: boolean;
+    readonly bottom: boolean;
+}
+/** What the caller may pass. Every field is optional; the rest keeps the default. */
+export interface SystemBarsOptions {
+    /** `true` / `false` for both edges, or per edge. Default: both. */
+    readonly insets?: boolean | Partial<SystemBarEdges>;
+    /** Colour of the status bar's icons and clock. Default `'auto'`. */
+    readonly statusBarIcons?: BarIcons;
+    /** Colour of the navigation bar's icons / gesture pill. Default `'auto'`. */
+    readonly navigationBarIcons?: BarIcons;
+    /** What shows behind the bars: the Adwaita window colour, nothing, or a colour. */
+    readonly background?: 'window' | 'transparent' | string;
+}
+/** {@link SystemBarsOptions} with every default filled in. */
+export interface ResolvedSystemBars {
+    readonly insets: SystemBarEdges;
+    readonly statusBarIcons: BarIcons;
+    readonly navigationBarIcons: BarIcons;
+    readonly background: string;
+}
+/** The Adwaita window background per scheme (`.adw-window` in the theme). */
+export declare const WINDOW_BACKGROUND: Record<AdwColorScheme, string>;
+export declare const DEFAULT_SYSTEM_BARS: ResolvedSystemBars;
+/** Fold a boolean or per-edge `insets` option into both edges. */
+export declare function resolveEdges(insets: boolean | Partial<SystemBarEdges> | null | undefined, base?: SystemBarEdges): SystemBarEdges;
+/** Layer `options` over `base`; an absent field keeps the base value. */
+export declare function resolveSystemBars(options: SystemBarsOptions | null | undefined, base?: ResolvedSystemBars): ResolvedSystemBars;
+/** Zero the edges whose padding is switched off. */
+export declare function insetsForEdges(insets: WindowInsets, edges: SystemBarEdges): WindowInsets;
+/**
+ * The value for `setAppearanceLightStatusBars` / `setAppearanceLightNavigationBars`.
+ *
+ * The flag is named for the BAR, not the icons: "light bars" means a light background,
+ * which needs DARK icons. So the light scheme sets it and the dark scheme clears it —
+ * the inversion that is easy to get backwards, hence a tested function.
+ */
+export declare function lightBarFlag(icons: BarIcons, scheme: AdwColorScheme): boolean;
+/** The colour behind the bars, or `null` for fully transparent. */
+export declare function barBackgroundColor(background: string, scheme: AdwColorScheme): string | null;
+/** What the native side must apply for `bars` under `scheme`. */
+export interface SystemBarsAppearance {
+    readonly lightStatusBars: boolean;
+    readonly lightNavigationBars: boolean;
+    readonly background: string | null;
+}
+export declare function systemBarsAppearance(bars: ResolvedSystemBars, scheme: AdwColorScheme): SystemBarsAppearance;
+/** Notified when the global options change. */
+export type SystemBarsListener = (bars: ResolvedSystemBars) => void;
+/** The global options and who listens to them. Exported for tests; apps use `configureSystemBars`. */
+export declare class SystemBarsConfig {
+    private _bars;
+    private readonly _listeners;
+    get bars(): ResolvedSystemBars;
+    /** Layer `options` over the CURRENT options (not over the defaults). */
+    configure(options: SystemBarsOptions): void;
+    /** Back to the defaults. */
+    reset(): void;
+    subscribe(listener: SystemBarsListener): () => void;
+}
+export declare const systemBarsConfig: SystemBarsConfig;
+/** Change how the app treats the system bars. Options not given keep their current value. */
+export declare function configureSystemBars(options: SystemBarsOptions): void;
+/** `className` with the theme's window class added once, so the page paints the Adwaita window colour. */
+export declare function withPageClass(className: string | null | undefined): string;

package/lib/types/widgets/transition-type.d.ts

@@ -0,0 +1,13 @@
+export declare const GTK_REVEALER_TRANSITIONS: readonly ["none", "crossfade", "slide-right", "slide-left", "slide-up", "slide-down", "swing-right", "swing-left", "swing-up", "swing-down", "fade-slide-right", "fade-slide-left", "fade-slide-up", "fade-slide-down"];
+export declare const GTK_STACK_TRANSITIONS: readonly ["none", "crossfade", "slide-right", "slide-left", "slide-up", "slide-down", "slide-left-right", "slide-up-down", "over-up", "over-down", "over-left", "over-right", "under-up", "under-down", "under-left", "under-right", "over-up-down", "over-down-up", "over-left-right", "over-right-left", "rotate-left", "rotate-right", "rotate-left-right"];
+export type GtkRevealerTransitionNick = (typeof GTK_REVEALER_TRANSITIONS)[number];
+export type GtkStackTransitionNick = (typeof GTK_STACK_TRANSITIONS)[number];
+/** `GtkStack:transition-duration` default, in ms. */
+export declare const DEFAULT_STACK_TRANSITION_DURATION = 200;
+/** `GtkRevealer:transition-duration` default, in ms. */
+export declare const DEFAULT_REVEALER_TRANSITION_DURATION = 250;
+/**
+ * The nick a transition write means: a nick, its Blueprint underscore spelling, or the
+ * constant — or throw, naming the members.
+ */
+export declare function transitionNick<Nick extends string>(value: unknown, members: readonly Nick[], property: string): Nick;

package/lib/types/widgets/view-stack-page.d.ts

@@ -23,6 +23,16 @@ declare const AdwViewStackPage_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/view-switcher-base.d.ts

@@ -27,6 +27,16 @@ declare const AdwViewSwitcherBase_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/widget-layout.d.ts

@@ -4,6 +4,9 @@ import type { Observable } from '@nativescript/core';
  * this module does not import the one that applies it.
  */
 type ObservableConstructor = abstract new (...args: any[]) => Observable;
+/** The events a `hexpand` / `vexpand` change emits, so a parent that allocates by them can re-allocate. */
+export declare const NOTIFY_HEXPAND = "notify::hexpand";
+export declare const NOTIFY_VEXPAND = "notify::vexpand";
 /** The six accessors the mixin adds. Named so a consumer can annotate with it. */
 export interface GtkWidgetLayout {
     /** `GtkWidget:halign` — a `Gtk.Align` nick, read back from `horizontalAlignment`. */
@@ -18,6 +21,16 @@ export interface GtkWidgetLayout {
     marginStart: number;
     /** `GtkWidget:margin-end` — the trailing edge, resolved against the text direction. */
     marginEnd: number;
+    /** `GtkWidget:visible` — `visibility`; `false` takes the widget out of layout. */
+    visible: boolean;
+    /** `GtkWidget:sensitive` — `isEnabled`. */
+    sensitive: boolean;
+    /** `GtkWidget:name` — the CSS `#name`, written through to `id` when the view has none. */
+    name: string;
+    /** `GtkWidget:width-request` — `minWidth`; `-1` is unset. */
+    widthRequest: number;
+    /** `GtkWidget:height-request` — `minHeight`; `-1` is unset. */
+    heightRequest: number;
 }
 /**
  * Give a `@nativescript/core` base GTK's widget layout properties.
@@ -39,6 +52,16 @@ export declare function withGtkWidgetLayout<TBase extends ObservableConstructor>
     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/window-base.d.ts

@@ -0,0 +1,41 @@
+import { type View } from '@nativescript/core';
+import { AdwSingleChildBase } from './single-child-base.js';
+import { type DialogHost } from './window-state.js';
+/**
+ * The class a window wears — the one the theme already gives a `Page`
+ * (`.adw-window`, Adwaita's `.background`: window fill and text colour), so a window built
+ * into a bare layout looks like the page it would have been.
+ */
+export declare const ADW_WINDOW_CLASS = "adw-window";
+export declare abstract class AdwWindowBase extends AdwSingleChildBase implements DialogHost {
+    /** `content` is the one destination, so it is also the fallback. */
+    static readonly builderSlots: readonly string[];
+    private _title;
+    private _defaultWidth;
+    private _defaultHeight;
+    private readonly _dialogs;
+    constructor();
+    protected get _ownClass(): string;
+    /** `Adw.Window:content` / `Adw.ApplicationWindow:content`. */
+    get content(): View | null;
+    set content(view: View | null);
+    /** `adw_window_set_content`. */
+    set_content(view: View | null): void;
+    /** `adw_window_get_content`. */
+    get_content(): View | null;
+    /** `GtkWindow:title`. Held: a `Page` has no title bar of this window's to put it in. */
+    get title(): string;
+    set title(value: string | null);
+    /** `GtkWindow:default-width` — held and read back; the screen is the width. */
+    get defaultWidth(): number;
+    set defaultWidth(value: number | string);
+    /** `GtkWindow:default-height` — held and read back; the screen is the height. */
+    get defaultHeight(): number;
+    set defaultHeight(value: number | string);
+    /** The dialogs presented over this window and not yet closed, bottom to top. */
+    get dialogs(): readonly View[];
+    /** `DialogHost` — `AdwDialog.present (parent)` calls this on the window it finds. */
+    _hostDialog(dialog: unknown): void;
+    /** `DialogHost` — the dialog closed. A view this window did not host is left alone. */
+    _unhostDialog(dialog: unknown): void;
+}

package/lib/types/widgets/window-state.d.ts

@@ -0,0 +1,37 @@
+/**
+ * `Adw.DialogPresentationMode`, in declaration order — a position IS the GIR constant,
+ * held against `generated/enum-values.mts` by arm 8 of `check-nativescript-xml-doors.mjs`.
+ */
+export declare const ADW_DIALOG_PRESENTATION_MODES: readonly ["auto", "floating", "bottom-sheet"];
+export type AdwDialogPresentationNick = (typeof ADW_DIALOG_PRESENTATION_MODES)[number];
+/** `AdwDialog:presentation-mode` default. */
+export declare const DEFAULT_DIALOG_PRESENTATION_MODE: AdwDialogPresentationNick;
+/** The presentation mode a write means, or throw naming the members. */
+export declare function dialogPresentationMode(value: unknown): AdwDialogPresentationNick;
+/**
+ * A window's or dialog's size property — `default-width`, `default-height`, `content-width`,
+ * `content-height` — an integer from `-1` up.
+ *
+ * GTK's pspecs are `-1 … G_MAXINT` and both `-1` and the default `0` mean "no size asked":
+ * the surface takes its natural one. The setter parses with `xmlNumber` (an attribute is
+ * always a string) and hands the result here with what was written: a value that is not such
+ * an integer is refused rather than clamped, as the other integer properties of this port are,
+ * and a blank attribute keeps what was there.
+ */
+export declare function surfaceSize(parsed: number, written: unknown, current: number, property: string): number;
+/** What a dialog hands itself to when it is presented over a widget. */
+export interface DialogHost {
+    /** Put `dialog` above everything the host shows. */
+    _hostDialog(dialog: unknown): void;
+    /** Take it back out once it closed. */
+    _unhostDialog(dialog: unknown): void;
+}
+/**
+ * The window `adw_dialog_present (dialog, parent)` shows a dialog in: `parent` itself, or the
+ * nearest ancestor of it, that hosts dialogs — or `null`.
+ *
+ * `adw_dialog_present` walks to the parent's `GtkRoot`; this port's equivalent of a root is a
+ * view that implements the two host methods, so the walk stops at the first one rather than
+ * at a class.
+ */
+export declare function findDialogHost(start: unknown): DialogHost | null;