@cdevhub/ngx-tw 0.5.0 → 0.6.1

package/types/cdevhub-ngx-tw-progress-bar.d.ts

@@ -42,7 +42,7 @@ interface ProgressBarOptions {
  * ```
  */
 declare class ProgressBarComponent {
-    /** Current progress value. When null or undefined, the bar renders indeterminate. Values outside `[options.min, options.max]` are clamped. */
+    /** Current progress value. When null or undefined, the bar renders indeterminate. Values outside `[options.min, options.max]` are clamped. Defaults to `null`. */
     readonly value: _angular_core.InputSignal<number | null | undefined>;
     /** Visual style of the bar. `'linear'` renders a single fill; `'segmented'` splits the rail into discrete steps. Defaults to `'linear'`. */
     readonly variant: _angular_core.InputSignal<ProgressBarVariant>;

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

@@ -10,7 +10,7 @@ type RadioOrientation = 'horizontal' | 'vertical';
 /** Position of the label relative to the radio control. */
 type RadioLabelPosition = 'before' | 'after';
 declare class RadioComponent implements ControlValueAccessor, OnInit {
-    /** The value this radio contributes when selected inside a `tw-radio-group`. Required when nested in a group; ignored when used standalone. */
+    /** The value this radio contributes when selected inside a `tw-radio-group`. Required when nested in a group; ignored when used standalone. Defaults to `undefined`. */
     readonly value: _angular_core.InputSignal<unknown>;
     /** Overrides the parent group's color for this radio. When undefined, inherits from the group (or defaults to `'primary'` standalone). */
     readonly color: _angular_core.InputSignal<TwColor | undefined>;
@@ -28,31 +28,51 @@ declare class RadioComponent implements ControlValueAccessor, OnInit {
     readonly labelPosition: _angular_core.InputSignal<RadioLabelPosition>;
     /** Optional name attribute for standalone use. Ignored when the parent group provides a name. */
     readonly name: _angular_core.InputSignal<string | undefined>;
-    /** Accessible name when no visible label is provided. Mirrored to `aria-label`. */
+    /** Accessible name when no visible label is provided. Mirrored to `aria-label`. Defaults to `undefined`. */
     readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
-    /** ID of an external element that labels the radio. Mirrored to `aria-labelledby`. */
+    /** ID of an external element that labels the radio. Mirrored to `aria-labelledby`. Defaults to `undefined`. */
     readonly ariaLabelledby: _angular_core.InputSignal<string | undefined>;
-    /** ID of an external element that describes the radio. Mirrored to `aria-describedby`. */
+    /** ID of an external element that describes the radio. Mirrored to `aria-describedby`. Defaults to `undefined`. */
     readonly ariaDescribedby: _angular_core.InputSignal<string | undefined>;
-    /** Two-way bound checked state. Authoritative only in standalone mode; when inside a `tw-radio-group`, this model reflects group selection but does NOT drive it. */
+    /**
+     * Two-way bound checked state. Authoritative only in standalone mode.
+     * Defaults to `false`.
+     *
+     * Standalone, the minted `checkedChange` output is the *any-change* channel:
+     * it fires both when the user selects this radio and when a bound form writes
+     * into it (`FormControl.setValue`, `ngModel`, `writeValue`). `(change)` is the
+     * *user-gesture-only* channel — bind that one for analytics or a confirmation
+     * prompt, where a programmatic write must not count as a click.
+     *
+     * Inside a `tw-radio-group` this model is inert: the group owns selection,
+     * the rendered state comes from the group's `value`, and the component never
+     * writes `checked` — so `(checkedChange)` never fires on a grouped radio.
+     * `(change)` still fires when this radio becomes the selected one. Bind the
+     * group's `[(value)]` / `(change)` instead.
+     */
     readonly checked: _angular_core.ModelSignal<boolean>;
     /** Per-instance override of the {@link ErrorStateMatcher}. When omitted, the radio uses the `TW_ERROR_STATE_MATCHER` token's value. */
     readonly errorStateMatcher: _angular_core.InputSignal<ErrorStateMatcher | undefined>;
-    /** Fires after the checked state changes from a user interaction on this radio. In grouped mode only fires when this radio becomes the selected one. Does not fire when selection is updated programmatically. */
+    /**
+     * Fires after the checked state changes from a user interaction on this
+     * radio. In grouped mode only fires when this radio becomes the selected one.
+     * Does **not** fire when selection is updated programmatically via
+     * `writeValue` / `FormControl.setValue` / `ngModel` — standalone, bind the
+     * two-way binding's `(checkedChange)` for that, which fires on any change.
+     * (Grouped, `(checkedChange)` never fires at all; use the group's
+     * `[(value)]`.)
+     */
     readonly change: _angular_core.OutputEmitterRef<boolean>;
     private readonly focusMonitor;
     readonly elementRef: ElementRef<any>;
     private readonly destroyRef;
     private readonly parent;
     private readonly ngControl;
-    private readonly parentForm;
-    private readonly parentFormGroup;
-    private readonly defaultMatcher;
     private onChange;
     private onTouched;
     private readonly cvaDisabled;
-    private readonly _ngControlRev;
-    private readonly _formSubmitRev;
+    /** @internal Shared `errorState` derivation — see `wireErrorState`. */
+    private readonly errorWiring;
     private readonly uid;
     readonly hostId: string;
     readonly labelId: string;
@@ -110,25 +130,52 @@ declare class RadioGroupComponent<T = unknown> implements ControlValueAccessor,
     readonly size: _angular_core.InputSignal<TwSize>;
     /** Visual style of the selected indicator. `'solid'` fills the dot with the color against a colored ring; `'outline'` keeps a transparent fill with a colored ring and colored dot. Propagated to children unless a child overrides it. Defaults to `'solid'`. */
     readonly variant: _angular_core.InputSignal<RadioVariant>;
-    /** Layout direction of the group. Drives `aria-orientation` and the arrow-key model. Defaults to `'vertical'`. */
+    /** Layout direction of the group. Sets `aria-orientation` and the visual axis; both arrow-key pairs navigate in either orientation, per WAI-ARIA APG. Defaults to `'vertical'`. */
     readonly orientation: _angular_core.InputSignal<RadioOrientation>;
     /** When true, disables every radio in the group and blocks keyboard interaction. Defaults to `false`. */
     readonly disabled: _angular_core.InputSignal<boolean>;
-    /** When true, sets `aria-required="true"` on the group for assistive tech. Defaults to `false`. */
-    readonly required: _angular_core.InputSignal<boolean>;
+    /** When true, sets `aria-required="true"` on the group for assistive tech. 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>;
+    /**
+     * @internal Shared `errorState` / `required` / `errors` derivation — see
+     * `wireErrorState`. Declared here, above `required`, because class field
+     * initializers run in declaration order.
+     */
+    private readonly errorWiring;
+    /**
+     * @internal Resolved required state: the `required` input OR'd with
+     * `Validators.required` on a bound `NgControl`.
+     */
+    readonly required: Signal<boolean>;
     /** Optional form-association name. Propagated to each child radio's host `name` attribute so standard HTML form semantics still apply. */
     readonly name: _angular_core.InputSignal<string | undefined>;
-    /** Accessible name for the group when no visible label is provided. Mirrored to `aria-label`. */
+    /** Accessible name for the group when no visible label is provided. Mirrored to `aria-label`. Defaults to `undefined`. */
     readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
-    /** ID of an external element that labels the group. Mirrored to `aria-labelledby`. */
+    /** ID of an external element that labels the group. Mirrored to `aria-labelledby`. Defaults to `undefined`. */
     readonly ariaLabelledby: _angular_core.InputSignal<string | undefined>;
-    /** ID of an external element that describes the group. Mirrored to `aria-describedby`. */
+    /** ID of an external element that describes the group. Mirrored to `aria-describedby`. Defaults to `undefined`. */
     readonly ariaDescribedby: _angular_core.InputSignal<string | undefined>;
-    /** Two-way bound selected value. Updates when the user picks a radio; fires `valueChange`. `null` means no selection. */
+    /**
+     * Two-way bound selected value. `null` means no selection. Defaults to
+     * `null`.
+     *
+     * The two-way binding mints a `valueChange` output. That output is the
+     * *any-change* channel: it fires when the user picks a radio **and** when a
+     * bound form writes into the group (`FormControl.setValue`, `ngModel`,
+     * `writeValue`). `(change)` is the *user-gesture-only* channel — bind that
+     * one for analytics or a confirmation prompt, where a programmatic write must
+     * not count as a click. Writing back into the same form from a
+     * `(valueChange)` handler will echo.
+     */
     readonly value: _angular_core.ModelSignal<T | null>;
     /** Per-instance override of the {@link ErrorStateMatcher}. When omitted, the group uses the `TW_ERROR_STATE_MATCHER` token's value. */
     readonly errorStateMatcher: _angular_core.InputSignal<ErrorStateMatcher | undefined>;
-    /** Fires after the selected value changes from a user interaction. Does not fire when the value is updated programmatically via `writeValue`. */
+    /**
+     * Fires after the selected value changes from a user interaction. Does
+     * **not** fire when the value is updated programmatically via `writeValue` /
+     * `FormControl.setValue` / `ngModel` — for those, bind the two-way binding's
+     * `(valueChange)` instead, which fires on any change.
+     */
     readonly change: _angular_core.OutputEmitterRef<T | null>;
     /** @internal Child radios discovered via content projection. */
     readonly radios: Signal<readonly RadioComponent[]>;
@@ -136,15 +183,10 @@ declare class RadioGroupComponent<T = unknown> implements ControlValueAccessor,
     private readonly elementRef;
     private readonly destroyRef;
     private readonly ngControl;
-    private readonly parentForm;
-    private readonly parentFormGroup;
-    private readonly defaultMatcher;
     readonly hostId: string;
     private onChange;
     private onTouched;
     private readonly cvaDisabled;
-    private readonly _ngControlRev;
-    private readonly _formSubmitRev;
     /** Effective disabled state — input OR CVA disabled. */
     readonly isDisabled: Signal<boolean>;
     /** Group-level error state per the configured `ErrorStateMatcher`. Reads the bound `NgControl.invalid` through the matcher; child radios inherit from this when wrapped in the group. */
@@ -157,6 +199,7 @@ declare class RadioGroupComponent<T = unknown> implements ControlValueAccessor,
     selectValue(next: unknown): void;
     /** @internal Called by child radios on blur — propagates to CVA onTouched and bumps the errorState revision so a blur on a child radio refreshes the group's `aria-invalid`. */
     notifyTouched(): void;
+    /** @internal Handles roving-focus keyboard navigation (Arrow keys, Space) across the radios in the group. */
     onKeydown(event: KeyboardEvent): void;
     private findNextEnabledIndex;
     private firstEnabledIndex;
@@ -167,7 +210,7 @@ declare class RadioGroupComponent<T = unknown> implements ControlValueAccessor,
     setDisabledState(isDisabled: boolean): void;
     ngOnInit(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RadioGroupComponent<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RadioGroupComponent<any>, "tw-radio-group", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "ariaDescribedby": { "alias": "aria-describedby"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "change": "change"; }, ["radios"], ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RadioGroupComponent<any>, "tw-radio-group", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "requiredInput": { "alias": "required"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "ariaDescribedby": { "alias": "aria-describedby"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "change": "change"; }, ["radios"], ["*"], true, never>;
 }
 
 export { RadioComponent, RadioGroupComponent };

package/types/cdevhub-ngx-tw-segmented-control.d.ts

@@ -1,10 +1,19 @@
 import * as _angular_core from '@angular/core';
-import { ElementRef } from '@angular/core';
+import { OnInit, Signal, ElementRef } from '@angular/core';
 import { ControlValueAccessor } from '@angular/forms';
-import { TwColor, TwSize, TwOrientation } from '@cdevhub/ngx-tw/core';
+import { TwColor, TwSize, TwOrientation, ErrorStateMatcher } from '@cdevhub/ngx-tw/core';
 
 /** Visual style of the active indicator. */
-type SegmentedControlVariant = 'surface' | 'filled' | 'outline';
+type SegmentedControlVariant = 'surface' | 'solid' | 'outline' | SegmentedControlVariantLegacy;
+/**
+ * Legacy `variant` spellings, kept so existing templates keep compiling.
+ *
+ * @deprecated `'filled'` is an alias for `'solid'`; it will be removed in the next
+ * major. Prefer `'solid'`.
+ */
+type SegmentedControlVariantLegacy = 'filled';
+/** Canonical `variant` spellings — the set `tv()` actually keys on. */
+type SegmentedControlVariantCanonical = Exclude<SegmentedControlVariant, SegmentedControlVariantLegacy>;
 /** Border-radius shape of the container and options. */
 type SegmentedControlRounded = 'pill' | 'md';
 declare class SegmentedControlOptionComponent {
@@ -16,17 +25,19 @@ declare class SegmentedControlOptionComponent {
     private readonly parent;
     readonly id: string;
     constructor();
-    readonly isActive: _angular_core.Signal<boolean>;
-    readonly isDisabled: _angular_core.Signal<boolean>;
-    readonly isFocusable: _angular_core.Signal<boolean>;
-    readonly classes: _angular_core.Signal<string>;
+    readonly isActive: Signal<boolean>;
+    readonly isDisabled: Signal<boolean>;
+    readonly isFocusable: Signal<boolean>;
+    readonly classes: Signal<string>;
+    /** Selects this option in the parent segmented control. No-op when the option is disabled. */
     select(): void;
+    /** Moves DOM focus to this option's element. Called by the parent group's arrow-key handler, which moves focus and selection together (selection-follows-focus, as WAI-ARIA APG specifies for a radiogroup). */
     focus(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SegmentedControlOptionComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<SegmentedControlOptionComponent, "tw-segmented-option", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
-declare class SegmentedControlComponent implements ControlValueAccessor {
-    /** Controls the active indicator style. `'surface'` shows a raised white pill; `'filled'` shows a solid colored background; `'outline'` shows a colored ring border. Defaults to `'surface'`. */
+declare class SegmentedControlComponent implements ControlValueAccessor, OnInit {
+    /** Controls the active indicator style. `'surface'` shows a raised white pill; `'solid'` shows a solid colored background; `'outline'` shows a colored ring border. Defaults to `'surface'`. `'filled'` is a deprecated alias for `'solid'`. */
     readonly variant: _angular_core.InputSignal<SegmentedControlVariant>;
     /** Sets the semantic color for the active option indicator. Defaults to `'primary'`. */
     readonly color: _angular_core.InputSignal<TwColor>;
@@ -38,29 +49,81 @@ declare class SegmentedControlComponent implements ControlValueAccessor {
     readonly rounded: _angular_core.InputSignal<SegmentedControlRounded>;
     /** When true, prevents all interaction and applies muted styling. Defaults to `false`. */
     readonly disabled: _angular_core.InputSignal<boolean>;
-    /** The value of the currently selected option. Two-way bound. Updates on user selection. */
+    /** When true, sets `aria-required="true"` on the radiogroup so assistive tech announces a choice is mandatory. 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>;
+    /** Per-instance override of the {@link ErrorStateMatcher}. When omitted, the control uses the `TW_ERROR_STATE_MATCHER` token's value. */
+    readonly errorStateMatcher: _angular_core.InputSignal<ErrorStateMatcher | undefined>;
+    /**
+     * The value of the currently selected option. Two-way bound. Defaults to
+     * `null`.
+     *
+     * The two-way binding mints a `valueChange` output, and it is the
+     * *any-change* channel: it fires on user selection **and** on a programmatic
+     * write from a bound form (`FormControl.setValue`, `ngModel`, `writeValue`).
+     * Unlike `tw-checkbox` / `tw-switch` / `tw-radio-group`, this control ships no
+     * separate gesture-only `change` output, so writing back into the same form
+     * from a `(valueChange)` handler will echo. To act on user selection alone,
+     * compare against the value you last wrote, or listen on the form control.
+     */
     readonly value: _angular_core.ModelSignal<string | null>;
     /** @internal */
-    readonly options: _angular_core.Signal<readonly SegmentedControlOptionComponent[]>;
+    readonly options: Signal<readonly SegmentedControlOptionComponent[]>;
+    private readonly elementRef;
+    private readonly ngControl;
+    /**
+     * Optional so a consumer that never imports `BidiModule` still gets a working
+     * control — arrow navigation falls back to LTR when the token is absent. Read
+     * imperatively inside the keydown handler; nothing here needs to re-render on
+     * a direction change.
+     */
+    private readonly directionality;
     private onChange;
     private onTouched;
     private readonly cvaDisabled;
-    readonly isDisabled: _angular_core.Signal<boolean>;
+    /** @internal Shared `errorState` / `required` / `errors` derivation — see `wireErrorState`. */
+    private readonly errorWiring;
+    constructor();
+    readonly isDisabled: Signal<boolean>;
+    /**
+     * @internal Resolved required state: the `required` input OR'd with
+     * `Validators.required` on a bound `NgControl`. The OR (rather than a
+     * validator-only read) is what keeps signal forms working — `cvaControlCreate`
+     * writes the `required` *input* directly from the field state and never
+     * consults validators, so the input arm carries that branch while the
+     * validator arm carries reactive/template-driven forms.
+     */
+    readonly required: Signal<boolean>;
+    /** @internal Whether the control is in an error state per the configured `ErrorStateMatcher`. Reads the bound `NgControl.invalid` through the matcher and drives `aria-invalid` on the radiogroup host. */
+    readonly errorState: Signal<boolean>;
     readonly activeValue: _angular_core.WritableSignal<string | null>;
     /** @internal Read by `SegmentedControlOptionComponent.classes` to resolve the option's tv() bucket. Vertical orientation forces `'md'` regardless of input. */
-    readonly effectiveRounded: _angular_core.Signal<SegmentedControlRounded>;
+    readonly effectiveRounded: Signal<SegmentedControlRounded>;
+    /** @internal Canonical variant with legacy spellings folded in. Read by `SegmentedControlOptionComponent.classes` to resolve the option's tv() bucket. */
+    readonly resolvedVariant: Signal<SegmentedControlVariantCanonical>;
     private readonly variantResult;
-    readonly rootClasses: _angular_core.Signal<string>;
+    readonly rootClasses: Signal<string>;
+    /** Selects the option with the given value, updating the two-way bound `value` and notifying the registered `ControlValueAccessor` callbacks. No-op when the control is disabled. */
     selectOption(val: string): void;
+    /**
+     * @internal Blur notification for the CVA contract. Fires `onTouched` only
+     * when focus leaves the radiogroup entirely — roving focus moves between
+     * option elements inside the group, and each of those hops raises `focusout`
+     * on the host too. Without this the control is only ever marked `touched` by
+     * a selection, so a user who tabs through without choosing never surfaces the
+     * `required` error.
+     */
+    onFocusOut(event: FocusEvent): void;
+    /** @internal Handles roving-focus keyboard navigation (Arrow keys, Home, End) and Space / Enter activation across the option group. */
     onKeydown(event: KeyboardEvent): void;
     private findNextEnabledIndex;
     writeValue(val: string | null): void;
     registerOnChange(fn: (value: string | null) => void): void;
     registerOnTouched(fn: () => void): void;
     setDisabledState(isDisabled: boolean): void;
+    ngOnInit(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SegmentedControlComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SegmentedControlComponent, "tw-segmented-control", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["options"], ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SegmentedControlComponent, "tw-segmented-control", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "requiredInput": { "alias": "required"; "required": false; "isSignal": true; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["options"], ["*"], true, never>;
 }
 
 export { SegmentedControlComponent, SegmentedControlOptionComponent };
-export type { SegmentedControlRounded, SegmentedControlVariant };
+export type { SegmentedControlRounded, SegmentedControlVariant, SegmentedControlVariantLegacy };

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 };