@cdevhub/ngx-tw 0.4.0 → 0.6.0

package/types/cdevhub-ngx-tw-theme.d.ts

@@ -1,84 +1,195 @@
 import * as _angular_core from '@angular/core';
 import { OnDestroy, InjectionToken, EnvironmentProviders } from '@angular/core';
 
-/** The user-selectable theme. `'system'` defers to the OS `prefers-color-scheme` setting. */
-type TwTheme = 'light' | 'dark' | 'high-contrast' | 'system';
-/** The theme actually applied to the DOM after resolving `'system'` against the OS preference. */
-type TwResolvedTheme = 'light' | 'dark' | 'high-contrast';
+/**
+ * The user-selectable theme. `'system'` defers to the OS, resolving
+ * `prefers-color-scheme` and `prefers-contrast` as two independent axes: dark
+ * plus increased contrast lands on `'high-contrast-dark'`, light plus increased
+ * contrast on `'high-contrast'`.
+ */
+type TwTheme = 'light' | 'dark' | 'high-contrast' | 'high-contrast-dark' | 'system';
+/**
+ * The theme actually applied to the DOM after resolving `'system'` against the
+ * OS preference.
+ *
+ * The two axes are appearance (light / dark) and contrast (normal / increased),
+ * so the four values are their product: `'high-contrast'` is the light-based
+ * increased-contrast scheme and `'high-contrast-dark'` the dark-based one.
+ */
+type TwResolvedTheme = 'light' | 'dark' | 'high-contrast' | 'high-contrast-dark';
 /** Ordered list of every {@link TwTheme} value, used by `cycleTheme()` and for UI iteration. */
-declare const TW_THEMES: readonly ["light", "dark", "high-contrast", "system"];
+declare const TW_THEMES: readonly ["light", "dark", "high-contrast", "high-contrast-dark", "system"];
 /** Ordered list of every {@link TwResolvedTheme} value (i.e. {@link TW_THEMES} minus `'system'`). */
-declare const TW_RESOLVED_THEMES: readonly ["light", "dark", "high-contrast"];
-/** Runtime configuration for {@link provideTheme}; controls storage, attribute name, target element, and default. */
+declare const TW_RESOLVED_THEMES: readonly ["light", "dark", "high-contrast", "high-contrast-dark"];
+/**
+ * Runtime configuration for {@link provideTheme}; controls storage, attribute
+ * name, target element, and default.
+ *
+ * Every member is optional. This interface only ever reaches consumers through
+ * `provideTheme(config?: Partial<TwThemeConfig>)`, which fills each unset key
+ * from {@link DEFAULT_TW_THEME_CONFIG} — so a consumer holding a config object
+ * typed as `TwThemeConfig` must not be forced to restate keys they do not
+ * override, and adding a member in a future minor must not break them. The
+ * resolved value handed to {@link TW_THEME_CONFIG} is `Required<TwThemeConfig>`.
+ */
 interface TwThemeConfig {
     /** The default theme when no preference is stored. Defaults to `'system'`. */
-    defaultTheme: TwTheme;
-    /** localStorage key for persisting theme preference. Defaults to `'ngx-tw-theme'`. */
-    storageKey: string;
+    defaultTheme?: TwTheme;
+    /**
+     * localStorage key for persisting an explicit theme choice. Defaults to
+     * `'ngx-tw-theme'`. Only `setTheme()` / `cycleTheme()` write it — providing
+     * the service never does.
+     */
+    storageKey?: string;
     /** The HTML attribute written to the target element. Defaults to `'data-theme'`. */
-    attribute: string;
+    attribute?: string;
     /** Which element receives the theme attribute. Defaults to `'documentElement'`. */
-    target: 'documentElement' | 'body';
+    target?: 'documentElement' | 'body';
 }
