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

package/a11y-module.d-DBHGyKoh.d.ts

@@ -0,0 +1,314 @@
+import * as i0 from '@angular/core';
+import { NgZone, Injector, OnDestroy, AfterContentInit, OnChanges, DoCheck, SimpleChanges, InjectionToken } from '@angular/core';
+import { ObserversModule } from './observers/index.js';
+import { C as CdkMonitorFocus } from './focus-monitor.d-CvvJeQRc.js';
+
+/**
+ * Configuration for the isFocusable method.
+ */
+declare class IsFocusableConfig {
+    /**
+     * Whether to count an element as focusable even if it is not currently visible.
+     */
+    ignoreVisibility: boolean;
+}
+/**
+ * Utility for checking the interactivity of an element, such as whether it is focusable or
+ * tabbable.
+ */
+declare class InteractivityChecker {
+    private _platform;
+    constructor(...args: unknown[]);
+    /**
+     * Gets whether an element is disabled.
+     *
+     * @param element Element to be checked.
+     * @returns Whether the element is disabled.
+     */
+    isDisabled(element: HTMLElement): boolean;
+    /**
+     * Gets whether an element is visible for the purposes of interactivity.
+     *
+     * This will capture states like `display: none` and `visibility: hidden`, but not things like
+     * being clipped by an `overflow: hidden` parent or being outside the viewport.
+     *
+     * @returns Whether the element is visible.
+     */
+    isVisible(element: HTMLElement): boolean;
+    /**
+     * Gets whether an element can be reached via Tab key.
+     * Assumes that the element has already been checked with isFocusable.
+     *
+     * @param element Element to be checked.
+     * @returns Whether the element is tabbable.
+     */
+    isTabbable(element: HTMLElement): boolean;
+    /**
+     * Gets whether an element can be focused by the user.
+     *
+     * @param element Element to be checked.
+     * @param config The config object with options to customize this method's behavior
+     * @returns Whether the element is focusable.
+     */
+    isFocusable(element: HTMLElement, config?: IsFocusableConfig): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InteractivityChecker, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InteractivityChecker>;
+}
+
+/**
+ * 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.
+ */
+declare class FocusTrap {
+    readonly _element: HTMLElement;
+    private _checker;
+    readonly _ngZone: NgZone;
+    readonly _document: Document;
+    /** @breaking-change 20.0.0 param to become required */
+    readonly _injector?: Injector | undefined;
+    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, 
+    /** @breaking-change 20.0.0 param to become required */
+    _injector?: Injector | undefined);
+    /** 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.
+ */
+declare class FocusTrapFactory {
+    private _checker;
+    private _ngZone;
+    private _document;
+    private _injector;
+    constructor(...args: unknown[]);
+    /**
+     * 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. */
+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: boolean);
+    /**
+     * Whether the directive should automatically move focus into the trapped region upon
+     * initialization and return focus to the previous activeElement upon destruction.
+     */
+    autoCapture: boolean;
+    constructor(...args: unknown[]);
+    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": { "alias": "cdkTrapFocus"; "required": false; }; "autoCapture": { "alias": "cdkTrapFocusAutoCapture"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_enabled: unknown;
+    static ngAcceptInputType_autoCapture: unknown;
+}
+
+/** Possible politeness levels. */
+type AriaLivePoliteness = 'off' | 'polite' | 'assertive';
+declare const LIVE_ANNOUNCER_ELEMENT_TOKEN: InjectionToken<HTMLElement | null>;
+/**
+ * @docs-private
+ * @deprecated No longer used, will be removed.
+ * @breaking-change 21.0.0
+ */
+declare function LIVE_ANNOUNCER_ELEMENT_TOKEN_FACTORY(): null;
+/** Object that can be used to configure the default options for the LiveAnnouncer. */
+interface LiveAnnouncerDefaultOptions {
+    /** Default politeness for the announcements. */
+    politeness?: AriaLivePoliteness;
+    /** Default duration for the announcement messages. */
+    duration?: number;
+}
+/** Injection token that can be used to configure the default options for the LiveAnnouncer. */
+declare const LIVE_ANNOUNCER_DEFAULT_OPTIONS: InjectionToken<LiveAnnouncerDefaultOptions>;
+
+declare class LiveAnnouncer implements OnDestroy {
+    private _ngZone;
+    private _defaultOptions;
+    private _liveElement;
+    private _document;
+    private _previousTimeout;
+    private _currentPromise;
+    private _currentResolve;
+    constructor(...args: unknown[]);
+    /**
+     * Announces a message to screen readers.
+     * @param message Message to be announced to the screen reader.
+     * @returns Promise that will be resolved when the message is added to the DOM.
+     */
+    announce(message: string): Promise<void>;
+    /**
+     * Announces a message to screen readers.
+     * @param message Message to be announced to the screen reader.
+     * @param politeness The politeness of the announcer element.
+     * @returns Promise that will be resolved when the message is added to the DOM.
+     */
+    announce(message: string, politeness?: AriaLivePoliteness): Promise<void>;
+    /**
+     * Announces a message to screen readers.
+     * @param message Message to be announced to the screen reader.
+     * @param duration Time in milliseconds after which to clear out the announcer element. Note
+     *   that this takes effect after the message has been added to the DOM, which can be up to
+     *   100ms after `announce` has been called.
+     * @returns Promise that will be resolved when the message is added to the DOM.
+     */
+    announce(message: string, duration?: number): Promise<void>;
+    /**
+     * Announces a message to screen readers.
+     * @param message Message to be announced to the screen reader.
+     * @param politeness The politeness of the announcer element.
+     * @param duration Time in milliseconds after which to clear out the announcer element. Note
+     *   that this takes effect after the message has been added to the DOM, which can be up to
+     *   100ms after `announce` has been called.
+     * @returns Promise that will be resolved when the message is added to the DOM.
+     */
+    announce(message: string, politeness?: AriaLivePoliteness, duration?: number): Promise<void>;
+    /**
+     * Clears the current text from the announcer element. Can be used to prevent
+     * screen readers from reading the text out again while the user is going
+     * through the page landmarks.
+     */
+    clear(): void;
+    ngOnDestroy(): void;
+    private _createLiveElement;
+    /**
+     * Some browsers won't expose the accessibility node of the live announcer element if there is an
+     * `aria-modal` and the live announcer is outside of it. This method works around the issue by
+     * pointing the `aria-owns` of all modals to the live announcer element.
+     */
+    private _exposeAnnouncerToModals;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LiveAnnouncer, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LiveAnnouncer>;
+}
+/**
+ * A directive that works similarly to aria-live, but uses the LiveAnnouncer to ensure compatibility
+ * with a wider range of browsers and screen readers.
+ */
+declare class CdkAriaLive implements OnDestroy {
+    private _elementRef;
+    private _liveAnnouncer;
+    private _contentObserver;
+    private _ngZone;
+    /** The aria-live politeness level to use when announcing messages. */
+    get politeness(): AriaLivePoliteness;
+    set politeness(value: AriaLivePoliteness);
+    private _politeness;
+    /** Time in milliseconds after which to clear out the announcer element. */
+    duration: number;
+    private _previousAnnouncedText?;
+    private _subscription;
+    constructor(...args: unknown[]);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkAriaLive, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkAriaLive, "[cdkAriaLive]", ["cdkAriaLive"], { "politeness": { "alias": "cdkAriaLive"; "required": false; }; "duration": { "alias": "cdkAriaLiveDuration"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class A11yModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<A11yModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<A11yModule, never, [typeof ObserversModule, typeof CdkAriaLive, typeof CdkTrapFocus, typeof CdkMonitorFocus], [typeof CdkAriaLive, typeof CdkTrapFocus, typeof CdkMonitorFocus]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<A11yModule>;
+}
+
+export { A11yModule as A, CdkTrapFocus as C, FocusTrapFactory as F, InteractivityChecker as I, LiveAnnouncer as L, FocusTrap as a, IsFocusableConfig as b, CdkAriaLive as c, LIVE_ANNOUNCER_ELEMENT_TOKEN as e, LIVE_ANNOUNCER_ELEMENT_TOKEN_FACTORY as f, LIVE_ANNOUNCER_DEFAULT_OPTIONS as h };
+export type { AriaLivePoliteness as d, LiveAnnouncerDefaultOptions as g };

package/a11y-prebuilt.css

@@ -1 +1 @@
-.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}
+.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}

