index.api.md

API Report File for "@angular/cdk_overlay"

Do not edit this file. It is a report generated by API Extractor.

import { AfterContentInit } from '@angular/core';
import { Binding } from '@angular/core';
import { ComponentRef } from '@angular/core';
import { DoCheck } from '@angular/core';
import { ElementRef } from '@angular/core';
import { EmbeddedViewRef } from '@angular/core';
import { EnvironmentInjector } from '@angular/core';
import { EventEmitter } from '@angular/core';
import * as i0 from '@angular/core';
import { InjectionToken } from '@angular/core';
import { Injector } from '@angular/core';
import { Location as Location_2 } from '@angular/common';
import { NgIterable } from '@angular/core';
import { NgZone } from '@angular/core';
import { Observable } from 'rxjs';
import { OnChanges } from '@angular/core';
import { OnDestroy } from '@angular/core';
import { OnInit } from '@angular/core';
import { Renderer2 } from '@angular/core';
import { SimpleChanges } from '@angular/core';
import { Subject } from 'rxjs';
import { Subscription } from 'rxjs';
import { TemplateRef } from '@angular/core';
import { TrackByFunction } from '@angular/core';
import { Type } from '@angular/core';
import { ViewContainerRef } from '@angular/core';

// @public
export class BlockScrollStrategy implements ScrollStrategy {
    constructor(_viewportRuler: ViewportRuler, document: any);
    attach(): void;
    disable(): void;
    enable(): void;
}

// @public
export const CDK_CONNECTED_OVERLAY_DEFAULT_CONFIG: InjectionToken<CdkConnectedOverlayConfig>;

// @public
export class CdkConnectedOverlay implements OnDestroy, OnChanges {
    constructor(...args: unknown[]);
    readonly attach: EventEmitter<void>;
    attachOverlay(): void;
    backdropClass: string | string[];
    readonly backdropClick: EventEmitter<MouseEvent>;
    set _config(value: string | CdkConnectedOverlayConfig);
    readonly detach: EventEmitter<void>;
    detachOverlay(): void;
    get dir(): Direction;
    disableClose: boolean;
    disposeOnNavigation: boolean;
    flexibleDimensions: boolean;
    growAfterOpen: boolean;
    hasBackdrop: boolean;
    height: number | string;
    lockPosition: boolean;
    matchWidth: boolean;
    minHeight: number | string;
    minWidth: number | string;
    // (undocumented)
    static ngAcceptInputType_disposeOnNavigation: unknown;
    // (undocumented)
    static ngAcceptInputType_flexibleDimensions: unknown;
    // (undocumented)
    static ngAcceptInputType_growAfterOpen: unknown;
    // (undocumented)
    static ngAcceptInputType_hasBackdrop: unknown;
    // (undocumented)
    static ngAcceptInputType_lockPosition: unknown;
    // (undocumented)
    static ngAcceptInputType_matchWidth: unknown;
    // (undocumented)
    static ngAcceptInputType_push: unknown;
    // (undocumented)
    ngOnChanges(changes: SimpleChanges<this>): void;
    // (undocumented)
    ngOnDestroy(): void;
    get offsetX(): number;
    set offsetX(offsetX: number);
    get offsetY(): number;
    set offsetY(offsetY: number);
    open: boolean;
    origin: CdkOverlayOrigin | FlexibleConnectedPositionStrategyOrigin;
    readonly overlayKeydown: EventEmitter<KeyboardEvent>;
    readonly overlayOutsideClick: EventEmitter<MouseEvent>;
    get overlayRef(): OverlayRef;
    panelClass: string | string[];
    readonly positionChange: EventEmitter<ConnectedOverlayPositionChange>;
    positions: ConnectedPosition[];
    positionStrategy: FlexibleConnectedPositionStrategy;
    push: boolean;
    scrollStrategy: ScrollStrategy;
    transformOriginSelector: string;
    usePopover: FlexibleOverlayPopoverLocation | null;
    viewportMargin: ViewportMargin;
    width: number | string;
    // (undocumented)
    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; }; "disposeOnNavigation": { "alias": "cdkConnectedOverlayDisposeOnNavigation"; "required": false; }; "usePopover": { "alias": "cdkConnectedOverlayUsePopover"; "required": false; }; "matchWidth": { "alias": "cdkConnectedOverlayMatchWidth"; "required": false; }; "_config": { "alias": "cdkConnectedOverlay"; "required": false; }; }, { "backdropClick": "backdropClick"; "positionChange": "positionChange"; "attach": "attach"; "detach": "detach"; "overlayKeydown": "overlayKeydown"; "overlayOutsideClick": "overlayOutsideClick"; }, never, never, true, never>;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<CdkConnectedOverlay, never>;
}

