@depup/angular__material 21.2.2-depup.19

package/types/snack-bar-testing.d.ts

@@ -0,0 +1,64 @@
+import { BaseHarnessFilters, ContentContainerComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+import { AriaLivePoliteness } from '@angular/cdk/a11y';
+
+/** A set of criteria that can be used to filter a list of `MatSnackBarHarness` instances. */
+interface SnackBarHarnessFilters extends BaseHarnessFilters {
+}
+
+/** Harness for interacting with a mat-snack-bar in tests. */
+declare class MatSnackBarHarness extends ContentContainerComponentHarness<string> {
+    /** The selector for the host element of a `MatSnackBar` instance. */
+    static hostSelector: string;
+    private _messageSelector;
+    private _actionButtonSelector;
+    private _snackBarLiveRegion;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `MatSnackBarHarness` that meets
+     * certain criteria.
+     * @param options Options for filtering which snack bar instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options?: SnackBarHarnessFilters): HarnessPredicate<MatSnackBarHarness>;
+    /**
+     * Gets the role of the snack-bar. The role of a snack-bar is determined based
+     * on the ARIA politeness specified in the snack-bar config.
+     * @deprecated Use `getAriaLive` instead.
+     * @breaking-change 13.0.0
+     */
+    getRole(): Promise<'alert' | 'status' | null>;
+    /**
+     * Gets the aria-live of the snack-bar's live region. The aria-live of a snack-bar is
+     * determined based on the ARIA politeness specified in the snack-bar config.
+     */
+    getAriaLive(): Promise<AriaLivePoliteness>;
+    /**
+     * Whether the snack-bar has an action. Method cannot be used for snack-bar's with custom content.
+     */
+    hasAction(): Promise<boolean>;
+    /**
+     * Gets the description of the snack-bar. Method cannot be used for snack-bar's without action or
+     * with custom content.
+     */
+    getActionDescription(): Promise<string>;
+    /**
+     * Dismisses the snack-bar by clicking the action button. Method cannot be used for snack-bar's
+     * without action or with custom content.
+     */
+    dismissWithAction(): Promise<void>;
+    /**
+     * Gets the message of the snack-bar. Method cannot be used for snack-bar's with custom content.
+     */
+    getMessage(): Promise<string>;
+    /** Gets whether the snack-bar has been dismissed. */
+    isDismissed(): Promise<boolean>;
+    /**
+     * Asserts that the current snack-bar has an action defined. Otherwise the
+     * promise will reject.
+     */
+    private _assertHasAction;
+    /** Gets the simple snack bar action button. */
+    private _getActionButton;
+}
+
+export { MatSnackBarHarness };
+export type { SnackBarHarnessFilters };

package/types/snack-bar.d.ts

