ngwr 10.2.0 → 11.0.0

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

@@ -0,0 +1,202 @@
+import { BaseHarnessFilters, ComponentHarness, HarnessPredicate, ContentContainerComponentHarness, HarnessLoader } 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 `[wrDropdown]` trigger a harness query matches. */
+interface WrDropdownHarnessFilters extends BaseHarnessFilters {
+    /**
+     * Match the trigger's visible text — the label of whatever element the
+     * consumer put `[wrDropdown]` on. A string is an exact match, a RegExp is
+     * tested.
+     */
+    readonly text?: string | RegExp;
+    /** Match only open (`true`) or only closed (`false`) dropdowns. */
+    readonly open?: boolean;
+}
+/** Narrows which item inside a dropdown's menu a harness query matches. */
+interface WrDropdownItemHarnessFilters extends BaseHarnessFilters {
+    /** Match the item's label — a string is an exact match, a RegExp is tested. */
+    readonly text?: string | RegExp;
+    /** Match only enabled (`false`) or only disabled (`true`) items. */
+    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 `<wr-dropdown-item>` inside a dropdown menu.
+ *
+ * The selector is the CLASS rather than the element: `.wr-dropdown-item` is what
+ * the directive's own keyboard navigation queries, so it is the contract both
+ * sides already rely on. Only the class, though — the directive narrows its query
+ * to `:not(.wr-dropdown-item--disabled)` because it is looking for focus stops,
+ * while a spec still has to be able to see a disabled item and assert that it is
+ * one.
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrDropdownItemHarness extends ComponentHarness {
+    /** The class the item paints on its host, and the one arrow-key navigation looks for. */
+    static hostSelector: string;
+    /** Build a predicate that narrows the query. */
+    static with(options?: WrDropdownItemHarnessFilters): HarnessPredicate<WrDropdownItemHarness>;
+    /** The item's label, trimmed. A leading icon is not part of it. */
+    getText(): Promise<string>;
+    /** The role the item announces — `menuitem`. */
+    getRole(): Promise<string | null>;
+    /** Whether the item refuses activation. */
+    isDisabled(): Promise<boolean>;
+    /** Whether the item shows a leading icon. */
+    hasIcon(): Promise<boolean>;
+    /** The leading icon's registered name, or `null` when the item has no icon. */
+    getIconName(): Promise<string | null>;
+    /** Whether the item holds the menu's roving focus. */
+    isFocused(): Promise<boolean>;
+    /**
+     * Click the item. A disabled item throws instead.
+     *
+     * Refusing is the only honest answer: the item's own `disabled` guards the
+     * KEYBOARD path only, and a pointer is stopped by `pointer-events: none` in the
+     * stylesheet. jsdom loads no stylesheets, so a click dispatched here would land
+     * on the host — exactly where the consumer bound `(click)` — and the spec would
+     * record an activation that cannot happen in a browser. Assert `isDisabled()`
+     * instead.
+     */
+    click(): Promise<void>;
+}
+
+/**
+ * @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 `[wrDropdown]` — the trigger, and the menu it opens.
+ *
+ * The harness matches the TRIGGER, because that is the only part of the dropdown
+ * in the fixture: `<wr-dropdown-menu>` renders nothing of its own (it hands over
+ * an `<ng-template>`), and the menu is portalled into the overlay container, a
+ * sibling of the whole app. So every item is read through the document root,
+ * scoped by the `aria-controls` id the trigger publishes while it is open — which
+ * is what keeps two dropdowns on one page from answering with each other's items.
+ *
+ * That scoped loader is also this harness's CONTENT loader, so
+ * `dropdown.getHarness(…)` resolves inside THIS dropdown's menu: the consumer's
+ * own components in the menu are reachable without the spec ever touching the
+ * overlay, and so is a nested `[wrDropdown]`, which is how a submenu is built
+ * here (the component ships no submenu API of its own).
+ *
+ * @example
+ * ```ts
+ * const dropdown = await loader.getHarness(WrDropdownHarness.with({ text: 'Actions' }));
+ *
+ * await dropdown.open();
+ * expect(await dropdown.getItemTexts()).toEqual(['Copy', 'Delete']);
+ *
+ * await dropdown.clickItem({ text: 'Copy' });
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrDropdownHarness extends ContentContainerComponentHarness {
+    /** The directive's host — whatever element the consumer put `[wrDropdown]` on. */
+    static hostSelector: string;
+    /** Build a predicate that narrows the query. */
+    static with(options?: WrDropdownHarnessFilters): HarnessPredicate<WrDropdownHarness>;
+    /** The trigger's visible text. */
+    getTriggerText(): Promise<string>;
+    /** Whether the menu is showing. */
+    isOpen(): Promise<boolean>;
+    /** The role the menu announces — `menu`. Throws while the menu is closed. */
+    getMenuRole(): Promise<string | null>;
+    /**
+     * Whether the menu takes its accessible name from this trigger.
+     *
+     * The menu carries no label of its own, so that reference IS its name — and the
+     * id it points at is generated unless the consumer named the trigger
+     * themselves, which is why a spec cannot simply hard-code one.
+     */
+    isMenuLabelledByTrigger(): Promise<boolean>;
+    /**
+     * Open the menu, whichever gesture this dropdown listens for.
+     *
+     * `trigger` is not reflected in the DOM, so the harness cannot ask which mode it
+     * is in: it moves the pointer on first and falls back to a click. Hover leads
+     * because a click is an outside pointer event for every OTHER open overlay — so
+     * leading with it would shut someone else's menu on the way to opening this one
+     * — and a `trigger="click"` dropdown ignores the hover outright.
+     */
+    open(): Promise<void>;
+    /**
+     * Open the menu from the keyboard — ArrowDown on the trigger, the APG
+     * menu-button path (ArrowUp / Enter / Space do the same).
+     *
+     * Worth its own method rather than an argument to `open()`: it is the only way
+     * to get TWO dropdowns open at once, because clicking a second trigger is an
+     * outside pointer event for the first and closes it.
+     */
+    openByKeyboard(): Promise<void>;
+    /** Close the menu. A closed dropdown is left alone. */
+    close(): Promise<void>;
+    /** Click the trigger. A `trigger="hover"` dropdown deliberately ignores this. */
+    clickTrigger(): Promise<void>;
+    /** Move the pointer onto the trigger. Opens a `trigger="hover"` dropdown. */
+    hoverTrigger(): Promise<void>;
+    /** Move the pointer off the trigger. Closes a `trigger="hover"` dropdown. */
+    mouseAwayFromTrigger(): Promise<void>;
+    /**
+     * The items in this dropdown's menu, in DOM order.
+     *
+     * Throws while the menu is closed: the items do not exist anywhere until the
+     * portal is attached, and an empty array reads like a menu that rendered
+     * nothing — a failure three lines later instead of here.
+     */
+    getItems(filters?: WrDropdownItemHarnessFilters): Promise<WrDropdownItemHarness[]>;
+    /** The labels of the items in this dropdown's menu, in DOM order. */
+    getItemTexts(): Promise<string[]>;
+    /**
+     * Open the menu if it is closed, then click the first item matching the filters.
+     *
+     * Picking does NOT close the menu — there is no close-on-select in the item or
+     * the menu, so a consumer who wants one calls `close()` themselves.
+     */
+    clickItem(filters: WrDropdownItemHarnessFilters): Promise<void>;
+    /**
+     * The label of the item that currently holds focus, or `null` when focus is
+     * elsewhere.
+     *
+     * The menu roves focus rather than moving a visual cursor — it lands on the
+     * first ENABLED item as the menu renders, and the arrow keys walk it from there
+     * over the enabled items only (a disabled one is not a stop) — so this is the
+     * only way to ask where the keyboard is.
+     */
+    getFocusedItemText(): Promise<string | null>;
+    /**
+     * A loader scoped to THIS dropdown's menu — the content loader every
+     * `HarnessLoader` method on this class runs through, `getItems()` included.
+     *
+     * Scoped by the published id rather than by `.wr-dropdown-menu`: the overlay
+     * container is shared, so a bare class query would answer with whichever
+     * dropdown happened to open first.
+     */
+    protected getRootHarnessLoader(): Promise<HarnessLoader>;
+    /** This dropdown's menu element in the overlay. */
+    private menu;
+    /** The id the trigger publishes as `aria-controls`, which its menu carries. */
+    private menuId;
+}
+
+export { WrDropdownHarness, WrDropdownItemHarness };
+export type { WrDropdownHarnessFilters, WrDropdownItemHarnessFilters };

