@angular/cdk 7.0.4 → 7.2.1

package/drag-drop/typings/directives/drop-list.d.ts

@@ -0,0 +1,135 @@
+/**
+ * @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 { ElementRef, EventEmitter, OnDestroy, QueryList, ChangeDetectorRef } from '@angular/core';
+import { Directionality } from '@angular/cdk/bidi';
+import { CdkDrag } from './drag';
+import { DragDropRegistry } from '../drag-drop-registry';
+import { CdkDragDrop, CdkDragEnter, CdkDragExit, CdkDragSortEvent } from '../drag-events';
+import { CdkDropListContainer } from '../drop-list-container';
+import { CdkDropListGroup } from './drop-list-group';
+import { DropListRef } from '../drop-list-ref';
+import { DragRef } from '../drag-ref';
+/**
+ * Internal compile-time-only representation of a `CdkDropList`.
+ * Used to avoid circular import issues between the `CdkDropList` and the `CdkDrag`.
+ * @docs-private
+ */
+export interface CdkDropListInternal extends CdkDropList {
+}
+/** Container that wraps a set of draggable items. */
+export declare class CdkDropList<T = any> implements CdkDropListContainer, OnDestroy {
+    element: ElementRef<HTMLElement>;
+    private _changeDetectorRef;
+    private _group?;
+    /** Keeps track of the drop lists that are currently on the page. */
+    private static _dropLists;
+    /** Reference to the underlying drop list instance. */
+    _dropListRef: DropListRef<CdkDropList<T>>;
+    /** Draggable items in the container. */
+    _draggables: QueryList<CdkDrag>;
+    /**
+     * Other draggable containers that this container is connected to and into which the
+     * container's items can be transferred. Can either be references to other drop containers,
+     * or their unique IDs.
+     */
+    connectedTo: (CdkDropList | string)[] | CdkDropList | string;
+    /** Arbitrary data to attach to this container. */
+    data: T;
+    /** Direction in which the list is oriented. */
+    orientation: 'horizontal' | 'vertical';
+    /**
+     * Unique ID for the drop zone. Can be used as a reference
+     * in the `connectedTo` of another `CdkDropList`.
+     */
+    id: string;
+    /** Locks the position of the draggable elements inside the container along the specified axis. */
+    lockAxis: 'x' | 'y';
+    /** Whether starting a dragging sequence from this container is disabled. */
+    disabled: boolean;
+    private _disabled;
+    /**
+     * Function that is used to determine whether an item
+     * is allowed to be moved into a drop container.
+     */
+    enterPredicate: (drag: CdkDrag, drop: CdkDropList) => boolean;
+    /** Emits when the user drops an item inside the container. */
+    dropped: EventEmitter<CdkDragDrop<T, any>>;
+    /**
+     * Emits when the user has moved a new drag item into this container.
+     */
+    entered: EventEmitter<CdkDragEnter<T>>;
+    /**
+     * Emits when the user removes an item from the container
+     * by dragging it into another container.
+     */
+    exited: EventEmitter<CdkDragExit<T>>;
+    /** Emits as the user is swapping items while actively dragging. */
+    sorted: EventEmitter<CdkDragSortEvent<T>>;
+    constructor(element: ElementRef<HTMLElement>, dragDropRegistry: DragDropRegistry<DragRef, DropListRef>, _changeDetectorRef: ChangeDetectorRef, dir?: Directionality, _group?: CdkDropListGroup<CdkDropList<any>> | undefined, _document?: any);
+    ngOnDestroy(): void;
+    /** Starts dragging an item. */
+    start(): void;
+    /**
+     * Drops an item into this container.
+     * @param item Item being dropped into the container.
+     * @param currentIndex Index at which the item should be inserted.
+     * @param previousContainer Container from which the item got dragged in.
+     * @param isPointerOverContainer Whether the user's pointer was over the
+     *    container when the item was dropped.
+     */
+    drop(item: CdkDrag, currentIndex: number, previousContainer: Partial<CdkDropListContainer>, isPointerOverContainer: boolean): void;
+    /**
+     * Emits an event to indicate that the user moved an item into the container.
+     * @param item Item that was moved into the container.
+     * @param pointerX Position of the item along the X axis.
+     * @param pointerY Position of the item along the Y axis.
+     */
+    enter(item: CdkDrag, pointerX: number, pointerY: number): void;
+    /**
+     * Removes an item from the container after it was dragged into another container by the user.
+     * @param item Item that was dragged out.
+     */
+    exit(item: CdkDrag): void;
+    /**
+     * Figures out the index of an item in the container.
+     * @param item Item whose index should be determined.
+     */
+    getItemIndex(item: CdkDrag): number;
+    /**
+     * Sorts an item inside the container based on its position.
+     * @param item Item to be sorted.
+     * @param pointerX Position of the item along the X axis.
+     * @param pointerY Position of the item along the Y axis.
+     * @param pointerDelta Direction in which the pointer is moving along each axis.
+     */
+    _sortItem(item: CdkDrag, pointerX: number, pointerY: number, pointerDelta: {
+        x: number;
+        y: number;
+    }): void;
+    /**
+     * Figures out whether an item should be moved into a sibling
+     * drop container, based on its current position.
+     * @param item Drag item that is being moved.
+     * @param x Position of the item along the X axis.
+     * @param y Position of the item along the Y axis.
+     */
+    _getSiblingContainerFromPosition(item: CdkDrag, x: number, y: number): CdkDropListContainer | null;
+    /**
+     * Checks whether the user's pointer is positioned over the container.
+     * @param x Pointer position along the X axis.
+     * @param y Pointer position along the Y axis.
+     */
+    _isOverContainer(x: number, y: number): boolean;
+    /** Syncs the inputs of the CdkDropList with the options of the underlying DropListRef. */
+    private _syncInputs;
+    /**
+     * Proxies the events from a DropListRef to events that
+     * match the interfaces of the CdkDropList outputs.
+     */
+    private _proxyEvents;
+}