@@ -0,0 +1,328 @@
+import * as i2 from '@angular/cdk/overlay';
+import { OverlayRef, ComponentType } from '@angular/cdk/overlay';
+import { Subject, Observable } from 'rxjs';
+import { AriaLivePoliteness } from '@angular/cdk/a11y';
+import * as i2$1 from '@angular/cdk/portal';
+import { BasePortalOutlet, CdkPortalOutlet, ComponentPortal, TemplatePortal, DomPortal } from '@angular/cdk/portal';
+import * as i0 from '@angular/core';
+import { InjectionToken, ViewContainerRef, OnDestroy, ElementRef, ComponentRef, EmbeddedViewRef, TemplateRef } from '@angular/core';
+import * as i2$2 from '@angular/cdk/bidi';
+import { Direction } from '@angular/cdk/bidi';
+import { MatButtonModule } from './button.js';
+import './_palette-chunk.js';
+import './_ripple-loader-chunk.js';
+import './_ripple-module-chunk.js';
+import './_ripple-chunk.js';
+import '@angular/cdk/platform';
+
+/** Injection token that can be used to access the data that was passed in to a snack bar. */
+declare const MAT_SNACK_BAR_DATA: InjectionToken<any>;
+/** Possible values for horizontalPosition on MatSnackBarConfig. */
+type MatSnackBarHorizontalPosition = 'start' | 'center' | 'end' | 'left' | 'right';
+/** Possible values for verticalPosition on MatSnackBarConfig. */
+type MatSnackBarVerticalPosition = 'top' | 'bottom';
+/**
+ * Configuration used when opening a snack-bar.
+ */
+declare class MatSnackBarConfig<D = any> {
+    /** The politeness level for the MatAriaLiveAnnouncer announcement. */
+    politeness?: AriaLivePoliteness;
+    /**
+     * Message to be announced by the LiveAnnouncer. When opening a snackbar without a custom
+     * component or template, the announcement message will default to the specified message.
+     */
+    announcementMessage?: string;
+    /**
+     * The view container that serves as the parent for the snackbar for the purposes of dependency
+     * injection. Note: this does not affect where the snackbar is inserted in the DOM.
+     */
+    viewContainerRef?: ViewContainerRef;
+    /** The length of time in milliseconds to wait before automatically dismissing the snack bar. */
+    duration?: number;
+    /** Extra CSS classes to be added to the snack bar container. */
+    panelClass?: string | string[];
+    /** Text layout direction for the snack bar. */
+    direction?: Direction;
+    /** Data being injected into the child component. */
+    data?: D | null;
+    /** The horizontal position to place the snack bar. */
+    horizontalPosition?: MatSnackBarHorizontalPosition;
+    /** The vertical position to place the snack bar. */
+    verticalPosition?: MatSnackBarVerticalPosition;
+}
+
+/**
+ * Internal component that wraps user-provided snack bar content.
+ * @docs-private
+ */
+declare class MatSnackBarContainer extends BasePortalOutlet implements OnDestroy {
+    private _ngZone;
+    readonly _elementRef: ElementRef<HTMLElement>;
+    private _changeDetectorRef;
+    private _platform;
+    protected _animationsDisabled: boolean;
+    snackBarConfig: MatSnackBarConfig<any>;
+    private _document;
+    private _trackedModals;
+    private _enterFallback;
+    private _exitFallback;
+    private _injector;
+    /** The number of milliseconds to wait before announcing the snack bar's content. */
+    private readonly _announceDelay;
+    /** The timeout for announcing the snack bar's content. */
+    private _announceTimeoutId;
+    /** Whether the component has been destroyed. */
+    private _destroyed;
+    /** The portal outlet inside of this container into which the snack bar content will be loaded. */
+    _portalOutlet: CdkPortalOutlet;
+    /** Subject for notifying that the snack bar has announced to screen readers. */
+    readonly _onAnnounce: Subject<void>;
+    /** Subject for notifying that the snack bar has exited from view. */
+    readonly _onExit: Subject<void>;
+    /** Subject for notifying that the snack bar has finished entering the view. */
+    readonly _onEnter: Subject<void>;
+    /** The state of the snack bar animations. */
+    _animationState: string;
+    /** aria-live value for the live region. */
+    _live: AriaLivePoliteness;
+    /**
+     * Element that will have the `mdc-snackbar__label` class applied if the attached component
+     * or template does not have it. This ensures that the appropriate structure, typography, and
+     * color is applied to the attached view.
+     */
+    _label: ElementRef;
+    /**
+     * Role of the live region. This is only for Firefox as there is a known issue where Firefox +
+     * JAWS does not read out aria-live message.
+     */
+    _role?: 'status' | 'alert';
+    /** Unique ID of the aria-live element. */
+    readonly _liveElementId: string;
+    constructor(...args: unknown[]);
+    /** Attach a component portal as content to this snack bar container. */
+    attachComponentPortal<T>(portal: ComponentPortal<T>): ComponentRef<T>;
+    /** Attach a template portal as content to this snack bar container. */
+    attachTemplatePortal<C>(portal: TemplatePortal<C>): EmbeddedViewRef<C>;
+    /**
+     * Attaches a DOM portal to the snack bar container.
+     * @deprecated To be turned into a method.
+     * @breaking-change 10.0.0
+     */
+    attachDomPortal: (portal: DomPortal) => void;
+    /** Handle end of animations, updating the state of the snackbar. */
+    onAnimationEnd(animationName: string): void;
+    /** Begin animation of snack bar entrance into view. */
+    enter(): void;
+    /** Begin animation of the snack bar exiting from view. */
+    exit(): Observable<void>;
+    /** Makes sure the exit callbacks have been invoked when the element is destroyed. */
+    ngOnDestroy(): void;
+    private _completeExit;
+    /**
+     * Called after the portal contents have been attached. Can be
+     * used to modify the DOM once it's guaranteed to be in place.
+     */
+    private _afterPortalAttached;
+    /**
+     * Some browsers won't expose the accessibility node of the live element if there is an
+     * `aria-modal` and the live element is outside of it. This method works around the issue by
+     * pointing the `aria-owns` of all modals to the live element.
+     */
+    private _exposeToModals;
+    /** Clears the references to the live element from any modals it was added to. */
+    private _clearFromModals;
+    /** Asserts that no content is already attached to the container. */
+    private _assertNotAttached;
+    /**
+     * Starts a timeout to move the snack bar content to the live region so screen readers will
+     * announce it.
+     */
+    private _screenReaderAnnounce;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatSnackBarContainer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatSnackBarContainer, "mat-snack-bar-container", never, {}, {}, never, never, true, never>;
+}
+
+/** Event that is emitted when a snack bar is dismissed. */
+interface MatSnackBarDismiss {
+    /** Whether the snack bar was dismissed using the action button. */
+    dismissedByAction: boolean;
+}
+/**
+ * Reference to a snack bar dispatched from the snack bar service.
+ */
+declare class MatSnackBarRef<T> {
+    private _overlayRef;
+    /** The instance of the component making up the content of the snack bar. */
+    instance: T;
+    /**
+     * The instance of the component making up the content of the snack bar.
+     * @docs-private
+     */
+    containerInstance: MatSnackBarContainer;
+    /** Subject for notifying the user that the snack bar has been dismissed. */
+    private readonly _afterDismissed;
+    /** Subject for notifying the user that the snack bar has opened and appeared. */
+    private readonly _afterOpened;
+    /** Subject for notifying the user that the snack bar action was called. */
+    private readonly _onAction;
+    /**
+     * Timeout ID for the duration setTimeout call. Used to clear the timeout if the snackbar is
+     * dismissed before the duration passes.
+     */
+    private _durationTimeoutId;
+    /** Whether the snack bar was dismissed using the action button. */
+    private _dismissedByAction;
+    constructor(containerInstance: MatSnackBarContainer, _overlayRef: OverlayRef);
+    /** Dismisses the snack bar. */
+    dismiss(): void;
+    /** Marks the snackbar action clicked. */
+    dismissWithAction(): void;
+    /**
+     * Marks the snackbar action clicked.
+     * @deprecated Use `dismissWithAction` instead.
+     * @breaking-change 8.0.0
+     */
+    closeWithAction(): void;
+    /** Dismisses the snack bar after some duration */
+    _dismissAfter(duration: number): void;
+    /** Marks the snackbar as opened */
+    _open(): void;
+    /** Cleans up the DOM after closing. */
+    private _finishDismiss;
+    /** Gets an observable that is notified when the snack bar is finished closing. */
+    afterDismissed(): Observable<MatSnackBarDismiss>;
+    /** Gets an observable that is notified when the snack bar has opened and appeared. */
+    afterOpened(): Observable<void>;
+    /** Gets an observable that is notified when the snack bar action is called. */
+    onAction(): Observable<void>;
+}
+
+/**
+ * Interface for a simple snack bar component that has a message and a single action.
+ */
+interface TextOnlySnackBar {
+    data: {
+        message: string;
+        action: string;
+    };
+    snackBarRef: MatSnackBarRef<TextOnlySnackBar>;
+    action: () => void;
+    hasAction: boolean;
+}
+declare class SimpleSnackBar implements TextOnlySnackBar {
+    snackBarRef: MatSnackBarRef<SimpleSnackBar>;
+    data: any;
+    constructor(...args: unknown[]);
+    /** Performs the action on the snack bar. */
+    action(): void;
+    /** If the action button should be shown. */
+    get hasAction(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SimpleSnackBar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SimpleSnackBar, "simple-snack-bar", ["matSnackBar"], {}, {}, never, never, true, never>;
+}
+
+/** Directive that should be applied to the text element to be rendered in the snack bar. */
+declare class MatSnackBarLabel {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatSnackBarLabel, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatSnackBarLabel, "[matSnackBarLabel]", never, {}, {}, never, never, true, never>;
+}
+/** Directive that should be applied to the element containing the snack bar's action buttons. */
+declare class MatSnackBarActions {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatSnackBarActions, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatSnackBarActions, "[matSnackBarActions]", never, {}, {}, never, never, true, never>;
+}
+/** Directive that should be applied to each of the snack bar's action buttons. */
+declare class MatSnackBarAction {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatSnackBarAction, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatSnackBarAction, "[matSnackBarAction]", never, {}, {}, never, never, true, never>;
+}
+
+/** Injection token that can be used to specify default snack bar. */
+declare const MAT_SNACK_BAR_DEFAULT_OPTIONS: InjectionToken<MatSnackBarConfig<any>>;
+/**
+ * Service to dispatch Material Design snack bar messages.
+ */
+declare class MatSnackBar implements OnDestroy {
+    private _live;
+    private _injector;
+    private _breakpointObserver;
+    private _parentSnackBar;
+    private _defaultConfig;
+    private _animationsDisabled;
+    /**
+     * Reference to the current snack bar in the view *at this level* (in the Angular injector tree).
+     * If there is a parent snack-bar service, all operations should delegate to that parent
+     * via `_openedSnackBarRef`.
+     */
+    private _snackBarRefAtThisLevel;
+    /** The component that should be rendered as the snack bar's simple component. */
+    simpleSnackBarComponent: typeof SimpleSnackBar;
+    /** The container component that attaches the provided template or component. */
+    snackBarContainerComponent: typeof MatSnackBarContainer;
+    /** The CSS class to apply for handset mode. */
+    handsetCssClass: string;
+    /** Reference to the currently opened snackbar at *any* level. */
+    get _openedSnackBarRef(): MatSnackBarRef<any> | null;
+    set _openedSnackBarRef(value: MatSnackBarRef<any> | null);
+    constructor(...args: unknown[]);
+    /**
+     * Creates and dispatches a snack bar with a custom component for the content, removing any
+     * currently opened snack bars.
+     *
+     * @param component Component to be instantiated.
+     * @param config Extra configuration for the snack bar.
+     */
+    openFromComponent<T, D = any>(component: ComponentType<T>, config?: MatSnackBarConfig<D>): MatSnackBarRef<T>;
+    /**
+     * Creates and dispatches a snack bar with a custom template for the content, removing any
+     * currently opened snack bars.
+     *
+     * @param template Template to be instantiated.
+     * @param config Extra configuration for the snack bar.
+     */
+    openFromTemplate(template: TemplateRef<any>, config?: MatSnackBarConfig): MatSnackBarRef<EmbeddedViewRef<any>>;
+    /**
+     * Opens a snackbar with a message and an optional action.
+     * @param message The message to show in the snackbar.
+     * @param action The label for the snackbar action.
+     * @param config Additional configuration options for the snackbar.
+     */
+    open(message: string, action?: string, config?: MatSnackBarConfig): MatSnackBarRef<TextOnlySnackBar>;
+    /**
+     * Dismisses the currently-visible snack bar.
+     */
+    dismiss(): void;
+    ngOnDestroy(): void;
+    /**
+     * Attaches the snack bar container component to the overlay.
+     */
+    private _attachSnackBarContainer;
+    /**
+     * Places a new component or a template as the content of the snack bar container.
+     */
+    private _attach;
+    /** Animates the old snack bar out and the new one in. */
+    private _animateSnackBar;
+    /**
+     * Creates a new overlay and places it in the correct location.
+     * @param config The user-specified snack bar config.
+     */
+    private _createOverlay;
+    /**
+     * Creates an injector to be used inside of a snack bar component.
+     * @param config Config that was used to create the snack bar.
+     * @param snackBarRef Reference to the snack bar.
+     */
+    private _createInjector;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatSnackBar, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MatSnackBar>;
+}
+
+declare class MatSnackBarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatSnackBarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatSnackBarModule, never, [typeof i2.OverlayModule, typeof i2$1.PortalModule, typeof MatButtonModule, typeof SimpleSnackBar, typeof MatSnackBarContainer, typeof MatSnackBarLabel, typeof MatSnackBarActions, typeof MatSnackBarAction], [typeof i2$2.BidiModule, typeof MatSnackBarContainer, typeof MatSnackBarLabel, typeof MatSnackBarActions, typeof MatSnackBarAction]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatSnackBarModule>;
+}
+
+export { MAT_SNACK_BAR_DATA, MAT_SNACK_BAR_DEFAULT_OPTIONS, MatSnackBar, MatSnackBarAction, MatSnackBarActions, MatSnackBarConfig, MatSnackBarContainer, MatSnackBarLabel, MatSnackBarModule, MatSnackBarRef, SimpleSnackBar };
+export type { MatSnackBarDismiss, MatSnackBarHorizontalPosition, MatSnackBarVerticalPosition, TextOnlySnackBar };

