@gjsify/adwaita-react-native 0.45.0 → 0.47.0

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

@@ -0,0 +1,15 @@
+import type { ReactElement } from 'react';
+import type { AdwNavigationSplitViewProps } from '../props.js';
+/**
+ * A sidebar beside content, which becomes a navigation stack when collapsed.
+ *
+ * THE SHARED HALF IS TWO THINGS, and both are `@gjsify/adwaita-core`'s. The WIDTH is
+ * `resolveNavigationSidebarWidth`, a port of the C that caps the sidebar's MAX BOUND by
+ * `width - content_min` and then clamps with GLib's `CLAMP` — which tests the high
+ * bound first and therefore disagrees with `Math.min(max, Math.max(min, x))` exactly
+ * where the bounds invert. The ORDERING is `resolveNavigationStack`, the table that
+ * keeps a LONE child visible whatever `show-content` says and makes the CONTENT the
+ * root page under `sidebar-position: end`. libadwaita runs the originals on GTK; the
+ * React Native half runs the ports, and the suites assert the same numbers on both.
+ */
+export declare function AdwNavigationSplitView(_props: AdwNavigationSplitViewProps): ReactElement | null;

package/lib/types/widgets/navigation-split-view.gtk.d.ts

@@ -0,0 +1,5 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+import type { ReactElement } from 'react';
+import type { AdwNavigationSplitViewProps } from '../props.js';
+/** {@link import('./navigation-split-view.js').AdwNavigationSplitView} on GTK. */
+export declare function AdwNavigationSplitView({ children, sidebar, sidebarTag, contentTag, sidebarTitle, contentTitle, collapsed, showContent, sidebarPosition, minSidebarWidth, maxSidebarWidth, sidebarWidthFraction, sidebarWidthUnit, }: AdwNavigationSplitViewProps): ReactElement | null;

package/lib/types/widgets/navigation-split-view.native.d.ts

@@ -0,0 +1,10 @@
+/** @jsxImportSource react */
+import { type ReactElement } from 'react';
+import type { AdwNavigationSplitViewProps } from '../props.js';
+/**
+ * {@link import('./navigation-split-view.js').AdwNavigationSplitView} on React Native.
+ *
+ * BEFORE THE FIRST LAYOUT there is no available width, so both panes render unsized for
+ * exactly one frame — the same one-frame case `AdwClamp` has, and for the same reason.
+ */
+export declare function AdwNavigationSplitView({ children, sidebar, sidebarTag, contentTag, collapsed, showContent, sidebarPosition, minSidebarWidth, maxSidebarWidth, sidebarWidthFraction, sidebarWidthUnit, }: AdwNavigationSplitViewProps): ReactElement | null;

package/lib/types/widgets/navigation-split-view.native.spec.d.ts

@@ -0,0 +1,3 @@
+/** @jsxImportSource react */
+declare const _default: () => Promise<void>;
+export default _default;

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

@@ -0,0 +1,16 @@
+import type { ReactElement } from 'react';
+import type { AdwNavigationViewProps } from '../props.js';
+/**
+ * A stack of pages, one visible at a time.
+ *
+ * THE TWO IMPLEMENTATIONS SHARE THE STACK MACHINE AND NOTHING ELSE, and unlike every
+ * widget above this one that machine is real state rather than arithmetic: a page
+ * registry, a tag index, the static-versus-dynamic `remove_on_pop` lifecycle, six
+ * mutators and the back-button derivation. On GTK it is libadwaita's own C; on React
+ * Native it is `@gjsify/adwaita-core`'s `NavigationViewState`, the same class
+ * `@gjsify/adwaita-web` and `@gjsify/adwaita-nativescript` already run — so the three
+ * renderers answer one question about a given page chain, and the suites assert the
+ * same tag and the same tooltip on both halves rather than each side's own idea of
+ * "the top of the stack".
+ */
+export declare function AdwNavigationView(_props: AdwNavigationViewProps): ReactElement | null;

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

@@ -0,0 +1,5 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+import { type ReactElement } from 'react';
+import type { AdwNavigationViewProps } from '../props.js';
+/** {@link import('./navigation-view.js').AdwNavigationView} on GTK. */
+export declare function AdwNavigationView({ children, animateTransitions, popOnEscape, ref, }: AdwNavigationViewProps): ReactElement | null;

package/lib/types/widgets/navigation-view.native.d.ts

