@gjsify/adwaita-nativescript 0.43.0 → 0.45.0

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

@@ -14,6 +14,12 @@ export declare class AdwPreferencesDialog extends GridLayout {
     set title(value: string);
     /** Add an `AdwPreferencesPage` (or any view) to the dialog body. */
     add(view: View): void;
+    /**
+     * An XML child is a page in the dialog BODY, not a child of the grid the dialog
+     * builds its header and scroller in — which is where `LayoutBase`'s inherited
+     * `_addChildFromBuilder` would have put it, on top of the title bar.
+     */
+    _addChildFromBuilder(_name: string, view: View): void;
     /** Remove a previously-added page from the body. */
     remove(view: View): void;
     /**
@@ -38,7 +44,7 @@ export declare class AdwPreferencesDialog extends GridLayout {
     close(): void;
     /** Whether the dialog is currently shown. */
     get open(): boolean;
-    set open(value: boolean);
+    set open(value: boolean | string);
     /** The scrollable body that hosts the preferences pages. */
     get body(): StackLayout;
 }

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

@@ -45,6 +45,17 @@ export declare class AdwPreferencesGroup extends StackLayout implements NsSearch
      */
     get headerSuffix(): View | null;
     set headerSuffix(view: View | null);
+    /**
+     * XML inflation — a template's children are ROWS, not stray layout children.
+     *
+     * `<AdwPreferencesGroup.headerSuffix>` reaches the suffix host; everything
+     * else goes into the boxed list, which is where a row has to be to get the
+     * card, the rounded ends and the separators. Without this the `StackLayout`
+     * default appended each row NEXT TO the listbox: measured on Android, the
+     * rows rendered — unboxed, on the page background, with no `.boxed-list`
+     * around them — which is the failure that looks like a styling bug.
+     */
+    _addChildFromBuilder(name: string, view: View): void;
     /** Append a row (or any view) to the boxed list. */
     addRow(view: View): void;
     /** Remove a previously-added row from the boxed list. */

package/lib/types/widgets/adw-preferences-page.d.ts

@@ -26,11 +26,17 @@ export declare class AdwPreferencesPage extends ScrollView implements NsSearchab
      * a search-result subtitle strips before showing it (:196-199).
      */
     get useUnderline(): boolean;
-    set useUnderline(value: boolean);
+    set useUnderline(value: boolean | string);
     /** Append a preferences group (or any view) to the page. */
     addGroup(view: View): void;
     /** Remove a previously-added group from the page. */
     removeGroup(view: View): void;
+    /**
+     * An XML child is a GROUP. `ScrollView`'s inherited `_addChildFromBuilder` sets
+     * `content`, which would REPLACE the page's own scroll body — one group in place
+     * of all of them, and no error.
+     */
+    _addChildFromBuilder(_name: string, view: View): void;
     /**
      * The groups this page contributes to a preferences search, in order.
      *

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

@@ -51,7 +51,7 @@ export declare class AdwSidebar extends ScrollView {
      * selection rather than being ignored (adw-sidebar.c:3028-3029).
      */
     get selected(): number;
-    set selected(value: number);
+    set selected(raw: number | string);
     /** The selected item, or undefined — `adw_sidebar_get_selected_item`. */
     get selectedItem(): AdwSidebarItemSpec | undefined;
     /**

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

@@ -29,16 +29,16 @@ export declare class AdwSliderRow extends StackLayout {
     set title(value: string);
     /** The current numeric value (always within `[min, max]`, snapped to `step`). */
     get value(): number;
-    set value(v: number);
+    set value(raw: number | string);
     /** Lower bound. Re-clamps the current value if it now falls below. */
     get min(): number;
-    set min(v: number);
+    set min(raw: number | string);
     /** Upper bound. Re-clamps the current value if it now falls above. */
     get max(): number;
-    set max(v: number);
+    set max(raw: number | string);
     /** Snap granularity applied as the slider is dragged. */
     get step(): number;
-    set step(v: number);
+    set step(raw: number | string);
     /** The underlying {@link Slider} (e.g. to tweak styling). */
     get slider(): Slider;
 }

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

