@dugararchit/cdk 0.0.0-dugararchit

package/types/stagefright5-cdk-overlay.d.ts

@@ -0,0 +1,1258 @@
+import * as i3 from '@dugararchit/cdk/portal';
+import { Portal, PortalOutlet, ComponentPortal, TemplatePortal } from '@dugararchit/cdk/portal';
+export { ComponentType } from '@dugararchit/cdk/portal';
+import * as i2 from '@dugararchit/cdk/bidi';
+import { Direction, Directionality } from '@dugararchit/cdk/bidi';
+import { Observable, Subject } from 'rxjs';
+import * as i4 from '@dugararchit/cdk/scrolling';
+import { ViewportRuler, ScrollDispatcher, CdkScrollable } from '@dugararchit/cdk/scrolling';
+export { CdkScrollable, ScrollDispatcher, ViewportRuler } from '@dugararchit/cdk/scrolling';
+import * as i0 from '@angular/core';
+import { NgZone, OnDestroy, ComponentRef, EmbeddedViewRef, ElementRef, ComponentFactoryResolver, Injector, OnChanges, EventEmitter, TemplateRef, ViewContainerRef, SimpleChanges } from '@angular/core';
+import { BooleanInput } from '@dugararchit/cdk/coercion';
+import { Location } from '@angular/common';
+import { Platform } from '@dugararchit/cdk/platform';
+
+/**
+ * @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
+ */
+
+/**
+ * Basic interface for an overlay. Used to avoid circular type references between
+ * `OverlayRef`, `PositionStrategy` and `ScrollStrategy`, and `OverlayConfig`.
+ * @docs-private
+ */
+interface OverlayReference {
+    attach: (portal: Portal<any>) => any;
+    detach: () => any;
+    dispose: () => void;
+    overlayElement: HTMLElement;
+    hostElement: HTMLElement;
+    backdropElement: HTMLElement | null;
+    getConfig: () => any;
+    hasAttached: () => boolean;
+    updateSize: (config: any) => void;
+    updatePosition: () => void;
+    getDirection: () => Direction;
+    setDirection: (dir: Direction | Directionality) => void;
+    backdropClick: () => Observable<MouseEvent>;
+    attachments: () => Observable<void>;
+    detachments: () => Observable<void>;
+    keydownEvents: () => Observable<KeyboardEvent>;
+    outsidePointerEvents: () => Observable<MouseEvent>;
+    addPanelClass: (classes: string | string[]) => void;
+    removePanelClass: (classes: string | string[]) => void;
+    readonly _outsidePointerEvents: Subject<MouseEvent>;
+    readonly _keydownEvents: Subject<KeyboardEvent>;
+}
+
+/**
+ * @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
+ */
+
+/** Strategy for setting the position on an overlay. */
+interface PositionStrategy {
+    /** Attaches this position strategy to an overlay. */
+    attach(overlayRef: OverlayReference): void;
+    /** Updates the position of the overlay element. */
+    apply(): void;
+    /** Called when the overlay is detached. */
+    detach?(): void;
+    /** Cleans up any DOM modifications made by the position strategy, if necessary. */
+    dispose(): void;
+}
+
+/**
+ * @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
+ */
+
+/**
+ * Describes a strategy that will be used by an overlay to handle scroll events while it is open.
+ */
+interface ScrollStrategy {
+    /** Enable this scroll strategy (called when the attached overlay is attached to a portal). */
+    enable: () => void;
+    /** Disable this scroll strategy (called when the attached overlay is detached from a portal). */
+    disable: () => void;
+    /** Attaches this `ScrollStrategy` to an overlay. */
+    attach: (overlayRef: OverlayReference) => void;
+    /** Detaches the scroll strategy from the current overlay. */
+    detach?: () => void;
+}
+
+/**
+ * @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
+ */
+
+/**
+ * Strategy that will prevent the user from scrolling while the overlay is visible.
+ */
+declare class BlockScrollStrategy implements ScrollStrategy {
+    private _viewportRuler;
+    private _previousHTMLStyles;
+    private _previousScrollPosition;
+    private _isEnabled;
+    private _document;
+    constructor(_viewportRuler: ViewportRuler, document: any);
+    /** Attaches this scroll strategy to an overlay. */
+    attach(): void;
+    /** Blocks page-level scroll while the attached overlay is open. */
+    enable(): void;
+    /** Unblocks page-level scroll while the attached overlay is open. */
+    disable(): void;
+    private _canBeEnabled;
+}
+
+/**
+ * @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
+ */
+
+/**
+ * Config options for the CloseScrollStrategy.
+ */
+interface CloseScrollStrategyConfig {
+    /** Amount of pixels the user has to scroll before the overlay is closed. */
+    threshold?: number;
+}
+/**
+ * Strategy that will close the overlay as soon as the user starts scrolling.
+ */
+declare class CloseScrollStrategy implements ScrollStrategy {
+    private _scrollDispatcher;
+    private _ngZone;
+    private _viewportRuler;
+    private _config?;
+    private _scrollSubscription;
+    private _overlayRef;
+    private _initialScrollPosition;
+    constructor(_scrollDispatcher: ScrollDispatcher, _ngZone: NgZone, _viewportRuler: ViewportRuler, _config?: CloseScrollStrategyConfig | undefined);
+    /** Attaches this scroll strategy to an overlay. */
+    attach(overlayRef: OverlayReference): void;
+    /** Enables the closing of the attached overlay on scroll. */
+    enable(): void;
+    /** Disables the closing the attached overlay on scroll. */
+    disable(): void;
+    detach(): void;
+    /** Detaches the overlay ref and disables the scroll strategy. */
+    private _detach;
+}
+
+/**
+ * @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
+ */
+
+/** Scroll strategy that doesn't do anything. */
+declare class NoopScrollStrategy implements ScrollStrategy {
+    /** Does nothing, as this scroll strategy is a no-op. */
+    enable(): void;
+    /** Does nothing, as this scroll strategy is a no-op. */
+    disable(): void;
+    /** Does nothing, as this scroll strategy is a no-op. */
+    attach(): void;
+}
+
+/**
+ * @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
+ */
+
+/**
+ * Config options for the RepositionScrollStrategy.
+ */
+interface RepositionScrollStrategyConfig {
+    /** Time in milliseconds to throttle the scroll events. */
+    scrollThrottle?: number;
+    /** Whether to close the overlay once the user has scrolled away completely. */
+    autoClose?: boolean;
+}
+/**
+ * Strategy that will update the element position as the user is scrolling.
+ */
+declare class RepositionScrollStrategy implements ScrollStrategy {
+    private _scrollDispatcher;
+    private _viewportRuler;
+    private _ngZone;
+    private _config?;
+    private _scrollSubscription;
+    private _overlayRef;
+    constructor(_scrollDispatcher: ScrollDispatcher, _viewportRuler: ViewportRuler, _ngZone: NgZone, _config?: RepositionScrollStrategyConfig | undefined);
+    /** Attaches this scroll strategy to an overlay. */
+    attach(overlayRef: OverlayReference): void;
+    /** Enables repositioning of the attached overlay on scroll. */
+    enable(): void;
+    /** Disables repositioning of the attached overlay on scroll. */
+    disable(): void;
+    detach(): void;
+}
+
+/**
+ * @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 how an overlay will handle scrolling.
+ *
+ * Users can provide a custom value for `ScrollStrategyOptions` to replace the default
+ * behaviors. This class primarily acts as a factory for ScrollStrategy instances.
+ */
+declare class ScrollStrategyOptions {
+    private _scrollDispatcher;
+    private _viewportRuler;
+    private _ngZone;
+    private _document;
+    constructor(_scrollDispatcher: ScrollDispatcher, _viewportRuler: ViewportRuler, _ngZone: NgZone, document: any);
+    /** Do nothing on scroll. */
+    noop: () => NoopScrollStrategy;
+    /**
+     * Close the overlay as soon as the user scrolls.
+     * @param config Configuration to be used inside the scroll strategy.
+     */
+    close: (config?: CloseScrollStrategyConfig) => CloseScrollStrategy;
+    /** Block scrolling. */
+    block: () => BlockScrollStrategy;
+    /**
+     * Update the overlay's position on scroll.
+     * @param config Configuration to be used inside the scroll strategy.
+     * Allows debouncing the reposition calls.
+     */
+    reposition: (config?: RepositionScrollStrategyConfig) => RepositionScrollStrategy;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollStrategyOptions, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScrollStrategyOptions>;
+}
+
+/**
+ * @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
+ */
+
+/** Initial configuration used when creating an overlay. */
+declare class OverlayConfig {
+    /** Strategy with which to position the overlay. */
+    positionStrategy?: PositionStrategy;
+    /** Strategy to be used when handling scroll events while the overlay is open. */
+    scrollStrategy?: ScrollStrategy;
+    /** Custom class to add to the overlay pane. */
+    panelClass?: string | string[];
+    /** Whether the overlay has a backdrop. */
+    hasBackdrop?: boolean;
+    /** Custom class to add to the backdrop */
+    backdropClass?: string | string[];
+    /** The width of the overlay panel. If a number is provided, pixel units are assumed. */
+    width?: number | string;
+    /** The height of the overlay panel. If a number is provided, pixel units are assumed. */
+    height?: number | string;
+    /** The min-width of the overlay panel. If a number is provided, pixel units are assumed. */
+    minWidth?: number | string;
+    /** The min-height of the overlay panel. If a number is provided, pixel units are assumed. */
+    minHeight?: number | string;
+    /** The max-width of the overlay panel. If a number is provided, pixel units are assumed. */
+    maxWidth?: number | string;
+    /** The max-height of the overlay panel. If a number is provided, pixel units are assumed. */
+    maxHeight?: number | string;
+    /**
+     * Direction of the text in the overlay panel. If a `Directionality` instance
+     * is passed in, the overlay will handle changes to its value automatically.
+     */
+    direction?: Direction | Directionality;
+    /**
+     * Whether the overlay should be disposed of when the user goes backwards/forwards in history.
+     * Note that this usually doesn't include clicking on links (unless the user is using
+     * the `HashLocationStrategy`).
+     */
+    disposeOnNavigation?: boolean;
+    constructor(config?: OverlayConfig);
+}
+
+/**
+ * @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
+ */
+/** Horizontal dimension of a connection point on the perimeter of the origin or overlay element. */
+type HorizontalConnectionPos = 'start' | 'center' | 'end';
+/** Vertical dimension of a connection point on the perimeter of the origin or overlay element. */
+type VerticalConnectionPos = 'top' | 'center' | 'bottom';
+/** A connection point on the origin element. */
+interface OriginConnectionPosition {
+    originX: HorizontalConnectionPos;
+    originY: VerticalConnectionPos;
+}
+/** A connection point on the overlay element. */
+interface OverlayConnectionPosition {
+    overlayX: HorizontalConnectionPos;
+    overlayY: VerticalConnectionPos;
+}
+/** The points of the origin element and the overlay element to connect. */
+declare class ConnectionPositionPair {
+    /** Offset along the X axis. */
+    offsetX?: number | undefined;
+    /** Offset along the Y axis. */
+    offsetY?: number | undefined;
+    /** Class(es) to be applied to the panel while this position is active. */
+    panelClass?: string | string[] | undefined;
+    /** X-axis attachment point for connected overlay origin. Can be 'start', 'end', or 'center'. */
+    originX: HorizontalConnectionPos;
+    /** Y-axis attachment point for connected overlay origin. Can be 'top', 'bottom', or 'center'. */
+    originY: VerticalConnectionPos;
+    /** X-axis attachment point for connected overlay. Can be 'start', 'end', or 'center'. */
+    overlayX: HorizontalConnectionPos;
+    /** Y-axis attachment point for connected overlay. Can be 'top', 'bottom', or 'center'. */
+    overlayY: VerticalConnectionPos;
+    constructor(origin: OriginConnectionPosition, overlay: OverlayConnectionPosition, 
+    /** Offset along the X axis. */
+    offsetX?: number | undefined, 
+    /** Offset along the Y axis. */
+    offsetY?: number | undefined, 
+    /** Class(es) to be applied to the panel while this position is active. */
+    panelClass?: string | string[] | undefined);
+}
+/**
+ * Set of properties regarding the position of the origin and overlay relative to the viewport
+ * with respect to the containing Scrollable elements.
+ *
+ * The overlay and origin are clipped if any part of their bounding client rectangle exceeds the
+ * bounds of any one of the strategy's Scrollable's bounding client rectangle.
+ *
+ * The overlay and origin are outside view if there is no overlap between their bounding client
+ * rectangle and any one of the strategy's Scrollable's bounding client rectangle.
+ *
+ *       -----------                    -----------
+ *       | outside |                    | clipped |
+ *       |  view   |              --------------------------
+ *       |         |              |     |         |        |
+ *       ----------               |     -----------        |
+ *  --------------------------    |                        |
+ *  |                        |    |      Scrollable        |
+ *  |                        |    |                        |
+ *  |                        |     --------------------------
+ *  |      Scrollable        |
+ *  |                        |
+ *  --------------------------
+ *
+ *  @docs-private
+ */
+declare class ScrollingVisibility {
+    isOriginClipped: boolean;
+    isOriginOutsideView: boolean;
+    isOverlayClipped: boolean;
+    isOverlayOutsideView: boolean;
+}
+/** The change event emitted by the strategy when a fallback position is used. */
+declare class ConnectedOverlayPositionChange {
+    /** The position used as a result of this change. */
+    connectionPair: ConnectionPositionPair;
+    /** @docs-private */
+    scrollableViewProperties: ScrollingVisibility;
+    constructor(
+    /** The position used as a result of this change. */
+    connectionPair: ConnectionPositionPair, 
+    /** @docs-private */
+    scrollableViewProperties: ScrollingVisibility);
+}
+/**
+ * Validates whether a vertical position property matches the expected values.
+ * @param property Name of the property being validated.
+ * @param value Value of the property being validated.
+ * @docs-private
+ */
+declare function validateVerticalPosition(property: string, value: VerticalConnectionPos): void;
+/**
+ * Validates whether a horizontal position property matches the expected values.
+ * @param property Name of the property being validated.
+ * @param value Value of the property being validated.
+ * @docs-private
+ */
+declare function validateHorizontalPosition(property: string, value: HorizontalConnectionPos): void;
+
+/**
+ * Service for dispatching events that land on the body to appropriate overlay ref,
+ * if any. It maintains a list of attached overlays to determine best suited overlay based
+ * on event target and order of overlay opens.
+ */
+declare abstract class BaseOverlayDispatcher implements OnDestroy {
+    /** Currently attached overlays in the order they were attached. */
+    _attachedOverlays: OverlayReference[];
+    protected _document: Document;
+    protected _isAttached: boolean;
+    constructor(document: any);
+    ngOnDestroy(): void;
+    /** Add a new overlay to the list of attached overlay refs. */
+    add(overlayRef: OverlayReference): void;
+    /** Remove an overlay from the list of attached overlay refs. */
+    remove(overlayRef: OverlayReference): void;
+    /** Detaches the global event listener. */
+    protected abstract detach(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseOverlayDispatcher, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseOverlayDispatcher>;
+}
+
+/**
+ * Service for dispatching keyboard events that land on the body to appropriate overlay ref,
+ * if any. It maintains a list of attached overlays to determine best suited overlay based
+ * on event target and order of overlay opens.
+ */
+declare class OverlayKeyboardDispatcher extends BaseOverlayDispatcher {
+    /** @breaking-change 14.0.0 _ngZone will be required. */
+    private _ngZone?;
+    constructor(document: any, 
+    /** @breaking-change 14.0.0 _ngZone will be required. */
+    _ngZone?: NgZone | undefined);
+    /** Add a new overlay to the list of attached overlay refs. */
+    add(overlayRef: OverlayReference): void;
+    /** Detaches the global keyboard event listener. */
+    protected detach(): void;
+    /** Keyboard event listener that will be attached to the body. */
+    private _keydownListener;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayKeyboardDispatcher, [null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OverlayKeyboardDispatcher>;
+}
+
+/**
+ * Service for dispatching mouse click events that land on the body to appropriate overlay ref,
+ * if any. It maintains a list of attached overlays to determine best suited overlay based
+ * on event target and order of overlay opens.
+ */
+declare class OverlayOutsideClickDispatcher extends BaseOverlayDispatcher {
+    private _platform;
+    /** @breaking-change 14.0.0 _ngZone will be required. */
+    private _ngZone?;
+    private _cursorOriginalValue;
+    private _cursorStyleIsSet;
+    private _pointerDownEventTarget;
+    constructor(document: any, _platform: Platform, 
+    /** @breaking-change 14.0.0 _ngZone will be required. */
+    _ngZone?: NgZone | undefined);
+    /** Add a new overlay to the list of attached overlay refs. */
+    add(overlayRef: OverlayReference): void;
+    /** Detaches the global keyboard event listener. */
+    protected detach(): void;
+    private _addEventListeners;
+    /** Store pointerdown event target to track origin of click. */
+    private _pointerDownListener;
+    /** Click event listener that will be attached to the body propagate phase. */
+    private _clickListener;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayOutsideClickDispatcher, [null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OverlayOutsideClickDispatcher>;
+}
+
+/** Container inside which all overlays will render. */
+declare class OverlayContainer implements OnDestroy {
+    protected _platform: Platform;
+    protected _containerElement: HTMLElement;
+    protected _document: Document;
+    constructor(document: any, _platform: Platform);
+    ngOnDestroy(): void;
+    /**
+     * This method returns the overlay container element. It will lazily
+     * create the element the first time it is called to facilitate using
+     * the container in non-browser environments.
+     * @returns the container element
+     */
+    getContainerElement(): HTMLElement;
+    /**
+     * Create the overlay container element, which is simply a div
+     * with the 'cdk-overlay-container' class on the document body.
+     */
+    protected _createContainer(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayContainer, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OverlayContainer>;
+}
+
+/**
+ * @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
+ */
+
+/** An object where all of its properties cannot be written. */
+type ImmutableObject<T> = {
+    readonly [P in keyof T]: T[P];
+};
+/**
+ * Reference to an overlay that has been created with the Overlay service.
+ * Used to manipulate or dispose of said overlay.
+ */
+declare class OverlayRef implements PortalOutlet, OverlayReference {
+    private _portalOutlet;
+    private _host;
+    private _pane;
+    private _config;
+    private _ngZone;
+    private _keyboardDispatcher;
+    private _document;
+    private _location;
+    private _outsideClickDispatcher;
+    private _backdropElement;
+    private _backdropTimeout;
+    private readonly _backdropClick;
+    private readonly _attachments;
+    private readonly _detachments;
+    private _positionStrategy;
+    private _scrollStrategy;
+    private _locationChanges;
+    private _backdropClickHandler;
+    private _backdropTransitionendHandler;
+    /**
+     * Reference to the parent of the `_host` at the time it was detached. Used to restore
+     * the `_host` to its original position in the DOM when it gets re-attached.
+     */
+    private _previousHostParent;
+    /** Stream of keydown events dispatched to this overlay. */
+    readonly _keydownEvents: Subject<KeyboardEvent>;
+    /** Stream of mouse outside events dispatched to this overlay. */
+    readonly _outsidePointerEvents: Subject<MouseEvent>;
+    constructor(_portalOutlet: PortalOutlet, _host: HTMLElement, _pane: HTMLElement, _config: ImmutableObject<OverlayConfig>, _ngZone: NgZone, _keyboardDispatcher: OverlayKeyboardDispatcher, _document: Document, _location: Location, _outsideClickDispatcher: OverlayOutsideClickDispatcher);
+    /** The overlay's HTML element */
+    get overlayElement(): HTMLElement;
+    /** The overlay's backdrop HTML element. */
+    get backdropElement(): HTMLElement | null;
+    /**
+     * Wrapper around the panel element. Can be used for advanced
+     * positioning where a wrapper with specific styling is
+     * required around the overlay pane.
+     */
+    get hostElement(): HTMLElement;
+    attach<T>(portal: ComponentPortal<T>): ComponentRef<T>;
+    attach<T>(portal: TemplatePortal<T>): EmbeddedViewRef<T>;
+    attach(portal: any): any;
+    /**
+     * Detaches an overlay from a portal.
+     * @returns The portal detachment result.
+     */
+    detach(): any;
+    /** Cleans up the overlay from the DOM. */
+    dispose(): void;
+    /** Whether the overlay has attached content. */
+    hasAttached(): boolean;
+    /** Gets an observable that emits when the backdrop has been clicked. */
+    backdropClick(): Observable<MouseEvent>;
+    /** Gets an observable that emits when the overlay has been attached. */
+    attachments(): Observable<void>;
+    /** Gets an observable that emits when the overlay has been detached. */
+    detachments(): Observable<void>;
+    /** Gets an observable of keydown events targeted to this overlay. */
+    keydownEvents(): Observable<KeyboardEvent>;
+    /** Gets an observable of pointer events targeted outside this overlay. */
+    outsidePointerEvents(): Observable<MouseEvent>;
+    /** Gets the current overlay configuration, which is immutable. */
+    getConfig(): OverlayConfig;
+    /** Updates the position of the overlay based on the position strategy. */
+    updatePosition(): void;
+    /** Switches to a new position strategy and updates the overlay position. */
+    updatePositionStrategy(strategy: PositionStrategy): void;
+    /** Update the size properties of the overlay. */
+    updateSize(sizeConfig: OverlaySizeConfig): void;
+    /** Sets the LTR/RTL direction for the overlay. */
+    setDirection(dir: Direction | Directionality): void;
+    /** Add a CSS class or an array of classes to the overlay pane. */
+    addPanelClass(classes: string | string[]): void;
+    /** Remove a CSS class or an array of classes from the overlay pane. */
+    removePanelClass(classes: string | string[]): void;
+    /**
+     * Returns the layout direction of the overlay panel.
+     */
+    getDirection(): Direction;
+    /** Switches to a new scroll strategy. */
+    updateScrollStrategy(strategy: ScrollStrategy): void;
+    /** Updates the text direction of the overlay panel. */
+    private _updateElementDirection;
+    /** Updates the size of the overlay element based on the overlay config. */
+    private _updateElementSize;
+    /** Toggles the pointer events for the overlay pane element. */
+    private _togglePointerEvents;
+    /** Attaches a backdrop for this overlay. */
+    private _attachBackdrop;
+    /**
+     * Updates the stacking order of the element, moving it to the top if necessary.
+     * This is required in cases where one overlay was detached, while another one,
+     * that should be behind it, was destroyed. The next time both of them are opened,
+     * the stacking will be wrong, because the detached element's pane will still be
+     * in its original DOM position.
+     */
+    private _updateStackingOrder;
+    /** Detaches the backdrop (if any) associated with the overlay. */
+    detachBackdrop(): void;
+    /** Toggles a single CSS class or an array of classes on an element. */
+    private _toggleClasses;
+    /** Detaches the overlay content next time the zone stabilizes. */
+    private _detachContentWhenStable;
+    /** Disposes of a scroll strategy. */
+    private _disposeScrollStrategy;
+    /** Removes a backdrop element from the DOM. */
+    private _disposeBackdrop;
+}
+/** Size properties for an overlay. */
+interface OverlaySizeConfig {
+    width?: number | string;
+    height?: number | string;
+    minWidth?: number | string;
+    minHeight?: number | string;
+    maxWidth?: number | string;
+    maxHeight?: number | string;
+}
+
+/**
+ * @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
+ */
+
+/** Possible values that can be set as the origin of a FlexibleConnectedPositionStrategy. */
+type FlexibleConnectedPositionStrategyOrigin = ElementRef | Element | (Point & {
+    width?: number;
+    height?: number;
+});
+/**
+ * A strategy for positioning overlays. Using this strategy, an overlay is given an
+ * implicit position relative some origin element. The relative position is defined in terms of
+ * a point on the origin element that is connected to a point on the overlay element. For example,
+ * a basic dropdown is connecting the bottom-left corner of the origin to the top-left corner
+ * of the overlay.
+ */
+declare class FlexibleConnectedPositionStrategy implements PositionStrategy {
+    private _viewportRuler;
+    private _document;
+    private _platform;
+    private _overlayContainer;
+    /** The overlay to which this strategy is attached. */
+    private _overlayRef;
+    /** Whether we're performing the very first positioning of the overlay. */
+    private _isInitialRender;
+    /** Last size used for the bounding box. Used to avoid resizing the overlay after open. */
+    private _lastBoundingBoxSize;
+    /** Whether the overlay was pushed in a previous positioning. */
+    private _isPushed;
+    /** Whether the overlay can be pushed on-screen on the initial open. */
+    private _canPush;
+    /** Whether the overlay can grow via flexible width/height after the initial open. */
+    private _growAfterOpen;
+    /** Whether the overlay's width and height can be constrained to fit within the viewport. */
+    private _hasFlexibleDimensions;
+    /** Whether the overlay position is locked. */
+    private _positionLocked;
+    /** Cached origin dimensions */
+    private _originRect;
+    /** Cached overlay dimensions */
+    private _overlayRect;
+    /** Cached viewport dimensions */
+    private _viewportRect;
+    /** Cached container dimensions */
+    private _containerRect;
+    /** Amount of space that must be maintained between the overlay and the edge of the viewport. */
+    private _viewportMargin;
+    /** The Scrollable containers used to check scrollable view properties on position change. */
+    private _scrollables;
+    /** Ordered list of preferred positions, from most to least desirable. */
+    _preferredPositions: ConnectionPositionPair[];
+    /** The origin element against which the overlay will be positioned. */
+    private _origin;
+    /** The overlay pane element. */
+    private _pane;
+    /** Whether the strategy has been disposed of already. */
+    private _isDisposed;
+    /**
+     * Parent element for the overlay panel used to constrain the overlay panel's size to fit
+     * within the viewport.
+     */
+    private _boundingBox;
+    /** The last position to have been calculated as the best fit position. */
+    private _lastPosition;
+    /** Subject that emits whenever the position changes. */
+    private readonly _positionChanges;
+    /** Subscription to viewport size changes. */
+    private _resizeSubscription;
+    /** Default offset for the overlay along the x axis. */
+    private _offsetX;
+    /** Default offset for the overlay along the y axis. */
+    private _offsetY;
+    /** Selector to be used when finding the elements on which to set the transform origin. */
+    private _transformOriginSelector;
+    /** Keeps track of the CSS classes that the position strategy has applied on the overlay panel. */
+    private _appliedPanelClasses;
+    /** Amount by which the overlay was pushed in each axis during the last time it was positioned. */
+    private _previousPushAmount;
+    /** Observable sequence of position changes. */
+    positionChanges: Observable<ConnectedOverlayPositionChange>;
+    /** Ordered list of preferred positions, from most to least desirable. */
+    get positions(): ConnectionPositionPair[];
+    constructor(connectedTo: FlexibleConnectedPositionStrategyOrigin, _viewportRuler: ViewportRuler, _document: Document, _platform: Platform, _overlayContainer: OverlayContainer);
+    /** Attaches this position strategy to an overlay. */
+    attach(overlayRef: OverlayReference): void;
+    /**
+     * Updates the position of the overlay element, using whichever preferred position relative
+     * to the origin best fits on-screen.
+     *
+     * The selection of a position goes as follows:
+     *  - If any positions fit completely within the viewport as-is,
+     *      choose the first position that does so.
+     *  - If flexible dimensions are enabled and at least one satifies the given minimum width/height,
+     *      choose the position with the greatest available size modified by the positions' weight.
+     *  - If pushing is enabled, take the position that went off-screen the least and push it
+     *      on-screen.
+     *  - If none of the previous criteria were met, use the position that goes off-screen the least.
+     * @docs-private
+     */
+    apply(): void;
+    detach(): void;
+    /** Cleanup after the element gets destroyed. */
+    dispose(): void;
+    /**
+     * This re-aligns the overlay element with the trigger in its last calculated position,
+     * even if a position higher in the "preferred positions" list would now fit. This
+     * allows one to re-align the panel without changing the orientation of the panel.
+     */
+    reapplyLastPosition(): void;
+    /**
+     * Sets the list of Scrollable containers that host the origin element so that
+     * on reposition we can evaluate if it or the overlay has been clipped or outside view. Every
+     * Scrollable must be an ancestor element of the strategy's origin element.
+     */
+    withScrollableContainers(scrollables: CdkScrollable[]): this;
+    /**
+     * Adds new preferred positions.
+     * @param positions List of positions options for this overlay.
+     */
+    withPositions(positions: ConnectedPosition[]): this;
+    /**
+     * Sets a minimum distance the overlay may be positioned to the edge of the viewport.
+     * @param margin Required margin between the overlay and the viewport edge in pixels.
+     */
+    withViewportMargin(margin: number): this;
+    /** Sets whether the overlay's width and height can be constrained to fit within the viewport. */
+    withFlexibleDimensions(flexibleDimensions?: boolean): this;
+    /** Sets whether the overlay can grow after the initial open via flexible width/height. */
+    withGrowAfterOpen(growAfterOpen?: boolean): this;
+    /** Sets whether the overlay can be pushed on-screen if none of the provided positions fit. */
+    withPush(canPush?: boolean): this;
+    /**
+     * Sets whether the overlay's position should be locked in after it is positioned
+     * initially. When an overlay is locked in, it won't attempt to reposition itself
+     * when the position is re-applied (e.g. when the user scrolls away).
+     * @param isLocked Whether the overlay should locked in.
+     */
+    withLockedPosition(isLocked?: boolean): this;
+    /**
+     * Sets the origin, relative to which to position the overlay.
+     * Using an element origin is useful for building components that need to be positioned
+     * relatively to a trigger (e.g. dropdown menus or tooltips), whereas using a point can be
+     * used for cases like contextual menus which open relative to the user's pointer.
+     * @param origin Reference to the new origin.
+     */
+    setOrigin(origin: FlexibleConnectedPositionStrategyOrigin): this;
+    /**
+     * Sets the default offset for the overlay's connection point on the x-axis.
+     * @param offset New offset in the X axis.
+     */
+    withDefaultOffsetX(offset: number): this;
+    /**
+     * Sets the default offset for the overlay's connection point on the y-axis.
+     * @param offset New offset in the Y axis.
+     */
+    withDefaultOffsetY(offset: number): this;
+    /**
+     * Configures that the position strategy should set a `transform-origin` on some elements
+     * inside the overlay, depending on the current position that is being applied. This is
+     * useful for the cases where the origin of an animation can change depending on the
+     * alignment of the overlay.
+     * @param selector CSS selector that will be used to find the target
+     *    elements onto which to set the transform origin.
+     */
+    withTransformOriginOn(selector: string): this;
+    /**
+     * Gets the (x, y) coordinate of a connection point on the origin based on a relative position.
+     */
+    private _getOriginPoint;
+    /**
+     * Gets the (x, y) coordinate of the top-left corner of the overlay given a given position and
+     * origin point to which the overlay should be connected.
+     */
+    private _getOverlayPoint;
+    /** Gets how well an overlay at the given point will fit within the viewport. */
+    private _getOverlayFit;
+    /**
+     * Whether the overlay can fit within the viewport when it may resize either its width or height.
+     * @param fit How well the overlay fits in the viewport at some position.
+     * @param point The (x, y) coordinates of the overlay at some position.
+     * @param viewport The geometry of the viewport.
+     */
+    private _canFitWithFlexibleDimensions;
+    /**
+     * Gets the point at which the overlay can be "pushed" on-screen. If the overlay is larger than
+     * the viewport, the top-left corner will be pushed on-screen (with overflow occuring on the
+     * right and bottom).
+     *
+     * @param start Starting point from which the overlay is pushed.
+     * @param rawOverlayRect Dimensions of the overlay.
+     * @param scrollPosition Current viewport scroll position.
+     * @returns The point at which to position the overlay after pushing. This is effectively a new
+     *     originPoint.
+     */
+    private _pushOverlayOnScreen;
+    /**
+     * Applies a computed position to the overlay and emits a position change.
+     * @param position The position preference
+     * @param originPoint The point on the origin element where the overlay is connected.
+     */
+    private _applyPosition;
+    /** Sets the transform origin based on the configured selector and the passed-in position.  */
+    private _setTransformOrigin;
+    /**
+     * Gets the position and size of the overlay's sizing container.
+     *
+     * This method does no measuring and applies no styles so that we can cheaply compute the
+     * bounds for all positions and choose the best fit based on these results.
+     */
+    private _calculateBoundingBoxRect;
+    /**
+     * Sets the position and size of the overlay's sizing wrapper. The wrapper is positioned on the
+     * origin's connection point and stetches to the bounds of the viewport.
+     *
+     * @param origin The point on the origin element where the overlay is connected.
+     * @param position The position preference
+     */
+    private _setBoundingBoxStyles;
+    /** Resets the styles for the bounding box so that a new positioning can be computed. */
+    private _resetBoundingBoxStyles;
+    /** Resets the styles for the overlay pane so that a new positioning can be computed. */
+    private _resetOverlayElementStyles;
+    /** Sets positioning styles to the overlay element. */
+    private _setOverlayElementStyles;
+    /** Gets the exact top/bottom for the overlay when not using flexible sizing or when pushing. */
+    private _getExactOverlayY;
+    /** Gets the exact left/right for the overlay when not using flexible sizing or when pushing. */
+    private _getExactOverlayX;
+    /**
+     * Gets the view properties of the trigger and overlay, including whether they are clipped
+     * or completely outside the view of any of the strategy's scrollables.
+     */
+    private _getScrollVisibility;
+    /** Subtracts the amount that an element is overflowing on an axis from its length. */
+    private _subtractOverflows;
+    /** Narrows the given viewport rect by the current _viewportMargin. */
+    private _getNarrowedViewportRect;
+    /** Whether the we're dealing with an RTL context */
+    private _isRtl;
+    /** Determines whether the overlay uses exact or flexible positioning. */
+    private _hasExactPosition;
+    /** Retrieves the offset of a position along the x or y axis. */
+    private _getOffset;
+    /** Validates that the current position match the expected values. */
+    private _validatePositions;
+    /** Adds a single CSS class or an array of classes on the overlay panel. */
+    private _addPanelClasses;
+    /** Clears the classes that the position strategy has applied from the overlay panel. */
+    private _clearPanelClasses;
+    /** Returns the ClientRect of the current origin. */
+    private _getOriginRect;
+}
+/** A simple (x, y) coordinate. */
+interface Point {
+    x: number;
+    y: number;
+}
+/** A connected position as specified by the user. */
+interface ConnectedPosition {
+    originX: 'start' | 'center' | 'end';
+    originY: 'top' | 'center' | 'bottom';
+    overlayX: 'start' | 'center' | 'end';
+    overlayY: 'top' | 'center' | 'bottom';
+    weight?: number;
+    offsetX?: number;
+    offsetY?: number;
+    panelClass?: string | string[];
+}
+
+/**
+ * @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
+ */
+
+/**
+ * A strategy for positioning overlays. Using this strategy, an overlay is given an
+ * explicit position relative to the browser's viewport. We use flexbox, instead of
+ * transforms, in order to avoid issues with subpixel rendering which can cause the
+ * element to become blurry.
+ */
+declare class GlobalPositionStrategy implements PositionStrategy {
+    /** The overlay to which this strategy is attached. */
+    private _overlayRef;
+    private _cssPosition;
+    private _topOffset;
+    private _bottomOffset;
+    private _leftOffset;
+    private _rightOffset;
+    private _alignItems;
+    private _justifyContent;
+    private _width;
+    private _height;
+    private _isDisposed;
+    attach(overlayRef: OverlayReference): void;
+    /**
+     * Sets the top position of the overlay. Clears any previously set vertical position.
+     * @param value New top offset.
+     */
+    top(value?: string): this;
+    /**
+     * Sets the left position of the overlay. Clears any previously set horizontal position.
+     * @param value New left offset.
+     */
+    left(value?: string): this;
+    /**
+     * Sets the bottom position of the overlay. Clears any previously set vertical position.
+     * @param value New bottom offset.
+     */
+    bottom(value?: string): this;
+    /**
+     * Sets the right position of the overlay. Clears any previously set horizontal position.
+     * @param value New right offset.
+     */
+    right(value?: string): this;
+    /**
+     * Sets the overlay width and clears any previously set width.
+     * @param value New width for the overlay
+     * @deprecated Pass the `width` through the `OverlayConfig`.
+     * @breaking-change 8.0.0
+     */
+    width(value?: string): this;
+    /**
+     * Sets the overlay height and clears any previously set height.
+     * @param value New height for the overlay
+     * @deprecated Pass the `height` through the `OverlayConfig`.
+     * @breaking-change 8.0.0
+     */
+    height(value?: string): this;
+    /**
+     * Centers the overlay horizontally with an optional offset.
+     * Clears any previously set horizontal position.
+     *
+     * @param offset Overlay offset from the horizontal center.
+     */
+    centerHorizontally(offset?: string): this;
+    /**
+     * Centers the overlay vertically with an optional offset.
+     * Clears any previously set vertical position.
+     *
+     * @param offset Overlay offset from the vertical center.
+     */
+    centerVertically(offset?: string): this;
+    /**
+     * Apply the position to the element.
+     * @docs-private
+     */
+    apply(): void;
+    /**
+     * Cleans up the DOM changes from the position strategy.
+     * @docs-private
+     */
+    dispose(): void;
+}
+
+/**
+ * @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
+ */
+
+/** Builder for overlay position strategy. */
+declare class OverlayPositionBuilder {
+    private _viewportRuler;
+    private _document;
+    private _platform;
+    private _overlayContainer;
+    constructor(_viewportRuler: ViewportRuler, _document: any, _platform: Platform, _overlayContainer: OverlayContainer);
+    /**
+     * Creates a global position strategy.
+     */
+    global(): GlobalPositionStrategy;
+    /**
+     * Creates a flexible position strategy.
+     * @param origin Origin relative to which to position the overlay.
+     */
+    flexibleConnectedTo(origin: FlexibleConnectedPositionStrategyOrigin): FlexibleConnectedPositionStrategy;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayPositionBuilder, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OverlayPositionBuilder>;
+}
+
+/**
+ * @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
+ */
+
+/**
+ * Service to create Overlays. Overlays are dynamically added pieces of floating UI, meant to be
+ * used as a low-level building block for other components. Dialogs, tooltips, menus,
+ * selects, etc. can all be built using overlays. The service should primarily be used by authors
+ * of re-usable components rather than developers building end-user applications.
+ *
+ * An overlay *is* a PortalOutlet, so any kind of Portal can be loaded into one.
+ */
+declare class Overlay {
+    /** Scrolling strategies that can be used when creating an overlay. */
+    scrollStrategies: ScrollStrategyOptions;
+    private _overlayContainer;
+    private _componentFactoryResolver;
+    private _positionBuilder;
+    private _keyboardDispatcher;
+    private _injector;
+    private _ngZone;
+    private _document;
+    private _directionality;
+    private _location;
+    private _outsideClickDispatcher;
+    private _appRef;
+    constructor(
+    /** Scrolling strategies that can be used when creating an overlay. */
+    scrollStrategies: ScrollStrategyOptions, _overlayContainer: OverlayContainer, _componentFactoryResolver: ComponentFactoryResolver, _positionBuilder: OverlayPositionBuilder, _keyboardDispatcher: OverlayKeyboardDispatcher, _injector: Injector, _ngZone: NgZone, _document: any, _directionality: Directionality, _location: Location, _outsideClickDispatcher: OverlayOutsideClickDispatcher);
+    /**
+     * Creates an overlay.
+     * @param config Configuration applied to the overlay.
+     * @returns Reference to the created overlay.
+     */
+    create(config?: OverlayConfig): OverlayRef;
+    /**
+     * Gets a position builder that can be used, via fluent API,
+     * to construct and configure a position strategy.
+     * @returns An overlay position builder.
+     */
+    position(): OverlayPositionBuilder;
+    /**
+     * Creates the DOM element for an overlay and appends it to the overlay container.
+     * @returns Newly-created pane element
+     */
+    private _createPaneElement;
+    /**
+     * Creates the host element that wraps around an overlay
+     * and can be used for advanced positioning.
+     * @returns Newly-create host element.
+     */
+    private _createHostElement;
+    /**
+     * Create a DomPortalOutlet into which the overlay content can be loaded.
+     * @param pane The DOM element to turn into a portal outlet.
+     * @returns A portal outlet for the given DOM element.
+     */
+    private _createPortalOutlet;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Overlay, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Overlay>;
+}
+
+/**
+ * @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
+ */
+
+/**
+ * Directive applied to an element to make it usable as an origin for an Overlay using a
+ * ConnectedPositionStrategy.
+ */
+declare class CdkOverlayOrigin {
+    /** Reference to the element on which the directive is applied. */
+    elementRef: ElementRef;
+    constructor(
+    /** Reference to the element on which the directive is applied. */
+    elementRef: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkOverlayOrigin, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkOverlayOrigin, "[cdk-overlay-origin], [overlay-origin], [cdkOverlayOrigin]", ["cdkOverlayOrigin"], {}, {}, never, never, false, never>;
+}
+/**
+ * Directive to facilitate declarative creation of an
+ * Overlay using a FlexibleConnectedPositionStrategy.
+ */
+declare class CdkConnectedOverlay implements OnDestroy, OnChanges {
+    private _overlay;
+    private _dir;
+    private _overlayRef;
+    private _templatePortal;
+    private _hasBackdrop;
+    private _lockPosition;
+    private _growAfterOpen;
+    private _flexibleDimensions;
+    private _push;
+    private _backdropSubscription;
+    private _attachSubscription;
+    private _detachSubscription;
+    private _positionSubscription;
+    private _offsetX;
+    private _offsetY;
+    private _position;
+    private _scrollStrategyFactory;
+    /** Origin for the connected overlay. */
+    origin: CdkOverlayOrigin | FlexibleConnectedPositionStrategyOrigin;
+    /** Registered connected position pairs. */
+    positions: ConnectedPosition[];
+    /**
+     * This input overrides the positions input if specified. It lets users pass
+     * in arbitrary positioning strategies.
+     */
+    positionStrategy: FlexibleConnectedPositionStrategy;
+    /** The offset in pixels for the overlay connection point on the x-axis */
+    get offsetX(): number;
+    set offsetX(offsetX: number);
+    /** The offset in pixels for the overlay connection point on the y-axis */
+    get offsetY(): number;
+    set offsetY(offsetY: number);
+    /** The width of the overlay panel. */
+    width: number | string;
+    /** The height of the overlay panel. */
+    height: number | string;
+    /** The min width of the overlay panel. */
+    minWidth: number | string;
+    /** The min height of the overlay panel. */
+    minHeight: number | string;
+    /** The custom class to be set on the backdrop element. */
+    backdropClass: string;
+    /** The custom class to add to the overlay pane element. */
+    panelClass: string | string[];
+    /** Margin between the overlay and the viewport edges. */
+    viewportMargin: number;
+    /** Strategy to be used when handling scroll events while the overlay is open. */
+    scrollStrategy: ScrollStrategy;
+    /** Whether the overlay is open. */
+    open: boolean;
+    /** Whether the overlay can be closed by user interaction. */
+    disableClose: boolean;
+    /** CSS selector which to set the transform origin. */
+    transformOriginSelector: string;
+    /** Whether or not the overlay should attach a backdrop. */
+    get hasBackdrop(): boolean;
+    set hasBackdrop(value: BooleanInput);
+    /** Whether or not the overlay should be locked when scrolling. */
+    get lockPosition(): boolean;
+    set lockPosition(value: BooleanInput);
+    /** Whether the overlay's width and height can be constrained to fit within the viewport. */
+    get flexibleDimensions(): boolean;
+    set flexibleDimensions(value: BooleanInput);
+    /** Whether the overlay can grow after the initial open when flexible positioning is turned on. */
+    get growAfterOpen(): boolean;
+    set growAfterOpen(value: BooleanInput);
+    /** Whether the overlay can be pushed on-screen if none of the provided positions fit. */
+    get push(): boolean;
+    set push(value: BooleanInput);
+    /** Event emitted when the backdrop is clicked. */
+    readonly backdropClick: EventEmitter<MouseEvent>;
+    /** Event emitted when the position has changed. */
+    readonly positionChange: EventEmitter<ConnectedOverlayPositionChange>;
+    /** Event emitted when the overlay has been attached. */
+    readonly attach: EventEmitter<void>;
+    /** Event emitted when the overlay has been detached. */
+    readonly detach: EventEmitter<void>;
+    /** Emits when there are keyboard events that are targeted at the overlay. */
+    readonly overlayKeydown: EventEmitter<KeyboardEvent>;
+    /** Emits when there are mouse outside click events that are targeted at the overlay. */
+    readonly overlayOutsideClick: EventEmitter<MouseEvent>;
+    constructor(_overlay: Overlay, templateRef: TemplateRef<any>, viewContainerRef: ViewContainerRef, scrollStrategyFactory: any, _dir: Directionality);
+    /** The associated overlay reference. */
+    get overlayRef(): OverlayRef;
+    /** The element's layout direction. */
+    get dir(): Direction;
+    ngOnDestroy(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    /** Creates an overlay */
+    private _createOverlay;
+    /** Builds the overlay config based on the directive's inputs */
+    private _buildConfig;
+    /** Updates the state of a position strategy, based on the values of the directive inputs. */
+    private _updatePositionStrategy;
+    /** Returns the position strategy of the overlay to be set on the overlay config */
+    private _createPositionStrategy;
+    private _getFlexibleConnectedPositionStrategyOrigin;
+    /** Attaches the overlay and subscribes to backdrop clicks if backdrop exists */
+    private _attachOverlay;
+    /** Detaches the overlay and unsubscribes to backdrop clicks if backdrop exists */
+    private _detachOverlay;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkConnectedOverlay, [null, null, null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkConnectedOverlay, "[cdk-connected-overlay], [connected-overlay], [cdkConnectedOverlay]", ["cdkConnectedOverlay"], { "origin": { "alias": "cdkConnectedOverlayOrigin"; "required": false; }; "positions": { "alias": "cdkConnectedOverlayPositions"; "required": false; }; "positionStrategy": { "alias": "cdkConnectedOverlayPositionStrategy"; "required": false; }; "offsetX": { "alias": "cdkConnectedOverlayOffsetX"; "required": false; }; "offsetY": { "alias": "cdkConnectedOverlayOffsetY"; "required": false; }; "width": { "alias": "cdkConnectedOverlayWidth"; "required": false; }; "height": { "alias": "cdkConnectedOverlayHeight"; "required": false; }; "minWidth": { "alias": "cdkConnectedOverlayMinWidth"; "required": false; }; "minHeight": { "alias": "cdkConnectedOverlayMinHeight"; "required": false; }; "backdropClass": { "alias": "cdkConnectedOverlayBackdropClass"; "required": false; }; "panelClass": { "alias": "cdkConnectedOverlayPanelClass"; "required": false; }; "viewportMargin": { "alias": "cdkConnectedOverlayViewportMargin"; "required": false; }; "scrollStrategy": { "alias": "cdkConnectedOverlayScrollStrategy"; "required": false; }; "open": { "alias": "cdkConnectedOverlayOpen"; "required": false; }; "disableClose": { "alias": "cdkConnectedOverlayDisableClose"; "required": false; }; "transformOriginSelector": { "alias": "cdkConnectedOverlayTransformOriginOn"; "required": false; }; "hasBackdrop": { "alias": "cdkConnectedOverlayHasBackdrop"; "required": false; }; "lockPosition": { "alias": "cdkConnectedOverlayLockPosition"; "required": false; }; "flexibleDimensions": { "alias": "cdkConnectedOverlayFlexibleDimensions"; "required": false; }; "growAfterOpen": { "alias": "cdkConnectedOverlayGrowAfterOpen"; "required": false; }; "push": { "alias": "cdkConnectedOverlayPush"; "required": false; }; }, { "backdropClick": "backdropClick"; "positionChange": "positionChange"; "attach": "attach"; "detach": "detach"; "overlayKeydown": "overlayKeydown"; "overlayOutsideClick": "overlayOutsideClick"; }, never, never, false, never>;
+}
+
+declare class OverlayModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<OverlayModule, [typeof CdkConnectedOverlay, typeof CdkOverlayOrigin], [typeof i2.BidiModule, typeof i3.PortalModule, typeof i4.ScrollingModule], [typeof CdkConnectedOverlay, typeof CdkOverlayOrigin, typeof i4.ScrollingModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<OverlayModule>;
+}
+
+/**
+ * @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
+ */
+
+/**
+ * Alternative to OverlayContainer that supports correct displaying of overlay elements in
+ * Fullscreen mode
+ * https://developer.mozilla.org/en-US/docs/Web/API/Element/requestFullScreen
+ *
+ * Should be provided in the root component.
+ */
+declare class FullscreenOverlayContainer extends OverlayContainer implements OnDestroy {
+    private _fullScreenEventName;
+    private _fullScreenListener;
+    constructor(_document: any, platform: Platform);
+    ngOnDestroy(): void;
+    protected _createContainer(): void;
+    private _adjustParentForFullscreenChange;
+    private _addFullscreenChangeListener;
+    private _getEventName;
+    /**
+     * When the page is put into fullscreen mode, a specific element is specified.
+     * Only that element and its children are visible when in fullscreen mode.
+     */
+    getFullscreenElement(): Element;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FullscreenOverlayContainer, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FullscreenOverlayContainer>;
+}
+
+export { BlockScrollStrategy, CdkConnectedOverlay, CdkOverlayOrigin, CloseScrollStrategy, ConnectedOverlayPositionChange, ConnectionPositionPair, FlexibleConnectedPositionStrategy, FullscreenOverlayContainer, GlobalPositionStrategy, NoopScrollStrategy, Overlay, OverlayConfig, OverlayContainer, OverlayKeyboardDispatcher, OverlayModule, OverlayOutsideClickDispatcher, OverlayPositionBuilder, OverlayRef, RepositionScrollStrategy, ScrollStrategyOptions, ScrollingVisibility, validateHorizontalPosition, validateVerticalPosition };
+export type { ConnectedPosition, FlexibleConnectedPositionStrategyOrigin, HorizontalConnectionPos, OriginConnectionPosition, OverlayConnectionPosition, OverlaySizeConfig, PositionStrategy, RepositionScrollStrategyConfig, ScrollStrategy, VerticalConnectionPos };