@gjsify/adwaita-core 0.30.0 → 0.32.0

package/lib/types/conformance/preferences.d.ts

@@ -0,0 +1,170 @@
+import type { MakeComparableOptions, PreferencesGroupHeaderInput, PreferencesGroupHeaderState, PreferencesSearchPage, PreferencesSearchRow, SearchRowSubtitleInput } from '../preferences.js';
+/** One `derivePreferencesGroupHeader` expectation. */
+export interface PreferencesGroupHeaderVector {
+    /** The group's title / description / suffix / row count. */
+    input: PreferencesGroupHeaderInput;
+    /** The five states C derives from it. */
+    state: PreferencesGroupHeaderState;
+    /**
+     * Set when the expectation only holds for a renderer that INTERPRETS Pango
+     * markup in its labels. Both current renderers paint the string verbatim
+     * and pass `useMarkup: false`, so their suites skip these rows rather than
+     * assert a rule they deliberately do not implement. Closing the
+     * markup-rendering gap is what retires the flag.
+     */
+    dependsOnMarkup?: boolean;
+    /** Why this row exists — the rule or the regression it pins down. */
+    rule: string;
+}
+/**
+ * `update_title_visibility` / `update_description_visibility` /
+ * `update_listbox_visibility` / `is_single_line` / `update_header_visibility`
+ * (adw-preferences-group.c:91-156).
+ */
+export declare const PREFERENCES_GROUP_HEADER_VECTORS: ReadonlyArray<PreferencesGroupHeaderVector>;
+/** One `defaultCaseFolder` expectation. */
+export interface CaseFoldVector {
+    /** The string being folded. */
+    text: string;
+    /** `g_utf8_casefold(text)` — Unicode FULL case folding. */
+    folded: string;
+    /** What a bare `toLowerCase()` returns, kept in the table as the trap. */
+    naiveLowerCase: string;
+    /** Why this row exists. */
+    rule: string;
+}
+/**
+ * `g_utf8_casefold` (adw-preferences-dialog.c:101, :133).
+ *
+ * Every row where `folded !== naiveLowerCase` is a query a `toLowerCase()` port
+ * silently fails to match — in German, Greek and any text with a typographic
+ * ligature. None of it is visible in an ASCII test suite, which is exactly why
+ * the rows are here.
+ */
+export declare const CASE_FOLD_VECTORS: ReadonlyArray<CaseFoldVector>;
+/** One `stripMarkup` expectation. */
+export interface StripMarkupVector {
+    /** The (already folded, in the real pipeline) markup string. */
+    markup: string;
+    /** The plain text, or `null` when `pango_parse_markup` fails. */
+    plain: string | null;
+    /** Why this row exists. */
+    rule: string;
+}
+/**
+ * `pango_parse_markup (…, accel_marker 0, …)` as `make_comparable` calls it
+ * (adw-preferences-dialog.c:104-114).
+ *
+ * `null` is not an error case to be smoothed over: it is the branch where C
+ * logs a `g_critical` and KEEPS the unparsed string, so every `null` row below
+ * is a row that must stay searchable under its literal spelling.
+ */
+export declare const STRIP_MARKUP_VECTORS: ReadonlyArray<StripMarkupVector>;
+/** One `stripMnemonic` expectation. */
+export interface StripMnemonicVector {
+    /** The label text with accel markers. */
+    text: string;
+    /** What `adw_strip_mnemonic` returns. */
+    stripped: string;
+    /** Why this row exists. */
+    rule: string;
+}
+/**
+ * `adw_strip_mnemonic` (adw-widget-utils.c:685-703) — `g_markup_escape_text`
+ * followed by `pango_parse_markup` with `accel_marker = '_'`.
+ */
+export declare const STRIP_MNEMONIC_VECTORS: ReadonlyArray<StripMnemonicVector>;
+/** One `makeComparable` expectation. */
+export interface MakeComparableVector {
+    /** The raw title or subtitle. */
+    source: string;
+    /** The row flags plus the title/subtitle `allowUnderline` distinction. */
+    options: MakeComparableOptions;
+    /** What the search compares against. */
+    comparable: string;
+    /** Why this row exists. */
+    rule: string;
+}
+/**
+ * `make_comparable` (adw-preferences-dialog.c:96-123).
+ *
+ * The defaults matter as much as the rows: `use-markup` defaults to TRUE
+ * (adw-preferences-row.c:185-188) and `use-underline` to FALSE (:155-158), so
+ * an ordinary row's title IS markup-parsed and is NOT mnemonic-stripped.
+ */
+export declare const MAKE_COMPARABLE_VECTORS: ReadonlyArray<MakeComparableVector>;
+/** One `rowMatchesQuery` expectation. */
+export interface RowMatchVector {
+    /** The row being tested. */
+    row: PreferencesSearchRow;
+    /** What the user typed into the search entry. */
+    query: string;
+    /** Whether `filter_search_results` keeps the row. */
+    matches: boolean;
+    /** Why this row exists. */
+    rule: string;
+}
+/** `filter_search_results` (adw-preferences-dialog.c:125-153). */
+export declare const ROW_MATCH_VECTORS: ReadonlyArray<RowMatchVector>;
+/** One `collectSearchRows` expectation. */
+export interface SearchCorpusVector {
+    /** The page tree being indexed. */
+    pages: readonly PreferencesSearchPage[];
+    /** The row titles the corpus contains, in order. */
+    titles: readonly string[];
+    /** Why this row exists. */
+    rule: string;
+}
+/**
+ * The three-filter chain: `adw_preferences_dialog_init`'s visible-page filter
+ * (:632-641) over `adw_preferences_page_get_rows`' `is_visible_group`
+ * (adw-preferences-page.c:831-834) over `adw_preferences_group_get_rows`'
+ * `row_has_title` (adw-preferences-group.c:736-740).
+ *
+ * Dropping any clause is invisible — nothing errors, the search just quietly
+ * indexes the wrong set — which is why these rows are separate from the
+ * end-to-end ones.
+ */
+export declare const SEARCH_CORPUS_VECTORS: ReadonlyArray<SearchCorpusVector>;
+/** One `createSearchRowSubtitle` expectation. */
+export interface SearchRowSubtitleVector {
+    /** The matched row's ancestors, plus the visible-page count. */
+    input: SearchRowSubtitleInput;
+    /** The second line of the result row, `null` for none. */
+    subtitle: string | null;
+    /** Why this row exists. */
+    rule: string;
+}
+/** `create_search_row_subtitle` (adw-preferences-dialog.c:168-234). */
+export declare const SEARCH_ROW_SUBTITLE_VECTORS: ReadonlyArray<SearchRowSubtitleVector>;
+/**
+ * The page tree both renderer suites materialise into real widgets.
+ *
+ * Chosen so every clause of the pipeline is exercised by at least one query:
+ * two visible pages (so subtitles carry the arrow) plus a hidden third, a hidden
+ * group, an untitled row, an action row with a searchable subtitle, an entry row
+ * whose subtitle must NOT be searched, a German title for the fold, and a
+ * markup title.
+ */
+export declare const PREFERENCES_SEARCH_PAGES: ReadonlyArray<PreferencesSearchPage>;
+/** One expected search result, as a renderer can read it off its own result row. */
+export interface PreferencesSearchExpectation {
+    /** The result row's title — copied verbatim from the matched row. */
+    title: string;
+    /** The result row's subtitle. */
+    subtitle: string | null;
+}
+/** One end-to-end `searchPreferences` expectation over {@link PREFERENCES_SEARCH_PAGES}. */
+export interface PreferencesSearchVector {
+    /** What the user typed. */
+    query: string;
+    /** The results, in corpus order. */
+    results: readonly PreferencesSearchExpectation[];
+    /** Why this row exists. */
+    rule: string;
+}
+/**
+ * The whole pipeline over {@link PREFERENCES_SEARCH_PAGES} — corpus, filter and
+ * subtitle at once. This is the table a renderer drives its own widgets with.
+ */
+export declare const PREFERENCES_SEARCH_VECTORS: ReadonlyArray<PreferencesSearchVector>;

