@depup/angular__material 21.2.2-depup.19

package/types/dialog-testing.d.ts

@@ -0,0 +1,83 @@
+import * as _angular_cdk_testing from '@angular/cdk/testing';
+import { BaseHarnessFilters, ContentContainerComponentHarness, ComponentHarnessConstructor, HarnessPredicate } from '@angular/cdk/testing';
+import { DialogRole, MatDialog, MatDialogConfig, MatDialogRef } from './_dialog-chunk.js';
+import { ComponentType } from '@angular/cdk/overlay';
+import { OnDestroy } from '@angular/core';
+import '@angular/cdk/bidi';
+import '@angular/cdk/dialog';
+import '@angular/cdk/a11y';
+import 'rxjs';
+import '@angular/cdk/portal';
+
+/** A set of criteria that can be used to filter a list of `MatDialogHarness` instances. */
+interface DialogHarnessFilters extends BaseHarnessFilters {
+}
+
+/** Selectors for different sections of the mat-dialog that can contain user content. */
+declare enum MatDialogSection {
+    TITLE = ".mat-mdc-dialog-title",
+    CONTENT = ".mat-mdc-dialog-content",
+    ACTIONS = ".mat-mdc-dialog-actions"
+}
+/** Harness for interacting with a standard `MatDialog` in tests. */
+declare class MatDialogHarness extends ContentContainerComponentHarness<MatDialogSection | string> {
+    /** The selector for the host element of a `MatDialog` instance. */
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a dialog with specific attributes.
+     * @param options Options for filtering which dialog instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with<T extends MatDialogHarness>(this: ComponentHarnessConstructor<T>, options?: DialogHarnessFilters): HarnessPredicate<T>;
+    protected _title: () => Promise<_angular_cdk_testing.TestElement | null>;
+    protected _content: () => Promise<_angular_cdk_testing.TestElement | null>;
+    protected _actions: () => Promise<_angular_cdk_testing.TestElement | null>;
+    /** Gets the id of the dialog. */
+    getId(): Promise<string | null>;
+    /** Gets the role of the dialog. */
+    getRole(): Promise<DialogRole | null>;
+    /** Gets the value of the dialog's "aria-label" attribute. */
+    getAriaLabel(): Promise<string | null>;
+    /** Gets the value of the dialog's "aria-labelledby" attribute. */
+    getAriaLabelledby(): Promise<string | null>;
+    /** Gets the value of the dialog's "aria-describedby" attribute. */
+    getAriaDescribedby(): Promise<string | null>;
+    /**
+     * Closes the dialog by pressing escape.
+     *
+     * Note: this method does nothing if `disableClose` has been set to `true` for the dialog.
+     */
+    close(): Promise<void>;
+    /** Gets the dialog's text. */
+    getText(): Promise<string>;
+    /** Gets the dialog's title text. This only works if the dialog is using mat-dialog-title. */
+    getTitleText(): Promise<string>;
+    /** Gets the dialog's content text. This only works if the dialog is using mat-dialog-content. */
+    getContentText(): Promise<string>;
+    /** Gets the dialog's actions text. This only works if the dialog is using mat-dialog-actions. */
+    getActionsText(): Promise<string>;
+}
+
+/** Test component that immediately opens a dialog when bootstrapped. */
+declare class MatTestDialogOpener<T = unknown, R = unknown> implements OnDestroy {
+    dialog: MatDialog;
+    /** Component that should be opened with the MatDialog `open` method. */
+    protected static component: ComponentType<unknown> | undefined;
+    /** Config that should be provided to the MatDialog `open` method. */
+    protected static config: MatDialogConfig | undefined;
+    /** MatDialogRef returned from the MatDialog `open` method. */
+    dialogRef: MatDialogRef<T, R>;
+    /** Data passed to the `MatDialog` close method. */
+    closedResult: R | undefined;
+    private readonly _afterClosedSubscription;
+    private readonly _ngZone;
+    /** Static method that prepares this class to open the provided component. */
+    static withComponent<T = unknown, R = unknown>(component: ComponentType<T>, config?: MatDialogConfig): ComponentType<MatTestDialogOpener<T, R>>;
+    constructor(...args: unknown[]);
+    ngOnDestroy(): void;
+}
+declare class MatTestDialogOpenerModule {
+}
+
+export { MatDialogHarness, MatDialogSection, MatTestDialogOpener, MatTestDialogOpenerModule };
+export type { DialogHarnessFilters };

