ngwr 10.2.1 → 11.0.0

package/types/ngwr-affix.d.ts

@@ -2,7 +2,7 @@ import * as _angular_core from '@angular/core';
 
 /**
  * Stick-on-scroll directive. Combines native CSS `position: sticky` with
- * an `IntersectionObserver`-driven `--affixed` state class, so consumers
+ * an `IntersectionObserver`-driven `wr-affix--active` state class, so consumers
  * can style the element differently while it's pinned (e.g. add a
  * shadow, change the background, shrink the height).
  *
@@ -35,6 +35,12 @@ declare class WrAffix {
     private readonly host;
     private readonly destroyRef;
     private readonly isBrowser;
+    /**
+     * `afterNextRender`'s callback is not an injection context, and the observer
+     * cannot exist before the sentinel it watches — so the effect that rebuilds it
+     * is handed the injector explicitly.
+     */
+    private readonly injector;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrAffix, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<WrAffix, "[wrAffix]", never, { "offsetTop": { "alias": "wrAffixOffsetTop"; "required": false; "isSignal": true; }; }, { "affixChange": "wrAffixChange"; }, never, never, true, never>;

package/types/ngwr-anchor.d.ts

@@ -32,6 +32,13 @@ interface WrAnchorLink {
  */
 declare class WrAnchor {
     readonly links: _angular_core.InputSignal<readonly WrAnchorLink[]>;
+    /**
+     * Accessible name for the navigation landmark. Falls back to `anchor.label`,
+     * then `'Table of contents'` — it used to be that English string, hard-coded
+     * on the host, in a landmark a screen reader reads out on every page.
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    protected readonly resolvedAriaLabel: _angular_core.Signal<string>;
     /** Pixel offset subtracted on scroll — for sticky headers. @default 0 */
     readonly offset: _angular_core.InputSignalWithTransform<number, unknown>;
     /** Highlight an item when its target's top is within this many px of the offset line. @default 80 */
@@ -46,7 +53,7 @@ declare class WrAnchor {
     constructor();
     protected onClick(id: string, event: MouseEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrAnchor, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrAnchor, "wr-anchor", never, { "links": { "alias": "links"; "required": false; "isSignal": true; }; "offset": { "alias": "offset"; "required": false; "isSignal": true; }; "hitArea": { "alias": "hitArea"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrAnchor, "wr-anchor", never, { "links": { "alias": "links"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "offset": { "alias": "offset"; "required": false; "isSignal": true; }; "hitArea": { "alias": "hitArea"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 export { WrAnchor };

package/types/ngwr-avatar.d.ts

@@ -58,11 +58,13 @@ declare class WrAvatar {
      */
     readonly url: _angular_core.InputSignal<string | null>;
     /**
-     * Alt text for the image.
+     * Alt text for the image. Falls back to `avatar.alt`, then `'Avatar'` — pass
+     * the person's name where you have it, since that is what a reader wants.
      *
-     * @default 'Avatar'
+     * @default null
      */
-    readonly alt: _angular_core.InputSignal<string>;
+    readonly alt: _angular_core.InputSignal<string | null>;
+    protected readonly resolvedAlt: _angular_core.Signal<string>;
     /**
      * Corner treatment. `rounded` (default) is a soft rounded square,
      * `circle` is the classic profile avatar, `squircle` is the iOS look.
@@ -77,11 +79,19 @@ declare class WrAvatar {
      */
     readonly size: _angular_core.InputSignal<WrAvatarSize>;
     protected readonly loaded: _angular_core.WritableSignal<boolean>;
+    /**
+     * Whether the image failed. Without this the spinner spun forever on a broken
+     * URL — the one state where an avatar is guaranteed to have projected initials
+     * worth showing instead.
+     */
+    protected readonly failed: _angular_core.WritableSignal<boolean>;
+    constructor();
     protected readonly resolved: _angular_core.Signal<ResolvedCssSize>;
     protected readonly cssSize: _angular_core.Signal<string>;
     protected readonly pxSize: _angular_core.Signal<number | null>;
     protected readonly classes: _angular_core.Signal<string>;
     protected onImageLoad(): void;
+    protected onImageError(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrAvatar, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrAvatar, "wr-avatar", never, { "url": { "alias": "url"; "required": false; "isSignal": true; }; "alt": { "alias": "alt"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }

package/types/ngwr-bar-chart.d.ts

@@ -32,12 +32,28 @@ declare class WrBarChart {
     readonly height: _angular_core.InputSignalWithTransform<number, unknown>;
     /** Explicit max value. `0` = auto. @default 0 */
     readonly max: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * A datum's value, with anything non-finite read as `0`.
+     *
+     * One `NaN` used to take out the whole chart rather than its own bar:
+     * `Math.max(...values)` is `NaN` as soon as one value is, so the scale fell
+     * back to `1` and every OTHER bar was asked for a height of `value * 100`%.
+     * The bad bar also printed the literal text `NaN` above itself.
+     */
+    private static value;
     protected readonly resolvedMax: _angular_core.Signal<number>;
     protected readonly bars: _angular_core.Signal<{
         label: string;
         value: number;
         color: string;
         heightPercent: number;
+        /**
+         * The bar's accessible name. The label and the value sit in separate
+         * rows, so a screen reader read every number and then every label with
+         * nothing tying the two together — and with `showValues` off the
+         * numbers were not in the accessible tree at all.
+         */
+        name: string;
     }[]>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrBarChart, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrBarChart, "wr-bar-chart", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "showValues": { "alias": "showValues"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;

package/types/ngwr-burger.d.ts

@@ -20,8 +20,12 @@ import * as _angular_core from '@angular/core';
 declare class WrBurger {
     /** Two-way bindable open state. Drives the hamburger ↔ close morph. @default false */
     readonly open: _angular_core.ModelSignal<boolean>;
-    /** Accessible label for the toggle button. @default 'Toggle menu' */
-    readonly label: _angular_core.InputSignal<string>;
+    /**
+     * Accessible name for the toggle button. Falls back to `burger.label`, then
+     * `'Toggle menu'`.
+     */
+    readonly label: _angular_core.InputSignal<string | null>;
+    protected readonly resolvedLabel: _angular_core.Signal<string>;
     /** Disable the toggle. @default false */
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, any>;
     protected readonly classes: _angular_core.Signal<{

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

@@ -0,0 +1,85 @@
+import { BaseHarnessFilters, ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+import { WrColor } from 'ngwr/theme';
+
+/**
+ * @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-btn>` a harness query matches. */
+interface WrButtonHarnessFilters extends BaseHarnessFilters {
+    /** Match the button's visible label — a string is an exact match, a RegExp is tested. */
+    readonly text?: string | RegExp;
+    /** Match only enabled (`false`) or only disabled (`true`) buttons. */
+    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 `<wr-btn>` — drive a button from a consumer's spec without
+ * knowing how it is built.
+ *
+ * Everything this reads is public API: the `wr-btn` selector, the
+ * `.wr-btn__label` element, the `wr-btn--*` modifiers and the disabled attributes.
+ * `<wr-btn>` is deliberately NOT always a native `<button>` — the element form
+ * exists so a link or a custom host can be one — which is why the disabled state
+ * is answered from the ATTRIBUTES rather than from `el.disabled`, a property half
+ * of those shapes do not have.
+ *
+ * @example
+ * ```ts
+ * const loader = TestbedHarnessEnvironment.loader(fixture);
+ * const save = await loader.getHarness(WrButtonHarness.with({ text: 'Save' }));
+ *
+ * expect(await save.isDisabled()).toBe(false);
+ * await save.click();
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrButtonHarness extends ComponentHarness {
+    /** Every shape the button ships in: the element, and the two attribute forms. */
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrButtonHarnessFilters): HarnessPredicate<WrButtonHarness>;
+    /** The button's visible label, trimmed. Icons and the spinner are not part of it. */
+    getText(): Promise<string>;
+    /**
+     * Whether the button refuses interaction.
+     *
+     * Both signals are read, because the component sets them for different reasons:
+     * `disabled` lands on every shape (it is inert on a custom element, which is
+     * exactly why `aria-disabled` exists as well, but it is the attribute that is
+     * always there). A button that is merely LOADING also answers `true` here, and
+     * that is not a quirk — by default a loading button refuses clicks.
+     */
+    isDisabled(): Promise<boolean>;
+    /** Whether the button is showing its loading spinner. */
+    isLoading(): Promise<boolean>;
+    /**
+     * The intent colour, or `null` when the button carries none.
+     *
+     * Matched against `WR_COLORS` rather than "the first `wr-btn--*` class": the
+     * modifier list also carries the size, the shape, `outlined`, `block`, `loading`
+     * and the icon position, so a pattern match answers `icon` as readily as
+     * `primary`.
+     */
+    getColor(): Promise<WrColor | null>;
+    /** Click the button. A disabled button is still clicked — assert, do not assume. */
+    click(): Promise<void>;
+    /** Move keyboard focus to the button. */
+    focus(): Promise<void>;
+    /** Whether the button currently has focus. */
+    isFocused(): Promise<boolean>;
+}
+
+export { WrButtonHarness };
+export type { WrButtonHarnessFilters };

package/types/ngwr-button.d.ts

@@ -68,13 +68,26 @@ type WrButtonIconPosition = 'start' | 'end';
  * @see https://ngwr.dev/reference/components/button
  */
 declare class WrButton {
-    /** Color variant. Omit for the neutral default style. @default null */
+    /**
+     * Color variant. Omit for the neutral default style.
+     *
+     * Deliberately NOT configurable app-wide: the library's own chrome binds
+     * `[color]="isCurrent ? 'primary' : null"`, where `null` means neutral, and a
+     * configured intent would repaint every one of those buttons. See `WrConfig`.
+     *
+     * @default null
+     */
     readonly color: _angular_core.InputSignal<"primary" | "secondary" | "success" | "warning" | "danger" | "info" | "light" | "medium" | "dark" | null>;
-    /** Size variant. @default 'md' */
-    readonly size: _angular_core.InputSignal<WrButtonSize>;
     /**
-     * Corner treatment — `rounded` or `pill`. `null` (default) falls back
-     * to `rounded`. Inside a `<wr-btn-group shape="…">`, the group's shape
+     * Size variant. Unset, it resolves through
+     * `provideWrConfig({ button: { size } })` and then to `md`.
+     *
+     * @default 'md'
+     */
+    readonly size: _angular_core.InputSignal<WrButtonSize | null>;
+    /**
+     * Corner treatment — `rounded`, `pill` or `squircle`. `null` (default) falls
+     * back to `rounded`. Inside a `<wr-btn-group shape="…">`, the group's shape
      * ALWAYS wins over this input — the group enforces a consistent corner
      * treatment across its members.
      *
@@ -106,13 +119,16 @@ declare class WrButton {
      */
     readonly isDisabledWhenLoading: _angular_core.InputSignalWithTransform<boolean, any>;
     private readonly group;
+    /** The size, or the app-wide default, or `md`. @see useConfigValue */
+    protected readonly resolvedSize: _angular_core.Signal<WrButtonSize>;
     /**
-     * Resolved shape. Inside a `<wr-btn-group>`, the group ALWAYS wins —
-     * child `[shape]` is ignored entirely so the group reads as one
-     * coherent control. Outside a group, the button's own `[shape]` is
-     * used, falling back to `rounded`.
+     * Resolved shape. Inside a `<wr-btn-group>`, the group ALWAYS wins — child
+     * `[shape]` is ignored entirely so the group reads as one coherent control.
+     * Outside a group, the button's own `[shape]` is used, falling back to
+     * `rounded`. Not config-resolved: see `WrConfig` for why a boolean cannot
+     * express this three-valued input.
      */
-    protected readonly effectiveShape: _angular_core.Signal<WrButtonShape>;
+    protected readonly resolvedShape: _angular_core.Signal<WrButtonShape>;
     private readonly hostEl;
     /**
      * Whether this instance is the `<wr-btn>` ELEMENT rather than the attribute

package/types/ngwr-calendar-heatmap.d.ts

@@ -27,6 +27,13 @@ interface Cell {
  */
 declare class WrCalendarHeatmap {
     readonly data: _angular_core.InputSignal<readonly WrHeatmapDatum[]>;
+    /**
+     * Accessible name of the whole grid. Its cells are bare spans whose `title` a screen
+     * reader on a role-less element does not read, so the map used to be several hundred
+     * anonymous nodes with no name. Falls back to `calendarHeatmap.label`.
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    protected readonly resolvedAriaLabel: _angular_core.Signal<string>;
     /** Last day to render. @default today */
     readonly endDate: _angular_core.InputSignal<string | Date | null>;
     /** Number of weeks (columns) to render. @default 53 */
@@ -41,7 +48,14 @@ declare class WrCalendarHeatmap {
     readonly emptyColor: _angular_core.InputSignal<string>;
     /** Show the weekday + month labels around the grid. @default true */
     readonly showLabels: _angular_core.InputSignalWithTransform<boolean, any>;
-    protected readonly weekdayLabels: string[];
+    private readonly locale;
+    /**
+     * Weekday names from the locale rather than a hard-coded English list — the row order is
+     * Sunday-first, matching the grid's own alignment, so 7 Jan 2024 (a Sunday) is the
+     * reference. Rows without a label stay blank on purpose: seven labels do not fit.
+     */
+    protected readonly weekdayLabels: _angular_core.Signal<readonly string[]>;
+    private readonly monthNames;
     protected readonly cells: _angular_core.Signal<readonly Cell[]>;
     protected readonly monthLabels: _angular_core.Signal<{
         label: string;
@@ -51,7 +65,7 @@ declare class WrCalendarHeatmap {
     protected colorFor(intensity: number): string;
     protected opacityFor(intensity: number): number;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrCalendarHeatmap, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrCalendarHeatmap, "wr-calendar-heatmap", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "endDate": { "alias": "endDate"; "required": false; "isSignal": true; }; "weeks": { "alias": "weeks"; "required": false; "isSignal": true; }; "cellSize": { "alias": "cellSize"; "required": false; "isSignal": true; }; "cellGap": { "alias": "cellGap"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "emptyColor": { "alias": "emptyColor"; "required": false; "isSignal": true; }; "showLabels": { "alias": "showLabels"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrCalendarHeatmap, "wr-calendar-heatmap", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "endDate": { "alias": "endDate"; "required": false; "isSignal": true; }; "weeks": { "alias": "weeks"; "required": false; "isSignal": true; }; "cellSize": { "alias": "cellSize"; "required": false; "isSignal": true; }; "cellGap": { "alias": "cellGap"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "emptyColor": { "alias": "emptyColor"; "required": false; "isSignal": true; }; "showLabels": { "alias": "showLabels"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 export { WrCalendarHeatmap };

package/types/ngwr-calendar.d.ts

@@ -68,6 +68,7 @@ declare class WrCalendar {
     /** Disable interaction entirely. @default false */
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, any>;
     private readonly adapter;
+    private readonly dir;
     private readonly host;
     private readonly injector;
     /** Currently displayed month (any date inside it). */
@@ -134,6 +135,15 @@ declare class WrCalendar {
     private focusActiveCell;
     /** Used by the template's `track` expression. */
     protected trackByTime(_: number, date: Date): number;
+    /**
+     * The key as the GRID sees it.
+     *
+     * Arrow keys follow visual order, and a calendar grid mirrors under
+     * `dir="rtl"`: the day to the visual right of today is yesterday. Only the
+     * inline pair swaps — Up/Down step a week either way, and PageUp/PageDown and
+     * Home/End are semantic rather than physical.
+     */
+    private inlineKey;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrCalendar, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrCalendar, "wr-calendar", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "date": { "alias": "date"; "required": false; "isSignal": true; }; "range": { "alias": "range"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "dateFilter": { "alias": "dateFilter"; "required": false; "isSignal": true; }; "autoFocus": { "alias": "autoFocus"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "date": "dateChange"; "range": "rangeChange"; }, never, never, true, never>;
 }

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

@@ -0,0 +1,257 @@
+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
+ */
+
+/** Narrows which `<wr-carousel>` a harness query matches. */
+interface WrCarouselHarnessFilters extends BaseHarnessFilters {
+    /**
+     * Match the carousel's accessible name — a string is an exact match, a RegExp
+     * is tested.
+     *
+     * This is the RESOLVED name, so it matches whatever the page announces: an
+     * `ariaLabel` the consumer passed, the `carousel.label` entry of the active
+     * `ngwr/i18n` catalog, or the built-in `'Carousel'` when a consumer named
+     * neither. A carousel is never nameless, so this option never excludes
+     * everything.
+     */
+    readonly ariaLabel?: string | RegExp;
+    /** Match a carousel holding exactly this many `<wr-carousel-slide>` children. */
+    readonly slideCount?: number;
+    /** Match a carousel one of whose slides carries this text — exact for a string, tested for a RegExp. */
+    readonly slideText?: string | RegExp;
+}
+
+/**
+ * @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-carousel>` — drive the strip the way someone on the page
+ * drives it.
+ *
+ * Everything it reads is public API: the `.wr-carousel__*` elements, the dots'
+ * `aria-current`, and the `aria-roledescription` the viewport and each slide
+ * publish. Two things are worth knowing before writing an assertion against it:
+ *
+ * - **The slides do not say which one is showing.** A `<wr-carousel-slide>` carries
+ *   `role="group"` and `aria-roledescription="slide"` and nothing else — no
+ *   `aria-current`, no `aria-hidden` on the ones off-screen. The current slide is
+ *   published in exactly two places, the dot carrying `aria-current="true"` and the
+ *   track's own offset, and {@link getActiveIndex} reads them in that order. There
+ *   is likewise no live region: the component announces a move to nobody, so a
+ *   harness cannot report one.
+ * - **It never drags.** The swipe the component supports is a touch gesture
+ *   measured against the viewport's own width, and jsdom has no layout — that width
+ *   is 0, so the "20% of the viewport" threshold is 0 too and EVERY drag clears it,
+ *   a 1px twitch included. The result says nothing about a real finger, and the spec
+ *   pins that artifact rather than pretending otherwise. Every move here goes
+ *   through the arrow buttons and the dots instead, which is the accessible path
+ *   anyway. `carousel.spec.ts` is where the gesture itself is pinned, by staging the
+ *   touch events and declaring an `offsetWidth`.
+ *
+ * @example
+ * ```ts
+ * const loader = TestbedHarnessEnvironment.loader(fixture);
+ * const gallery = await loader.getHarness(WrCarouselHarness.with({ ariaLabel: 'Gallery' }));
+ *
+ * expect(await gallery.getSlideCount()).toBe(3);
+ * await gallery.next();
+ * expect(await gallery.getActiveIndex()).toBe(1);
+ *
+ * await gallery.goTo(2);
+ * expect(await gallery.getActiveSlideText()).toBe('Dunes');
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrCarouselHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrCarouselHarnessFilters): HarnessPredicate<WrCarouselHarness>;
+    /**
+     * The role the strip announces — `group`, which is what lets
+     * `aria-roledescription` mean anything.
+     *
+     * Read off the VIEWPORT rather than the host, and that is the whole point of the
+     * pairing: `aria-roledescription` is dropped on an element with no semantic role,
+     * and the host element (`<wr-carousel>`) has none.
+     */
+    getRole(): Promise<string | null>;
+    /** How the strip describes itself to a screen reader — `carousel`. */
+    getRoleDescription(): Promise<string | null>;
+    /**
+     * The carousel's accessible name.
+     *
+     * The RESOLVED one, which is the only one the page has: the `ariaLabel` input
+     * defaults to `null` and the component runs it through the `ngwr/i18n` catalog
+     * (`carousel.label`, falling back to `'Carousel'`), so a consumer who passed
+     * nothing still gets a named group and this still answers. Reporting the raw
+     * input would say `null` about a carousel that announces itself perfectly well.
+     */
+    getAccessibleName(): Promise<string | null>;
+    /** The accessible name of the previous-slide button. Throws when the arrows are not rendered. */
+    getPreviousLabel(): Promise<string | null>;
+    /** The accessible name of the next-slide button. Throws when the arrows are not rendered. */
+    getNextLabel(): Promise<string | null>;
+    /**
+     * The accessible name of the dot group — what names the row of dots as a set
+     * rather than leaving a screen reader with N unexplained buttons.
+     *
+     * Throws when the dots are not rendered: there is no group to name then, and a
+     * `null` would read like a group that lost its label.
+     */
+    getPaginationLabel(): Promise<string | null>;
+    /**
+     * What each slide announces itself as — `slide`, on every one of them, in DOM
+     * order.
+     *
+     * The one piece of ARIA the slides carry, and the reason it is worth asking: it
+     * is set on the slide component's own host, so a slide reaching the page through
+     * some other element would come back `null` here while the carousel kept working.
+     */
+    getSlideRoleDescriptions(): Promise<(string | null)[]>;
+    /** How many slides the carousel holds. */
+    getSlideCount(): Promise<number>;
+    /** The text of every slide, in DOM order. */
+    getSlideTexts(): Promise<string[]>;
+    /**
+     * Which slide is showing, as a zero-based index.
+     *
+     * Taken from the dot carrying `aria-current="true"` whenever the dots are
+     * rendered — that attribute is the only thing on the page that tells a screen
+     * reader where in the strip it has got to, so it is the answer that matters —
+     * and derived from the track's rendered offset when they are not, `[showDots]`
+     * being off and a single-slide carousel both dropping the strip entirely.
+     *
+     * That fallback takes the MAGNITUDE of the offset on purpose. The transform is
+     * physical while the slides sit on the inline axis, so a mirrored carousel paints
+     * `translateX(100%)` for the very slide an LTR one paints `translateX(-100%)`
+     * for; signed, this reported slide -1 for a perfectly healthy RTL carousel.
+     *
+     * Throws on a carousel with no slides at all — nothing is showing there, and `0`
+     * would read like the first slide.
+     */
+    getActiveIndex(): Promise<number>;
+    /** The text of the slide that is showing. Throws on a carousel with no slides. */
+    getActiveSlideText(): Promise<string>;
+    /**
+     * The track's rendered offset, as a percentage of one viewport: `-100` for the
+     * second slide of an LTR carousel, `+100` for the second slide of a mirrored one.
+     *
+     * Read off the inline `style` attribute rather than through `getCssValue()`,
+     * because the percentage only survives where the component wrote it. jsdom hands
+     * a declared `transform` straight back through `getComputedStyle`, so
+     * `getCssValue()` answers correctly HERE and would stop the moment the same
+     * harness ran against a real browser, which resolves the property to a pixel
+     * matrix — a green unit test would be hiding it. Mid-drag the component writes
+     * `translateX(calc(-100% + 12px))` and this reports the settled `-100`: the pixel
+     * half is the finger's own displacement, which is physical in both directions and
+     * belongs to no slide.
+     *
+     * Worth asserting next to {@link getActiveIndex}: it is the same fact painted
+     * instead of announced, and a carousel that lights the right dot while parking
+     * the track in blank space is exactly the failure nobody sees in a spec.
+     */
+    getTrackOffsetPercent(): Promise<number>;
+    /** Whether the prev / next arrows are on the page. Both are dropped together. */
+    hasArrows(): Promise<boolean>;
+    /** Whether the dot strip is on the page. */
+    hasDots(): Promise<boolean>;
+    /** How many dots are rendered — one per slide, or `0` while the strip is hidden. */
+    getDotCount(): Promise<number>;
+    /**
+     * The accessible name of every dot, in order — `'Go to slide 1'`, … resolved
+     * through the `ngwr/i18n` catalog.
+     *
+     * A dot is a bare button with no text of its own, so this label is all a screen
+     * reader has to tell one from another. `[]` when the strip is hidden, matching
+     * {@link getDotCount}.
+     */
+    getDotLabels(): Promise<(string | null)[]>;
+    /**
+     * Click the next-slide arrow.
+     *
+     * "Next" is the next SLIDE, not the next thing on the right: the buttons keep
+     * their semantics under `dir="rtl"` and only the travel under them turns around.
+     * At the last slide this wraps to the first one, unless `[loop]` is off — in
+     * which case it legitimately does nothing, so nothing is asserted about the move.
+     */
+    next(): Promise<void>;
+    /** Click the previous-slide arrow. Wraps to the last slide unless `[loop]` is off. */
+    previous(): Promise<void>;
+    /**
+     * Jump to a slide by clicking its dot — the only way the page offers to reach a
+     * slide directly.
+     *
+     * Throws when the dots are hidden (the component's own `goTo()` is still there
+     * for a spec holding the instance, but nothing on the page can be clicked) and
+     * throws on an index no slide has, rather than clicking nothing and leaving the
+     * carousel where it was.
+     */
+    goTo(index: number): Promise<void>;
+    /**
+     * Move the pointer onto the carousel, which is what HOLDS autoplay.
+     *
+     * Aimed at the host and not the viewport, deliberately: the arrows and the dots
+     * are the viewport's SIBLINGS, so a viewport-scoped hover would let a slide
+     * change under a cursor that is aiming at an arrow.
+     */
+    hover(): Promise<void>;
+    /** Move the pointer away again, releasing the hold. */
+    mouseAway(): Promise<void>;
+    /**
+     * Put keyboard focus on the first control the carousel renders — the previous
+     * arrow, or the first dot when the arrows are hidden.
+     *
+     * This is the keyboard half of the autoplay hold: WCAG 2.2.2 wants a way to stop
+     * moving content, and hovering is not one for someone who never touches a mouse,
+     * so the component listens for `focusin` on its host as well. Focus lands on the
+     * carousel's OWN controls; anything focusable a slide happens to project is not
+     * this harness's business, though in a browser it would hold autoplay just the
+     * same.
+     *
+     * Note what this is NOT: the dot of the slide showing. The dots are ordinary
+     * buttons with no roving `tabindex`, so each of them is a tab stop of its own and
+     * the first one a Tab press meets is the prev arrow whatever slide is current —
+     * two different questions, answered here and by {@link getActiveIndex}.
+     *
+     * Throws when the carousel renders no controls at all, because then there is
+     * nothing for a Tab press to land on and no keyboard mechanism to assert.
+     */
+    focus(): Promise<void>;
+    /**
+     * Take focus off whichever of the carousel's controls holds it, releasing the
+     * hold {@link focus} started.
+     *
+     * Throws when none of them is focused: `focusout` is what the component listens
+     * for, and blurring an element that never had focus fires nothing — a quiet
+     * no-op here surfaces as an autoplay assertion failing three lines later.
+     */
+    blur(): Promise<void>;
+    /** Whether one of the carousel's own controls holds focus — which is what holds autoplay. */
+    isFocused(): Promise<boolean>;
+    /** The element that carries the carousel's role and name. */
+    private viewport;
+    /** The moving strip, whose inline transform is where the carousel IS. */
+    private track;
+    private slides;
+    private dots;
+    /**
+     * Every control the carousel renders itself, in the order a Tab press meets
+     * them: the two arrows, then the dots.
+     */
+    private controls;
+    /** One arrow, or a failure naming both reasons it might not be there. */
+    private nav;
+}
+
+export { WrCarouselHarness };
+export type { WrCarouselHarnessFilters };