@angular/cdk 20.0.0-next.0 → 20.0.0-next.1

package/fesm2022/typeahead-11ae39bd.mjs

@@ -0,0 +1,88 @@
+import { Subject } from 'rxjs';
+import { tap, debounceTime, filter, map } from 'rxjs/operators';
+import { c as A, Z, d as ZERO, N as NINE } from './keycodes-107cd3e4.mjs';
+
+const DEFAULT_TYPEAHEAD_DEBOUNCE_INTERVAL_MS = 200;
+/**
+ * Selects items based on keyboard inputs. Implements the typeahead functionality of
+ * `role="listbox"` or `role="tree"` and other related roles.
+ */
+class Typeahead {
+    _letterKeyStream = new Subject();
+    _items = [];
+    _selectedItemIndex = -1;
+    /** Buffer for the letters that the user has pressed */
+    _pressedLetters = [];
+    _skipPredicateFn;
+    _selectedItem = new Subject();
+    selectedItem = this._selectedItem;
+    constructor(initialItems, config) {
+        const typeAheadInterval = typeof config?.debounceInterval === 'number'
+            ? config.debounceInterval
+            : DEFAULT_TYPEAHEAD_DEBOUNCE_INTERVAL_MS;
+        if (config?.skipPredicate) {
+            this._skipPredicateFn = config.skipPredicate;
+        }
+        if ((typeof ngDevMode === 'undefined' || ngDevMode) &&
+            initialItems.length &&
+            initialItems.some(item => typeof item.getLabel !== 'function')) {
+            throw new Error('KeyManager items in typeahead mode must implement the `getLabel` method.');
+        }
+        this.setItems(initialItems);
+        this._setupKeyHandler(typeAheadInterval);
+    }
+    destroy() {
+        this._pressedLetters = [];
+        this._letterKeyStream.complete();
+        this._selectedItem.complete();
+    }
+    setCurrentSelectedItemIndex(index) {
+        this._selectedItemIndex = index;
+    }
+    setItems(items) {
+        this._items = items;
+    }
+    handleKey(event) {
+        const keyCode = event.keyCode;
+        // Attempt to use the `event.key` which also maps it to the user's keyboard language,
+        // otherwise fall back to resolving alphanumeric characters via the keyCode.
+        if (event.key && event.key.length === 1) {
+            this._letterKeyStream.next(event.key.toLocaleUpperCase());
+        }
+        else if ((keyCode >= A && keyCode <= Z) || (keyCode >= ZERO && keyCode <= NINE)) {
+            this._letterKeyStream.next(String.fromCharCode(keyCode));
+        }
+    }
+    /** Gets whether the user is currently typing into the manager using the typeahead feature. */
+    isTyping() {
+        return this._pressedLetters.length > 0;
+    }
+    /** Resets the currently stored sequence of typed letters. */
+    reset() {
+        this._pressedLetters = [];
+    }
+    _setupKeyHandler(typeAheadInterval) {
+        // Debounce the presses of non-navigational keys, collect the ones that correspond to letters
+        // and convert those letters back into a string. Afterwards find the first item that starts
+        // with that string and select it.
+        this._letterKeyStream
+            .pipe(tap(letter => this._pressedLetters.push(letter)), debounceTime(typeAheadInterval), filter(() => this._pressedLetters.length > 0), map(() => this._pressedLetters.join('').toLocaleUpperCase()))
+            .subscribe(inputString => {
+            // Start at 1 because we want to start searching at the item immediately
+            // following the current active item.
+            for (let i = 1; i < this._items.length + 1; i++) {
+                const index = (this._selectedItemIndex + i) % this._items.length;
+                const item = this._items[index];
+                if (!this._skipPredicateFn?.(item) &&
+                    item.getLabel?.().toLocaleUpperCase().trim().indexOf(inputString) === 0) {
+                    this._selectedItem.next(item);
+                    break;
+                }
+            }
+            this._pressedLetters = [];
+        });
+    }
+}
+
+export { Typeahead as T };
+//# sourceMappingURL=typeahead-11ae39bd.mjs.map

