@angular/material 14.0.0-next.9 → 14.0.0-rc.0

package/tabs/testing/index.d.ts

@@ -1,8 +1,153 @@
-/**
- * @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 { ContentContainerComponentHarness } from '@angular/cdk/testing';
+import { HarnessLoader } from '@angular/cdk/testing';
+import { HarnessPredicate } from '@angular/cdk/testing';
+
+/** Harness for interacting with a standard mat-tab-group in tests. */
+export declare class MatTabGroupHarness extends ComponentHarness {
+    /** The selector for the host element of a `MatTabGroup` instance. */
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `MatTabGroupHarness` that meets
+     * certain criteria.
+     * @param options Options for filtering which tab group instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options?: TabGroupHarnessFilters): HarnessPredicate<MatTabGroupHarness>;
+    /**
+     * Gets the list of tabs in the tab group.
+     * @param filter Optionally filters which tabs are included.
+     */
+    getTabs(filter?: TabHarnessFilters): Promise<MatTabHarness[]>;
+    /** Gets the selected tab of the tab group. */
+    getSelectedTab(): Promise<MatTabHarness>;
+    /**
+     * Selects a tab in this tab group.
+     * @param filter An optional filter to apply to the child tabs. The first tab matching the filter
+     *     will be selected.
+     */
+    selectTab(filter?: TabHarnessFilters): Promise<void>;
+}
+
+/** Harness for interacting with a standard Angular Material tab-label in tests. */
+export declare class MatTabHarness extends ContentContainerComponentHarness<string> {
+    /** The selector for the host element of a `MatTab` instance. */
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `MatTabHarness` that meets
+     * certain criteria.
+     * @param options Options for filtering which tab instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options?: TabHarnessFilters): HarnessPredicate<MatTabHarness>;
+    /** Gets the label of the tab. */
+    getLabel(): Promise<string>;
+    /** Gets the aria-label of the tab. */
+    getAriaLabel(): Promise<string | null>;
+    /** Gets the value of the "aria-labelledby" attribute. */
+    getAriaLabelledby(): Promise<string | null>;
+    /** Whether the tab is selected. */
+    isSelected(): Promise<boolean>;
+    /** Whether the tab is disabled. */
+    isDisabled(): Promise<boolean>;
+    /** Selects the given tab by clicking on the label. Tab cannot be selected if disabled. */
+    select(): Promise<void>;
+    /** Gets the text content of the tab. */
+    getTextContent(): Promise<string>;
+    protected getRootHarnessLoader(): Promise<HarnessLoader>;
+    /** Gets the element id for the content of the current tab. */
+    private _getContentId;
+}
+
+/** Harness for interacting with a standard Angular Material tab link in tests. */
+export declare class MatTabLinkHarness extends ComponentHarness {
+    /** The selector for the host element of a `MatTabLink` instance. */
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `MatTabLinkHarness` that meets
+     * certain criteria.
+     * @param options Options for filtering which tab link instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options?: TabLinkHarnessFilters): HarnessPredicate<MatTabLinkHarness>;
+    /** Gets the label of the link. */
+    getLabel(): Promise<string>;
+    /** Whether the link is active. */
+    isActive(): Promise<boolean>;
+    /** Whether the link is disabled. */
+    isDisabled(): Promise<boolean>;
+    /** Clicks on the link. */
+    click(): Promise<void>;
+}
+
+/** Harness for interacting with a standard mat-tab-nav-bar in tests. */
+export declare class MatTabNavBarHarness extends ComponentHarness {
+    /** The selector for the host element of a `MatTabNavBar` instance. */
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `MatTabNavBar` that meets
+     * certain criteria.
+     * @param options Options for filtering which tab nav bar instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options?: TabNavBarHarnessFilters): HarnessPredicate<MatTabNavBarHarness>;
+    /**
+     * Gets the list of links in the nav bar.
+     * @param filter Optionally filters which links are included.
+     */
+    getLinks(filter?: TabLinkHarnessFilters): Promise<MatTabLinkHarness[]>;
+    /** Gets the active link in the nav bar. */
+    getActiveLink(): Promise<MatTabLinkHarness>;
+    /**
+     * Clicks a link inside the nav bar.
+     * @param filter An optional filter to apply to the child link. The first link matching the filter
+     *     will be clicked.
+     */
+    clickLink(filter?: TabLinkHarnessFilters): Promise<void>;
+    /** Gets the panel associated with the nav bar. */
+    getPanel(): Promise<MatTabNavPanelHarness>;
+}
+
+/** Harness for interacting with a standard mat-tab-nav-panel in tests. */
+declare class MatTabNavPanelHarness extends ContentContainerComponentHarness {
+    /** The selector for the host element of a `MatTabNavPanel` instance. */
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `MatTabNavPanel` that meets
+     * certain criteria.
+     * @param options Options for filtering which tab nav panel instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options?: TabNavPanelHarnessFilters): HarnessPredicate<MatTabNavPanelHarness>;
+    /** Gets the tab panel text content. */
+    getTextContent(): Promise<string>;
+}
+
+/** A set of criteria that can be used to filter a list of `MatTabGroupHarness` instances. */
+export declare interface TabGroupHarnessFilters extends BaseHarnessFilters {
+    /** Only find instances whose selected tab label matches the given value. */
+    selectedTabLabel?: string | RegExp;
+}
+
+/** A set of criteria that can be used to filter a list of `MatTabHarness` instances. */
+export declare interface TabHarnessFilters extends BaseHarnessFilters {
+    /** Only find instances whose label matches the given value. */
+    label?: string | RegExp;
+}
+
+/** A set of criteria that can be used to filter a list of `MatTabLinkHarness` instances. */
+export declare interface TabLinkHarnessFilters extends BaseHarnessFilters {
+    /** Only find instances whose label matches the given value. */
+    label?: string | RegExp;
+}
+
+/** A set of criteria that can be used to filter a list of `MatTabNavBarHarness` instances. */
+export declare interface TabNavBarHarnessFilters extends BaseHarnessFilters {
+}
+
+/** A set of criteria that can be used to filter a list of `MatTabNavBarHarness` instances. */
+export declare interface TabNavPanelHarnessFilters extends BaseHarnessFilters {
+}
+
+export { }