package/accordion/index.d.ts

@@ -1,24 +1,18 @@
-import { EventEmitter } from '@angular/core';
 import * as i0 from '@angular/core';
-import { InjectionToken } from '@angular/core';
-import { OnChanges } from '@angular/core';
-import { OnDestroy } from '@angular/core';
-import { OnInit } from '@angular/core';
-import { SimpleChanges } from '@angular/core';
+import { InjectionToken, OnDestroy, OnChanges, SimpleChanges, OnInit, EventEmitter } from '@angular/core';
+import { U as UniqueSelectionDispatcher } from '../unique-selection-dispatcher.d-DSFqf1MM.js';
 import { Subject } from 'rxjs';
-import { UniqueSelectionDispatcher } from '@angular/cdk/collections';
 
 /**
  * Injection token that can be used to reference instances of `CdkAccordion`. It serves
  * as alternative token to the actual `CdkAccordion` class which could cause unnecessary
  * retention of the class and its directive metadata.
  */
-export declare const CDK_ACCORDION: InjectionToken<CdkAccordion>;
-
+declare const CDK_ACCORDION: InjectionToken<CdkAccordion>;
 /**
  * Directive whose purpose is to manage the expanded state of CdkAccordionItem children.
  */
-export declare class CdkAccordion implements OnDestroy, OnChanges {
+declare class CdkAccordion implements OnDestroy, OnChanges {
     /** Emits when the state of the accordion changes */
     readonly _stateChanges: Subject<SimpleChanges>;
     /** Stream that emits true/false when openAll/closeAll is triggered. */
@@ -42,7 +36,7 @@ export declare class CdkAccordion implements OnDestroy, OnChanges {
  * A basic directive expected to be extended and decorated as a component.  Sets up all
  * events and attributes needed to be managed by a CdkAccordion parent.
  */
-export declare class CdkAccordionItem implements OnInit, OnDestroy {
+declare class CdkAccordionItem implements OnInit, OnDestroy {
     accordion: CdkAccordion;
     private _changeDetectorRef;
     protected _expansionDispatcher: UniqueSelectionDispatcher;
@@ -87,23 +81,10 @@ export declare class CdkAccordionItem implements OnInit, OnDestroy {
     static ngAcceptInputType_disabled: unknown;
 }
 
-export declare class CdkAccordionModule {
+declare class CdkAccordionModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<CdkAccordionModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<CdkAccordionModule, never, [typeof i1.CdkAccordion, typeof i2.CdkAccordionItem], [typeof i1.CdkAccordion, typeof i2.CdkAccordionItem]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CdkAccordionModule, never, [typeof CdkAccordion, typeof CdkAccordionItem], [typeof CdkAccordion, typeof CdkAccordionItem]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<CdkAccordionModule>;
 }
 
-declare namespace i1 {
-    export {
-        CDK_ACCORDION,
-        CdkAccordion
-    }
-}
-
-declare namespace i2 {
-    export {
-        CdkAccordionItem
-    }
-}
-
-export { }
+export { CDK_ACCORDION, CdkAccordion, CdkAccordionItem, CdkAccordionModule };

package/activedescendant-key-manager.d-Bjic5obv.d.ts

@@ -0,0 +1,32 @@
+import { L as ListKeyManagerOption, a as ListKeyManager } from './list-key-manager.d-BlK3jyRn.js';
+
+/**
+ * This is the interface for highlightable items (used by the ActiveDescendantKeyManager).
+ * Each item must know how to style itself as active or inactive and whether or not it is
+ * currently disabled.
+ */
+interface Highlightable extends ListKeyManagerOption {
+    /** Applies the styles for an active item to this item. */
+    setActiveStyles(): void;
+    /** Applies the styles for an inactive item to this item. */
+    setInactiveStyles(): void;
+}
+declare class ActiveDescendantKeyManager<T> extends ListKeyManager<Highlightable & T> {
+    /**
+     * Sets the active item to the item at the specified index and adds the
+     * active styles to the newly active item. Also removes active styles
+     * from the previously active item.
+     * @param index Index of the item to be set as active.
+     */
+    setActiveItem(index: number): void;
+    /**
+     * Sets the active item to the item to the specified one and adds the
+     * active styles to the it. Also removes active styles from the
+     * previously active item.
+     * @param item Item to be set as active.
+     */
+    setActiveItem(item: T): void;
+}
+
+export { ActiveDescendantKeyManager as A };
+export type { Highlightable as H };

package/bidi/index.d.ts

@@ -1,41 +1,5 @@
-import { AfterContentInit } from '@angular/core';
-import { EventEmitter } from '@angular/core';
-import * as i0 from '@angular/core';
+export { B as BidiModule, b as Dir, a as Direction, D as Directionality } from '../bidi-module.d-IN1Vp56w.js';
 import { InjectionToken } from '@angular/core';
-import { OnDestroy } from '@angular/core';
-
-export declare class BidiModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<BidiModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<BidiModule, never, [typeof i1.Dir], [typeof i1.Dir]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<BidiModule>;
-}
-
-/**
- * Directive to listen for changes of direction of part of the DOM.
- *
- * Provides itself as Directionality such that descendant directives only need to ever inject
- * Directionality to get the closest direction.
- */
-export declare class Dir implements Directionality, AfterContentInit, OnDestroy {
-    /** Normalized direction that accounts for invalid/unsupported values. */
-    private _dir;
-    /** Whether the `value` has been set to its initial value. */
-    private _isInitialized;
-    /** Direction as passed in by the consumer. */
-    _rawDir: string;
-    /** Event emitted when the direction changes. */
-    readonly change: EventEmitter<Direction>;
-    /** @docs-private */
-    get dir(): Direction;
-    set dir(value: Direction | 'auto');
-    /** Current layout direction of the element. */
-    get value(): Direction;
-    /** Initialize once default value has been set. */
-    ngAfterContentInit(): void;
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<Dir, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<Dir, "[dir]", ["dir"], { "dir": { "alias": "dir"; "required": false; }; }, { "change": "dirChange"; }, never, never, true, never>;
-}
 
 /**
  * Injection token used to inject the document into Directionality.
@@ -52,29 +16,6 @@ export declare class Dir implements Directionality, AfterContentInit, OnDestroy
  *
  * @docs-private
  */
-export declare const DIR_DOCUMENT: InjectionToken<Document>;
-
-export declare type Direction = 'ltr' | 'rtl';
-
-/**
- * The directionality (LTR / RTL) context for the application (or a subtree of it).
- * Exposes the current direction and a stream of direction changes.
- */
-export declare class Directionality implements OnDestroy {
-    /** The current 'ltr' or 'rtl' value. */
-    readonly value: Direction;
-    /** Stream that emits whenever the 'ltr' / 'rtl' state changes. */
-    readonly change: EventEmitter<Direction>;
-    constructor(...args: unknown[]);
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<Directionality, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<Directionality>;
-}
-
-declare namespace i1 {
-    export {
-        Dir
-    }
-}
+declare const DIR_DOCUMENT: InjectionToken<Document>;
 
-export { }
+export { DIR_DOCUMENT };

package/bidi-module.d-IN1Vp56w.d.ts

@@ -0,0 +1,57 @@
+import * as i0 from '@angular/core';
+import { OnDestroy, EventEmitter, AfterContentInit } from '@angular/core';
+
+type Direction = 'ltr' | 'rtl';
+/**
+ * The directionality (LTR / RTL) context for the application (or a subtree of it).
+ * Exposes the current direction and a stream of direction changes.
+ */
+declare class Directionality implements OnDestroy {
+    /** The current 'ltr' or 'rtl' value. */
+    get value(): Direction;
+    /**
+     * The current 'ltr' or 'rtl' value.
+     */
+    readonly valueSignal: i0.WritableSignal<Direction>;
+    /** Stream that emits whenever the 'ltr' / 'rtl' state changes. */
+    readonly change: EventEmitter<Direction>;
+    constructor(...args: unknown[]);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Directionality, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Directionality>;
+}
+
+/**
+ * Directive to listen for changes of direction of part of the DOM.
+ *
+ * Provides itself as Directionality such that descendant directives only need to ever inject
+ * Directionality to get the closest direction.
+ */
+declare class Dir implements Directionality, AfterContentInit, OnDestroy {
+    /** Whether the `value` has been set to its initial value. */
+    private _isInitialized;
+    /** Direction as passed in by the consumer. */
+    _rawDir: string;
+    /** Event emitted when the direction changes. */
+    readonly change: EventEmitter<Direction>;
+    /** @docs-private */
+    get dir(): Direction;
+    set dir(value: Direction | 'auto');
+    /** Current layout direction of the element. */
+    get value(): Direction;
+    readonly valueSignal: i0.WritableSignal<Direction>;
+    /** Initialize once default value has been set. */
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Dir, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<Dir, "[dir]", ["dir"], { "dir": { "alias": "dir"; "required": false; }; }, { "change": "dirChange"; }, never, never, true, never>;
+}
+
+declare class BidiModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BidiModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BidiModule, never, [typeof Dir], [typeof Dir]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BidiModule>;
+}
+
+export { BidiModule as B, Directionality as D, Dir as b };
+export type { Direction as a };