@@ -0,0 +1,5 @@
+/** @jsxImportSource react */
+import { type ReactElement } from 'react';
+import type { AdwNavigationViewProps } from '../props.js';
+/** {@link import('./navigation-view.js').AdwNavigationView} on React Native. */
+export declare function AdwNavigationView({ children, animateTransitions, popOnEscape, ref, }: AdwNavigationViewProps): ReactElement | null;

package/lib/types/widgets/navigation-view.native.spec.d.ts

@@ -0,0 +1,3 @@
+/** @jsxImportSource react */
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/widgets/navigation.gtk.spec.d.ts

@@ -0,0 +1,3 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+declare const _default: () => Promise<void>;
+export default _default;

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

@@ -0,0 +1,13 @@
+import type { ReactElement } from 'react';
+import type { AdwOverlaySplitViewProps } from '../props.js';
+/**
+ * A sidebar beside content, which slides OVER it when collapsed.
+ *
+ * IT IS NOT `AdwNavigationSplitView` WITH A DIFFERENT PAINT, and the width is where
+ * that shows: `resolveOverlaySidebarWidth` caps the RESULT by `width - content_min`
+ * where the navigation widget caps the BOUND, and a COLLAPSED overlay ignores the
+ * fraction entirely and clamps the VIEW width instead — 280 on a 360-point phone where
+ * a quarter would be 180. Both rules are `@gjsify/adwaita-core`'s port of the C, run by
+ * the React Native half and by libadwaita itself on GTK.
+ */
+export declare function AdwOverlaySplitView(_props: AdwOverlaySplitViewProps): ReactElement | null;

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

@@ -0,0 +1,5 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+import { type ReactElement } from 'react';
+import type { AdwOverlaySplitViewProps } from '../props.js';
+/** {@link import('./overlay-split-view.js').AdwOverlaySplitView} on GTK. */
+export declare function AdwOverlaySplitView({ children, sidebar, collapsed, showSidebar, pinSidebar, sidebarPosition, enableShowGesture, enableHideGesture, minSidebarWidth, maxSidebarWidth, sidebarWidthFraction, sidebarWidthUnit, onNotifyShowSidebar, }: AdwOverlaySplitViewProps): ReactElement | null;

package/lib/types/widgets/overlay-split-view.native.d.ts

@@ -0,0 +1,5 @@
+/** @jsxImportSource react */
+import { type ReactElement } from 'react';
+import type { AdwOverlaySplitViewProps } from '../props.js';
+/** {@link import('./overlay-split-view.js').AdwOverlaySplitView} on React Native. */
+export declare function AdwOverlaySplitView({ children, sidebar, collapsed, showSidebar, pinSidebar, sidebarPosition, enableShowGesture, enableHideGesture, minSidebarWidth, maxSidebarWidth, sidebarWidthFraction, sidebarWidthUnit, onNotifyShowSidebar, }: AdwOverlaySplitViewProps): ReactElement | null;

package/lib/types/widgets/overlay-split-view.native.spec.d.ts

@@ -0,0 +1,3 @@
+/** @jsxImportSource react */
+declare const _default: () => Promise<void>;
+export default _default;

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

@@ -0,0 +1,13 @@
+import type { ReactElement } from 'react';
+import type { AdwPasswordEntryRowProps } from '../props.js';
+/**
+ * An entry row whose contents are masked, with a button that peeks at them.
+ *
+ * THE TWO IMPLEMENTATIONS SHARE `update_empty` AND THE PEEK PAIR. On GTK the real
+ * `Adw.PasswordEntryRow` runs both in C; on React Native `@gjsify/adwaita-core`'s
+ * `EntryRowState` and the `PasswordEntryRowState` that COMPOSES it — mirroring the C, which
+ * subclasses but reaches its parent through a private hook — run them in TypeScript. The
+ * mask is the assertion both suites share: masked on mount, clear after one press of the
+ * peek button, and the peek button's accessible name flipping with it.
+ */
+export declare function AdwPasswordEntryRow(_props: AdwPasswordEntryRowProps): ReactElement | null;

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

@@ -0,0 +1,5 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+import { type ReactElement } from 'react';
+import type { AdwPasswordEntryRowProps } from '../props.js';
+/** {@link import('./password-entry-row.js').AdwPasswordEntryRow} on GTK. */
+export declare function AdwPasswordEntryRow({ title, text, maxLength, editable, showApplyButton, onNotifyText, onApply, onEntryActivated, }: AdwPasswordEntryRowProps): ReactElement | null;

