@angular/material 14.0.0-next.12 → 14.0.0-next.13

package/dialog/index.d.ts

@@ -1,8 +1,491 @@
+import { AnimationEvent as AnimationEvent_2 } from '@angular/animations';
+import { AnimationTriggerMetadata } from '@angular/animations';
+import { CdkDialogContainer } from '@angular/cdk/dialog';
+import { ChangeDetectorRef } from '@angular/core';
+import { ComponentFactoryResolver } from '@angular/core';
+import { ComponentType } from '@angular/cdk/portal';
+import { DialogRef } from '@angular/cdk/dialog';
+import { Direction } from '@angular/cdk/bidi';
+import { ElementRef } from '@angular/core';
+import { EventEmitter } from '@angular/core';
+import { FocusMonitor } from '@angular/cdk/a11y';
+import { FocusOrigin } from '@angular/cdk/a11y';
+import { FocusTrapFactory } from '@angular/cdk/a11y';
+import * as i0 from '@angular/core';
+import * as i3 from '@angular/cdk/dialog';
+import * as i4 from '@angular/cdk/overlay';
+import * as i5 from '@angular/cdk/portal';
+import * as i6 from '@angular/material/core';
+import { InjectionToken } from '@angular/core';
+import { Injector } from '@angular/core';
+import { InteractivityChecker } from '@angular/cdk/a11y';
+import { Location as Location_2 } from '@angular/common';
+import { NgZone } from '@angular/core';
+import { Observable } from 'rxjs';
+import { OnChanges } from '@angular/core';
+import { OnDestroy } from '@angular/core';
+import { OnInit } from '@angular/core';
+import { Overlay } from '@angular/cdk/overlay';
+import { OverlayContainer } from '@angular/cdk/overlay';
+import { OverlayRef } from '@angular/cdk/overlay';
+import { ScrollStrategy } from '@angular/cdk/overlay';
+import { SimpleChanges } from '@angular/core';
+import { Subject } from 'rxjs';
+import { TemplateRef } from '@angular/core';
+import { Type } from '@angular/core';
+import { ViewContainerRef } from '@angular/core';
+
+/** Options for where to set focus to automatically on dialog open */
+export declare type AutoFocusTarget = 'dialog' | 'first-tabbable' | 'first-heading';
+
 /**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
+ * Closes the dialog with the specified interaction type. This is currently not part of
+ * `MatDialogRef` as that would conflict with custom dialog ref mocks provided in tests.
+ * More details. See: https://github.com/angular/components/pull/9257#issuecomment-651342226.
  */
