@angular/cdk 14.0.0-next.12 → 14.0.0-next.13

package/a11y/focus-monitor/focus-monitor.d.ts

@@ -1,209 +0,0 @@
-/**
- * @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
- */
-import { Platform } from '@angular/cdk/platform';
-import { ElementRef, EventEmitter, InjectionToken, NgZone, OnDestroy, AfterViewInit } from '@angular/core';
-import { Observable } from 'rxjs';
-import { InputModalityDetector } from '../input-modality/input-modality-detector';
-import * as i0 from "@angular/core";
-export declare type FocusOrigin = 'touch' | 'mouse' | 'keyboard' | 'program' | null;
-/**
- * Corresponds to the options that can be passed to the native `focus` event.
- * via https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus
- */
-export interface FocusOptions {
-    /** Whether the browser should scroll to the element when it is focused. */
-    preventScroll?: boolean;
-}
-/** Detection mode used for attributing the origin of a focus event. */
-export declare const enum FocusMonitorDetectionMode {
-    /**
-     * Any mousedown, keydown, or touchstart event that happened in the previous
-     * tick or the current tick will be used to assign a focus event's origin (to
-     * either mouse, keyboard, or touch). This is the default option.
-     */
-    IMMEDIATE = 0,
-    /**
-     * A focus event's origin is always attributed to the last corresponding
-     * mousedown, keydown, or touchstart event, no matter how long ago it occurred.
-     */
-    EVENTUAL = 1
-}
-/** Injectable service-level options for FocusMonitor. */
-export interface FocusMonitorOptions {
-    detectionMode?: FocusMonitorDetectionMode;
-}
-/** InjectionToken for FocusMonitorOptions. */
-export declare const FOCUS_MONITOR_DEFAULT_OPTIONS: InjectionToken<FocusMonitorOptions>;
-/** Monitors mouse and keyboard events to determine the cause of focus events. */
-export declare class FocusMonitor implements OnDestroy {
-    private _ngZone;
-    private _platform;
-    private readonly _inputModalityDetector;
-    /** The focus origin that the next focus event is a result of. */
-    private _origin;
-    /** The FocusOrigin of the last focus event tracked by the FocusMonitor. */
-    private _lastFocusOrigin;
-    /** Whether the window has just been focused. */
-    private _windowFocused;
-    /** The timeout id of the window focus timeout. */
-    private _windowFocusTimeoutId;
-    /** The timeout id of the origin clearing timeout. */
-    private _originTimeoutId;
-    /**
-     * Whether the origin was determined via a touch interaction. Necessary as properly attributing
-     * focus events to touch interactions requires special logic.
-     */
-    private _originFromTouchInteraction;
-    /** Map of elements being monitored to their info. */
-    private _elementInfo;
-    /** The number of elements currently being monitored. */
-    private _monitoredElementCount;
-    /**
-     * Keeps track of the root nodes to which we've currently bound a focus/blur handler,
-     * as well as the number of monitored elements that they contain. We have to treat focus/blur
-     * handlers differently from the rest of the events, because the browser won't emit events
-     * to the document when focus moves inside of a shadow root.
-     */
-    private _rootNodeFocusListenerCount;
-    /**
-     * The specified detection mode, used for attributing the origin of a focus
-     * event.
-     */
-    private readonly _detectionMode;
-    /**
-     * Event listener for `focus` events on the window.
-     * Needs to be an arrow function in order to preserve the context when it gets bound.
-     */
-    private _windowFocusListener;
-    /** Used to reference correct document/window */
-    protected _document?: Document;
-    /** Subject for stopping our InputModalityDetector subscription. */
-    private readonly _stopInputModalityDetector;
-    constructor(_ngZone: NgZone, _platform: Platform, _inputModalityDetector: InputModalityDetector, 
-    /** @breaking-change 11.0.0 make document required */
-    document: any | null, options: FocusMonitorOptions | null);
-    /**
-     * Event listener for `focus` and 'blur' events on the document.
-     * Needs to be an arrow function in order to preserve the context when it gets bound.
-     */
-    private _rootNodeFocusAndBlurListener;
-    /**
-     * Monitors focus on an element and applies appropriate CSS classes.
-     * @param element The element to monitor
-     * @param checkChildren Whether to count the element as focused when its children are focused.
-     * @returns An observable that emits when the focus state of the element changes.
-     *     When the element is blurred, null will be emitted.
-     */
-    monitor(element: HTMLElement, checkChildren?: boolean): Observable<FocusOrigin>;
-    /**
-     * Monitors focus on an element and applies appropriate CSS classes.
-     * @param element The element to monitor
-     * @param checkChildren Whether to count the element as focused when its children are focused.
-     * @returns An observable that emits when the focus state of the element changes.
-     *     When the element is blurred, null will be emitted.
-     */
-    monitor(element: ElementRef<HTMLElement>, checkChildren?: boolean): Observable<FocusOrigin>;
-    /**
-     * Stops monitoring an element and removes all focus classes.
-     * @param element The element to stop monitoring.
-     */
-    stopMonitoring(element: HTMLElement): void;
-    /**
-     * Stops monitoring an element and removes all focus classes.
-     * @param element The element to stop monitoring.
-     */
-    stopMonitoring(element: ElementRef<HTMLElement>): void;
-    /**
-     * Focuses the element via the specified focus origin.
-     * @param element Element to focus.
-     * @param origin Focus origin.
-     * @param options Options that can be used to configure the focus behavior.
-     */
-    focusVia(element: HTMLElement, origin: FocusOrigin, options?: FocusOptions): void;
-    /**
-     * Focuses the element via the specified focus origin.
-     * @param element Element to focus.
-     * @param origin Focus origin.
-     * @param options Options that can be used to configure the focus behavior.
-     */
-    focusVia(element: ElementRef<HTMLElement>, origin: FocusOrigin, options?: FocusOptions): void;
-    ngOnDestroy(): void;
-    /** Access injected document if available or fallback to global document reference */
-    private _getDocument;
-    /** Use defaultView of injected document if available or fallback to global window reference */
-    private _getWindow;
-    private _getFocusOrigin;
-    /**
-     * Returns whether the focus event should be attributed to touch. Recall that in IMMEDIATE mode, a
-     * touch origin isn't immediately reset at the next tick (see _setOrigin). This means that when we
-     * handle a focus event following a touch interaction, we need to determine whether (1) the focus
-     * event was directly caused by the touch interaction or (2) the focus event was caused by a
-     * subsequent programmatic focus call triggered by the touch interaction.
-     * @param focusEventTarget The target of the focus event under examination.
-     */
-    private _shouldBeAttributedToTouch;
-    /**
-     * Sets the focus classes on the element based on the given focus origin.
-     * @param element The element to update the classes on.
-     * @param origin The focus origin.
-     */
-    private _setClasses;
-    /**
-     * Updates the focus origin. If we're using immediate detection mode, we schedule an async
-     * function to clear the origin at the end of a timeout. The duration of the timeout depends on
-     * the origin being set.
-     * @param origin The origin to set.
-     * @param isFromInteraction Whether we are setting the origin from an interaction event.
-     */
-    private _setOrigin;
-    /**
-     * Handles focus events on a registered element.
-     * @param event The focus event.
-     * @param element The monitored element.
-     */
-    private _onFocus;
-    /**
-     * Handles blur events on a registered element.
-     * @param event The blur event.
-     * @param element The monitored element.
-     */
-    _onBlur(event: FocusEvent, element: HTMLElement): void;
-    private _emitOrigin;
-    private _registerGlobalListeners;
-    private _removeGlobalListeners;
-    /** Updates all the state on an element once its focus origin has changed. */
-    private _originChanged;
-    /**
-     * Collects the `MonitoredElementInfo` of a particular element and
-     * all of its ancestors that have enabled `checkChildren`.
-     * @param element Element from which to start the search.
-     */
-    private _getClosestElementsInfo;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FocusMonitor, [null, null, null, { optional: true; }, { optional: true; }]>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<FocusMonitor>;
-}
-/**
- * Directive that determines how a particular element was focused (via keyboard, mouse, touch, or
- * programmatically) and adds corresponding classes to the element.
- *
- * There are two variants of this directive:
- * 1) cdkMonitorElementFocus: does not consider an element to be focused if one of its children is
- *    focused.
- * 2) cdkMonitorSubtreeFocus: considers an element focused if it or any of its children are focused.
- */
-export declare class CdkMonitorFocus implements AfterViewInit, OnDestroy {
-    private _elementRef;
-    private _focusMonitor;
-    private _monitorSubscription;
-    readonly cdkFocusChange: EventEmitter<FocusOrigin>;
-    constructor(_elementRef: ElementRef<HTMLElement>, _focusMonitor: FocusMonitor);
-    ngAfterViewInit(): void;
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMonitorFocus, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMonitorFocus, "[cdkMonitorElementFocus], [cdkMonitorSubtreeFocus]", never, {}, { "cdkFocusChange": "cdkFocusChange"; }, never, never, false>;
-}