package/types/sort-testing.d.ts

@@ -0,0 +1,48 @@
+import { BaseHarnessFilters, ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+import { SortDirection } from './_sort-direction-chunk.js';
+
+interface SortHarnessFilters extends BaseHarnessFilters {
+}
+interface SortHeaderHarnessFilters extends BaseHarnessFilters {
+    label?: string | RegExp;
+    sortDirection?: SortDirection;
+}
+
+/** Harness for interacting with a standard Angular Material sort header in tests. */
+declare class MatSortHeaderHarness extends ComponentHarness {
+    static hostSelector: string;
+    private _container;
+    /**
+     * Gets a `HarnessPredicate` that can be used to
+     * search for a sort header with specific attributes.
+     */
+    static with(options?: SortHeaderHarnessFilters): HarnessPredicate<MatSortHeaderHarness>;
+    /** Gets the label of the sort header. */
+    getLabel(): Promise<string>;
+    /** Gets the sorting direction of the header. */
+    getSortDirection(): Promise<SortDirection>;
+    /** Gets whether the sort header is currently being sorted by. */
+    isActive(): Promise<boolean>;
+    /** Whether the sort header is disabled. */
+    isDisabled(): Promise<boolean>;
+    /** Clicks the header to change its sorting direction. Only works if the header is enabled. */
+    click(): Promise<void>;
+}
+
+/** Harness for interacting with a standard `mat-sort` in tests. */
+declare class MatSortHarness extends ComponentHarness {
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `mat-sort` with specific attributes.
+     * @param options Options for narrowing the search.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options?: SortHarnessFilters): HarnessPredicate<MatSortHarness>;
+    /** Gets all of the sort headers in the `mat-sort`. */
+    getSortHeaders(filter?: SortHeaderHarnessFilters): Promise<MatSortHeaderHarness[]>;
+    /** Gets the selected header in the `mat-sort`. */
+    getActiveHeader(): Promise<MatSortHeaderHarness | null>;
+}
+
+export { MatSortHarness, MatSortHeaderHarness };
+export type { SortHarnessFilters, SortHeaderHarnessFilters };