package/types/ngwr-dropdown.d.ts

@@ -80,7 +80,13 @@ declare class WrDropdown {
     private readonly destroyRef;
     /** @internal Public so host bindings can read it. */
     readonly isOpen: _angular_core.WritableSignal<boolean>;
-    /** Auto-generated id for `aria-labelledby` wiring on the menu. */
+    /**
+     * Id the menu names itself after. The trigger is the CONSUMER's own element, so
+     * an `id` they already put there wins: overwriting it broke `<label for>`,
+     * `document.getElementById` and any `aria-labelledby` aimed at that button from
+     * elsewhere in their app. The generated one is only a fallback so the menu has
+     * something to reference.
+     */
     protected readonly triggerId: string;
     private overlayRef;
     constructor();

package/types/ngwr-empty.d.ts

@@ -15,7 +15,7 @@ import * as _angular_core from '@angular/core';
  *
  * @example
  * ```html
- * <wr-empty icon="search" title="No results">
+ * <wr-empty iconName="search" title="No results">
  *   Try a different query or clear filters.
  *   <ng-container wrEmptyActions>
  *     <wr-btn (click)="reset()">Reset filters</wr-btn>
@@ -26,13 +26,28 @@ import * as _angular_core from '@angular/core';
  * @see https://ngwr.dev/reference/components/empty
  */
 declare class WrEmpty {
-    /** Icon name shown above the title. @default 'folder' */
-    readonly icon: _angular_core.InputSignal<string | null>;
+    /**
+     * Render the built-in folder glyph. Pass `false` to show no icon at all.
+     * Ignored when `iconName` is set — the same contract as `<wr-alert>`.
+     *
+     * This used to be typed as an icon NAME, which it never was: whatever name
+     * you passed, the template drew the folder. Any truthy value still shows it,
+     * so nothing that compiled before behaves differently.
+     *
+     * @default true
+     */
+    readonly icon: _angular_core.InputSignalWithTransform<boolean, any>;
+    /**
+     * Show any registered ngwr icon instead of the built-in glyph.
+     *
+     * @default null
+     */
+    readonly iconName: _angular_core.InputSignal<string | null>;
     /** Headline. Falls back to `empty.noData` from WrI18n, then `'No data'`. */
     readonly title: _angular_core.InputSignal<string | null>;
     protected readonly resolvedTitle: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrEmpty, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrEmpty, "wr-empty", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; }, {}, never, ["*", "[wrEmptyActions]"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrEmpty, "wr-empty", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconName": { "alias": "iconName"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; }, {}, never, ["*", "[wrEmptyActions]"], true, never>;
 }
 
 export { WrEmpty };

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

@@ -218,6 +218,7 @@ declare class WrEventCalendar {
     readonly eventChange: _angular_core.OutputEmitterRef<WrCalendarEventChange>;
     private readonly adapter;
     private readonly document;
+    private readonly dir;
     private readonly chipTpl;
     protected readonly todayLabel: string;
     protected readonly previousLabel: string;
@@ -254,7 +255,13 @@ declare class WrEventCalendar {
     /** Only what overlaps the window — everything downstream works off this. */
     private readonly visible;
     protected readonly title: _angular_core.Signal<string>;
-    protected readonly weekdayNames: _angular_core.Signal<string[]>;
+    /**
+     * The adapter contract is "names ordered from `getFirstDayOfWeek()` onwards",
+     * so the list is ALREADY rotated. Rotating it again here put every column one
+     * day out for every locale whose week does not start on Sunday — invisible in
+     * en-US, wrong everywhere else. `wr-calendar` consumes the same call directly.
+     */
+    protected readonly weekdayNames: _angular_core.Signal<readonly string[]>;
     protected readonly switcher: _angular_core.Signal<{
         view: WrCalendarView;
         label: string;
@@ -282,6 +289,15 @@ declare class WrEventCalendar {
     protected onCellClick(date: Date, minutes: number): void;
     protected onChipKeyDown(event: KeyboardEvent, chipEvent: WrCalendarEvent): void;
     protected onGridKeyDown(event: KeyboardEvent): void;
+    /**
+     * Keep the roving cursor on the cell that actually has focus.
+     *
+     * The cursor was only ever written by an arrow key, while focus moves for three
+     * other reasons — a click, a Tab onto a chip, Escape out of one — so the next
+     * arrow read a coordinate nobody was standing on and threw focus back to it,
+     * usually the top-left of the grid.
+     */
+    protected onCellFocus(day: number, minutes: number): void;
     protected isCursor(day: number, minutes: number): boolean;
     /**
      * Greedy lane packing for day-spanning chips. Sorted by start then by length,
@@ -323,6 +339,15 @@ declare class WrEventCalendar {
     private spansWholeDay;
     private clock;
     private iso;
+    /**
+     * The key as the grid SEES it.
+     *
+     * A day step follows visual order, so under `dir="rtl"` ArrowRight goes back a
+     * day. Up/Down move by week or by row and never flip; Home/End are semantic.
+     * Both key handlers route through here — the grid nav and the `Alt`+arrow drag,
+     * which moves an event and would otherwise reschedule it the wrong way.
+     */
+    private inlineKey;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrEventCalendar, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrEventCalendar, "wr-event-calendar", never, { "events": { "alias": "events"; "required": false; "isSignal": true; }; "view": { "alias": "view"; "required": false; "isSignal": true; }; "date": { "alias": "date"; "required": false; "isSignal": true; }; "views": { "alias": "views"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "slotMinutes": { "alias": "slotMinutes"; "required": false; "isSignal": true; }; "dayStartHour": { "alias": "dayStartHour"; "required": false; "isSignal": true; }; "dayEndHour": { "alias": "dayEndHour"; "required": false; "isSignal": true; }; "maxLanes": { "alias": "maxLanes"; "required": false; "isSignal": true; }; "hideHeader": { "alias": "hideHeader"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "view": "viewChange"; "date": "dateChange"; "eventClick": "eventClick"; "slotClick": "slotClick"; "eventChange": "eventChange"; }, ["chipTpl"], never, true, never>;
 }

package/types/ngwr-file-upload-testing.d.ts

@@ -0,0 +1,194 @@
+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-file-upload>` a harness query matches. */
+interface WrFileUploadHarnessFilters extends BaseHarnessFilters {
+    /**
+     * Match the drop zone's accessible name — a string is an exact match, a RegExp
+     * is tested. This is `dropZoneLabel`, not the visible CTA: the zone carries an
+     * `aria-label`, so the copy inside it is not what identifies the control.
+     */
+    readonly label?: string | RegExp;
+    /** Match only single-file (`false`) or only multi-file (`true`) uploads. */
+    readonly multiple?: boolean;
+    /** Match only enabled (`false`) or only disabled (`true`) uploads. */
+    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-file-upload>`.
+ *
+ * The control a user operates is the `.wr-file-upload__zone` — a `role="button"`
+ * div that is the single tab stop; the `<input type="file">` behind it is
+ * `aria-hidden` and `tabindex="-1"`, and exists only so a click can be forwarded
+ * to it. So focus, drag and disabled state are all read off the zone, plus the
+ * `wr-file-upload--*` host modifiers and the rendered file list. The picker is
+ * touched only where it is the one that carries the state — `accept` and
+ * `multiple` land on it, and {@link selectFiles} has to hand it the files.
+ *
+ * What this component does NOT have, so this harness does not either:
+ * - **no per-file progress or status.** `<wr-file-upload>` picks files; uploading
+ *   them is the app's job, and there is no bar or state to read.
+ * - **no rendered error.** A file refused for its type, its size or the file count
+ *   leaves NOTHING in the DOM — no `aria-invalid`, no message, and a list that
+ *   simply did not grow. The `(rejected)` output is the only channel, so a spec
+ *   asserts on the host's handler. See {@link selectFiles}.
+ * - **no `maxSize` / `maxFiles` readback.** Neither reaches the DOM (unlike
+ *   `accept` and `multiple`, which land on the picker), so they can only be
+ *   observed by offering a file that breaks them.
+ *
+ * Two traps worth knowing before writing assertions. The bound value's SHAPE
+ * follows `multiple` — a bare `File` (or `null`) in single mode, a `File[]` in
+ * multi — and `[showList]="false"` renders no list at all, so {@link getFileNames}
+ * answers `[]` for a component that is holding files. Assert the bound value in
+ * that case.
+ *
+ * @example
+ * ```ts
+ * const upload = await loader.getHarness(WrFileUploadHarness.with({ label: 'Avatar' }));
+ * await upload.selectFiles(new File(['…'], 'me.png', { type: 'image/png' }));
+ *
+ * expect(await upload.getFileNames()).toEqual(['me.png']);
+ * await upload.removeFileNamed('me.png');
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrFileUploadHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrFileUploadHarnessFilters): HarnessPredicate<WrFileUploadHarness>;
+    private readonly zone;
+    private readonly picker;
+    private readonly items;
+    private readonly names;
+    private readonly sizes;
+    private readonly removeButtons;
+    /**
+     * The accessible name of the trigger — what a screen-reader user is told this
+     * control is.
+     *
+     * Read from the zone's `aria-label` (the `dropZoneLabel` input) rather than from
+     * the copy inside it, because that label OVERRIDES the copy: the visible "Click
+     * to browse" is not the accessible name, and a harness that returned it would
+     * describe a control nobody is announced.
+     */
+    getLabel(): Promise<string>;
+    /** The visible call-to-action line — the `pickLabel` input. */
+    getPickText(): Promise<string>;
+    /** The visible instruction below the CTA — the `dropLabel` input. */
+    getDropText(): Promise<string>;
+    /** The optional `helperText` line, or `null` when the component was given none. */
+    getHelperText(): Promise<string | null>;
+    /** The `accept` list the picker advertises, or `null` when it accepts anything. */
+    getAccept(): Promise<string | null>;
+    /**
+     * Whether more than one file can be held.
+     *
+     * Read as the DOM PROPERTY: the template writes the attribute as an empty string
+     * (`[attr.multiple]="multiple() ? '' : null"`), and `''` is falsy — an attribute
+     * read would report a multi-file upload as single.
+     */
+    isMultiple(): Promise<boolean>;
+    /**
+     * Whether the control refuses interaction.
+     *
+     * Read from the zone's `aria-disabled`. The host also carries
+     * `wr-file-upload--disabled` and the picker its own `disabled`, but the zone is
+     * a `role="button"` div — `aria-disabled` is the only one of the three that
+     * tells a screen-reader user the trigger is inert.
+     */
+    isDisabled(): Promise<boolean>;
+    /**
+     * Whether the zone is armed for a drop.
+     *
+     * The `wr-file-upload--dragging` host modifier is the whole signal — a drop
+     * target has no ARIA state, so there is nothing better to read here.
+     */
+    isDragging(): Promise<boolean>;
+    /** How many files the list is RENDERING. Zero with `[showList]="false"`, always. */
+    getFileCount(): Promise<number>;
+    /** The file names in the rendered list, in order. */
+    getFileNames(): Promise<string[]>;
+    /**
+     * The file sizes in the rendered list, as SHOWN — `'4.9 KB'`, not `5000`.
+     *
+     * The component formats bytes for display and the byte count never reaches the
+     * DOM, so this is the string a user reads. Assert the `File` itself if the exact
+     * size matters.
+     */
+    getFileSizes(): Promise<string[]>;
+    /**
+     * Hand files to the picker, the way choosing them in the browser dialog does.
+     *
+     * This is the one method that reaches past `TestElement` to the native
+     * `<input type="file">`, and it has to: `TestElement` has no file API, and it
+     * cannot grow one portably, because a `FileList` is not constructible and a
+     * remote WebDriver session cannot be handed a `File` object at all. Everything
+     * else on this harness is environment-agnostic; this needs a DOM behind it
+     * (`TestbedHarnessEnvironment`), and says so with an error when it does not have
+     * one. The input is found through this harness's own locator rather than a
+     * `document` query, so it is still THIS component's picker that gets the files.
+     *
+     * Rejected files are silent: nothing appears in the DOM, so pair this with the
+     * host's `(rejected)` handler when a file is meant to be refused. In single mode
+     * the LAST accepted file wins, which is also how a drop of several files onto a
+     * single-file zone behaves.
+     *
+     * @throws if called with no files, on a disabled upload, or outside a DOM
+     *   environment.
+     */
+    selectFiles(...files: File[]): Promise<void>;
+    /**
+     * Drag files over the zone and drop them.
+     *
+     * Driven by dispatching the drag sequence AT the zone rather than by coordinates:
+     * nothing has layout in a unit test — `getBoundingClientRect` is all zeros — so a
+     * pointer-driven drag would land nowhere. From the component's side it is the
+     * same event either way; it reads `dataTransfer.files` and never a position.
+     *
+     * A disabled upload refuses the drop itself, so this stays a no-op there rather
+     * than throwing the way {@link selectFiles} does — that refusal is the
+     * component's own, and worth asserting.
+     */
+    dropFiles(...files: File[]): Promise<void>;
+    /** Drag over the zone without letting go — arms {@link isDragging}. */
+    dragOver(): Promise<void>;
+    /**
+     * Drag back out of the zone, disarming {@link isDragging}.
+     *
+     * Dispatched at the zone itself on purpose: the component ignores a `dragleave`
+     * whose target is one of the zone's children, because crossing the icon or the
+     * hint text is not leaving the zone.
+     */
+    dragLeave(): Promise<void>;
+    /**
+     * Remove the file at `index` from the rendered list.
+     *
+     * On a disabled upload the remove buttons are disabled too, so this is a no-op
+     * there — assert the result rather than assuming it.
+     */
+    removeFile(index: number): Promise<void>;
+    /** Remove the file with this name. Names come from {@link getFileNames}. */
+    removeFileNamed(name: string): Promise<void>;
+    /** Move keyboard focus to the zone — the control's only tab stop. */
+    focus(): Promise<void>;
+    /** Whether the zone has focus. */
+    isFocused(): Promise<boolean>;
+}
+
+export { WrFileUploadHarness };
+export type { WrFileUploadHarnessFilters };