package/a11y/focus-trap/configurable-focus-trap-config.d.ts

@@ -1,16 +0,0 @@
-/**
- * @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
- */
-/**
- * Options for creating a ConfigurableFocusTrap.
- */
-export interface ConfigurableFocusTrapConfig {
-    /**
-     * Whether to defer the creation of FocusTrap elements to be done manually by the user.
-     */
-    defer: boolean;
-}

package/a11y/focus-trap/configurable-focus-trap-factory.d.ts

@@ -1,30 +0,0 @@
-import { NgZone } from '@angular/core';
-import { InteractivityChecker } from '../interactivity-checker/interactivity-checker';
-import { ConfigurableFocusTrap } from './configurable-focus-trap';
-import { ConfigurableFocusTrapConfig } from './configurable-focus-trap-config';
-import { FocusTrapInertStrategy } from './focus-trap-inert-strategy';
-import { FocusTrapManager } from './focus-trap-manager';
-import * as i0 from "@angular/core";
-/** Factory that allows easy instantiation of configurable focus traps. */
-export declare class ConfigurableFocusTrapFactory {
-    private _checker;
-    private _ngZone;
-    private _focusTrapManager;
-    private _document;
-    private _inertStrategy;
-    constructor(_checker: InteractivityChecker, _ngZone: NgZone, _focusTrapManager: FocusTrapManager, _document: any, _inertStrategy?: FocusTrapInertStrategy);
-    /**
-     * Creates a focus-trapped region around the given element.
-     * @param element The element around which focus will be trapped.
-     * @param config The focus trap configuration.
-     * @returns The created focus trap instance.
-     */
-    create(element: HTMLElement, config?: ConfigurableFocusTrapConfig): ConfigurableFocusTrap;
-    /**
-     * @deprecated Pass a config object instead of the `deferCaptureElements` flag.
-     * @breaking-change 11.0.0
-     */
-    create(element: HTMLElement, deferCaptureElements: boolean): ConfigurableFocusTrap;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurableFocusTrapFactory, [null, null, null, null, { optional: true; }]>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigurableFocusTrapFactory>;
-}