package/drag-drop/typings/drag-drop-registry.d.ts

@@ -54,13 +54,18 @@ export declare class DragDropRegistry<I, C extends {
     stopDragging(drag: I): void;
     /** Gets whether a drag item instance is currently being dragged. */
     isDragging(drag: I): boolean;
-    /** Gets a drop container by its id. */
+    /**
+     * Gets a drop container by its id.
+     * @deprecated No longer being used. To be removed.
+     * @breaking-change 8.0.0
+     */
     getDropContainer(id: string): C | undefined;
     ngOnDestroy(): void;
     /**
-     * Listener used to prevent `touchmove` and `wheel` events while the element is being dragged.
+     * Event listener that will prevent the default browser action while the user is dragging.
+     * @param event Event whose default action should be prevented.
      */
-    private _preventScrollListener;
+    private _preventDefaultWhileDragging;
     /** Clears out the global event listeners from the `document`. */
     private _clearGlobalListeners;
 }

package/drag-drop/typings/drag-events.d.ts

@@ -5,13 +5,18 @@
  * 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 { CdkDrag } from './drag';
-import { CdkDropListContainer } from './drop-list-container';
+import { CdkDrag } from './directives/drag';
+import { CdkDropList } from './directives/drop-list';
 /** Event emitted when the user starts dragging a draggable. */
 export interface CdkDragStart<T = any> {
     /** Draggable that emitted the event. */
     source: CdkDrag<T>;
 }
