ngwr 10.2.0 → 11.0.0

package/types/ngwr-textarea.d.ts

@@ -35,8 +35,12 @@ declare class WrTextarea implements FormValueControl<string> {
      */
     readonly ariaLabel: _angular_core.InputSignal<string | null>;
     protected readonly resolvedAriaLabel: _angular_core.Signal<string | null>;
-    /** Control size — shares the `--wr-control-*` contract. @default 'md' */
-    readonly size: _angular_core.InputSignal<WrTextareaSize>;
+    /**
+     * Control size — shares the `--wr-control-*` contract. Unset, it falls back to
+     * `provideWrConfig({ textarea: { size } })`. @default 'md'
+     */
+    readonly size: _angular_core.InputSignal<WrTextareaSize | null>;
+    protected readonly resolvedSize: _angular_core.Signal<"sm" | "md" | "lg">;
     /** Visible row count. @default 3 */
     readonly rows: _angular_core.InputSignalWithTransform<number, unknown>;
     /** Allow user resize via the corner grip. @default true */
@@ -83,6 +87,7 @@ declare class WrTextarea implements FormValueControl<string> {
     protected startResize(event: PointerEvent): void;
     protected onResize(event: PointerEvent): void;
     protected endResize(event: PointerEvent): void;
+    private releaseHeight;
     private autofit;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrTextarea, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrTextarea, "wr-textarea", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "resizable": { "alias": "resizable"; "required": false; "isSignal": true; }; "resize": { "alias": "resize"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "autosize": { "alias": "autosize"; "required": false; "isSignal": true; }; "maxRows": { "alias": "maxRows"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;

package/types/ngwr-toast-testing.d.ts

@@ -0,0 +1,80 @@
+import { BaseHarnessFilters, ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+import { WrToastType } from 'ngwr/toast';
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+
+/** Narrows which toast a harness query matches. */
+interface WrToastHarnessFilters extends BaseHarnessFilters {
+    /** Match the toast's message — a string is an exact match, a RegExp is tested. */
+    readonly message?: string | RegExp;
+    /** Match the toast's title. A toast with no title never matches. */
+    readonly title?: string | RegExp;
+    /** Match the intent: `info`, `success`, `warning` or `danger`. */
+    readonly type?: WrToastType;
+}
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+
+/**
+ * Test harness for a toast shown with `WrToast.show()`.
+ *
+ * Toasts live in the overlay, so load this from
+ * `TestbedHarnessEnvironment.documentRootLoader()`. What is worth asserting on a
+ * toast is mostly what it ANNOUNCES: `getRole()` and `getLiveLevel()` are how a
+ * screen-reader user learns something happened, and they escalate with the
+ * intent — a `danger` toast interrupts, an `info` toast waits its turn.
+ *
+ * @example
+ * ```ts
+ * const rootLoader = TestbedHarnessEnvironment.documentRootLoader(fixture);
+ * const toast = await rootLoader.getHarness(WrToastHarness.with({ type: 'danger' }));
+ *
+ * expect(await toast.getMessage()).toBe('Could not save');
+ * expect(await toast.getRole()).toBe('alert');
+ * await toast.dismiss();
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrToastHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — several toasts are usually stacked. */
+    static with(options?: WrToastHarnessFilters): HarnessPredicate<WrToastHarness>;
+    /** The toast's message line. */
+    getMessage(): Promise<string>;
+    /** The toast's title, or `null` when it was shown without one. */
+    getTitle(): Promise<string | null>;
+    /** The intent, read from the `wr-toast--*` modifier. */
+    getType(): Promise<WrToastType | null>;
+    /** `'alert'` for a danger toast, `'status'` otherwise — how urgently it interrupts. */
+    getRole(): Promise<string | null>;
+    /** `'assertive'` for danger and warning, `'polite'` otherwise. */
+    getLiveLevel(): Promise<string | null>;
+    /** Whether the toast offers a dismiss button. */
+    isDismissible(): Promise<boolean>;
+    /** Whether the toast offers a copy button. */
+    hasCopyAction(): Promise<boolean>;
+    /** Click the dismiss button. Throws on a toast shown `dismissible: false`. */
+    dismiss(): Promise<void>;
+    /** Click the copy button. Throws unless the toast was shown `showCopy: true`. */
+    copy(): Promise<void>;
+    /** Whether the auto-dismiss progress bar is showing. */
+    hasProgressBar(): Promise<boolean>;
+    /** Hover the toast — which is what pauses its auto-dismiss timer. */
+    hover(): Promise<void>;
+    /** Move the pointer away again, resuming the timer. */
+    mouseAway(): Promise<void>;
+}
+
+export { WrToastHarness };
+export type { WrToastHarnessFilters };

package/types/ngwr-toast.d.ts

@@ -39,7 +39,11 @@ interface WrToastOptions {
     readonly duration?: number;
     /** Show a close (×) button. @default true */
     readonly dismissible?: boolean;
-    /** Override the corner for this toast only. */
+    /**
+     * Corner this toast opens in. The whole stack shares one host, so this is
+     * not per-toast: passing a different corner relocates the toasts already on
+     * screen along with this one.
+     */
     readonly position?: WrToastPosition;
     /** Override the progress bar visibility for this toast only. */
     readonly showProgress?: boolean;
@@ -90,7 +94,16 @@ interface WrToastConfig {
     readonly showCloseAll: boolean;
     /** Minimum number of stacked toasts before "Close all" appears. @default 2 */
     readonly closeAllThreshold: number;
-    /** Maximum toasts visible at once. Oldest is dismissed when exceeded. `0` = unlimited. @default 5 */
+    /**
+     * Maximum toasts visible at once. `0` = unlimited.
+     *
+     * Nothing on screen is taken away to make room: once the cap is reached the
+     * *newest* toast waits in a queue, and queued toasts are promoted FIFO as
+     * visible ones dismiss. A queued toast's auto-dismiss countdown only starts
+     * when it becomes visible, so it can never expire unseen.
+     *
+     * @default 5
+     */
     readonly maxStack: number;
     /** Labels rendered in the UI. Keep short — meant to be overridden for i18n. */
     readonly labels: {
@@ -195,13 +208,15 @@ declare class WrToast {
  *       position: 'bottom-end',
  *       showCopy: true,
  *       maxStack: 3,
- *       labels: { close: 'Закрыть', copy: 'Копировать', copied: 'Скопировано', closeAll: 'Закрыть все' },
+ *       labels: { close: 'Закрыть' },
  *     }),
  *   ],
  * });
  * ```
  */
-declare function provideWrToastConfig(config: Partial<WrToastConfig>): EnvironmentProviders;
+declare function provideWrToastConfig(config: Partial<Omit<WrToastConfig, 'labels'>> & {
+    readonly labels?: Partial<WrToastConfig['labels']>;
+}): EnvironmentProviders;
 
 /**
  * @license

package/types/ngwr-tour.d.ts

@@ -51,6 +51,7 @@ interface WrTourStep {
  */
 declare class WrTour {
     private readonly overlay;
+    private readonly dir;
     private readonly scrollStrategies;
     private readonly injector;
     private readonly focusTrapFactory;
@@ -59,6 +60,7 @@ declare class WrTour {
     private readonly steps;
     private readonly cursor;
     private overlayRef;
+    private focusTrap;
     private spotlight;
     private detachKeydown;
     private detachReposition;
@@ -71,6 +73,15 @@ declare class WrTour {
     readonly total: _angular_core.Signal<number>;
     /** The step being shown, or `null` when idle. */
     readonly step: _angular_core.Signal<WrTourStep | null>;
+    private readonly noStepAfter;
+    /**
+     * Whether this is the last step the user will see. Not `index() === total() - 1`:
+     * a trailing step whose target is missing is skipped, so comparing against the
+     * raw count left the primary button reading "Next" on the final card and then
+     * ending the tour when it was pressed.
+     */
+    readonly isLast: _angular_core.Signal<boolean>;
+    constructor();
     /**
      * Begin a tour. Restarts if one is already running. A no-op under SSR — a
      * tour is a client-side affordance and there is nothing to spotlight on the
@@ -89,10 +100,20 @@ declare class WrTour {
      * between two dead ends.
      */
     private goTo;
+    /** Whether the tour has a step past `index` that can actually be shown. */
+    private anyResolvableAfter;
     private resolve;
     private openStep;
     private placeSpotlight;
     private teardownStep;
+    /**
+     * Whether the app reads right-to-left.
+     *
+     * Optional inject: `Directionality` is root-provided, so this is never null in
+     * an app — but a bare `TestBed` that provides nothing should still get a
+     * component that works, and defaulting to LTR is the honest fallback.
+     */
+    private isRtl;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrTour, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<WrTour>;
 }
@@ -102,6 +123,12 @@ interface WrTourController {
     readonly index: () => number;
     readonly total: () => number;
     readonly step: () => WrTourStep | null;
+    /**
+     * Whether this is the last step the user will actually see — the service looks
+     * ahead for a reachable one, because a trailing step whose target is missing gets
+     * skipped and the raw count would call the final card "Next".
+     */
+    readonly isLast: () => boolean;
     next(): void;
     prev(): void;
     stop(): void;

package/types/ngwr-transfer-testing.d.ts

@@ -0,0 +1,444 @@
+import { BaseHarnessFilters, ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+/**
+ * Which pane of a `<wr-transfer>` a call is about — the left one (`'source'`, the
+ * rows NOT in the value) or the right one (`'target'`, the rows that are).
+ *
+ * These are the component's own two names for the panes, `[sourceTitle]` /
+ * `[targetTitle]` and the `wr-transfer__pane--target` modifier, rather than
+ * left / right: a pane's side is a fact about the value it stands for, and under
+ * `dir="rtl"` the left pane is on the right.
+ */
+type WrTransferSide = 'source' | 'target';
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+
+/** Narrows which `<wr-transfer>` a harness query matches. */
+interface WrTransferHarnessFilters extends BaseHarnessFilters {
+    /** Match the LEFT pane's heading. A string is an exact match, a RegExp is tested. */
+    readonly sourceTitle?: string | RegExp;
+    /** Match the RIGHT pane's heading. A string is an exact match, a RegExp is tested. */
+    readonly targetTitle?: string | RegExp;
+    /**
+     * Match a transfer SHOWING a row with this label, in either pane — the readable
+     * way to tell two transfers apart, since both headings fall back to the same
+     * built-in strings when a template sets neither. A row a pane's filter has hidden
+     * is not rendered and does not count.
+     */
+    readonly itemLabel?: string | RegExp;
+    /** Match only transfers with a filter box above each pane (`true`) or without (`false`). */
+    readonly searchable?: boolean;
+    /** Match only disabled (`true`) or only enabled (`false`) transfers. */
+    readonly disabled?: boolean;
+}
+/** Narrows which pane of a transfer a harness query matches. */
+interface WrTransferPaneHarnessFilters extends BaseHarnessFilters {
+    /** Match one side — what `WrTransferHarness.getPane()` narrows by. */
+    readonly side?: WrTransferSide;
+    /** Match the pane's heading. A string is an exact match, a RegExp is tested. */
+    readonly title?: string | RegExp;
+}
+/** Narrows which row inside a pane a harness query matches. */
+interface WrTransferItemHarnessFilters extends BaseHarnessFilters {
+    /** Match the row's label — a string is an exact match, a RegExp is tested. */
+    readonly label?: string | RegExp;
+    /**
+     * Match only staged (`true`) or only unstaged (`false`) rows. Staged is the
+     * transient tick a move spends — NOT membership of the value, which is the pane
+     * the row sits in.
+     */
+    readonly checked?: boolean;
+    /**
+     * Match only rows that refuse staging (`true`) or only rows that accept it
+     * (`false`). Every row of a disabled TRANSFER refuses it, so `false` matches
+     * nothing there.
+     */
+    readonly disabled?: boolean;
+}
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+
+/**
+ * Test harness for one row of a `<wr-transfer>` pane.
+ *
+ * A row is a `<li>` holding a `<wr-checkbox>`, and the checkbox is the thing the
+ * user operates — so the state is read from the native `<input type="checkbox">`
+ * inside it, and {@link toggle} clicks that. The pane is deliberately NOT a
+ * `role="listbox"` of `role="option"` rows (an option may not contain an
+ * interactive control, and the axe gate says so), which is why there is no
+ * `aria-selected` here to read: the checkbox's own state IS the announcement.
+ *
+ * **Checked is not the value.** A tick stages the row for the next move and
+ * nothing more; which pane the row sits in is what `[(value)]` carries. Staging is
+ * spent — and cleared — by the move that commits it.
+ *
+ * @example
+ * ```ts
+ * const source = await transfer.getPane('source');
+ * await (await source.getItem({ label: 'Read' })).check();
+ *
+ * await transfer.moveTo('target');
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrTransferItemHarness extends ComponentHarness {
+    /**
+     * `.wr-transfer__item` is a DATA row and nothing else.
+     *
+     * An empty pane renders an `<li class="wr-transfer__empty">` for its placeholder,
+     * so querying `li` would hand that back as a row with no checkbox to read.
+     */
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrTransferItemHarnessFilters): HarnessPredicate<WrTransferItemHarness>;
+    private readonly input;
+    /** The row's label, trimmed — the `WrTransferItem.label` the pane shows and the search matches. */
+    getLabel(): Promise<string>;
+    /**
+     * Whether the row is STAGED for the next move.
+     *
+     * Not "selected": a row's pane is what the value says, and the tick is transient
+     * staging the move spends. `WrTransferPaneHarness.getCheckedLabels()` reads the
+     * whole staged set of a pane.
+     */
+    isChecked(): Promise<boolean>;
+    /**
+     * Whether the row refuses staging.
+     *
+     * The native input's `disabled` — the state a screen reader is given and the one
+     * that decides whether a click does anything. It answers `true` for BOTH reasons a
+     * row can be inert: the item's own `disabled` flag, and a disabled transfer, which
+     * disables every row. The `wr-transfer__item--disabled` modifier only marks the
+     * first of those, so it is the narrower question and not the one that predicts
+     * behaviour.
+     */
+    isDisabled(): Promise<boolean>;
+    /**
+     * Flip the row's staging.
+     *
+     * Refuses a disabled row rather than clicking into the void: the component drops
+     * the toggle outright, so the click would resolve having changed nothing and the
+     * failure would surface as an unexplained empty move two assertions later.
+     */
+    toggle(): Promise<void>;
+    /** Stage the row if it is not already staged. */
+    check(): Promise<void>;
+    /** Unstage the row if it is staged. */
+    uncheck(): Promise<void>;
+    /** Move keyboard focus onto the row's checkbox — the row's only tab stop. */
+    focus(): Promise<void>;
+    /** Whether the row's checkbox has focus. */
+    isFocused(): Promise<boolean>;
+}
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+
+/**
+ * Test harness for ONE pane of a `<wr-transfer>` — reached with
+ * `WrTransferHarness.getPane('source' | 'target')`.
+ *
+ * The two panes are the same block rendered twice (the component's template
+ * iterates them), so they are one harness class keyed by side rather than two sets
+ * of `…Source` / `…Target` methods: the side is named once, at `getPane()`, and
+ * every question after that is asked of a pane without repeating which one. It also
+ * means the symmetry cannot rot — a method that only works on the left is
+ * impossible to write here.
+ *
+ * What a pane SHOWS is the honest scope of everything below. `[items]` minus the
+ * value on the left, the value on the right, and then the pane's own filter on top:
+ * rows a filter has hidden are not rendered at all, are not counted by the header,
+ * and — the component's own rule — are not moved either, however they were staged.
+ *
+ * @example
+ * ```ts
+ * const source = await transfer.getPane('source');
+ *
+ * await source.search('adm');
+ * await source.checkAll();
+ * expect(await source.getCheckedLabels()).toEqual(['Admin']);
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrTransferPaneHarness extends ComponentHarness {
+    /**
+     * The pane is a plain `<div>` with no role of its own — the heading names the
+     * list, and the checkbox in each row carries the semantics — so its BEM class is
+     * the only handle, and being `ViewEncapsulation.None` that class is public API.
+     */
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrTransferPaneHarnessFilters): HarnessPredicate<WrTransferPaneHarness>;
+    private readonly list;
+    private readonly selectAllBox;
+    private readonly searchBox;
+    /**
+     * Which side this pane is.
+     *
+     * From the `--target` modifier rather than from DOM order: order is a layout fact
+     * that `dir="rtl"` and any future reflow are free to change, while the modifier is
+     * what the component says the pane MEANS.
+     */
+    getSide(): Promise<WrTransferSide>;
+    /** The pane's heading — `[sourceTitle]` / `[targetTitle]`, or the i18n fallback. */
+    getTitle(): Promise<string>;
+    /**
+     * The count beside the heading, verbatim — `'1 / 4'` with the built-in copy.
+     *
+     * Deliberately not parsed into numbers: it is an i18n FORMAT
+     * (`transfer.count`) a consuming app can replace wholesale, so a harness that
+     * split it on `/` would answer for the default catalog and break on a translated
+     * one. Its two numbers are `(await getCheckedLabels()).length` and
+     * `(await getItems()).length` — both of which this harness reads from the rendered
+     * rows, so a spec can assert the header agrees with them.
+     */
+    getCountText(): Promise<string>;
+    /**
+     * The list's accessible name — the `aria-label` on the `<ul>`, which repeats the
+     * heading so that a row announced in isolation still says which pane it is in.
+     */
+    getListLabel(): Promise<string | null>;
+    /**
+     * The explicit `role` on the pane's list, which is `null` — and that `null` is the
+     * ANSWER, not a gap worth fixing.
+     *
+     * The pane is a plain `<ul>` of checkboxes on purpose. Dressing it as a
+     * `role="listbox"` of `role="option"` rows reads better in the abstract but is
+     * invalid: an option may not contain an interactive control, and the axe gate
+     * rejects it. Pinning this is what keeps that "improvement" from looking like a
+     * win.
+     */
+    getListRole(): Promise<string | null>;
+    /** The rows the pane is showing, in render order. */
+    getItems(filters?: WrTransferItemHarnessFilters): Promise<WrTransferItemHarness[]>;
+    /**
+     * The labels the pane is showing, in render order.
+     *
+     * On the right that is the value, in the order the user built it — not `[items]`
+     * order, which the component deliberately does not impose.
+     */
+    getItemLabels(): Promise<string[]>;
+    /** The first row matching the filters, or a failure that says what the pane is showing. */
+    getItem(filters: WrTransferItemHarnessFilters): Promise<WrTransferItemHarness>;
+    /**
+     * The labels of the rows STAGED for the next move, in render order.
+     *
+     * The staged set and the value are different things, and this is the one the pane
+     * shows: read from the rendered rows, so a row staged before a search hid it is
+     * absent — exactly as the header count and the move itself treat it.
+     */
+    getCheckedLabels(): Promise<string[]>;
+    /** The placeholder shown in a pane with no rows, or `null` while it has some. */
+    getEmptyText(): Promise<string | null>;
+    /** Whether this pane has a filter box — `[searchable]` puts one above both panes. */
+    hasSearch(): Promise<boolean>;
+    /**
+     * Type into the pane's filter box, narrowing it to the rows whose label contains
+     * the query (case-insensitively).
+     *
+     * Pass `''` to clear it. No `change` is dispatched — `input` is the event the
+     * component listens for, and the one a real keystroke carries; a browser defers
+     * `change` on a text field to the commit, so nothing here depends on it. (The
+     * keystrokes themselves come with the `keydown` / `keypress` / `keyup` the CDK
+     * sends alongside, which this component ignores.)
+     */
+    search(query: string): Promise<void>;
+    /** What is currently typed in the pane's filter box, or `''`. Throws when there is none. */
+    getSearchValue(): Promise<string>;
+    /** The filter box's placeholder — `[searchPlaceholder]`, or the i18n fallback. */
+    getSearchPlaceholder(): Promise<string>;
+    /**
+     * The filter box's accessible name.
+     *
+     * Composed with the pane heading by the component, and it has to be: both panes
+     * carry the same placeholder, so an unnamed pair announces as two identical
+     * "Search" fields with no way to tell which list either one filters.
+     */
+    getSearchLabel(): Promise<string | null>;
+    /**
+     * The select-all box's accessible name.
+     *
+     * It has one of its own — the heading names the LIST, so reusing it here would
+     * leave a screen reader announcing two different controls identically.
+     */
+    getSelectAllLabel(): Promise<string | null>;
+    /** Whether every row the pane is showing that CAN be staged is staged. */
+    isAllChecked(): Promise<boolean>;
+    /**
+     * Whether some of the pane's stageable rows are staged and others are not.
+     *
+     * `indeterminate` is a DOM PROPERTY, not an attribute — reading the attribute
+     * would report `null` for a box that is visibly dashed.
+     */
+    isPartiallyChecked(): Promise<boolean>;
+    /**
+     * Whether the select-all box refuses interaction — a disabled transfer, or a pane
+     * with nothing stageable in it (empty, filtered to nothing, or showing only
+     * disabled rows).
+     */
+    isSelectAllDisabled(): Promise<boolean>;
+    /**
+     * Click the select-all box once.
+     *
+     * Its scope is the rows the pane is SHOWING and can stage: a filtered-out row and
+     * a disabled row are both outside it. Worth knowing before asserting on a partial
+     * pane — the box reads UNchecked while the staging is partial, so one click there
+     * stages everything rather than clearing it. {@link uncheckAll} handles that.
+     */
+    toggleSelectAll(): Promise<void>;
+    /** Stage every row the pane shows that can be staged. A pane already fully staged is left alone. */
+    checkAll(): Promise<void>;
+    /** Clear the pane's staging. */
+    uncheckAll(): Promise<void>;
+    /** The filter box, or a failure naming the input that turns it on. */
+    private searchOrThrow;
+}
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+
+/**
+ * Test harness for `<wr-transfer>` — the root of a small family, since a dual
+ * listbox is three things and not one control: {@link WrTransferPaneHarness} for one
+ * pane and {@link WrTransferItemHarness} for one row inside it.
+ *
+ * **Everything is keyed by SIDE, never duplicated per pane.** The two panes are the
+ * same block rendered twice, so a `…Source` / `…Target` method pair for each
+ * question would double the surface and let the halves drift; instead
+ * {@link getPane} takes the side once and the pane answers, and the two whole-
+ * control operations that are inherently directional — the move buttons — take the
+ * side they move rows INTO. `moveTo('target')` is the right-facing button in an LTR
+ * layout, and stays the correct one under `dir="rtl"`, where "right" is not.
+ *
+ * **The staged ticks are not the value.** `[(value)]` is the RIGHT pane's
+ * membership; a tick inside either pane is transient staging that the next move
+ * spends and clears. Conflating them is the failure this component invites, so the
+ * two are separate questions here: {@link WrTransferPaneHarness.getItemLabels} is
+ * what a pane HOLDS (the value, on the right) and
+ * {@link WrTransferPaneHarness.getCheckedLabels} is what it has STAGED.
+ *
+ * Both are scoped to what a pane is showing, which is also the component's own rule
+ * for a move: a row staged before a search hid it is no longer counted, no longer
+ * ticked, and does not travel.
+ *
+ * @example
+ * ```ts
+ * const transfer = await loader.getHarness(WrTransferHarness);
+ * const source = await transfer.getPane('source');
+ *
+ * await (await source.getItem({ label: 'Read' })).check();
+ * await transfer.moveTo('target');
+ *
+ * expect(await (await transfer.getPane('target')).getItemLabels()).toEqual(['Read']);
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrTransferHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrTransferHarnessFilters): HarnessPredicate<WrTransferHarness>;
+    /**
+     * One of the two panes — `'source'` is the left one (the rows outside the value),
+     * `'target'` the right one (the value).
+     *
+     * The side is named here and nowhere else; see the class note.
+     */
+    getPane(side: WrTransferSide): Promise<WrTransferPaneHarness>;
+    /**
+     * Whether the whole control refuses interaction.
+     *
+     * From the host modifier, which is the only signal the host itself carries: a
+     * `<wr-transfer>` element is not a control and publishes no `aria-disabled` of its
+     * own — the state reaches assistive tech through the checkboxes, the buttons and
+     * the filter boxes it disables, which is where
+     * {@link WrTransferItemHarness.isDisabled} and {@link canMoveTo} read it.
+     */
+    isDisabled(): Promise<boolean>;
+    /** Whether the panes have filter boxes — `[searchable]` gives both one or neither. */
+    isSearchable(): Promise<boolean>;
+    /**
+     * Whether the button that moves rows INTO `side` is offering itself.
+     *
+     * It is enabled only while the OTHER pane has something staged and showing, so
+     * this is also the readable way to assert that staging landed — and that a search
+     * which hid a staged row took the move away again.
+     *
+     * Read from the native `disabled` attribute: these are `button[wr-btn]`, the
+     * native shape, where that attribute is the state. (`wr-btn` adds `aria-disabled`
+     * only for its custom-element shape, on which `disabled` is inert.)
+     */
+    canMoveTo(side: WrTransferSide): Promise<boolean>;
+    /**
+     * The accessible name of the button that moves rows INTO `side` —
+     * `[toTargetLabel]` / `[toSourceLabel]`, or the i18n fallback.
+     *
+     * Worth pinning: the button's only content is an `aria-hidden` chevron, so this
+     * `aria-label` is the entire announcement. Lose it and the pair becomes two
+     * unnamed buttons.
+     */
+    getMoveLabel(side: WrTransferSide): Promise<string | null>;
+    /**
+     * Press the button that moves the staged rows INTO `side`, committing them to the
+     * value.
+     *
+     * Only the rows the other pane is SHOWING as staged travel, and the staging is
+     * cleared afterwards — the component's rule, not this harness's.
+     *
+     * Refuses a disabled button rather than pressing it: a native disabled `<button>`
+     * swallows the click before Angular's listener sees it, so the call would resolve
+     * having moved nothing at all.
+     */
+    moveTo(side: WrTransferSide): Promise<void>;
+    /**
+     * Stage everything the other pane can stage, then move it INTO `side`.
+     *
+     * "Everything" is the pane's own scope: the rows it is SHOWING, disabled ones
+     * excluded. A search narrows it, and with a filter typed this moves what is
+     * visible rather than the whole pane.
+     */
+    moveAllTo(side: WrTransferSide): Promise<void>;
+    /** The heading of one pane — the `sourceTitle` / `targetTitle` filters run through this. */
+    private paneTitle;
+    /** Every label rendered in either pane, for the `itemLabel` filter. */
+    private shownLabels;
+    /**
+     * The move button for a direction, addressed by its `--to-source` / `--to-target`
+     * modifier.
+     *
+     * Not by DOM order, and that is the point: two identically classed buttons whose
+     * only difference was their position would let a template reshuffle silently
+     * reverse every `moveTo()` in every consumer's suite, with both directions still
+     * green. Not by the `aria-label` either — that string is localizable.
+     */
+    private moveButton;
+}
+
+export { WrTransferHarness, WrTransferItemHarness, WrTransferPaneHarness };
+export type { WrTransferHarnessFilters, WrTransferItemHarnessFilters, WrTransferPaneHarnessFilters, WrTransferSide };