package/a11y/focus-trap/configurable-focus-trap.d.ts

@@ -1,33 +0,0 @@
-/**
- * @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
- */
-import { NgZone } from '@angular/core';
-import { InteractivityChecker } from '../interactivity-checker/interactivity-checker';
-import { FocusTrap } from './focus-trap';
-import { FocusTrapManager, ManagedFocusTrap } from './focus-trap-manager';
-import { FocusTrapInertStrategy } from './focus-trap-inert-strategy';
-import { ConfigurableFocusTrapConfig } from './configurable-focus-trap-config';
-/**
- * Class that allows for trapping focus within a DOM element.
- *
- * This class uses a strategy pattern that determines how it traps focus.
- * See FocusTrapInertStrategy.
- */
-export declare class ConfigurableFocusTrap extends FocusTrap implements ManagedFocusTrap {
-    private _focusTrapManager;
-    private _inertStrategy;
-    /** Whether the FocusTrap is enabled. */
-    get enabled(): boolean;
-    set enabled(value: boolean);
-    constructor(_element: HTMLElement, _checker: InteractivityChecker, _ngZone: NgZone, _document: Document, _focusTrapManager: FocusTrapManager, _inertStrategy: FocusTrapInertStrategy, config: ConfigurableFocusTrapConfig);
-    /** Notifies the FocusTrapManager that this FocusTrap will be destroyed. */
-    destroy(): void;
-    /** @docs-private Implemented as part of ManagedFocusTrap. */
-    _enable(): void;
-    /** @docs-private Implemented as part of ManagedFocusTrap. */
-    _disable(): void;
-}