package/lib/types/conformance/rows.d.ts

@@ -0,0 +1,51 @@
+import type { AdwComboOption, ComboStateChange } from '../rows.js';
+/**
+ * One mutation in a combo scenario. DATA, not a closure: a renderer suite
+ * replays these against a real widget (set the options, pick from the chooser)
+ * and compares what the user would see.
+ */
+export type ComboSelectionStep = {
+    op: 'setOptions';
+    options: ReadonlyArray<AdwComboOption>;
+} | {
+    op: 'setSelectedIndex';
+    index: number;
+} | {
+    op: 'setSelectedValue';
+    value: string;
+} | {
+    op: 'select';
+    index: number;
+};
+/** One combo-selection scenario. */
+export interface ComboSelectionVector {
+    /** Short scenario name. */
+    name: string;
+    /** The mutations, applied in order to a fresh state. */
+    steps: readonly ComboSelectionStep[];
+    /** `selectedIndex` afterwards. */
+    selected: number;
+    /** `selectedValue` afterwards — `''` when the index sits outside the options. */
+    value: string;
+    /** `selectedLabel` afterwards — the text the inline value / button shows. */
+    label: string;
+    /**
+     * Every change the state emits, in order. This IS the renderer's feed: the
+     * label repaint comes off `label`, and the `notify::selected` re-emit is
+     * gated on `interactive`.
+     */
+    emitted: ReadonlyArray<ComboStateChange>;
+    /** Why this row exists — the rule or edge case it pins down. */
+    rule: string;
+}
+/**
+ * `adw_combo_row_set_selected` (adw-combo-row.c:772-789) and the notify chain it
+ * drives (:136-155, :157-185), plus the two port answers the C leaves open (see
+ * the module header).
+ *
+ * Note that EVERY scenario starts with a `setOptions`, which is itself an
+ * emission: the model is what the label is read out of, so a renderer that
+ * repaints only on a selection change draws a stale value after the list is
+ * replaced. That first change is in `emitted` for exactly that reason.
+ */
+export declare const COMBO_SELECTION_VECTORS: ReadonlyArray<ComboSelectionVector>;