+/** Event emitted when the user releases an item, before any animations have started. */
+export interface CdkDragRelease<T = any> {
+    /** Draggable that emitted the event. */
+    source: CdkDrag<T>;
+}
 /** Event emitted when the user stops dragging a draggable. */
 export interface CdkDragEnd<T = any> {
     /** Draggable that emitted the event. */
@@ -20,7 +25,7 @@ export interface CdkDragEnd<T = any> {
 /** Event emitted when the user moves an item into a new drop container. */
 export interface CdkDragEnter<T = any, I = T> {
     /** Container into which the user has moved the item. */
-    container: CdkDropListContainer<T>;
+    container: CdkDropList<T>;
     /** Item that was removed from the container. */
     item: CdkDrag<I>;
 }
@@ -30,7 +35,7 @@ export interface CdkDragEnter<T = any, I = T> {
  */
 export interface CdkDragExit<T = any, I = T> {
     /** Container from which the user has a removed an item. */
-    container: CdkDropListContainer<T>;
+    container: CdkDropList<T>;
     /** Item that was removed from the container. */
     item: CdkDrag<I>;
 }
@@ -43,9 +48,11 @@ export interface CdkDragDrop<T, O = T> {
     /** Item that is being dropped. */
     item: CdkDrag;
     /** Container in which the item was dropped. */
-    container: CdkDropListContainer<T>;
+    container: CdkDropList<T>;
     /** Container from which the item was picked up. Can be the same as the `container`. */
-    previousContainer: CdkDropListContainer<O>;
+    previousContainer: CdkDropList<O>;
+    /** Whether the user's pointer was over the container when the item was dropped. */
+    isPointerOverContainer: boolean;
 }
 /** Event emitted as the user is dragging a draggable item. */
 export interface CdkDragMove<T = any> {
@@ -76,7 +83,7 @@ export interface CdkDragSortEvent<T = any, I = T> {
     /** Index that the item is currently in. */
     currentIndex: number;
     /** Container that the item belongs to. */
-    container: CdkDropListContainer<T>;
+    container: CdkDropList<T>;
     /** Item that is being sorted. */
     item: CdkDrag<I>;
 }

package/{typings/esm5/drag-drop/drag.d.ts → drag-drop/typings/drag-ref.d.ts}

@@ -5,18 +5,14 @@
  * 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 { ElementRef, NgZone, ViewContainerRef, TemplateRef } from '@angular/core';
 import { ViewportRuler } from '@angular/cdk/scrolling';
-import { AfterViewInit, ElementRef, EventEmitter, InjectionToken, NgZone, OnDestroy, QueryList, ViewContainerRef } from '@angular/core';
-import { Observable } from 'rxjs';
+import { Directionality } from '@angular/cdk/bidi';
+import { Subject, Observable } from 'rxjs';
+import { DropListRefInternal as DropListRef } from './drop-list-ref';
 import { DragDropRegistry } from './drag-drop-registry';
-import { CdkDragDrop, CdkDragEnd, CdkDragEnter, CdkDragExit, CdkDragMove, CdkDragStart } from './drag-events';
-import { CdkDragHandle } from './drag-handle';
-import { CdkDragPlaceholder } from './drag-placeholder';
-import { CdkDragPreview } from './drag-preview';
-import { CdkDropListContainer } from './drop-list-container';
-/** Object that can be used to configure the behavior of CdkDrag. */
-export interface CdkDragConfig {
+/** Object that can be used to configure the behavior of DragRef. */
+export interface DragRefConfig {
     /**
      * Minimum amount of pixels that the user should
      * drag, before the CDK initiates a drag sequence.
@@ -28,23 +24,38 @@ export interface CdkDragConfig {
      */
     pointerDirectionChangeThreshold: number;
 }
-/** Injection token that can be used to configure the behavior of `CdkDrag`. */
-export declare const CDK_DRAG_CONFIG: InjectionToken<CdkDragConfig>;
-/** @docs-private */
-export declare function CDK_DRAG_CONFIG_FACTORY(): CdkDragConfig;
-/** Element that can be moved inside a CdkDropList container. */
-export declare class CdkDrag<T = any> implements AfterViewInit, OnDestroy {
-    /** Element that the draggable is attached to. */
+/**
+ * Template that can be used to create a drag helper element (e.g. a preview or a placeholder).
+ */
+interface DragHelperTemplate<T = any> {
+    templateRef: TemplateRef<T>;
+    data: T;
+}
+interface DragHandle {
     element: ElementRef<HTMLElement>;
-    /** Droppable container that the draggable is a part of. */
-    dropContainer: CdkDropListContainer;
+    disabled: boolean;
+}
+/**
+ * Internal compile-time-only representation of a `DragRef`.
+ * Used to avoid circular import issues between the `DragRef` and the `DropListRef`.
+ * @docs-private
+ */
+export interface DragRefInternal extends DragRef {
+}
+/**
+ * Reference to a draggable item. Used to manipulate or dispose of the item.
+ * @docs-private
+ */
+export declare class DragRef<T = any> {
+    private _document;
     private _ngZone;
     private _viewContainerRef;
     private _viewportRuler;
     private _dragDropRegistry;
     private _config;
-    private _dir;
-    private _document;
+    /** Droppable container that the draggable is a part of. */
+    dropContainer?: DropListRef | undefined;
+    private _dir?;
     /** Element displayed next to the user's pointer while the element is dragged. */
     private _preview;
     /** Reference to the view of the preview element. */
@@ -77,10 +88,10 @@ export declare class CdkDrag<T = any> implements AfterViewInit, OnDestroy {
      * Whether the dragging sequence has been started. Doesn't
      * necessarily mean that the element has been moved.
      */
-    _hasStartedDragging: boolean;
+    private _hasStartedDragging;
     /** Whether the element has moved since the user started dragging it. */
     private _hasMoved;
-    /** Drop container in which the CdkDrag resided when dragging began. */
+    /** Drop container in which the DragRef resided when dragging began. */
     private _initialContainer;
     /** Cached scroll position on the page when the element was picked up. */
     private _scrollPosition;
@@ -95,50 +106,99 @@ export declare class CdkDrag<T = any> implements AfterViewInit, OnDestroy {
     private _pointerDirectionDelta;
     /** Pointer position at which the last change in the delta occurred. */
     private _pointerPositionAtLastDirectionChange;
-    /** Root element that will be dragged by the user. */
+    /**
+     * Root DOM node of the drag instance. This is the element that will
+     * be moved around as the user is dragging.
+     */
     private _rootElement;
+    /**
+     * Inline style value of `-webkit-tap-highlight-color` at the time the
+     * dragging was started. Used to restore the value once we're done dragging.
+     */
+    private _rootElementTapHighlight;
     /** Subscription to pointer movement events. */
     private _pointerMoveSubscription;
     /** Subscription to the event that is dispatched when the user lifts their pointer. */
     private _pointerUpSubscription;
-    /** Subscription to the stream that initializes the root element. */
-    private _rootElementInitSubscription;
-    /** Elements that can be used to drag the draggable item. */
-    _handles: QueryList<CdkDragHandle>;
+    /**
+     * Time at which the last touch event occurred. Used to avoid firing the same
+     * events multiple times on touch devices where the browser will fire a fake
+     * mouse event for each touch event, after a certain time.
+     */
+    private _lastTouchEventTime;
+    /** Cached reference to the boundary element. */
+    private _boundaryElement;
+    /** Whether the native dragging interactions have been enabled on the root element. */
+    private _nativeInteractionsEnabled;
+    /** Cached dimensions of the preview element. */
+    private _previewRect?;
+    /** Cached dimensions of the boundary element. */
+    private _boundaryRect?;
     /** Element that will be used as a template to create the draggable item's preview. */
-    _previewTemplate: CdkDragPreview;
+    private _previewTemplate;
     /** Template for placeholder element rendered to show where a draggable would be dropped. */
-    _placeholderTemplate: CdkDragPlaceholder;
-    /** Arbitrary data to attach to this drag instance. */
-    data: T;
-    /** Locks the position of the dragged element along the specified axis. */
+    private _placeholderTemplate;
+    /** Elements that can be used to drag the draggable item. */
+    private _handles;
+    /** Axis along which dragging is locked. */
     lockAxis: 'x' | 'y';
-    /**
-     * Selector that will be used to determine the root draggable element, starting from
-     * the `cdkDrag` element and going up the DOM. Passing an alternate root element is useful
-     * when trying to enable dragging on an element that you might not have access to.
-     */
-    rootElementSelector: string;
+    /** Whether starting to drag this element is disabled. */
+    disabled: boolean;
+    private _disabled;
+    /** Emits as the drag sequence is being prepared. */
+    beforeStarted: Subject<void>;
     /** Emits when the user starts dragging the item. */
-    started: EventEmitter<CdkDragStart>;
+    started: Subject<{
+        source: DragRef<any>;
+    }>;
+    /** Emits when the user has released a drag item, before any animations have started. */
+    released: Subject<{
+        source: DragRef<any>;
+    }>;
     /** Emits when the user stops dragging an item in the container. */
-    ended: EventEmitter<CdkDragEnd>;
+    ended: Subject<{
+        source: DragRef<any>;
+    }>;
     /** Emits when the user has moved the item into a new container. */
-    entered: EventEmitter<CdkDragEnter<any>>;
+    entered: Subject<{
+        container: DropListRef;
+        item: DragRef<any>;
+    }>;
     /** Emits when the user removes the item its container by dragging it into another container. */
-    exited: EventEmitter<CdkDragExit<any>>;
+    exited: Subject<{
+        container: DropListRef;
+        item: DragRef<any>;
+    }>;
     /** Emits when the user drops the item inside a container. */
-    dropped: EventEmitter<CdkDragDrop<any>>;
+    dropped: Subject<{
+        previousIndex: number;
+        currentIndex: number;
+        item: DragRef<any>;
+        container: DropListRef;
+        previousContainer: DropListRef;
+        isPointerOverContainer: boolean;
+    }>;
     /**
      * Emits as the user is dragging the item. Use with caution,
      * because this event will fire for every pixel that the user has dragged.
      */
-    moved: Observable<CdkDragMove<T>>;
-    constructor(
-    /** Element that the draggable is attached to. */
-    element: ElementRef<HTMLElement>, 
+    moved: Observable<{
+        source: DragRef;
+        pointerPosition: {
+            x: number;
+            y: number;
+        };
+        event: MouseEvent | TouchEvent;
+        delta: {
+            x: -1 | 0 | 1;
+            y: -1 | 0 | 1;
+        };
+    }>;
+    /** Arbitrary data that can be attached to the drag item. */
+    data: T;
+    constructor(element: ElementRef<HTMLElement> | HTMLElement, _document: Document, _ngZone: NgZone, _viewContainerRef: ViewContainerRef, _viewportRuler: ViewportRuler, _dragDropRegistry: DragDropRegistry<DragRef, DropListRef>, _config: DragRefConfig, 
     /** Droppable container that the draggable is a part of. */
-    dropContainer: CdkDropListContainer, document: any, _ngZone: NgZone, _viewContainerRef: ViewContainerRef, _viewportRuler: ViewportRuler, _dragDropRegistry: DragDropRegistry<CdkDrag<T>, CdkDropListContainer>, _config: CdkDragConfig, _dir: Directionality);
+    dropContainer?: DropListRef | undefined, _dir?: Directionality | undefined);
     /**
      * Returns the element that is being used as a placeholder
      * while the current element is being dragged.
@@ -146,16 +206,42 @@ export declare class CdkDrag<T = any> implements AfterViewInit, OnDestroy {
     getPlaceholderElement(): HTMLElement;
     /** Returns the root draggable element. */
     getRootElement(): HTMLElement;
+    /** Registers the handles that can be used to drag the element. */
+    withHandles(handles: DragHandle[]): this;
+    /** Registers the template that should be used for the drag preview. */
+    withPreviewTemplate(template: DragHelperTemplate | null): this;
+    /** Registers the template that should be used for the drag placeholder. */
+    withPlaceholderTemplate(template: DragHelperTemplate | null): this;
+    /**
+     * Sets an alternate drag root element. The root element is the element that will be moved as
+     * the user is dragging. Passing an alternate root element is useful when trying to enable
+     * dragging on an element that you might not have access to.
+     */
+    withRootElement(rootElement: ElementRef<HTMLElement> | HTMLElement): this;
+    /**
+     * Element to which the draggable's position will be constrained.
+     */
+    withBoundaryElement(boundaryElement: ElementRef<HTMLElement> | HTMLElement | null): this;
+    /** Removes the dragging functionality from the DOM element. */
+    dispose(): void;
+    /** Checks whether the element is currently being dragged. */
+    isDragging(): boolean;
     /** Resets a standalone drag item to its initial position. */
     reset(): void;
-    ngAfterViewInit(): void;
-    ngOnDestroy(): void;
-    /** Checks whether the element is currently being dragged. */
-    _isDragging(): boolean;
-    /** Gets only handles that are not inside descendant `CdkDrag` instances. */
-    private getChildHandles;
+    /** Unsubscribes from the global subscriptions. */
+    private _removeSubscriptions;
+    /** Destroys the preview element and its ViewRef. */
+    private _destroyPreview;
+    /** Destroys the placeholder element and its ViewRef. */
+    private _destroyPlaceholder;
     /** Handler for the `mousedown`/`touchstart` events. */
-    _pointerDown: (event: TouchEvent | MouseEvent) => void;
+    private _pointerDown;
+    /** Handler that is invoked when the user moves their pointer after they've initiated a drag. */
+    private _pointerMove;
+    /** Handler that is invoked when the user lifts their pointer up, after initiating a drag. */
+    private _pointerUp;
+    /** Starts the dragging sequence. */
+    private _startDragSequence;
     /**
      * Sets up the different variables and subscriptions
      * that will be necessary for the dragging sequence.
@@ -163,12 +249,6 @@ export declare class CdkDrag<T = any> implements AfterViewInit, OnDestroy {
      * @param event Browser event object that started the sequence.
      */
     private _initializeDragSequence;
-    /** Starts the dragging sequence. */
-    private _startDragSequence;
-    /** Handler that is invoked when the user moves their pointer after they've initiated a drag. */
-    private _pointerMove;
-    /** Handler that is invoked when the user lifts their pointer up, after initiating a drag. */
-    private _pointerUp;
     /** Cleans up the DOM artifacts that were added to facilitate the element being dragged. */
     private _cleanupDragArtifacts;
     /**
@@ -181,6 +261,11 @@ export declare class CdkDrag<T = any> implements AfterViewInit, OnDestroy {
      * and will be used as a preview of the element that is being dragged.
      */
     private _createPreviewElement;
+    /**
+     * Animates the preview element from its current position to the location of the drop placeholder.
+     * @returns Promise that resolves when the animation completes.
+     */
+    private _animatePreviewToPlaceholder;
     /** Creates an element that will be shown instead of the current element while dragging. */
     private _createPlaceholderElement;
     /**
@@ -189,30 +274,15 @@ export declare class CdkDrag<T = any> implements AfterViewInit, OnDestroy {
      * @param event Event that initiated the dragging.
      */
     private _getPointerPositionInElement;
-    /**
-     * Animates the preview element from its current position to the location of the drop placeholder.
-     * @returns Promise that resolves when the animation completes.
-     */
-    private _animatePreviewToPlaceholder;
-    /**
-     * Helper to remove an element from the DOM and to do all the necessary null checks.
-     * @param element Element to be removed.
-     */
-    private _removeElement;
     /** Determines the point of the page that was touched by the user. */
     private _getPointerPositionOnPage;
     /** Gets the pointer position on the page, accounting for any position constraints. */
     private _getConstrainedPointerPosition;
-    /** Determines whether an event is a touch event. */
-    private _isTouchEvent;
-    /** Destroys the preview element and its ViewRef. */
-    private _destroyPreview;
-    /** Destroys the placeholder element and its ViewRef. */
-    private _destroyPlaceholder;
     /** Updates the current drag delta, based on the user's current pointer position on the page. */
     private _updatePointerDirectionDelta;
-    /** Gets the root draggable element, based on the `rootElementSelector`. */
-    private _getRootElement;
-    /** Unsubscribes from the global subscriptions. */
-    private _removeSubscriptions;
+    /** Toggles the native drag interactions, based on how many handles are registered. */
+    private _toggleNativeDragInteractions;
+    /** Removes the manually-added event listeners from the root element. */
+    private _removeRootElementListeners;
 }
+export {};

package/drag-drop/typings/drop-list-container.d.ts

@@ -6,7 +6,14 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { InjectionToken, QueryList, ElementRef } from '@angular/core';
-import { CdkDrag } from './drag';
+import { CdkDrag } from './directives/drag';
+/**
+ * @deprecated To be removed. No longer being used. Previously the interface was used to avoid
+ * circular imports between `CdkDrag` and `CdkDropList`, however now we're using the
+ * `CdkDropListInternal` interface to achieve the same result, without having to maintain
+ * this large of an interface.
+ * @breaking-change 8.0.0
+ */
 export interface CdkDropListContainer<T = any> {
     /** DOM node that corresponds to the drop container. */
     element: ElementRef<HTMLElement>;
@@ -18,6 +25,8 @@ export interface CdkDropListContainer<T = any> {
     orientation: 'horizontal' | 'vertical';
     /** Locks the position of the draggable elements inside the container along the specified axis. */
     lockAxis: 'x' | 'y';
+    /** Whether starting a dragging sequence from this container is disabled. */
+    disabled: boolean;
     /** Starts dragging an item. */
     start(): void;
     /**
@@ -25,8 +34,10 @@ export interface CdkDropListContainer<T = any> {
      * @param item Item being dropped into the container.
      * @param currentIndex Index at which the item should be inserted.
      * @param previousContainer Container from which the item got dragged in.
+     * @param isPointerOverContainer Whether the user's pointer was over the
+     *    container when the item was dropped.
      */
-    drop(item: CdkDrag, currentIndex: number, previousContainer?: CdkDropListContainer): void;
+    drop(item: CdkDrag, currentIndex: number, previousContainer: Partial<CdkDropListContainer>, isPointerOverContainer: boolean): void;
     /**
      * Emits an event to indicate that the user moved an item into the container.
      * @param item Item that was moved into the container.
@@ -50,10 +61,17 @@ export interface CdkDropListContainer<T = any> {
     }): void;
     _draggables: QueryList<CdkDrag>;
     _getSiblingContainerFromPosition(item: CdkDrag, x: number, y: number): CdkDropListContainer | null;
-    _canReturnItem(x: number, y: number): boolean;
+    _isOverContainer(x: number, y: number): boolean;
 }
 /**
  * Injection token that is used to provide a CdkDropList instance to CdkDrag.
  * Used for avoiding circular imports.
  */
+export declare const CDK_DROP_LIST: InjectionToken<CdkDropListContainer<any>>;
+/**
+ * Injection token that is used to provide a CdkDropList instance to CdkDrag.
+ * Used for avoiding circular imports.
+ * @deprecated Use `CDK_DROP_LIST` instead.
+ * @breaking-change 8.0.0
+ */
 export declare const CDK_DROP_LIST_CONTAINER: InjectionToken<CdkDropListContainer<any>>;