// @public
export interface CdkConnectedOverlayConfig {
    // (undocumented)
    backdropClass?: string | string[];
    // (undocumented)
    disableClose?: boolean;
    // (undocumented)
    disposeOnNavigation?: boolean;
    // (undocumented)
    flexibleDimensions?: boolean;
    // (undocumented)
    growAfterOpen?: boolean;
    // (undocumented)
    hasBackdrop?: boolean;
    // (undocumented)
    height?: number | string;
    // (undocumented)
    lockPosition?: boolean;
    // (undocumented)
    matchWidth?: boolean;
    // (undocumented)
    minHeight?: number | string;
    // (undocumented)
    minWidth?: number | string;
    // (undocumented)
    offsetX?: number;
    // (undocumented)
    offsetY?: number;
    // (undocumented)
    origin?: CdkOverlayOrigin | FlexibleConnectedPositionStrategyOrigin;
    // (undocumented)
    panelClass?: string | string[];
    // (undocumented)
    positions?: ConnectedPosition[];
    // (undocumented)
    positionStrategy?: FlexibleConnectedPositionStrategy;
    // (undocumented)
    push?: boolean;
    // (undocumented)
    scrollStrategy?: ScrollStrategy;
    // (undocumented)
    transformOriginSelector?: string;
    // (undocumented)
    usePopover?: FlexibleOverlayPopoverLocation | null;
    // (undocumented)
    viewportMargin?: ViewportMargin;
    // (undocumented)
    width?: number | string;
}

// @public
export class CdkOverlayOrigin {
    constructor(...args: unknown[]);
    // (undocumented)
    elementRef: ElementRef<any>;
    // (undocumented)
    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkOverlayOrigin, "[cdk-overlay-origin], [overlay-origin], [cdkOverlayOrigin]", ["cdkOverlayOrigin"], {}, {}, never, never, true, never>;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<CdkOverlayOrigin, never>;
}

// @public
export class CdkScrollable implements OnInit, OnDestroy {
    constructor(...args: unknown[]);
    // (undocumented)
    protected readonly _destroyed: Subject<void>;
    // (undocumented)
    protected dir?: Directionality | null | undefined;
    // (undocumented)
    protected elementRef: ElementRef<HTMLElement>;
    elementScrolled(): Observable<Event>;
    getElementRef(): ElementRef<HTMLElement>;
    measureScrollOffset(from: 'top' | 'left' | 'right' | 'bottom' | 'start' | 'end'): number;
    // (undocumented)
    ngOnDestroy(): void;
    // (undocumented)
    ngOnInit(): void;
    // (undocumented)
    protected ngZone: NgZone;
    // (undocumented)
    protected scrollDispatcher: ScrollDispatcher;
    // (undocumented)
    protected _scrollElement: EventTarget;
    scrollTo(options: ExtendedScrollToOptions): void;
    // (undocumented)
    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkScrollable, "[cdk-scrollable], [cdkScrollable]", never, {}, {}, never, never, true, never>;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<CdkScrollable, never>;
}