package/lib/types/widgets/password-entry-row.native.d.ts

@@ -0,0 +1,5 @@
+/** @jsxImportSource react */
+import { type ReactElement } from 'react';
+import type { AdwPasswordEntryRowProps } from '../props.js';
+/** {@link import('./password-entry-row.js').AdwPasswordEntryRow} on React Native. */
+export declare function AdwPasswordEntryRow({ title, text, maxLength, editable, showApplyButton, onNotifyText, onApply, onEntryActivated, }: AdwPasswordEntryRowProps): ReactElement | null;

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

@@ -0,0 +1,13 @@
+import type { ReactElement } from 'react';
+import type { AdwPreferencesGroupProps } from '../props.js';
+/**
+ * A titled card of preference rows.
+ *
+ * THE TWO IMPLEMENTATIONS SHARE THEIR ARITHMETIC AND NOTHING ELSE. On GTK libadwaita runs
+ * `update_title_visibility`, `update_description_visibility`, `update_header_visibility`,
+ * `is_single_line` and `update_listbox_visibility` in C; on React Native
+ * `@gjsify/adwaita-core`'s `derivePreferencesGroupHeader` — one function that answers all
+ * five — runs them in TypeScript. Both suites assert the same five answers for the same
+ * inputs rather than each side's own idea of "the header is showing".
+ */
+export declare function AdwPreferencesGroup(_props: AdwPreferencesGroupProps): ReactElement | null;

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

@@ -0,0 +1,5 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+import type { ReactElement } from 'react';
+import type { AdwPreferencesGroupProps } from '../props.js';
+/** {@link import('./preferences-group.js').AdwPreferencesGroup} on GTK. */
+export declare function AdwPreferencesGroup({ children, title, description }: AdwPreferencesGroupProps): ReactElement | null;

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

@@ -0,0 +1,5 @@
+/** @jsxImportSource react */
+import { type ReactElement } from 'react';
+import type { AdwPreferencesGroupProps } from '../props.js';
+/** {@link import('./preferences-group.js').AdwPreferencesGroup} on React Native. */
+export declare function AdwPreferencesGroup({ children, title, description }: AdwPreferencesGroupProps): ReactElement | null;

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

@@ -0,0 +1,14 @@
+import type { ReactElement } from 'react';
+import type { AdwPreferencesPageProps } from '../props.js';
+/**
+ * A scrolling page of preference groups.
+ *
+ * THE TWO IMPLEMENTATIONS SHARE THE PAGE'S CONTRACT AND NOT ITS SCROLLER. On GTK the real
+ * `Adw.PreferencesPage` is an `AdwBin` around a `GtkScrolledWindow`; on React Native the
+ * page is a plain column, because `ScrollView` is a COMPOSITE that moves props into a
+ * content container and `testing/react-native.ts` may only double a host element with its
+ * props forwarded. The divergence is one-directional, named in the README, and does not
+ * touch what the page IS — four identity properties a view switcher reads and one
+ * description it draws.
+ */
+export declare function AdwPreferencesPage(_props: AdwPreferencesPageProps): ReactElement | null;

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

@@ -0,0 +1,5 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+import type { ReactElement } from 'react';
+import type { AdwPreferencesPageProps } from '../props.js';
+/** {@link import('./preferences-page.js').AdwPreferencesPage} on GTK. */
+export declare function AdwPreferencesPage({ children, title, iconName, name, description, descriptionCentered, useUnderline, }: AdwPreferencesPageProps): ReactElement | null;

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

@@ -0,0 +1,5 @@
+/** @jsxImportSource react */
+import { type ReactElement } from 'react';
+import type { AdwPreferencesPageProps } from '../props.js';
+/** {@link import('./preferences-page.js').AdwPreferencesPage} on React Native. */
+export declare function AdwPreferencesPage({ children, title: _title, iconName: _iconName, name: _name, description, descriptionCentered, useUnderline: _useUnderline, }: AdwPreferencesPageProps): ReactElement | null;

package/lib/types/widgets/preferences.gtk.spec.d.ts

@@ -0,0 +1,3 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/widgets/preferences.native.spec.d.ts

@@ -0,0 +1,3 @@
+/** @jsxImportSource react */
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/widgets/rows.gtk.spec.d.ts