package/a11y/focus-trap/event-listener-inert-strategy.d.ts

@@ -1,29 +0,0 @@
-/**
- * @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
- */
-import { FocusTrapInertStrategy } from './focus-trap-inert-strategy';
-import { ConfigurableFocusTrap } from './configurable-focus-trap';
-/**
- * Lightweight FocusTrapInertStrategy that adds a document focus event
- * listener to redirect focus back inside the FocusTrap.
- */
-export declare class EventListenerFocusTrapInertStrategy implements FocusTrapInertStrategy {
-    /** Focus event handler. */
-    private _listener;
-    /** Adds a document event listener that keeps focus inside the FocusTrap. */
-    preventFocus(focusTrap: ConfigurableFocusTrap): void;
-    /** Removes the event listener added in preventFocus. */
-    allowFocus(focusTrap: ConfigurableFocusTrap): void;
-    /**
-     * Refocuses the first element in the FocusTrap if the focus event target was outside
-     * the FocusTrap.
-     *
-     * This is an event listener callback. The event listener is added in runOutsideAngular,
-     * so all this code runs outside Angular as well.
-     */
-    private _trapFocus;
-}

package/a11y/focus-trap/focus-trap-inert-strategy.d.ts

@@ -1,21 +0,0 @@
-/**
- * @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
- */
-import { InjectionToken } from '@angular/core';
-import { FocusTrap } from './focus-trap';
-/** The injection token used to specify the inert strategy. */
-export declare const FOCUS_TRAP_INERT_STRATEGY: InjectionToken<FocusTrapInertStrategy>;
-/**
- * A strategy that dictates how FocusTrap should prevent elements
- * outside of the FocusTrap from being focused.
- */
-export interface FocusTrapInertStrategy {
-    /** Makes all elements outside focusTrap unfocusable. */
-    preventFocus(focusTrap: FocusTrap): void;
-    /** Reverts elements made unfocusable by preventFocus to their previous state. */
-    allowFocus(focusTrap: FocusTrap): void;
-}

package/a11y/focus-trap/focus-trap-manager.d.ts

@@ -1,26 +0,0 @@
-import * as i0 from "@angular/core";
-/**
- * A FocusTrap managed by FocusTrapManager.
- * Implemented by ConfigurableFocusTrap to avoid circular dependency.
- */
-export interface ManagedFocusTrap {
-    _enable(): void;
-    _disable(): void;
-    focusInitialElementWhenReady(): Promise<boolean>;
-}
-/** Injectable that ensures only the most recently enabled FocusTrap is active. */
-export declare class FocusTrapManager {
-    private _focusTrapStack;
-    /**
-     * Disables the FocusTrap at the top of the stack, and then pushes
-     * the new FocusTrap onto the stack.
-     */
-    register(focusTrap: ManagedFocusTrap): void;
-    /**
-     * Removes the FocusTrap from the stack, and activates the
-     * FocusTrap that is the new top of the stack.
-     */
-    deregister(focusTrap: ManagedFocusTrap): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FocusTrapManager, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<FocusTrapManager>;
-}

package/a11y/focus-trap/focus-trap.d.ts