// @public
export class CloseScrollStrategy implements ScrollStrategy {
    constructor(_scrollDispatcher: ScrollDispatcher, _ngZone: NgZone, _viewportRuler: ViewportRuler, _config?: CloseScrollStrategyConfig | undefined);
    attach(overlayRef: OverlayRef): void;
    // (undocumented)
    detach(): void;
    disable(): void;
    enable(): void;
}

// @public @deprecated
export interface ComponentType<T> {
    // (undocumented)
    new (...args: any[]): T;
}

// @public
export class ConnectedOverlayPositionChange {
    constructor(
    connectionPair: ConnectionPositionPair,
    scrollableViewProperties: ScrollingVisibility);
    connectionPair: ConnectionPositionPair;
    scrollableViewProperties: ScrollingVisibility;
}

// @public
export interface ConnectedPosition {
    // (undocumented)
    offsetX?: number;
    // (undocumented)
    offsetY?: number;
    // (undocumented)
    originX: 'start' | 'center' | 'end';
    // (undocumented)
    originY: 'top' | 'center' | 'bottom';
    // (undocumented)
    overlayX: 'start' | 'center' | 'end';
    // (undocumented)
    overlayY: 'top' | 'center' | 'bottom';
    // (undocumented)
    panelClass?: string | string[];
    // (undocumented)
    weight?: number;
}

// @public
export class ConnectionPositionPair {
    constructor(origin: OriginConnectionPosition, overlay: OverlayConnectionPosition,
    offsetX?: number | undefined,
    offsetY?: number | undefined,
    panelClass?: string | string[] | undefined);
    offsetX?: number | undefined;
    offsetY?: number | undefined;
    originX: HorizontalConnectionPos;
    originY: VerticalConnectionPos;
    overlayX: HorizontalConnectionPos;
    overlayY: VerticalConnectionPos;
    panelClass?: string | string[] | undefined;
}

// @public
export function createBlockScrollStrategy(injector: Injector): BlockScrollStrategy;

// @public
export function createCloseScrollStrategy(injector: Injector, config?: CloseScrollStrategyConfig): CloseScrollStrategy;

// @public
export function createFlexibleConnectedPositionStrategy(injector: Injector, origin: FlexibleConnectedPositionStrategyOrigin): FlexibleConnectedPositionStrategy;

// @public
export function createGlobalPositionStrategy(_injector: Injector): GlobalPositionStrategy;

// @public
export function createNoopScrollStrategy(): NoopScrollStrategy;

// @public
export function createOverlayRef(injector: Injector, config?: OverlayConfig): OverlayRef;

// @public
export function createRepositionScrollStrategy(injector: Injector, config?: RepositionScrollStrategyConfig): RepositionScrollStrategy;

// @public
export class FlexibleConnectedPositionStrategy implements PositionStrategy {
    constructor(connectedTo: FlexibleConnectedPositionStrategyOrigin, _viewportRuler: ViewportRuler, _document: Document, _platform: Platform, _overlayContainer: OverlayContainer);
    apply(): void;
    attach(overlayRef: OverlayRef): void;
    // (undocumented)
    detach(): void;
    dispose(): void;
    getPopoverInsertionPoint(): Element | null | {
        type: 'parent';
        element: Element;
    };
    _origin: FlexibleConnectedPositionStrategyOrigin;
    positionChanges: Observable<ConnectedOverlayPositionChange>;
    get positions(): ConnectionPositionPair[];
    _preferredPositions: ConnectionPositionPair[];
    reapplyLastPosition(): void;
    setOrigin(origin: FlexibleConnectedPositionStrategyOrigin): this;
    withDefaultOffsetX(offset: number): this;
    withDefaultOffsetY(offset: number): this;
    withFlexibleDimensions(flexibleDimensions?: boolean): this;
    withGrowAfterOpen(growAfterOpen?: boolean): this;
    withLockedPosition(isLocked?: boolean): this;
    withPopoverLocation(location: FlexibleOverlayPopoverLocation): this;
    withPositions(positions: ConnectedPosition[]): this;
    withPush(canPush?: boolean): this;
    withScrollableContainers(scrollables: CdkScrollable[]): this;
    withTransformOriginOn(selector: string): this;
    withViewportMargin(margin: ViewportMargin): this;
}