@@ -23,14 +23,14 @@ export declare class AdwSpinRow extends AdwActionRow {
     constructor();
     /** The current numeric value (always within `[min, max]`). */
     get value(): number;
-    set value(v: number);
+    set value(v: number | string);
     /** Lower bound. Re-clamps the current value if it now falls below. */
     get min(): number;
-    set min(v: number);
+    set min(v: number | string);
     /** Upper bound. Re-clamps the current value if it now falls above. */
     get max(): number;
-    set max(v: number);
+    set max(v: number | string);
     /** Increment/decrement step applied per button press. */
     get step(): number;
-    set step(v: number);
+    set step(v: number | string);
 }

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

@@ -13,7 +13,7 @@ export declare class AdwSpinner extends GridLayout {
     private _applySpinning;
     /** Whether the spinner is animating. Gated on being mapped, as in GTK. */
     get spinning(): boolean;
-    set spinning(value: boolean);
+    set spinning(value: boolean | string);
     /**
      * The BOX size in DIPs — what was requested, floored at the measured
      * minimum 16 and NOT capped.
@@ -24,7 +24,7 @@ export declare class AdwSpinner extends GridLayout {
      * silently took 64 DIPs of layout instead of the 200 it was given.
      */
     get size(): number;
-    set size(value: number);
+    set size(value: number | string);
     /** The drawn ring diameter — `spinnerGeometry`, capped at 64. */
     get ringDiameter(): number;
 }

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

@@ -70,10 +70,10 @@ export declare class AdwSplitButton extends GridLayout {
     set dropdownTooltip(value: string);
     /** Whether an underline in the label marks a mnemonic. */
     get useUnderline(): boolean;
-    set useUnderline(value: boolean);
+    set useUnderline(raw: boolean | string);
     /** Whether the control is insensitive: dimmed, and emitting neither signal. */
     get disabled(): boolean;
-    set disabled(value: boolean);
+    set disabled(raw: boolean | string);
     /** The main action part (for composing a custom content widget). */
     get actionButton(): StackLayout;
 }

package/lib/types/widgets/adw-status-page.d.ts

@@ -46,4 +46,11 @@ export declare class AdwStatusPage extends GridLayout {
     setChild(view: View | null): void;
     /** The currently-installed child, or `null`. */
     get child(): View | null;
+    /**
+     * The one destination an XML child can have: the slot under the description,
+     * where `AdwStatusPage:child` goes. The name is ignored because
+     * `<AdwStatusPage.child>` and a bare child mean the same thing — the shape
+     * `AdwClamp` already has.
+     */
+    _addChildFromBuilder(_name: string, view: View): void;
 }

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