@@ -1,163 +0,0 @@
-/**
- * @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
- */
-import { BooleanInput } from '@angular/cdk/coercion';
-import { AfterContentInit, ElementRef, NgZone, OnDestroy, DoCheck, SimpleChanges, OnChanges } from '@angular/core';
-import { InteractivityChecker } from '../interactivity-checker/interactivity-checker';
-import * as i0 from "@angular/core";
-/**
- * Class that allows for trapping focus within a DOM element.
- *
- * This class currently uses a relatively simple approach to focus trapping.
- * It assumes that the tab order is the same as DOM order, which is not necessarily true.
- * Things like `tabIndex > 0`, flex `order`, and shadow roots can cause the two to be misaligned.
- *
- * @deprecated Use `ConfigurableFocusTrap` instead.
- * @breaking-change 11.0.0
- */
-export declare class FocusTrap {
-    readonly _element: HTMLElement;
-    private _checker;
-    readonly _ngZone: NgZone;
-    readonly _document: Document;
-    private _startAnchor;
-    private _endAnchor;
-    private _hasAttached;
-    protected startAnchorListener: () => boolean;
-    protected endAnchorListener: () => boolean;
-    /** Whether the focus trap is active. */
-    get enabled(): boolean;
-    set enabled(value: boolean);
-    protected _enabled: boolean;
-    constructor(_element: HTMLElement, _checker: InteractivityChecker, _ngZone: NgZone, _document: Document, deferAnchors?: boolean);
-    /** Destroys the focus trap by cleaning up the anchors. */
-    destroy(): void;
-    /**
-     * Inserts the anchors into the DOM. This is usually done automatically
-     * in the constructor, but can be deferred for cases like directives with `*ngIf`.
-     * @returns Whether the focus trap managed to attach successfully. This may not be the case
-     * if the target element isn't currently in the DOM.
-     */
-    attachAnchors(): boolean;
-    /**
-     * Waits for the zone to stabilize, then focuses the first tabbable element.
-     * @returns Returns a promise that resolves with a boolean, depending
-     * on whether focus was moved successfully.
-     */
-    focusInitialElementWhenReady(options?: FocusOptions): Promise<boolean>;
-    /**
-     * Waits for the zone to stabilize, then focuses
-     * the first tabbable element within the focus trap region.
-     * @returns Returns a promise that resolves with a boolean, depending
-     * on whether focus was moved successfully.
-     */
-    focusFirstTabbableElementWhenReady(options?: FocusOptions): Promise<boolean>;
-    /**
-     * Waits for the zone to stabilize, then focuses
-     * the last tabbable element within the focus trap region.
-     * @returns Returns a promise that resolves with a boolean, depending
-     * on whether focus was moved successfully.
-     */
-    focusLastTabbableElementWhenReady(options?: FocusOptions): Promise<boolean>;
-    /**
-     * Get the specified boundary element of the trapped region.
-     * @param bound The boundary to get (start or end of trapped region).
-     * @returns The boundary element.
-     */
-    private _getRegionBoundary;
-    /**
-     * Focuses the element that should be focused when the focus trap is initialized.
-     * @returns Whether focus was moved successfully.
-     */
-    focusInitialElement(options?: FocusOptions): boolean;
-    /**
-     * Focuses the first tabbable element within the focus trap region.
-     * @returns Whether focus was moved successfully.
-     */
-    focusFirstTabbableElement(options?: FocusOptions): boolean;
-    /**
-     * Focuses the last tabbable element within the focus trap region.
-     * @returns Whether focus was moved successfully.
-     */
-    focusLastTabbableElement(options?: FocusOptions): boolean;
-    /**
-     * Checks whether the focus trap has successfully been attached.
-     */
-    hasAttached(): boolean;
-    /** Get the first tabbable element from a DOM subtree (inclusive). */
-    private _getFirstTabbableElement;
-    /** Get the last tabbable element from a DOM subtree (inclusive). */
-    private _getLastTabbableElement;
-    /** Creates an anchor element. */
-    private _createAnchor;
-    /**
-     * Toggles the `tabindex` of an anchor, based on the enabled state of the focus trap.
-     * @param isEnabled Whether the focus trap is enabled.
-     * @param anchor Anchor on which to toggle the tabindex.
-     */
-    private _toggleAnchorTabIndex;
-    /**
-     * Toggles the`tabindex` of both anchors to either trap Tab focus or allow it to escape.
-     * @param enabled: Whether the anchors should trap Tab.
-     */
-    protected toggleAnchors(enabled: boolean): void;
-    /** Executes a function when the zone is stable. */
-    private _executeOnStable;
-}
-/**
- * Factory that allows easy instantiation of focus traps.
- * @deprecated Use `ConfigurableFocusTrapFactory` instead.
- * @breaking-change 11.0.0
- */
-export declare class FocusTrapFactory {
-    private _checker;
-    private _ngZone;
-    private _document;
-    constructor(_checker: InteractivityChecker, _ngZone: NgZone, _document: any);
-    /**
-     * Creates a focus-trapped region around the given element.
-     * @param element The element around which focus will be trapped.
-     * @param deferCaptureElements Defers the creation of focus-capturing elements to be done
-     *     manually by the user.
-     * @returns The created focus trap instance.
-     */
-    create(element: HTMLElement, deferCaptureElements?: boolean): FocusTrap;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FocusTrapFactory, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<FocusTrapFactory>;
-}
-/** Directive for trapping focus within a region. */
-export declare class CdkTrapFocus implements OnDestroy, AfterContentInit, OnChanges, DoCheck {
-    private _elementRef;
-    private _focusTrapFactory;
-    /** Underlying FocusTrap instance. */
-    focusTrap: FocusTrap;
-    /** Previously focused element to restore focus to upon destroy when using autoCapture. */
-    private _previouslyFocusedElement;
-    /** Whether the focus trap is active. */
-    get enabled(): boolean;
-    set enabled(value: BooleanInput);
-    /**
-     * Whether the directive should automatically move focus into the trapped region upon
-     * initialization and return focus to the previous activeElement upon destruction.
-     */
-    get autoCapture(): boolean;
-    set autoCapture(value: BooleanInput);
-    private _autoCapture;
-    constructor(_elementRef: ElementRef<HTMLElement>, _focusTrapFactory: FocusTrapFactory, 
-    /**
-     * @deprecated No longer being used. To be removed.
-     * @breaking-change 13.0.0
-     */
-    _document: any);
-    ngOnDestroy(): void;
-    ngAfterContentInit(): void;
-    ngDoCheck(): void;
-    ngOnChanges(changes: SimpleChanges): void;
-    private _captureFocus;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkTrapFocus, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkTrapFocus, "[cdkTrapFocus]", ["cdkTrapFocus"], { "enabled": "cdkTrapFocus"; "autoCapture": "cdkTrapFocusAutoCapture"; }, {}, never, never, false>;
-}

