@gjsify/adwaita-core 0.31.0 → 0.33.0

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

@@ -0,0 +1,443 @@
+import type { AdwInlineViewSwitcherDisplayMode, AdwViewSwitcherPolicy, ViewSwitcherScheduler } from '../view-switcher.js';
+/**
+ * A page as a vector declares it — the input half of `AdwViewSwitcherPageInit`.
+ *
+ * `title`/`iconName` omitted OR `null` both mean "the page has none", which is
+ * also what `getAttribute` returns for a missing attribute, so a DOM driver maps
+ * both to "do not set the attribute".
+ */
+export interface ViewSwitcherVectorPage {
+    /** The page name. */
+    name: string;
+    /** `AdwViewStackPage:title`; absent means NULL. */
+    title?: string | null;
+    /** `AdwViewStackPage:icon-name`; absent means NULL. */
+    iconName?: string | null;
+    /** `AdwViewStackPage:visible`; absent means `true`. */
+    visible?: boolean;
+    /** `AdwViewStackPage:use-underline`; absent means `false`. */
+    useUnderline?: boolean;
+    /** `AdwViewStackPage:badge-number`; absent means `0`. */
+    badgeNumber?: number;
+    /** `AdwViewStackPage:needs-attention`; absent means `false`. */
+    needsAttention?: boolean;
+}
+/** One `stripMnemonic` expectation. */
+export interface MnemonicVector {
+    /** The raw title. */
+    label: string;
+    /** What `adw_strip_mnemonic` produces. */
+    stripped: string;
+    /** What this row pins down. */
+    rule: string;
+}
+/**
+ * `adw_strip_mnemonic` (adw-widget-utils.c:685-703) — `g_markup_escape_text`
+ * then `pango_parse_markup` with `'_'` as the accel marker.
+ *
+ * The escape/parse round trip is entity-NEUTRAL, which is what the `R&D` row
+ * pins: a port that only escaped, or only unescaped, would drift on every
+ * ampersand.
+ */
+export declare const VIEW_SWITCHER_MNEMONIC_VECTORS: ReadonlyArray<MnemonicVector>;
+/** One `viewSwitcherIconName` expectation. */
+export interface ViewSwitcherIconVector {
+    /** `AdwViewStackPage:icon-name` as the page carries it. */
+    iconName: string | null | undefined;
+    /** The icon the switcher actually renders. */
+    resolved: string;
+    /** What this row pins down. */
+    rule: string;
+}
+/**
+ * The `image-missing` substitution (adw-view-switcher-button.c:399-405,
+ * adw-inline-view-switcher.c:137-142). Both ports rendered NO icon instead,
+ * which is why an icons-mode toggle for a page without an icon was a blank box.
+ *
+ * Note there is no `-symbolic` stripping here: C passes the name to `GtkImage`
+ * unchanged. Turning a name into a CSS class or an SVG document is the
+ * renderer's job.
+ */
+export declare const VIEW_SWITCHER_ICON_VECTORS: ReadonlyArray<ViewSwitcherIconVector>;
+/** One `isViewSwitcherButtonVisible` expectation. */
+export interface ViewSwitcherButtonVisibilityVector {
+    /** `AdwViewStackPage:visible`. */
+    visible: boolean;
+    /** `AdwViewStackPage:title`. */
+    title: string | null;
+    /** `AdwViewStackPage:icon-name`. */
+    iconName: string | null;
+    /** Whether `AdwViewSwitcher` shows the button. */
+    buttonVisible: boolean;
+    /** What this row pins down. */
+    rule: string;
+}
+/**
+ * `update_button`'s `gtk_widget_set_visible (button, visible && (title != NULL ||
+ * icon_name != NULL))` (adw-view-switcher.c:178).
+ *
+ * Implemented in NEITHER port: the browser one hid the label and icon spans but
+ * always appended a visible `<button>`, the NativeScript one always added the
+ * button `StackLayout` with an empty `Label`. Both therefore rendered an empty,
+ * clickable, space-consuming tab for a page with no title and no icon.
+ */
+export declare const VIEW_SWITCHER_BUTTON_VISIBILITY_VECTORS: ReadonlyArray<ViewSwitcherButtonVisibilityVector>;
+/** One badge-label + indicator-description expectation. */
+export interface ViewSwitcherBadgeVector {
+    /** `AdwViewStackPage:badge-number`. */
+    badgeNumber: number;
+    /** `AdwViewStackPage:needs-attention`. */
+    needsAttention: boolean;
+    /** `get_badge_label`'s text. */
+    badgeLabel: string;
+    /** `update_description`'s text. */
+    description: string;
+    /** What this row pins down. */
+    rule: string;
+}
+/**
+ * `get_badge_label` (adw-indicator-bin.c:58-68) and `update_description`
+ * (:70-113), which both ports omit entirely — neither renders a badge, a
+ * needs-attention dot, or an accessible description.
+ *
+ * The composition ORDER is the subtle part: when both clauses apply the format
+ * is `"%s %s", badge_description, needs_attention_description` (:96), so the
+ * BADGE comes first.
+ */
+export declare const VIEW_SWITCHER_BADGE_VECTORS: ReadonlyArray<ViewSwitcherBadgeVector>;
+/** One `shouldRevealViewSwitcherBar` expectation. */
+export interface ViewSwitcherBarRevealVector {
+    /** `AdwViewSwitcherBar:reveal` — what the layout asked for. */
+    reveal: boolean;
+    /** The bound stack's pages, reduced to their `visible` flag. */
+    pages: readonly {
+        readonly visible: boolean;
+    }[];
+    /** Whether the action bar is actually revealed. */
+    revealed: boolean;
+    /** What this row pins down. */
+    rule: string;
+}
+/**
+ * `update_bar_revealed` (adw-view-switcher-bar.c:104-126) — absent from BOTH
+ * ports, which each reduced `revealed` to their own boolean flag and never
+ * consulted the page count. A bar bound to a one-page stack therefore showed an
+ * empty strip libadwaita keeps collapsed.
+ */
+export declare const VIEW_SWITCHER_BAR_REVEAL_VECTORS: ReadonlyArray<ViewSwitcherBarRevealVector>;
+/** One step of a {@link ViewSwitcherBarVector} script. */
+export type ViewSwitcherBarStep = {
+    readonly kind: 'reveal';
+    readonly value: boolean;
+} | {
+    readonly kind: 'pages';
+    readonly pages: readonly {
+        readonly visible: boolean;
+    }[];
+};
+/** The `{ reveal, revealed }` pair a bar exposes. */
+export interface ViewSwitcherBarSnapshot {
+    /** The request. */
+    reveal: boolean;
+    /** The derived truth. */
+    revealed: boolean;
+}
+/** One end-to-end switcher-bar expectation. */
+export interface ViewSwitcherBarVector {
+    /** What this row pins down. */
+    rule: string;
+    /** The C function + lines it is derived from. */
+    derivedFrom: string;
+    /** The script, applied in order to a fresh bar. */
+    steps: readonly ViewSwitcherBarStep[];
+    /**
+     * Return value of each step. A `reveal` step returns whether `reveal` ITSELF
+     * changed (C returns early before its notify otherwise); a `pages` step
+     * returns whether `revealed` flipped.
+     */
+    stepResults: readonly boolean[];
+    /** The state after each step, in order. */
+    states: readonly ViewSwitcherBarSnapshot[];
+    /** The changes emitted, in order — only a flip of `revealed` notifies. */
+    changes: readonly ViewSwitcherBarSnapshot[];
+}
+/**
+ * `AdwViewSwitcherBar`'s reveal machine end to end. `update_bar_revealed` is
+ * re-run from `set_reveal`, from `set_stack` and from the pages' `items-changed`
+ * (adw-view-switcher-bar.c:340-343, :383, :277), which is why the page set alone
+ * can flip the bar while `reveal` never moves.
+ */
+export declare const VIEW_SWITCHER_BAR_VECTORS: ReadonlyArray<ViewSwitcherBarVector>;
+/** One `inlineToggleTooltip` expectation. */
+export interface InlineTooltipVector {
+    /** `AdwViewStackPage:title`. */
+    title: string | null;
+    /** `AdwViewStackPage:use-underline`. */
+    useUnderline: boolean;
+    /** The current display mode. */
+    displayMode: AdwInlineViewSwitcherDisplayMode;
+    /** The tooltip text, as PLAIN text. */
+    tooltip: string;
+    /** What this row pins down. */
+    rule: string;
+}
+/**
+ * `update_tooltip` (adw-inline-view-switcher.c:163-192). The browser port gated
+ * on the mode correctly but used the RAW attribute, so `title="_Files"` produced
+ * the tooltip `_Files`; the NativeScript port has no tooltip at all.
+ */
+export declare const INLINE_TOOLTIP_VECTORS: ReadonlyArray<InlineTooltipVector>;
+/** The derived per-button model a vector expects. */
+export interface ExpectedViewSwitcherButton {
+    /** Position in the page list. */
+    pageIndex: number;
+    /** The page name. */
+    name: string;
+    /** The text painted on the button. */
+    label: string;
+    /** The icon name painted on the button, never empty. */
+    iconName: string;
+    /** Whether the button is shown at all. */
+    visible: boolean;
+    /** Whether it is the selected one. */
+    selected: boolean;
+    /** Icon/label arrangement, from the policy. */
+    orientation: 'horizontal' | 'vertical';
+    /** Badge text, `''` for none. */
+    badgeLabel: string;
+    /** Whether the needs-attention dot is painted. */
+    needsAttention: boolean;
+    /** Screen-reader description, `''` for none. */
+    description: string;
+}
+/** One `buildViewSwitcherButtons` expectation. */
+export interface ViewSwitcherButtonVector {
+    /** What this row pins down. */
+    rule: string;
+    /** The C function + lines it is derived from. */
+    derivedFrom: string;
+    /** The pages, in order. */
+    pages: readonly ViewSwitcherVectorPage[];
+    /** The selected PAGE index, `-1` for none. */
+    selected: number;
+    /** `AdwViewSwitcher:policy`. */
+    policy: AdwViewSwitcherPolicy;
+    /** One model per page — the index space is preserved, hidden buttons included. */
+    buttons: readonly ExpectedViewSwitcherButton[];
+}
+/**
+ * `AdwViewSwitcher`'s per-button derivation: `populate_switcher` adds a button
+ * for EVERY page (adw-view-switcher.c:230-238) and `update_button` decides what
+ * it shows and whether it is visible (:149-182).
+ */
+export declare const VIEW_SWITCHER_BUTTON_VECTORS: ReadonlyArray<ViewSwitcherButtonVector>;
+/** The derived per-toggle model a vector expects. */
+export interface ExpectedInlineToggle {
+    /** Position among the toggles — compacted. */
+    toggleIndex: number;
+    /** Position in the page list — libadwaita's `child-index`. */
+    pageIndex: number;
+    /** The page name. */
+    name: string;
+    /** The text painted on the toggle. */
+    label: string;
+    /** The icon name painted on the toggle, never empty. */
+    iconName: string;
+    /** Whether this display mode builds an icon. */
+    showIcon: boolean;
+    /** Whether this display mode builds a label. */
+    showLabel: boolean;
+    /** Tooltip text, `''` outside icons mode. */
+    tooltip: string;
+    /** Badge text, `''` for none. */
+    badgeLabel: string;
+    /** Whether the needs-attention dot is painted. */
+    needsAttention: boolean;
+    /** Screen-reader description, `''` for none. */
+    description: string;
+}
+/** One `buildInlineToggles` + index-mapping expectation. */
+export interface InlineToggleVector {
+    /** What this row pins down. */
+    rule: string;
+    /** The C function + lines it is derived from. */
+    derivedFrom: string;
+    /** The pages, in order. */
+    pages: readonly ViewSwitcherVectorPage[];
+    /** `AdwInlineViewSwitcher:display-mode`. */
+    displayMode: AdwInlineViewSwitcherDisplayMode;
+    /** One model per VISIBLE page. */
+    toggles: readonly ExpectedInlineToggle[];
+    /** `toggleIndexForPage` for every page index, in order — `-1` for a hidden page. */
+    toggleIndexByPage: readonly number[];
+    /** `pageIndexForToggle` for every toggle index, in order. */
+    pageIndexByToggle: readonly number[];
+}
+/**
+ * The inline switcher's TWO index spaces, plus what each display mode builds.
+ *
+ * `populate_group` calls `add_toggle` only for visible pages and passes the PAGE
+ * index `i`, which `add_toggle` stashes as `child-index`
+ * (adw-inline-view-switcher.c:370-378, :346); `notify_active_cb` reads it back
+ * (:114-129) and `selection_changed_cb` walks the other way (:434-453). Neither
+ * port filtered hidden pages, so the mapping looked like the identity and the
+ * `-1` sentinel had no spelling.
+ */
+export declare const INLINE_TOGGLE_VECTORS: ReadonlyArray<InlineToggleVector>;
+/** One change notification, in the order it is emitted. */
+export interface ViewSwitcherVectorChange {
+    /** Index of the newly-selected page, `-1` for none. */
+    selected: number;
+    /** Its name, `''` for none. */
+    name: string;
+    /** Its painted label, `''` for none. */
+    title: string;
+    /** `true` for a user activation or an explicit select; `false` for an auto-pick. */
+    interactive: boolean;
+}
+/** One operation a selection vector applies after its pages exist. */
+export type ViewSwitcherVectorOp = {
+    readonly kind: 'selectIndex';
+    readonly index: number;
+} | {
+    readonly kind: 'selectName';
+    readonly name: string | null | undefined;
+} | {
+    readonly kind: 'setPageVisible';
+    readonly name: string;
+    readonly visible: boolean;
+};
+/** One end-to-end switcher-selection expectation. */
+export interface ViewSwitcherSelectionVector {
+    /** What this row pins down. */
+    rule: string;
+    /** The C function + lines it is derived from. */
+    derivedFrom: string;
+    /** The pages, set in this order. */
+    pages: readonly ViewSwitcherVectorPage[];
+    /** Changes emitted WHILE the pages are set (the auto-pick), in order. */
+    setupChanges: readonly ViewSwitcherVectorChange[];
+    /** Operations applied after the pages exist. */
+    ops: readonly ViewSwitcherVectorOp[];
+    /**
+     * Return value of each op, in order. Asserted by the core and NativeScript
+     * suites; the browser suite drives property setters, which return nothing,
+     * and asserts `changes` plus the final state instead.
+     */
+    opResults: readonly boolean[];
+    /** Changes emitted BY the ops, in order. */
+    changes: readonly ViewSwitcherVectorChange[];
+    /** Final selected page index, `-1` for none. */
+    selected: number;
+    /** Final selected page name, `''` for none. */
+    selectedName: string;
+    /** Final selected page label, `''` for none. */
+    selectedTitle: string;
+    /** Expected diagnostics (C's `g_warning` texts), when the row exercises them. */
+    diagnostics?: readonly string[];
+}
+/**
+ * The selection machine a switcher drives, which is the bound stack's — the
+ * switcher owns no selection property of its own (adw-view-switcher.c:126-147
+ * goes straight to `gtk_selection_model_select_item`).
+ *
+ * The refusal rows are the ones both ports failed differently: the browser
+ * switcher CLAMPED an out-of-range or negative index into range (so `active="-1"`
+ * jumped to the first page and `active="99"` to the last), and both stacks
+ * accepted a fractional index and then matched no page at all.
+ */
+export declare const VIEW_SWITCHER_SELECTION_VECTORS: ReadonlyArray<ViewSwitcherSelectionVector>;
+/** One page-list rebuild expectation. */
+export interface ViewSwitcherRebuildVector {
+    /** What this row pins down. */
+    rule: string;
+    /** The C function + lines it is derived from. */
+    derivedFrom: string;
+    /** The initial pages. */
+    pages: readonly ViewSwitcherVectorPage[];
+    /** A page name to select before the rebuild; omitted keeps the auto-pick. */
+    select?: string;
+    /** The replacement pages. */
+    nextPages: readonly ViewSwitcherVectorPage[];
+    /** Changes emitted BY the rebuild, in order. */
+    changes: readonly ViewSwitcherVectorChange[];
+    /** Selected page index after the rebuild. */
+    selected: number;
+    /** Selected page name after the rebuild. */
+    selectedName: string;
+}
+/**
+ * What happens to the selection when the page list is replaced wholesale — the
+ * shape both renderers actually use (`setViews` on NativeScript, a re-parse on
+ * the browser side).
+ *
+ * libadwaita's selection is a page POINTER compared by identity
+ * (`adw_view_stack_pages_is_selected`, adw-view-stack.c:660-672), so it follows
+ * the page across inserts instead of pinning an index; a rebuild that drops the
+ * selected page falls through to the first-visible auto-pick
+ * (adw-view-switcher.c:258-263).
+ */
+export declare const VIEW_SWITCHER_REBUILD_VECTORS: ReadonlyArray<ViewSwitcherRebuildVector>;
+/** One step of a {@link ViewSwitcherDragVector} script. */
+export type ViewSwitcherDragStep = {
+    readonly kind: 'enter';
+    readonly index: number;
+} | {
+    readonly kind: 'leave';
+    readonly index: number;
+} | {
+    readonly kind: 'advance';
+    readonly ms: number;
+};
+/** One drag-hover auto-switch expectation. */
+export interface ViewSwitcherDragVector {
+    /** What this row pins down. */
+    rule: string;
+    /** The C function + lines it is derived from. */
+    derivedFrom: string;
+    /** The pages. */
+    pages: readonly ViewSwitcherVectorPage[];
+    /** The page index selected before the drag starts. */
+    initial: number;
+    /** The drag script. */
+    steps: readonly ViewSwitcherDragStep[];
+    /** Changes emitted by the script, in order. */
+    changes: readonly ViewSwitcherVectorChange[];
+    /** Selected page index once the script has run. */
+    selected: number;
+}
+/**
+ * `TIMEOUT_EXPAND` — the 500 ms dwell that switches pages mid-drag. Defined
+ * identically in both C files (adw-view-switcher-button.c:14, :58-96;
+ * adw-inline-view-switcher.c:80, :194-236) and present in NEITHER port, which
+ * only ever listened for `click`/`tap`.
+ *
+ * `interactive: true` on the resulting change: the C timeout activates the
+ * toggle, which runs the very same `on_button_toggled` a click does.
+ */
+export declare const VIEW_SWITCHER_DRAG_VECTORS: ReadonlyArray<ViewSwitcherDragVector>;
+/** A deterministic stand-in for a platform timer, driven by {@link advance}. */
+export interface ViewSwitcherClock extends ViewSwitcherScheduler {
+    /** Move the clock forward, firing every dwell whose deadline has passed. */
+    advance(ms: number): void;
+    /** How many dwells are still pending. */
+    readonly pending: number;
+}
+/**
+ * A fake clock for the drag vectors.
+ *
+ * Note WHAT it is: a clock, not a stand-in for any behaviour under test. It
+ * schedules and cancels callbacks and nothing else, so it cannot transcribe the
+ * logic it is used to exercise.
+ *
+ * WHO DRIVES THOSE VECTORS: the core suite, and only it. This said "the core,
+ * browser and NativeScript suites all" — a claim of coverage that was never
+ * true, which is worse than silence, because it reads as a reason to stop
+ * looking. The browser elements construct
+ * `new ViewSwitcherState({ scheduler: domViewSwitcherScheduler })` inline
+ * (`elements/adw-view-switcher.ts`, `elements/adw-inline-view-switcher.ts`), so
+ * there is no seam to hand this clock through, and the NativeScript port has no
+ * drag surface at all. Wiring the browser side means giving the elements a
+ * scheduler seam first.
+ */
+export declare function createViewSwitcherClock(): ViewSwitcherClock;