package/types/dialog.d.ts

@@ -0,0 +1,84 @@
+import { MatDialogRef, MatDialogContainer } from './_dialog-chunk.js';
+export { AutoFocusTarget, DialogPosition, DialogRole, MAT_DIALOG_DATA, MAT_DIALOG_DEFAULT_OPTIONS, MAT_DIALOG_SCROLL_STRATEGY, MatDialog, MatDialogConfig, MatDialogState, _closeDialogVia } from './_dialog-chunk.js';
+import * as i0 from '@angular/core';
+import { OnInit, OnChanges, SimpleChanges, OnDestroy } from '@angular/core';
+import * as i1 from '@angular/cdk/scrolling';
+import * as i1$1 from '@angular/cdk/dialog';
+import * as i2 from '@angular/cdk/overlay';
+import * as i2$1 from '@angular/cdk/portal';
+import * as i2$2 from '@angular/cdk/bidi';
+import '@angular/cdk/a11y';
+import 'rxjs';
+
+/**
+ * Button that will close the current dialog.
+ */
+declare class MatDialogClose implements OnInit, OnChanges {
+    dialogRef: MatDialogRef<any, any>;
+    private _elementRef;
+    private _dialog;
+    /** Screen-reader label for the button. */
+    ariaLabel: string;
+    /** Default to "button" to prevents accidental form submits. */
+    type: 'submit' | 'button' | 'reset';
+    /** Dialog close input. */
+    dialogResult: any;
+    _matDialogClose: any;
+    constructor(...args: unknown[]);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    _onButtonClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatDialogClose, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatDialogClose, "[mat-dialog-close], [matDialogClose]", ["matDialogClose"], { "ariaLabel": { "alias": "aria-label"; "required": false; }; "type": { "alias": "type"; "required": false; }; "dialogResult": { "alias": "mat-dialog-close"; "required": false; }; "_matDialogClose": { "alias": "matDialogClose"; "required": false; }; }, {}, never, never, true, never>;
+}
+declare abstract class MatDialogLayoutSection implements OnInit, OnDestroy {
+    protected _dialogRef: MatDialogRef<any, any>;
+    private _elementRef;
+    private _dialog;
+    constructor(...args: unknown[]);
+    protected abstract _onAdd(): void;
+    protected abstract _onRemove(): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatDialogLayoutSection, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatDialogLayoutSection, never, never, {}, {}, never, never, true, never>;
+}
+/**
+ * Title of a dialog element. Stays fixed to the top of the dialog when scrolling.
+ */
+declare class MatDialogTitle extends MatDialogLayoutSection {
+    id: string;
+    protected _onAdd(): void;
+    protected _onRemove(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatDialogTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatDialogTitle, "[mat-dialog-title], [matDialogTitle]", ["matDialogTitle"], { "id": { "alias": "id"; "required": false; }; }, {}, never, never, true, never>;
+}
+/**
+ * Scrollable content container of a dialog.
+ */
+declare class MatDialogContent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatDialogContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatDialogContent, "[mat-dialog-content], mat-dialog-content, [matDialogContent]", never, {}, {}, never, never, true, [{ directive: typeof i1.CdkScrollable; inputs: {}; outputs: {}; }]>;
+}
+/**
+ * Container for the bottom action buttons in a dialog.
+ * Stays fixed to the bottom when scrolling.
+ */
+declare class MatDialogActions extends MatDialogLayoutSection {
+    /**
+     * Horizontal alignment of action buttons.
+     */
+    align?: 'start' | 'center' | 'end';
+    protected _onAdd(): void;
+    protected _onRemove(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatDialogActions, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatDialogActions, "[mat-dialog-actions], mat-dialog-actions, [matDialogActions]", never, { "align": { "alias": "align"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MatDialogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatDialogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatDialogModule, never, [typeof i1$1.DialogModule, typeof i2.OverlayModule, typeof i2$1.PortalModule, typeof MatDialogContainer, typeof MatDialogClose, typeof MatDialogTitle, typeof MatDialogActions, typeof MatDialogContent], [typeof i2$2.BidiModule, typeof MatDialogContainer, typeof MatDialogClose, typeof MatDialogTitle, typeof MatDialogActions, typeof MatDialogContent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatDialogModule>;
+}
+
+export { MatDialogActions, MatDialogClose, MatDialogContainer, MatDialogContent, MatDialogModule, MatDialogRef, MatDialogTitle };

package/types/divider-testing.d.ts

@@ -0,0 +1,15 @@
+import { BaseHarnessFilters, ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+
+interface DividerHarnessFilters extends BaseHarnessFilters {
+}
+
+/** Harness for interacting with a `mat-divider`. */
+declare class MatDividerHarness extends ComponentHarness {
+    static hostSelector: string;
+    static with(options?: DividerHarnessFilters): HarnessPredicate<MatDividerHarness>;
+    getOrientation(): Promise<'horizontal' | 'vertical'>;
+    isInset(): Promise<boolean>;
+}
+
+export { MatDividerHarness };
+export type { DividerHarnessFilters };

package/types/divider.d.ts

@@ -0,0 +1,24 @@
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i0 from '@angular/core';
+import * as i2 from '@angular/cdk/bidi';
+
+declare class MatDivider {
+    /** Whether the divider is vertically aligned. */
+    get vertical(): boolean;
+    set vertical(value: BooleanInput);
+    private _vertical;
+    /** Whether the divider is an inset divider. */
+    get inset(): boolean;
+    set inset(value: BooleanInput);
+    private _inset;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatDivider, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatDivider, "mat-divider", never, { "vertical": { "alias": "vertical"; "required": false; }; "inset": { "alias": "inset"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MatDividerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatDividerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatDividerModule, never, [typeof MatDivider], [typeof MatDivider, typeof i2.BidiModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatDividerModule>;
+}
+
+export { MatDivider, MatDividerModule };

package/types/expansion-testing.d.ts

@@ -0,0 +1,101 @@
+import { BaseHarnessFilters, ContentContainerComponentHarness, HarnessPredicate, HarnessLoader, ComponentHarness } from '@angular/cdk/testing';
+
+interface AccordionHarnessFilters extends BaseHarnessFilters {
+}
+interface ExpansionPanelHarnessFilters extends BaseHarnessFilters {
+    title?: string | RegExp | null;
+    description?: string | RegExp | null;
+    content?: string | RegExp;
+    expanded?: boolean;
+    disabled?: boolean;
+}
+
+/** Selectors for the various `mat-expansion-panel` sections that may contain user content. */
+declare enum MatExpansionPanelSection {
+    HEADER = ".mat-expansion-panel-header",
+    TITLE = ".mat-expansion-panel-header-title",
+    DESCRIPTION = ".mat-expansion-panel-header-description",
+    CONTENT = ".mat-expansion-panel-content"
+}
+/** Harness for interacting with a standard mat-expansion-panel in tests. */
+declare class MatExpansionPanelHarness extends ContentContainerComponentHarness<MatExpansionPanelSection> {
+    static hostSelector: string;
+    private _header;
+    private _title;
+    private _description;
+    private _expansionIndicator;
+    private _content;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for an expansion-panel
+     * with specific attributes.
+     * @param options Options for narrowing the search:
+     *   - `title` finds an expansion-panel with a specific title text.
+     *   - `description` finds an expansion-panel with a specific description text.
+     *   - `expanded` finds an expansion-panel that is currently expanded.
+     *   - `disabled` finds an expansion-panel that is disabled.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options?: ExpansionPanelHarnessFilters): HarnessPredicate<MatExpansionPanelHarness>;
+    /** Whether the panel is expanded. */
+    isExpanded(): Promise<boolean>;
+    /**
+     * Gets the title text of the panel.
+     * @returns Title text or `null` if no title is set up.
+     */
+    getTitle(): Promise<string | null>;
+    /**
+     * Gets the description text of the panel.
+     * @returns Description text or `null` if no description is set up.
+     */
+    getDescription(): Promise<string | null>;
+    /** Whether the panel is disabled. */
+    isDisabled(): Promise<boolean>;
+    /**
+     * Toggles the expanded state of the panel by clicking on the panel
+     * header. This method will not work if the panel is disabled.
+     */
+    toggle(): Promise<void>;
+    /** Expands the expansion panel if collapsed. */
+    expand(): Promise<void>;
+    /** Collapses the expansion panel if expanded. */
+    collapse(): Promise<void>;
+    /** Gets the text content of the panel. */
+    getTextContent(): Promise<string>;
+    /**
+     * Gets a `HarnessLoader` that can be used to load harnesses for
+     * components within the panel's content area.
+     * @deprecated Use either `getChildLoader(MatExpansionPanelSection.CONTENT)`, `getHarness` or
+     *    `getAllHarnesses` instead.
+     * @breaking-change 12.0.0
+     */
+    getHarnessLoaderForContent(): Promise<HarnessLoader>;
+    /** Focuses the panel. */
+    focus(): Promise<void>;
+    /** Blurs the panel. */
+    blur(): Promise<void>;
+    /** Whether the panel is focused. */
+    isFocused(): Promise<boolean>;
+    /** Whether the panel has a toggle indicator displayed. */
+    hasToggleIndicator(): Promise<boolean>;
+    /** Gets the position of the toggle indicator. */
+    getToggleIndicatorPosition(): Promise<'before' | 'after'>;
+}
+
+/** Harness for interacting with a standard mat-accordion in tests. */
+declare class MatAccordionHarness extends ComponentHarness {
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for an accordion
+     * with specific attributes.
+     * @param options Options for narrowing the search.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options?: AccordionHarnessFilters): HarnessPredicate<MatAccordionHarness>;
+    /** Gets all expansion panels which are part of the accordion. */
+    getExpansionPanels(filter?: ExpansionPanelHarnessFilters): Promise<MatExpansionPanelHarness[]>;
+    /** Whether the accordion allows multiple expanded panels simultaneously. */
+    isMulti(): Promise<boolean>;
+}
+
+export { MatAccordionHarness, MatExpansionPanelHarness, MatExpansionPanelSection };
+export type { AccordionHarnessFilters, ExpansionPanelHarnessFilters };

package/types/expansion.d.ts

@@ -0,0 +1,258 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, TemplateRef, AfterContentInit, OnChanges, OnDestroy, EventEmitter, ElementRef, SimpleChanges, AfterViewInit, QueryList } from '@angular/core';
+import * as i1 from '@angular/cdk/accordion';
+import { CdkAccordion, CdkAccordionItem } from '@angular/cdk/accordion';
+import * as i2 from '@angular/cdk/portal';
+import { TemplatePortal } from '@angular/cdk/portal';
+import { FocusableOption, FocusOrigin } from '@angular/cdk/a11y';
+import { Subject } from 'rxjs';
+import * as i2$1 from '@angular/cdk/bidi';
+
+/** MatAccordion's display modes. */
+type MatAccordionDisplayMode = 'default' | 'flat';
+/** MatAccordion's toggle positions. */
+type MatAccordionTogglePosition = 'before' | 'after';
+/**
+ * Base interface for a `MatAccordion`.
+ * @docs-private
+ */
+interface MatAccordionBase extends CdkAccordion {
+    /** Whether the expansion indicator should be hidden. */
+    hideToggle: boolean;
+    /** Display mode used for all expansion panels in the accordion. */
+    displayMode: MatAccordionDisplayMode;
+    /** The position of the expansion indicator. */
+    togglePosition: MatAccordionTogglePosition;
+    /** Handles keyboard events coming in from the panel headers. */
+    _handleHeaderKeydown: (event: KeyboardEvent) => void;
+    /** Handles focus events on the panel headers. */
+    _handleHeaderFocus: (header: any) => void;
+}
+/**
+ * Token used to provide a `MatAccordion` to `MatExpansionPanel`.
+ * Used primarily to avoid circular imports between `MatAccordion` and `MatExpansionPanel`.
+ */
+declare const MAT_ACCORDION: InjectionToken<MatAccordionBase>;
+
+/**
+ * Base interface for a `MatExpansionPanel`.
+ * @docs-private
+ */
+interface MatExpansionPanelBase extends CdkAccordionItem {
+    /** Whether the toggle indicator should be hidden. */
+    hideToggle: boolean;
+}
+/**
+ * Token used to provide a `MatExpansionPanel` to `MatExpansionPanelContent`.
+ * Used to avoid circular imports between `MatExpansionPanel` and `MatExpansionPanelContent`.
+ */
+declare const MAT_EXPANSION_PANEL: InjectionToken<MatExpansionPanelBase>;
+
+/**
+ * Expansion panel content that will be rendered lazily
+ * after the panel is opened for the first time.
+ */
+declare class MatExpansionPanelContent {
+    _template: TemplateRef<any>;
+    _expansionPanel: MatExpansionPanelBase | null;
+    constructor(...args: unknown[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatExpansionPanelContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatExpansionPanelContent, "ng-template[matExpansionPanelContent]", never, {}, {}, never, never, true, never>;
+}
+
+/** MatExpansionPanel's states. */
+type MatExpansionPanelState = 'expanded' | 'collapsed';
+/**
+ * Object that can be used to override the default options
+ * for all of the expansion panels in a module.
+ */
+interface MatExpansionPanelDefaultOptions {
+    /** Height of the header while the panel is expanded. */
+    expandedHeight: string;
+    /** Height of the header while the panel is collapsed. */
+    collapsedHeight: string;
+    /** Whether the toggle indicator should be hidden. */
+    hideToggle: boolean;
+}
+/**
+ * Injection token that can be used to configure the default
+ * options for the expansion panel component.
+ */
+declare const MAT_EXPANSION_PANEL_DEFAULT_OPTIONS: InjectionToken<MatExpansionPanelDefaultOptions>;
+/**
+ * This component can be used as a single element to show expandable content, or as one of
+ * multiple children of an element with the MatAccordion directive attached.
+ */
+declare class MatExpansionPanel extends CdkAccordionItem implements AfterContentInit, OnChanges, OnDestroy {
+    private _viewContainerRef;
+    private readonly _animationsDisabled;
+    private _document;
+    private _ngZone;
+    private _elementRef;
+    private _renderer;
+    private _cleanupTransitionEnd;
+    /** Whether the toggle indicator should be hidden. */
+    get hideToggle(): boolean;
+    set hideToggle(value: boolean);
+    private _hideToggle;
+    /** The position of the expansion indicator. */
+    get togglePosition(): MatAccordionTogglePosition;
+    set togglePosition(value: MatAccordionTogglePosition);
+    private _togglePosition;
+    /** An event emitted after the body's expansion animation happens. */
+    readonly afterExpand: EventEmitter<void>;
+    /** An event emitted after the body's collapse animation happens. */
+    readonly afterCollapse: EventEmitter<void>;
+    /** Stream that emits for changes in `@Input` properties. */
+    readonly _inputChanges: Subject<{
+        [propName: string]: i0.SimpleChange<any>;
+    }>;
+    /** Optionally defined accordion the expansion panel belongs to. */
+    accordion: MatAccordionBase;
+    /** Content that will be rendered lazily. */
+    _lazyContent: MatExpansionPanelContent;
+    /** Element containing the panel's user-provided content. */
+    _body: ElementRef<HTMLElement>;
+    /** Element wrapping the panel body. */
+    protected _bodyWrapper: ElementRef<HTMLElement> | undefined;
+    /** Portal holding the user's content. */
+    _portal: TemplatePortal;
+    /** ID for the associated header element. Used for a11y labelling. */
+    _headerId: string;
+    constructor(...args: unknown[]);
+    /** Determines whether the expansion panel should have spacing between it and its siblings. */
+    _hasSpacing(): boolean;
+    /** Gets the expanded state string. */
+    _getExpandedState(): MatExpansionPanelState;
+    /** Toggles the expanded state of the expansion panel. */
+    toggle(): void;
+    /** Sets the expanded state of the expansion panel to false. */
+    close(): void;
+    /** Sets the expanded state of the expansion panel to true. */
+    open(): void;
+    ngAfterContentInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    /** Checks whether the expansion panel's content contains the currently-focused element. */
+    _containsFocus(): boolean;
+    private _transitionEndListener;
+    protected _setupAnimationEvents(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatExpansionPanel, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatExpansionPanel, "mat-expansion-panel", ["matExpansionPanel"], { "hideToggle": { "alias": "hideToggle"; "required": false; }; "togglePosition": { "alias": "togglePosition"; "required": false; }; }, { "afterExpand": "afterExpand"; "afterCollapse": "afterCollapse"; }, ["_lazyContent"], ["mat-expansion-panel-header", "*", "mat-action-row"], true, never>;
+    static ngAcceptInputType_hideToggle: unknown;
+}
+/**
+ * Actions of a `<mat-expansion-panel>`.
+ */
+declare class MatExpansionPanelActionRow {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatExpansionPanelActionRow, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatExpansionPanelActionRow, "mat-action-row", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Header element of a `<mat-expansion-panel>`.
+ */
+declare class MatExpansionPanelHeader implements AfterViewInit, OnDestroy, FocusableOption {
+    panel: MatExpansionPanel;
+    private _element;
+    private _focusMonitor;
+    private _changeDetectorRef;
+    private _parentChangeSubscription;
+    constructor(...args: unknown[]);
+    /** Height of the header while the panel is expanded. */
+    expandedHeight: string;
+    /** Height of the header while the panel is collapsed. */
+    collapsedHeight: string;
+    /** Tab index of the header. */
+    tabIndex: number;
+    /**
+     * Whether the associated panel is disabled. Implemented as a part of `FocusableOption`.
+     * @docs-private
+     */
+    get disabled(): boolean;
+    /** Toggles the expanded state of the panel. */
+    _toggle(): void;
+    /** Gets whether the panel is expanded. */
+    _isExpanded(): boolean;
+    /** Gets the expanded state string of the panel. */
+    _getExpandedState(): string;
+    /** Gets the panel id. */
+    _getPanelId(): string;
+    /** Gets the toggle position for the header. */
+    _getTogglePosition(): MatAccordionTogglePosition;
+    /** Gets whether the expand indicator should be shown. */
+    _showToggle(): boolean;
+    /**
+     * Gets the current height of the header. Null if no custom height has been
+     * specified, and if the default height from the stylesheet should be used.
+     */
+    _getHeaderHeight(): string | null;
+    /** Handle keydown event calling to toggle() if appropriate. */
+    _keydown(event: KeyboardEvent): void;
+    /**
+     * Focuses the panel header. Implemented as a part of `FocusableOption`.
+     * @param origin Origin of the action that triggered the focus.
+     * @docs-private
+     */
+    focus(origin?: FocusOrigin, options?: FocusOptions): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatExpansionPanelHeader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatExpansionPanelHeader, "mat-expansion-panel-header", never, { "expandedHeight": { "alias": "expandedHeight"; "required": false; }; "collapsedHeight": { "alias": "collapsedHeight"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; }, {}, never, ["mat-panel-title", "mat-panel-description", "*"], true, never>;
+    static ngAcceptInputType_tabIndex: unknown;
+}
+/**
+ * Description element of a `<mat-expansion-panel-header>`.
+ */
+declare class MatExpansionPanelDescription {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatExpansionPanelDescription, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatExpansionPanelDescription, "mat-panel-description", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Title element of a `<mat-expansion-panel-header>`.
+ */
+declare class MatExpansionPanelTitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatExpansionPanelTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatExpansionPanelTitle, "mat-panel-title", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Directive for a Material Design Accordion.
+ */
+declare class MatAccordion extends CdkAccordion implements MatAccordionBase, AfterContentInit, OnDestroy {
+    private _keyManager;
+    /** Headers belonging to this accordion. */
+    private _ownHeaders;
+    /** All headers inside the accordion. Includes headers inside nested accordions. */
+    _headers: QueryList<MatExpansionPanelHeader>;
+    /** Whether the expansion indicator should be hidden. */
+    hideToggle: boolean;
+    /**
+     * Display mode used for all expansion panels in the accordion. Currently two display
+     * modes exist:
+     *  default - a gutter-like spacing is placed around any expanded panel, placing the expanded
+     *     panel at a different elevation from the rest of the accordion.
+     *  flat - no spacing is placed around expanded panels, showing all panels at the same
+     *     elevation.
+     */
+    displayMode: MatAccordionDisplayMode;
+    /** The position of the expansion indicator. */
+    togglePosition: MatAccordionTogglePosition;
+    ngAfterContentInit(): void;
+    /** Handles keyboard events coming in from the panel headers. */
+    _handleHeaderKeydown(event: KeyboardEvent): void;
+    _handleHeaderFocus(header: MatExpansionPanelHeader): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatAccordion, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatAccordion, "mat-accordion", ["matAccordion"], { "hideToggle": { "alias": "hideToggle"; "required": false; }; "displayMode": { "alias": "displayMode"; "required": false; }; "togglePosition": { "alias": "togglePosition"; "required": false; }; }, {}, ["_headers"], never, true, never>;
+    static ngAcceptInputType_hideToggle: unknown;
+}
+
+declare class MatExpansionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatExpansionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatExpansionModule, never, [typeof i1.CdkAccordionModule, typeof i2.PortalModule, typeof MatAccordion, typeof MatExpansionPanel, typeof MatExpansionPanelActionRow, typeof MatExpansionPanelHeader, typeof MatExpansionPanelTitle, typeof MatExpansionPanelDescription, typeof MatExpansionPanelContent], [typeof i2$1.BidiModule, typeof MatAccordion, typeof MatExpansionPanel, typeof MatExpansionPanelActionRow, typeof MatExpansionPanelHeader, typeof MatExpansionPanelTitle, typeof MatExpansionPanelDescription, typeof MatExpansionPanelContent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatExpansionModule>;
+}
+
+export { MAT_ACCORDION, MAT_EXPANSION_PANEL, MAT_EXPANSION_PANEL_DEFAULT_OPTIONS, MatAccordion, MatExpansionModule, MatExpansionPanel, MatExpansionPanelActionRow, MatExpansionPanelContent, MatExpansionPanelDescription, MatExpansionPanelHeader, MatExpansionPanelTitle };
+export type { MatAccordionBase, MatAccordionDisplayMode, MatAccordionTogglePosition, MatExpansionPanelDefaultOptions, MatExpansionPanelState };

package/types/form-field-testing-control.d.ts

@@ -0,0 +1,13 @@
+export { MatFormFieldControlHarness, MatFormFieldControlHarnessBase } from './_form-field-control-harness-chunk.js';
+import { BaseHarnessFilters } from '@angular/cdk/testing';
+
+/**
+ * A set of criteria shared by any class derived from `MatFormFieldControlHarness`, that can be
+ * used to filter a list of those components.
+ */
+interface MatFormFieldControlHarnessFilters extends BaseHarnessFilters {
+    /** Filters based on the text of the form field's floating label. */
+    label?: string | RegExp;
+}
+
+export type { MatFormFieldControlHarnessFilters };