package/a11y/high-contrast-mode/high-contrast-mode-detector.d.ts

@@ -1,48 +0,0 @@
-/**
- * @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
- */
-import { Platform } from '@angular/cdk/platform';
-import * as i0 from "@angular/core";
-/** Set of possible high-contrast mode backgrounds. */
-export declare const enum HighContrastMode {
-    NONE = 0,
-    BLACK_ON_WHITE = 1,
-    WHITE_ON_BLACK = 2
-}
-/** CSS class applied to the document body when in black-on-white high-contrast mode. */
-export declare const BLACK_ON_WHITE_CSS_CLASS = "cdk-high-contrast-black-on-white";
-/** CSS class applied to the document body when in white-on-black high-contrast mode. */
-export declare const WHITE_ON_BLACK_CSS_CLASS = "cdk-high-contrast-white-on-black";
-/** CSS class applied to the document body when in high-contrast mode. */
-export declare const HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS = "cdk-high-contrast-active";
-/**
- * Service to determine whether the browser is currently in a high-contrast-mode environment.
- *
- * Microsoft Windows supports an accessibility feature called "High Contrast Mode". This mode
- * changes the appearance of all applications, including web applications, to dramatically increase
- * contrast.
- *
- * IE, Edge, and Firefox currently support this mode. Chrome does not support Windows High Contrast
- * Mode. This service does not detect high-contrast mode as added by the Chrome "High Contrast"
- * browser extension.
- */
-export declare class HighContrastModeDetector {
-    private _platform;
-    /**
-     * Figuring out the high contrast mode and adding the body classes can cause
-     * some expensive layouts. This flag is used to ensure that we only do it once.
-     */
-    private _hasCheckedHighContrastMode;
-    private _document;
-    constructor(_platform: Platform, document: any);
-    /** Gets the current high-contrast-mode for the page. */
-    getHighContrastMode(): HighContrastMode;
-    /** Applies CSS classes indicating high-contrast mode to document body (browser-only). */
-    _applyBodyHighContrastModeCssClasses(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<HighContrastModeDetector, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<HighContrastModeDetector>;
-}