package/lib/types/conformance/wrap-box.d.ts

@@ -0,0 +1,185 @@
+import type { AdwWrapBoxJustify, AdwWrapPolicy, WrapBoxLineLayout } from '../wrap-box.js';
+/** One row of the decision table. */
+export interface WrapBoxLineVector {
+    /** The widget's `justify` property. */
+    justify: AdwWrapBoxJustify;
+    /** The widget's `justify-last-line` property. */
+    justifyLastLine: boolean;
+    /** The widget's `align` property, already validated into `[0, 1]`. */
+    align: number;
+    /**
+     * Whether this is the FINAL line — `i == *n_lines - 1`
+     * (adw-wrap-layout.c:463-464). Note it is the final line, NOT merely an
+     * incomplete one: a wrap box whose children all fit on one line has that
+     * line as its last, so by default `justify` does nothing to it at all.
+     */
+    lastLine: boolean;
+    /**
+     * How many children the line holds. Only `spread` reads it, and only to
+     * distinguish 1 from more (adw-wrap-layout.c:338).
+     */
+    childrenInLine: number;
+    /** What the renderer must do. */
+    layout: WrapBoxLineLayout;
+    /** The rule or edge case this row pins down. */
+    rule: string;
+}
+/**
+ * The line-layout decision, row by row (adw-wrap-layout.c:317-341, :397-400,
+ * :705-706, :717-725).
+ *
+ * Two rows are counter-intuitive and are the reason the table exists rather than
+ * a sentence in a comment. First, `lastLine` is the FINAL line whether or not it
+ * is full, so the single-line case — the common one — is governed by
+ * `justify-last-line`, not by `justify`. Second, `spread` with exactly ONE child
+ * in the line does not spread anything: `n_children > 1` guards the branch that
+ * keeps children at `minimum_size`, so a lone child is STRETCHED instead, which
+ * the property documentation states outright (adw-wrap-box.c:349-352).
+ */
+export declare const WRAP_BOX_LINE_VECTORS: ReadonlyArray<WrapBoxLineVector>;
+/** One `child-spacing` / `line-spacing` normalisation expectation. */
+export interface WrapBoxSpacingVector {
+    /**
+     * The value handed to the setter. A string is what an HTML attribute or an
+     * XML layout carries; a number is what a JS property setter gets. C only
+     * ever sees an `int`, so the string rows are the PORTS' own edge — they
+     * exist because the browser port propagated `NaN` into the style where the
+     * NativeScript port coerced it to 0.
+     */
+    value: number | string | null;
+    /** The value the widget stores and lays out with. */
+    spacing: number;
+    /** The rule this row pins down. */
+    rule: string;
+}
+/**
+ * `adw_wrap_box_set_child_spacing` / `set_line_spacing`
+ * (adw-wrap-box.c:587-588, :927-928) — a negative spacing is clamped to 0
+ * BEFORE anything else happens, so it never reaches the layout.
+ *
+ * The property is declared with a minimum of 0 (adw-wrap-box.c:285-287,
+ * :393-395), which is why the clamp exists at all: without it GObject would
+ * reject the value and warn.
+ */
+export declare const WRAP_BOX_SPACING_VECTORS: ReadonlyArray<WrapBoxSpacingVector>;
+/** One "does the setter report a change" expectation. */
+export interface WrapBoxSpacingNotifyVector {
+    /** The spacing the widget already holds. */
+    from: number;
+    /** The value handed to the setter. */
+    value: number | string;
+    /** Whether the setter reaches `g_object_notify_by_pspec` at all. */
+    notifies: boolean;
+    /** The rule this row pins down. */
+    rule: string;
+}
+/**
+ * The early return in `adw_wrap_box_set_child_spacing`
+ * (adw-wrap-box.c:592-593, :930-931): the comparison happens AFTER the clamp,
+ * so setting `-5` on a box that already holds 0 changes nothing and notifies
+ * nobody. The browser port compared raw attribute strings and fired
+ * `notify::child-spacing` for a value libadwaita had normalised away.
+ */
+export declare const WRAP_BOX_SPACING_NOTIFY_VECTORS: ReadonlyArray<WrapBoxSpacingNotifyVector>;
+/**
+ * Every `notify::` an `Adw.WrapBox` emits — the thirteen installed pspecs
+ * (adw-wrap-box.c:284-495) plus the overridden `orientation` (:497).
+ *
+ * The count is the assertion. C notifies on all fourteen; the browser port
+ * notified on TWO (`child-spacing`, `line-spacing`) and the NativeScript port on
+ * none, so a consumer binding to any other property was watching a signal that
+ * could not fire. A roster is the only shape that fails when a property is ADDED
+ * without its notification, which is how the first twelve went missing.
+ */
+export declare const WRAP_BOX_NOTIFY_PROPERTIES: readonly string[];
+/** One `wrap-policy` → child-shrink expectation. */
+export interface WrapBoxPolicyVector {
+    /** The authored value. Anything not in the enum leaves the property at its default. */
+    value: unknown;
+    /** The stored policy. */
+    policy: AdwWrapPolicy;
+    /** The `flex-shrink` a child gets — `FlexboxLayout.setFlexShrink` on NativeScript. */
+    flexShrink: number;
+    /** The rule this row pins down. */
+    rule: string;
+}
+/**
+ * `Adw.WrapBox:wrap-policy` (adw-wrap-box.c:476-495).
+ *
+ * The default is `natural`, which is the RESTRICTIVE one: a line wraps as soon
+ * as the next child would not fit at its natural size. `minimum` packs harder by
+ * squeezing children down to their minimum first. Both renderers had neither, so
+ * they inherited whatever their flex container defaults to — and CSS defaults
+ * `flex-shrink` to 1, i.e. to `minimum`, the value libadwaita does NOT default to.
+ */
+export declare const WRAP_BOX_POLICY_VECTORS: ReadonlyArray<WrapBoxPolicyVector>;
+/** One length-unit conversion expectation. */
+export interface WrapBoxLengthVector {
+    /** The property value, in `unit`. */
+    value: number;
+    /** The authored unit. Anything outside the enum falls back to the `px` default. */
+    unit: unknown;
+    /** The `gtk-xft-dpi` the renderer reports. */
+    dpi: number;
+    /** The resolved pixel length. */
+    px: number;
+    /** The rule this row pins down. */
+    rule: string;
+}
+/**
+ * `adw_length_unit_to_px` as the three wrap-box length properties reach it
+ * (adw-wrap-layout.c:554-565, :798-804).
+ *
+ * The wrap box defaults its units to `px` where the split views default to `sp`
+ * (adw-wrap-box.c:300-305) — the same helper, two different defaults, which is
+ * why the fallback is the caller's argument and not the helper's.
+ */
+export declare const WRAP_BOX_LENGTH_VECTORS: ReadonlyArray<WrapBoxLengthVector>;
+/** One `natural-line-length` normalisation expectation. */
+export interface WrapBoxNaturalLengthVector {
+    /** The authored value. */
+    value: unknown;
+    /** The stored length, `-1` when unset. */
+    length: number;
+    /** The rule this row pins down. */
+    rule: string;
+}
+/**
+ * `Adw.WrapBox:natural-line-length` — `g_param_spec_int (…, -1, G_MAXINT, -1, …)`
+ * (adw-wrap-box.c:438-441).
+ *
+ * `-1` means UNSET, not "zero length", so it is the landing place for everything
+ * out of range: a GObject setter would have refused those and left the property
+ * where it was, and unset is where it was born.
+ */
+export declare const WRAP_BOX_NATURAL_LENGTH_VECTORS: ReadonlyArray<WrapBoxNaturalLengthVector>;
+/** One `insert_child_after` / `reorder_child_after` expectation. */
+export interface WrapBoxChildOrderVector {
+    /** Which operation is being resolved. */
+    op: 'insert-after' | 'reorder-after';
+    /** The box's children before the call. */
+    children: readonly string[];
+    /** The child being placed. */
+    child: string;
+    /** The sibling to place it after, or `null` for the FIRST position. */
+    sibling: string | null;
+    /** The children afterwards, or `null` when the call is refused. */
+    result: readonly string[] | null;
+    /** The rule this row pins down. */
+    rule: string;
+}
+/**
+ * `adw_wrap_box_insert_child_after` (adw-wrap-box.c:1283-1300) and
+ * `adw_wrap_box_reorder_child_after` (:1315-1332), both of which delegate to
+ * `gtk_widget_insert_after (child, self, sibling)`.
+ *
+ * The counter-intuitive rule is the NULL sibling: it inserts at the FIRST
+ * position, not the last. Reading it as "append" is the obvious misreading and a
+ * silent one — the child lands somewhere plausible. Neither renderer had any of
+ * this API, so there was nothing to misread yet, which is the good time to pin it.
+ *
+ * The refusals are the C's `g_return_if_fail`s: an insert wants the child
+ * unparented, a reorder wants it already a child, the sibling must belong to this
+ * box, and `child == sibling` is an explicit early return in both (:1297, :1329).
+ */
+export declare const WRAP_BOX_CHILD_ORDER_VECTORS: ReadonlyArray<WrapBoxChildOrderVector>;