-export * from './public-api';
+export declare function _closeDialogVia<R>(ref: MatDialogRef<R>, interactionType: FocusOrigin, result?: R): void;
+
+/** Event that captures the state of dialog container animations. */
+declare interface DialogAnimationEvent {
+    state: 'opened' | 'opening' | 'closing' | 'closed';
+    totalTime: number;
+}
+
+/** Possible overrides for a dialog's position. */
+export declare interface DialogPosition {
+    /** Override for the dialog's top position. */
+    top?: string;
+    /** Override for the dialog's bottom position. */
+    bottom?: string;
+    /** Override for the dialog's left position. */
+    left?: string;
+    /** Override for the dialog's right position. */
+    right?: string;
+}
+
+/** Valid ARIA roles for a dialog element. */
+export declare type DialogRole = 'dialog' | 'alertdialog';
+
+declare namespace i1 {
+    export {
+        _MatDialogContainerBase,
+        MatDialogContainer
+    }
+}
+
+declare namespace i2 {
+    export {
+        MatDialogClose,
+        MatDialogTitle,
+        MatDialogContent,
+        MatDialogActions
+    }
+}
+
+/** Injection token that can be used to access the data that was passed in to a dialog. */
+export declare const MAT_DIALOG_DATA: InjectionToken<any>;
+
+/** Injection token that can be used to specify default dialog options. */
+export declare const MAT_DIALOG_DEFAULT_OPTIONS: InjectionToken<MatDialogConfig<any>>;
+
+/** Injection token that determines the scroll handling while the dialog is open. */
+export declare const MAT_DIALOG_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
+
+/** @docs-private */
+export declare function MAT_DIALOG_SCROLL_STRATEGY_FACTORY(overlay: Overlay): () => ScrollStrategy;
+
+/** @docs-private */
+export declare const MAT_DIALOG_SCROLL_STRATEGY_PROVIDER: {
+    provide: InjectionToken<() => ScrollStrategy>;
+    deps: (typeof Overlay)[];
+    useFactory: typeof MAT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY;
+};
+
+/** @docs-private */
+export declare function MAT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay: Overlay): () => ScrollStrategy;
+
+/**
+ * Service to open Material Design modal dialogs.
+ */
+export declare class MatDialog extends _MatDialogBase<MatDialogContainer> {
+    constructor(overlay: Overlay, injector: Injector, 
+    /**
+     * @deprecated `_location` parameter to be removed.
+     * @breaking-change 10.0.0
+     */
+    _location: Location_2, defaultOptions: MatDialogConfig, scrollStrategy: any, parentDialog: MatDialog, 
+    /**
+     * @deprecated No longer used. To be removed.
+     * @breaking-change 15.0.0
+     */
+    overlayContainer: OverlayContainer, 
+    /**
+     * @deprecated No longer used. To be removed.
+     * @breaking-change 14.0.0
+     */
+    animationMode?: 'NoopAnimations' | 'BrowserAnimations');
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatDialog, [null, null, { optional: true; }, { optional: true; }, null, { optional: true; skipSelf: true; }, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MatDialog>;
+}
+
+/**
+ * Container for the bottom action buttons in a dialog.
+ * Stays fixed to the bottom when scrolling.
+ */
+export declare class MatDialogActions {
+    /**
+     * Horizontal alignment of action buttons.
+     */
+    align?: 'start' | 'center' | 'end';
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatDialogActions, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatDialogActions, "[mat-dialog-actions], mat-dialog-actions, [matDialogActions]", never, { "align": "align"; }, {}, never, never, false>;
+}
+
+/**
+ * Animations used by MatDialog.
+ * @docs-private
+ */
+export declare const matDialogAnimations: {
+    readonly dialogContainer: AnimationTriggerMetadata;
+};
+
+/**
+ * Base class for dialog services. The base dialog service allows
+ * for arbitrary dialog refs and dialog container components.
+ */
+export declare abstract class _MatDialogBase<C extends _MatDialogContainerBase> implements OnDestroy {
+    private _overlay;
+    private _defaultOptions;
+    private _parentDialog;
+    private _dialogRefConstructor;
+    private _dialogContainerType;
+    private _dialogDataToken;
+    private readonly _openDialogsAtThisLevel;
+    private readonly _afterAllClosedAtThisLevel;
+    private readonly _afterOpenedAtThisLevel;
+    private _scrollStrategy;
+    protected _idPrefix: string;
+    private _dialog;
+    /** Keeps track of the currently-open dialogs. */
+    get openDialogs(): MatDialogRef<any>[];
+    /** Stream that emits when a dialog has been opened. */
+    get afterOpened(): Subject<MatDialogRef<any>>;
+    private _getAfterAllClosed;
+    /**
+     * Stream that emits when all open dialog have finished closing.
+     * Will emit on subscribe if there are no open dialogs to begin with.
+     */
+    readonly afterAllClosed: Observable<void>;
+    constructor(_overlay: Overlay, injector: Injector, _defaultOptions: MatDialogConfig | undefined, _parentDialog: _MatDialogBase<C> | undefined, 
+    /**
+     * @deprecated No longer used. To be removed.
+     * @breaking-change 15.0.0
+     */
+    _overlayContainer: OverlayContainer, scrollStrategy: any, _dialogRefConstructor: Type<MatDialogRef<any>>, _dialogContainerType: Type<C>, _dialogDataToken: InjectionToken<any>, 
+    /**
+     * @deprecated No longer used. To be removed.
+     * @breaking-change 14.0.0
+     */
+    _animationMode?: 'NoopAnimations' | 'BrowserAnimations');
+    /**
+     * Opens a modal dialog containing the given component.
+     * @param component Type of the component to load into the dialog.
+     * @param config Extra configuration options.
+     * @returns Reference to the newly-opened dialog.
+     */
+    open<T, D = any, R = any>(component: ComponentType<T>, config?: MatDialogConfig<D>): MatDialogRef<T, R>;
+    /**
+     * Opens a modal dialog containing the given template.
+     * @param template TemplateRef to instantiate as the dialog content.
+     * @param config Extra configuration options.
+     * @returns Reference to the newly-opened dialog.
+     */
+    open<T, D = any, R = any>(template: TemplateRef<T>, config?: MatDialogConfig<D>): MatDialogRef<T, R>;
+    open<T, D = any, R = any>(template: ComponentType<T> | TemplateRef<T>, config?: MatDialogConfig<D>): MatDialogRef<T, R>;
+    /**
+     * Closes all of the currently-open dialogs.
+     */
+    closeAll(): void;
+    /**
+     * Finds an open dialog by its id.
+     * @param id ID to use when looking up the dialog.
+     */
+    getDialogById(id: string): MatDialogRef<any> | undefined;
+    ngOnDestroy(): void;
+    private _closeDialogs;
+    static ɵfac: i0.ɵɵFactoryDeclaration<_MatDialogBase<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<_MatDialogBase<any>>;
+}
+
+/**
+ * Button that will close the current dialog.
+ */
+export declare class MatDialogClose implements OnInit, OnChanges {
+    /**
+     * Reference to the containing dialog.
+     * @deprecated `dialogRef` property to become private.
+     * @breaking-change 13.0.0
+     */
+    dialogRef: MatDialogRef<any>;
+    private _elementRef;
+    private _dialog;
+    /** Screenreader 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(
+    /**
+     * Reference to the containing dialog.
+     * @deprecated `dialogRef` property to become private.
+     * @breaking-change 13.0.0
+     */
+    dialogRef: MatDialogRef<any>, _elementRef: ElementRef<HTMLElement>, _dialog: MatDialog);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    _onButtonClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatDialogClose, [{ optional: true; }, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatDialogClose, "[mat-dialog-close], [matDialogClose]", ["matDialogClose"], { "ariaLabel": "aria-label"; "type": "type"; "dialogResult": "mat-dialog-close"; "_matDialogClose": "matDialogClose"; }, {}, never, never, false>;
+}
+
+/**
+ * Configuration for opening a modal dialog with the MatDialog service.
+ */
+export declare class MatDialogConfig<D = any> {
+    /**
+     * Where the attached component should live in Angular's *logical* component tree.
+     * This affects what is available for injection and the change detection order for the
+     * component instantiated inside of the dialog. This does not affect where the dialog
+     * content will be rendered.
+     */
+    viewContainerRef?: ViewContainerRef;
+    /**
+     * Injector used for the instantiation of the component to be attached. If provided,
+     * takes precedence over the injector indirectly provided by `ViewContainerRef`.
+     */
+    injector?: Injector;
+    /** ID for the dialog. If omitted, a unique one will be generated. */
+    id?: string;
+    /** The ARIA role of the dialog element. */
+    role?: DialogRole;
+    /** Custom class for the overlay pane. */
+    panelClass?: string | string[];
+    /** Whether the dialog has a backdrop. */
+    hasBackdrop?: boolean;
+    /** Custom class for the backdrop. */
+    backdropClass?: string | string[];
+    /** Whether the user can use escape or clicking on the backdrop to close the modal. */
+    disableClose?: boolean;
+    /** Width of the dialog. */
+    width?: string;
+    /** Height of the dialog. */
+    height?: string;
+    /** Min-width of the dialog. If a number is provided, assumes pixel units. */
+    minWidth?: number | string;
+    /** Min-height of the dialog. If a number is provided, assumes pixel units. */
+    minHeight?: number | string;
+    /** Max-width of the dialog. If a number is provided, assumes pixel units. Defaults to 80vw. */
+    maxWidth?: number | string;
+    /** Max-height of the dialog. If a number is provided, assumes pixel units. */
+    maxHeight?: number | string;
+    /** Position overrides. */
+    position?: DialogPosition;
+    /** Data being injected into the child component. */
+    data?: D | null;
+    /** Layout direction for the dialog's content. */
+    direction?: Direction;
+    /** ID of the element that describes the dialog. */
+    ariaDescribedBy?: string | null;
+    /** ID of the element that labels the dialog. */
+    ariaLabelledBy?: string | null;
+    /** Aria label to assign to the dialog element. */
+    ariaLabel?: string | null;
+    /**
+     * Where the dialog should focus on open.
+     * @breaking-change 14.0.0 Remove boolean option from autoFocus. Use string or
+     * AutoFocusTarget instead.
+     */
+    autoFocus?: AutoFocusTarget | string | boolean;
+    /**
+     * Whether the dialog should restore focus to the
+     * previously-focused element, after it's closed.
+     */
+    restoreFocus?: boolean;
+    /** Whether to wait for the opening animation to finish before trapping focus. */
+    delayFocusTrap?: boolean;
+    /** Scroll strategy to be used for the dialog. */
+    scrollStrategy?: ScrollStrategy;
+    /**
+     * Whether the dialog should close when the user goes backwards/forwards in history.
+     * Note that this usually doesn't include clicking on links (unless the user is using
+     * the `HashLocationStrategy`).
+     */
+    closeOnNavigation?: boolean;
+    /** Alternate `ComponentFactoryResolver` to use when resolving the associated component. */
+    componentFactoryResolver?: ComponentFactoryResolver;
+    /** Duration of the enter animation. Has to be a valid CSS value (e.g. 100ms). */
+    enterAnimationDuration?: string;
+    /** Duration of the exit animation. Has to be a valid CSS value (e.g. 50ms). */
+    exitAnimationDuration?: string;
+}
+
+/**
+ * Internal component that wraps user-provided dialog content.
+ * Animation is based on https://material.io/guidelines/motion/choreography.html.
+ * @docs-private
+ */
+export declare class MatDialogContainer extends _MatDialogContainerBase {
+    private _changeDetectorRef;
+    /** State of the dialog animation. */
+    _state: 'void' | 'enter' | 'exit';
+    /** Callback, invoked whenever an animation on the host completes. */
+    _onAnimationDone({ toState, totalTime }: AnimationEvent_2): void;
+    /** Callback, invoked when an animation on the host starts. */
+    _onAnimationStart({ toState, totalTime }: AnimationEvent_2): void;
+    /** Starts the dialog exit animation. */
+    _startExitAnimation(): void;
+    constructor(elementRef: ElementRef, focusTrapFactory: FocusTrapFactory, document: any, dialogConfig: MatDialogConfig, checker: InteractivityChecker, ngZone: NgZone, overlayRef: OverlayRef, _changeDetectorRef: ChangeDetectorRef, focusMonitor?: FocusMonitor);
+    _getAnimationState(): {
+        value: "enter" | "void" | "exit";
+        params: {
+            enterAnimationDuration: string;
+            exitAnimationDuration: string;
+        };
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatDialogContainer, [null, null, { optional: true; }, null, null, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatDialogContainer, "mat-dialog-container", never, {}, {}, never, never, false>;
+}
+
+/**
+ * Base class for the `MatDialogContainer`. The base class does not implement
+ * animations as these are left to implementers of the dialog container.
+ */
+export declare abstract class _MatDialogContainerBase extends CdkDialogContainer<MatDialogConfig> {
+    /** Emits when an animation state changes. */
+    _animationStateChanged: EventEmitter<DialogAnimationEvent>;
+    constructor(elementRef: ElementRef, focusTrapFactory: FocusTrapFactory, _document: any, dialogConfig: MatDialogConfig, interactivityChecker: InteractivityChecker, ngZone: NgZone, overlayRef: OverlayRef, focusMonitor?: FocusMonitor);
+    /** Starts the dialog exit animation. */
+    abstract _startExitAnimation(): void;
+    protected _captureInitialFocus(): void;
+    /**
+     * Callback for when the open dialog animation has finished. Intended to
+     * be called by sub-classes that use different animation implementations.
+     */
+    protected _openAnimationDone(totalTime: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<_MatDialogContainerBase, [null, null, { optional: true; }, null, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<_MatDialogContainerBase, "ng-component", never, {}, {}, never, never, false>;
+}
+
+/**
+ * Scrollable content container of a dialog.
+ */
+export declare class MatDialogContent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatDialogContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatDialogContent, "[mat-dialog-content], mat-dialog-content, [matDialogContent]", never, {}, {}, never, never, false>;
+}
+
+export declare class MatDialogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatDialogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatDialogModule, [typeof i1.MatDialogContainer, typeof i2.MatDialogClose, typeof i2.MatDialogTitle, typeof i2.MatDialogActions, typeof i2.MatDialogContent], [typeof i3.DialogModule, typeof i4.OverlayModule, typeof i5.PortalModule, typeof i6.MatCommonModule], [typeof i1.MatDialogContainer, typeof i2.MatDialogClose, typeof i2.MatDialogTitle, typeof i2.MatDialogContent, typeof i2.MatDialogActions, typeof i6.MatCommonModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatDialogModule>;
+}
+
+/**
+ * Reference to a dialog opened via the MatDialog service.
+ */
+export declare class MatDialogRef<T, R = any> {
+    private _ref;
+    _containerInstance: _MatDialogContainerBase;
+    /** The instance of component opened into the dialog. */
+    componentInstance: T;
+    /** Whether the user is allowed to close the dialog. */
+    disableClose: boolean | undefined;
+    /** Unique ID for the dialog. */
+    id: string;
+    /** Subject for notifying the user that the dialog has finished opening. */
+    private readonly _afterOpened;
+    /** Subject for notifying the user that the dialog has started closing. */
+    private readonly _beforeClosed;
+    /** Result to be passed to afterClosed. */
+    private _result;
+    /** Handle to the timeout that's running as a fallback in case the exit animation doesn't fire. */
+    private _closeFallbackTimeout;
+    /** Current state of the dialog. */
+    private _state;
+    /** Interaction that caused the dialog to close. */
+    private _closeInteractionType;
+    constructor(_ref: DialogRef<R, T>, config: MatDialogConfig, _containerInstance: _MatDialogContainerBase);
+    /**
+     * Close the dialog.
+     * @param dialogResult Optional result to return to the dialog opener.
+     */
+    close(dialogResult?: R): void;
+    /**
+     * Gets an observable that is notified when the dialog is finished opening.
+     */
+    afterOpened(): Observable<void>;
+    /**
+     * Gets an observable that is notified when the dialog is finished closing.
+     */
+    afterClosed(): Observable<R | undefined>;
+    /**
+     * Gets an observable that is notified when the dialog has started closing.
+     */
+    beforeClosed(): Observable<R | undefined>;
+    /**
+     * Gets an observable that emits when the overlay's backdrop has been clicked.
+     */
+    backdropClick(): Observable<MouseEvent>;
+    /**
+     * Gets an observable that emits when keydown events are targeted on the overlay.
+     */
+    keydownEvents(): Observable<KeyboardEvent>;
+    /**
+     * Updates the dialog's position.
+     * @param position New dialog position.
+     */
+    updatePosition(position?: DialogPosition): this;
+    /**
+     * Updates the dialog's width and height.
+     * @param width New width of the dialog.
+     * @param height New height of the dialog.
+     */
+    updateSize(width?: string, height?: string): this;
+    /** Add a CSS class or an array of classes to the overlay pane. */
+    addPanelClass(classes: string | string[]): this;
+    /** Remove a CSS class or an array of classes from the overlay pane. */
+    removePanelClass(classes: string | string[]): this;
+    /** Gets the current state of the dialog's lifecycle. */
+    getState(): MatDialogState;
+    /**
+     * Finishes the dialog close by updating the state of the dialog
+     * and disposing the overlay.
+     */
+    private _finishDialogClose;
+}
+
+/** Possible states of the lifecycle of a dialog. */
+export declare const enum MatDialogState {
+    OPEN = 0,
+    CLOSING = 1,
+    CLOSED = 2
+}
+
+/**
+ * Title of a dialog element. Stays fixed to the top of the dialog when scrolling.
+ */
+export declare class MatDialogTitle implements OnInit {
+    private _dialogRef;
+    private _elementRef;
+    private _dialog;
+    /** Unique id for the dialog title. If none is supplied, it will be auto-generated. */
+    id: string;
+    constructor(_dialogRef: MatDialogRef<any>, _elementRef: ElementRef<HTMLElement>, _dialog: MatDialog);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatDialogTitle, [{ optional: true; }, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatDialogTitle, "[mat-dialog-title], [matDialogTitle]", ["matDialogTitle"], { "id": "id"; }, {}, never, never, false>;
+}
+
+export { }

package/dialog/testing/index.d.ts

@@ -1,8 +1,97 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-export * from './public-api';
+import { AsyncFactoryFn } from '@angular/cdk/testing';
+import { BaseHarnessFilters } from '@angular/cdk/testing';
+import { ComponentType } from '@angular/cdk/overlay';
+import { ContentContainerComponentHarness } from '@angular/cdk/testing';
+import { DialogRole } from '@angular/material/dialog';
+import { HarnessPredicate } from '@angular/cdk/testing';
+import { MatDialog } from '@angular/material/dialog';
+import { _MatDialogBase } from '@angular/material/dialog';
+import { MatDialogConfig } from '@angular/material/dialog';
+import { MatDialogContainer } from '@angular/material/dialog';
+import { _MatDialogContainerBase } from '@angular/material/dialog';
+import { MatDialogRef } from '@angular/material/dialog';
+import { OnDestroy } from '@angular/core';
+import { TestElement } from '@angular/cdk/testing';
+
+/** A set of criteria that can be used to filter a list of `MatDialogHarness` instances. */
+export declare interface DialogHarnessFilters extends BaseHarnessFilters {
+}
+
+/** Harness for interacting with a standard `MatDialog` in tests. */
+export declare class MatDialogHarness extends _MatDialogHarnessBase {
+    /** The selector for the host element of a `MatDialog` instance. */
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `MatDialogHarness` that meets
+     * certain criteria.
+     * @param options Options for filtering which dialog instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options?: DialogHarnessFilters): HarnessPredicate<MatDialogHarness>;
+}
+
+/** Base class for the `MatDialogHarness` implementation. */
+export declare class _MatDialogHarnessBase extends ContentContainerComponentHarness<MatDialogSection | string> {
+    protected _title: AsyncFactoryFn<TestElement | null>;
+    protected _content: AsyncFactoryFn<TestElement | null>;
+    protected _actions: AsyncFactoryFn<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 te 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>;
+}
+
+/** Selectors for different sections of the mat-dialog that can contain user content. */
+export declare const enum MatDialogSection {
+    TITLE = ".mat-dialog-title",
+    CONTENT = ".mat-dialog-content",
+    ACTIONS = ".mat-dialog-actions"
+}
+
+/** Test component that immediately opens a dialog when created. */
+export declare class MatTestDialogOpener<T = unknown, R = unknown> extends _MatTestDialogOpenerBase<MatDialogContainer, T, R> {
+    constructor(dialog: MatDialog);
+    /** 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>>;
+}
+
+/** Base class for a component that immediately opens a dialog when created. */
+export declare class _MatTestDialogOpenerBase<C extends _MatDialogContainerBase, T, R> implements OnDestroy {
+    dialog: _MatDialogBase<C>;
+    /** 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;
+    constructor(dialog: _MatDialogBase<C>);
+    ngOnDestroy(): void;
+}
+
+export declare class MatTestDialogOpenerModule {
+}
+
+export { }

package/divider/index.d.ts

@@ -1,8 +1,30 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-export * from './public-api';
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i0 from '@angular/core';
+import * as i2 from '@angular/material/core';
+
+declare namespace i1 {
+    export {
+        MatDivider
+    }
+}
+
+export 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": "vertical"; "inset": "inset"; }, {}, never, never, false>;
+}
+
+export declare class MatDividerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatDividerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatDividerModule, [typeof i1.MatDivider], [typeof i2.MatCommonModule], [typeof i1.MatDivider, typeof i2.MatCommonModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatDividerModule>;
+}
+
+export { }

package/divider/testing/index.d.ts

@@ -1,8 +1,16 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-export * from './public-api';
+import { BaseHarnessFilters } from '@angular/cdk/testing';
+import { ComponentHarness } from '@angular/cdk/testing';
+import { HarnessPredicate } from '@angular/cdk/testing';
+
+export declare interface DividerHarnessFilters extends BaseHarnessFilters {
+}
+
+/** Harness for interacting with a `mat-divider`. */
+export declare class MatDividerHarness extends ComponentHarness {
+    static hostSelector: string;
+    static with(options?: DividerHarnessFilters): HarnessPredicate<MatDividerHarness>;
+    getOrientation(): Promise<'horizontal' | 'vertical'>;
+    isInset(): Promise<boolean>;
+}
+
+export { }