@depup/angular__material 21.2.2-depup.19

package/types/input.d.ts

@@ -0,0 +1,208 @@
+import { BooleanInput } from '@angular/cdk/coercion';
+import { Platform } from '@angular/cdk/platform';
+import * as i0 from '@angular/core';
+import { InjectionToken, OnChanges, OnDestroy, AfterViewInit, DoCheck, ElementRef, WritableSignal } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import { Subject } from 'rxjs';
+import { ErrorStateMatcher } from './_error-options-chunk.js';
+import { MatFormField } from './_form-field-chunk.js';
+export { MatError, MatHint, MatPrefix, MatSuffix } from './_form-field-chunk.js';
+import { MatFormFieldControl } from './_form-field-control-chunk.js';
+import { MatFormFieldModule } from './_form-field-module-chunk.js';
+export { MatLabel } from './_form-field-module-chunk.js';
+import * as i3 from '@angular/cdk/text-field';
+import * as i2 from '@angular/cdk/bidi';
+import './_palette-chunk.js';
+import '@angular/cdk/observers';
+
+/** Object that can be used to configure the default options for the input. */
+interface MatInputConfig {
+    /** Whether disabled inputs should be interactive. */
+    disabledInteractive?: boolean;
+}
+/** Injection token that can be used to provide the default options for the input. */
+declare const MAT_INPUT_CONFIG: InjectionToken<MatInputConfig>;
+declare class MatInput implements MatFormFieldControl<any>, OnChanges, OnDestroy, AfterViewInit, DoCheck {
+    protected _elementRef: ElementRef<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement>;
+    protected _platform: Platform;
+    ngControl: NgControl;
+    private _autofillMonitor;
+    private _ngZone;
+    protected _formField?: MatFormField | null | undefined;
+    private _renderer;
+    protected _uid: string;
+    protected _previousNativeValue: any;
+    private _inputValueAccessor;
+    private _signalBasedValueAccessor?;
+    private _previousPlaceholder;
+    private _errorStateTracker;
+    private _config;
+    private _cleanupIosKeyup;
+    private _cleanupWebkitWheel;
+    /** Whether the component is being rendered on the server. */
+    readonly _isServer: boolean;
+    /** Whether the component is a native html select. */
+    readonly _isNativeSelect: boolean;
+    /** Whether the component is a textarea. */
+    readonly _isTextarea: boolean;
+    /** Whether the input is inside of a form field. */
+    readonly _isInFormField: boolean;
+    /**
+     * Implemented as part of MatFormFieldControl.
+     * @docs-private
+     */
+    focused: boolean;
+    /**
+     * Implemented as part of MatFormFieldControl.
+     * @docs-private
+     */
+    readonly stateChanges: Subject<void>;
+    /**
+     * Implemented as part of MatFormFieldControl.
+     * @docs-private
+     */
+    controlType: string;
+    /**
+     * Implemented as part of MatFormFieldControl.
+     * @docs-private
+     */
+    autofilled: boolean;
+    /**
+     * Implemented as part of MatFormFieldControl.
+     * @docs-private
+     */
+    get disabled(): boolean;
+    set disabled(value: BooleanInput);
+    protected _disabled: boolean;
+    /**
+     * Implemented as part of MatFormFieldControl.
+     * @docs-private
+     */
+    get id(): string;
+    set id(value: string);
+    protected _id: string;
+    /**
+     * Implemented as part of MatFormFieldControl.
+     * @docs-private
+     */
+    placeholder: string;
+    /**
+     * Name of the input.
+     * @docs-private
+     */
+    name: string;
+    /**
+     * Implemented as part of MatFormFieldControl.
+     * @docs-private
+     */
+    get required(): boolean;
+    set required(value: BooleanInput);
+    protected _required: boolean | undefined;
+    /** Input type of the element. */
+    get type(): string;
+    set type(value: string);
+    protected _type: string;
+    /** An object used to control when error messages are shown. */
+    get errorStateMatcher(): ErrorStateMatcher;
+    set errorStateMatcher(value: ErrorStateMatcher);
+    /**
+     * Implemented as part of MatFormFieldControl.
+     * @docs-private
+     */
+    userAriaDescribedBy: string;
+    /**
+     * Implemented as part of MatFormFieldControl.
+     * @docs-private
+     */
+    get value(): string;
+    set value(value: any);
+    /** Whether the element is readonly. */
+    get readonly(): boolean;
+    set readonly(value: BooleanInput);
+    private _readonly;
+    /** Whether the input should remain interactive when it is disabled. */
+    disabledInteractive: boolean;
+    /** Whether the input is in an error state. */
+    get errorState(): boolean;
+    set errorState(value: boolean);
+    protected _neverEmptyInputTypes: string[];
+    constructor(...args: unknown[]);
+    ngAfterViewInit(): void;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    ngDoCheck(): void;
+    /** Focuses the input. */
+    focus(options?: FocusOptions): void;
+    /** Refreshes the error state of the input. */
+    updateErrorState(): void;
+    /** Callback for the cases where the focused state of the input changes. */
+    _focusChanged(isFocused: boolean): void;
+    _onInput(): void;
+    /** Does some manual dirty checking on the native input `value` property. */
+    protected _dirtyCheckNativeValue(): void;
+    /** Does some manual dirty checking on the native input `placeholder` attribute. */
+    private _dirtyCheckPlaceholder;
+    /** Gets the current placeholder of the form field. */
+    protected _getPlaceholder(): string | null;
+    /** Make sure the input is a supported type. */
+    protected _validateType(): void;
+    /** Checks whether the input type is one of the types that are never empty. */
+    protected _isNeverEmpty(): boolean;
+    /** Checks whether the input is invalid based on the native validation. */
+    protected _isBadInput(): boolean;
+    /**
+     * Implemented as part of MatFormFieldControl.
+     * @docs-private
+     */
+    get empty(): boolean;
+    /**
+     * Implemented as part of MatFormFieldControl.
+     * @docs-private
+     */
+    get shouldLabelFloat(): boolean;
+    /**
+     * Implemented as part of MatFormFieldControl.
+     * @docs-private
+     */
+    get describedByIds(): string[];
+    /**
+     * Implemented as part of MatFormFieldControl.
+     * @docs-private
+     */
+    setDescribedByIds(ids: string[]): void;
+    /**
+     * Implemented as part of MatFormFieldControl.
+     * @docs-private
+     */
+    onContainerClick(): void;
+    /** Whether the form control is a native select that is displayed inline. */
+    _isInlineSelect(): boolean;
+    private _iOSKeyupListener;
+    /** Gets the value to set on the `readonly` attribute. */
+    protected _getReadonlyAttribute(): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatInput, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatInput, "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", ["matInput"], { "disabled": { "alias": "disabled"; "required": false; }; "id": { "alias": "id"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "name": { "alias": "name"; "required": false; }; "required": { "alias": "required"; "required": false; }; "type": { "alias": "type"; "required": false; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; }; "userAriaDescribedBy": { "alias": "aria-describedby"; "required": false; }; "value": { "alias": "value"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "disabledInteractive": { "alias": "disabledInteractive"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_disabledInteractive: unknown;
+}
+
+declare class MatInputModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatInputModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatInputModule, never, [typeof MatFormFieldModule, typeof MatInput], [typeof MatInput, typeof MatFormFieldModule, typeof i3.TextFieldModule, typeof i2.BidiModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatInputModule>;
+}
+
+/**
+ * This token is used to inject the object whose value should be set into `MatInput`. If none is
+ * provided, the native `HTMLInputElement` is used. Directives like `MatDatepickerInput` can provide
+ * themselves for this token, in order to make `MatInput` delegate the getting and setting of the
+ * value to them.
+ */
+declare const MAT_INPUT_VALUE_ACCESSOR: InjectionToken<{
+    value: any | WritableSignal<any>;
+}>;
+
+/** @docs-private */
+declare function getMatInputUnsupportedTypeError(type: string): Error;
+
+export { MAT_INPUT_CONFIG, MAT_INPUT_VALUE_ACCESSOR, MatFormField, MatInput, MatInputModule, getMatInputUnsupportedTypeError };
+export type { MatInputConfig };

package/types/list-testing.d.ts

@@ -0,0 +1,354 @@
+import { BaseHarnessFilters, ComponentHarness, HarnessPredicate, ContentContainerComponentHarness, ComponentHarnessConstructor } from '@angular/cdk/testing';
+import { DividerHarnessFilters, MatDividerHarness } from './divider-testing.js';
+import { MatListOptionTogglePosition } from './_list-option-types-chunk.js';
+
+interface ListHarnessFilters extends BaseHarnessFilters {
+}
+interface ActionListHarnessFilters extends BaseHarnessFilters {
+}
+interface NavListHarnessFilters extends BaseHarnessFilters {
+}
+interface SelectionListHarnessFilters extends BaseHarnessFilters {
+}
+interface BaseListItemHarnessFilters extends BaseHarnessFilters {
+    title?: string | RegExp;
+    secondaryText?: string | RegExp | null;
+    tertiaryText?: string | RegExp | null;
+    fullText?: string | RegExp;
+    /**
+     * @deprecated Use the `fullText` filter instead.
+     * @breaking-change 16.0.0
+     */
+    text?: string | RegExp;
+}
+interface ListItemHarnessFilters extends BaseListItemHarnessFilters {
+}
+interface ActionListItemHarnessFilters extends BaseListItemHarnessFilters {
+}
+interface NavListItemHarnessFilters extends BaseListItemHarnessFilters {
+    href?: string | RegExp | null;
+    activated?: boolean;
+}
+interface ListOptionHarnessFilters extends BaseListItemHarnessFilters {
+    selected?: boolean;
+}
+interface SubheaderHarnessFilters extends BaseHarnessFilters {
+    text?: string | RegExp;
+}
+
+/** Harness for interacting with a list subheader. */
+declare class MatSubheaderHarness extends ComponentHarness {
+    static hostSelector: string;
+    static with(options?: SubheaderHarnessFilters): HarnessPredicate<MatSubheaderHarness>;
+    /** Gets the full text content of the list item (including text from any font icons). */
+    getText(): Promise<string>;
+}
+/** Selectors for the various list item sections that may contain user content. */
+declare enum MatListItemSection {
+    CONTENT = ".mdc-list-item__content"
+}
+/** Enum describing the possible variants of a list item. */
+declare enum MatListItemType {
+    ONE_LINE_ITEM = 0,
+    TWO_LINE_ITEM = 1,
+    THREE_LINE_ITEM = 2
+}
+/**
+ * Shared behavior among the harnesses for the various `MatListItem` flavors.
+ * @docs-private
+ */
+declare abstract class MatListItemHarnessBase extends ContentContainerComponentHarness<MatListItemSection> {
+    private _lines;
+    private _primaryText;
+    private _avatar;
+    private _icon;
+    private _unscopedTextContent;
+    /** Gets the type of the list item, currently describing how many lines there are. */
+    getType(): Promise<MatListItemType>;
+    /**
+     * Gets the full text content of the list item, excluding text
+     * from icons and avatars.
+     *
+     * @deprecated Use the `getFullText` method instead.
+     * @breaking-change 16.0.0
+     */
+    getText(): Promise<string>;
+    /**
+     * Gets the full text content of the list item, excluding text
+     * from icons and avatars.
+     */
+    getFullText(): Promise<string>;
+    /** Gets the title of the list item. */
+    getTitle(): Promise<string>;
+    /** Whether the list item is disabled. */
+    isDisabled(): Promise<boolean>;
+    /**
+     * Gets the secondary line text of the list item. Null if the list item
+     * does not have a secondary line.
+     */
+    getSecondaryText(): Promise<string | null>;
+    /**
+     * Gets the tertiary line text of the list item. Null if the list item
+     * does not have a tertiary line.
+     */
+    getTertiaryText(): Promise<string | null>;
+    /** Whether this list item has an avatar. */
+    hasAvatar(): Promise<boolean>;
+    /** Whether this list item has an icon. */
+    hasIcon(): Promise<boolean>;
+}
+
+/** Represents a section of a list falling under a specific header. */
+interface ListSection<I> {
+    /** The heading for this list section. `undefined` if there is no heading. */
+    heading?: string;
+    /** The items in this list section. */
+    items: I[];
+}
+/**
+ * Shared behavior among the harnesses for the various `MatList` flavors.
+ * @template T A constructor type for a list item harness type used by this list harness.
+ * @template C The list item harness type that `T` constructs.
+ * @template F The filter type used filter list item harness of type `C`.
+ * @docs-private
+ */
+declare abstract class MatListHarnessBase<T extends ComponentHarnessConstructor<C> & {
+    with: (options?: F) => HarnessPredicate<C>;
+}, C extends ComponentHarness, F extends BaseListItemHarnessFilters> extends ComponentHarness {
+    protected _itemHarness: T;
+    /**
+     * Gets a list of harnesses representing the items in this list.
+     * @param filters Optional filters used to narrow which harnesses are included
+     * @return The list of items matching the given filters.
+     */
+    getItems(filters?: F): Promise<C[]>;
+    /**
+     * Gets a list of `ListSection` representing the list items grouped by subheaders. If the list has
+     * no subheaders it is represented as a single `ListSection` with an undefined `heading` property.
+     * @param filters Optional filters used to narrow which list item harnesses are included
+     * @return The list of items matching the given filters, grouped into sections by subheader.
+     */
+    getItemsGroupedBySubheader(filters?: F): Promise<ListSection<C>[]>;
+    /**
+     * Gets a list of sub-lists representing the list items grouped by dividers. If the list has no
+     * dividers it is represented as a list with a single sub-list.
+     * @param filters Optional filters used to narrow which list item harnesses are included
+     * @return The list of items matching the given filters, grouped into sub-lists by divider.
+     */
+    getItemsGroupedByDividers(filters?: F): Promise<C[][]>;
+    /**
+     * Gets a list of harnesses representing all of the items, subheaders, and dividers
+     * (in the order they appear in the list). Use `instanceof` to check which type of harness a given
+     * item is.
+     * @param filters Optional filters used to narrow which list items, subheaders, and dividers are
+     *     included. A value of `false` for the `item`, `subheader`, or `divider` properties indicates
+     *     that the respective harness type should be omitted completely.
+     * @return The list of harnesses representing the items, subheaders, and dividers matching the
+     *     given filters.
+     */
+    getItemsWithSubheadersAndDividers(filters: {
+        item: false;
+        subheader: false;
+        divider: false;
+    }): Promise<[]>;
+    getItemsWithSubheadersAndDividers(filters: {
+        item?: F | false;
+        subheader: false;
+        divider: false;
+    }): Promise<C[]>;
+    getItemsWithSubheadersAndDividers(filters: {
+        item: false;
+        subheader?: SubheaderHarnessFilters | false;
+        divider: false;
+    }): Promise<MatSubheaderHarness[]>;
+    getItemsWithSubheadersAndDividers(filters: {
+        item: false;
+        subheader: false;
+        divider?: DividerHarnessFilters | false;
+    }): Promise<MatDividerHarness[]>;
+    getItemsWithSubheadersAndDividers(filters: {
+        item?: F | false;
+        subheader?: SubheaderHarnessFilters | false;
+        divider: false;
+    }): Promise<(C | MatSubheaderHarness)[]>;
+    getItemsWithSubheadersAndDividers(filters: {
+        item?: F | false;
+        subheader: false;
+        divider?: false | DividerHarnessFilters;
+    }): Promise<(C | MatDividerHarness)[]>;
+    getItemsWithSubheadersAndDividers(filters: {
+        item: false;
+        subheader?: false | SubheaderHarnessFilters;
+        divider?: false | DividerHarnessFilters;
+    }): Promise<(MatSubheaderHarness | MatDividerHarness)[]>;
+    getItemsWithSubheadersAndDividers(filters?: {
+        item?: F | false;
+        subheader?: SubheaderHarnessFilters | false;
+        divider?: DividerHarnessFilters | false;
+    }): Promise<(C | MatSubheaderHarness | MatDividerHarness)[]>;
+}
+
+/** Harness for interacting with a action-list in tests. */
+declare class MatActionListHarness extends MatListHarnessBase<typeof MatActionListItemHarness, MatActionListItemHarness, ActionListItemHarnessFilters> {
+    /** The selector for the host element of a `MatActionList` instance. */
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for an action list with specific
+     * attributes.
+     * @param options Options for filtering which action list instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with<T extends MatActionListHarness>(this: ComponentHarnessConstructor<T>, options?: ActionListHarnessFilters): HarnessPredicate<T>;
+    _itemHarness: typeof MatActionListItemHarness;
+}
+/** Harness for interacting with an action list item. */
+declare class MatActionListItemHarness extends MatListItemHarnessBase {
+    /** The selector for the host element of a `MatListItem` instance. */
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a list item with specific
+     * attributes.
+     * @param options Options for filtering which action list item instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with<T extends MatActionListItemHarness>(this: ComponentHarnessConstructor<T>, options?: ActionListItemHarnessFilters): HarnessPredicate<T>;
+    /** Clicks on the action list item. */
+    click(): Promise<void>;
+    /** Focuses the action list item. */
+    focus(): Promise<void>;
+    /** Blurs the action list item. */
+    blur(): Promise<void>;
+    /** Whether the action list item is focused. */
+    isFocused(): Promise<boolean>;
+}
+
+/** Harness for interacting with a list in tests. */
+declare class MatListHarness extends MatListHarnessBase<typeof MatListItemHarness, MatListItemHarness, ListItemHarnessFilters> {
+    /** The selector for the host element of a `MatList` instance. */
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a list with specific attributes.
+     * @param options Options for filtering which list instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with<T extends MatListHarness>(this: ComponentHarnessConstructor<T>, options?: ListHarnessFilters): HarnessPredicate<T>;
+    _itemHarness: typeof MatListItemHarness;
+}
+/** Harness for interacting with a list item. */
+declare class MatListItemHarness extends MatListItemHarnessBase {
+    /** The selector for the host element of a `MatListItem` instance. */
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a list item with specific attributes.
+     * @param options Options for filtering which list item instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with<T extends MatListItemHarness>(this: ComponentHarnessConstructor<T>, options?: ListItemHarnessFilters): HarnessPredicate<T>;
+}
+
+/** Harness for interacting with a mat-nav-list in tests. */
+declare class MatNavListHarness extends MatListHarnessBase<typeof MatNavListItemHarness, MatNavListItemHarness, NavListItemHarnessFilters> {
+    /** The selector for the host element of a `MatNavList` instance. */
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a nav list with specific
+     * attributes.
+     * @param options Options for filtering which nav list instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with<T extends MatNavListHarness>(this: ComponentHarnessConstructor<T>, options?: NavListHarnessFilters): HarnessPredicate<T>;
+    _itemHarness: typeof MatNavListItemHarness;
+}
+/** Harness for interacting with a nav-list item. */
+declare class MatNavListItemHarness extends MatListItemHarnessBase {
+    /** The selector for the host element of a `MatListItem` instance. */
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a nav list item with specific
+     * attributes.
+     * @param options Options for filtering which nav list item instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with<T extends MatNavListItemHarness>(this: ComponentHarnessConstructor<T>, options?: NavListItemHarnessFilters): HarnessPredicate<T>;
+    /** Gets the href for this nav list item. */
+    getHref(): Promise<string | null>;
+    /** Clicks on the nav list item. */
+    click(): Promise<void>;
+    /** Focuses the nav list item. */
+    focus(): Promise<void>;
+    /** Blurs the nav list item. */
+    blur(): Promise<void>;
+    /** Whether the nav list item is focused. */
+    isFocused(): Promise<boolean>;
+    /** Whether the list item is activated. Should only be used for nav list items. */
+    isActivated(): Promise<boolean>;
+}
+
+/** Harness for interacting with a selection-list in tests. */
+declare class MatSelectionListHarness extends MatListHarnessBase<typeof MatListOptionHarness, MatListOptionHarness, ListOptionHarnessFilters> {
+    /** The selector for the host element of a `MatSelectionList` instance. */
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a selection list with specific
+     * attributes.
+     * @param options Options for filtering which selection list instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with<T extends MatSelectionListHarness>(this: ComponentHarnessConstructor<T>, options?: SelectionListHarnessFilters): HarnessPredicate<T>;
+    _itemHarness: typeof MatListOptionHarness;
+    /** Whether the selection list is disabled. */
+    isDisabled(): Promise<boolean>;
+    /**
+     * Selects all items matching any of the given filters.
+     * @param filters Filters that specify which items should be selected.
+     */
+    selectItems(...filters: ListOptionHarnessFilters[]): Promise<void>;
+    /**
+     * Deselects all items matching any of the given filters.
+     * @param filters Filters that specify which items should be deselected.
+     */
+    deselectItems(...filters: ListItemHarnessFilters[]): Promise<void>;
+    /** Gets all items matching the given list of filters. */
+    private _getItems;
+}
+/** Harness for interacting with a list option. */
+declare class MatListOptionHarness extends MatListItemHarnessBase {
+    /** The selector for the host element of a `MatListOption` instance. */
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a list option with specific
+     * attributes.
+     * @param options Options for filtering which list option instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with<T extends MatListOptionHarness>(this: ComponentHarnessConstructor<T>, options?: ListOptionHarnessFilters): HarnessPredicate<T>;
+    private _beforeCheckbox;
+    private _beforeRadio;
+    /** Gets the position of the checkbox relative to the list option content. */
+    getCheckboxPosition(): Promise<MatListOptionTogglePosition>;
+    /** Gets the position of the radio relative to the list option content. */
+    getRadioPosition(): Promise<MatListOptionTogglePosition>;
+    /** Whether the list option is selected. */
+    isSelected(): Promise<boolean>;
+    /** Focuses the list option. */
+    focus(): Promise<void>;
+    /** Blurs the list option. */
+    blur(): Promise<void>;
+    /** Whether the list option is focused. */
+    isFocused(): Promise<boolean>;
+    /** Toggles the checked state of the checkbox. */
+    toggle(): Promise<void>;
+    /**
+     * Puts the list option in a checked state by toggling it if it is currently
+     * unchecked, or doing nothing if it is already checked.
+     */
+    select(): Promise<void>;
+    /**
+     * Puts the list option in an unchecked state by toggling it if it is currently
+     * checked, or doing nothing if it is already unchecked.
+     */
+    deselect(): Promise<void>;
+}
+
+export { MatActionListHarness, MatActionListItemHarness, MatListHarness, MatListItemHarness, MatListItemSection, MatListItemType, MatListOptionHarness, MatNavListHarness, MatNavListItemHarness, MatSelectionListHarness, MatSubheaderHarness };
+export type { ActionListHarnessFilters, ActionListItemHarnessFilters, BaseListItemHarnessFilters, ListHarnessFilters, ListItemHarnessFilters, ListOptionHarnessFilters, NavListHarnessFilters, NavListItemHarnessFilters, SelectionListHarnessFilters, SubheaderHarnessFilters };