/**
 * @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 { Direction, Directionality } from 'cdk/bidi';
import { BooleanInput } from 'cdk/coercion';
import {
	ElementRef,
	EventEmitter,
	InjectionToken,
	OnChanges,
	OnDestroy,
	SimpleChanges,
	TemplateRef,
	ViewContainerRef,
} from '@angular/core';
import { Overlay } from './overlay';
import { OverlayRef } from './overlay-ref';
import { ConnectedOverlayPositionChange } from './position/connected-position';
import {
	ConnectedPosition,
	FlexibleConnectedPositionStrategy,
} from './position/flexible-connected-position-strategy';
import { RepositionScrollStrategy, ScrollStrategy } from './scroll/index';
/** Injection token that determines the scroll handling while the connected overlay is open. */
import * as ɵngcc0 from '@angular/core';
export declare const CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY: InjectionToken<
	() => ScrollStrategy
>;
/**
 * Directive applied to an element to make it usable as an origin for an Overlay using a
 * ConnectedPositionStrategy.
 */
export 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: ɵngcc0.ɵɵFactoryDef<CdkOverlayOrigin, never>;
	static ɵdir: ɵngcc0.ɵɵDirectiveDefWithMeta<
		CdkOverlayOrigin,
		'[cdk-overlay-origin], [overlay-origin], [cdkOverlayOrigin]',
		['cdkOverlayOrigin'],
		{},
		{},
		never
	>;
}
/**
 * Directive to facilitate declarative creation of an
 * Overlay using a FlexibleConnectedPositionStrategy.
 */
export 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;
	/** 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(): any;
	set hasBackdrop(value: any);
	/** Whether or not the overlay should be locked when scrolling. */
	get lockPosition(): any;
	set lockPosition(value: any);
	/** Whether the overlay's width and height can be constrained to fit within the viewport. */
	get flexibleDimensions(): boolean;
	set flexibleDimensions(value: boolean);
	/** Whether the overlay can grow after the initial open when flexible positioning is turned on. */
	get growAfterOpen(): boolean;
	set growAfterOpen(value: boolean);
	/** Whether the overlay can be pushed on-screen if none of the provided positions fit. */
	get push(): boolean;
	set push(value: boolean);
	/** 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;
	/** 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 ngAcceptInputType_hasBackdrop: BooleanInput;
	static ngAcceptInputType_lockPosition: BooleanInput;
	static ngAcceptInputType_flexibleDimensions: BooleanInput;
	static ngAcceptInputType_growAfterOpen: BooleanInput;
	static ngAcceptInputType_push: BooleanInput;
	static ɵfac: ɵngcc0.ɵɵFactoryDef<
		CdkConnectedOverlay,
		[null, null, null, null, { optional: true }]
	>;
	static ɵdir: ɵngcc0.ɵɵDirectiveDefWithMeta<
		CdkConnectedOverlay,
		'[cdk-connected-overlay], [connected-overlay], [cdkConnectedOverlay]',
		['cdkConnectedOverlay'],
		{
			viewportMargin: 'cdkConnectedOverlayViewportMargin';
			open: 'cdkConnectedOverlayOpen';
			disableClose: 'cdkConnectedOverlayDisableClose';
			scrollStrategy: 'cdkConnectedOverlayScrollStrategy';
			offsetX: 'cdkConnectedOverlayOffsetX';
			offsetY: 'cdkConnectedOverlayOffsetY';
			hasBackdrop: 'cdkConnectedOverlayHasBackdrop';
			lockPosition: 'cdkConnectedOverlayLockPosition';
			flexibleDimensions: 'cdkConnectedOverlayFlexibleDimensions';
			growAfterOpen: 'cdkConnectedOverlayGrowAfterOpen';
			push: 'cdkConnectedOverlayPush';
			positions: 'cdkConnectedOverlayPositions';
			origin: 'cdkConnectedOverlayOrigin';
			positionStrategy: 'cdkConnectedOverlayPositionStrategy';
			width: 'cdkConnectedOverlayWidth';
			height: 'cdkConnectedOverlayHeight';
			minWidth: 'cdkConnectedOverlayMinWidth';
			minHeight: 'cdkConnectedOverlayMinHeight';
			backdropClass: 'cdkConnectedOverlayBackdropClass';
			panelClass: 'cdkConnectedOverlayPanelClass';
			transformOriginSelector: 'cdkConnectedOverlayTransformOriginOn';
		},
		{
			backdropClick: 'backdropClick';
			positionChange: 'positionChange';
			attach: 'attach';
			detach: 'detach';
			overlayKeydown: 'overlayKeydown';
			overlayOutsideClick: 'overlayOutsideClick';
		},
		never
	>;
}
/** @docs-private */
export declare function CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY(
	overlay: Overlay
): () => RepositionScrollStrategy;
/** @docs-private */
export declare const CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER: {
	provide: InjectionToken<() => ScrollStrategy>;
	deps: typeof Overlay[];
	useFactory: typeof CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY;
};