package/fesm2022/typeahead-11ae39bd.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeahead-11ae39bd.mjs","sources":["../../../../../../src/cdk/a11y/key-manager/typeahead.ts"],"sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.dev/license\n */\n\nimport {A, NINE, Z, ZERO} from '../../keycodes';\nimport {Subject, Observable} from 'rxjs';\nimport {debounceTime, filter, map, tap} from 'rxjs/operators';\n\nconst DEFAULT_TYPEAHEAD_DEBOUNCE_INTERVAL_MS = 200;\n\ninterface TypeaheadItem {\n  getLabel?(): string;\n}\n\ninterface TypeaheadConfig<T> {\n  debounceInterval?: number;\n  skipPredicate?: (item: T) => boolean | undefined;\n}\n\n/**\n * Selects items based on keyboard inputs. Implements the typeahead functionality of\n * `role=\"listbox\"` or `role=\"tree\"` and other related roles.\n */\nexport class Typeahead<T extends TypeaheadItem> {\n  private readonly _letterKeyStream = new Subject<string>();\n  private _items: readonly T[] = [];\n  private _selectedItemIndex = -1;\n\n  /** Buffer for the letters that the user has pressed */\n  private _pressedLetters: string[] = [];\n\n  private _skipPredicateFn?: (item: T) => boolean | undefined;\n\n  private readonly _selectedItem = new Subject<T>();\n  readonly selectedItem: Observable<T> = this._selectedItem;\n\n  constructor(initialItems: readonly T[], config?: TypeaheadConfig<T>) {\n    const typeAheadInterval =\n      typeof config?.debounceInterval === 'number'\n        ? config.debounceInterval\n        : DEFAULT_TYPEAHEAD_DEBOUNCE_INTERVAL_MS;\n\n    if (config?.skipPredicate) {\n      this._skipPredicateFn = config.skipPredicate;\n    }\n\n    if (\n      (typeof ngDevMode === 'undefined' || ngDevMode) &&\n      initialItems.length &&\n      initialItems.some(item => typeof item.getLabel !== 'function')\n    ) {\n      throw new Error('KeyManager items in typeahead mode must implement the `getLabel` method.');\n    }\n\n    this.setItems(initialItems);\n    this._setupKeyHandler(typeAheadInterval);\n  }\n\n  destroy() {\n    this._pressedLetters = [];\n    this._letterKeyStream.complete();\n    this._selectedItem.complete();\n  }\n\n  setCurrentSelectedItemIndex(index: number) {\n    this._selectedItemIndex = index;\n  }\n\n  setItems(items: readonly T[]) {\n    this._items = items;\n  }\n\n  handleKey(event: KeyboardEvent): void {\n    const keyCode = event.keyCode;\n\n    // Attempt to use the `event.key` which also maps it to the user's keyboard language,\n    // otherwise fall back to resolving alphanumeric characters via the keyCode.\n    if (event.key && event.key.length === 1) {\n      this._letterKeyStream.next(event.key.toLocaleUpperCase());\n    } else if ((keyCode >= A && keyCode <= Z) || (keyCode >= ZERO && keyCode <= NINE)) {\n      this._letterKeyStream.next(String.fromCharCode(keyCode));\n    }\n  }\n\n  /** Gets whether the user is currently typing into the manager using the typeahead feature. */\n  isTyping(): boolean {\n    return this._pressedLetters.length > 0;\n  }\n\n  /** Resets the currently stored sequence of typed letters. */\n  reset(): void {\n    this._pressedLetters = [];\n  }\n\n  private _setupKeyHandler(typeAheadInterval: number) {\n    // Debounce the presses of non-navigational keys, collect the ones that correspond to letters\n    // and convert those letters back into a string. Afterwards find the first item that starts\n    // with that string and select it.\n    this._letterKeyStream\n      .pipe(\n        tap(letter => this._pressedLetters.push(letter)),\n        debounceTime(typeAheadInterval),\n        filter(() => this._pressedLetters.length > 0),\n        map(() => this._pressedLetters.join('').toLocaleUpperCase()),\n      )\n      .subscribe(inputString => {\n        // Start at 1 because we want to start searching at the item immediately\n        // following the current active item.\n        for (let i = 1; i < this._items.length + 1; i++) {\n          const index = (this._selectedItemIndex + i) % this._items.length;\n          const item = this._items[index];\n\n          if (\n            !this._skipPredicateFn?.(item) &&\n            item.getLabel?.().toLocaleUpperCase().trim().indexOf(inputString) === 0\n          ) {\n            this._selectedItem.next(item);\n            break;\n          }\n        }\n\n        this._pressedLetters = [];\n      });\n  }\n}\n"],"names":[],"mappings":"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"}

package/fesm2022/unique-selection-dispatcher-1d6f91d8.mjs

@@ -0,0 +1,49 @@
+import * as i0 from '@angular/core';
+import { Injectable } from '@angular/core';
+
+/**
+ * Class to coordinate unique selection based on name.
+ * Intended to be consumed as an Angular service.
+ * This service is needed because native radio change events are only fired on the item currently
+ * being selected, and we still need to uncheck the previous selection.
+ *
+ * This service does not *store* any IDs and names because they may change at any time, so it is
+ * less error-prone if they are simply passed through when the events occur.
+ */
+class UniqueSelectionDispatcher {
+    _listeners = [];
+    /**
+     * Notify other items that selection for the given name has been set.
+     * @param id ID of the item.
+     * @param name Name of the item.
+     */
+    notify(id, name) {
+        for (let listener of this._listeners) {
+            listener(id, name);
+        }
+    }
+    /**
+     * Listen for future changes to item selection.
+     * @return Function used to deregister listener
+     */
+    listen(listener) {
+        this._listeners.push(listener);
+        return () => {
+            this._listeners = this._listeners.filter((registered) => {
+                return listener !== registered;
+            });
+        };
+    }
+    ngOnDestroy() {
+        this._listeners = [];
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.0-next.1", ngImport: i0, type: UniqueSelectionDispatcher, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.0-next.1", ngImport: i0, type: UniqueSelectionDispatcher, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.0-next.1", ngImport: i0, type: UniqueSelectionDispatcher, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+export { UniqueSelectionDispatcher as U };
+//# sourceMappingURL=unique-selection-dispatcher-1d6f91d8.mjs.map

package/fesm2022/unique-selection-dispatcher-1d6f91d8.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"unique-selection-dispatcher-1d6f91d8.mjs","sources":["../../../../../../src/cdk/collections/unique-selection-dispatcher.ts"],"sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.dev/license\n */\n\nimport {Injectable, OnDestroy} from '@angular/core';\n\n// Users of the Dispatcher never need to see this type, but TypeScript requires it to be exported.\nexport type UniqueSelectionDispatcherListener = (id: string, name: string) => void;\n\n/**\n * Class to coordinate unique selection based on name.\n * Intended to be consumed as an Angular service.\n * This service is needed because native radio change events are only fired on the item currently\n * being selected, and we still need to uncheck the previous selection.\n *\n * This service does not *store* any IDs and names because they may change at any time, so it is\n * less error-prone if they are simply passed through when the events occur.\n */\n@Injectable({providedIn: 'root'})\nexport class UniqueSelectionDispatcher implements OnDestroy {\n  private _listeners: UniqueSelectionDispatcherListener[] = [];\n\n  /**\n   * Notify other items that selection for the given name has been set.\n   * @param id ID of the item.\n   * @param name Name of the item.\n   */\n  notify(id: string, name: string) {\n    for (let listener of this._listeners) {\n      listener(id, name);\n    }\n  }\n\n  /**\n   * Listen for future changes to item selection.\n   * @return Function used to deregister listener\n   */\n  listen(listener: UniqueSelectionDispatcherListener): () => void {\n    this._listeners.push(listener);\n    return () => {\n      this._listeners = this._listeners.filter((registered: UniqueSelectionDispatcherListener) => {\n        return listener !== registered;\n      });\n    };\n  }\n\n  ngOnDestroy() {\n    this._listeners = [];\n  }\n}\n"],"names":[],"mappings":";;;AAaA;;;;;;;;AAQG;MAEU,yBAAyB,CAAA;IAC5B,UAAU,GAAwC,EAAE,CAAA;AAE5D;;;;AAIG;IACH,MAAM,CAAC,EAAU,EAAE,IAAY,EAAA;AAC7B,QAAA,KAAK,IAAI,QAAQ,IAAI,IAAI,CAAC,UAAU,EAAE;AACpC,YAAA,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC,CAAA;SACpB;KACF;AAEA;;;AAGG;AACH,IAAA,MAAM,CAAC,QAA2C,EAAA;AAChD,QAAA,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;AAC9B,QAAA,OAAO,MAAK;AACV,YAAA,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,UAA6C,KAAI;gBACzF,OAAO,QAAQ,KAAK,UAAU,CAAA;AAChC,aAAC,CAAC,CAAA;AACJ,SAAC,CAAA;KACH;IAEA,WAAW,GAAA;AACT,QAAA,IAAI,CAAC,UAAU,GAAG,EAAE,CAAA;KACtB;8GA7BW,yBAAyB,EAAA,IAAA,EAAA,EAAA,EAAA,MAAA,EAAA,EAAA,CAAA,eAAA,CAAA,UAAA,EAAA,CAAA,CAAA;AAAzB,IAAA,OAAA,KAAA,GAAA,EAAA,CAAA,qBAAA,CAAA,EAAA,UAAA,EAAA,QAAA,EAAA,OAAA,EAAA,eAAA,EAAA,QAAA,EAAA,EAAA,EAAA,IAAA,EAAA,yBAAyB,cADb,MAAM,EAAA,CAAA,CAAA;;kGAClB,yBAAyB,EAAA,UAAA,EAAA,CAAA;kBADrC,UAAU;mBAAC,EAAC,UAAU,EAAE,MAAM,EAAC,CAAA;;;;;"}

package/fesm2022/visually-hidden-83aea4a0.mjs

@@ -0,0 +1,18 @@
+import * as i0 from '@angular/core';
+import { Component, ViewEncapsulation, ChangeDetectionStrategy } from '@angular/core';
+
+/**
+ * Component used to load the .cdk-visually-hidden styles.
+ * @docs-private
+ */
+class _VisuallyHiddenLoader {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.0-next.1", ngImport: i0, type: _VisuallyHiddenLoader, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.0.0-next.1", type: _VisuallyHiddenLoader, isStandalone: true, selector: "ng-component", exportAs: ["cdkVisuallyHidden"], ngImport: i0, template: '', isInline: true, styles: [".cdk-visually-hidden{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;white-space:nowrap;outline:0;-webkit-appearance:none;-moz-appearance:none;left:0}[dir=rtl] .cdk-visually-hidden{left:auto;right:0}"], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.0-next.1", ngImport: i0, type: _VisuallyHiddenLoader, decorators: [{
+            type: Component,
+            args: [{ exportAs: 'cdkVisuallyHidden', encapsulation: ViewEncapsulation.None, template: '', changeDetection: ChangeDetectionStrategy.OnPush, styles: [".cdk-visually-hidden{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;white-space:nowrap;outline:0;-webkit-appearance:none;-moz-appearance:none;left:0}[dir=rtl] .cdk-visually-hidden{left:auto;right:0}"] }]
+        }] });
+
+export { _VisuallyHiddenLoader as _ };
+//# sourceMappingURL=visually-hidden-83aea4a0.mjs.map