@@ -0,0 +1,3 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/widgets/rows.native.spec.d.ts

@@ -0,0 +1,3 @@
+/** @jsxImportSource react */
+declare const _default: () => Promise<void>;
+export default _default;

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

@@ -0,0 +1,13 @@
+import type { ReactElement } from 'react';
+import type { AdwSpinRowProps } from '../props.js';
+/**
+ * A row holding a number with a stepper.
+ *
+ * THE TWO IMPLEMENTATIONS SHARE THE CLAMP AND NOTHING ELSE. On GTK a real `Gtk.Adjustment`
+ * bounds the value in C; on React Native `@gjsify/adwaita-core`'s `SpinState` — the same
+ * clamp on every mutation, the same re-clamp when a bound moves under a value — runs in
+ * TypeScript. Both suites assert the same number for the same authored range, including the
+ * two cases a naive port gets wrong: a value authored OUTSIDE the range, and a stepper press
+ * that would leave it.
+ */
+export declare function AdwSpinRow(_props: AdwSpinRowProps): ReactElement | null;

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

@@ -0,0 +1,20 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+import { type ReactElement } from 'react';
+import type { AdwSpinRowProps } from '../props.js';
+/**
+ * `SpinState`'s own defaults, which are the ones the React Native half falls back to.
+ *
+ * Exported so the spec asserts the two halves against ONE table rather than each against its
+ * own literals. They are not libadwaita's: a bare `Gtk.Adjustment` is 0…0 with a step of 0,
+ * which is a spin row that cannot move. `@gjsify/adwaita-core` picked 0…100 step 1, both
+ * sibling renderers use it, and the GTK half adopts it here rather than shipping a widget
+ * whose omitted range means something else than it does on a phone.
+ */
+export declare const ADW_SPIN_ROW_DEFAULTS: {
+    readonly lower: 0;
+    readonly upper: 100;
+    readonly stepIncrement: 1;
+    readonly value: 0;
+};
+/** {@link import('./spin-row.js').AdwSpinRow} on GTK. */
+export declare function AdwSpinRow({ title, subtitle, value, lower, upper, stepIncrement, digits, onNotifyValue, }: AdwSpinRowProps): ReactElement | null;

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

@@ -0,0 +1,5 @@
+/** @jsxImportSource react */
+import { type ReactElement } from 'react';
+import type { AdwSpinRowProps } from '../props.js';
+/** {@link import('./spin-row.js').AdwSpinRow} on React Native. */
+export declare function AdwSpinRow({ title, subtitle, value, lower, upper, stepIncrement, digits, onNotifyValue, }: AdwSpinRowProps): ReactElement | null;

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

@@ -0,0 +1,17 @@
+import type { ReactElement } from 'react';
+import type { AdwSpinnerProps } from '../props.js';
+/**
+ * A busy indicator.
+ *
+ * THE SHARED NUMBERS ARE THE BOX AND THE RING, and they are deliberately two numbers:
+ * `adw_spinner_measure` reports `MIN_SIZE` as both the minimum and the natural size with
+ * no upper bound, while `adw_spinner_paintable_snapshot_with_weight` caps only the RADIUS
+ * and still centres on the box. `@gjsify/adwaita-core`'s `resolveSpinnerSize` and
+ * `spinnerGeometry` are that split, and both halves run them.
+ *
+ * What the React Native half cannot carry is the breathing ARC, and the divergence is
+ * named in the README rather than approximated with a rotating quarter-circle — which is
+ * a different animation with a different period, and the one thing the core's own header
+ * says not to copy.
+ */
+export declare function AdwSpinner(_props: AdwSpinnerProps): ReactElement | null;

package/lib/types/widgets/spinner.gtk.d.ts

@@ -0,0 +1,5 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+import type { ReactElement } from 'react';
+import type { AdwSpinnerProps } from '../props.js';
+/** {@link import('./spinner.js').AdwSpinner} on GTK. */
+export declare function AdwSpinner({ widthRequest, heightRequest }: AdwSpinnerProps): ReactElement | null;

package/lib/types/widgets/spinner.native.d.ts

@@ -0,0 +1,5 @@
+/** @jsxImportSource react */
+import type { ReactElement } from 'react';
+import type { AdwSpinnerProps } from '../props.js';
+/** {@link import('./spinner.js').AdwSpinner} on React Native. */
+export declare function AdwSpinner({ widthRequest, heightRequest }: AdwSpinnerProps): ReactElement | null;

