ngwr 11.0.0 → 11.2.0

package/types/ngwr-fuzzy-text-testing.d.ts

@@ -0,0 +1,130 @@
+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-fuzzy-text>` a harness query matches. */
+interface WrFuzzyTextHarnessFilters extends BaseHarnessFilters {
+    /**
+     * Match the headline — a string is an exact match, a RegExp is tested.
+     *
+     * The only filter, and the only one possible: everything else this component is told
+     * ends up as a canvas font string or a fill style and never reaches the DOM, so the
+     * readable copy of the text is the sole thing that tells two headlines apart. Matched
+     * through `WrFuzzyTextHarness.getText`, which reads the screen-reader span rather than
+     * the pixels.
+     */
+    readonly text?: 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-fuzzy-text>` — a headline drawn into a canvas, one row of pixels
+ * at a time, with a random offset per row.
+ *
+ * **The drawing is out of reach and the accessible half is not, which is the whole shape
+ * of this harness.** There is no 2D context in a unit test — `getContext('2d')` returns
+ * `null`, and the component's `init()` gives up on the line after — so nothing downstream
+ * of that ever happens: no font load, no animation frame, no canvas listeners, no sizing.
+ * What survives is the markup, and the markup is the part that regressed: everything this
+ * component rendered used to be a canvas, so a screen reader got an empty element where
+ * the page showed a headline. {@link getText} and {@link isDecorative} are that fix,
+ * asserted as the PAIR it has to be — a readable copy plus a hidden pixel copy. Reading
+ * one without the other passes just as happily on a component that announces the headline
+ * twice.
+ *
+ * **The canvas is selected by tag, not by a class.** It carries no BEM name, unlike the
+ * two sibling animation canvases — this entry point ships no stylesheet at all, which is
+ * also why {@link isTextVisuallyHidden} is a real question rather than a formality.
+ *
+ * Nothing about the animation is offered, and none of it is a gap that could be closed by
+ * trying harder. There is no `getIntensity()` / `isFuzzing()` / `isGlitching()`: those are
+ * closure variables inside `init()` that only ever manifest as pixels, and in a test the
+ * function returns before they exist. No `hover()` / `click()` / `getHoverIntensity()`:
+ * the pointer listeners are attached only after a real context AND a resolved
+ * `document.fonts` — neither of which a unit test has — so a dispatched event would land
+ * on nothing and the assertion would pass vacuously; the hit test also measures the canvas
+ * box, which is all zeros. No `getCanvasSize()`, which would be asserting jsdom's untouched
+ * 300×150 default rather than the component's layout maths. No `getColor()` /
+ * `getFontSize()` / `getFontFamily()` / `getGradient()`: every one of those becomes a
+ * canvas font string or a fill style and never reaches the DOM. No `getRenderedText()` or
+ * `readPixel()` — there are no pixels, and faking a context would change what every spec
+ * here is testing. And no `isReducedMotion()`: the preference is honoured by taking a
+ * different DRAWING path, with identical markup, classes and attributes either way, so the
+ * method would answer the same for a component that honoured it and one that ignored it.
+ *
+ * @example
+ * ```ts
+ * const headline = await loader.getHarness(WrFuzzyTextHarness.with({ text: '404' }));
+ *
+ * expect(await headline.getText()).toBe('404');
+ * expect(await headline.isDecorative()).toBe(true);
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrFuzzyTextHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrFuzzyTextHarnessFilters): HarnessPredicate<WrFuzzyTextHarness>;
+    private readonly srOnly;
+    private readonly canvas;
+    /**
+     * The headline as TEXT, trimmed.
+     *
+     * From the screen-reader span, which is the only place the string exists as characters —
+     * the visible copy is glyphs painted into a canvas. This is the single assertion that
+     * separates the component from an empty box for anyone not looking at the screen, and it
+     * is the one that has already regressed once.
+     *
+     * There is no letter-by-letter split to worry about here, unlike the other text
+     * animations in the library: the span holds one text node, so what a reader announces is
+     * what {@link WrFuzzyTextHarness.getText} returns.
+     */
+    getText(): Promise<string>;
+    /**
+     * Whether the pixel copy stays out of the accessibility tree.
+     *
+     * The other half of {@link getText}. The canvas has no text and no name, so without its
+     * `aria-hidden` a reader meets an anonymous element next to the headline it already
+     * read — or, if the span ever goes away again, only the anonymous element. Asserting the
+     * two together is what pins the arrangement; asserting either alone does not.
+     */
+    isDecorative(): Promise<boolean>;
+    /**
+     * Whether the drawing surface is in the markup.
+     *
+     * True even where it can never be painted — under SSR, in a prerender, in a browser that
+     * refuses a 2D context, and in every unit test — because the element is rendered
+     * unconditionally and only the drawing depends on a context. That is precisely the state
+     * the readable copy exists to cover, so this is the method that says "the fallback is
+     * carrying the page right now".
+     */
+    hasCanvas(): Promise<boolean>;
+    /**
+     * Whether the readable copy hides itself without a stylesheet.
+     *
+     * This entry point ships no CSS. The span is therefore hidden with inline declarations
+     * rather than an `.sr-only` class, and that is load-bearing rather than a style choice:
+     * move the block into a class and every consumer who imported no CSS sees the headline
+     * twice — once as pixels, once as a stray line of markup underneath.
+     *
+     * Three of the declarations are checked, not one, because they fail apart: `position`
+     * takes the span out of flow, the 1px box collapses it, and `clip-path` is what keeps
+     * the character still reachable by a reader instead of `display: none`-ing it away.
+     */
+    isTextVisuallyHidden(): Promise<boolean>;
+}
+
+export { WrFuzzyTextHarness };
+export type { WrFuzzyTextHarnessFilters };

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

@@ -0,0 +1,71 @@
+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-gauge>` a harness query matches. */
+interface WrGaugeHarnessFilters extends BaseHarnessFilters {
+    /** Match the dial's accessible name. */
+    readonly ariaLabel?: string | RegExp;
+    /** Match the value the dial announces. */
+    readonly value?: number;
+}
+
+/**
+ * @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-gauge>`.
+ *
+ * **The dial is `aria-hidden` and the printed number is optional, so the ARIA is the
+ * whole readable surface.** The component carries `role="meter"` with the value
+ * trio and an `aria-valuetext` that includes the suffix — which is what makes a
+ * gauge with `showValue` off readable at all. {@link getValue} is what it announces;
+ * {@link getDisplayValue} is what is drawn, and it is `null` when nothing is.
+ *
+ * The arc is an SVG path, and its `d` is a rendering detail rather than an
+ * assertion — it moves with the size, the stroke width and the sweep.
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrGaugeHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrGaugeHarnessFilters): HarnessPredicate<WrGaugeHarness>;
+    private readonly surface;
+    /** The role the dial announces — `meter`, which is what a gauge is. */
+    getRole(): Promise<string | null>;
+    /** The dial's accessible name. */
+    getAccessibleName(): Promise<string | null>;
+    /** The value it announces, from `aria-valuenow`. */
+    getValue(): Promise<number>;
+    /** The bottom of the range, from `aria-valuemin`. */
+    getMin(): Promise<number>;
+    /** The top of the range, from `aria-valuemax`. */
+    getMax(): Promise<number>;
+    /**
+     * The spoken form of the value — the number with its suffix.
+     *
+     * The reason a gauge with no printed value is still readable, and worth asserting
+     * separately from {@link getValue}: a percentage announced as a bare `72` says
+     * something different from `72%`.
+     */
+    getValueText(): Promise<string | null>;
+    /** The number printed in the middle, suffix included, or `null` when `showValue` is off. */
+    getDisplayValue(): Promise<string | null>;
+    /** The suffix alone, or `null` when there is none — or nothing is printed. */
+    getSuffix(): Promise<string | null>;
+    /** The dial's width in pixels, as the component writes it inline. */
+    getSize(): Promise<number>;
+}
+
+export { WrGaugeHarness };
+export type { WrGaugeHarnessFilters };

