@depup/angular__material 21.2.2-depup.19

package/types/_paginator-chunk.d.ts

@@ -0,0 +1,184 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, OnInit, OnDestroy, EventEmitter } from '@angular/core';
+import { ThemePalette } from './_palette-chunk.js';
+import { Subject, Observable } from 'rxjs';
+import { MatFormFieldAppearance } from './_form-field-chunk.js';
+
+/**
+ * To modify the labels and text displayed, create a new instance of MatPaginatorIntl and
+ * include it in a custom provider
+ */
+declare class MatPaginatorIntl {
+    /**
+     * Stream to emit from when labels are changed. Use this to notify components when the labels have
+     * changed after initialization.
+     */
+    readonly changes: Subject<void>;
+    /** A label for the page size selector. */
+    itemsPerPageLabel: string;
+    /** A label for the button that increments the current page. */
+    nextPageLabel: string;
+    /** A label for the button that decrements the current page. */
+    previousPageLabel: string;
+    /** A label for the button that moves to the first page. */
+    firstPageLabel: string;
+    /** A label for the button that moves to the last page. */
+    lastPageLabel: string;
+    /** A label for the range of items within the current page and the length of the whole list. */
+    getRangeLabel: (page: number, pageSize: number, length: number) => string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatPaginatorIntl, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MatPaginatorIntl>;
+}
+
+/** Object that can used to configure the underlying `MatSelect` inside a `MatPaginator`. */
+interface MatPaginatorSelectConfig {
+    /** Whether to center the active option over the trigger. */
+    disableOptionCentering?: boolean;
+    /** Classes to be passed to the select panel. */
+    panelClass?: string | string[] | Set<string> | {
+        [key: string]: any;
+    };
+}
+/**
+ * Change event object that is emitted when the user selects a
+ * different page size or navigates to another page.
+ */
+declare class PageEvent {
+    /** The current page index. */
+    pageIndex: number;
+    /**
+     * Index of the page that was selected previously.
+     * @breaking-change 8.0.0 To be made into a required property.
+     */
+    previousPageIndex?: number;
+    /** The current page size. */
+    pageSize: number;
+    /** The current total number of items being paged. */
+    length: number;
+}
+/** Object that can be used to configure the default options for the paginator module. */
+interface MatPaginatorDefaultOptions {
+    /** Number of items to display on a page. By default set to 50. */
+    pageSize?: number;
+    /** The set of provided page size options to display to the user. */
+    pageSizeOptions?: number[];
+    /** Whether to hide the page size selection UI from the user. */
+    hidePageSize?: boolean;
+    /** Whether to show the first/last buttons UI to the user. */
+    showFirstLastButtons?: boolean;
+    /** The default form-field appearance to apply to the page size options selector. */
+    formFieldAppearance?: MatFormFieldAppearance;
+}
+/** Injection token that can be used to provide the default options for the paginator module. */
+declare const MAT_PAGINATOR_DEFAULT_OPTIONS: InjectionToken<MatPaginatorDefaultOptions>;
+/**
+ * Component to provide navigation between paged information. Displays the size of the current
+ * page, user-selectable options to change that size, what items are being shown, and
+ * navigational button to go to the previous or next page.
+ */
+declare class MatPaginator implements OnInit, OnDestroy {
+    _intl: MatPaginatorIntl;
+    private _changeDetectorRef;
+    /** If set, styles the "page size" form field with the designated style. */
+    _formFieldAppearance?: MatFormFieldAppearance;
+    /** ID for the DOM node containing the paginator's items per page label. */
+    readonly _pageSizeLabelId: string;
+    private _intlChanges;
+    private _isInitialized;
+    private _initializedStream;
+    /**
+     * Theme color of the underlying form controls. 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/paginator/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;
+    /** The zero-based page index of the displayed list of items. Defaulted to 0. */
+    get pageIndex(): number;
+    set pageIndex(value: number);
+    private _pageIndex;
+    /** The length of the total number of items that are being paginated. Defaulted to 0. */
+    get length(): number;
+    set length(value: number);
+    private _length;
+    /** Number of items to display on a page. By default set to 50. */
+    get pageSize(): number;
+    set pageSize(value: number);
+    private _pageSize;
+    /** The set of provided page size options to display to the user. */
+    get pageSizeOptions(): number[];
+    set pageSizeOptions(value: number[] | readonly number[]);
+    private _pageSizeOptions;
+    /** Whether to hide the page size selection UI from the user. */
+    hidePageSize: boolean;
+    /** Whether to show the first/last buttons UI to the user. */
+    showFirstLastButtons: boolean;
+    /** Used to configure the underlying `MatSelect` inside the paginator. */
+    selectConfig: MatPaginatorSelectConfig;
+    /** Whether the paginator is disabled. */
+    disabled: boolean;
+    /** Event emitted when the paginator changes the page size or page index. */
+    readonly page: EventEmitter<PageEvent>;
+    /** Displayed set of page size options. Will be sorted and include current page size. */
+    _displayedPageSizeOptions: number[];
+    /** Emits when the paginator is initialized. */
+    initialized: Observable<void>;
+    /** Inserted by Angular inject() migration for backwards compatibility */
+    constructor(...args: unknown[]);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** Advances to the next page if it exists. */
+    nextPage(): void;
+    /** Move back to the previous page if it exists. */
+    previousPage(): void;
+    /** Move to the first page if not already there. */
+    firstPage(): void;
+    /** Move to the last page if not already there. */
+    lastPage(): void;
+    /** Whether there is a previous page. */
+    hasPreviousPage(): boolean;
+    /** Whether there is a next page. */
+    hasNextPage(): boolean;
+    /** Calculate the number of pages */
+    getNumberOfPages(): number;
+    /**
+     * Changes the page size so that the first item displayed on the page will still be
+     * displayed using the new page size.
+     *
+     * For example, if the page size is 10 and on the second page (items indexed 10-19) then
+     * switching so that the page size is 5 will set the third page as the current page so
+     * that the 10th item will still be displayed.
+     */
+    _changePageSize(pageSize: number): void;
+    /** Checks whether the buttons for going forwards should be disabled. */
+    _nextButtonsDisabled(): boolean;
+    /** Checks whether the buttons for going backwards should be disabled. */
+    _previousButtonsDisabled(): boolean;
+    /**
+     * Updates the list of page size options to display to the user. Includes making sure that
+     * the page size is an option and that the list is sorted.
+     */
+    private _updateDisplayedPageSizeOptions;
+    /** Emits an event notifying that a change of the paginator's properties has been triggered. */
+    private _emitPageEvent;
+    /** Navigates to a specific page index. */
+    private _navigate;
+    /**
+     * Callback invoked when one of the navigation buttons is called.
+     * @param targetIndex Index to which the paginator should navigate.
+     * @param isDisabled Whether the button is disabled.
+     */
+    protected _buttonClicked(targetIndex: number, isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatPaginator, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatPaginator, "mat-paginator", ["matPaginator"], { "color": { "alias": "color"; "required": false; }; "pageIndex": { "alias": "pageIndex"; "required": false; }; "length": { "alias": "length"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; }; "hidePageSize": { "alias": "hidePageSize"; "required": false; }; "showFirstLastButtons": { "alias": "showFirstLastButtons"; "required": false; }; "selectConfig": { "alias": "selectConfig"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "page": "page"; }, never, never, true, never>;
+    static ngAcceptInputType_pageIndex: unknown;
+    static ngAcceptInputType_length: unknown;
+    static ngAcceptInputType_pageSize: unknown;
+    static ngAcceptInputType_hidePageSize: unknown;
+    static ngAcceptInputType_showFirstLastButtons: unknown;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+export { MAT_PAGINATOR_DEFAULT_OPTIONS, MatPaginator, MatPaginatorIntl, PageEvent };
+export type { MatPaginatorDefaultOptions, MatPaginatorSelectConfig };

package/types/_palette-chunk.d.ts

@@ -0,0 +1,4 @@
+/** Possible color palette values. */
+type ThemePalette = 'primary' | 'accent' | 'warn' | undefined;
+
+export type { ThemePalette };

package/types/_progress-spinner-chunk.d.ts

@@ -0,0 +1,91 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, ElementRef } from '@angular/core';
+import { ThemePalette } from './_palette-chunk.js';
+
+/** Possible mode for a progress spinner. */
+type ProgressSpinnerMode = 'determinate' | 'indeterminate';
+/** Default `mat-progress-spinner` options that can be overridden. */
+interface MatProgressSpinnerDefaultOptions {
+    /**
+     * Default theme color of the progress spinner. 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/progress-spinner/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;
+    /** Diameter of the spinner. */
+    diameter?: number;
+    /** Width of the spinner's stroke. */
+    strokeWidth?: number;
+    /**
+     * Whether the animations should be force to be enabled, ignoring if the current environment
+     * disables them.
+     */
+    _forceAnimations?: boolean;
+}
+/** Injection token to be used to override the default options for `mat-progress-spinner`. */
+declare const MAT_PROGRESS_SPINNER_DEFAULT_OPTIONS: InjectionToken<MatProgressSpinnerDefaultOptions>;
+declare class MatProgressSpinner {
+    readonly _elementRef: ElementRef<HTMLElement>;
+    /** Whether the _mat-animation-noopable class should be applied, disabling animations.  */
+    _noopAnimations: boolean;
+    /**
+     * Theme color of the progress spinner. 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/progress-spinner/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
+     */
+    get color(): string | null | undefined;
+    set color(value: string | null | undefined);
+    private _color;
+    private _defaultColor;
+    /** The element of the determinate spinner. */
+    _determinateCircle: ElementRef<HTMLElement>;
+    constructor(...args: unknown[]);
+    /**
+     * Mode of the progress bar.
+     *
+     * Input must be one of these values: determinate, indeterminate, buffer, query, defaults to
+     * 'determinate'.
+     * Mirrored to mode attribute.
+     */
+    mode: ProgressSpinnerMode;
+    /** Value of the progress bar. Defaults to zero. Mirrored to aria-valuenow. */
+    get value(): number;
+    set value(v: number);
+    private _value;
+    /** The diameter of the progress spinner (will set width and height of svg). */
+    get diameter(): number;
+    set diameter(size: number);
+    private _diameter;
+    /** Stroke width of the progress spinner. */
+    get strokeWidth(): number;
+    set strokeWidth(value: number);
+    private _strokeWidth;
+    /** The radius of the spinner, adjusted for stroke width. */
+    _circleRadius(): number;
+    /** The view box of the spinner's svg element. */
+    _viewBox(): string;
+    /** The stroke circumference of the svg circle. */
+    _strokeCircumference(): number;
+    /** The dash offset of the svg circle. */
+    _strokeDashOffset(): number | null;
+    /** Stroke width of the circle in percent. */
+    _circleStrokeWidth(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatProgressSpinner, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatProgressSpinner, "mat-progress-spinner, mat-spinner", ["matProgressSpinner"], { "color": { "alias": "color"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "value": { "alias": "value"; "required": false; }; "diameter": { "alias": "diameter"; "required": false; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_value: unknown;
+    static ngAcceptInputType_diameter: unknown;
+    static ngAcceptInputType_strokeWidth: unknown;
+}
+/**
+ * @deprecated Import Progress Spinner instead. Note that the
+ *    `mat-spinner` selector isn't deprecated.
+ * @breaking-change 16.0.0
+ */
+declare const MatSpinner: typeof MatProgressSpinner;
+
+export { MAT_PROGRESS_SPINNER_DEFAULT_OPTIONS, MatProgressSpinner, MatSpinner };
+export type { MatProgressSpinnerDefaultOptions, ProgressSpinnerMode };

package/types/_pseudo-checkbox-module-chunk.d.ts

@@ -0,0 +1,45 @@
+import * as i0 from '@angular/core';
+import * as i2 from '@angular/cdk/bidi';
+
+/**
+ * Possible states for a pseudo checkbox.
+ * @docs-private
+ */
+type MatPseudoCheckboxState = 'unchecked' | 'checked' | 'indeterminate';
+/**
+ * Component that shows a simplified checkbox without including any kind of "real" checkbox.
+ * Meant to be used when the checkbox is purely decorative and a large number of them will be
+ * included, such as for the options in a multi-select. Uses no SVGs or complex animations.
+ * Note that theming is meant to be handled by the parent element, e.g.
+ * `mat-primary .mat-pseudo-checkbox`.
+ *
+ * Note that this component will be completely invisible to screen-reader users. This is *not*
+ * interchangeable with `<mat-checkbox>` and should *not* be used if the user would directly
+ * interact with the checkbox. The pseudo-checkbox should only be used as an implementation detail
+ * of more complex components that appropriately handle selected / checked state.
+ * @docs-private
+ */
+declare class MatPseudoCheckbox {
+    _animationsDisabled: boolean;
+    /** Display state of the checkbox. */
+    state: MatPseudoCheckboxState;
+    /** Whether the checkbox is disabled. */
+    disabled: boolean;
+    /**
+     * Appearance of the pseudo checkbox. Default appearance of 'full' renders a checkmark/mixedmark
+     * indicator inside a square box. 'minimal' appearance only renders the checkmark/mixedmark.
+     */
+    appearance: 'minimal' | 'full';
+    constructor(...args: unknown[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatPseudoCheckbox, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatPseudoCheckbox, "mat-pseudo-checkbox", never, { "state": { "alias": "state"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MatPseudoCheckboxModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatPseudoCheckboxModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatPseudoCheckboxModule, never, [typeof MatPseudoCheckbox], [typeof MatPseudoCheckbox, typeof i2.BidiModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatPseudoCheckboxModule>;
+}
+
+export { MatPseudoCheckbox, MatPseudoCheckboxModule };
+export type { MatPseudoCheckboxState };

package/types/_ripple-chunk.d.ts

@@ -0,0 +1,256 @@
+import * as i0 from '@angular/core';
+import { NgZone, ElementRef, Injector, InjectionToken, OnInit, OnDestroy } from '@angular/core';
+import { Platform } from '@angular/cdk/platform';
+
+/** Possible states for a ripple element. */
+declare enum RippleState {
+    FADING_IN = 0,
+    VISIBLE = 1,
+    FADING_OUT = 2,
+    HIDDEN = 3
+}
+type RippleConfig = {
+    color?: string;
+    centered?: boolean;
+    radius?: number;
+    persistent?: boolean;
+    animation?: RippleAnimationConfig;
+    terminateOnPointerUp?: boolean;
+};
+/**
+ * Interface that describes the configuration for the animation of a ripple.
+ * There are two animation phases with different durations for the ripples.
+ */
+interface RippleAnimationConfig {
+    /** Duration in milliseconds for the enter animation (expansion from point of contact). */
+    enterDuration?: number;
+    /** Duration in milliseconds for the exit animation (fade-out). */
+    exitDuration?: number;
+}
+/**
+ * Reference to a previously launched ripple element.
+ */
+declare class RippleRef {
+    private _renderer;
+    /** Reference to the ripple HTML element. */
+    element: HTMLElement;
+    /** Ripple configuration used for the ripple. */
+    config: RippleConfig;
+    _animationForciblyDisabledThroughCss: boolean;
+    /** Current state of the ripple. */
+    state: RippleState;
+    constructor(_renderer: {
+        fadeOutRipple(ref: RippleRef): void;
+    }, 
+    /** Reference to the ripple HTML element. */
+    element: HTMLElement, 
+    /** Ripple configuration used for the ripple. */
+    config: RippleConfig, _animationForciblyDisabledThroughCss?: boolean);
+    /** Fades out the ripple element. */
+    fadeOut(): void;
+}
+
+/**
+ * Interface that describes the target for launching ripples.
+ * It defines the ripple configuration and disabled state for interaction ripples.
+ * @docs-private
+ */
+interface RippleTarget {
+    /** Configuration for ripples that are launched on pointer down. */
+    rippleConfig: RippleConfig;
+    /** Whether ripples on pointer down should be disabled. */
+    rippleDisabled: boolean;
+}
+/**
+ * Default ripple animation configuration for ripples without an explicit
+ * animation config specified.
+ */
+declare const defaultRippleAnimationConfig: {
+    enterDuration: number;
+    exitDuration: number;
+};
+/**
+ * Helper service that performs DOM manipulations. Not intended to be used outside this module.
+ * The constructor takes a reference to the ripple directive's host element and a map of DOM
+ * event handlers to be installed on the element that triggers ripple animations.
+ * This will eventually become a custom renderer once Angular support exists.
+ * @docs-private
+ */
+declare class RippleRenderer implements EventListenerObject {
+    private _target;
+    private _ngZone;
+    private _platform;
+    /** Element where the ripples are being added to. */
+    private _containerElement;
+    /** Element which triggers the ripple elements on mouse events. */
+    private _triggerElement;
+    /** Whether the pointer is currently down or not. */
+    private _isPointerDown;
+    /**
+     * Map of currently active ripple references.
+     * The ripple reference is mapped to its element event listeners.
+     * The reason why `| null` is used is that event listeners are added only
+     * when the condition is truthy (see the `_startFadeOutTransition` method).
+     */
+    private _activeRipples;
+    /** Latest non-persistent ripple that was triggered. */
+    private _mostRecentTransientRipple;
+    /** Time in milliseconds when the last touchstart event happened. */
+    private _lastTouchStartEvent;
+    /** Whether pointer-up event listeners have been registered. */
+    private _pointerUpEventsRegistered;
+    /**
+     * Cached dimensions of the ripple container. Set when the first
+     * ripple is shown and cleared once no more ripples are visible.
+     */
+    private _containerRect;
+    private static _eventManager;
+    constructor(_target: RippleTarget, _ngZone: NgZone, elementOrElementRef: HTMLElement | ElementRef<HTMLElement>, _platform: Platform, injector?: Injector);
+    /**
+     * Fades in a ripple at the given coordinates.
+     * @param x Coordinate within the element, along the X axis at which to start the ripple.
+     * @param y Coordinate within the element, along the Y axis at which to start the ripple.
+     * @param config Extra ripple options.
+     */
+    fadeInRipple(x: number, y: number, config?: RippleConfig): RippleRef;
+    /** Fades out a ripple reference. */
+    fadeOutRipple(rippleRef: RippleRef): void;
+    /** Fades out all currently active ripples. */
+    fadeOutAll(): void;
+    /** Fades out all currently active non-persistent ripples. */
+    fadeOutAllNonPersistent(): void;
+    /** Sets up the trigger event listeners */
+    setupTriggerEvents(elementOrElementRef: HTMLElement | ElementRef<HTMLElement>): void;
+    /**
+     * Handles all registered events.
+     * @docs-private
+     */
+    handleEvent(event: Event): void;
+    /** Method that will be called if the fade-in or fade-in transition completed. */
+    private _finishRippleTransition;
+    /**
+     * Starts the fade-out transition of the given ripple if it's not persistent and the pointer
+     * is not held down anymore.
+     */
+    private _startFadeOutTransition;
+    /** Destroys the given ripple by removing it from the DOM and updating its state. */
+    private _destroyRipple;
+    /** Function being called whenever the trigger is being pressed using mouse. */
+    private _onMousedown;
+    /** Function being called whenever the trigger is being pressed using touch. */
+    private _onTouchStart;
+    /** Function being called whenever the trigger is being released. */
+    private _onPointerUp;
+    private _getActiveRipples;
+    /** Removes previously registered event listeners from the trigger element. */
+    _removeTriggerEvents(): void;
+}
+
+/** Configurable options for `matRipple`. */
+interface RippleGlobalOptions {
+    /**
+     * Whether ripples should be disabled. Ripples can be still launched manually by using
+     * the `launch()` method. Therefore focus indicators will still show up.
+     */
+    disabled?: boolean;
+    /**
+     * Default configuration for the animation duration of the ripples. There are two phases with
+     * different durations for the ripples: `enter` and `leave`. The durations will be overwritten
+     * by the value of `matRippleAnimation` or if animations are disabled.
+     */
+    animation?: RippleAnimationConfig;
+    /**
+     * Whether ripples should start fading out immediately after the mouse or touch is released. By
+     * default, ripples will wait for the enter animation to complete and for mouse or touch release.
+     */
+    terminateOnPointerUp?: boolean;
+    /**
+     * A namespace to use for ripple loader to allow multiple instances to exist on the same page.
+     */
+    namespace?: string;
+}
+/** Injection token that can be used to specify the global ripple options. */
+declare const MAT_RIPPLE_GLOBAL_OPTIONS: InjectionToken<RippleGlobalOptions>;
+declare class MatRipple implements OnInit, OnDestroy, RippleTarget {
+    private _elementRef;
+    private _animationsDisabled;
+    /** Custom color for all ripples. */
+    color: string;
+    /** Whether the ripples should be visible outside the component's bounds. */
+    unbounded: boolean;
+    /**
+     * Whether the ripple always originates from the center of the host element's bounds, rather
+     * than originating from the location of the click event.
+     */
+    centered: boolean;
+    /**
+     * If set, the radius in pixels of foreground ripples when fully expanded. If unset, the radius
+     * will be the distance from the center of the ripple to the furthest corner of the host element's
+     * bounding rectangle.
+     */
+    radius: number;
+    /**
+     * Configuration for the ripple animation. Allows modifying the enter and exit animation
+     * duration of the ripples. The animation durations will be overwritten if animations are
+     * disabled.
+     */
+    animation: RippleAnimationConfig;
+    /**
+     * Whether click events will not trigger the ripple. Ripples can be still launched manually
+     * by using the `launch()` method.
+     */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _disabled;
+    /**
+     * The element that triggers the ripple when click events are received.
+     * Defaults to the directive's host element.
+     */
+    get trigger(): HTMLElement;
+    set trigger(trigger: HTMLElement);
+    private _trigger;
+    /** Renderer for the ripple DOM manipulations. */
+    private _rippleRenderer;
+    /** Options that are set globally for all ripples. */
+    private _globalOptions;
+    /** @docs-private Whether ripple directive is initialized and the input bindings are set. */
+    _isInitialized: boolean;
+    constructor(...args: unknown[]);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** Fades out all currently showing ripple elements. */
+    fadeOutAll(): void;
+    /** Fades out all currently showing non-persistent ripple elements. */
+    fadeOutAllNonPersistent(): void;
+    /**
+     * Ripple configuration from the directive's input values.
+     * @docs-private Implemented as part of RippleTarget
+     */
+    get rippleConfig(): RippleConfig;
+    /**
+     * Whether ripples on pointer-down are disabled or not.
+     * @docs-private Implemented as part of RippleTarget
+     */
+    get rippleDisabled(): boolean;
+    /** Sets up the trigger event listeners if ripples are enabled. */
+    private _setupTriggerEventsIfEnabled;
+    /**
+     * Launches a manual ripple using the specified ripple configuration.
+     * @param config Configuration for the manual ripple.
+     */
+    launch(config: RippleConfig): RippleRef;
+    /**
+     * Launches a manual ripple at the specified coordinates relative to the viewport.
+     * @param x Coordinate along the X axis at which to fade-in the ripple. Coordinate
+     *   should be relative to the viewport.
+     * @param y Coordinate along the Y axis at which to fade-in the ripple. Coordinate
+     *   should be relative to the viewport.
+     * @param config Optional ripple configuration for the manual ripple.
+     */
+    launch(x: number, y: number, config?: RippleConfig): RippleRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatRipple, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatRipple, "[mat-ripple], [matRipple]", ["matRipple"], { "color": { "alias": "matRippleColor"; "required": false; }; "unbounded": { "alias": "matRippleUnbounded"; "required": false; }; "centered": { "alias": "matRippleCentered"; "required": false; }; "radius": { "alias": "matRippleRadius"; "required": false; }; "animation": { "alias": "matRippleAnimation"; "required": false; }; "disabled": { "alias": "matRippleDisabled"; "required": false; }; "trigger": { "alias": "matRippleTrigger"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { MAT_RIPPLE_GLOBAL_OPTIONS, MatRipple, RippleRef, RippleRenderer, RippleState, defaultRippleAnimationConfig };
+export type { RippleAnimationConfig, RippleConfig, RippleGlobalOptions, RippleTarget };

package/types/_ripple-loader-chunk.d.ts

@@ -0,0 +1,48 @@
+import * as i0 from '@angular/core';
+import { OnDestroy } from '@angular/core';
+
+/**
+ * Handles attaching ripples on demand.
+ *
+ * This service allows us to avoid eagerly creating & attaching MatRipples.
+ * It works by creating & attaching a ripple only when a component is first interacted with.
+ *
+ * @docs-private
+ */
+declare class MatRippleLoader implements OnDestroy {
+    private _document;
+    private _animationsDisabled;
+    private _globalRippleOptions;
+    private _platform;
+    private _ngZone;
+    private _injector;
+    private _eventCleanups;
+    private _hosts;
+    constructor();
+    ngOnDestroy(): void;
+    /**
+     * Configures the ripple that will be rendered by the ripple loader.
+     *
+     * Stores the given information about how the ripple should be configured on the host
+     * element so that it can later be retrived & used when the ripple is actually created.
+     */
+    configureRipple(host: HTMLElement, config: {
+        className?: string;
+        centered?: boolean;
+        disabled?: boolean;
+    }): void;
+    /** Sets the disabled state on the ripple instance corresponding to the given host element. */
+    setDisabled(host: HTMLElement, disabled: boolean): void;
+    /**
+     * Handles creating and attaching component internals
+     * when a component is initially interacted with.
+     */
+    private _onInteraction;
+    /** Creates a MatRipple and appends it to the given element. */
+    private _createRipple;
+    destroyRipple(host: HTMLElement): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatRippleLoader, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MatRippleLoader>;
+}
+
+export { MatRippleLoader };

package/types/_ripple-module-chunk.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from '@angular/core';
+import { MatRipple } from './_ripple-chunk.js';
+import * as i2 from '@angular/cdk/bidi';
+
+declare class MatRippleModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatRippleModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatRippleModule, never, [typeof MatRipple], [typeof MatRipple, typeof i2.BidiModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatRippleModule>;
+}
+
+export { MatRippleModule };