@gjsify/adwaita-nativescript 0.48.0 → 0.50.0

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

@@ -1,8 +1,20 @@
 import { FlexboxLayout, type View } from '@nativescript/core';
 import { type AdwLengthUnit, type AdwWrapBoxJustify, type AdwWrapBoxOrientation, type AdwWrapBoxPackDirection, type AdwWrapPolicy } from '@gjsify/adwaita-core';
+import { type ConstructProps } from './construct-props.js';
 /** Every `notify::` an `Adw.WrapBox` emits (adw-wrap-box.c:284-497). */
 export type AdwWrapBoxProperty = 'child-spacing' | 'child-spacing-unit' | 'pack-direction' | 'align' | 'justify' | 'justify-last-line' | 'line-spacing' | 'line-spacing-unit' | 'line-homogeneous' | 'natural-line-length' | 'natural-line-length-unit' | 'wrap-reverse' | 'wrap-policy' | 'orientation';
-export declare class AdwWrapBox extends FlexboxLayout {
+declare const AdwWrapBox_base: (abstract new (...args: any[]) => {
+    connect(eventName: string, callback: (self: /*elided*/ any, data: import("@nativescript/core").EventData) => void): number;
+    disconnect(handlerId: number): void;
+    _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 FlexboxLayout;
+export declare class AdwWrapBox extends AdwWrapBox_base {
     private _childSpacing;
     private _lineSpacing;
     private _childSpacingUnit;
@@ -17,17 +29,17 @@ export declare class AdwWrapBox extends FlexboxLayout {
     private _orientation;
     private _naturalLineLength;
     private _naturalLineLengthUnit;
-    constructor();
+    constructor(props?: ConstructProps<AdwWrapBox>);
     /** Append a child — `adw_wrap_box_append` (adw-wrap-box.c:1344-1352). */
-    add(view: View): void;
+    append(view: View): void;
     /** Remove a previously-added child — `adw_wrap_box_remove` (:1387-1395). */
     remove(view: View): void;
     /** `adw_wrap_box_remove_all` (:1406-1414). */
-    removeAll(): void;
+    remove_all(): void;
     /**
-     * Every path a child can enter by — `add()`, a direct `addChild()`, and XML
+     * Every path a child can enter by — `append()`, a direct `addChild()`, and XML
      * inflation via `_addChildFromBuilder` — ends here, which is why the spacing
-     * is applied here and not in `add()`. It used to be applied in `add()` only,
+     * is applied here and not in `append()`. It used to be applied in `append()` only,
      * so a child declared in markup got no spacing at all; C routes GtkBuildable's
      * `add_child` through the same append for the same reason.
      */
@@ -40,9 +52,9 @@ export declare class AdwWrapBox extends FlexboxLayout {
      * `WRAP_BOX_CHILD_ORDER_VECTORS`. Returns whether the insert happened; a
      * refusal is where C would have hit a `g_return_if_fail`.
      */
-    insertChildAfter(view: View, sibling?: View | null): boolean;
+    insert_child_after(view: View, sibling?: View | null): boolean;
     /** `adw_wrap_box_reorder_child_after` (:1315-1332). Same NULL rule. */
-    reorderChildAfter(view: View, sibling?: View | null): boolean;
+    reorder_child_after(view: View, sibling?: View | null): boolean;
     private _childViews;
     private _applyOrder;
     /** Gap between items in a line, in {@link childSpacingUnit}. Defaults to 0, as in C. */
@@ -101,3 +113,4 @@ export declare class AdwWrapBox extends FlexboxLayout {
     private _applyLayout;
     private _applyChildren;
 }
+export {};

package/lib/types/widgets/avatar-view.d.ts

@@ -0,0 +1,57 @@
+import { type AdwAvatarMode } from '@gjsify/adwaita-core';
+import { type NsVisibility } from './row-state.js';
+export type { AdwAvatarMode };
+/** The fallback icon NAME, exported because it is a SUBSTITUTION a caller can see. */
+export declare const AVATAR_DEFAULT_ICON = "avatar-default-symbolic";
+/**
+ * `update_icon`: the caller's icon, or the default when none was set.
+ *
+ * The emptiness test is the port's, not the C's — C keys on `icon_name != NULL`, and a
+ * NativeScript setter has no null to tell from `''`. Same reading `AdwStatusPage` takes.
+ */
+export declare function avatarIcon(iconName: string | null | undefined): string;
+/** Which of the avatar's two NativeScript children is in the layout. */
+export interface AvatarVisibilities {
+    /** The initials label. */
+    label: NsVisibility;
+    /** The fallback symbolic icon. */
+    icon: NsVisibility;
+}
+/**
+ * The two `visibility` values for a mode, straight off `update_visibility`'s three
+ * `gtk_widget_set_visible` calls (refs/libadwaita/src/adw-avatar.c:122-123#has_custom_image).
+ *
+ * `'image'` is REACHABLE and shows NEITHER child, rather than being folded into `'icon'`:
+ * a function that cannot express the third mode is how the web element shipped a
+ * `hasCustomImage: false` no vector could falsify.
+ */
+export declare function avatarVisibilities(mode: AdwAvatarMode): AvatarVisibilities;
+/** What `AdwAvatar` sets on its two children for a given property state. */
+export interface AvatarViewState extends AvatarVisibilities {
+    /** The mode `update_visibility` picked. */
+    mode: AdwAvatarMode;
+    /**
+     * The icon the icon child renders — the default when the caller set none.
+     *
+     * NOT `icon`: {@link AvatarVisibilities} already owns that key for the child's
+     * `visibility`, and one interface cannot hold both.
+     */
+    iconName: string;
+}
+/**
+ * The WHOLE decision `AdwAvatar` makes, so that a spec can drive it.
+ *
+ * It lives here for a reason a mutation showed: `extends GridLayout` puts the class out of
+ * reach of every unit test in this package, so anything decided inside it is
+ * unfalsifiable — the fallback was reverted to "always initials" in the widget body and
+ * the whole suite, plus every gate that reads this tree, stayed green. What is left
+ * unreachable is three assignments; no test here closes that.
+ *
+ * `hasCustomImage` is hard `false` because the port has no `custom-image` counterpart
+ * (status/open-todos.md); when it lands, only this argument changes.
+ */
+export declare function avatarViewState(input: {
+    showInitials: boolean;
+    text: string;
+    iconName: string;
+}): AvatarViewState;

package/lib/types/widgets/bottom-sheet-state.d.ts

@@ -63,7 +63,7 @@ export declare function requestBottomSheetClose(state: BottomSheetPresentation,
  * libadwaita never writes to the child's own style classes — the marker lives on
  * the internal bin (`adw_bottom_sheet_set_content`, adw-bottom-sheet.c:1497-1510).
  * This port does write it, and used to do so with a bare string concat, so
- * `setContent(v)` twice left `'adw-bottom-sheet-content adw-bottom-sheet-content'`.
+ * `set_content(v)` twice left `'adw-bottom-sheet-content adw-bottom-sheet-content'`.
  */
 export declare function addMarkerClass(className: string | null | undefined, marker: string): string;
 /**

package/lib/types/widgets/box-layout.d.ts

@@ -0,0 +1,39 @@
+import { resolveWrapBoxChildOrder } from '@gjsify/adwaita-core';
+/**
+ * `Gtk.Box:spacing`'s default, in DIPs. `0` in C (`gtkbox.c`, the property's default
+ * value), which is also what makes the margin write invisible until a caller asks.
+ */
+export declare const DEFAULT_BOX_SPACING = 0;
+/** Which axis a box stacks along — NativeScript's two words, and `Gtk.Orientation`'s nicks. */
+export type BoxOrientation = 'horizontal' | 'vertical';
+/**
+ * A spacing value as the box will hold it: a finite, non-negative number of DIPs.
+ *
+ * `gtk_box_set_spacing` takes an `int` and the property's minimum is 0, so a negative
+ * value is clamped rather than refused — the same clamp `normalizeWrapBoxSpacing` applies
+ * one widget over, restated here because that one carries the wrap box's UNIT machinery
+ * (`Adw.LengthUnit`) and a `Gtk.Box` has no unit to convert from.
+ */
+export declare function normalizeBoxSpacing(value: unknown): number;
+/** Whether writing `next` over `current` is a change the box must push to its children. */
+export declare function boxSpacingChanges(current: number, next: unknown): boolean;
+/**
+ * The margin shorthand that gives child `index` its share of the box's gap.
+ *
+ * `top right bottom left`, NativeScript's own order. The first child gets none: with N
+ * children there are N−1 gaps, and putting the gap on the LEADING edge of every child but
+ * the first is the only distribution that leaves the box's own bounds untouched.
+ */
+export declare function boxChildMargin(index: number, spacing: unknown, orientation: BoxOrientation): string;
+/**
+ * Where the child list ends up after an `insert_child_after` / `reorder_child_after`, or
+ * `null` where C would have hit a `g_return_if_fail`.
+ *
+ * SHARED WITH THE WRAP BOX RATHER THAN COPIED, and the name is the wrap box's only
+ * because that widget needed it first: the rule is `gtk_widget_insert_after`'s — a NULL
+ * sibling means the FIRST position, not the last — and `gtk_box_insert_child_after`
+ * documents itself by pointing at it. `resolveWrapBoxChildOrder` is generic over the
+ * child type and pure, so the alternative was a second copy of one paragraph of GTK
+ * semantics that could drift from the vectors already pinning it.
+ */
+export { resolveWrapBoxChildOrder as resolveBoxChildOrder };

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

@@ -5,17 +5,17 @@ export type { ButtonContentEllipsize };
 /** The class the content carries while `can-shrink` is set, for the theme to key off. */
 export declare const BUTTON_CONTENT_CAN_SHRINK_CLASS = "can-shrink";
 /**
- * The SVG the icon view is given: the app's, or the `image-missing` asset for an
- * empty slot — the fallback `init` applies too, while `icon_name` is still `""`.
+ * The icon the icon view is given: the app's, or the `image-missing` NAME for an empty
+ * slot — the fallback `init` applies too, while `icon_name` is still `""`.
  *
  * The C NEVER hides the image, only the label, so this port keeps the icon view
  * parented at all times and swaps its source. Upstream's own doc comments claim the
  * icon is hidden instead; the code disagrees with them and this follows the code
  * (see the conformance vector's `rule`).
  */
-export declare function buttonContentIconSvg(svg: string): string;
+export declare function buttonContentIcon(icon: string): string;
 /** Whether the icon shown is the empty-slot fallback rather than an app asset. */
-export declare function buttonContentIconIsFallback(svg: string): boolean;
+export declare function buttonContentIconIsFallback(icon: string): boolean;
 /**
  * The parent button's `className` with `image-text-button` added — the root-time half
  * of `adw_button_content_root`. Adds rather than rewrites, so a caller's composed

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

@@ -0,0 +1,16 @@
+/** The slot a `Gtk.Button` currently shows. `empty` is a button with no child at all. */
+export type ButtonSlot = 'label' | 'icon' | 'child' | 'empty';
+/** Which property was written. */
+export type ButtonSlotWrite = 'label' | 'icon' | 'child';
+/**
+ * The slot a button shows after `wrote` was assigned `value`.
+ *
+ * AN EMPTY LABEL IS STILL THE LABEL SLOT, and an empty icon name is still the icon slot:
+ * `gtk_button_set_label("")` leaves a `GtkLabel` in the child, showing nothing — the
+ * button is not childless, it has an empty label. Only `set_child(NULL)` empties it, which
+ * is the one write that can return `empty`. Reading `''` as "clear the button" would make
+ * a caller who blanks a label lose the padding the child was holding.
+ */
+export declare function buttonSlotAfterWrite(wrote: ButtonSlotWrite, value: unknown): ButtonSlot;
+/** Whether moving from `from` to `to` has to detach the view `from` had parented. */
+export declare function buttonSlotDetaches(from: ButtonSlot, to: ButtonSlot): boolean;

package/lib/types/widgets/construct-props.d.ts

@@ -0,0 +1,102 @@
+/**
+ * The keys a widget's construct-props bag accepts, derived from the widget itself.
+ *
+ * Methods are dropped; everything else a caller could assign stays, its type read off the
+ * GETTER (so `size?: number` even though `set size(value: number | string)` also takes the
+ * string XML hands over — the bag is the TypeScript door, the attribute is the string one).
+ *
+ * A read-only accessor survives this type and is refused at RUNTIME instead. The
+ * `readonly`-detecting mapped type that would have caught `parent` at compile time was
+ * measured to drop `size` as well — a getter/setter pair with different types does not
+ * compare equal under it — and a type that silently loses real properties is worse than
+ * one that admits two impossible ones and says so when they arrive.
+ */
+export type ConstructProps<T> = Partial<{
+    [K in keyof T as T[K] extends (...args: never[]) => unknown ? never : K]: K extends EnumProp ? T[K] | number : T[K];
+}>;
+/**
+ * Every key this bag reads as a GIR ENUM, so `| number` is admitted for exactly those and
+ * nowhere else. ADR 0034 § 4's second spelling: a nick is what an XML attribute can carry,
+ * and the constant is what a snippet ported off GJS carries.
+ */
+export type EnumProp = AlignmentProp | IconSizeProp;
+/**
+ * The NativeScript properties whose value this package reads as a `Gtk.Align`.
+ *
+ * `horizontalAlignment` and `verticalAlignment` are NativeScript's own — declared by
+ * `View`, never re-declared by a widget here — so this is a WIDENING of what they accept
+ * and not a second vocabulary: every NativeScript spelling passes through untouched, and
+ * only the GTK-side ones are translated.
+ *
+ * WHERE THIS DOOR AND THE ATTRIBUTE DOOR DISAGREE, exactly. NativeScript's `verticalAlignment`
+ * is `'top' | 'middle' | 'bottom' | 'stretch'`, and its layout pass sends anything else to the
+ * `default:` arm, which is `stretch`
+ * (`ui/core/view/view-helper/view-helper-common.ts`, both platforms). So the three GTK
+ * spellings this table TRANSLATES on that axis — `center`, `start`, `end` — reach the widget
+ * as `middle`/`top`/`bottom` through the bag and as themselves through
+ * `<adw:Avatar verticalAlignment="center">`, where they silently stretch. The horizontal axis
+ * has no such gap: `start`, `end` and `center` are NativeScript's own words, and `fill` maps
+ * to `stretch`, which is also what the `default:` arm does with it. Nothing here closes the
+ * vertical three — the attribute door has no coercer to hang this on and a per-widget
+ * `set verticalAlignment` would shadow `View`'s, which is the hazard arm 2 of
+ * `check-nativescript-xml-doors.mjs` exists for — so it is a declared divergence and the same
+ * § 1 convergence question ADR 0034 § Amendment 12 leaves open for `halign` / `valign`.
+ */
+declare const ALIGNMENT_AXES: {
+    readonly horizontalAlignment: "horizontal";
+    readonly verticalAlignment: "vertical";
+};
+/**
+ * The keys the bag reads as a `Gtk.Align` — the runtime table's OWN key set, so the type
+ * cannot admit one the applier does not translate or refuse one it does.
+ *
+ * {@link ConstructProps} widens exactly these to `| number`. Without it the constant spelling
+ * was reachable at runtime and refused by the compiler: `new AdwAvatar({ horizontalAlignment:
+ * Gtk.Align.CENTER })` was `TS2322: Type 'number' is not assignable to type 'string'`, which
+ * is the one caller the second spelling exists for.
+ */
+export type AlignmentProp = keyof typeof ALIGNMENT_AXES;
+/**
+ * The keys the bag reads as a `Gtk.IconSize` — the port's OWN property, unlike the two
+ * alignment axes, which are NativeScript's.
+ *
+ * A table of one, and it is a table for the same reason `ALIGNMENT_AXES` is: the runtime key
+ * set and the type widening are derived from ONE declaration, so the type cannot admit a key
+ * the applier does not coerce, nor refuse one it does. `GtkImage` and `AdwImageButton` both
+ * spell it `iconSize` (#1584), and no other widget on this surface has a key of that name.
+ */
+declare const ICON_SIZE_PROPS: {
+    readonly iconSize: true;
+};
+/** The keys {@link ICON_SIZE_PROPS} declares — {@link ConstructProps} widens exactly these. */
+export type IconSizeProp = keyof typeof ICON_SIZE_PROPS;
+/**
+ * A `Gtk.Align` value — the nick, or the constant a GJS caller's `Gtk.Align.CENTER` is —
+ * as the NativeScript alignment for `axis`. Any other value is NativeScript's own and is
+ * returned unchanged.
+ *
+ * The number spelling is resolved through {@link GTK_ALIGN} rather than assumed, because
+ * the constants are NOT the positions in the nick list: `GTK_ALIGN_BASELINE` was
+ * deprecated in GTK 4.12 and made an ALIAS of `GTK_ALIGN_BASELINE_FILL`, so both are 4 and
+ * `GTK_ALIGN_BASELINE_CENTER` is 5 where its position says 6.
+ */
+export declare function nsAlignment(value: unknown, axis: 'horizontal' | 'vertical'): unknown;
+/**
+ * Apply a construct-props bag through the target's declared setters.
+ *
+ * Called as the LAST statement of a widget's own constructor, so the bag wins over whatever
+ * that constructor set up — which is the point of a construct property.
+ *
+ * An `undefined` VALUE is skipped rather than assigned: every key of a `Partial` is
+ * optional, so `{ title: maybeTitle }` is the ordinary spelling of "set it if I have one",
+ * and assigning `undefined` there would clear a default the constructor had just chosen. An
+ * unknown KEY still throws — the key is what the caller got wrong.
+ *
+ * The parameter is a bare record rather than `ConstructProps<T>` because inside a
+ * constructor `this` has the POLYMORPHIC this-type: a generic `<T extends object>(target: T,
+ * props?: ConstructProps<T>)` infers `T` as `this`, and `ConstructProps<AdwAvatar>` is not
+ * assignable to `ConstructProps<this>` — 46 of 46 call sites failed to compile that way. The
+ * typed door is the widget's own constructor signature; this is what it hands over.
+ */
+export declare function applyConstructProps(target: object, props?: Readonly<Record<string, unknown>>): void;
+export {};

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

@@ -37,7 +37,7 @@ export interface PasswordEntryRowViews {
     field: {
         secure: boolean;
     };
-    /** The peek toggle, whose `icon` takes an Adwaita symbolic SVG string. */
+    /** The peek toggle, whose `iconName` takes an Adwaita icon name or SVG source. */
     peekButton: {
         iconName: string;
     };
@@ -85,12 +85,13 @@ export declare function entryRowClassName(base: string, state: EntryRowRenderSta
  */
 export declare function applyEntryRowState(views: EntryRowViews, state: EntryRowRenderState, base: string): void;
 /**
- * The Adwaita symbolic SVG for a canonical peek icon name.
+ * Paint one password-entry-row render snapshot — `notify_visibility_cb` (C:62-81).
  *
- * The core names the icon the way the C does (`view-reveal-symbolic` /
- * `view-conceal-symbolic`, adw-password-entry-row.c:68,73); this is the one
- * place that maps a name onto the asset `@gjsify/adwaita-icons` ships.
+ * The peek icon goes through UNTRANSLATED. The core names it the way the C does
+ * (`view-reveal-symbolic` / `view-conceal-symbolic`, adw-password-entry-row.c:68,73),
+ * and since `icon-theme.ts` this port resolves that name at the widget — so the
+ * `peekIconSvg` that used to sit here, mapping the two names onto two imported
+ * documents, was one of four hand-rolled registries and is gone. Its whole body was
+ * the substitution the registry now performs for every name at once.
  */
-export declare function peekIconSvg(iconName: PasswordEntryRowRenderState['peekIconName']): string;
-/** Paint one password-entry-row render snapshot — `notify_visibility_cb` (C:62-81). */
 export declare function applyPasswordEntryRowState(views: PasswordEntryRowViews, state: PasswordEntryRowRenderState): void;

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

@@ -0,0 +1,59 @@
+/**
+ * Every `Gtk.Align` member, in GIR declaration order.
+ *
+ * Held against `GtkAlignNick` in `packages/framework/gtk-host/src/generated/props.ts` —
+ * in-repo, GIR-derived, emitted by a generator that has never heard of this port — so this
+ * array is a copy that cannot drift rather than a second source.
+ */
+export declare const GTK_ALIGN_NICKS: readonly ["fill", "start", "end", "center", "baseline-fill", "baseline", "baseline-center"];
+/**
+ * The members that are a SECOND NAME for another member rather than a value of their own,
+ * as alias to the member it stands for.
+ *
+ * The single authored GIR fact in this file. An alias takes its target's number and does
+ * not consume one, which is what shifts every later member below its position.
+ *
+ * `baseline` is here because GTK 4.12 deprecated `GTK_ALIGN_BASELINE` in favour of
+ * `GTK_ALIGN_BASELINE_FILL` and gave the new name the SAME value — "a different name for
+ * `GTK_ALIGN_BASELINE`", as the GIR doc on `baseline-fill` puts it — rather than adding a
+ * member. That is the whole of the off-by-one below it.
+ */
+export declare const GTK_ALIGN_ALIASES: Readonly<Record<string, string>>;
+/**
+ * Every `Gtk.Align` member, nick to constant.
+ *
+ * Six distinct values across seven nicks: `baseline` and `baseline-fill` are the same
+ * member under two names.
+ */
+export declare const GTK_ALIGN: Readonly<Record<string, number>>;
+/**
+ * `Gtk.Align` to `View.horizontalAlignment`.
+ *
+ * FOUR OF THE SEVEN MEMBERS MAP, not two. ADR 0034 § Context measured NativeScript's
+ * horizontal vocabulary as `'left' | 'center' | 'right' | 'stretch'` and concluded that
+ * `start` and `end` have no counterpart; `@nativescript/core` 9.0.21-next.15 declares
+ * `'start' | 'left' | 'center' | 'right' | 'end' | 'stretch'` (`core-types/index.ts:127`),
+ * and its shared layout pass resolves `start`/`end` against the view's own `direction`
+ * (`ui/core/view/view-helper/view-helper-common.ts:98-111`) — the same direction-relative
+ * meaning GTK gives them. The remainder is the three baselines and nothing else.
+ */
+export declare const NS_HORIZONTAL_ALIGNMENT: Readonly<Record<string, string>>;
+/**
+ * `Gtk.Align` to `View.verticalAlignment`.
+ *
+ * NativeScript's vertical vocabulary is `'top' | 'middle' | 'bottom' | 'stretch'` — no
+ * `center` and no `start`/`end`, so all four mapped members are genuinely translated here
+ * rather than passed through. GTK's vertical `start`/`end` are not direction-relative
+ * (`gtkenums.h` scopes that to the horizontal context), which is why they can be top and
+ * bottom without asking the view which way its text runs.
+ */
+export declare const NS_VERTICAL_ALIGNMENT: Readonly<Record<string, string>>;
+/**
+ * Why a `Gtk.Align` member has no NativeScript counterpart on either axis.
+ *
+ * ADR 0034 § 1's declared remainder: a member that is absent from both maps and absent from
+ * here is a silent omission, and the gate fails on it.
+ */
+export declare const GTK_ALIGN_REFUSALS: Readonly<Record<string, string>>;
+/** The refusal reason for `nick`, for an error message that says why and not only no. */
+export declare function gtkAlignRefusal(nick: string): string;

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

@@ -0,0 +1,75 @@
+import { StackLayout, type View } from '@nativescript/core';
+import { DEFAULT_BOX_SPACING } from './box-layout.js';
+import { type ConstructProps } from './construct-props.js';
+export { DEFAULT_BOX_SPACING };
+declare const GtkBox_base: (abstract new (...args: any[]) => {
+    connect(eventName: string, callback: (self: /*elided*/ any, data: import("@nativescript/core").EventData) => void): number;
+    disconnect(handlerId: number): void;
+    _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 StackLayout;
+export declare class GtkBox extends GtkBox_base {
+    private _spacing;
+    private _styleClasses;
+    constructor(props?: ConstructProps<GtkBox>);
+    /** Append a child — `gtk_box_append`. */
+    append(view: View): void;
+    /** Insert a child at the START — `gtk_box_prepend`. */
+    prepend(view: View): void;
+    /** Remove a previously-added child — `gtk_box_remove`. */
+    remove(view: View): void;
+    /**
+     * Every path a child can enter by — `append()`, a direct `addChild()`, and XML
+     * inflation through `_addChildFromBuilder` — ends here, which is why the spacing is
+     * applied here and not in `append()`. `AdwWrapBox` records the incident that rule
+     * comes from: applied in `append()` only, a child declared in markup got no spacing
+     * at all.
+     */
+    addChild(view: View): void;
+    /**
+     * `gtk_box_insert_child_after`.
+     *
+     * A NULL/absent `sibling` inserts at the FIRST position, not the last —
+     * `gtk_widget_insert_after`'s documented rule. Returns whether the insert happened; a
+     * refusal is where C would have hit a `g_return_if_fail`.
+     */
+    insert_child_after(view: View, sibling?: View | null): boolean;
+    /** `gtk_box_reorder_child_after`. Same NULL rule. */
+    reorder_child_after(view: View, sibling?: View | null): boolean;
+    /** `Gtk.Box:spacing` — the gap between children, in DIPs. Defaults to 0, as in C. */
+    get spacing(): number;
+    set spacing(value: number | string);
+    /**
+     * `GtkWidget:css-classes`, spelled `styleClasses` — the platform owns `cssClasses` as a
+     * live `Set`, and taking that name is fatal inside the widget's own constructor
+     * (`style-classes.ts`). From XML it is a space-separated list, which is what an
+     * attribute can carry: `<gtk:Box styleClasses="card" />`.
+     */
+    get styleClasses(): string[];
+    set styleClasses(value: string | null | undefined);
+    /** `gtk_widget_add_css_class`. A class the box already carries is a no-op. */
+    add_css_class(name: string): void;
+    /** `gtk_widget_remove_css_class`. A class it does not carry is a no-op. */
+    remove_css_class(name: string): void;
+    /** `gtk_widget_has_css_class`. */
+    has_css_class(name: string): boolean;
+    /** `gtk_widget_get_css_classes` — the list, without the widget's own CSS name. */
+    get_css_classes(): string[];
+    /** `gtk_widget_set_css_classes` — REPLACES the list, as in C. */
+    set_css_classes(names: readonly string[]): void;
+    private _setClasses;
+    private _childViews;
+    private _applyOrder;
+    /**
+     * Give every child its share of the gap.
+     *
+     * The WHOLE set, not just the newcomer: adding a second child changes the FIRST one's
+     * answer too when the box is re-ordered, and a removal shifts every index after it.
+     */
+    private _applyChildren;
+}

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

@@ -1,33 +1,115 @@
-import { type AdwButtonStyleClass } from '@gjsify/adwaita-core';
-import { Button } from '@nativescript/core';
-/**
- * The Adwaita button variants this widget can apply. `'default'` = plain button.
- *
- * The class list is `@gjsify/adwaita-core`'s, not a local table: this widget's own
- * one was MISSING `circular`, which the browser element had, and neither file could
- * see the other. `circular` is now here because the shared table says it exists.
- *
- * STILL `Adw…`, on a class that is not: the variants ARE libadwaita style classes
- * (`.suggested-action`, `.pill`, `_buttons.scss`), so the prefix names what they are.
- * ADR 0034 clause 1 renames WIDGETS after the library owning their GType; a style-class
- * vocabulary is not a widget, and renaming it would have moved a true name to a false one.
- */
-export type AdwButtonVariant = 'default' | AdwButtonStyleClass;
-export declare class GtkButton extends Button {
-    private _variant;
-    constructor();
+import { GridLayout, type View } from '@nativescript/core';
+import { type ConstructProps } from './construct-props.js';
+/** Event name emitted when the button is tapped. Mirrors `Gtk.Button::clicked`. */
+export declare const GTK_BUTTON_CLICKED = "clicked";
+/** The class the button's own label carries, so the theme can give it Adwaita's type. */
+export declare const GTK_BUTTON_LABEL_CLASS = "adw-button-label";
+declare const GtkButton_base: (abstract new (...args: any[]) => {
+    connect(eventName: string, callback: (self: /*elided*/ any, data: import("@nativescript/core").EventData) => void): number;
+    disconnect(handlerId: number): void;
+    _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 class GtkButton extends GtkButton_base {
+    private _styleClasses;
+    private _label;
+    private _iconName;
+    private _useUnderline;
+    private _slot;
+    /** The view currently in the single cell, whichever slot filled it. */
+    private _content;
+    constructor(props?: ConstructProps<GtkButton>);
     /**
-     * The Adwaita style variant. Setting it swaps the corresponding CSS class
-     * (one of `GtkButton.variantClasses`) onto the button,
-     * preserving the base `adw-button` class. Note that `pill` is the rounded
-     * SHAPE and combines with no other variant here (set the shape OR the accent
-     * intent — matching how this CSS subset expresses them as flat classes).
+     * `Gtk.Button:label` — the button's text.
+     *
+     * Writing it REPLACES whatever was in the child, which is `gtk_button_set_label`
+     * building a fresh `GtkLabel` and handing it to `set_child`. An empty label is still a
+     * label: the button keeps its child and shows nothing, rather than collapsing.
      */
-    get variant(): AdwButtonVariant;
-    set variant(value: AdwButtonVariant);
+    get label(): string;
+    set label(value: string);
     /**
-     * All Adwaita variant class names this widget recognises — exposed for tests
-     * and for consumers composing class lists manually.
+     * `Gtk.Button:icon-name` — an Adwaita symbolic SVG string, not a theme name (see the
+     * header). Writing it replaces the child, as `gtk_button_set_icon_name` does.
      */
-    static get variantClasses(): readonly string[];
+    get iconName(): string;
+    set iconName(value: string);
+    /**
+     * `Gtk.Button:child` — any view, which is how a button wraps an `Adw.ButtonContent`.
+     *
+     * `null` empties the button. Setting it also hands an `AdwButtonContent` the host it
+     * needs: that widget stamps `image-text-button` on the button around it, which C gets
+     * from `gtk_widget_get_ancestor` and NativeScript has no rooting protocol for — so the
+     * button that receives the content is what tells it.
+     */
+    get child(): View | null;
+    set child(view: View | null);
+    /** `gtk_button_set_child`. The method spelling of {@link child}. */
+    set_child(view: View | null): void;
+    /** `gtk_button_get_child`. */
+    get_child(): View | null;
+    /**
+     * XML inflation — every child a template declares is THE button's child.
+     *
+     * Without this, `LayoutBase`'s default calls `addChild`, which drops the view into the
+     * cell without the slot bookkeeping: a second child would paint on top of the first
+     * and `child` would read back `null`, both at exit 0.
+     */
+    _addChildFromBuilder(_name: string, view: View): void;
+    /**
+     * `Gtk.Button:use-underline` — whether an `_` in {@link label} marks a mnemonic.
+     *
+     * The marker is REMOVED and no key is bound: NativeScript has no accelerator layer.
+     * Same reduction `Adw.ButtonContent` and `Gtk.Label` make, through the same helper.
+     */
+    get useUnderline(): boolean;
+    set useUnderline(raw: boolean | string);
+    /**
+     * The style classes this button carries (`GtkWidget:css-classes`), without the
+     * `adw-button` class that makes it a button — GTK's own rule for the property.
+     *
+     * IT WAS `variant`, AN ENUM, AND THAT WAS ONE LOOK AT A TIME (ADR 0049). Its own doc
+     * said so: "`pill` is the rounded SHAPE and combines with no other variant here (set
+     * the shape OR the accent intent)". GTK holds a LIST, so `.pill.suggested-action` is
+     * an ordinary Adwaita button and was unreachable through the enum. The names are the
+     * CLASS names now, not the web element's attribute spellings: `suggested-action`,
+     * not `suggested`.
+     *
+     * NOT `cssClasses`: `ViewBase` owns that name as a live `Set<string>` the CSS engine
+     * rebuilds on every `className` write, and shadowing it kills the widget in its own
+     * constructor — see `style-classes.ts`.
+     *
+     * From XML it is a space-separated list, which is what an attribute can carry:
+     * `<gtk:Button styleClasses="pill suggested-action" />`.
+     */
+    get styleClasses(): string[];
+    set styleClasses(value: string | null | undefined);
+    /** `gtk_widget_add_css_class`. A class the button already carries is a no-op. */
+    add_css_class(name: string): void;
+    /** `gtk_widget_remove_css_class`. A class it does not carry is a no-op. */
+    remove_css_class(name: string): void;
+    /** `gtk_widget_has_css_class`. */
+    has_css_class(name: string): boolean;
+    /** `gtk_widget_get_css_classes` — the list, without the widget's own CSS name. */
+    get_css_classes(): string[];
+    /** `gtk_widget_set_css_classes` — REPLACES the list, as in C. */
+    set_css_classes(names: readonly string[]): void;
+    private _setClasses;
+    /**
+     * Put `value` in the single cell under `wrote`'s slot, detaching whatever the previous
+     * slot had parented.
+     *
+     * The detach is the whole reason `button-slot.ts` exists: two views left in one
+     * `GridLayout` cell paint on top of each other and nothing complains.
+     */
+    private _fill;
+    private _detach;
+    /** Parent `view` in the single cell, centred, and remember it as the content. */
+    private _adopt;
 }
+export {};