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

package/overlay/overlay-reference.d.ts

@@ -1,38 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { Portal } from '@angular/cdk/portal';
-import { Direction, Directionality } from '@angular/cdk/bidi';
-import { Observable, Subject } from 'rxjs';
-/**
- * Basic interface for an overlay. Used to avoid circular type references between
- * `OverlayRef`, `PositionStrategy` and `ScrollStrategy`, and `OverlayConfig`.
- * @docs-private
- */
-export 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>;
-}

package/overlay/overlay.d.ts

@@ -1,76 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { Directionality } from '@angular/cdk/bidi';
-import { Location } from '@angular/common';
-import { ComponentFactoryResolver, Injector, NgZone } from '@angular/core';
-import { OverlayKeyboardDispatcher } from './dispatchers/overlay-keyboard-dispatcher';
-import { OverlayOutsideClickDispatcher } from './dispatchers/overlay-outside-click-dispatcher';
-import { OverlayConfig } from './overlay-config';
-import { OverlayContainer } from './overlay-container';
-import { OverlayRef } from './overlay-ref';
-import { OverlayPositionBuilder } from './position/overlay-position-builder';
-import { ScrollStrategyOptions } from './scroll/index';
-import * as i0 from "@angular/core";
-/**
- * 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.
- */
-export 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 _animationsModuleType?;
-    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, _animationsModuleType?: string | undefined);
-    /**
-     * 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, [null, null, null, null, null, null, null, null, null, null, null, { optional: true; }]>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<Overlay>;
-}

package/overlay/overlay_public_index.d.ts

@@ -1,4 +0,0 @@
-/**
- * Generated bundle index. Do not edit.
- */
-export * from './index';

package/overlay/package.json

@@ -1,9 +0,0 @@
-{
-  "name": "@angular/cdk/overlay",
-  "fesm2020": "../fesm2020/overlay.mjs",
-  "fesm2015": "../fesm2015/overlay.mjs",
-  "esm2020": "../esm2020/overlay/overlay_public_index.mjs",
-  "typings": "./overlay_public_index.d.ts",
-  "module": "../fesm2015/overlay.mjs",
-  "es2020": "../fesm2020/overlay.mjs"
-}

package/overlay/position/connected-position.d.ts

@@ -1,102 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-/** Horizontal dimension of a connection point on the perimeter of the origin or overlay element. */
-export declare type HorizontalConnectionPos = 'start' | 'center' | 'end';
-/** Vertical dimension of a connection point on the perimeter of the origin or overlay element. */
-export declare type VerticalConnectionPos = 'top' | 'center' | 'bottom';
-/** A connection point on the origin element. */
-export interface OriginConnectionPosition {
-    originX: HorizontalConnectionPos;
-    originY: VerticalConnectionPos;
-}
-/** A connection point on the overlay element. */
-export interface OverlayConnectionPosition {
-    overlayX: HorizontalConnectionPos;
-    overlayY: VerticalConnectionPos;
-}
-/** The points of the origin element and the overlay element to connect. */
-export 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
- */
-export declare class ScrollingVisibility {
-    isOriginClipped: boolean;
-    isOriginOutsideView: boolean;
-    isOverlayClipped: boolean;
-    isOverlayOutsideView: boolean;
-}
-/** The change event emitted by the strategy when a fallback position is used. */
-export 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
- */
-export 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
- */
-export declare function validateHorizontalPosition(property: string, value: HorizontalConnectionPos): void;

package/overlay/position/flexible-connected-position-strategy.d.ts

@@ -1,282 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { PositionStrategy } from './position-strategy';
-import { ElementRef } from '@angular/core';
-import { ViewportRuler, CdkScrollable } from '@angular/cdk/scrolling';
-import { ConnectedOverlayPositionChange, ConnectionPositionPair } from './connected-position';
-import { Observable } from 'rxjs';
-import { OverlayReference } from '../overlay-reference';
-import { Platform } from '@angular/cdk/platform';
-import { OverlayContainer } from '../overlay-container';
-/** Possible values that can be set as the origin of a FlexibleConnectedPositionStrategy. */
-export declare 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.
- */
-export 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. */
-export 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[];
-}
-export declare const STANDARD_DROPDOWN_BELOW_POSITIONS: ConnectedPosition[];
-export declare const STANDARD_DROPDOWN_ADJACENT_POSITIONS: ConnectedPosition[];
-export {};

package/overlay/position/global-position-strategy.d.ts

@@ -1,99 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { PositionStrategy } from './position-strategy';
-import { OverlayReference } from '../overlay-reference';
-/**
- * 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.
- */
-export declare class GlobalPositionStrategy implements PositionStrategy {
-    /** The overlay to which this strategy is attached. */
-    private _overlayRef;
-    private _cssPosition;
-    private _topOffset;
-    private _bottomOffset;
-    private _alignItems;
-    private _xPosition;
-    private _xOffset;
-    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 to the start of the viewport, depending on the overlay direction.
-     * This will be to the left in LTR layouts and to the right in RTL.
-     * @param offset Offset from the edge of the screen.
-     */
-    start(value?: string): this;
-    /**
-     * Sets the overlay to the end of the viewport, depending on the overlay direction.
-     * This will be to the right in LTR layouts and to the left in RTL.
-     * @param offset Offset from the edge of the screen.
-     */
-    end(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;
-}

package/overlay/position/overlay-position-builder.d.ts

@@ -1,32 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { Platform } from '@angular/cdk/platform';
-import { ViewportRuler } from '@angular/cdk/scrolling';
-import { OverlayContainer } from '../overlay-container';
-import { FlexibleConnectedPositionStrategy, FlexibleConnectedPositionStrategyOrigin } from './flexible-connected-position-strategy';
-import { GlobalPositionStrategy } from './global-position-strategy';
-import * as i0 from "@angular/core";
-/** Builder for overlay position strategy. */
-export 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>;
-}

package/overlay/position/position-strategy.d.ts

@@ -1,19 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { OverlayReference } from '../overlay-reference';
-/** Strategy for setting the position on an overlay. */
-export 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;
-}