//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"overlay-directives.d.ts","sources":["overlay-directives.d.ts"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport { Direction, Directionality } from '@angular/cdk/bidi';\nimport { BooleanInput } from '@angular/cdk/coercion';\nimport { ElementRef, EventEmitter, InjectionToken, OnChanges, OnDestroy, SimpleChanges, TemplateRef, ViewContainerRef } from '@angular/core';\nimport { Overlay } from './overlay';\nimport { OverlayRef } from './overlay-ref';\nimport { ConnectedOverlayPositionChange } from './position/connected-position';\nimport { ConnectedPosition, FlexibleConnectedPositionStrategy } from './position/flexible-connected-position-strategy';\nimport { RepositionScrollStrategy, ScrollStrategy } from './scroll/index';\n/** Injection token that determines the scroll handling while the connected overlay is open. */\nexport declare const CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;\n/**\n * Directive applied to an element to make it usable as an origin for an Overlay using a\n * ConnectedPositionStrategy.\n */\nexport declare class CdkOverlayOrigin {\n    /** Reference to the element on which the directive is applied. */\n    elementRef: ElementRef;\n    constructor(\n    /** Reference to the element on which the directive is applied. */\n    elementRef: ElementRef);\n}\n/**\n * Directive to facilitate declarative creation of an\n * Overlay using a FlexibleConnectedPositionStrategy.\n */\nexport declare class CdkConnectedOverlay implements OnDestroy, OnChanges {\n    private _overlay;\n    private _dir;\n    private _overlayRef;\n    private _templatePortal;\n    private _hasBackdrop;\n    private _lockPosition;\n    private _growAfterOpen;\n    private _flexibleDimensions;\n    private _push;\n    private _backdropSubscription;\n    private _attachSubscription;\n    private _detachSubscription;\n    private _positionSubscription;\n    private _offsetX;\n    private _offsetY;\n    private _position;\n    private _scrollStrategyFactory;\n    /** Origin for the connected overlay. */\n    origin: CdkOverlayOrigin;\n    /** Registered connected position pairs. */\n    positions: ConnectedPosition[];\n    /**\n     * This input overrides the positions input if specified. It lets users pass\n     * in arbitrary positioning strategies.\n     */\n    positionStrategy: FlexibleConnectedPositionStrategy;\n    /** The offset in pixels for the overlay connection point on the x-axis */\n    get offsetX(): number;\n    set offsetX(offsetX: number);\n    /** The offset in pixels for the overlay connection point on the y-axis */\n    get offsetY(): number;\n    set offsetY(offsetY: number);\n    /** The width of the overlay panel. */\n    width: number | string;\n    /** The height of the overlay panel. */\n    height: number | string;\n    /** The min width of the overlay panel. */\n    minWidth: number | string;\n    /** The min height of the overlay panel. */\n    minHeight: number | string;\n    /** The custom class to be set on the backdrop element. */\n    backdropClass: string;\n    /** The custom class to add to the overlay pane element. */\n    panelClass: string | string[];\n    /** Margin between the overlay and the viewport edges. */\n    viewportMargin: number;\n    /** Strategy to be used when handling scroll events while the overlay is open. */\n    scrollStrategy: ScrollStrategy;\n    /** Whether the overlay is open. */\n    open: boolean;\n    /** Whether the overlay can be closed by user interaction. */\n    disableClose: boolean;\n    /** CSS selector which to set the transform origin. */\n    transformOriginSelector: string;\n    /** Whether or not the overlay should attach a backdrop. */\n    get hasBackdrop(): any;\n    set hasBackdrop(value: any);\n    /** Whether or not the overlay should be locked when scrolling. */\n    get lockPosition(): any;\n    set lockPosition(value: any);\n    /** Whether the overlay's width and height can be constrained to fit within the viewport. */\n    get flexibleDimensions(): boolean;\n    set flexibleDimensions(value: boolean);\n    /** Whether the overlay can grow after the initial open when flexible positioning is turned on. */\n    get growAfterOpen(): boolean;\n    set growAfterOpen(value: boolean);\n    /** Whether the overlay can be pushed on-screen if none of the provided positions fit. */\n    get push(): boolean;\n    set push(value: boolean);\n    /** Event emitted when the backdrop is clicked. */\n    readonly backdropClick: EventEmitter<MouseEvent>;\n    /** Event emitted when the position has changed. */\n    readonly positionChange: EventEmitter<ConnectedOverlayPositionChange>;\n    /** Event emitted when the overlay has been attached. */\n    readonly attach: EventEmitter<void>;\n    /** Event emitted when the overlay has been detached. */\n    readonly detach: EventEmitter<void>;\n    /** Emits when there are keyboard events that are targeted at the overlay. */\n    readonly overlayKeydown: EventEmitter<KeyboardEvent>;\n    /** Emits when there are mouse outside click events that are targeted at the overlay. */\n    readonly overlayOutsideClick: EventEmitter<MouseEvent>;\n    constructor(_overlay: Overlay, templateRef: TemplateRef<any>, viewContainerRef: ViewContainerRef, scrollStrategyFactory: any, _dir: Directionality);\n    /** The associated overlay reference. */\n    get overlayRef(): OverlayRef;\n    /** The element's layout direction. */\n    get dir(): Direction;\n    ngOnDestroy(): void;\n    ngOnChanges(changes: SimpleChanges): void;\n    /** Creates an overlay */\n    private _createOverlay;\n    /** Builds the overlay config based on the directive's inputs */\n    private _buildConfig;\n    /** Updates the state of a position strategy, based on the values of the directive inputs. */\n    private _updatePositionStrategy;\n    /** Returns the position strategy of the overlay to be set on the overlay config */\n    private _createPositionStrategy;\n    /** Attaches the overlay and subscribes to backdrop clicks if backdrop exists */\n    private _attachOverlay;\n    /** Detaches the overlay and unsubscribes to backdrop clicks if backdrop exists */\n    private _detachOverlay;\n    static ngAcceptInputType_hasBackdrop: BooleanInput;\n    static ngAcceptInputType_lockPosition: BooleanInput;\n    static ngAcceptInputType_flexibleDimensions: BooleanInput;\n    static ngAcceptInputType_growAfterOpen: BooleanInput;\n    static ngAcceptInputType_push: BooleanInput;\n}\n/** @docs-private */\nexport declare function CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay: Overlay): () => RepositionScrollStrategy;\n/** @docs-private */\nexport declare const CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER: {\n    provide: InjectionToken<() => ScrollStrategy>;\n    deps: (typeof Overlay)[];\n    useFactory: typeof CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY;\n};\n"]}