package/lib/types/widgets/spinner.native.spec.d.ts

@@ -0,0 +1,3 @@
+/** @jsxImportSource react */
+declare const _default: () => Promise<void>;
+export default _default;

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

@@ -0,0 +1,15 @@
+import type { ReactElement } from 'react';
+import type { AdwStatusPageProps } from '../props.js';
+/**
+ * A centred empty state: an icon, a title, a description and one child.
+ *
+ * THE PARTS ARE BUILT ONCE AND SHOWN OR HIDDEN, which is `adw-status-page.ui`'s own
+ * shape: every part binds its `visible` to a closure over the property that feeds it
+ * (:23-28, :41-46, :57-62), so a page with only a description opens without a blank line
+ * above it. The predicate is `string_is_not_empty` — the FIRST BYTE, never trimmed — and
+ * both halves take it from `@gjsify/adwaita-core` rather than writing `.length === 0`
+ * again, which is what both other renderers had done.
+ *
+ * `iconName` is the one prop that does not reach both halves; the reason is on the prop.
+ */
+export declare function AdwStatusPage(_props: AdwStatusPageProps): ReactElement | null;

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

@@ -0,0 +1,5 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+import type { ReactElement } from 'react';
+import type { AdwStatusPageProps } from '../props.js';
+/** {@link import('./status-page.js').AdwStatusPage} on GTK. */
+export declare function AdwStatusPage({ children, iconName, title, description }: AdwStatusPageProps): ReactElement | null;

package/lib/types/widgets/status-page.gtk.spec.d.ts

@@ -0,0 +1,3 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+declare const _default: () => Promise<void>;
+export default _default;

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

@@ -0,0 +1,5 @@
+/** @jsxImportSource react */
+import type { ReactElement } from 'react';
+import type { AdwStatusPageProps } from '../props.js';
+/** {@link import('./status-page.js').AdwStatusPage} on React Native. */
+export declare function AdwStatusPage({ children, title, description }: AdwStatusPageProps): ReactElement | null;

package/lib/types/widgets/status-page.native.spec.d.ts

@@ -0,0 +1,3 @@
+/** @jsxImportSource react */
+declare const _default: () => Promise<void>;
+export default _default;

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

@@ -0,0 +1,14 @@
+import type { ReactElement } from 'react';
+import type { AdwSwitchRowProps } from '../props.js';
+/**
+ * A boxed-list row whose trailing control is a switch.
+ *
+ * THE WHOLE ROW IS THE CONTROL, not just the handle. `adw_switch_row_init` makes the row
+ * activatable and points its activatable-widget at the slider, and the class
+ * documentation states the outcome directly: "the user can control the switch by
+ * activating the row or by dragging on the switch handle". Both halves therefore have two
+ * routes into one transition, and both run them through
+ * `@gjsify/adwaita-core`'s `SwitchRowState` — `activate()` for the row, `setActive()` for
+ * the slider — so the `g_object_notify` gate on the second is the same gate on the first.
+ */
+export declare function AdwSwitchRow(_props: AdwSwitchRowProps): ReactElement | null;

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

@@ -0,0 +1,5 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+import { type ReactElement } from 'react';
+import type { AdwSwitchRowProps } from '../props.js';
+/** {@link import('./switch-row.js').AdwSwitchRow} on GTK. */
+export declare function AdwSwitchRow({ title, subtitle, active, onNotifyActive }: AdwSwitchRowProps): ReactElement | null;

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

@@ -0,0 +1,5 @@
+/** @jsxImportSource react */
+import { type ReactElement } from 'react';
+import type { AdwSwitchRowProps } from '../props.js';
+/** {@link import('./switch-row.js').AdwSwitchRow} on React Native. */
+export declare function AdwSwitchRow({ title, subtitle, active, onNotifyActive }: AdwSwitchRowProps): ReactElement | null;

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