@@ -15,7 +15,7 @@ export declare class AdwSwitchRow extends AdwActionRow {
     constructor();
     /** Whether the switch is on. */
     get active(): boolean;
-    set active(value: boolean);
+    set active(value: boolean | string);
     /**
      * The row was tapped — invert the state, then emit `activated` like any
      * other action row (adw-switch-row.c:23-27 via the activatable widget).

package/lib/types/widgets/adw-tab-view.d.ts

@@ -55,7 +55,7 @@ export declare class AdwTabView extends GridLayout {
     get selectedIndex(): number;
     /** The selected page index. Setting it IGNORES a non-integer or out-of-range value. */
     get selected(): number;
-    set selected(value: number);
+    set selected(raw: number | string);
     isClosing(id: string): boolean;
     setSelectedPage(id: string | null): boolean;
     selectNthPage(n: number): boolean;
@@ -103,7 +103,7 @@ export declare class AdwTabView extends GridLayout {
      * visible before this lift stays visible unless asked otherwise.
      */
     get autohide(): boolean;
-    set autohide(value: boolean);
+    set autohide(raw: boolean | string);
     /** `Adw.TabView:default-icon` — what a PINNED page with no icon of its own shows. */
     get defaultIcon(): string | null;
     set defaultIcon(value: string | null);

package/lib/types/widgets/adw-toggle-group.d.ts

@@ -30,7 +30,7 @@ export declare class AdwToggleGroup extends StackLayout {
     private _applySelection;
     /** The selected segment index. Swaps the active pill + emits `notify::selected`. */
     get selected(): number;
-    set selected(value: number);
+    set selected(raw: number | string);
     /** The selected segment's label, or `''` when out of range. */
     get selectedValue(): string;
 }

package/lib/types/widgets/adw-toolbar-view.d.ts

@@ -20,6 +20,16 @@ export declare class AdwToolbarView extends GridLayout {
     addBottomBar(view: View): void;
     /** Set (or replace) the main content view. Pass `null` to clear it. */
     setContent(view: View | null): void;
+    /**
+     * XML inflation — route a template's child through the slot API.
+     *
+     * `<AdwToolbarView.topBar>` / `.bottomBar` / `.content` arrive here as those
+     * names; anything else (a bare child) is the content, which is the one slot a
+     * toolbar view cannot do without. Without this the `GridLayout` default put
+     * every child in row 0: measured on Android, a top bar and the content were
+     * painted ON TOP OF EACH OTHER in the bar row while row 1 stayed empty.
+     */
+    _addChildFromBuilder(name: string, view: View): void;
     /** The currently-installed content view, or `null`. */
     get content(): View | null;
     /** The top-bar slot container. */
@@ -34,10 +44,10 @@ export declare class AdwToolbarView extends GridLayout {
     set bottomBarStyle(value: AdwToolbarStyle);
     /** `Adw.ToolbarView:extend-content-to-top-edge` — draw the top bar OVER the content. */
     get extendContentToTopEdge(): boolean;
-    set extendContentToTopEdge(value: boolean);
+    set extendContentToTopEdge(raw: boolean | string);
     /** `Adw.ToolbarView:extend-content-to-bottom-edge` — draw the bottom bar OVER the content. */
     get extendContentToBottomEdge(): boolean;
-    set extendContentToBottomEdge(value: boolean);
+    set extendContentToBottomEdge(raw: boolean | string);
     /**
      * Put each bar box in its own row, or — when the content extends under it —
      * in the CONTENT row pinned to that edge, which is how an NS `GridLayout`
@@ -54,7 +64,14 @@ export declare class AdwToolbarView extends GridLayout {
      */
     private _restackBars;
     /**
-     * Pay each edge's inset out of the slot that sits on it.
+     * Pay each edge's inset out of the slot that sits on it — the part of it this
+     * widget still owes.
+     *
+     * `insetsOwedBy` drops what the HOST already paid, which on Android is the bottom
+     * edge (the page's `LayoutBase`, because only its branch also folds in the keyboard)
+     * and never the top (`host-insets.android.ts` hands that edge back, because only the
+     * top-bar box paints it in the header colour). Without it the inset was applied
+     * twice: 142 px + 142 px above the header bar on emulator-5554.
      *
      * The assignment is decided by the pure sibling (`toolbarViewInsetPadding`); this
      * only spells it in NativeScript. Where that module says "the content pays", the

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

@@ -40,7 +40,7 @@ export declare class AdwViewStack extends GridLayout {
     get pages(): readonly AdwViewStackPage[];
     /** The visible page index, `-1` when nothing is selected. Swaps the visible page + emits. */
     get visibleChildIndex(): number;
-    set visibleChildIndex(value: number);
+    set visibleChildIndex(raw: number | string);
     /** The visible page name (`Adw.ViewStack.visible-child-name`), `''` for none. */
     get visibleChildName(): string;
     set visibleChildName(name: string | null | undefined);

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

@@ -19,7 +19,7 @@ export declare class AdwViewSwitcherBar extends GridLayout {
      * where a header-bar `AdwViewSwitcher` takes over.
      */
     get reveal(): boolean;
-    set reveal(value: boolean);
+    set reveal(raw: boolean | string);
     /**
      * Whether the bar is actually shown. READ-ONLY: a one-page stack keeps it
      * collapsed however loudly the layout asks (adw-view-switcher-bar.c:125).

package/lib/types/widgets/adw-wrap-box.d.ts

@@ -47,31 +47,31 @@ export declare class AdwWrapBox extends FlexboxLayout {
     private _applyOrder;
     /** Gap between items in a line, in {@link childSpacingUnit}. Defaults to 0, as in C. */
     get childSpacing(): number;
-    set childSpacing(value: number);
+    set childSpacing(value: number | string);
     /** The unit {@link childSpacing} is written in. Defaults to `px`, as in C. */
     get childSpacingUnit(): AdwLengthUnit;
     set childSpacingUnit(value: AdwLengthUnit);
     /** Gap between wrapped lines, in {@link lineSpacingUnit}. Defaults to 0, as in C. */
     get lineSpacing(): number;
-    set lineSpacing(value: number);
+    set lineSpacing(value: number | string);
     /** The unit {@link lineSpacing} is written in. Defaults to `px`, as in C. */
     get lineSpacingUnit(): AdwLengthUnit;
     set lineSpacingUnit(value: AdwLengthUnit);
     /** Where the children sit ALONG the line (main axis): 0 start, 0.5 middle, 1 end. */
     get align(): number;
-    set align(value: number);
+    set align(raw: number | string);
     /** Whether and how each line is stretched to fill the widget. */
     get justify(): AdwWrapBoxJustify;
     set justify(value: AdwWrapBoxJustify);
     /** Whether the FINAL line is justified too. Default false, as in C. */
     get justifyLastLine(): boolean;
-    set justifyLastLine(value: boolean);
+    set justifyLastLine(raw: boolean | string);
     /** Whether every line takes the same amount of space. */
     get lineHomogeneous(): boolean;
-    set lineHomogeneous(value: boolean);
+    set lineHomogeneous(raw: boolean | string);
     /** Whether lines wrap upwards (horizontal) / towards the start (vertical). */
     get wrapReverse(): boolean;
-    set wrapReverse(value: boolean);
+    set wrapReverse(raw: boolean | string);
     /** Whether an overflowing line squeezes its children or lets them spill. */
     get wrapPolicy(): AdwWrapPolicy;
     set wrapPolicy(value: AdwWrapPolicy);
@@ -88,7 +88,7 @@ export declare class AdwWrapBox extends FlexboxLayout {
      * maximum-size property to cap a line with.
      */
     get naturalLineLength(): number;
-    set naturalLineLength(value: number);
+    set naturalLineLength(raw: number | string);
     /** The unit {@link naturalLineLength} is written in. Defaults to `px`, as in C. */
     get naturalLineLengthUnit(): AdwLengthUnit;
     set naturalLineLengthUnit(value: AdwLengthUnit);

package/lib/types/widgets/builder-slots.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The slot an XML child asks for, or `fallback` when it asks for nothing this
+ * widget knows.
+ *
+ * `slots` are the widget's own property names, because that is what NativeScript's
+ * complex-property syntax spells: `<AdwToolbarView.topBar>` reaches
+ * `_addChildFromBuilder('topBar', …)`. A bare `<AdwHeaderBar>` child arrives under
+ * its ELEMENT name instead, which is never a slot name and so takes the fallback —
+ * the same shape as GtkBuildable's untyped `<child>`.
+ *
+ * A dotted `name` is reduced to its last segment first. NativeScript already does
+ * that before it calls us, but a caller that does not is the difference between
+ * "no slot" and "the wrong slot", and this returns the answer to a question about
+ * a widget's own tree.
+ */
+export declare function resolveBuilderSlot<Slot extends string, Fallback extends string>(name: unknown, slots: readonly Slot[], fallback: Fallback): Slot | Fallback;

package/lib/types/widgets/host-insets.android.d.ts

@@ -0,0 +1,4 @@
+import type { View } from '@nativescript/core';
+import { type HostPaidEdges, type WindowInsets } from './window-insets.js';
+/** Settle which window-inset edges `view` still owes. See {@link resolveHostInsets}. */
+export declare function resolveHostInsets(view: View, insets: WindowInsets): HostPaidEdges;

package/lib/types/widgets/host-insets.d.ts

@@ -0,0 +1,13 @@
+import type { View } from '@nativescript/core';
+import { type HostPaidEdges, type WindowInsets } from './window-insets.js';
+/**
+ * Settle which window-inset edges `view` still owes, adjusting the host where the
+ * widget paints an edge better than the host can.
+ *
+ * Takes the READING as well as the view, and is called on every inset application
+ * rather than once at `loaded`, because an Android variant that hands an edge back to
+ * the host must not do so before it holds a reading to pay that edge with. Idempotent:
+ * a page with two toolbar views resolves twice, and a view re-attached to another page
+ * resolves again.
+ */
+export declare function resolveHostInsets(_view: View, _insets: WindowInsets): HostPaidEdges;

package/lib/types/widgets/host-insets.ios.d.ts

@@ -0,0 +1,4 @@
+import type { View } from '@nativescript/core';
+import { type HostPaidEdges, type WindowInsets } from './window-insets.js';
+/** Settle which window-inset edges `view` still owes. See {@link resolveHostInsets}. */
+export declare function resolveHostInsets(_view: View, _insets: WindowInsets): HostPaidEdges;

package/lib/types/widgets/icon-path.d.ts

@@ -8,20 +8,74 @@ export interface SymbolicIconOptions {
     /** Fill colour as a hex string (`#RRGGBB` / `#AARRGGBB`). Default = light fg. */
     color?: string;
 }
-/** One fillable path of a symbolic icon: its path data + its own fill opacity. */
+/**
+ * A 2D affine transform in SVG's own `matrix(a b c d e f)` order.
+ *
+ * `[a c e; b d f; 0 0 1]` — the same six numbers `android.graphics.Matrix.setValues`
+ * and `CGAffineTransformMake` take, so neither renderer has to convert anything.
+ */
+export type IconTransform = readonly [number, number, number, number, number, number];
+/** The identity — nothing to apply. */
+export declare const IDENTITY_TRANSFORM: IconTransform;
+/** One fillable path of a symbolic icon. */
 export interface IconPath {
     /** SVG `d` path data (the `androidx` `PathParser` `pathData` grammar). */
     d: string;
     /** Per-path fill opacity in [0, 1] — Adwaita dims accent sub-shapes (e.g. the
      *  filled panel of `sidebar-show`); defaults to 1 when the path has none. */
     opacity: number;
+    /**
+     * This path's own `transform`, composed under every enclosing `<g transform=…>`.
+     *
+     * {@link IDENTITY_TRANSFORM} for the icons that need none. NOT optional: an
+     * optional field is one a renderer forgets to read, and forgetting it is exactly
+     * the defect this exists to fix.
+     */
+    transform: IconTransform;
+    /**
+     * `fill-rule` — `evenodd`, or `nonzero` (SVG's initial value) when unset.
+     *
+     * Neither renderer set one, so both drew the platform default and every icon
+     * declaring `evenodd` filled a hole it should have carved.
+     */
+    fillRule: 'nonzero' | 'evenodd';
+    /**
+     * The path's own `fill`, when it names a colour instead of inheriting one.
+     *
+     * `null` means "use the caller's colour" — the symbolic case, and the common one.
+     * A shipped icon that hardcodes `#ed333b` for a critical battery is NOT symbolic,
+     * and drawing it in one colour is what turned a red battery grey. The icon
+     * generator rewrites the four neutral greys to `currentColor`, so anything still
+     * literal here was meant to be literal.
+     */
+    fill: string | null;
 }
 /**
- * Extract every fillable `<path>` of a symbolic SVG as `{ d, opacity }`. Each path
- * must be drawn SEPARATELY (not concatenated): Adwaita icons frequently pair a
- * solid outline with a dimmed (`fill-opacity`) inner shape, and a single path's
- * subpaths carve holes via the non-zero winding rule — flattening all paths into
- * one fill destroys both. Returns `[]` when the SVG carries no path data.
+ * Parse an SVG `transform` attribute into one affine matrix.
+ *
+ * The whole grammar, not the two functions the shipped icons happen to use
+ * (`translate` 33×, `matrix` 9×): SVG's transform list is exactly matrix / translate /
+ * scale / rotate / skewX / skewY, all affine, and supporting five of six would sit
+ * silently wrong the first time an icon set grows the sixth. Returns `null` for a
+ * string it cannot read, which a caller must treat as a refusal rather than as
+ * identity — quietly dropping a transform is the failure being repaired here.
+ */
+export declare function parseIconTransform(value: string): IconTransform | null;
+/**
+ * Extract every fillable `<path>` of a symbolic SVG.
+ *
+ * Each path must be drawn SEPARATELY (not concatenated): Adwaita icons frequently pair
+ * a solid outline with a dimmed (`fill-opacity`) inner shape, and a single path's
+ * subpaths carve holes via the winding rule — flattening all paths into one fill
+ * destroys both. Returns `[]` when the SVG carries no path data.
+ *
+ * WHY THIS WALKS `<g>` AND NOT JUST `<path>`. It used to be one regex over `<path>`
+ * tags, and the geometry of a grouped icon is authored in the group's coordinate space:
+ * icons whose paths live at x≈684, y≈180 under a `translate(-680,-180)` were extracted
+ * with the translate dropped, scaled by `size/16`, and drawn onto a 16×16 bitmap that
+ * their geometry misses entirely. Measured before this change: 12 shipped icons —
+ * eleven `battery-level-*-charging` and one parental-controls glyph — rendered
+ * COMPLETELY EMPTY on NativeScript, with no diagnostic anywhere.
  */
 export declare function extractIconPaths(svg: string): IconPath[];
 /**
@@ -48,9 +102,20 @@ export interface IconColorComponents {
  * two backends must read the same string the same way.
  *
  * Returns opaque black for anything unparsable, so a typo in a caller's colour
- * yields a visible icon rather than an invisible one.
+ * yields a visible icon rather than an invisible one. Where the caller has a better
+ * fallback than black — a path's own `fill`, which should fall back to the icon
+ * colour rather than to black — use {@link parseHexColorOrNull}.
  */
 export declare function parseHexColor(hex: string): IconColorComponents;
+/**
+ * {@link parseHexColor} without the black fallback: `null` says "not a colour I read".
+ *
+ * Two callers want different answers to the same failure. A caller's own
+ * `options.color` has no better candidate than black — an invisible icon is worse
+ * than a wrong-coloured one. A path's `fill` does: the icon colour the caller passed
+ * in. Folding both into one black default made the second silently draw black.
+ */
+export declare function parseHexColorOrNull(hex: string): IconColorComponents | null;
 /**
  * Space-separate the two single-digit ARC FLAGS (large-arc, sweep) in every
  * elliptical-arc command (`A`/`a`) of an SVG path-data string.

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

@@ -90,12 +90,19 @@ export type { AdwColorScheme } from './color-scheme.js';
 export { AdwBreakpoint, addBreakpoints, evaluateBreakpointCondition, parseBreakpointCondition } from './breakpoint.js';
 export type { AdwBreakpointHandlers, BreakpointBound, BreakpointConditionGroup, BreakpointConditionLeaf, BreakpointConditionNode, BreakpointDimension, BreakpointSize, } from './breakpoint.js';
 /**
- * Register all Adwaita widgets as NativeScript XML elements (idempotent).
+ * Register all Adwaita widgets as UNPREFIXED NativeScript XML elements, where a
+ * framework integration provides the `registerElement` global (idempotent).
  *
- * After calling this once at app bootstrap, markup like
- * `<AdwSwitchRow title="Dark mode" />` resolves to the corresponding class.
- * No-op (returns silently) when the `registerElement` runtime global is absent
- * — i.e. off NativeScript, or when the bundler context has not injected it yet —
- * so the call is safe to make unconditionally.
+ * That global is NOT part of NativeScript itself: `@nativescript/core` 9.1 does
+ * not contain the identifier at all, and it is `undefined` in a plain app built
+ * with `@nativescript/vite` — measured on an Android emulator, 2026-08-28, where
+ * this function therefore returned silently and `<AdwSwitchRow>` resolved to
+ * nothing. It comes from `@nativescript/angular` / `nativescript-vue`, which is
+ * where this call earns its keep; a plain XML app uses the `xmlns` barrel above
+ * instead and needs no registration at all.
+ *
+ * The no-op is the safe branch of that split, not a fallback: it is why the call
+ * can be made unconditionally, and why it must never be the only thing an app
+ * does before writing `<AdwSwitchRow>` in markup.
  */
 export declare function registerAdwaitaElements(): void;

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

@@ -78,6 +78,15 @@ export declare abstract class AdwSplitViewBase<TState extends NsSplitViewState =
     setSidebar(view: View | null): void;
     /** Set (or replace) the content pane. */
     setContent(view: View | null): void;
+    /**
+     * An XML child asks for `sidebar` or `content`, and a bare one is CONTENT.
+     *
+     * The fallback follows the widget's own collapsed behaviour: a lone child stays
+     * visible whatever `show-content` says, so the pane a template gives without
+     * naming one is the one a reader will see. Without this override, `LayoutBase`'s
+     * default drops both panes into column 0 of the grid, stacked.
+     */
+    _addChildFromBuilder(name: string, view: View): void;
     /** Show the sidebar (relevant in collapsed mode). */
     showSidebarPane(): void;
     /** Hide the sidebar (relevant in collapsed mode). */
@@ -90,26 +99,26 @@ export declare abstract class AdwSplitViewBase<TState extends NsSplitViewState =
      * `notify::show-sidebar` first — the state machine owns that, not this setter.
      */
     get collapsed(): boolean;
-    set collapsed(value: boolean);
+    set collapsed(raw: boolean | string);
     /** Whether the sidebar is shown. Toggling emits `notify::show-sidebar`. */
     get showSidebar(): boolean;
-    set showSidebar(value: boolean);
+    set showSidebar(raw: boolean | string);
     /**
      * The sidebar pane width in DIPs, DERIVED from the container size unless a caller
      * assigned one — `Adw.OverlaySplitView` stores no width; see
      * `split-view-width.ts` for the rule.
      */
     get sidebarWidth(): number;
-    set sidebarWidth(value: number);
+    set sidebarWidth(raw: number | string);
     /** Lower bound in DIPs (`Adw.OverlaySplitView:min-sidebar-width`, default 180). */
     get minSidebarWidth(): number;
-    set minSidebarWidth(value: number);
+    set minSidebarWidth(raw: number | string);
     /** Upper bound in DIPs (`Adw.OverlaySplitView:max-sidebar-width`, default 280). */
     get maxSidebarWidth(): number;
-    set maxSidebarWidth(value: number);
+    set maxSidebarWidth(raw: number | string);
     /** Share of the container the sidebar asks for (default 0.25). */
     get sidebarWidthFraction(): number;
-    set sidebarWidthFraction(value: number);
+    set sidebarWidthFraction(raw: number | string);
     /**
      * Re-measure the container and re-size the sidebar.
      *

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

@@ -74,7 +74,7 @@ export declare abstract class AdwViewSwitcherBase extends GridLayout {
      * NO-OPS — refused, never clamped, as `adw_view_stack_pages_select_item` does.
      */
     get selected(): number;
-    set selected(value: number);
+    set selected(raw: number | string);
     /** Name of the selected page, `''` when nothing is selected. */
     get selectedName(): string;
     /**

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

@@ -18,6 +18,30 @@ export interface InsetPadding {
     readonly contentBottom: number;
 }
 export declare const NO_INSETS: WindowInsets;
+/**
+ * The edges a HOST layout already pays, so the widget must not pay them again.
+ *
+ * Declared here rather than beside the platform files that answer it, so this module
+ * stays the one place the inset arithmetic lives and keeps importing nothing.
+ */
+export interface HostPaidEdges {
+    readonly top: boolean;
+    readonly bottom: boolean;
+}
+/** Nothing above the widget pays anything — it owes every edge. */
+export declare const NO_HOST_PAYMENT: HostPaidEdges;
+/**
+ * Drop the edges a host layout already paid, leaving what the widget still owes.
+ *
+ * Separate from {@link toolbarViewInsetPadding} because it answers a different question:
+ * that one splits an owed inset between the slots of ONE widget, this one decides
+ * whether the inset is owed at all. Which edges a host pays is a per-platform fact
+ * (`host-insets.{android,ios}.ts`); how much of it lands on which slot is not.
+ *
+ * Left and right pass through: no host in this tree pays them, and dropping an edge
+ * nobody paid is how an inset silently goes missing.
+ */
+export declare function insetsOwedBy(insets: WindowInsets, paidByHost: HostPaidEdges): WindowInsets;
 /**
  * Assign `insets` to the slots of a toolbar view of `shape`.
  *

package/lib/types/widgets/xml-values.d.ts

@@ -0,0 +1,18 @@
+/**
+ * An attribute as a finite number, or `fallback` when it is not one.
+ *
+ * A string is trimmed and parsed; empty is NOT zero (`Number('')` is 0, which is how
+ * a missing value becomes a real setting). `NaN` and `Infinity` are refused, so a
+ * caller can keep validating a RANGE without also having to re-check the type.
+ */
+export declare function xmlNumber(value: unknown, fallback: number): number;
+/**
+ * An attribute as a boolean.
+ *
+ * Only the two spellings XML can mean are accepted — anything else takes the
+ * `fallback` rather than the truthiness of the string, because truthiness is exactly
+ * what made `revealed="false"` reveal. `'True'`/`'FALSE'` are accepted too: XML
+ * attribute VALUES are not case-normalised by any parser, and a template that means
+ * one of the two booleans should not depend on which case its author typed.
+ */
+export declare function xmlBoolean(value: unknown, fallback: boolean): boolean;