@depup/angular__material 21.2.2-depup.19

package/types/timepicker-testing.d.ts

@@ -0,0 +1,108 @@
+import { BaseHarnessFilters, ComponentHarness, ComponentHarnessConstructor, HarnessPredicate } from '@angular/cdk/testing';
+import { OptionHarnessFilters, MatOptionHarness } from './_option-harness-chunk.js';
+
+/** A set of criteria that can be used to filter a list of `MatTimepickerHarness` instances. */
+interface TimepickerHarnessFilters extends BaseHarnessFilters {
+}
+/** A set of criteria that can be used to filter a list of timepicker input instances. */
+interface TimepickerInputHarnessFilters extends BaseHarnessFilters {
+    /** Filters based on the value of the input. */
+    value?: string | RegExp;
+    /** Filters based on the placeholder text of the input. */
+    placeholder?: string | RegExp;
+}
+/** A set of criteria that can be used to filter a list of timepicker toggle instances. */
+interface TimepickerToggleHarnessFilters extends BaseHarnessFilters {
+}
+
+declare class MatTimepickerHarness extends ComponentHarness {
+    private _documentRootLocator;
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a timepicker with specific
+     * attributes.
+     * @param options Options for filtering which timepicker instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with<T extends MatTimepickerHarness>(this: ComponentHarnessConstructor<T>, options?: TimepickerHarnessFilters): HarnessPredicate<T>;
+    /** Whether the timepicker is open. */
+    isOpen(): Promise<boolean>;
+    /** Gets the options inside the timepicker panel. */
+    getOptions(filters?: Omit<OptionHarnessFilters, 'ancestor'>): Promise<MatOptionHarness[]>;
+    /** Selects the first option matching the given filters. */
+    selectOption(filters: OptionHarnessFilters): Promise<void>;
+    /** Gets the selector that can be used to find the timepicker's panel. */
+    protected _getPanelSelector(): Promise<string>;
+}
+
+/** Harness for interacting with a standard Material timepicker inputs in tests. */
+declare class MatTimepickerInputHarness extends ComponentHarness {
+    private _documentRootLocator;
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `MatTimepickerInputHarness`
+     * that meets certain criteria.
+     * @param options Options for filtering which input instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with<T extends MatTimepickerInputHarness>(this: ComponentHarnessConstructor<T>, options?: TimepickerInputHarnessFilters): HarnessPredicate<T>;
+    /** Gets whether the timepicker associated with the input is open. */
+    isTimepickerOpen(): Promise<boolean>;
+    /** Opens the timepicker associated with the input and returns the timepicker instance. */
+    openTimepicker(): Promise<MatTimepickerHarness>;
+    /** Closes the timepicker associated with the input. */
+    closeTimepicker(): Promise<void>;
+    /**
+     * Gets the `MatTimepickerHarness` that is associated with the input.
+     * @param filter Optionally filters which timepicker is included.
+     */
+    getTimepicker(filter?: TimepickerHarnessFilters): Promise<MatTimepickerHarness>;
+    /** Whether the input is disabled. */
+    isDisabled(): Promise<boolean>;
+    /** Whether the input is required. */
+    isRequired(): Promise<boolean>;
+    /** Gets the value of the input. */
+    getValue(): Promise<string>;
+    /**
+     * Sets the value of the input. The value will be set by simulating
+     * keypresses that correspond to the given value.
+     */
+    setValue(newValue: string): Promise<void>;
+    /** Gets the placeholder of the input. */
+    getPlaceholder(): Promise<string>;
+    /**
+     * Focuses the input and returns a promise that indicates when the
+     * action is complete.
+     */
+    focus(): Promise<void>;
+    /**
+     * Blurs the input and returns a promise that indicates when the
+     * action is complete.
+     */
+    blur(): Promise<void>;
+    /** Whether the input is focused. */
+    isFocused(): Promise<boolean>;
+}
+
+/** Harness for interacting with a standard Material timepicker toggle in tests. */
+declare class MatTimepickerToggleHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** The clickable button inside the toggle. */
+    private _button;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `MatTimepickerToggleHarness` that
+     * meets certain criteria.
+     * @param options Options for filtering which timepicker toggle instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options?: TimepickerToggleHarnessFilters): HarnessPredicate<MatTimepickerToggleHarness>;
+    /** Opens the timepicker associated with the toggle. */
+    openTimepicker(): Promise<void>;
+    /** Gets whether the timepicker associated with the toggle is open. */
+    isTimepickerOpen(): Promise<boolean>;
+    /** Whether the toggle is disabled. */
+    isDisabled(): Promise<boolean>;
+}
+
+export { MatTimepickerHarness, MatTimepickerInputHarness, MatTimepickerToggleHarness };
+export type { TimepickerHarnessFilters, TimepickerInputHarnessFilters, TimepickerToggleHarnessFilters };