package/lib/types/conformance/sidebar.d.ts

@@ -0,0 +1,182 @@
+import type { AdwSidebarItemSpec, AdwSidebarSectionSpec, SidebarHeaderSpec } from '../sidebar.js';
+/** One `clampSidebarSelection` expectation. */
+export interface SidebarClampVector {
+    /** The index handed to `AdwSidebar:selected`. */
+    index: number;
+    /** How many items the sidebar has (`n_items`). */
+    count: number;
+    /** What `selected` reads back as: the index itself, or `-1` for no selection. */
+    selected: number;
+    /** Why this row exists. */
+    rule: string;
+}
+/**
+ * `adw_sidebar_set_selected` (adw-sidebar.c:3028-3029):
+ * `if (selected >= self->n_items) selected = GTK_INVALID_LIST_POSITION;`
+ *
+ * The negative rows are not a TS invention — `selected` is a `guint`, so `-7`
+ * arrives as `4294967289`, which is `>= n_items`. The fractional/`NaN` rows are
+ * the generalisation to values C cannot express: not a valid position is no
+ * position. They are the inputs that used to be wrong — the web port truncated
+ * `"1.5"` to row 1 and the NativeScript port stored `1.5` verbatim, highlighting
+ * no row while reporting a selection.
+ */
+export declare const SIDEBAR_CLAMP_VECTORS: ReadonlyArray<SidebarClampVector>;
+/** One `adjustSidebarSelection` expectation — an `items-changed` splice. */
+export interface SidebarItemsChangedVector {
+    /** `selected` before the splice. */
+    selected: number;
+    /** `n_items` before the splice. */
+    oldCount: number;
+    /** `n_items` after the splice. */
+    newCount: number;
+    /** Flat index the splice starts at. */
+    position: number;
+    /** How many items were removed. */
+    removed: number;
+    /** How many items were added. */
+    added: number;
+    /** `selected` after `items_changed_cb` has run. */
+    expected: number;
+    /** Why this row exists. */
+    rule: string;
+}
+/**
+ * `items_changed_cb` (adw-sidebar.c:2246-2284) — the derivation NEITHER port had.
+ *
+ * The last row documents libadwaita's unsigned wraparound: with no selection,
+ * `selected` is `G_MAXUINT`, so the "splice covers the selection" test can never
+ * fire and the shift branch computes `G_MAXUINT + added - removed`, which wraps
+ * into range. It is reproduced rather than repaired — a renderer that "fixed" it
+ * would stop matching the toolkit it mirrors.
+ */
+export declare const SIDEBAR_ITEMS_CHANGED_VECTORS: ReadonlyArray<SidebarItemsChangedVector>;
+/** One flattened-model expectation for a whole section list. */
+export interface SidebarModelVector {
+    /** Human-readable name, used as the test title. */
+    name: string;
+    /** The declared sections. */
+    sections: ReadonlyArray<AdwSidebarSectionSpec>;
+    /** `n_items` — the size of the selection index space. */
+    count: number;
+    /** `adw_sidebar_section_get_first_index` per section, in declaration order. */
+    sectionFirstIndex: ReadonlyArray<number>;
+    /** Every rendered row, in render order. */
+    flat: ReadonlyArray<{
+        index: number;
+        sectionIndex: number;
+        sectionItemIndex: number;
+        title: string;
+    }>;
+    /** The headers that get drawn, in render order. */
+    headers: ReadonlyArray<SidebarHeaderSpec>;
+    /** Why this row exists. */
+    rule: string;
+}
+/**
+ * The flat index space (`items_changed_cb`'s section walk, adw-sidebar.c:2261-2267
+ * + `adw_sidebar_item_get_index`, adw-sidebar-item.c:1040) and the header
+ * derivation (`set_header_cb`/`create_header`, adw-sidebar.c:1532-1563, :1483-1530).
+ *
+ * The empty-leading-section rows are the ones the web port got wrong: it keyed
+ * `.first` and the hidden-separator case off the DECLARATION index, so an empty
+ * or fully-filtered first section drew a stray separator and cost section 1 the
+ * flush-to-top padding `.header.first > .heading` prescribes.
+ */
+export declare const SIDEBAR_MODEL_VECTORS: ReadonlyArray<SidebarModelVector>;
+/** One item-label-visibility expectation. */
+export interface SidebarItemFlagsVector {
+    /** The declared item. */
+    item: AdwSidebarItemSpec;
+    /** `string_is_not_empty(title)` (adw-sidebar.c:1411-1412). */
+    titleVisible: boolean;
+    /** `string_is_not_empty(subtitle)` (adw-sidebar.c:1420-1421). */
+    subtitleVisible: boolean;
+    /** `notify_icon_cb`'s `icon_name && *icon_name` (adw-sidebar.c:1303). */
+    iconVisible: boolean;
+    /** Why this row exists. */
+    rule: string;
+}
+/**
+ * The three `string_is_not_empty` bindings, so renderers stop spelling
+ * `x.length === 0` themselves — and so the `'-symbolic'` row pins that icon
+ * visibility is decided on the RAW name, before any suffix stripping.
+ */
+export declare const SIDEBAR_ITEM_FLAG_VECTORS: ReadonlyArray<SidebarItemFlagsVector>;
+/** One activation (row click) expectation. */
+export interface SidebarActivationVector {
+    /** Human-readable name, used as the test title. */
+    name: string;
+    /** The declared sections. */
+    sections: ReadonlyArray<AdwSidebarSectionSpec>;
+    /** The selection to establish before clicking, applied through `setSelected`. */
+    initialSelected: number;
+    /** The flat index that is clicked. */
+    activate: number;
+    /** Whether a row was actually activated — the `activated` signal. */
+    activated: boolean;
+    /** Whether `notify::selected` fired. */
+    selectionChanged: boolean;
+    /** `selected` afterwards. */
+    selected: number;
+    /** Why this row exists. */
+    rule: string;
+}
+/**
+ * The selection/activation split: `row-selected` fires only on a real change,
+ * `row-activated` fires on EVERY click (adw-sidebar.c:1585-1612), and page mode
+ * does the same thing in one callback (`boxed_row_activated_cb`, :1662-1674).
+ *
+ * The re-click row is the one that matters: it is the documented way to reveal
+ * the content pane of a split view (adw-sidebar.c:73-75), and the NativeScript
+ * port could not express it at all — its setter early-returned on an unchanged
+ * index and it emitted no activation signal.
+ */
+export declare const SIDEBAR_ACTIVATION_VECTORS: ReadonlyArray<SidebarActivationVector>;
+/** One filter / empty-state expectation. */
+export interface SidebarFilterVector {
+    /** Human-readable name, used as the test title. */
+    name: string;
+    /** The declared sections. */
+    sections: ReadonlyArray<AdwSidebarSectionSpec>;
+    /** Item titles the filter keeps; the suites build `(item) => keepTitles.includes(item.title)`. */
+    keepTitles: ReadonlyArray<string>;
+    /** `n_items` — UNCHANGED by the filter, because the selection counts the unfiltered model. */
+    count: number;
+    /** Flat indices of the rows that survive the filter, in render order. */
+    visibleIndices: ReadonlyArray<number>;
+    /** The headers that get drawn once the filter is applied. */
+    headers: ReadonlyArray<SidebarHeaderSpec>;
+    /** The `.empty` / placeholder state — computed from the FILTERED count. */
+    isEmpty: boolean;
+    /** Why this row exists. */
+    rule: string;
+}
+/**
+ * `adw_sidebar_set_filter` (adw-sidebar.c:3127-3139) feeds a `GtkFilterListModel`
+ * that only the row list and the placeholder see; the selection index space stays
+ * on the unfiltered `items_model` (adw-sidebar.c:2866 vs :2177-2180), and
+ * `update_placeholder` counts the filtered one (adw-sidebar.c:1828, :1839-1842).
+ *
+ * Neither port had a filter or a placeholder at all.
+ */
+export declare const SIDEBAR_FILTER_VECTORS: ReadonlyArray<SidebarFilterVector>;
+/** One mode expectation. */
+export interface SidebarModeVector {
+    /** The mode being set. */
+    mode: 'sidebar' | 'page';
+    /** Whether the selection is PAINTED in that mode. */
+    selectionVisible: boolean;
+    /** Why this row exists. */
+    rule: string;
+}
+/**
+ * `adw_sidebar_set_mode` (adw-sidebar.c:2960-2981) never touches `selected`:
+ * "In this mode, the selection is invisible and only tracked to determine the
+ * initially selected item once switched back to sidebar mode" (adw-sidebar.c:2948-2951).
+ *
+ * The web port painted its `.selected` highlight in BOTH modes; page mode builds
+ * plain `AdwActionRow`s in a boxed list (`create_boxed_row`, adw-sidebar.c:1676)
+ * and shows no selected row at all.
+ */
+export declare const SIDEBAR_MODE_VECTORS: ReadonlyArray<SidebarModeVector>;