// @public
export type FlexibleConnectedPositionStrategyOrigin = ElementRef | Element | (Point & {
    width?: number;
    height?: number;
});

// @public
export type FlexibleOverlayPopoverLocation = 'global' | 'inline' | {
    type: 'parent';
    element: Element;
};

// @public
export class FullscreenOverlayContainer extends OverlayContainer implements OnDestroy {
    constructor(...args: unknown[]);
    // (undocumented)
    protected _createContainer(): void;
    getFullscreenElement(): Element;
    // (undocumented)
    ngOnDestroy(): void;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<FullscreenOverlayContainer, never>;
    // (undocumented)
    static ɵprov: i0.ɵɵInjectableDeclaration<FullscreenOverlayContainer>;
}

// @public
export class GlobalPositionStrategy implements PositionStrategy {
    apply(): void;
    // (undocumented)
    attach(overlayRef: OverlayRef): void;
    bottom(value?: string): this;
    centerHorizontally(offset?: string): this;
    centerVertically(offset?: string): this;
    dispose(): void;
    end(value?: string): this;
    // @deprecated
    height(value?: string): this;
    left(value?: string): this;
    right(value?: string): this;
    start(value?: string): this;
    top(value?: string): this;
    // @deprecated
    width(value?: string): this;
}

// @public
export type HorizontalConnectionPos = 'start' | 'center' | 'end';

// @public
export class NoopScrollStrategy implements ScrollStrategy {
    attach(): void;
    disable(): void;
    enable(): void;
}

// @public
export interface OriginConnectionPosition {
    // (undocumented)
    originX: HorizontalConnectionPos;
    // (undocumented)
    originY: VerticalConnectionPos;
}

// @public
export class Overlay {
    constructor(...args: unknown[]);
    create(config?: OverlayConfig): OverlayRef;
    position(): OverlayPositionBuilder;
    // (undocumented)
    scrollStrategies: ScrollStrategyOptions;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<Overlay, never>;
    // (undocumented)
    static ɵprov: i0.ɵɵInjectableDeclaration<Overlay>;
}

// @public
export const OVERLAY_DEFAULT_CONFIG: InjectionToken<OverlayDefaultConfig>;

// @public
export class OverlayConfig {
    constructor(config?: OverlayConfig);
    backdropClass?: string | string[];
    direction?: Direction | Directionality;
    disableAnimations?: boolean;
    disposeOnNavigation?: boolean;
    eventPredicate?: (event: Event) => boolean;
    hasBackdrop?: boolean;
    height?: number | string;
    maxHeight?: number | string;
    maxWidth?: number | string;
    minHeight?: number | string;
    minWidth?: number | string;
    panelClass?: string | string[];
    positionStrategy?: PositionStrategy;
    scrollStrategy?: ScrollStrategy;
    usePopover?: boolean;
    width?: number | string;
}

// @public
export interface OverlayConnectionPosition {
    // (undocumented)
    overlayX: HorizontalConnectionPos;
    // (undocumented)
    overlayY: VerticalConnectionPos;
}

// @public
export class OverlayContainer implements OnDestroy {
    constructor(...args: unknown[]);
    // (undocumented)
    protected _containerElement: HTMLElement | undefined;
    protected _createContainer(): void;
    // (undocumented)
    protected _document: Document;
    getContainerElement(): HTMLElement;
    protected _loadStyles(): void;
    // (undocumented)
    ngOnDestroy(): void;
    // (undocumented)
    protected _platform: Platform;
    // (undocumented)
    protected _styleLoader: _CdkPrivateStyleLoader;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayContainer, never>;
    // (undocumented)
    static ɵprov: i0.ɵɵInjectableDeclaration<OverlayContainer>;
}

// @public
export interface OverlayDefaultConfig {
    // (undocumented)
    usePopover?: boolean;
}