package/toolbar/index.d.ts

@@ -1,8 +1,58 @@
+import { _AbstractConstructor } from '@angular/material/core';
+import { AfterViewInit } from '@angular/core';
+import { CanColor } from '@angular/material/core';
+import { _Constructor } from '@angular/material/core';
+import { ElementRef } from '@angular/core';
+import * as i0 from '@angular/core';
+import * as i2 from '@angular/material/core';
+import { Platform } from '@angular/cdk/platform';
+import { QueryList } from '@angular/core';
+
+declare namespace i1 {
+    export {
+        throwToolbarMixedModesError,
+        MatToolbarRow,
+        MatToolbar
+    }
+}
+
+export declare class MatToolbar extends _MatToolbarBase implements CanColor, AfterViewInit {
+    private _platform;
+    private _document;
+    /** Reference to all toolbar row elements that have been projected. */
+    _toolbarRows: QueryList<MatToolbarRow>;
+    constructor(elementRef: ElementRef, _platform: Platform, document?: any);
+    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": "color"; }, {}, ["_toolbarRows"], ["*", "mat-toolbar-row"], false>;
+}
+
+/** @docs-private */
+declare const _MatToolbarBase: _Constructor<CanColor> & _AbstractConstructor<CanColor> & {
+    new (_elementRef: ElementRef): {
+        _elementRef: ElementRef;
+    };
+};
+
+export declare class MatToolbarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatToolbarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatToolbarModule, [typeof i1.MatToolbar, typeof i1.MatToolbarRow], [typeof i2.MatCommonModule], [typeof i1.MatToolbar, typeof i1.MatToolbarRow, typeof i2.MatCommonModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatToolbarModule>;
+}
+
+export declare class MatToolbarRow {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatToolbarRow, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatToolbarRow, "mat-toolbar-row", ["matToolbarRow"], {}, {}, never, never, false>;
+}
+
 /**
- * @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
+ * Throws an exception when attempting to combine the different toolbar row modes.
+ * @docs-private
  */
-export * from './public-api';
+export declare function throwToolbarMixedModesError(): void;
+
+export { }

package/toolbar/testing/index.d.ts

@@ -1,8 +1,35 @@
-/**
- * @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 { ContentContainerComponentHarness } from '@angular/cdk/testing';
+import { HarnessPredicate } from '@angular/cdk/testing';
+
+/** Harness for interacting with a standard mat-toolbar in tests. */
+export 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[]>;
+}
+
+/** Selectors for different sections of the mat-toolbar that contain user content. */
+export declare const enum MatToolbarSection {
+    ROW = ".mat-toolbar-row"
+}
+
+/** A set of criteria that can be used to filter a list of `MatToolbarHarness` instances. */
+export declare interface ToolbarHarnessFilters extends BaseHarnessFilters {
+    /** Only find instances whose text matches the given value. */
+    text?: string | RegExp;
+}
+
+export { }

