@cdevhub/ngx-tw 0.4.0 → 0.6.0

package/types/cdevhub-ngx-tw-select-testing.d.ts

@@ -0,0 +1,114 @@
+import { BaseHarnessFilters, ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+
+/** Filters accepted by `SelectOptionHarness.with`. */
+interface SelectOptionHarnessFilters extends BaseHarnessFilters {
+    /** Match by the option's visible text. */
+    text?: string | RegExp;
+    /** Match selected / unselected options. */
+    selected?: boolean;
+    /** Match disabled / enabled options. */
+    disabled?: boolean;
+}
+/**
+ * Harness for a single option inside an open `tw-select` panel.
+ *
+ * Options render into the CDK overlay, not inside `tw-select`, so they are
+ * reached through {@link SelectHarness} rather than located directly against a
+ * fixture.
+ */
+declare class SelectOptionHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Predicate for `locatorFor` / `locatorForAll`. */
+    static with(options?: SelectOptionHarnessFilters): HarnessPredicate<SelectOptionHarness>;
+    /** The option's rendered text, trimmed. */
+    getText(): Promise<string>;
+    /** Whether the option reports `aria-selected="true"`. */
+    isSelected(): Promise<boolean>;
+    /** Whether the option reports `aria-disabled="true"`. */
+    isDisabled(): Promise<boolean>;
+    /** Clicks the option. A disabled option ignores the click, as in the browser. */
+    click(): Promise<void>;
+}
+
+/** Filters accepted by `SelectHarness.with`. */
+interface SelectHarnessFilters extends BaseHarnessFilters {
+    /** Match by the trigger's accessible name. */
+    label?: string | RegExp;
+    /** Match by the text currently displayed in the trigger. */
+    triggerText?: string | RegExp;
+    /** Match disabled / enabled selects. */
+    disabled?: boolean;
+}
+/**
+ * Harness for `tw-select`.
+ *
+ * The options panel renders into the CDK overlay container, outside the
+ * `tw-select` host, so this harness resolves it through
+ * `documentRootLocatorFactory()`. A consumer can therefore load this harness
+ * from the ordinary fixture loader and still reach the options — no
+ * `documentRootLoader` ceremony required.
+ *
+ * The panel is *disposed* on close rather than merely detached, so option
+ * harnesses must be re-read after each `open()`. Do not cache them across a
+ * close.
+ */
+declare class SelectHarness extends ComponentHarness {
+    static hostSelector: string;
+    private readonly trigger;
+    private readonly clearButton;
+    /** Resolves the overlay panel, which lives outside this harness's host. */
+    private readonly panel;
+    /** Predicate for `locatorFor` / `locatorForAll`. */
+    static with(options?: SelectHarnessFilters): HarnessPredicate<SelectHarness>;
+    /** The trigger's accessible name, from `aria-label` when one is set. */
+    getLabel(): Promise<string | null>;
+    /**
+     * The text currently rendered in the trigger, trimmed. This is the
+     * placeholder when the select holds no value.
+     */
+    getTriggerText(): Promise<string>;
+    /** Whether the panel is open, read from the trigger's `aria-expanded`. */
+    isOpen(): Promise<boolean>;
+    /** Whether the trigger reports `aria-disabled="true"`. */
+    isDisabled(): Promise<boolean>;
+    /** Whether the trigger reports `aria-invalid="true"`. */
+    isInvalid(): Promise<boolean>;
+    /** Whether the trigger reports `aria-required="true"`. */
+    isRequired(): Promise<boolean>;
+    /** Opens the panel. No-op when already open. */
+    open(): Promise<void>;
+    /** Closes the panel with Escape. No-op when already closed. */
+    close(): Promise<void>;
+    /**
+     * Every option in the open panel. Returns an empty array when the panel is
+     * closed, because the overlay is disposed rather than hidden.
+     */
+    getOptions(filters?: SelectOptionHarnessFilters): Promise<SelectOptionHarness[]>;
+    /**
+     * Opens the panel if needed and clicks the first option whose text matches.
+     * Throws when nothing matches, rather than failing silently.
+     */
+    selectOption(text: string | RegExp): Promise<void>;
+    /**
+     * The text of every currently selected option. Opens the panel if needed,
+     * because selection state is exposed on the options, which only exist while
+     * the panel is attached.
+     */
+    getSelectedOptionTexts(): Promise<string[]>;
+    /**
+     * Whether a clear control is rendered. `tw-select` has no `clearable` input —
+     * the control appears whenever the select is enabled and holds a value.
+     */
+    hasClearButton(): Promise<boolean>;
+    /**
+     * Clicks the clear control. Throws when none is rendered.
+     *
+     * The control is a native `<button>` and a *sibling* of the trigger, not a
+     * descendant — HTML's content model forbids interactive content inside a
+     * `<button>`.
+     */
+    clear(): Promise<void>;
+}
+
+export { SelectHarness, SelectOptionHarness };
+export type { SelectHarnessFilters, SelectOptionHarnessFilters };

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