@@ -0,0 +1,18 @@
+import type { ReactElement } from 'react';
+import type { AdwToastOverlayProps } from '../props.js';
+/**
+ * Wraps content and shows one transient toast at a time over it.
+ *
+ * THIS IS THE ONE WIDGET IN THE PACKAGE WITH STATE RATHER THAN LAYOUT, and the two
+ * halves therefore hold it in two places on purpose. On GTK the queue is libadwaita's
+ * own: `adw_toast_overlay_add_toast` enqueues, the overlay shows one at a time and
+ * builds the `AdwToastWidget` itself, and nothing about it is reachable from a renderer.
+ * On React Native the queue is `@gjsify/adwaita-core`'s `AdwToastQueue` — the port of
+ * that policy — living in a `useRef` because it owns timers whose identity must survive
+ * a re-render, with only the VISIBLE toast in `useState` because that is what React
+ * re-renders on.
+ *
+ * So there is exactly one authority per half and neither is React's. What is asserted
+ * across them is the behaviour: two toasts added at once show ONE, on both.
+ */
+export declare function AdwToastOverlay(_props: AdwToastOverlayProps): ReactElement | null;

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

@@ -0,0 +1,23 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+import { type ReactElement } from 'react';
+import type { AdwToastOverlayProps } from '../props.js';
+/**
+ * `AdwToast.timeout` (ms) as `Adw.Toast:timeout` (whole seconds).
+ *
+ * Exported so `content.gtk.spec.tsx` can assert the conversion against
+ * libadwaita's own default instead of against itself; `parity.spec.ts` allows a
+ * platform-only export beside the widget for exactly this.
+ *
+ * IT ROUNDS UP, AND `Math.round` WAS THE FIRST VERSION AND WAS WRONG. `timeout: 0` is
+ * libadwaita's "until dismissed", so any rule that can take a POSITIVE millisecond count
+ * to 0 turns a brief toast into a permanent one — and `Math.round(400 / 1000)` is exactly
+ * that, caught by the row in `content.gtk.spec.tsx` that asserts the conversion. `ceil`
+ * cannot reach 0 from a positive input and leaves an authored 0 alone, so the one value
+ * that means something else keeps meaning it.
+ *
+ * It is lossy in the other direction and the README names that: GObject stores whole
+ * seconds, so 1500 ms is 2 s on GTK and stays 1500 ms on React Native.
+ */
+export declare const adwToastTimeoutSeconds: (milliseconds: number) => number;
+/** {@link import('./toast-overlay.js').AdwToastOverlay} on GTK. */
+export declare function AdwToastOverlay({ children, ref }: AdwToastOverlayProps): ReactElement | null;

package/lib/types/widgets/toast-overlay.native.d.ts

@@ -0,0 +1,5 @@
+/** @jsxImportSource react */
+import { type ReactElement } from 'react';
+import type { AdwToastOverlayProps } from '../props.js';
+/** {@link import('./toast-overlay.js').AdwToastOverlay} on React Native. */
+export declare function AdwToastOverlay({ children, ref }: AdwToastOverlayProps): ReactElement | null;

package/lib/types/widgets/toast-overlay.native.spec.d.ts

@@ -0,0 +1,3 @@
+/** @jsxImportSource react */
+declare const _default: () => Promise<void>;
+export default _default;

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

@@ -0,0 +1,23 @@
+import type { ReactElement } from 'react';
+import type { AdwToolbarViewProps } from '../props.js';
+/**
+ * A content area framed by top and/or bottom bars.
+ *
+ * WHAT THE TWO HALVES SHARE IS THE ARRANGEMENT, NOT THE ARITHMETIC, and that is a
+ * measured statement rather than a shortcut. `adw_toolbar_view_size_allocate` is two
+ * chained GLib CLAMPs over the bars' MINIMUM and NATURAL heights — ported in
+ * `@gjsify/adwaita-core` as `toolbarViewAllocate` and held to vectors — and neither this
+ * half nor `@gjsify/adwaita-nativescript`'s can run it: both get an ALREADY-LAID-OUT size
+ * from their engine and never a child's intrinsic minimum, so feeding the measurement in
+ * as both `min` and `nat` would turn each CLAMP into the identity and dress a
+ * pass-through up as libadwaita's arithmetic. The consequence is real and one-directional
+ * — a STRETCHY bar keeps its natural height where libadwaita would shrink it toward its
+ * minimum to protect the content — and the README names it.
+ *
+ * The other half of the widget, `toolbarViewClasses`, is four STYLE CLASSES (`raised`,
+ * `border`, `undershoot-top`, `undershoot-bottom`), and React Native has no class system
+ * to stamp them into. So `topBarStyle` and `bottomBarStyle` reach the real widget on GTK
+ * and draw nothing on a phone; that too is named in the README and pinned by a test on
+ * each side.
+ */
+export declare function AdwToolbarView(_props: AdwToolbarViewProps): ReactElement | null;

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