package/tooltip/index.d.ts

@@ -1,8 +1,365 @@
+import { AfterViewInit } from '@angular/core';
+import { AnimationTriggerMetadata } from '@angular/animations';
+import { AriaDescriber } from '@angular/cdk/a11y';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { BreakpointObserver } from '@angular/cdk/layout';
+import { BreakpointState } from '@angular/cdk/layout';
+import { ChangeDetectorRef } from '@angular/core';
+import { ComponentType } from '@angular/cdk/portal';
+import { ConnectedPosition } from '@angular/cdk/overlay';
+import { Directionality } from '@angular/cdk/bidi';
+import { ElementRef } from '@angular/core';
+import { FocusMonitor } from '@angular/cdk/a11y';
+import * as i0 from '@angular/core';
+import * as i2 from '@angular/cdk/a11y';
+import * as i3 from '@angular/common';
+import * as i4 from '@angular/cdk/overlay';
+import * as i5 from '@angular/material/core';
+import * as i6 from '@angular/cdk/scrolling';
+import { InjectionToken } from '@angular/core';
+import { NgZone } from '@angular/core';
+import { NumberInput } from '@angular/cdk/coercion';
+import { Observable } from 'rxjs';
+import { OnDestroy } from '@angular/core';
+import { OriginConnectionPosition } from '@angular/cdk/overlay';
+import { Overlay } from '@angular/cdk/overlay';
+import { OverlayConnectionPosition } from '@angular/cdk/overlay';
+import { OverlayRef } from '@angular/cdk/overlay';
+import { Platform } from '@angular/cdk/platform';
+import { ScrollDispatcher } from '@angular/cdk/scrolling';
+import { ScrollStrategy } from '@angular/cdk/overlay';
+import { ViewContainerRef } from '@angular/core';
+
 /**
- * @license
- * Copyright Google LLC All Rights Reserved.
+ * Creates an error to be thrown if the user supplied an invalid tooltip position.
+ * @docs-private
+ */
+export declare function getMatTooltipInvalidPositionError(position: string): Error;
+
+declare namespace i1 {
+    export {
+        getMatTooltipInvalidPositionError,
+        MAT_TOOLTIP_SCROLL_STRATEGY_FACTORY,
+        MAT_TOOLTIP_DEFAULT_OPTIONS_FACTORY,
+        TooltipPosition,
+        TooltipTouchGestures,
+        TooltipVisibility,
+        SCROLL_THROTTLE_MS,
+        TOOLTIP_PANEL_CLASS,
+        MAT_TOOLTIP_SCROLL_STRATEGY,
+        MAT_TOOLTIP_SCROLL_STRATEGY_FACTORY_PROVIDER,
+        MatTooltipDefaultOptions,
+        MAT_TOOLTIP_DEFAULT_OPTIONS,
+        _MatTooltipBase,
+        MatTooltip,
+        _TooltipComponentBase,
+        TooltipComponent
+    }
+}
+
+/** Injection token to be used to override the default options for `matTooltip`. */
+export declare const MAT_TOOLTIP_DEFAULT_OPTIONS: InjectionToken<MatTooltipDefaultOptions>;
+
+/** @docs-private */
+export declare function MAT_TOOLTIP_DEFAULT_OPTIONS_FACTORY(): MatTooltipDefaultOptions;
+
+/** Injection token that determines the scroll handling while a tooltip is visible. */
+export declare const MAT_TOOLTIP_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
+
+/** @docs-private */
+export declare function MAT_TOOLTIP_SCROLL_STRATEGY_FACTORY(overlay: Overlay): () => ScrollStrategy;
+
+/** @docs-private */
+export declare const MAT_TOOLTIP_SCROLL_STRATEGY_FACTORY_PROVIDER: {
+    provide: InjectionToken<() => ScrollStrategy>;
+    deps: (typeof Overlay)[];
+    useFactory: typeof MAT_TOOLTIP_SCROLL_STRATEGY_FACTORY;
+};
+
+/**
+ * Directive that attaches a material design tooltip to the host element. Animates the showing and
+ * hiding of a tooltip provided position (defaults to below the element).
  *
- * 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
+ * https://material.io/design/components/tooltips.html
+ */
+export declare class MatTooltip extends _MatTooltipBase<TooltipComponent> {
+    protected readonly _tooltipComponent: typeof TooltipComponent;
+    constructor(overlay: Overlay, elementRef: ElementRef<HTMLElement>, scrollDispatcher: ScrollDispatcher, viewContainerRef: ViewContainerRef, ngZone: NgZone, platform: Platform, ariaDescriber: AriaDescriber, focusMonitor: FocusMonitor, scrollStrategy: any, dir: Directionality, defaultOptions: MatTooltipDefaultOptions, _document: any);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatTooltip, [null, null, null, null, null, null, null, null, null, { optional: true; }, { optional: true; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatTooltip, "[matTooltip]", ["matTooltip"], {}, {}, never, never, false>;
+}
+
+/**
+ * Animations used by MatTooltip.
+ * @docs-private
+ */
+export declare const matTooltipAnimations: {
+    readonly tooltipState: AnimationTriggerMetadata;
+};
+
+export declare abstract class _MatTooltipBase<T extends _TooltipComponentBase> implements OnDestroy, AfterViewInit {
+    private _overlay;
+    private _elementRef;
+    private _scrollDispatcher;
+    private _viewContainerRef;
+    private _ngZone;
+    private _platform;
+    private _ariaDescriber;
+    private _focusMonitor;
+    protected _dir: Directionality;
+    private _defaultOptions;
+    _overlayRef: OverlayRef | null;
+    _tooltipInstance: T | null;
+    private _portal;
+    private _position;
+    private _disabled;
+    private _tooltipClass;
+    private _scrollStrategy;
+    private _viewInitialized;
+    private _pointerExitEventsInitialized;
+    protected abstract readonly _tooltipComponent: ComponentType<T>;
+    protected _viewportMargin: number;
+    private _currentPosition;
+    protected readonly _cssClassPrefix: string;
+    /** Allows the user to define the position of the tooltip relative to the parent element */
+    get position(): TooltipPosition;
+    set position(value: TooltipPosition);
+    /** Disables the display of the tooltip. */
+    get disabled(): boolean;
+    set disabled(value: BooleanInput);
+    /** The default delay in ms before showing the tooltip after show is called */
+    get showDelay(): number;
+    set showDelay(value: NumberInput);
+    private _showDelay;
+    /** The default delay in ms before hiding the tooltip after hide is called */
+    get hideDelay(): number;
+    set hideDelay(value: NumberInput);
+    private _hideDelay;
+    /**
+     * How touch gestures should be handled by the tooltip. On touch devices the tooltip directive
+     * uses a long press gesture to show and hide, however it can conflict with the native browser
+     * gestures. To work around the conflict, Angular Material disables native gestures on the
+     * trigger, but that might not be desirable on particular elements (e.g. inputs and draggable
+     * elements). The different values for this option configure the touch event handling as follows:
+     * - `auto` - Enables touch gestures for all elements, but tries to avoid conflicts with native
+     *   browser gestures on particular elements. In particular, it allows text selection on inputs
+     *   and textareas, and preserves the native browser dragging on elements marked as `draggable`.
+     * - `on` - Enables touch gestures for all elements and disables native
+     *   browser gestures with no exceptions.
+     * - `off` - Disables touch gestures. Note that this will prevent the tooltip from
+     *   showing on touch devices.
+     */
+    touchGestures: TooltipTouchGestures;
+    /** The message to be displayed in the tooltip */
+    get message(): string;
+    set message(value: string);
+    private _message;
+    /** Classes to be passed to the tooltip. Supports the same syntax as `ngClass`. */
+    get tooltipClass(): string | string[] | Set<string> | {
+        [key: string]: any;
+    };
+    set tooltipClass(value: string | string[] | Set<string> | {
+        [key: string]: any;
+    });
+    /** Manually-bound passive event listeners. */
+    private readonly _passiveListeners;
+    /** Reference to the current document. */
+    private _document;
+    /** Timer started at the last `touchstart` event. */
+    private _touchstartTimeout;
+    /** Emits when the component is destroyed. */
+    private readonly _destroyed;
+    constructor(_overlay: Overlay, _elementRef: ElementRef<HTMLElement>, _scrollDispatcher: ScrollDispatcher, _viewContainerRef: ViewContainerRef, _ngZone: NgZone, _platform: Platform, _ariaDescriber: AriaDescriber, _focusMonitor: FocusMonitor, scrollStrategy: any, _dir: Directionality, _defaultOptions: MatTooltipDefaultOptions, _document: any);
+    ngAfterViewInit(): void;
+    /**
+     * Dispose the tooltip when destroyed.
+     */
+    ngOnDestroy(): void;
+    /** Shows the tooltip after the delay in ms, defaults to tooltip-delay-show or 0ms if no input */
+    show(delay?: number): void;
+    /** Hides the tooltip after the delay in ms, defaults to tooltip-delay-hide or 0ms if no input */
+    hide(delay?: number): void;
+    /** Shows/hides the tooltip */
+    toggle(): void;
+    /** Returns true if the tooltip is currently visible to the user */
+    _isTooltipVisible(): boolean;
+    /** Create the overlay config and position strategy */
+    private _createOverlay;
+    /** Detaches the currently-attached tooltip. */
+    private _detach;
+    /** Updates the position of the current tooltip. */
+    private _updatePosition;
+    /** Adds the configured offset to a position. Used as a hook for child classes. */
+    protected _addOffset(position: ConnectedPosition): ConnectedPosition;
+    /**
+     * Returns the origin position and a fallback position based on the user's position preference.
+     * The fallback position is the inverse of the origin (e.g. `'below' -> 'above'`).
+     */
+    _getOrigin(): {
+        main: OriginConnectionPosition;
+        fallback: OriginConnectionPosition;
+    };
+    /** Returns the overlay position and a fallback position based on the user's preference */
+    _getOverlayPosition(): {
+        main: OverlayConnectionPosition;
+        fallback: OverlayConnectionPosition;
+    };
+    /** Updates the tooltip message and repositions the overlay according to the new message length */
+    private _updateTooltipMessage;
+    /** Updates the tooltip class */
+    private _setTooltipClass;
+    /** Inverts an overlay position. */
+    private _invertPosition;
+    /** Updates the class on the overlay panel based on the current position of the tooltip. */
+    private _updateCurrentPositionClass;
+    /** Binds the pointer events to the tooltip trigger. */
+    private _setupPointerEnterEventsIfNeeded;
+    private _setupPointerExitEventsIfNeeded;
+    private _addListeners;
+    private _platformSupportsMouseEvents;
+    /** Listener for the `wheel` event on the element. */
+    private _wheelListener;
+    /** Disables the native browser gestures, based on how the tooltip has been configured. */
+    private _disableNativeGesturesIfNecessary;
+    static ɵfac: i0.ɵɵFactoryDeclaration<_MatTooltipBase<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<_MatTooltipBase<any>, never, never, { "position": "matTooltipPosition"; "disabled": "matTooltipDisabled"; "showDelay": "matTooltipShowDelay"; "hideDelay": "matTooltipHideDelay"; "touchGestures": "matTooltipTouchGestures"; "message": "matTooltip"; "tooltipClass": "matTooltipClass"; }, {}, never, never, false>;
+}
+
+/** Default `matTooltip` options that can be overridden. */
+export declare interface MatTooltipDefaultOptions {
+    /** Default delay when the tooltip is shown. */
+    showDelay: number;
+    /** Default delay when the tooltip is hidden. */
+    hideDelay: number;
+    /** Default delay when hiding the tooltip on a touch device. */
+    touchendHideDelay: number;
+    /** Default touch gesture handling for tooltips. */
+    touchGestures?: TooltipTouchGestures;
+    /** Default position for tooltips. */
+    position?: TooltipPosition;
+    /** Disables the ability for the user to interact with the tooltip element. */
+    disableTooltipInteractivity?: boolean;
+}
+
+export declare class MatTooltipModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatTooltipModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatTooltipModule, [typeof i1.MatTooltip, typeof i1.TooltipComponent], [typeof i2.A11yModule, typeof i3.CommonModule, typeof i4.OverlayModule, typeof i5.MatCommonModule], [typeof i1.MatTooltip, typeof i1.TooltipComponent, typeof i5.MatCommonModule, typeof i6.CdkScrollableModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatTooltipModule>;
+}
+
+/** Time in ms to throttle repositioning after scroll events. */
+export declare const SCROLL_THROTTLE_MS = 20;
+
+/**
+ * CSS class that will be attached to the overlay panel.
+ * @deprecated
+ * @breaking-change 13.0.0 remove this variable
+ */
+export declare const TOOLTIP_PANEL_CLASS = "mat-tooltip-panel";
+
+/**
+ * Internal component that wraps the tooltip's content.
+ * @docs-private
+ */
+export declare class TooltipComponent extends _TooltipComponentBase {
+    private _breakpointObserver;
+    /** Stream that emits whether the user has a handset-sized display.  */
+    _isHandset: Observable<BreakpointState>;
+    _showAnimation: string;
+    _hideAnimation: string;
+    _tooltip: ElementRef<HTMLElement>;
+    constructor(changeDetectorRef: ChangeDetectorRef, _breakpointObserver: BreakpointObserver, animationMode?: string);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipComponent, [null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TooltipComponent, "mat-tooltip-component", never, {}, {}, never, never, false>;
+}
+
+export declare abstract class _TooltipComponentBase implements OnDestroy {
+    private _changeDetectorRef;
+    /** Message to display in the tooltip */
+    message: string;
+    /** Classes to be added to the tooltip. Supports the same syntax as `ngClass`. */
+    tooltipClass: string | string[] | Set<string> | {
+        [key: string]: any;
+    };
+    /** The timeout ID of any current timer set to show the tooltip */
+    _showTimeoutId: number | undefined;
+    /** The timeout ID of any current timer set to hide the tooltip */
+    _hideTimeoutId: number | undefined;
+    /** Property watched by the animation framework to show or hide the tooltip */
+    _visibility: TooltipVisibility;
+    /** Element that caused the tooltip to open. */
+    _triggerElement: HTMLElement;
+    /** Amount of milliseconds to delay the closing sequence. */
+    _mouseLeaveHideDelay: number;
+    /** Whether animations are currently disabled. */
+    private _animationsDisabled;
+    /** Reference to the internal tooltip element. */
+    abstract _tooltip: ElementRef<HTMLElement>;
+    /** Whether interactions on the page should close the tooltip */
+    private _closeOnInteraction;
+    /** Whether the tooltip is currently visible. */
+    private _isVisible;
+    /** Subject for notifying that the tooltip has been hidden from the view */
+    private readonly _onHide;
+    /** Name of the show animation and the class that toggles it. */
+    protected abstract readonly _showAnimation: string;
+    /** Name of the hide animation and the class that toggles it. */
+    protected abstract readonly _hideAnimation: string;
+    constructor(_changeDetectorRef: ChangeDetectorRef, animationMode?: string);
+    /**
+     * Shows the tooltip with an animation originating from the provided origin
+     * @param delay Amount of milliseconds to the delay showing the tooltip.
+     */
+    show(delay: number): void;
+    /**
+     * Begins the animation to hide the tooltip after the provided delay in ms.
+     * @param delay Amount of milliseconds to delay showing the tooltip.
+     */
+    hide(delay: number): void;
+    /** Returns an observable that notifies when the tooltip has been hidden from view. */
+    afterHidden(): Observable<void>;
+    /** Whether the tooltip is being displayed. */
+    isVisible(): boolean;
+    ngOnDestroy(): void;
+    /**
+     * Interactions on the HTML body should close the tooltip immediately as defined in the
+     * material design spec.
+     * https://material.io/design/components/tooltips.html#behavior
+     */
+    _handleBodyInteraction(): void;
+    /**
+     * Marks that the tooltip needs to be checked in the next change detection run.
+     * Mainly used for rendering the initial text before positioning a tooltip, which
+     * can be problematic in components with OnPush change detection.
+     */
+    _markForCheck(): void;
+    _handleMouseLeave({ relatedTarget }: MouseEvent): void;
+    /**
+     * Callback for when the timeout in this.show() gets completed.
+     * This method is only needed by the mdc-tooltip, and so it is only implemented
+     * in the mdc-tooltip, not here.
+     */
+    protected _onShow(): void;
+    /** Event listener dispatched when an animation on the tooltip finishes. */
+    _handleAnimationEnd({ animationName }: AnimationEvent): void;
+    /** Handles the cleanup after an animation has finished. */
+    private _finalizeAnimation;
+    /** Toggles the visibility of the tooltip element. */
+    private _toggleVisibility;
+    static ɵfac: i0.ɵɵFactoryDeclaration<_TooltipComponentBase, [null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<_TooltipComponentBase, never, never, {}, {}, never, never, false>;
+}
+
+/** Possible positions for a tooltip. */
+export declare type TooltipPosition = 'left' | 'right' | 'above' | 'below' | 'before' | 'after';
+
+/**
+ * Options for how the tooltip trigger should handle touch gestures.
+ * See `MatTooltip.touchGestures` for more information.
  */
-export * from './public-api';
+export declare type TooltipTouchGestures = 'auto' | 'on' | 'off';
+
+/** Possible visibility states of a tooltip. */
+export declare type TooltipVisibility = 'initial' | 'visible' | 'hidden';
+
+export { }