package/types/sort.d.ts

@@ -0,0 +1,126 @@
+import * as i0 from '@angular/core';
+import { OnDestroy, OnInit, AfterViewInit } from '@angular/core';
+import { MatSortable, MatSort, SortHeaderArrowPosition } from './_sort-chunk.js';
+export { MAT_SORT_DEFAULT_OPTIONS, MatSortDefaultOptions, Sort } from './_sort-chunk.js';
+import { SortDirection } from './_sort-direction-chunk.js';
+import * as i2 from '@angular/cdk/bidi';
+import { Subject } from 'rxjs';
+
+/**
+ * Valid positions for the arrow to be in for its opacity and translation. If the state is a
+ * sort direction, the position of the arrow will be above/below and opacity 0. If the state is
+ * hint, the arrow will be in the center with a slight opacity. Active state means the arrow will
+ * be fully opaque in the center.
+ *
+ * @docs-private
+ * @deprecated No longer being used, to be removed.
+ * @breaking-change 21.0.0
+ */
+type ArrowViewState = SortDirection | 'hint' | 'active';
+/**
+ * States describing the arrow's animated position (animating fromState to toState).
+ * If the fromState is not defined, there will be no animated transition to the toState.
+ * @docs-private
+ * @deprecated No longer being used, to be removed.
+ * @breaking-change 21.0.0
+ */
+interface ArrowViewStateTransition {
+    fromState?: ArrowViewState;
+    toState?: ArrowViewState;
+}
+/**
+ * Applies sorting behavior (click to change sort) and styles to an element, including an
+ * arrow to display the current sort direction.
+ *
+ * Must be provided with an id and contained within a parent MatSort directive.
+ *
+ * If used on header cells in a CdkTable, it will automatically default its id from its containing
+ * column definition.
+ */
+declare class MatSortHeader implements MatSortable, OnDestroy, OnInit, AfterViewInit {
+    protected _sort: MatSort;
+    private _columnDef;
+    private _changeDetectorRef;
+    private _focusMonitor;
+    private _elementRef;
+    private _ariaDescriber;
+    private _renderChanges;
+    protected _animationsDisabled: boolean;
+    /**
+     * Indicates which state was just cleared from the sort header.
+     * Will be reset on the next interaction. Used for coordinating animations.
+     */
+    protected _recentlyCleared: i0.WritableSignal<SortDirection | null>;
+    /**
+     * The element with role="button" inside this component's view. We need this
+     * in order to apply a description with AriaDescriber.
+     */
+    private _sortButton;
+    /**
+     * ID of this sort header. If used within the context of a CdkColumnDef, this will default to
+     * the column's name.
+     */
+    id: string;
+    /** Sets the position of the arrow that displays when sorted. */
+    arrowPosition: SortHeaderArrowPosition;
+    /** Overrides the sort start value of the containing MatSort for this MatSortable. */
+    start: SortDirection;
+    /** whether the sort header is disabled. */
+    disabled: boolean;
+    /**
+     * Description applied to MatSortHeader's button element with aria-describedby. This text should
+     * describe the action that will occur when the user clicks the sort header.
+     */
+    get sortActionDescription(): string;
+    set sortActionDescription(value: string);
+    private _sortActionDescription;
+    /** Overrides the disable clear value of the containing MatSort for this MatSortable. */
+    disableClear: boolean;
+    constructor(...args: unknown[]);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /** Triggers the sort on this sort header and removes the indicator hint. */
+    _toggleOnInteraction(): void;
+    _handleKeydown(event: KeyboardEvent): void;
+    /** Whether this MatSortHeader is currently sorted in either ascending or descending order. */
+    _isSorted(): boolean;
+    _isDisabled(): boolean;
+    /**
+     * Gets the aria-sort attribute that should be applied to this sort header. If this header
+     * is not sorted, returns null so that the attribute is removed from the host element. Aria spec
+     * says that the aria-sort property should only be present on one header at a time, so removing
+     * ensures this is true.
+     */
+    _getAriaSortAttribute(): "none" | "ascending" | "descending";
+    /** Whether the arrow inside the sort header should be rendered. */
+    _renderArrow(): boolean;
+    private _updateSortActionDescription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatSortHeader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatSortHeader, "[mat-sort-header]", ["matSortHeader"], { "id": { "alias": "mat-sort-header"; "required": false; }; "arrowPosition": { "alias": "arrowPosition"; "required": false; }; "start": { "alias": "start"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "sortActionDescription": { "alias": "sortActionDescription"; "required": false; }; "disableClear": { "alias": "disableClear"; "required": false; }; }, {}, never, ["*", "[matSortHeaderIcon]"], true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_disableClear: unknown;
+}
+
+declare class MatSortModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatSortModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatSortModule, never, [typeof MatSort, typeof MatSortHeader], [typeof MatSort, typeof MatSortHeader, typeof i2.BidiModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatSortModule>;
+}
+
+/**
+ * To modify the labels and text displayed, create a new instance of MatSortHeaderIntl and
+ * include it in a custom provider.
+ */
+declare class MatSortHeaderIntl {
+    /**
+     * Stream that emits whenever the labels here are changed. Use this to notify
+     * components if the labels have changed after initialization.
+     */
+    readonly changes: Subject<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatSortHeaderIntl, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MatSortHeaderIntl>;
+}
+
+export { MatSort, MatSortHeader, MatSortHeaderIntl, MatSortModule, MatSortable, SortDirection, SortHeaderArrowPosition };
+export type { ArrowViewState, ArrowViewStateTransition };