package/types/ngwr-glitch-text-testing.d.ts

@@ -0,0 +1,172 @@
+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-glitch-text>` a harness query matches. */
+interface WrGlitchTextHarnessFilters extends BaseHarnessFilters {
+    /** Match the rendered text — a string is an exact match, a RegExp is tested. */
+    readonly text?: string | RegExp;
+    /**
+     * Match only the hover-gated variant (`true`) or only the always-on one (`false`).
+     * Note that hover-gated is the DEFAULT, so `{ hoverOnly: false }` selects the
+     * component that was explicitly told `[enableOnHover]="false"`.
+     */
+    readonly hoverOnly?: boolean;
+}
+/** How long each clone layer takes to complete one tear cycle, in seconds. */
+interface WrGlitchTextDurations {
+    /** The `::before` clone — `speed × 2`. */
+    readonly before: number;
+    /** The `::after` clone — `speed × 3`. */
+    readonly after: number;
+}
+/** The two clone `text-shadow`s, exactly as the component wrote them. */
+interface WrGlitchTextColourSplit {
+    /** The `::before` clone's shadow — offset right, and tinted `info`. */
+    readonly before: string;
+    /** The `::after` clone's shadow — offset left, and tinted `danger`. */
+    readonly after: string;
+}
+
+/**
+ * @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-glitch-text>`.
+ *
+ * **The one thing worth testing here is the pairing.** The two torn clones are
+ * `::before` / `::after` pseudo-elements whose glyphs come from `content:
+ * attr(data-text)`, so the string has to be in the host's text node AND in the host's
+ * `data-text` attribute. Drop either binding and the visible text stays flawless while
+ * the effect disappears — no error, no missing element, nothing else in the DOM
+ * changes. {@link isCloneTextInSync} is that assertion in one call.
+ *
+ * **Everything else the harness reads is an inline custom property**, because that is
+ * everything the component writes: the two clone durations, the two colour-split
+ * shadows and the optional slice background. They are worth pinning for the unit
+ * transforms — a duration that loses its `s`, or two clones that end up on the same
+ * multiple and tear in lockstep, is a regression that changes no class, no attribute
+ * and no text.
+ *
+ * **What the harness deliberately does not offer**, and why. There is no
+ * `isGlitching()`: the tear is a `@keyframes` animation on a pseudo-element, applied by
+ * a stylesheet a unit test never loads, so the only available answer is a class name
+ * repackaged as a state. There is no `hover()` / `isGlitchingOnHover()`: the gate is a
+ * `:hover` SELECTOR, and the DOM after a dispatched mouse event is byte-identical to
+ * the DOM before it — a spec built on that would pass against a component whose hover
+ * rules had been deleted. There is no `getCloneOffset()` / `getClipPath()`: the ±10px
+ * offsets and the tear bands live in the stylesheet and are pure layout besides. There
+ * is no `respectsReducedMotion()`: the handling is a `@media` block with no TypeScript
+ * counterpart, so the DOM is identical in both states and there is nothing to read.
+ * There is no resolver for the shadow colours — they hold `var(--wr-color-info)` /
+ * `var(--wr-color-danger)`, and resolving those needs the theme stylesheet. And there
+ * is no `getSpeed()`: the input is never written to the DOM, only its two products are,
+ * and dividing one back would invent a precision the component never published (at
+ * `[speed]="0.3"` the after-duration is literally `0.8999999999999999s`).
+ *
+ * @example
+ * ```ts
+ * const glitch = await loader.getHarness(WrGlitchTextHarness);
+ *
+ * expect(await glitch.isCloneTextInSync()).toBe(true);
+ * expect((await glitch.getDurations()).after).toBeCloseTo(3);
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrGlitchTextHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrGlitchTextHarnessFilters): HarnessPredicate<WrGlitchTextHarness>;
+    /**
+     * The rendered text, trimmed.
+     *
+     * The half a sighted user reads, and the half every other check would notice
+     * breaking. The component interpolates the input straight onto the host, so there is
+     * no inner element to query.
+     */
+    getText(): Promise<string>;
+    /**
+     * The string the two clone layers draw from — the host's `data-text`.
+     *
+     * The half nothing else notices. `content: attr(data-text)` is how both pseudo-clones
+     * get their glyphs, so this attribute IS the effect. `null` means the mirror is gone
+     * and the component is rendering plain text with extra classes.
+     */
+    getCloneText(): Promise<string | null>;
+    /**
+     * Whether the clone attribute still mirrors the rendered text.
+     *
+     * The component's defining silent failure, as a single assertion — two separate reads
+     * are two things a spec can forget to write together. Compared raw on both sides,
+     * with no trimming: the template is the bare interpolation, so the text node and the
+     * attribute are byte-identical or the mirror is broken. An empty `text` is legal and
+     * counts as in sync — `data-text=""` is a mirror of nothing, not a missing binding,
+     * which is why {@link getCloneText} reports the absent case as `null` instead.
+     */
+    isCloneTextInSync(): Promise<boolean>;
+    /**
+     * Whether the effect idles until the pointer arrives (`enableOnHover`).
+     *
+     * The `wr-glitch-text--hover-only` class is the only DOM trace of that input, the gate
+     * itself being a `:hover` rule. It defaults to `true`, so this is also how a spec
+     * catches the day someone "fixes" the default to match the component's own JSDoc,
+     * which describes the opposite.
+     */
+    isHoverOnly(): Promise<boolean>;
+    /**
+     * How long each clone takes to complete a cycle, in seconds.
+     *
+     * The two must NOT be equal: they run at 2× and 3× the `speed` multiplier so the tears
+     * fall out of phase, and clones tearing in lockstep read as one shifted copy rather
+     * than as a glitch. That regression changes no class, no attribute and no text, and no
+     * visual gate in this repo can see it either.
+     *
+     * These are raw JavaScript floats — `[speed]="0.3"` writes `0.8999999999999999s` —
+     * so compare with `toBeCloseTo`, never against a formatted string.
+     */
+    getDurations(): Promise<WrGlitchTextDurations>;
+    /**
+     * Whether the red / cyan colour split is switched on (`enableShadows`).
+     *
+     * The component writes the literal `none` rather than removing the properties when the
+     * split is off, so "disabled" and "never set" stay distinguishable — an absent property
+     * would mean a broken binding, and this reports that as no split either.
+     */
+    hasColourSplit(): Promise<boolean>;
+    /**
+     * The two clone `text-shadow`s, exactly as written — `var()` tokens and all.
+     *
+     * Returned unresolved on purpose: resolving `var(--wr-color-info)` needs the theme
+     * stylesheet, and a unit test that answered with a colour would be inventing one.
+     * What the raw pair does prove is the thing a copy-paste breaks — the offsets must
+     * have OPPOSITE signs and the two tints must be DIFFERENT intents. Give both clones
+     * the same colour, or the same sign, and the chromatic aberration is gone while every
+     * other reading stays green.
+     */
+    getColourSplit(): Promise<WrGlitchTextColourSplit>;
+    /**
+     * The masking colour behind the clone slices, or `null` when none was given.
+     *
+     * The binding emits `null` for an empty input, so the property is ABSENT rather than
+     * set to `transparent`, and the stylesheet's own `var(--wr-glitch-text-bg, transparent)`
+     * fallback does the work. A component that started writing `transparent` inline would
+     * look identical and break nothing until a consumer relied on that fallback — which is
+     * the whole reason this reports the absent case as `null` instead of as a colour.
+     */
+    getSliceBackground(): Promise<string | null>;
+    /** One of the host's inline duration properties, as a number of seconds. */
+    private seconds;
+}
+
+export { WrGlitchTextHarness };
+export type { WrGlitchTextColourSplit, WrGlitchTextDurations, WrGlitchTextHarnessFilters };

package/types/ngwr-gradient-text-testing.d.ts

@@ -0,0 +1,173 @@
+import { BaseHarnessFilters, ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+import { WrGradientTextDirection } from 'ngwr/gradient-text';
+
+/**
+ * @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-gradient-text>` a harness query matches. */
+interface WrGradientTextHarnessFilters extends BaseHarnessFilters {
+    /** Match the projected text — a string is an exact match, a RegExp is tested. */
+    readonly text?: string | RegExp;
+    /**
+     * Match the sweep direction. `'horizontal'` is the ABSENCE of a modifier rather than a
+     * class of its own — see `WrGradientTextHarness.getDirection`, which resolves it.
+     */
+    readonly direction?: WrGradientTextDirection;
+    /** Match only the pill variant (`true`) or only the bare one (`false`). */
+    readonly border?: 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-gradient-text>`.
+ *
+ * **The gradient string is the component.** Everything `[colors]` and `[direction]`
+ * decide ends up in one inline custom property — the angle keyword, the stop list, and
+ * the first colour repeated at the end, which is what makes the loop seamless instead of
+ * snapping back at the wrap. {@link getColors} returns that list AS WRITTEN, wrap stop
+ * included, because the duplicate is the thing worth asserting and stripping it would
+ * hide the day it goes missing.
+ *
+ * **Direction is two facts, not one.** The modifier class says which way the gradient
+ * travels and {@link getBackgroundSize} says which axis it was stretched along, and they
+ * are computed separately: a direction change that forgets the size leaves every class
+ * looking right while the effect is squashed flat. Note too that `horizontal` writes NO
+ * class at all — {@link getDirection} resolves the absence, which is the mapping a
+ * refactor breaks most easily.
+ *
+ * **What the harness deliberately does not offer**, and why. There is no `isAnimating()`
+ * / `isPaused()`: the sweep is a stylesheet keyframe, and a unit test loads no
+ * stylesheet, so the answer would be the same constant for a working component and a
+ * broken one. There is no `getBackgroundPosition()`: the swept value exists only
+ * mid-animation, and the static declaration it would return corresponds to no frame the
+ * user ever sees. {@link pausesOnHover} claims the CLASS and not the pause, deliberately
+ * — `:hover` is a selector, and the DOM after a dispatched mouse event is identical to
+ * the DOM before it. There is no `respectsReducedMotion()`: the only handling is a
+ * `@media` block with no TypeScript counterpart, so nothing in the DOM changes in either
+ * state. And there is nothing that reports the painted text colour: the fill comes from
+ * `background-clip: text` over a `color: transparent` declared in the stylesheet, so a
+ * read would describe the inherited colour and call the text readable where the browser
+ * paints a gradient.
+ *
+ * @example
+ * ```ts
+ * const gradient = await loader.getHarness(WrGradientTextHarness);
+ *
+ * expect(await gradient.getColors()).toEqual(['#111111', '#222222', '#111111']);
+ * expect(await gradient.getBackgroundSize()).toBe('300% 100%');
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrGradientTextHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrGradientTextHarnessFilters): HarnessPredicate<WrGradientTextHarness>;
+    private readonly text;
+    private readonly ring;
+    /**
+     * The projected text, trimmed.
+     *
+     * Read from the text span rather than from the host, so the answer stays correct on the
+     * day the decorative ring gains content of its own — it is a sibling of this span, and
+     * the host's text would include both.
+     */
+    getText(): Promise<string>;
+    /**
+     * Which way the gradient travels.
+     *
+     * `horizontal` is reported for the absence of both modifiers, because the component
+     * writes no `--horizontal` class — there is nothing to read for the default, only the
+     * two exceptions.
+     */
+    getDirection(): Promise<WrGradientTextDirection>;
+    /**
+     * The whole gradient the component computed, as written.
+     *
+     * Unresolved on purpose: a consumer may pass theme tokens, and resolving `var()` needs
+     * the stylesheet. The stops come back spelled as they were written — a custom property
+     * holds an unparsed token stream, so `#111111` stays `#111111` rather than being
+     * re-serialised as `rgb()` the way it would be inside a standard `background-image`.
+     * Whitespace is the exception, so prefer {@link getColors} over string-equalling the
+     * whole gradient.
+     */
+    getGradient(): Promise<string>;
+    /**
+     * The gradient's colour stops, in order, INCLUDING the repeated first colour at the end.
+     *
+     * So the list is one longer than the `[colors]` input, and that extra entry is the
+     * point: it is what lets the sweep wrap without a visible snap, and nothing else in the
+     * DOM records it. An empty `[colors]` falls back to the three built-in stops, which
+     * shows up here as four entries rather than one.
+     *
+     * Throws rather than guessing when the property holds something that is not a
+     * `linear-gradient()` — an empty read means the host binding is gone, and a list of
+     * fragments parsed out of the wreckage would look like a colour set.
+     */
+    getColors(): Promise<string[]>;
+    /**
+     * How far the gradient is stretched, as the `background-size` pair.
+     *
+     * The other half of direction: the gradient has to be oversized along the axis it
+     * travels — `300% 100%` horizontal, `100% 300%` vertical, `300% 300%` diagonal — or
+     * there is nothing outside the box to slide in. Worth asserting beside
+     * {@link getDirection}, since the two are computed independently and only agree by
+     * intent.
+     */
+    getBackgroundSize(): Promise<string>;
+    /**
+     * One full sweep in seconds, from `[animationSpeed]`.
+     *
+     * Proves the input reaches CSS at all, `numAttr` coercion included — a string attribute
+     * arrives as a number and garbage falls back to the documented default. Throws when the
+     * property holds no number, which is the only way the read can fail.
+     */
+    getAnimationDurationSeconds(): Promise<number>;
+    /**
+     * Whether the decorative ring element was rendered (`showBorder`).
+     *
+     * Strictly more than the `wr-gradient-text--border` class says: the class is a host
+     * binding and the ring is an `@if` branch in the template, two mechanisms reading one
+     * input, and they can drift. This asks whether the element that paints the pill is
+     * actually there.
+     */
+    hasBorderRing(): Promise<boolean>;
+    /**
+     * Whether the ring is hidden from assistive tech, or `null` when there is no ring.
+     *
+     * The ring is an empty, nameless span. Paired with {@link hasBorderRing} this is the
+     * component's whole a11y contract: if it ever loses `aria-hidden`, a screen reader stops
+     * on an element with nothing to say. `null` rather than `false` for the absent case, so
+     * "no ring" cannot be mistaken for "an exposed ring".
+     */
+    isBorderDecorative(): Promise<boolean | null>;
+    /**
+     * Whether the sweep bounces instead of restarting (`yoyo`).
+     *
+     * Defaults to `true` here, unlike every other boolean on this component and unlike the
+     * same-named input on `wr-shiny-text` — worth pinning in both directions. The class is
+     * the only thing the `animation-direction: alternate` rule keys off.
+     */
+    isYoyo(): Promise<boolean>;
+    /**
+     * Whether the opt-in reached the class the `:hover` rule needs.
+     *
+     * Named for the class and not for the pause on purpose: the pause itself is a CSS
+     * selector match, which no unit test can observe. What this catches is the input never
+     * arriving, which is the half that can go wrong in TypeScript.
+     */
+    pausesOnHover(): Promise<boolean>;
+}
+
+export { WrGradientTextHarness };
+export type { WrGradientTextHarnessFilters };