-/** Composite snapshot of `ThemeService` state — selected, resolved, system, and boolean flags. */
+/**
+ * Composite snapshot of `ThemeService` state — selected, resolved, system, and
+ * boolean flags.
+ *
+ * The three flags are **not** mutually exclusive: `'high-contrast-dark'` sets
+ * both {@link isDark} and {@link isHighContrast}, because it is dark *and*
+ * high contrast. Branch on {@link resolvedTheme} when you need one case.
+ */
 interface TwThemeState {
     /** The user-selected theme — may be `'system'`. */
     readonly theme: TwTheme;
     /** The theme actually applied to the DOM — never `'system'`. */
     readonly resolvedTheme: TwResolvedTheme;
-    /** The OS color-scheme preference detected via `prefers-color-scheme`. */
+    /** The OS appearance preference detected via `prefers-color-scheme` and `prefers-contrast`. */
     readonly systemTheme: TwResolvedTheme;
-    /** True when {@link resolvedTheme} is `'dark'`. */
+    /** True when {@link resolvedTheme} is a dark scheme — `'dark'` or `'high-contrast-dark'`. */
     readonly isDark: boolean;
-    /** True when {@link resolvedTheme} is `'light'`. */
+    /** True when {@link resolvedTheme} is exactly `'light'`; the light-based `'high-contrast'` does not set it. */
     readonly isLight: boolean;
-    /** True when {@link resolvedTheme} is `'high-contrast'`. */
+    /** True when {@link resolvedTheme} is an increased-contrast scheme — `'high-contrast'` or `'high-contrast-dark'`. */
     readonly isHighContrast: boolean;
 }