package/fesm2022/visually-hidden-83aea4a0.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"visually-hidden-83aea4a0.mjs","sources":["../../../../../../src/cdk/private/visually-hidden/visually-hidden.ts"],"sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.dev/license\n */\n\nimport {ChangeDetectionStrategy, Component, ViewEncapsulation} from '@angular/core';\n\n/**\n * Component used to load the .cdk-visually-hidden styles.\n * @docs-private\n */\n@Component({\n  styleUrl: 'visually-hidden.css',\n  exportAs: 'cdkVisuallyHidden',\n  encapsulation: ViewEncapsulation.None,\n  template: '',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class _VisuallyHiddenLoader {}\n"],"names":[],"mappings":";;;AAUA;;;AAGG;MAQU,qBAAqB,CAAA;8GAArB,qBAAqB,EAAA,IAAA,EAAA,EAAA,EAAA,MAAA,EAAA,EAAA,CAAA,eAAA,CAAA,SAAA,EAAA,CAAA,CAAA;AAArB,IAAA,OAAA,IAAA,GAAA,EAAA,CAAA,oBAAA,CAAA,EAAA,UAAA,EAAA,QAAA,EAAA,OAAA,EAAA,eAAA,EAAA,IAAA,EAAA,qBAAqB,yGAHtB,EAAE,EAAA,QAAA,EAAA,IAAA,EAAA,MAAA,EAAA,CAAA,kQAAA,CAAA,EAAA,eAAA,EAAA,EAAA,CAAA,uBAAA,CAAA,MAAA,EAAA,aAAA,EAAA,EAAA,CAAA,iBAAA,CAAA,IAAA,EAAA,CAAA,CAAA;;kGAGD,qBAAqB,EAAA,UAAA,EAAA,CAAA;kBAPjC,SAAS;+BAEE,mBAAmB,EAAA,aAAA,EACd,iBAAiB,CAAC,IAAI,YAC3B,EAAE,EAAA,eAAA,EACK,uBAAuB,CAAC,MAAM,EAAA,MAAA,EAAA,CAAA,kQAAA,CAAA,EAAA,CAAA;;;;;"}