// @public
export class OverlayKeyboardDispatcher extends BaseOverlayDispatcher {
    add(overlayRef: OverlayRef): void;
    protected detach(): void;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayKeyboardDispatcher, never>;
    // (undocumented)
    static ɵprov: i0.ɵɵInjectableDeclaration<OverlayKeyboardDispatcher>;
}

// @public (undocumented)
export class OverlayModule {
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayModule, never>;
    // (undocumented)
    static ɵinj: i0.ɵɵInjectorDeclaration<OverlayModule>;
    // (undocumented)
    static ɵmod: i0.ɵɵNgModuleDeclaration<OverlayModule, never, [typeof BidiModule, typeof PortalModule, typeof ScrollingModule, typeof CdkConnectedOverlay, typeof CdkOverlayOrigin], [typeof CdkConnectedOverlay, typeof CdkOverlayOrigin, typeof ScrollingModule]>;
}

// @public
export class OverlayOutsideClickDispatcher extends BaseOverlayDispatcher {
    add(overlayRef: OverlayRef): void;
    protected detach(): void;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayOutsideClickDispatcher, never>;
    // (undocumented)
    static ɵprov: i0.ɵɵInjectableDeclaration<OverlayOutsideClickDispatcher>;
}

// @public
export class OverlayPositionBuilder {
    constructor(...args: unknown[]);
    flexibleConnectedTo(origin: FlexibleConnectedPositionStrategyOrigin): FlexibleConnectedPositionStrategy;
    global(): GlobalPositionStrategy;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayPositionBuilder, never>;
    // (undocumented)
    static ɵprov: i0.ɵɵInjectableDeclaration<OverlayPositionBuilder>;
}

// @public
export class OverlayRef implements PortalOutlet {
    constructor(_portalOutlet: PortalOutlet, _host: HTMLElement, _pane: HTMLElement, _config: ImmutableObject<OverlayConfig>, _ngZone: NgZone, _keyboardDispatcher: OverlayKeyboardDispatcher, _document: Document, _location: Location_2, _outsideClickDispatcher: OverlayOutsideClickDispatcher, _animationsDisabled: boolean | undefined, _injector: EnvironmentInjector, _renderer: Renderer2);
    addPanelClass(classes: string | string[]): void;
    // (undocumented)
    attach<T>(portal: ComponentPortal<T>): ComponentRef<T>;
    // (undocumented)
    attach<T>(portal: TemplatePortal<T>): EmbeddedViewRef<T>;
    // (undocumented)
    attach(portal: any): any;
    attachments(): Observable<void>;
    backdropClick(): Observable<MouseEvent>;
    get backdropElement(): HTMLElement | null;
    detach(): any;
    detachBackdrop(): void;
    detachments(): Observable<void>;
    dispose(): void;
    get eventPredicate(): ((event: Event) => boolean) | null;
    getConfig(): OverlayConfig;
    getDirection(): Direction;
    hasAttached(): boolean;
    get hostElement(): HTMLElement;
    keydownEvents(): Observable<KeyboardEvent>;
    readonly _keydownEvents: Subject<KeyboardEvent>;
    outsidePointerEvents(): Observable<MouseEvent>;
    readonly _outsidePointerEvents: Subject<MouseEvent>;
    get overlayElement(): HTMLElement;
    removePanelClass(classes: string | string[]): void;
    setDirection(dir: Direction | Directionality): void;
    updatePosition(): void;
    updatePositionStrategy(strategy: PositionStrategy): void;
    updateScrollStrategy(strategy: ScrollStrategy): void;
    updateSize(sizeConfig: OverlaySizeConfig): void;
}

// @public
export interface OverlaySizeConfig {
    // (undocumented)
    height?: number | string;
    // (undocumented)
    maxHeight?: number | string;
    // (undocumented)
    maxWidth?: number | string;
    // (undocumented)
    minHeight?: number | string;
    // (undocumented)
    minWidth?: number | string;
    // (undocumented)
    width?: number | string;
}

