@depup/angular__material 21.2.2-depup.19

package/types/bottom-sheet.d.ts

@@ -0,0 +1,192 @@
+import * as i0 from '@angular/core';
+import { OnDestroy, EventEmitter, InjectionToken, ViewContainerRef, Injector, ComponentRef, TemplateRef } from '@angular/core';
+import * as i1 from '@angular/cdk/dialog';
+import { CdkDialogContainer, RestoreFocusValue, DialogRef } from '@angular/cdk/dialog';
+import * as i2 from '@angular/cdk/portal';
+import { ComponentType } from '@angular/cdk/portal';
+import * as i2$1 from '@angular/cdk/bidi';
+import { Direction } from '@angular/cdk/bidi';
+import { ScrollStrategy } from '@angular/cdk/overlay';
+import { Observable } from 'rxjs';
+
+/**
+ * Internal component that wraps user-provided bottom sheet content.
+ * @docs-private
+ */
+declare class MatBottomSheetContainer extends CdkDialogContainer implements OnDestroy {
+    private _breakpointSubscription;
+    protected _animationsDisabled: boolean;
+    /** The state of the bottom sheet animations. */
+    _animationState: 'void' | 'visible' | 'hidden';
+    /** Emits whenever the state of the animation changes. */
+    _animationStateChanged: EventEmitter<{
+        toState: "visible" | "hidden";
+        phase: "start" | "done";
+    }>;
+    /** Whether the component has been destroyed. */
+    private _destroyed;
+    constructor(...args: unknown[]);
+    /** Begin animation of bottom sheet entrance into view. */
+    enter(): void;
+    /** Begin animation of the bottom sheet exiting from view. */
+    exit(): void;
+    ngOnDestroy(): void;
+    private _simulateAnimation;
+    protected _trapFocus(): void;
+    protected _handleAnimationEvent(isStart: boolean, animationName: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatBottomSheetContainer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatBottomSheetContainer, "mat-bottom-sheet-container", never, {}, {}, never, never, true, never>;
+}
+
+declare class MatBottomSheetModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatBottomSheetModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatBottomSheetModule, never, [typeof i1.DialogModule, typeof i2.PortalModule, typeof MatBottomSheetContainer], [typeof MatBottomSheetContainer, typeof i2$1.BidiModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatBottomSheetModule>;
+}
+
+/** Options for where to set focus to automatically on dialog open */
+type AutoFocusTarget = 'dialog' | 'first-tabbable' | 'first-heading';
+/** Injection token that can be used to access the data that was passed in to a bottom sheet. */
+declare const MAT_BOTTOM_SHEET_DATA: InjectionToken<any>;
+/**
+ * Configuration used when opening a bottom sheet.
+ */
+declare class MatBottomSheetConfig<D = any> {
+    /** The view container to place the overlay for the bottom sheet into. */
+    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;
+    /** Extra CSS classes to be added to the bottom sheet container. */
+    panelClass?: string | string[];
+    /** Text layout direction for the bottom sheet. */
+    direction?: Direction;
+    /** Data being injected into the child component. */
+    data?: D | null;
+    /** Whether the bottom sheet has a backdrop. */
+    hasBackdrop?: boolean;
+    /** Custom class for the backdrop. */
+    backdropClass?: string;
+    /** Whether the user can use escape or clicking outside to close the bottom sheet. */
+    disableClose?: boolean;
+    /** Aria label to assign to the bottom sheet element. */
+    ariaLabel?: string | null;
+    /**
+     * Whether this is a modal dialog. Used to set the `aria-modal` attribute. Off by default,
+     * because it can interfere with other overlay-based components (e.g. `mat-select`) and because
+     * it is redundant since the dialog marks all outside content as `aria-hidden` anyway.
+     */
+    ariaModal?: boolean;
+    /**
+     * Whether the bottom sheet 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;
+    /**
+     * Where the bottom sheet should focus on open.
+     * @breaking-change 14.0.0 Remove boolean option from autoFocus. Use string or
+     * AutoFocusTarget instead.
+     */
+    autoFocus?: AutoFocusTarget | string | boolean;
+    /** Configures the focus restoration behavior. See `RestoreFocusValue` for more information. */
+    restoreFocus?: RestoreFocusValue;
+    /** Scroll strategy to be used for the bottom sheet. */
+    scrollStrategy?: ScrollStrategy;
+    /** Height for the bottom sheet. */
+    height?: string;
+    /** Minimum height for the bottom sheet. If a number is provided, assumes pixel units. */
+    minHeight?: number | string;
+    /** Maximum height for the bottom sheet. If a number is provided, assumes pixel units. */
+    maxHeight?: number | string;
+}
+
+/**
+ * Reference to a bottom sheet dispatched from the bottom sheet service.
+ */
+declare class MatBottomSheetRef<T = any, R = any> {
+    private _ref;
+    /** Instance of the component making up the content of the bottom sheet. */
+    get instance(): T;
+    /**
+     * `ComponentRef` of the component opened into the bottom sheet. Will be
+     * null when the bottom sheet is opened using a `TemplateRef`.
+     */
+    get componentRef(): ComponentRef<T> | null;
+    /**
+     * Instance of the component into which the bottom sheet content is projected.
+     * @docs-private
+     */
+    containerInstance: MatBottomSheetContainer;
+    /** Whether the user is allowed to close the bottom sheet. */
+    disableClose: boolean | undefined;
+    /** Subject for notifying the user that the bottom sheet has opened and appeared. */
+    private readonly _afterOpened;
+    /** Result to be passed down to the `afterDismissed` stream. */
+    private _result;
+    /** Handle to the timeout that's running as a fallback in case the exit animation doesn't fire. */
+    private _closeFallbackTimeout;
+    constructor(_ref: DialogRef<R, T>, config: MatBottomSheetConfig, containerInstance: MatBottomSheetContainer);
+    /**
+     * Dismisses the bottom sheet.
+     * @param result Data to be passed back to the bottom sheet opener.
+     */
+    dismiss(result?: R): void;
+    /** Gets an observable that is notified when the bottom sheet is finished closing. */
+    afterDismissed(): Observable<R | undefined>;
+    /** Gets an observable that is notified when the bottom sheet has opened and appeared. */
+    afterOpened(): Observable<void>;
+    /**
+     * 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>;
+}
+
+/** Injection token that can be used to specify default bottom sheet options. */
+declare const MAT_BOTTOM_SHEET_DEFAULT_OPTIONS: InjectionToken<MatBottomSheetConfig<any>>;
+/**
+ * Service to trigger Material Design bottom sheets.
+ */
+declare class MatBottomSheet implements OnDestroy {
+    private _injector;
+    private _parentBottomSheet;
+    private _animationsDisabled;
+    private _defaultOptions;
+    private _bottomSheetRefAtThisLevel;
+    private _dialog;
+    /** Reference to the currently opened bottom sheet. */
+    get _openedBottomSheetRef(): MatBottomSheetRef<any> | null;
+    set _openedBottomSheetRef(value: MatBottomSheetRef<any> | null);
+    constructor(...args: unknown[]);
+    /**
+     * Opens a bottom sheet containing the given component.
+     * @param component Type of the component to load into the bottom sheet.
+     * @param config Extra configuration options.
+     * @returns Reference to the newly-opened bottom sheet.
+     */
+    open<T, D = any, R = any>(component: ComponentType<T>, config?: MatBottomSheetConfig<D>): MatBottomSheetRef<T, R>;
+    /**
+     * Opens a bottom sheet containing the given template.
+     * @param template TemplateRef to instantiate as the bottom sheet content.
+     * @param config Extra configuration options.
+     * @returns Reference to the newly-opened bottom sheet.
+     */
+    open<T, D = any, R = any>(template: TemplateRef<T>, config?: MatBottomSheetConfig<D>): MatBottomSheetRef<T, R>;
+    /**
+     * Dismisses the currently-visible bottom sheet.
+     * @param result Data to pass to the bottom sheet instance.
+     */
+    dismiss<R = any>(result?: R): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatBottomSheet, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MatBottomSheet>;
+}
+
+export { MAT_BOTTOM_SHEET_DATA, MAT_BOTTOM_SHEET_DEFAULT_OPTIONS, MatBottomSheet, MatBottomSheetConfig, MatBottomSheetContainer, MatBottomSheetModule, MatBottomSheetRef };
+export type { AutoFocusTarget };

package/types/button-testing.d.ts

@@ -0,0 +1,70 @@
+import { BaseHarnessFilters, ContentContainerComponentHarness, ComponentHarnessConstructor, HarnessPredicate } from '@angular/cdk/testing';
+
+/** Possible button variants. */
+type ButtonVariant = 'basic' | 'icon' | 'fab' | 'mini-fab';
+/** Possible button appearances. */
+type ButtonAppearance = 'text' | 'filled' | 'elevated' | 'outlined' | 'tonal';
+/** Possible button types. */
+type ButtonType = 'button' | 'submit' | 'reset';
+/** A set of criteria that can be used to filter a list of button harness instances. */
+interface ButtonHarnessFilters extends BaseHarnessFilters {
+    /** Only find instances whose text matches the given value. */
+    text?: string | RegExp;
+    /** Only find instances with a variant. */
+    variant?: ButtonVariant;
+    /** Only find instances with a specific appearance. */
+    appearance?: ButtonAppearance;
+    /** Only find instances which match the given disabled state. */
+    disabled?: boolean;
+    /** Only find instances with the specified type. */
+    buttonType?: ButtonType;
+    /** Only find instances that contain an icon whose name matches the given value. */
+    iconName?: string | RegExp;
+}
+
+/** Harness for interacting with a mat-button in tests. */
+declare class MatButtonHarness extends ContentContainerComponentHarness {
+    /** Selector for the harness. */
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a button with specific attributes.
+     * @param options Options for narrowing the search:
+     *   - `selector` finds a button whose host element matches the given selector.
+     *   - `text` finds a button with specific text content.
+     *   - `variant` finds buttons matching a specific variant.
+     *   - `appearance` finds buttons matching a specific appearance.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with<T extends MatButtonHarness>(this: ComponentHarnessConstructor<T>, options?: ButtonHarnessFilters): HarnessPredicate<T>;
+    /**
+     * Clicks the button at the given position relative to its top-left.
+     * @param relativeX The relative x position of the click.
+     * @param relativeY The relative y position of the click.
+     */
+    click(relativeX: number, relativeY: number): Promise<void>;
+    /** Clicks the button at its center. */
+    click(location: 'center'): Promise<void>;
+    /** Clicks the button. */
+    click(): Promise<void>;
+    /** Gets a boolean promise indicating if the button is disabled. */
+    isDisabled(): Promise<boolean>;
+    /** Gets a promise for the button's label text. */
+    getText(): Promise<string>;
+    /** Focuses the button and returns a void promise that indicates when the action is complete. */
+    focus(): Promise<void>;
+    /** Blurs the button and returns a void promise that indicates when the action is complete. */
+    blur(): Promise<void>;
+    /** Whether the button is focused. */
+    isFocused(): Promise<boolean>;
+    /** Gets the variant of the button. */
+    getVariant(): Promise<ButtonVariant>;
+    /** Gets the appearance of the button. */
+    getAppearance(): Promise<ButtonAppearance | null>;
+    /**
+     * Gets the type of the button. Supported values are 'button', 'submit', and 'reset'.
+     */
+    getType(): Promise<ButtonType | null>;
+}
+
+export { MatButtonHarness };
+export type { ButtonAppearance, ButtonHarnessFilters, ButtonType, ButtonVariant };

package/types/button-toggle-testing.d.ts

@@ -0,0 +1,97 @@
+import { BaseHarnessFilters, ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+import { MatButtonToggleAppearance } from './_button-toggle-chunk.js';
+import '@angular/cdk/bidi';
+import '@angular/core';
+import '@angular/forms';
+
+/** Criteria that can be used to filter a list of `MatButtonToggleHarness` instances. */
+interface ButtonToggleHarnessFilters extends BaseHarnessFilters {
+    /** Only find instances whose text matches the given value. */
+    text?: string | RegExp;
+    /** Only find instances whose name matches the given value. */
+    name?: string | RegExp;
+    /** Only find instances that are checked. */
+    checked?: boolean;
+    /** Only find instances which match the given disabled state. */
+    disabled?: boolean;
+}
+
+/** Harness for interacting with a standard mat-button-toggle in tests. */
+declare class MatButtonToggleHarness extends ComponentHarness {
+    /** The selector for the host element of a `MatButton` instance. */
+    static hostSelector: string;
+    private _label;
+    private _button;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `MatButtonToggleHarness` that meets
+     * certain criteria.
+     * @param options Options for filtering which button toggle instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options?: ButtonToggleHarnessFilters): HarnessPredicate<MatButtonToggleHarness>;
+    /** Gets a boolean promise indicating if the button toggle is checked. */
+    isChecked(): Promise<boolean>;
+    /** Gets a boolean promise indicating if the button toggle is disabled. */
+    isDisabled(): Promise<boolean>;
+    /** Gets a promise for the button toggle's name. */
+    getName(): Promise<string | null>;
+    /** Gets a promise for the button toggle's aria-label. */
+    getAriaLabel(): Promise<string | null>;
+    /** Gets a promise for the button toggles's aria-labelledby. */
+    getAriaLabelledby(): Promise<string | null>;
+    /** Gets a promise for the button toggle's text. */
+    getText(): Promise<string>;
+    /** Gets the appearance that the button toggle is using. */
+    getAppearance(): Promise<MatButtonToggleAppearance>;
+    /** Focuses the toggle. */
+    focus(): Promise<void>;
+    /** Blurs the toggle. */
+    blur(): Promise<void>;
+    /** Whether the toggle is focused. */
+    isFocused(): Promise<boolean>;
+    /** Toggle the checked state of the buttons toggle. */
+    toggle(): Promise<void>;
+    /**
+     * Puts the button toggle in a checked state by toggling it if it's
+     * currently unchecked, or doing nothing if it is already checked.
+     */
+    check(): Promise<void>;
+    /**
+     * Puts the button toggle in an unchecked state by toggling it if it's
+     * currently checked, or doing nothing if it's already unchecked.
+     */
+    uncheck(): Promise<void>;
+}
+
+/** Criteria that can be used to filter a list of `MatButtonToggleGroupHarness` instances. */
+interface ButtonToggleGroupHarnessFilters extends BaseHarnessFilters {
+    /** Only find instances which match the given disabled state. */
+    disabled?: boolean;
+}
+
+/** Harness for interacting with a standard mat-button-toggle in tests. */
+declare class MatButtonToggleGroupHarness extends ComponentHarness {
+    /** The selector for the host element of a `MatButton` instance. */
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `MatButtonToggleGroupHarness`
+     * that meets certain criteria.
+     * @param options Options for filtering which button toggle instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options?: ButtonToggleGroupHarnessFilters): HarnessPredicate<MatButtonToggleGroupHarness>;
+    /**
+     * Gets the button toggles that are inside the group.
+     * @param filter Optionally filters which toggles are included.
+     */
+    getToggles(filter?: ButtonToggleHarnessFilters): Promise<MatButtonToggleHarness[]>;
+    /** Gets whether the button toggle group is disabled. */
+    isDisabled(): Promise<boolean>;
+    /** Gets whether the button toggle group is laid out vertically. */
+    isVertical(): Promise<boolean>;
+    /** Gets the appearance that the group is using. */
+    getAppearance(): Promise<MatButtonToggleAppearance>;
+}
+
+export { MatButtonToggleGroupHarness, MatButtonToggleHarness };
+export type { ButtonToggleGroupHarnessFilters, ButtonToggleHarnessFilters };

package/types/button-toggle.d.ts

@@ -0,0 +1,16 @@
+import { MatButtonToggleGroup, MatButtonToggle } from './_button-toggle-chunk.js';
+export { MAT_BUTTON_TOGGLE_DEFAULT_OPTIONS, MAT_BUTTON_TOGGLE_GROUP, MAT_BUTTON_TOGGLE_GROUP_VALUE_ACCESSOR, MatButtonToggleAppearance, MatButtonToggleChange, MatButtonToggleDefaultOptions, ToggleType } from './_button-toggle-chunk.js';
+import * as i0 from '@angular/core';
+import { MatRippleModule } from './_ripple-module-chunk.js';
+import * as i2 from '@angular/cdk/bidi';
+import '@angular/forms';
+import './_ripple-chunk.js';
+import '@angular/cdk/platform';
+
+declare class MatButtonToggleModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatButtonToggleModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatButtonToggleModule, never, [typeof MatRippleModule, typeof MatButtonToggleGroup, typeof MatButtonToggle], [typeof i2.BidiModule, typeof MatButtonToggleGroup, typeof MatButtonToggle]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatButtonToggleModule>;
+}
+
+export { MatButtonToggle, MatButtonToggleGroup, MatButtonToggleModule };