@@ -0,0 +1,5 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+import type { ReactElement } from 'react';
+import type { AdwToolbarViewProps } from '../props.js';
+/** {@link import('./toolbar-view.js').AdwToolbarView} on GTK. */
+export declare function AdwToolbarView({ children, topBar, bottomBar, topBarStyle, bottomBarStyle, extendContentToTopEdge, extendContentToBottomEdge, }: AdwToolbarViewProps): ReactElement | null;

package/lib/types/widgets/toolbar-view.gtk.spec.d.ts

@@ -0,0 +1,3 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+declare const _default: () => Promise<void>;
+export default _default;

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

@@ -0,0 +1,5 @@
+/** @jsxImportSource react */
+import type { ReactElement } from 'react';
+import type { AdwToolbarViewProps } from '../props.js';
+/** {@link import('./toolbar-view.js').AdwToolbarView} on React Native. */
+export declare function AdwToolbarView({ children, topBar, bottomBar, extendContentToTopEdge, extendContentToBottomEdge, }: AdwToolbarViewProps): ReactElement | null;

package/lib/types/widgets/toolbar-view.native.spec.d.ts

@@ -0,0 +1,3 @@
+/** @jsxImportSource react */
+declare const _default: () => Promise<void>;
+export default _default;

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

@@ -0,0 +1,13 @@
+import type { ReactElement } from 'react';
+import type { AdwViewStackProps } from '../props.js';
+/**
+ * Named pages, one visible at a time.
+ *
+ * THE SELECTION IS THE SHARED HALF. Which page an omitted `visible-child-name` shows
+ * (the first VISIBLE one, and the auto-pick NOTIFIES), what an unknown name does
+ * (nothing — refused, not clamped), and where the selection goes when the visible page
+ * is hidden are `@gjsify/adwaita-core`'s `ViewStackState`, held to conformance vectors
+ * and already run by both other renderers. On GTK the original answers instead, and
+ * the suites assert the same name on both halves.
+ */
+export declare function AdwViewStack(_props: AdwViewStackProps): ReactElement | null;

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

@@ -0,0 +1,52 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+import type Adw from 'gi://Adw?version=1';
+import { type ReactElement } from 'react';
+import type { AdwViewStackPageProps, AdwViewStackProps } from '../props.js';
+/**
+ * The page bodies, as children of an `<adw-view-stack>`.
+ *
+ * Exported because `view-switcher.gtk.tsx` builds the same stack; `parity.spec.ts`
+ * allows a platform-only export beside the widget, and the second copy is where a
+ * `slot`-versus-`layout` decision would drift.
+ *
+ * Each body gets its own `GtkBox` rather than being handed to `add_titled` directly:
+ * `child` is an arbitrary `ReactNode` with nothing to write a `slot` on, the same wall
+ * `header-bar.gtk.tsx` documents.
+ */
+export declare function viewStackChildren(pages: readonly AdwViewStackPageProps[]): ReactElement[];
+/**
+ * Write the seven `Adw.ViewStackPage` properties `add_titled` cannot carry.
+ *
+ * IT RUNS AFTER EVERY COMMIT, WITH NO DEPENDENCY LIST, and that is deliberate: the page
+ * list is a prop array whose identity a caller has no reason to keep stable, so a
+ * dependency list over its contents would be a second hand-maintained copy of the same
+ * record. A redundant `g_object_set` with an unchanged value emits no `notify` and
+ * nothing else, so the cost is a property read per page per commit.
+ *
+ * AN OMITTED PROP IS LEFT ALONE rather than written as libadwaita's default — the rule
+ * `clamp.gtk.tsx` states — so the installed libadwaita stays the authority for its own
+ * defaults and a drift against `@gjsify/adwaita-core`'s transcription of them is visible
+ * instead of silent.
+ */
+export declare function useViewStackPageProperties(stack: Adw.ViewStack | null, pages: readonly AdwViewStackPageProps[]): void;
+/**
+ * The `notify::visible-child` handler both stack-owning components install.
+ *
+ * IT REPORTS NOTHING UNTIL THE WIDGET IS READABLE. libadwaita's auto-pick notifies from
+ * inside `adw_view_stack_add_titled` — child insertion is deliberately OUTSIDE gtk-host's
+ * host-write window, so the notify is delivered — and at that moment React has not yet
+ * committed the `ref`, so there is no stack to read the settled name off. Measured, the
+ * inline `stack?.visibleChildName ?? ''` this replaces reported `''` at mount: a name no
+ * page carries, on a callback whose whole contract is to name the page that is showing.
+ * The React Native half reports nothing there, because its subscription is installed in
+ * an effect after the pages are filled in.
+ *
+ * A change the CALLER made does not come back through here either — gtk-host drops the
+ * notify raised inside its own property write, the same rule `AdwExpanderRowProps`
+ * records for `onNotifyExpanded`. That one IS a divergence from the React Native half,
+ * which re-applies `visibleChildName` through `selectName` and reports what it settled
+ * on; the README names it. What both halves report is a change the USER made.
+ */
+export declare function visibleChildNotifier(stack: Adw.ViewStack | null, notify: ((name: string) => void) | undefined): (() => void) | undefined;
+/** {@link import('./view-stack.js').AdwViewStack} on GTK. */
+export declare function AdwViewStack({ pages, visibleChildName, onNotifyVisibleChild, }: AdwViewStackProps): ReactElement | null;

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