// @public
export interface PositionStrategy {
    apply(): void;
    attach(overlayRef: OverlayRef): void;
    detach?(): void;
    dispose(): void;
    getPopoverInsertionPoint?(): Element | null | {
        type: 'parent';
        element: Element;
    };
}

// @public
export class RepositionScrollStrategy implements ScrollStrategy {
    constructor(_scrollDispatcher: ScrollDispatcher, _viewportRuler: ViewportRuler, _ngZone: NgZone, _config?: RepositionScrollStrategyConfig | undefined);
    attach(overlayRef: OverlayRef): void;
    // (undocumented)
    detach(): void;
    disable(): void;
    enable(): void;
}

// @public
export interface RepositionScrollStrategyConfig {
    autoClose?: boolean;
    scrollThrottle?: number;
}

// @public
export class ScrollDispatcher implements OnDestroy {
    constructor(...args: unknown[]);
    ancestorScrolled(elementOrElementRef: ElementRef | HTMLElement, auditTimeInMs?: number): Observable<CdkScrollable | void>;
    deregister(scrollable: CdkScrollable): void;
    getAncestorScrollContainers(elementOrElementRef: ElementRef | HTMLElement): CdkScrollable[];
    // (undocumented)
    ngOnDestroy(): void;
    register(scrollable: CdkScrollable): void;
    scrollContainers: Map<CdkScrollable, Subscription>;
    scrolled(auditTimeInMs?: number): Observable<CdkScrollable | void>;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollDispatcher, never>;
    // (undocumented)
    static ɵprov: i0.ɵɵInjectableDeclaration<ScrollDispatcher>;
}

// @public
export class ScrollingVisibility {
    // (undocumented)
    isOriginClipped: boolean;
    // (undocumented)
    isOriginOutsideView: boolean;
    // (undocumented)
    isOverlayClipped: boolean;
    // (undocumented)
    isOverlayOutsideView: boolean;
}

// @public
export interface ScrollStrategy {
    attach: (overlayRef: OverlayRef) => void;
    detach?: () => void;
    disable: () => void;
    enable: () => void;
}

// @public
export class ScrollStrategyOptions {
    constructor(...args: unknown[]);
    block: () => BlockScrollStrategy;
    close: (config?: CloseScrollStrategyConfig) => CloseScrollStrategy;
    noop: () => NoopScrollStrategy;
    reposition: (config?: RepositionScrollStrategyConfig) => RepositionScrollStrategy;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollStrategyOptions, never>;
    // (undocumented)
    static ɵprov: i0.ɵɵInjectableDeclaration<ScrollStrategyOptions>;
}

// @public (undocumented)
export const STANDARD_DROPDOWN_ADJACENT_POSITIONS: ConnectedPosition[];

// @public (undocumented)
export const STANDARD_DROPDOWN_BELOW_POSITIONS: ConnectedPosition[];

// @public
export function validateHorizontalPosition(property: string, value: HorizontalConnectionPos): void;

// @public
export function validateVerticalPosition(property: string, value: VerticalConnectionPos): void;

// @public
export type VerticalConnectionPos = 'top' | 'center' | 'bottom';

// @public
export type ViewportMargin = number | {
    top?: number;
    bottom?: number;
    start?: number;
    end?: number;
};

// @public
export class ViewportRuler implements OnDestroy {
    constructor(...args: unknown[]);
    change(throttleTime?: number): Observable<Event>;
    protected _document: Document;
    getViewportRect(): {
        top: number;
        left: number;
        bottom: number;
        right: number;
        height: number;
        width: number;
    };
    getViewportScrollPosition(): ViewportScrollPosition;
    getViewportSize(): Readonly<{
        width: number;
        height: number;
    }>;
    // (undocumented)
    ngOnDestroy(): void;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<ViewportRuler, never>;
    // (undocumented)
    static ɵprov: i0.ɵɵInjectableDeclaration<ViewportRuler>;
}

// (No @packageDocumentation comment for this package)