package/types/button.d.ts

@@ -0,0 +1,210 @@
+import { FocusOrigin } from '@angular/cdk/a11y';
+import * as i0 from '@angular/core';
+import { InjectionToken, AfterViewInit, OnDestroy, ElementRef, NgZone } from '@angular/core';
+import { ThemePalette } from './_palette-chunk.js';
+import { MatRippleLoader } from './_ripple-loader-chunk.js';
+import { MatRippleModule } from './_ripple-module-chunk.js';
+import * as i2 from '@angular/cdk/bidi';
+import './_ripple-chunk.js';
+import '@angular/cdk/platform';
+
+/**
+ * Possible appearances for a `MatButton`.
+ * See https://m3.material.io/components/buttons/overview
+ */
+type MatButtonAppearance = 'text' | 'filled' | 'elevated' | 'outlined' | 'tonal';
+/** Object that can be used to configure the default options for the button component. */
+interface MatButtonConfig {
+    /** Whether disabled buttons should be interactive. */
+    disabledInteractive?: boolean;
+    /** Default palette color to apply to buttons. */
+    color?: ThemePalette;
+    /** Default appearance for plain buttons (not icon buttons or FABs). */
+    defaultAppearance?: MatButtonAppearance;
+}
+/** Injection token that can be used to provide the default options the button component. */
+declare const MAT_BUTTON_CONFIG: InjectionToken<MatButtonConfig>;
+/** Base class for all buttons. */
+declare class MatButtonBase implements AfterViewInit, OnDestroy {
+    _elementRef: ElementRef<HTMLElement>;
+    protected _ngZone: NgZone;
+    protected _animationsDisabled: boolean;
+    protected readonly _config: MatButtonConfig | null;
+    private readonly _focusMonitor;
+    private _cleanupClick;
+    private _renderer;
+    /**
+     * Handles the lazy creation of the MatButton ripple.
+     * Used to improve initial load time of large applications.
+     */
+    protected _rippleLoader: MatRippleLoader;
+    /** Whether the button is set on an anchor node. */
+    protected _isAnchor: boolean;
+    /** Whether this button is a FAB. Used to apply the correct class on the ripple. */
+    protected _isFab: boolean;
+    /**
+     * Theme color of the button. This API is supported in M2 themes only, it has
+     * no effect in M3 themes. For color customization in M3, see https://material.angular.dev/components/button/styling.
+     *
+     * For information on applying color variants in M3, see
+     * https://material.angular.dev/guide/material-2-theming#optional-add-backwards-compatibility-styles-for-color-variants
+     */
+    color?: string | null;
+    /** Whether the ripple effect is disabled or not. */
+    get disableRipple(): boolean;
+    set disableRipple(value: any);
+    private _disableRipple;
+    /** Whether the button is disabled. */
+    get disabled(): boolean;
+    set disabled(value: any);
+    private _disabled;
+    /** `aria-disabled` value of the button. */
+    ariaDisabled: boolean | undefined;
+    /**
+     * Natively disabled buttons prevent focus and any pointer events from reaching the button.
+     * In some scenarios this might not be desirable, because it can prevent users from finding out
+     * why the button is disabled (e.g. via tooltip). This is also useful for buttons that may
+     * become disabled when activated, which would cause focus to be transferred to the document
+     * body instead of remaining on the button.
+     *
+     * Enabling this input will change the button so that it is styled to be disabled and will be
+     * marked as `aria-disabled`, but it will allow the button to receive events and focus.
+     *
+     * Note that by enabling this, you need to set the `tabindex` yourself if the button isn't
+     * meant to be tabbable and you have to prevent the button action (e.g. form submissions).
+     */
+    disabledInteractive: boolean;
+    /** Tab index for the button. */
+    tabIndex: number;
+    /**
+     * Backwards-compatibility input that handles pre-existing `[tabindex]` bindings.
+     * @docs-private
+     */
+    set _tabindex(value: number);
+    constructor(...args: unknown[]);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /** Focuses the button. */
+    focus(origin?: FocusOrigin, options?: FocusOptions): void;
+    protected _getAriaDisabled(): boolean | null;
+    protected _getDisabledAttribute(): true | null;
+    private _updateRippleDisabled;
+    protected _getTabIndex(): number;
+    private _setupAsAnchor;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatButtonBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatButtonBase, never, never, { "color": { "alias": "color"; "required": false; }; "disableRipple": { "alias": "disableRipple"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "ariaDisabled": { "alias": "aria-disabled"; "required": false; }; "disabledInteractive": { "alias": "disabledInteractive"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "_tabindex": { "alias": "tabindex"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_disableRipple: unknown;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_ariaDisabled: unknown;
+    static ngAcceptInputType_disabledInteractive: unknown;
+    static ngAcceptInputType_tabIndex: unknown;
+    static ngAcceptInputType__tabindex: unknown;
+}
+
+/**
+ * Material Design button component. Users interact with a button to perform an action.
+ * See https://m3.material.io/components/buttons/overview
+ */
+declare class MatButton extends MatButtonBase {
+    /** Appearance of the button. */
+    get appearance(): MatButtonAppearance | null;
+    set appearance(value: MatButtonAppearance | '');
+    private _appearance;
+    constructor(...args: unknown[]);
+    /** Programmatically sets the appearance of the button. */
+    setAppearance(appearance: MatButtonAppearance): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatButton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatButton, "    button[matButton], a[matButton], button[mat-button], button[mat-raised-button],    button[mat-flat-button], button[mat-stroked-button], a[mat-button], a[mat-raised-button],    a[mat-flat-button], a[mat-stroked-button]  ", ["matButton", "matAnchor"], { "appearance": { "alias": "matButton"; "required": false; }; }, {}, never, [".material-icons:not([iconPositionEnd]), mat-icon:not([iconPositionEnd]), [matButtonIcon]:not([iconPositionEnd])", "*", ".material-icons[iconPositionEnd], mat-icon[iconPositionEnd], [matButtonIcon][iconPositionEnd]"], true, never>;
+}
+/**
+ * Material Design button component for anchor elements. Anchor elements are used to provide
+ * links for the user to navigate across different routes or pages.
+ * See https://m3.material.io/components/buttons/overview
+ */
+declare const MatAnchor: typeof MatButton;
+type MatAnchor = MatButton;
+
+/** Default FAB options that can be overridden. */
+interface MatFabDefaultOptions {
+    /**
+     * Default theme color of the button. This API is supported in M2 themes
+     * only, it has no effect in M3 themes. For color customization in M3, see https://material.angular.dev/components/button/styling.
+     *
+     * For information on applying color variants in M3, see
+     * https://material.angular.dev/guide/material-2-theming#optional-add-backwards-compatibility-styles-for-color-variants.
+     */
+    color?: ThemePalette;
+}
+/** Injection token to be used to override the default options for FAB. */
+declare const MAT_FAB_DEFAULT_OPTIONS: InjectionToken<MatFabDefaultOptions>;
+/**
+ * Material Design floating action button (FAB) component. These buttons represent the primary
+ * or most common action for users to interact with.
+ * See https://m3.material.io/components/floating-action-button/overview
+ *
+ * The `MatFabButton` class has two appearances: normal and extended.
+ */
+declare class MatFabButton extends MatButtonBase {
+    private _options;
+    _isFab: boolean;
+    extended: boolean;
+    constructor(...args: unknown[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatFabButton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatFabButton, "button[mat-fab], a[mat-fab], button[matFab], a[matFab]", ["matButton", "matAnchor"], { "extended": { "alias": "extended"; "required": false; }; }, {}, never, [".material-icons:not([iconPositionEnd]), mat-icon:not([iconPositionEnd]), [matButtonIcon]:not([iconPositionEnd])", "*", ".material-icons[iconPositionEnd], mat-icon[iconPositionEnd], [matButtonIcon][iconPositionEnd]"], true, never>;
+    static ngAcceptInputType_extended: unknown;
+}
+/**
+ * Material Design mini floating action button (FAB) component. These buttons represent the primary
+ * or most common action for users to interact with.
+ * See https://m3.material.io/components/floating-action-button/overview
+ */
+declare class MatMiniFabButton extends MatButtonBase {
+    private _options;
+    _isFab: boolean;
+    constructor(...args: unknown[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatMiniFabButton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatMiniFabButton, "button[mat-mini-fab], a[mat-mini-fab], button[matMiniFab], a[matMiniFab]", ["matButton", "matAnchor"], {}, {}, never, [".material-icons:not([iconPositionEnd]), mat-icon:not([iconPositionEnd]), [matButtonIcon]:not([iconPositionEnd])", "*", ".material-icons[iconPositionEnd], mat-icon[iconPositionEnd], [matButtonIcon][iconPositionEnd]"], true, never>;
+}
+/**
+ * Material Design floating action button (FAB) component for anchor elements. Anchor elements
+ * are used to provide links for the user to navigate across different routes or pages.
+ * See https://m3.material.io/components/floating-action-button/overview
+ *
+ * The `MatFabAnchor` class has two appearances: normal and extended.
+ */
+declare const MatFabAnchor: typeof MatFabButton;
+type MatFabAnchor = MatFabButton;
+/**
+ * Material Design mini floating action button (FAB) component for anchor elements. Anchor elements
+ * are used to provide links for the user to navigate across different routes or pages.
+ * See https://m3.material.io/components/floating-action-button/overview
+ */
+declare const MatMiniFabAnchor: typeof MatMiniFabButton;
+type MatMiniFabAnchor = MatMiniFabButton;
+
+/**
+ * Material Design icon button component. This type of button displays a single interactive icon for
+ * users to perform an action.
+ * See https://material.io/develop/web/components/buttons/icon-buttons/
+ */
+declare class MatIconButton extends MatButtonBase {
+    constructor(...args: unknown[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatIconButton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatIconButton, "button[mat-icon-button], a[mat-icon-button], button[matIconButton], a[matIconButton]", ["matButton", "matAnchor"], {}, {}, never, ["*"], true, never>;
+}
+/**
+ * Material Design icon button component for anchor elements. This button displays a single
+ * interaction icon that allows users to navigate across different routes or pages.
+ * See https://material.io/develop/web/components/buttons/icon-buttons/
+ */
+declare const MatIconAnchor: typeof MatIconButton;
+type MatIconAnchor = MatIconButton;
+
+declare class MatButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatButtonModule, never, [typeof MatRippleModule, typeof MatButton, typeof MatMiniFabButton, typeof MatIconButton, typeof MatFabButton], [typeof i2.BidiModule, typeof MatButton, typeof MatMiniFabButton, typeof MatIconButton, typeof MatFabButton]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatButtonModule>;
+}
+
+export { MAT_BUTTON_CONFIG, MAT_FAB_DEFAULT_OPTIONS, MatAnchor, MatButton, MatButtonModule, MatFabAnchor, MatFabButton, MatIconAnchor, MatIconButton, MatMiniFabAnchor, MatMiniFabButton };
+export type { MatButtonAppearance, MatButtonConfig, MatFabDefaultOptions };

package/types/card-testing.d.ts

@@ -0,0 +1,41 @@
+import { BaseHarnessFilters, ContentContainerComponentHarness, ComponentHarnessConstructor, HarnessPredicate } from '@angular/cdk/testing';
+
+/** A set of criteria that can be used to filter a list of `MatCardHarness` instances. */
+interface CardHarnessFilters extends BaseHarnessFilters {
+    /** Only find instances whose text matches the given value. */
+    text?: string | RegExp;
+    /** Only find instances whose title matches the given value. */
+    title?: string | RegExp;
+    /** Only find instances whose subtitle matches the given value. */
+    subtitle?: string | RegExp;
+}
+
+/** Selectors for different sections of the mat-card that can container user content. */
+declare enum MatCardSection {
+    HEADER = ".mat-mdc-card-header",
+    CONTENT = ".mat-mdc-card-content",
+    ACTIONS = ".mat-mdc-card-actions",
+    FOOTER = ".mat-mdc-card-footer"
+}
+/** Harness for interacting with a mat-card in tests. */
+declare class MatCardHarness extends ContentContainerComponentHarness<MatCardSection> {
+    /** The selector for the host element of a `MatCard` instance. */
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a card with specific attributes.
+     * @param options Options for filtering which card instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with<T extends MatCardHarness>(this: ComponentHarnessConstructor<T>, options?: CardHarnessFilters): HarnessPredicate<T>;
+    private _title;
+    private _subtitle;
+    /** Gets all of the card's content as text. */
+    getText(): Promise<string>;
+    /** Gets the cards's title text. */
+    getTitleText(): Promise<string>;
+    /** Gets the cards's subtitle text. */
+    getSubtitleText(): Promise<string>;
+}
+
+export { MatCardHarness, MatCardSection };
+export type { CardHarnessFilters };