@@ -0,0 +1,20 @@
+/** @jsxImportSource react */
+import { type ReactElement } from 'react';
+import { ViewSwitcherState } from '@gjsify/adwaita-core';
+import type { AdwViewStackPageProps, AdwViewStackProps } from '../props.js';
+/**
+ * The page model and its selection, shared with `view-switcher.native.tsx`.
+ *
+ * Exported because the switcher bundles the same stack; `parity.spec.ts` allows a
+ * platform-only export beside the widget, and a second copy of this wiring is where the
+ * two would come to disagree about what an unknown name does.
+ */
+export declare function useViewStackSelection(pages: readonly AdwViewStackPageProps[], visibleChildName: string | undefined, onNotifyVisibleChild: ((name: string) => void) | undefined): ViewSwitcherState;
+/**
+ * The page bodies, one per page, with only the selected one displayed.
+ *
+ * Shared with the switcher for the reason {@link useViewStackSelection} gives.
+ */
+export declare function viewStackBodies(pages: readonly AdwViewStackPageProps[], selected: number): ReactElement[];
+/** {@link import('./view-stack.js').AdwViewStack} on React Native. */
+export declare function AdwViewStack({ pages, visibleChildName, onNotifyVisibleChild, }: AdwViewStackProps): ReactElement | null;

package/lib/types/widgets/view-stack.native.spec.d.ts

@@ -0,0 +1,3 @@
+/** @jsxImportSource react */
+declare const _default: () => Promise<void>;
+export default _default;

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

@@ -0,0 +1,13 @@
+import type { ReactElement } from 'react';
+import type { AdwViewSwitcherProps } from '../props.js';
+/**
+ * A row of buttons over a view stack.
+ *
+ * WHAT EACH BUTTON SHOWS IS DERIVED, NOT AUTHORED, and that derivation is
+ * `@gjsify/adwaita-core`'s `buildViewSwitcherButtons`: a page with NEITHER a title NOR
+ * an icon has no button at all, a page with no icon gets `image-missing` rather than
+ * nothing, a badge above 999 reads `999+`, and the button's orientation follows the
+ * policy. libadwaita computes the same on GTK, so this widget's two halves differ in
+ * what they can DRAW and never in which buttons exist.
+ */
+export declare function AdwViewSwitcher(_props: AdwViewSwitcherProps): ReactElement | null;

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

@@ -0,0 +1,5 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+import { type ReactElement } from 'react';
+import type { AdwViewSwitcherProps } from '../props.js';
+/** {@link import('./view-switcher.js').AdwViewSwitcher} on GTK. */
+export declare function AdwViewSwitcher({ pages, policy, visibleChildName, onNotifyVisibleChild, }: AdwViewSwitcherProps): ReactElement | null;

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

@@ -0,0 +1,5 @@
+/** @jsxImportSource react */
+import { type ReactElement } from 'react';
+import type { AdwViewSwitcherProps } from '../props.js';
+/** {@link import('./view-switcher.js').AdwViewSwitcher} on React Native. */
+export declare function AdwViewSwitcher({ pages, policy, visibleChildName, onNotifyVisibleChild, }: AdwViewSwitcherProps): ReactElement | null;