package/lib/types/conformance/split-button.d.ts

@@ -0,0 +1,189 @@
+import type { AdwArrowIcon, AdwMenuEntry, SplitButtonContentMode, SplitButtonDirection, SplitButtonHalfState, SplitButtonProperty, SplitButtonStyleClass } from '../split-button.js';
+/** One mutation in a {@link SplitButtonContentVector} sequence, with its outcome. */
+export interface SplitButtonContentStep {
+    /** Which slot is being set. */
+    op: 'label' | 'icon-name' | 'child';
+    /**
+     * The value passed. For `label`/`icon-name` the string itself; for `child` a
+     * KEY naming one of three distinct child objects the driver supplies, or
+     * `null` to clear the content.
+     */
+    value: string | null;
+    /** Whether the setter reports a change (and therefore notifies at all). */
+    changed: boolean;
+    /** The `notify::*` properties C emits for this one call, in emission order. */
+    notified: readonly SplitButtonProperty[];
+    /** The content mode after the step. */
+    mode: SplitButtonContentMode;
+    /** `get_label()` after the step. */
+    label: string | null;
+    /** `get_icon_name()` after the step. */
+    iconName: string | null;
+    /** The root style classes after the step. */
+    styleClasses: readonly SplitButtonStyleClass[];
+    /** Why this step exists — the rule or edge case it pins down. */
+    rule: string;
+}
+/** A scripted sequence of content mutations applied to a FRESH state. */
+export interface SplitButtonContentVector {
+    /** Which upstream test (or derivation) this sequence transcribes. */
+    name: string;
+    /** The mutations, in order. */
+    steps: readonly SplitButtonContentStep[];
+}
+/**
+ * The content machine (adw-split-button.c:661-682, :749-771, :799-824).
+ *
+ * Two things in here are easy to get wrong and are asserted explicitly. First,
+ * the `notified` ORDER: C freezes, notifies the slots it is about to CLEAR, sets
+ * the new one, notifies it, then thaws — so one `set_label()` can emit three
+ * notifications. Second, `child` is notified far more often than a reader
+ * expects, because `adw_split_button_get_child()` returns GtkButton's INTERNAL
+ * label/image widget in label/icon mode (the upstream suite states this at
+ * tests/test-split-button.c:155-157) and the C guard tests that pointer, not
+ * whether the app ever set a child.
+ *
+ * A driver that cannot express a step — a DOM element has no `child` slot —
+ * asserts the sequence up to that step and stops; every sequence is written so
+ * the interesting rows come first.
+ */
+export declare const SPLIT_BUTTON_CONTENT_VECTORS: ReadonlyArray<SplitButtonContentVector>;
+/** One `update_style_classes` expectation. */
+export interface SplitButtonStyleClassVector {
+    /** `gtk_button_get_label()`. */
+    label: string | null;
+    /** `gtk_button_get_icon_name()`. */
+    iconName: string | null;
+    /** The classes on the `splitbutton` node. */
+    classes: readonly SplitButtonStyleClass[];
+    /** Why this row exists. */
+    rule: string;
+}
+/**
+ * `update_style_classes` (adw-split-button.c:145-165). Both branches read the
+ * FIRST CHARACTER, which is why `''` and `'  '` land on opposite sides.
+ */
+export declare const SPLIT_BUTTON_STYLE_CLASS_VECTORS: ReadonlyArray<SplitButtonStyleClassVector>;
+/** One `set_dropdown_tooltip` expectation. */
+export interface SplitButtonTooltipVector {
+    /** The value passed to `adw_split_button_set_dropdown_tooltip`. */
+    tooltip: string;
+    /** What the dropdown actually shows. */
+    text: string;
+    /** Whether it is Pango MARKUP (`set_tooltip_markup`) rather than plain text. */
+    markup: boolean;
+    /** Why this row exists. */
+    rule: string;
+}
+/**
+ * The tooltip fallback (adw-split-button.c:1044-1051, initial value :531-532).
+ *
+ * `has_dropdown_tooltip = tooltip && *tooltip`. The empty branch is the one both
+ * renderers got wrong: the browser port hardcoded `Menu` and, because `''` is not
+ * nullish, `dropdown-tooltip=""` left the button with NO accessible name at all;
+ * the NativeScript port had neither tooltip nor accessible name.
+ */
+export declare const SPLIT_BUTTON_TOOLTIP_VECTORS: ReadonlyArray<SplitButtonTooltipVector>;
+/** One direction expectation. */
+export interface SplitButtonDirectionVector {
+    /** The `GtkArrowType`. */
+    direction: SplitButtonDirection;
+    /** The symbolic icon the arrow node draws. */
+    arrowIcon: AdwArrowIcon;
+    /** Where the popup is placed. */
+    popupDirection: SplitButtonDirection;
+    /** Why this row exists — naming the selector that WINS, not the one that loses. */
+    rule: string;
+}
+/**
+ * Direction → glyph for the dropdown half of a SPLIT BUTTON, and → popup
+ * placement (adw-split-button.c:415).
+ *
+ * `none` is the row that matters, and it is the row that was WRONG here until the
+ * override was found: the four shared directions come from `menubutton arrow`
+ * (_buttons.scss:457-468), but `.none` is re-declared inside `splitbutton { … }`
+ * at :621-623, and that selector wins. See the header of `./index.ts` — "cite the
+ * winning selector" — for what this table cost.
+ */
+export declare const SPLIT_BUTTON_DIRECTION_VECTORS: ReadonlyArray<SplitButtonDirectionVector>;
+/**
+ * The same axis for a PLAIN `menubutton`, where nothing overrides `.none`.
+ *
+ * This table is not decoration: it is what makes the split button's row above a
+ * demonstrated OVERRIDE rather than an assertion. Holding both means a reader can
+ * see the two values and the two selectors side by side, and a renderer that
+ * reaches for the wrong one fails a test that names which widget it is drawing.
+ */
+export declare const MENU_BUTTON_DIRECTION_VECTORS: ReadonlyArray<SplitButtonDirectionVector>;
+/** One `update_state` expectation. */
+export interface SplitButtonRootStateVector {
+    /** State flags of the action half. */
+    action: SplitButtonHalfState;
+    /** State flags of the dropdown (arrow) half. */
+    dropdown: SplitButtonHalfState;
+    /** Whether the root reads ACTIVE. */
+    active: boolean;
+    /** Whether the root reads CHECKED. */
+    checked: boolean;
+    /** Why this row exists. */
+    rule: string;
+}
+/**
+ * `update_state` (adw-split-button.c:118-143) — an OR-fold of both halves onto
+ * the root, which is what `splitbutton.flat:active/:checked` styles
+ * (_buttons.scss:542-549).
+ */
+export declare const SPLIT_BUTTON_ROOT_STATE_VECTORS: ReadonlyArray<SplitButtonRootStateVector>;
+/** One `parseMenuEntries` expectation. */
+export interface SplitButtonMenuParseVector {
+    /** The raw `menu` attribute (or `null` when absent). */
+    json: string | null;
+    /** The entries it yields. */
+    entries: readonly AdwMenuEntry[];
+    /** Why this row exists. */
+    rule: string;
+}
+/**
+ * Menu-attribute parsing — the byte-identical helper both browser elements
+ * carried. Total: nothing an author can type may prevent the widget upgrading.
+ */
+export declare const SPLIT_BUTTON_MENU_PARSE_VECTORS: ReadonlyArray<SplitButtonMenuParseVector>;
+/** One activate-by-position expectation. */
+export interface SplitButtonMenuActivationVector {
+    /** The menu model. */
+    entries: readonly AdwMenuEntry[];
+    /** The position activated. */
+    index: number;
+    /** The entry that must be dispatched, or `null`. */
+    activated: AdwMenuEntry | null;
+    /** Why this row exists. */
+    rule: string;
+}
+/**
+ * Activation is BY POSITION, never by label lookup: a `GMenuModel` addresses its
+ * items by index and each carries its own detailed action (adw-split-button.c:385-388).
+ */
+export declare const SPLIT_BUTTON_MENU_ACTIVATION_VECTORS: ReadonlyArray<SplitButtonMenuActivationVector>;
+/**
+ * One dropdown-sensitivity expectation. A driver installs the popover FIRST (when
+ * {@link SplitButtonDropdownVector.popover} is set) and the menu model second, so
+ * a row with both also exercises the dissociation.
+ */
+export interface SplitButtonDropdownVector {
+    /** The menu model to install (empty = none). */
+    entries: readonly AdwMenuEntry[];
+    /** Whether a popover is installed before it. */
+    popover: boolean;
+    /** Whether the dropdown half is live. */
+    enabled: boolean;
+    /** Whether the menu can be popped up at all. */
+    canOpen: boolean;
+    /** Why this row exists. */
+    rule: string;
+}
+/**
+ * "If the menu model is `NULL`, the dropdown is disabled" (adw-split-button.c:376-378),
+ * and the same for the popover (:394-396). An empty entry list is the renderers'
+ * only spelling of "no menu", so it collapses onto the `NULL` case.
+ */
+export declare const SPLIT_BUTTON_DROPDOWN_VECTORS: ReadonlyArray<SplitButtonDropdownVector>;