package/types/timepicker.d.ts

@@ -0,0 +1,318 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, Signal, ElementRef, OnDestroy, TemplateRef, InputSignalWithTransform, InputSignal, OutputEmitterRef, ModelSignal } from '@angular/core';
+import { MatOption } from './_option-chunk.js';
+import { MatOptionParentComponent } from './_option-parent-chunk.js';
+import { ScrollStrategy } from '@angular/cdk/overlay';
+import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors } from '@angular/forms';
+import * as i1 from '@angular/cdk/scrolling';
+import '@angular/cdk/a11y';
+import 'rxjs';
+
+/**
+ * Object that can be used to configure the default options for the timepicker component.
+ */
+interface MatTimepickerConfig {
+    /** Default interval for all time pickers. */
+    interval?: string | number;
+    /** Whether ripples inside the timepicker should be disabled by default. */
+    disableRipple?: boolean;
+}
+/**
+ * Injection token that can be used to configure the default options for the timepicker component.
+ */
+declare const MAT_TIMEPICKER_CONFIG: InjectionToken<MatTimepickerConfig>;
+/**
+ * Time selection option that can be displayed within a `mat-timepicker`.
+ */
+interface MatTimepickerOption<D = unknown> {
+    /** Date value of the option. */
+    value: D;
+    /** Label to show to the user. */
+    label: string;
+}
+
+/** Event emitted when a value is selected in the timepicker. */
+interface MatTimepickerSelected<D> {
+    value: D;
+    source: MatTimepicker<D>;
+}
+/** Injection token used to configure the behavior of the timepicker dropdown while scrolling. */
+declare const MAT_TIMEPICKER_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
+/** Represents an input that is connected to a `mat-timepicker`. */
+interface MatTimepickerConnectedInput<D> {
+    /** Current value of the input. */
+    value: Signal<D | null>;
+    /** Minimum allowed time. */
+    min: Signal<D | null>;
+    /** Maximum allowed time. */
+    max: Signal<D | null>;
+    /** Whether the input is disabled. */
+    disabled: Signal<boolean>;
+    /** Focuses the input. */
+    focus(): void;
+    /** Gets the element to which to connect the timepicker overlay. */
+    getOverlayOrigin(): ElementRef<HTMLElement>;
+    /** Gets the ID of the input's label. */
+    getLabelId(): string | null;
+    /** Callback invoked when the timepicker assigns a value. */
+    timepickerValueAssigned(value: D | null): void;
+}
+/**
+ * Renders out a listbox that can be used to select a time of day.
+ * Intended to be used together with `MatTimepickerInput`.
+ */
+declare class MatTimepicker<D> implements OnDestroy, MatOptionParentComponent {
+    private _dir;
+    private _viewContainerRef;
+    private _injector;
+    private _defaultConfig;
+    private _dateAdapter;
+    private _dateFormats;
+    private _scrollStrategyFactory;
+    protected _animationsDisabled: boolean;
+    private _isOpen;
+    private _activeDescendant;
+    private _input;
+    private _overlayRef;
+    private _portal;
+    private _optionsCacheKey;
+    private _localeChanges;
+    private _onOpenRender;
+    protected _panelTemplate: Signal<TemplateRef<unknown>>;
+    protected _timeOptions: readonly MatTimepickerOption<D>[];
+    protected _options: Signal<readonly MatOption<any>[]>;
+    private _keyManager;
+    /**
+     * Interval between each option in the timepicker. The value can either be an amount of
+     * seconds (e.g. 90) or a number with a unit (e.g. 45m). Supported units are `s` for seconds,
+     * `m` for minutes or `h` for hours.
+     */
+    readonly interval: InputSignalWithTransform<number | null, number | string | null>;
+    /**
+     * Array of pre-defined options that the user can select from, as an alternative to using the
+     * `interval` input. An error will be thrown if both `options` and `interval` are specified.
+     */
+    readonly options: InputSignal<readonly MatTimepickerOption<D>[] | null>;
+    /** Whether the timepicker is open. */
+    readonly isOpen: Signal<boolean>;
+    /** Emits when the user selects a time. */
+    readonly selected: OutputEmitterRef<MatTimepickerSelected<D>>;
+    /** Emits when the timepicker is opened. */
+    readonly opened: OutputEmitterRef<void>;
+    /** Emits when the timepicker is closed. */
+    readonly closed: OutputEmitterRef<void>;
+    /** ID of the active descendant option. */
+    readonly activeDescendant: Signal<string | null>;
+    /** Unique ID of the timepicker's panel */
+    readonly panelId: string;
+    /** Whether ripples within the timepicker should be disabled. */
+    readonly disableRipple: InputSignalWithTransform<boolean, unknown>;
+    /** ARIA label for the timepicker panel. */
+    readonly ariaLabel: InputSignal<string | null>;
+    /** ID of the label element for the timepicker panel. */
+    readonly ariaLabelledby: InputSignal<string | null>;
+    /** Whether the timepicker is currently disabled. */
+    readonly disabled: Signal<boolean>;
+    /** Classes to be passed to the timepicker panel. */
+    readonly panelClass: InputSignal<string | string[] | undefined>;
+    constructor();
+    /** Opens the timepicker. */
+    open(): void;
+    /** Closes the timepicker. */
+    close(): void;
+    /** Registers an input with the timepicker. */
+    registerInput(input: MatTimepickerConnectedInput<D>): void;
+    ngOnDestroy(): void;
+    _getOverlayHost(): HTMLElement | undefined;
+    /** Selects a specific time value. */
+    protected _selectValue(option: MatOption<D>): void;
+    /** Gets the value of the `aria-labelledby` attribute. */
+    protected _getAriaLabelledby(): string | null;
+    /** Handles animation events coming from the panel. */
+    protected _handleAnimationEnd(event: AnimationEvent): void;
+    /** Creates an overlay reference for the timepicker panel. */
+    private _getOverlayRef;
+    /** Generates the list of options from which the user can select.. */
+    private _generateOptions;
+    /**
+     * Synchronizes the internal state of the component based on a specific selected date.
+     * @param value Currently selected date.
+     * @param options Options rendered out in the timepicker.
+     * @param fallback Option to set as active if no option is selected.
+     */
+    private _syncSelectedState;
+    /** Handles keyboard events while the overlay is open. */
+    private _handleKeydown;
+    /** Sets up the logic that updates the timepicker when the locale changes. */
+    private _handleLocaleChanges;
+    /**
+     * Sets up the logic that updates the timepicker when the state of the connected input changes.
+     */
+    private _handleInputStateChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatTimepicker<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatTimepicker<any>, "mat-timepicker", ["matTimepicker"], { "interval": { "alias": "interval"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "disableRipple": { "alias": "disableRipple"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "panelClass": { "alias": "panelClass"; "required": false; "isSignal": true; }; }, { "selected": "selected"; "opened": "opened"; "closed": "closed"; }, never, never, true, never>;
+}
+
+/**
+ * Input that can be used to enter time and connect to a `mat-timepicker`.
+ */
+declare class MatTimepickerInput<D> implements MatTimepickerConnectedInput<D>, ControlValueAccessor, Validator, OnDestroy {
+    private _elementRef;
+    private _dateAdapter;
+    private _dateFormats;
+    private _formField;
+    private _onChange;
+    private _onTouched;
+    private _validatorOnChange;
+    private _cleanupClick;
+    private _accessorDisabled;
+    private _localeSubscription;
+    private _timepickerSubscription;
+    private _validator;
+    private _lastValueValid;
+    private _minValid;
+    private _maxValid;
+    private _lastValidDate;
+    /** Value of the `aria-activedescendant` attribute. */
+    protected readonly _ariaActiveDescendant: Signal<string | null>;
+    /** Value of the `aria-expanded` attribute. */
+    protected readonly _ariaExpanded: Signal<string>;
+    /** Value of the `aria-controls` attribute. */
+    protected readonly _ariaControls: Signal<string | null>;
+    /** Current value of the input. */
+    readonly value: ModelSignal<D | null>;
+    /** Timepicker that the input is associated with. */
+    readonly timepicker: InputSignal<MatTimepicker<D>>;
+    /**
+     * Minimum time that can be selected or typed in. Can be either
+     * a date object (only time will be used) or a valid time string.
+     */
+    readonly min: InputSignalWithTransform<D | null, unknown>;
+    /**
+     * Maximum time that can be selected or typed in. Can be either
+     * a date object (only time will be used) or a valid time string.
+     */
+    readonly max: InputSignalWithTransform<D | null, unknown>;
+    /**
+     * Whether to open the timepicker overlay when clicking on the input. Enabled by default.
+     * Note that when disabling this option, you'll have to provide your own logic for opening
+     * the overlay.
+     */
+    readonly openOnClick: InputSignalWithTransform<boolean, unknown>;
+    /** Whether the input is disabled. */
+    readonly disabled: Signal<boolean>;
+    /**
+     * Whether the input should be disabled through the template.
+     * @docs-private
+     */
+    readonly disabledInput: InputSignalWithTransform<boolean, unknown>;
+    constructor();
+    /**
+     * Implemented as a part of `ControlValueAccessor`.
+     * @docs-private
+     */
+    writeValue(value: unknown): void;
+    /**
+     * Implemented as a part of `ControlValueAccessor`.
+     * @docs-private
+     */
+    registerOnChange(fn: (value: unknown) => void): void;
+    /**
+     * Implemented as a part of `ControlValueAccessor`.
+     * @docs-private
+     */
+    registerOnTouched(fn: () => void): void;
+    /**
+     * Implemented as a part of `ControlValueAccessor`.
+     * @docs-private
+     */
+    setDisabledState(isDisabled: boolean): void;
+    /**
+     * Implemented as a part of `Validator`.
+     * @docs-private
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    /**
+     * Implemented as a part of `Validator`.
+     * @docs-private
+     */
+    registerOnValidatorChange(fn: () => void): void;
+    /** Gets the element to which the timepicker popup should be attached. */
+    getOverlayOrigin(): ElementRef<HTMLElement>;
+    /** Focuses the input. */
+    focus(): void;
+    ngOnDestroy(): void;
+    /** Gets the ID of the input's label. */
+    getLabelId(): string | null;
+    /** Handles clicks on the input or the containing form field. */
+    private _handleClick;
+    /** Handles the `input` event. */
+    protected _handleInput(event: Event): void;
+    /** Handles the `blur` event. */
+    protected _handleBlur(): void;
+    /** Handles the `keydown` event. */
+    protected _handleKeydown(event: KeyboardEvent): void;
+    /** Called by the timepicker to sync up the user-selected value. */
+    timepickerValueAssigned(value: D | null): void;
+    /** Sets up the code that keeps the input state in sync with the forms module. */
+    private _updateFormsState;
+    /** Sets up the logic that registers the input with the timepicker. */
+    private _registerTimepicker;
+    /**
+     * Assigns a value set by the user to the input's model.
+     * @param selection Time selected by the user that should be assigned.
+     * @param propagateToAccessor Whether the value should be propagated to the ControlValueAccessor.
+     */
+    private _assignUserSelection;
+    /** Formats the current value and assigns it to the input. */
+    private _formatValue;
+    /** Checks whether a value is valid. */
+    private _isValid;
+    /** Transforms an arbitrary value into a value that can be assigned to a date-based input. */
+    private _transformDateInput;
+    /** Whether the input is currently focused. */
+    private _hasFocus;
+    /** Gets a function that can be used to validate the input. */
+    private _getValidator;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatTimepickerInput<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatTimepickerInput<any>, "input[matTimepicker]", ["matTimepickerInput"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "timepicker": { "alias": "matTimepicker"; "required": true; "isSignal": true; }; "min": { "alias": "matTimepickerMin"; "required": false; "isSignal": true; }; "max": { "alias": "matTimepickerMax"; "required": false; "isSignal": true; }; "openOnClick": { "alias": "matTimepickerOpenOnClick"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/** Button that can be used to open a `mat-timepicker`. */
+declare class MatTimepickerToggle<D> {
+    private _defaultConfig;
+    private _defaultTabIndex;
+    protected _isDisabled: i0.Signal<boolean>;
+    /** Timepicker instance that the button will toggle. */
+    readonly timepicker: InputSignal<MatTimepicker<D>>;
+    /** Screen-reader label for the button. */
+    readonly ariaLabel: InputSignal<string | undefined>;
+    /** Screen-reader labelled by id for the button. */
+    readonly ariaLabelledby: InputSignal<string | undefined>;
+    /** Default aria-label for the toggle if none is provided. */
+    private readonly _defaultAriaLabel;
+    /** Whether the toggle button is disabled. */
+    readonly disabled: InputSignalWithTransform<boolean, unknown>;
+    /** Tabindex for the toggle. */
+    readonly tabIndex: InputSignal<number | null>;
+    /** Whether ripples on the toggle should be disabled. */
+    readonly disableRipple: InputSignalWithTransform<boolean, unknown>;
+    /** Opens the connected timepicker. */
+    protected _open(event: Event): void;
+    /**
+     * Checks for ariaLabelledby and if empty uses custom
+     * aria-label or defaultAriaLabel if neither is provided.
+     */
+    getAriaLabel(): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatTimepickerToggle<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatTimepickerToggle<any>, "mat-timepicker-toggle", ["matTimepickerToggle"], { "timepicker": { "alias": "for"; "required": true; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "tabIndex": { "alias": "tabIndex"; "required": false; "isSignal": true; }; "disableRipple": { "alias": "disableRipple"; "required": false; "isSignal": true; }; }, {}, never, ["[matTimepickerToggleIcon]"], true, never>;
+}
+
+declare class MatTimepickerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatTimepickerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatTimepickerModule, never, [typeof MatTimepicker, typeof MatTimepickerInput, typeof MatTimepickerToggle], [typeof i1.CdkScrollableModule, typeof MatTimepicker, typeof MatTimepickerInput, typeof MatTimepickerToggle]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatTimepickerModule>;
+}
+
+export { MAT_TIMEPICKER_CONFIG, MAT_TIMEPICKER_SCROLL_STRATEGY, MatTimepicker, MatTimepickerInput, MatTimepickerModule, MatTimepickerToggle };
+export type { MatTimepickerConfig, MatTimepickerConnectedInput, MatTimepickerOption, MatTimepickerSelected };

package/types/toolbar-testing.d.ts

@@ -0,0 +1,33 @@
+import { BaseHarnessFilters, ContentContainerComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+
+/** A set of criteria that can be used to filter a list of `MatToolbarHarness` instances. */
+interface ToolbarHarnessFilters extends BaseHarnessFilters {
+    /** Only find instances whose text matches the given value. */
+    text?: string | RegExp;
+}
+
+/** Selectors for different sections of the mat-toolbar that contain user content. */
+declare enum MatToolbarSection {
+    ROW = ".mat-toolbar-row"
+}
+/** Harness for interacting with a standard mat-toolbar in tests. */
+declare class MatToolbarHarness extends ContentContainerComponentHarness<MatToolbarSection> {
+    static hostSelector: string;
+    private _getRows;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `MatToolbarHarness` that meets
+     * certain criteria.
+     * @param options Options for filtering which card instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options?: ToolbarHarnessFilters): HarnessPredicate<MatToolbarHarness>;
+    /** Whether the toolbar has multiple rows. */
+    hasMultipleRows(): Promise<boolean>;
+    /** Gets all of the toolbar's content as text. */
+    private _getText;
+    /** Gets the text of each row in the toolbar. */
+    getRowsAsText(): Promise<string[]>;
+}
+
+export { MatToolbarHarness, MatToolbarSection };
+export type { ToolbarHarnessFilters };

package/types/toolbar.d.ts

@@ -0,0 +1,44 @@
+import * as i0 from '@angular/core';
+import { AfterViewInit, ElementRef, QueryList } from '@angular/core';
+import * as i2 from '@angular/cdk/bidi';
+
+declare class MatToolbarRow {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatToolbarRow, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatToolbarRow, "mat-toolbar-row", ["matToolbarRow"], {}, {}, never, never, true, never>;
+}
+declare class MatToolbar implements AfterViewInit {
+    protected _elementRef: ElementRef<any>;
+    private _platform;
+    private _document;
+    /**
+     * Theme color of the toolbar. 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/toolbar/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;
+    /** Reference to all toolbar row elements that have been projected. */
+    _toolbarRows: QueryList<MatToolbarRow>;
+    constructor(...args: unknown[]);
+    ngAfterViewInit(): void;
+    /**
+     * Throws an exception when developers are attempting to combine the different toolbar row modes.
+     */
+    private _checkToolbarMixedModes;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatToolbar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatToolbar, "mat-toolbar", ["matToolbar"], { "color": { "alias": "color"; "required": false; }; }, {}, ["_toolbarRows"], ["*", "mat-toolbar-row"], true, never>;
+}
+/**
+ * Throws an exception when attempting to combine the different toolbar row modes.
+ * @docs-private
+ */
+declare function throwToolbarMixedModesError(): void;
+
+declare class MatToolbarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatToolbarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatToolbarModule, never, [typeof MatToolbar, typeof MatToolbarRow], [typeof MatToolbar, typeof MatToolbarRow, typeof i2.BidiModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatToolbarModule>;
+}
+
+export { MatToolbar, MatToolbarModule, MatToolbarRow, throwToolbarMixedModesError };

package/types/tooltip-testing.d.ts

@@ -0,0 +1,35 @@
+import { BaseHarnessFilters, ComponentHarness, ComponentHarnessConstructor, HarnessPredicate } from '@angular/cdk/testing';
+
+/** A set of criteria that can be used to filter a list of `MatTooltipHarness` instances. */
+interface TooltipHarnessFilters extends BaseHarnessFilters {
+}
+
+/** Harness for interacting with a mat-tooltip in tests. */
+declare class MatTooltipHarness extends ComponentHarness {
+    static hostSelector: string;
+    private _optionalPanel;
+    private _hiddenClass;
+    private _disabledClass;
+    private _showAnimationName;
+    private _hideAnimationName;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a tooltip trigger with specific
+     * attributes.
+     * @param options Options for narrowing the search.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with<T extends MatTooltipHarness>(this: ComponentHarnessConstructor<T>, options?: TooltipHarnessFilters): HarnessPredicate<T>;
+    /** Shows the tooltip. */
+    show(): Promise<void>;
+    /** Hides the tooltip. */
+    hide(): Promise<void>;
+    /** Gets whether the tooltip is open. */
+    isOpen(): Promise<boolean>;
+    /** Gets whether the tooltip is disabled */
+    isDisabled(): Promise<boolean>;
+    /** Gets a promise for the tooltip panel's text. */
+    getTooltipText(): Promise<string>;
+}
+
+export { MatTooltipHarness };
+export type { TooltipHarnessFilters };

package/types/tooltip.d.ts

@@ -0,0 +1,17 @@
+import { MatTooltip, TooltipComponent } from './_tooltip-chunk.js';
+export { MAT_TOOLTIP_DEFAULT_OPTIONS, MAT_TOOLTIP_SCROLL_STRATEGY, MatTooltipDefaultOptions, SCROLL_THROTTLE_MS, TOOLTIP_PANEL_CLASS, TooltipPosition, TooltipTouchGestures, TooltipVisibility, getMatTooltipInvalidPositionError } from './_tooltip-chunk.js';
+import * as i0 from '@angular/core';
+import * as i1 from '@angular/cdk/a11y';
+import * as i2 from '@angular/cdk/overlay';
+import * as i2$1 from '@angular/cdk/bidi';
+import * as i1$1 from '@angular/cdk/scrolling';
+import '@angular/cdk/coercion';
+import 'rxjs';
+
+declare class MatTooltipModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatTooltipModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatTooltipModule, never, [typeof i1.A11yModule, typeof i2.OverlayModule, typeof MatTooltip, typeof TooltipComponent], [typeof MatTooltip, typeof TooltipComponent, typeof i2$1.BidiModule, typeof i1$1.CdkScrollableModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatTooltipModule>;
+}
+
+export { MatTooltip, MatTooltipModule, TooltipComponent };