package/focus-key-manager.d-415a6958.d.ts

@@ -0,0 +1,33 @@
+import { L as ListKeyManagerOption, b as ListKeyManager } from './list-key-manager.d-72e9a2e7.js';
+import { F as FocusOrigin } from './focus-monitor.d-810a02e6.js';
+
+/**
+ * This is the interface for focusable items (used by the FocusKeyManager).
+ * Each item must know how to focus itself, whether or not it is currently disabled
+ * and be able to supply its label.
+ */
+interface FocusableOption extends ListKeyManagerOption {
+    /** Focuses the `FocusableOption`. */
+    focus(origin?: FocusOrigin): void;
+}
+declare class FocusKeyManager<T> extends ListKeyManager<FocusableOption & T> {
+    private _origin;
+    /**
+     * Sets the focus origin that will be passed in to the items for any subsequent `focus` calls.
+     * @param origin Focus origin to be used when focusing items.
+     */
+    setFocusOrigin(origin: FocusOrigin): this;
+    /**
+     * Sets the active item to the item at the specified
+     * index and focuses the newly active item.
+     * @param index Index of the item to be set as active.
+     */
+    setActiveItem(index: number): void;
+    /**
+     * Sets the active item to the item that is specified and focuses it.
+     * @param item Item to be set as active.
+     */
+    setActiveItem(item: T): void;
+}
+
+export { type FocusableOption as F, FocusKeyManager as a };