@@ -143,13 +143,13 @@ declare class SelectFooterTemplateDirective {
 declare class SelectComponent<T = unknown> implements ControlValueAccessor, FormFieldControl<T | readonly T[]>, OnInit {
     /** Array of options to render in the panel. Accepts either `TwSelectOption<T>` objects or arbitrary records read via the accessor inputs. Defaults to an empty array. */
     readonly options: _angular_core.InputSignal<readonly unknown[]>;
-    /** Accessor returning the visible label for an option. Override when passing arbitrary objects. */
+    /** Accessor returning the visible label for an option. Override when passing arbitrary objects. Defaults to reading `.label`, falling back to `String(.value)`. */
     readonly optionLabel: _angular_core.InputSignal<(option: unknown) => string>;
-    /** Accessor returning the value for an option. The result is what `value` / `valueChange` emit. */
+    /** Accessor returning the value for an option. The result is what `value` / `valueChange` emit. Defaults to reading `.value`. */
     readonly optionValue: _angular_core.InputSignal<(option: unknown) => T>;
     /** Accessor returning the disabled state for an option. Defaults to reading `.disabled`. */
     readonly optionDisabled: _angular_core.InputSignal<(option: unknown) => boolean>;
-    /** Accessor returning the group name for an option. Options sharing a group render under a labelled `role="group"` region. */
+    /** Accessor returning the group name for an option. Options sharing a group render under a labelled `role="group"` region. Defaults to reading `.group`. */
     readonly optionGroup: _angular_core.InputSignal<(option: unknown) => string | undefined>;
     /** When true, enables multi-selection. The `value` model becomes a `T[]` and the panel renders checkable options. Defaults to `false`. */
     readonly multiple: _angular_core.InputSignal<boolean>;
@@ -157,11 +157,11 @@ declare class SelectComponent<T = unknown> implements ControlValueAccessor, Form
     readonly searchable: _angular_core.InputSignal<boolean>;
     /** Custom filter function for the search input. Defaults to a case-insensitive substring match on the option label. */
     readonly filterPredicate: _angular_core.InputSignal<(option: unknown, search: string) => boolean>;
-    /** Placeholder text shown in the trigger when no value is selected. */
+    /** Placeholder text shown in the trigger when no value is selected. Defaults to `undefined`. */
     readonly placeholder: _angular_core.InputSignal<string | undefined>;
-    /** When true, the trigger cannot be activated and the panel cannot open. Defaults to `false`. */
+    /** When true, the trigger cannot be activated and the panel cannot open. Defaults to `false`. Alias: `disabled`. */
     readonly disabledInput: _angular_core.InputSignal<boolean>;
-    /** When true, exposes `aria-required="true"` on the trigger. Defaults to `false`. */
+    /** When true, exposes `aria-required="true"` on the trigger and the `*` marker on a wrapping `tw-form-field`. Also inferred from `Validators.required` on a bound control, so a reactive/template-driven form does not have to state it twice. Defaults to `false`. */
     readonly requiredInput: _angular_core.InputSignal<boolean>;
     /** Controls trigger padding, font size, and panel option density. Defaults to `'md'`. */
     readonly size: _angular_core.InputSignal<TwSize>;
@@ -171,7 +171,7 @@ declare class SelectComponent<T = unknown> implements ControlValueAccessor, Form
     readonly variant: _angular_core.InputSignal<SelectVariant | undefined>;
     /** Overlay panel width. `'trigger'` matches the trigger's measured width; `'auto'` lets content decide; a number is applied as pixels; a string is passed through as a CSS length. Defaults to `'trigger'`. */
     readonly panelWidth: _angular_core.InputSignal<string | number>;
-    /** Extra class(es) applied to the overlay panel element. */
+    /** Extra class(es) applied to the overlay panel element. Defaults to an empty string. */
     readonly panelClass: _angular_core.InputSignal<string | readonly string[]>;
     /** Maximum height of the listbox scroll region in pixels. Defaults to `256`. */
     readonly panelMaxHeight: _angular_core.InputSignal<number>;
@@ -181,27 +181,27 @@ declare class SelectComponent<T = unknown> implements ControlValueAccessor, Form
     readonly scrollStrategy: _angular_core.InputSignal<"reposition" | "close" | "block">;
     /** Pixel distance between trigger and panel. Defaults to `4`. */
     readonly offset: _angular_core.InputSignal<number>;
-    /** Fallback message rendered when the filter yields no options and no `*twSelectEmpty` template is provided. */
+    /** Fallback message rendered when the filter yields no options and no `*twSelectEmpty` template is provided. Defaults to `'No results'`. */
     readonly emptyMessage: _angular_core.InputSignal<string>;
-    /** Accessible name for the combobox trigger. */
+    /** Accessible name for the combobox trigger. Defaults to `undefined`. Alias: `aria-label`. */
     readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
-    /** ID of an external element that labels the combobox. */
+    /** ID of an external element that labels the combobox. Defaults to `undefined`. Alias: `aria-labelledby`. */
     readonly ariaLabelledby: _angular_core.InputSignal<string | undefined>;
-    /** ID of an external element that describes the combobox. */
+    /** ID of an external element that describes the combobox. Defaults to `undefined`. Alias: `aria-describedby`. */
     readonly ariaDescribedby: _angular_core.InputSignal<string | undefined>;
     /** Per-instance override of the {@link ErrorStateMatcher}. When omitted, the select uses the `TW_ERROR_STATE_MATCHER` token's value. */
     readonly errorStateMatcher: _angular_core.InputSignal<ErrorStateMatcher | undefined>;
     /** Equality comparator for option values. Defaults to `Object.is`. */
     readonly compareWith: _angular_core.InputSignal<(a: T, b: T) => boolean>;
-    /** Two-way bound selected value(s). Single-select: `T | null`. Multi-select: `T[]`. */
+    /** Two-way bound selected value(s). Single-select: `T | null`. Multi-select: `T[]`. Defaults to `null`. */
     readonly value: _angular_core.ModelSignal<T | readonly T[] | null>;
-    /** Two-way bound open state of the panel. */
+    /** Two-way bound open state of the panel. Defaults to `false`. */
     readonly open: _angular_core.ModelSignal<boolean>;
-    /** Fires when the panel's visibility finishes changing. */
+    /** Fires when the panel's visibility finishes changing. Payload carries the new `open` state and the trigger element the overlay is anchored to. */
     readonly openedChange: _angular_core.OutputEmitterRef<TwSelectOpenedEvent>;
     /** Fires after any selection change, with `added`, `removed`, `previousValue`, and a `source` discriminator. */
     readonly selectionChange: _angular_core.OutputEmitterRef<TwSelectSelectionChangeEvent<T>>;
-    /** Fires whenever the search input changes (only when `searchable` is true). */
+    /** Fires whenever the search input changes (only when `searchable` is true). Payload carries the raw, untrimmed query and the post-filter `visibleCount`. Emitted immediately, not debounced. */
     readonly searchChange: _angular_core.OutputEmitterRef<TwSelectSearchEvent>;
     /** @internal */
     readonly triggerTemplateChild: Signal<SelectTriggerTemplateDirective<any, any> | undefined>;
@@ -213,7 +213,10 @@ declare class SelectComponent<T = unknown> implements ControlValueAccessor, Form
     readonly headerTemplateChild: Signal<SelectHeaderTemplateDirective | undefined>;
     /** @internal */
     readonly footerTemplateChild: Signal<SelectFooterTemplateDirective | undefined>;
+    /** @internal The combobox trigger — focus target after the clear control unmounts. */
+    private readonly triggerButtonRef;
     private readonly overlayService;
+    private readonly coordinator;
     private readonly elementRef;
     private readonly viewContainerRef;
     private readonly injector;
@@ -223,9 +226,6 @@ declare class SelectComponent<T = unknown> implements ControlValueAccessor, Form
     private readonly platform;
     private readonly formField;
     private readonly ngControl;
-    private readonly parentForm;
-    private readonly parentFormGroup;
-    private readonly defaultMatcher;
     private readonly uid;
     /** @internal */
     readonly hostId: string;
@@ -244,19 +244,22 @@ declare class SelectComponent<T = unknown> implements ControlValueAccessor, Form
     /** @internal */
     readonly focusedSignal: _angular_core.WritableSignal<boolean>;
     private readonly cvaDisabled;
-    private readonly _ngControlRev;
-    private readonly _formSubmitRev;
+    /** @internal Shared `errorState` / `required` / `errors` derivation — see `wireErrorState`. */
+    private readonly errorWiring;
     private readonly describedByIdsSignal;
     private readonly labelledByIdsSignal;
-    private readonly closingSignal;
     private onChange;
     private onTouched;
-    private overlayRef;
-    private readonly overlayInstanceSignal;
-    private perOpenSubs;
-    private closeTimer;
+    /**
+     * Watches the host for size changes so `panelWidth="trigger"` keeps tracking
+     * while the panel is up. Minted per open and disconnected on close, because
+     * the `OverlayRef` it feeds is disposed on close (see `openOverlay`).
+     */
     private resizeObserver;
-    private get overlayInstance();
+    private overlayInstance;
+    private closing;
+    /** Flips true once the overlay component is attached; the sole trigger for the state-push effect. */
+    private readonly isAttached;
     /** @internal */
     readonly isDisabled: Signal<boolean>;
     /** @internal Effective variant — auto-naked when wrapped in tw-form-field. */
@@ -275,6 +278,16 @@ declare class SelectComponent<T = unknown> implements ControlValueAccessor, Form
     readonly showClearButton: Signal<boolean>;
     /** @internal */
     readonly activeDescendantId: Signal<string | null>;
+    /**
+     * @internal `aria-activedescendant` for the trigger button.
+     *
+     * Null while a searchable panel is open: `openOverlay()` moves DOM focus to
+     * the overlay's search input, and `aria-activedescendant` is only honoured
+     * on the element that actually holds focus. Leaving it on the blurred
+     * trigger made arrow-key navigation silent to assistive tech. The overlay's
+     * search input carries it instead in that mode.
+     */
+    readonly triggerActiveDescendantId: Signal<string | null>;
     /** @internal */
     readonly describedBy: Signal<string>;
     /** @internal Merged `aria-labelledby`: form-field-pushed label ids + consumer-supplied `aria-labelledby`. */
@@ -295,7 +308,9 @@ declare class SelectComponent<T = unknown> implements ControlValueAccessor, Form
     /** @internal */
     readonly clearButtonClasses: Signal<string>;
     /** @internal */
-    readonly optionSizeClass: Signal<"px-3 py-1.5 text-sm" | "px-2 py-1 text-xs gap-1.5" | "px-3 py-2 text-sm" | "px-4 py-2.5 text-base" | "px-4 py-3 text-base">;
+    readonly clearSpacerClasses: Signal<string>;
+    /** @internal */
+    readonly optionSizeClass: Signal<"px-2 py-1 text-xs gap-1.5" | "px-3 py-1.5 text-sm" | "px-3 py-2 text-sm" | "px-4 py-2.5 text-base" | "px-4 py-3 text-base">;
     /** @internal */
     readonly checkmarkColorClass: Signal<string>;
     /** @internal Class string applied to each option row. */
@@ -308,8 +323,18 @@ declare class SelectComponent<T = unknown> implements ControlValueAccessor, Form
     readonly empty: Signal<boolean>;
     /** @internal */
     readonly disabled: Signal<boolean>;
-    /** @internal */
+    /**
+     * @internal Resolved required state: the `required` input OR'd with
+     * `Validators.required` on a bound `NgControl`. Without the validator arm the
+     * form-field `*` marker (`FormFieldComponent.isRequired`) and the trigger's
+     * `aria-required` silently vanish under reactive/template-driven forms, while
+     * signal forms shows them — `cvaControlCreate` writes the `required` *input*
+     * directly from the field state and never consults validators. The OR keeps
+     * both branches true at once.
+     */
     readonly required: Signal<boolean>;
+    /** @internal Active validation errors map from the bound `NgControl`. Drives `[twError match="…"]` inside a wrapping `tw-form-field`; without it the form-field's key set is permanently empty and every `match`ed error stays hidden. */
+    readonly errors: Signal<Record<string, unknown> | null>;
     /** @internal Error-state per the configured `ErrorStateMatcher`. Reads the bound `NgControl.invalid` through the matcher. */
     readonly errorState: Signal<boolean>;
     /** @internal */
@@ -336,10 +361,38 @@ declare class SelectComponent<T = unknown> implements ControlValueAccessor, Form
     selectByVisibleIndex(index: number, source?: TwSelectSelectionSource): void;
     /** @internal */
     onTriggerClick(): void;
-    /** @internal */
+    /**
+     * @internal
+     *
+     * `stopPropagation` + `preventDefault` are load-bearing even now that the
+     * control is a sibling of the trigger rather than nested inside it: inside a
+     * `tw-form-field` the click still bubbles to the field's control wrapper,
+     * which calls `onContainerClick()` and would open the panel on a clear.
+     */
     onClearClick(event: MouseEvent): void;
-    /** @internal */
+    /**
+     * @internal
+     *
+     * A native `button` already activates on Enter and Space in a browser, so
+     * this looks redundant — it is not. `preventDefault()` here suppresses that
+     * native activation, so the two paths cannot both fire, and jsdom never
+     * synthesises a click from a key event at all, which makes this the only
+     * keyboard path a unit spec can exercise.
+     */
     onClearKeydown(event: KeyboardEvent): void;
+    /**
+     * Clearing removes the clear control from the DOM (`showClearButton()` goes
+     * false), so whatever had focus is destroyed under the user. Hand focus back
+     * to the trigger rather than letting it fall to `<body>` (SC 2.4.3).
+     *
+     * The disabled guard is not redundant. `[disabled]` on a native button makes
+     * `.focus()` a silent no-op (the same trap `calendar-cell` hit), and today
+     * the only reason the path cannot be reached is that `showClearButton()`
+     * happens to include `!isDisabled()`. That is ordering, not a guarantee: a
+     * `setDisabledState(true)` landing between the keydown and this call would
+     * drop focus to `<body>` with nothing to show for it.
+     */
+    private focusTrigger;
     /** @internal */
     onTriggerKeydown(event: KeyboardEvent): void;
     /** @internal Handles keyboard events from the trigger AND the search input inside the overlay. */
@@ -354,15 +407,33 @@ declare class SelectComponent<T = unknown> implements ControlValueAccessor, Form
     initActiveIndexOnOpen(): void;
     private scrollActiveIntoView;
     private commitSelection;
+    /**
+     * Builds and attaches the panel through {@link PickerOverlayCoordinator}.
+     *
+     * The coordinator disposes the `OverlayRef` on close, so every value read
+     * here — `offset`, `scrollStrategy`, `panelClass`, and the position
+     * strategy's origin — is re-read on each open rather than frozen at the
+     * first one. That replaces the previous `refreshPositionConfig()` /
+     * `applyScrollStrategy()` pair, which could only refresh the two inputs it
+     * knew about on a reused ref.
+     *
+     * `focusTrap: false` is load-bearing: this is an `aria-activedescendant`
+     * listbox, so DOM focus stays on the trigger (or the panel's search input)
+     * and a trap's anchor elements would inject tab stops around the panel.
+     */
     private openOverlay;
     private closeOverlay;
-    private ensureOverlay;
     private installResizeObserver;
     private updateOverlaySize;
-    private attachOverlayComponent;
+    /**
+     * Registers the backdrop-click and Escape listeners for one open.
+     *
+     * Both streams come from the coordinator, which completes them when the
+     * overlay closes — so there is no per-open `Subscription` aggregate to keep
+     * and no way for listeners to accumulate across opens.
+     */
     private subscribePerOpen;
     private resolvePanelClass;
-    private clearCloseTimer;
     /** @internal */
     buildTriggerContext(): TwSelectTriggerContext<T>;
     writeValue(value: T | readonly T[] | null): void;

package/types/cdevhub-ngx-tw-sheet-testing.d.ts

@@ -0,0 +1,104 @@
+import { ComponentHarness, BaseHarnessFilters, HarnessPredicate } from '@angular/cdk/testing';
+import { SheetSide } from '@cdevhub/ngx-tw/sheet';
+
+/** Filters accepted by `SheetHarness.with`. */
+interface SheetHarnessFilters extends BaseHarnessFilters {
+    /** Match by the sheet's id — the same value as `SheetRef.id`. */
+    id?: string | RegExp;
+    /** Match by the text of the projected `[twSheetTitle]` element. */
+    title?: string | RegExp;
+    /** Match by the edge the sheet is anchored to. */
+    side?: SheetSide;
+}
+/**
+ * Harness for a sheet opened with `Sheet.open()`.
+ *
+ * ## Loading it
+ *
+ * A sheet is **service-opened**, not template-declared: nothing in the test
+ * fixture's own DOM represents it, and the container renders into the CDK
+ * overlay container on `document.body`. This harness's host *is* that container,
+ * so it must be loaded from
+ * `TestbedHarnessEnvironment.documentRootLoader(fixture)` — the ordinary
+ * `loader(fixture)` searches inside `fixture.nativeElement` and will never find
+ * it. Overlay panels belonging to template-declared components (`tw-select`,
+ * `tw-popover-overlay`, `tw-menu`) are the opposite case: those harnesses host
+ * on the in-fixture trigger and reach their panel internally, so the plain
+ * fixture loader is correct there.
+ *
+ * ## Waiting for it
+ *
+ * `Sheet` loads its render layer through a dynamic `import()`, so the container
+ * does **not** exist synchronously after `open()`. Await the ref's public
+ * {@link SheetRef.whenComponentReady} before asking for the harness — it
+ * resolves once the chunk has landed and the overlay is attached, for template
+ * sheets (with `null`) as well as component sheets.
+ *
+ * @example
+ * ```ts
+ * const ref = sheet.open(FiltersSheet, { side: 'left' });
+ * await ref.whenComponentReady();
+ * const rootLoader = TestbedHarnessEnvironment.documentRootLoader(fixture);
+ * const harness = await rootLoader.getHarness(SheetHarness);
+ * expect(await harness.getSide()).toBe('left');
+ * ```
+ */
+declare class SheetHarness extends ComponentHarness {
+    static hostSelector: string;
+    private readonly title;
+    private readonly content;
+    /** Any descendant of the container that currently holds DOM focus. */
+    private readonly focusedDescendant;
+    /**
+     * Overlay backdrops, which are siblings of the sheet's overlay pane rather
+     * than descendants of the container — hence the document-root lookup.
+     */
+    private readonly backdrops;
+    /** Predicate for `locatorFor` / `locatorForAll`. */
+    static with(options?: SheetHarnessFilters): HarnessPredicate<SheetHarness>;
+    /** The sheet's id. Matches the `id` on the `SheetRef` returned by `open()`. */
+    getId(): Promise<string | null>;
+    /** The sheet's ARIA role — `'dialog'`, or `'alertdialog'` when so configured. */
+    getRole(): Promise<string | null>;
+    /**
+     * The edge the sheet is anchored to, read from the container's `data-side`
+     * attribute. This is the one axis a sheet has that a dialog does not.
+     */
+    getSide(): Promise<SheetSide | null>;
+    /**
+     * Text of the projected `[twSheetTitle]` element, trimmed, or `null` when the
+     * sheet's content does not use the title directive.
+     */
+    getTitleText(): Promise<string | null>;
+    /**
+     * Text of the projected `[twSheetContent]` region, trimmed, or `null` when
+     * the sheet's content does not use the content directive.
+     */
+    getContentText(): Promise<string | null>;
+    /**
+     * Whether DOM focus currently sits on the sheet container or anywhere inside
+     * it — the observable consequence of the CDK focus trap. CDK moves focus
+     * asynchronously, so let the fixture settle after opening before asserting.
+     */
+    containsFocus(): Promise<boolean>;
+    /** Whether the sheet rendered a backdrop. */
+    hasBackdrop(): Promise<boolean>;
+    /**
+     * Clicks the backdrop — the pointer dismiss gesture. Does nothing observable
+     * when the sheet was opened with `disableClose: true` or
+     * `closeOnBackdropClick: false`, which is how a test asserts those flags.
+     *
+     * Throws when no backdrop is rendered. With several overlays stacked, the
+     * last backdrop in the overlay container is used, i.e. the topmost one.
+     */
+    clickBackdrop(): Promise<void>;
+    /**
+     * Sends Escape to the sheet — the keyboard dismiss gesture. Deliberately a
+     * no-op when the sheet was opened with `disableClose: true` or
+     * `closeOnEscape: false`.
+     */
+    pressEscape(): Promise<void>;
+}
+
+export { SheetHarness };
+export type { SheetHarnessFilters };