-/** Built-in defaults merged under any user-provided {@link TwThemeConfig} by `provideTheme()`. */
-declare const DEFAULT_TW_THEME_CONFIG: TwThemeConfig;
+/**
+ * Built-in defaults merged under any user-provided {@link TwThemeConfig} by
+ * `provideTheme()`. Typed `Required<TwThemeConfig>` so readers keep a
+ * non-optional `string` / `TwTheme` for every field even though the interface
+ * itself is all-optional.
+ */
+declare const DEFAULT_TW_THEME_CONFIG: Required<TwThemeConfig>;
 
 /**
  * Stateful runtime service that owns the active theme, reacts to OS
- * `prefers-color-scheme` changes, persists the user selection to
- * `localStorage`, and writes the resolved theme onto the configured DOM
- * target as a `data-theme` attribute.
+ * `prefers-color-scheme` / `prefers-contrast` changes, persists an explicit
+ * user selection to `localStorage`, and writes the resolved theme onto the
+ * configured DOM target as a `data-theme` attribute.
  *
  * The selected {@link theme} may be `'system'` (defer to the OS); the
  * {@link resolvedTheme} computed from it is always one of `'light'`,
- * `'dark'`, or `'high-contrast'` — never `'system'`. Register via
- * {@link provideTheme} in the app's environment providers.
+ * `'dark'`, `'high-contrast'`, or `'high-contrast-dark'` — never `'system'`.
+ * Register via
+ * {@link provideTheme} in the app's environment providers; `provideTheme`
+ * also constructs the service at bootstrap, so injecting it is only needed
+ * to read or change the theme.
+ *
+ * Storage is written **only** by {@link setTheme} / {@link cycleTheme}.
+ * Merely providing the service never touches `localStorage`, so the
+ * configured `defaultTheme` keeps applying until the user actually picks
+ * something, and apps under a storage-consent flow can provide the service
+ * before consent is granted.
  */
 declare class ThemeService implements OnDestroy {
     private readonly config;
     private readonly document;
     private readonly isBrowser;
     private readonly ngZone;
-    private mediaQuery;
+    private darkQuery;
+    private contrastQuery;
     private readonly mediaListener;
     /** The user-selected theme (may be `'system'`). */
     readonly theme: _angular_core.WritableSignal<TwTheme>;
-    /** The OS color scheme preference. */
+    /** The OS appearance preference — `prefers-color-scheme` plus `prefers-contrast`. */
     readonly systemTheme: _angular_core.WritableSignal<TwResolvedTheme>;
     /** The resolved theme actually applied to the DOM (never `'system'`). */
     readonly resolvedTheme: _angular_core.Signal<TwResolvedTheme>;
-    /** True when the resolved theme is `'dark'`. */
+    /**
+     * True when the resolved theme is a **dark** scheme — `'dark'` or
+     * `'high-contrast-dark'`.
+     *
+     * It answers the appearance question, not "which scheme": the canonical use
+     * is picking a colour that has to sit on the page background (a chart grid,
+     * a canvas fill), and dark high contrast needs the dark answer there just as
+     * much as plain dark does. It is therefore **not** mutually exclusive with
+     * {@link isHighContrast}; branch on {@link resolvedTheme} for one case.
+     */
     readonly isDark: _angular_core.Signal<boolean>;
-    /** True when the resolved theme is `'light'`. */
+    /**
+     * True when the resolved theme is exactly `'light'`.
+     *
+     * Deliberately narrower than {@link isDark}'s mirror image: the light-based
+     * `'high-contrast'` does **not** set it, because widening it would change
+     * what a shipped scheme reports to consumers already reading this flag.
+     * Use `!isDark()` for the appearance question.
+     */
     readonly isLight: _angular_core.Signal<boolean>;
-    /** True when the resolved theme is `'high-contrast'`. */
+    /**
+     * True when the resolved theme is an **increased-contrast** scheme —
+     * `'high-contrast'` or `'high-contrast-dark'`.
+     *
+     * It answers the contrast question, so it can be true at the same time as
+     * {@link isDark}.
+     */
     readonly isHighContrast: _angular_core.Signal<boolean>;
     /** Snapshot of the full theme state — selected, resolved, system, and boolean flags. */
     readonly state: _angular_core.Signal<TwThemeState>;
     constructor();
-    /** Sets the selected theme. Pass `'system'` to follow the OS preference. */
+    /**
+     * Sets the selected theme and persists it. Pass `'system'` to follow the OS
+     * preference.
+     *
+     * This is the only entry point that writes to `localStorage` — see the note
+     * on the class.
+     */
     setTheme(theme: TwTheme): void;
-    /** Advances the selected theme to the next entry in {@link TW_THEMES}, wrapping around. */
+    /** Advances the selected theme to the next entry in {@link TW_THEMES}, wrapping around, and persists it. */
     cycleTheme(): void;
-    /** Writes the configured theme attribute onto an arbitrary element — used to scope themes to a subtree. */
+    /**
+     * Writes the configured theme attribute onto an arbitrary element, scoping
+     * that subtree to the given theme.
+     *
+     * Each of the four schemes ships an element-agnostic `[data-theme=…]` block
+     * (`_light.css`, `_dark.css`, `_high-contrast.css`,
+     * `_high-contrast-dark.css`), so the tokens really do re-resolve on the
+     * element and cascade into its descendants — including back to `'light'`
+     * from inside a dark page.
+     *
+     * Caveat: those CSS blocks key off the literal `data-theme` attribute. If
+     * `provideTheme({ attribute })` renamed it, this method writes the renamed
+     * attribute and the shipped stylesheet will not react — a custom attribute
+     * only works with matching custom CSS.
+     */
     applyToElement(element: HTMLElement, theme: TwResolvedTheme): void;
     ngOnDestroy(): void;
     private loadInitialTheme;
+    /**
+     * Resolves `'system'` against the OS.
+     *
+     * The two preferences are treated as independent axes and composed, not
+     * ranked: `prefers-color-scheme` picks the appearance and
+     * `prefers-contrast: more` picks the contrast, giving the full 2×2 —
+     * `light` / `dark` / `high-contrast` / `high-contrast-dark`.
+     *
+     * This is only correct because the library ships **both** high-contrast
+     * ramps. While `_high-contrast.css` was the only one, contrast had to be
+     * suppressed whenever the OS also asked for dark, or a user running dark +
+     * increased contrast — a common pairing — would have been moved from a dark
+     * surface onto a white one. `_high-contrast-dark.css` removed that
+     * constraint, so the ranking is gone; if a future change ever drops one of
+     * the two ramps, this method has to go back to ranking them.
+     *
+     * Both queries are minted here (not in the constructor) because the
+     * `systemTheme` field initialiser calls this before the constructor body
+     * runs; the constructor then attaches `change` listeners to the same two
+     * objects, so the resolution stays live rather than read-once.
+     */
     private detectSystemTheme;
     private applyToDocument;
     private persistTheme;
@@ -87,20 +198,115 @@ declare class ThemeService implements OnDestroy {
 }
 
 declare class ThemeDirective {
-    /** Scopes a subtree to a specific resolved theme by writing `data-theme` on the host. Required. */
+    /**
+     * Scopes a subtree to a specific resolved theme by writing `data-theme` on
+     * the host. Required.
+     *
+     * Works in every direction: each of the four schemes ships an
+     * element-agnostic `[data-theme="…"]` block (`_light.css`, `_dark.css`,
+     * `_high-contrast.css`, `_high-contrast-dark.css`), so a `'light'` pane
+     * inside a dark page re-resolves the tokens rather than inheriting the
+     * ancestor's.
+     *
+     * The attribute name is the literal `data-theme` that the shipped CSS keys
+     * off — it deliberately ignores `provideTheme({ attribute })`, since a
+     * renamed attribute matches none of those blocks.
+     */
     readonly twTheme: _angular_core.InputSignal<TwResolvedTheme>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThemeDirective, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ThemeDirective, "[twTheme]", never, { "twTheme": { "alias": "twTheme"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-/** Injection token carrying the resolved {@link TwThemeConfig} (storage key, attribute, target element, default theme). */
-declare const THEME_CONFIG: InjectionToken<TwThemeConfig>;
 /**
- * Registers {@link ThemeService} and a {@link THEME_CONFIG} value built by
- * merging `config` over {@link DEFAULT_TW_THEME_CONFIG}. Call once in the
- * app's environment providers.
+ * Injection token carrying the resolved {@link TwThemeConfig} (storage key,
+ * attribute, target element, default theme).
+ *
+ * The value is `Required<TwThemeConfig>`: `TwThemeConfig`'s members are
+ * optional so consumers can pass a partial config, but `provideTheme` fills
+ * every key from {@link DEFAULT_TW_THEME_CONFIG} before providing it. Injectors
+ * therefore still read a non-optional field for each setting, exactly as
+ * before this token's type was tightened.
+ */
+declare const TW_THEME_CONFIG: InjectionToken<Required<TwThemeConfig>>;
+/**
+ * @deprecated Renamed to {@link TW_THEME_CONFIG} for consistency with every
+ * other ngx-tw injection token. This is the *same token instance*, not a copy —
+ * providing under either name and injecting under the other resolves — so the
+ * rename is safe to adopt incrementally. Removed in the next major.
+ */
+declare const THEME_CONFIG: InjectionToken<Required<TwThemeConfig>>;
+/**
+ * Registers {@link ThemeService}, a {@link TW_THEME_CONFIG} value built by merging
+ * `config` over {@link DEFAULT_TW_THEME_CONFIG}, and an environment initializer
+ * that constructs the service at bootstrap. Call once in the app's environment
+ * providers.
+ *
+ * The initializer is what makes the call self-sufficient. Everything that
+ * applies a theme lives in `ThemeService`'s field initialisers and constructor
+ * effect, so without it the stored preference was read — and `data-theme`
+ * written — only once something happened to `inject(ThemeService)`. An app
+ * whose theme toggle sits in a lazily-loaded route therefore rendered every
+ * other route with no `data-theme` at all, silently falling back to the
+ * `prefers-color-scheme` CSS branch; the failure looked intermittent because
+ * it disappeared whenever the stored choice agreed with the OS. Injecting the
+ * service yourself is still supported and is idempotent.
+ *
+ * Keys explicitly set to `undefined` are dropped before merging. Root
+ * `tsconfig.json` does not set `exactOptionalPropertyTypes`, so
+ * `provideTheme({ storageKey: env.themeKey })` type-checks even when
+ * `env.themeKey` is `string | undefined` — and a plain spread would then write
+ * `undefined` into a field `TwThemeConfig` types as `string`, making
+ * `ThemeService` persist under the literal `localStorage` key `"undefined"`
+ * (and, for `attribute`, call `setAttribute("undefined", …)`).
+ *
+ * Providing the service does **not** write to `localStorage`; only an explicit
+ * `setTheme()` / `cycleTheme()` does. For a flash-free first paint when the
+ * stored choice disagrees with the OS, pair this with
+ * {@link TW_THEME_BOOTSTRAP_SCRIPT} in `index.html`.
  */
 declare function provideTheme(config?: Partial<TwThemeConfig>): EnvironmentProviders;
 
-export { DEFAULT_TW_THEME_CONFIG, THEME_CONFIG, TW_RESOLVED_THEMES, TW_THEMES, ThemeDirective, ThemeService, provideTheme };
+/**
+ * Body of an inline `<head>` script that applies a previously persisted theme
+ * before the app bundle runs, eliminating the flash of the wrong theme on
+ * reload.
+ *
+ * `ThemeService` cannot cover this case: it is JavaScript in the application
+ * bundle, so the browser has already painted by the time it writes
+ * `data-theme` — and `provideTheme`'s environment initializer does not change
+ * that. The CSS `@media (prefers-color-scheme: dark)` fallback covers users
+ * who never chose a theme; the flash is what an *explicit* choice that
+ * disagrees with the OS looks like — light chosen on a dark machine, or
+ * either high-contrast scheme chosen on a machine not already asking for
+ * increased contrast (the CSS has a `prefers-color-scheme` branch but
+ * deliberately no `prefers-contrast` one, so neither contrast scheme is
+ * reachable without an explicit `data-theme`).
+ *
+ * The string is built from {@link DEFAULT_TW_THEME_CONFIG}, so the storage key
+ * and attribute cannot drift from what `ThemeService` actually uses — that
+ * drift is the reason this ships as code rather than as a README snippet
+ * alone. Copy the literal script into `index.html`, or interpolate this
+ * constant during an SSR / index transform:
+ *
+ * ```html
+ * <head>
+ *   <script>try{var t=localStorage.getItem('ngx-tw-theme');if(t&&t!=='system')document.documentElement.setAttribute('data-theme',t)}catch(e){}</script>
+ * </head>
+ * ```
+ *
+ * Notes on the behaviour it deliberately does *not* have:
+ * - A stored `'system'` writes nothing, so the CSS `prefers-color-scheme`
+ *   fallback keeps deciding — which is exactly what `'system'` means.
+ * - It assumes the default `target: 'documentElement'`. A `<head>` script runs
+ *   before `<body>` exists, so `target: 'body'` cannot be bootstrapped this
+ *   way.
+ * - If you overrode `storageKey` or `attribute` via `provideTheme`, adapt the
+ *   literal snippet to match; this constant only encodes the defaults.
+ * - It is dependency-free and wrapped in `try`/`catch`, so a browser with
+ *   storage blocked falls through to the CSS behaviour instead of throwing
+ *   before the app loads.
+ */
+declare const TW_THEME_BOOTSTRAP_SCRIPT: string;
+
+export { DEFAULT_TW_THEME_CONFIG, THEME_CONFIG, TW_RESOLVED_THEMES, TW_THEMES, TW_THEME_BOOTSTRAP_SCRIPT, TW_THEME_CONFIG, ThemeDirective, ThemeService, provideTheme };
 export type { TwResolvedTheme, TwTheme, TwThemeConfig, TwThemeState };

package/types/cdevhub-ngx-tw-time-picker-testing.d.ts

@@ -0,0 +1,129 @@
+import { ComponentHarness, BaseHarnessFilters, HarnessPredicate } from '@angular/cdk/testing';
+
+/**
+ * The editable numeric fields, in render order. Mirrored here rather than
+ * imported from `@cdevhub/ngx-tw/time-picker` so a test file does not have to
+ * pull in the component entry point just to name a field.
+ */
+type TimePickerHarnessField = 'hour' | 'minute' | 'second';
+/** The two meridiem options of the 12h format. */
+type TimePickerHarnessMeridiem = 'AM' | 'PM';
+/** Filters accepted by `TimePickerHarness.with`. */
+interface TimePickerHarnessFilters extends BaseHarnessFilters {
+    /** Match by the field group's accessible name. */
+    label?: string | RegExp;
+    /** Match disabled / enabled time pickers. */
+    disabled?: boolean;
+}
+/**
+ * Harness for `tw-time-picker`.
+ *
+ * Unlike every other picker in the library this component has **no CDK
+ * overlay** — it renders three `input[role="spinbutton"]` fields inline inside
+ * a `role="group"`, plus an optional stepper pair, an optional AM/PM
+ * radiogroup, and an optional clear button. Nothing here reaches outside the
+ * host, so no `documentRootLocatorFactory()` is involved.
+ *
+ * Fields are addressed by position, not by `aria-label`: every visible string
+ * on this component comes from the injectable `TimePickerIntl` and a localized
+ * app would break a label-based selector.
+ */
+declare class TimePickerHarness extends ComponentHarness {
+    static hostSelector: string;
+    private readonly group;
+    private readonly fields;
+    /**
+     * The two stepper buttons, up then down. They are the only buttons inside a
+     * plain (role-less) wrapper div — the meridiem buttons live in a
+     * `role="radiogroup"` and the clear button is a direct child of the host.
+     */
+    private readonly steppers;
+    /** The AM then PM radio, present only while `format` is `'12h'`. */
+    private readonly meridiemButtons;
+    /** Predicate for `locatorFor` / `locatorForAll`. */
+    static with(options?: TimePickerHarnessFilters): HarnessPredicate<TimePickerHarness>;
+    /**
+     * The field group's accessible name, from `aria-label` on the
+     * `role="group"` wrapper. `null` when the group is named by reference
+     * (`aria-labelledby`) instead — a `<tw-form-field>` label does exactly that.
+     */
+    getLabel(): Promise<string | null>;
+    /** Whether the seconds field is rendered (`showSeconds`). */
+    hasSeconds(): Promise<boolean>;
+    /** Whether the stepper buttons are rendered (`showSteppers`, suppressed at `xs` density). */
+    hasSteppers(): Promise<boolean>;
+    /**
+     * The numeric value of one field, read from its `aria-valuenow`. `null` when
+     * the field is blank. In `12h` format the hour is 1–12 and the meridiem is
+     * read separately via {@link getMeridiem}.
+     */
+    getValue(field: TimePickerHarnessField): Promise<number | null>;
+    /**
+     * The spoken text of one field, from `aria-valuetext` — `'Empty'` for a blank
+     * field, and the hour additionally carries the meridiem in `12h` format.
+     * Exposed because it is what a screen reader announces, which no other read
+     * on this harness reproduces.
+     */
+    getValueText(field: TimePickerHarnessField): Promise<string | null>;
+    /**
+     * Types `value` into one field as two digits, exactly as a user would.
+     *
+     * The component drives entry from `beforeinput`, buffering one digit at a
+     * time, so the first digit lands on its own before the second replaces the
+     * buffer. That means a *partial* time may be committed in between — the same
+     * intermediate emission a real keystroke pair produces. Pass values inside
+     * the field's range (hour 0–23, or 1–12 in `12h` format; minute/second 0–59)
+     * or the component will reject the digit that overflows.
+     */
+    setValue(field: TimePickerHarnessField, value: number): Promise<void>;
+    /** Clears one field's text, leaving the time incomplete. */
+    clearValue(field: TimePickerHarnessField): Promise<void>;
+    /**
+     * The current meridiem, or `null` in `24h` format where no radiogroup is
+     * rendered.
+     */
+    getMeridiem(): Promise<TimePickerHarnessMeridiem | null>;
+    /**
+     * Clicks the AM or PM radio. Throws in `24h` format, where the control does
+     * not exist. Selecting the already-selected meridiem is a no-op, as it is for
+     * a user.
+     */
+    setMeridiem(meridiem: TimePickerHarnessMeridiem): Promise<void>;
+    /**
+     * Focuses `field` and clicks the up stepper, which steps whichever field
+     * holds focus by that field's configured step, wrapping at its bounds.
+     * Throws when the steppers are not rendered.
+     */
+    stepUp(field?: TimePickerHarnessField): Promise<void>;
+    /** Focuses `field` and clicks the down stepper. Throws when the steppers are not rendered. */
+    stepDown(field?: TimePickerHarnessField): Promise<void>;
+    /** Whether every field reports `aria-disabled="true"`. */
+    isDisabled(): Promise<boolean>;
+    /** Whether the fields report `aria-invalid="true"`. */
+    isInvalid(): Promise<boolean>;
+    /**
+     * Whether the fields report `aria-required="true"`. Reflects the `required`
+     * input *and* a `Validators.required` on a bound control.
+     */
+    isRequired(): Promise<boolean>;
+    /**
+     * Whether the clear control is rendered. It appears only while `showClear` is
+     * on, the picker is enabled and not readonly, and a value is set.
+     */
+    hasClearButton(): Promise<boolean>;
+    /** Clicks the clear control. Throws when none is rendered. */
+    clear(): Promise<void>;
+    /** @internal Resolves one field by its position in the spinbutton sequence. */
+    private field;
+    /**
+     * @internal The clear button — the only `<button>` that is a direct child of
+     * the host, the steppers and meridiem radios both sitting inside wrapper
+     * divs.
+     */
+    private clearButton;
+    /** @internal Focuses a field, then clicks the stepper at `index` (0 = up, 1 = down). */
+    private clickStepper;
+}
+
+export { TimePickerHarness };
+export type { TimePickerHarnessField, TimePickerHarnessFilters, TimePickerHarnessMeridiem };