package/focus-monitor.d-810a02e6.d.ts

@@ -0,0 +1,209 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, OnDestroy, ElementRef, AfterViewInit, EventEmitter } from '@angular/core';
+import { Observable } from 'rxjs';
+
+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
+ */
+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. */
+declare 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. */
+interface FocusMonitorOptions {
+    detectionMode?: FocusMonitorDetectionMode;
+}
+/** InjectionToken for FocusMonitorOptions. */
+declare const FOCUS_MONITOR_DEFAULT_OPTIONS: InjectionToken<FocusMonitorOptions>;
+/** Monitors mouse and keyboard events to determine the cause of focus events. */
+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 | null | undefined;
+    /** Subject for stopping our InputModalityDetector subscription. */
+    private readonly _stopInputModalityDetector;
+    constructor(...args: unknown[]);
+    /**
+     * 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;
+    /**
+     * Returns whether an interaction is likely to have come from the user clicking the `label` of
+     * an `input` or `textarea` in order to focus it.
+     * @param focusEventTarget Target currently receiving focus.
+     */
+    private _isLastInteractionFromInputLabel;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FocusMonitor, never>;
+    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.
+ */
+declare class CdkMonitorFocus implements AfterViewInit, OnDestroy {
+    private _elementRef;
+    private _focusMonitor;
+    private _monitorSubscription;
+    private _focusOrigin;
+    readonly cdkFocusChange: EventEmitter<FocusOrigin>;
+    constructor(...args: unknown[]);
+    get focusOrigin(): FocusOrigin;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMonitorFocus, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMonitorFocus, "[cdkMonitorElementFocus], [cdkMonitorSubtreeFocus]", ["cdkMonitorFocus"], {}, { "cdkFocusChange": "cdkFocusChange"; }, never, never, true, never>;
+}
+
+export { CdkMonitorFocus as C, type FocusOrigin as F, type FocusOptions as a, FocusMonitorDetectionMode as b, type FocusMonitorOptions as c, FOCUS_MONITOR_DEFAULT_OPTIONS as d, FocusMonitor as e };