@angular/cdk 19.2.2 → 19.2.4

package/drag-drop/index.d.ts

@@ -1,419 +1,348 @@
-import { AfterViewInit } from '@angular/core';
-import { Direction } from '@angular/cdk/bidi';
-import { ElementRef } from '@angular/core';
-import { EventEmitter } from '@angular/core';
 import * as i0 from '@angular/core';
-import * as i7 from '@angular/cdk/scrolling';
-import { InjectionToken } from '@angular/core';
-import { NgZone } from '@angular/core';
-import { NumberInput } from '@angular/cdk/coercion';
-import { Observable } from 'rxjs';
-import { OnChanges } from '@angular/core';
-import { OnDestroy } from '@angular/core';
-import { Renderer2 } from '@angular/core';
-import { SimpleChanges } from '@angular/core';
-import { Subject } from 'rxjs';
-import { TemplateRef } from '@angular/core';
-import { ViewContainerRef } from '@angular/core';
-import { ViewportRuler } from '@angular/cdk/scrolling';
+import { InjectionToken, ElementRef, NgZone, OnDestroy, EventEmitter, AfterViewInit, TemplateRef, OnChanges, SimpleChanges, ViewContainerRef, Renderer2 } from '@angular/core';
+import { a as Direction } from '../bidi-module.d-f8648621.js';
+import { Subject, Observable } from 'rxjs';
+import { V as ViewportRuler } from '../viewport-ruler.d-f3d3e82f.js';
+import { N as NumberInput } from '../number-property.d-ce316715.js';
+import { b as CdkScrollableModule } from '../scrolling-module.d-e181b1be.js';
+import '../data-source.d-7cab2c9d.js';
 
+/** Possible values that can be used to configure the drag start delay. */
+type DragStartDelay = number | {
+    touch: number;
+    mouse: number;
+};
+/** Possible axis along which dragging can be locked. */
+type DragAxis = 'x' | 'y';
+/** Function that can be used to constrain the position of a dragged element. */
+type DragConstrainPosition = (point: Point, dragRef: DragRef) => Point;
+/** Possible orientations for a drop list. */
+type DropListOrientation = 'horizontal' | 'vertical' | 'mixed';
 /**
  * Injection token that can be used to configure the
  * behavior of the drag&drop-related components.
  */
-export declare const CDK_DRAG_CONFIG: InjectionToken<DragDropConfig>;
-
-/**
- * Injection token that can be used to reference instances of `CdkDragHandle`. It serves as
- * alternative token to the actual `CdkDragHandle` class which could cause unnecessary
- * retention of the class and its directive metadata.
- */
-export declare const CDK_DRAG_HANDLE: InjectionToken<CdkDragHandle>;
-
-/**
- * Injection token that can be used for a `CdkDrag` to provide itself as a parent to the
- * drag-specific child directive (`CdkDragHandle`, `CdkDragPreview` etc.). Used primarily
- * to avoid circular imports.
- * @docs-private
- */
-export declare const CDK_DRAG_PARENT: InjectionToken<CdkDrag<any>>;
-
-/**
- * Injection token that can be used to reference instances of `CdkDragPlaceholder`. It serves as
- * alternative token to the actual `CdkDragPlaceholder` class which could cause unnecessary
- * retention of the class and its directive metadata.
- */
-export declare const CDK_DRAG_PLACEHOLDER: InjectionToken<CdkDragPlaceholder<any>>;
-
-/**
- * Injection token that can be used to reference instances of `CdkDragPreview`. It serves as
- * alternative token to the actual `CdkDragPreview` class which could cause unnecessary
- * retention of the class and its directive metadata.
- */
-export declare const CDK_DRAG_PREVIEW: InjectionToken<CdkDragPreview<any>>;
-
+declare const CDK_DRAG_CONFIG: InjectionToken<DragDropConfig>;
 /**
- * Injection token that can be used to reference instances of `CdkDropList`. It serves as
- * alternative token to the actual `CdkDropList` class which could cause unnecessary
- * retention of the class and its directive metadata.
+ * Object that can be used to configure the drag
+ * items and drop lists within a module or a component.
  */
-export declare const CDK_DROP_LIST: InjectionToken<CdkDropList<any>>;
+interface DragDropConfig extends Partial<DragRefConfig> {
+    lockAxis?: DragAxis;
+    dragStartDelay?: DragStartDelay;
+    constrainPosition?: DragConstrainPosition;
+    previewClass?: string | string[];
+    boundaryElement?: string;
+    rootElementSelector?: string;
+    draggingDisabled?: boolean;
+    sortingDisabled?: boolean;
+    listAutoScrollDisabled?: boolean;
+    listOrientation?: DropListOrientation;
+    zIndex?: number;
+    previewContainer?: 'global' | 'parent';
+}
 
 /**
- * Injection token that can be used to reference instances of `CdkDropListGroup`. It serves as
- * alternative token to the actual `CdkDropListGroup` class which could cause unnecessary
- * retention of the class and its directive metadata.
+ * Reference to a drop list. Used to manipulate or dispose of the container.
  */
-export declare const CDK_DROP_LIST_GROUP: InjectionToken<CdkDropListGroup<unknown>>;
-
-/** Element that can be moved inside a CdkDropList container. */
-export declare class CdkDrag<T = any> implements AfterViewInit, OnChanges, OnDestroy {
-    element: ElementRef<HTMLElement>;
-    dropContainer: CdkDropList<any>;
-    private _ngZone;
-    private _viewContainerRef;
-    private _dir;
-    private _changeDetectorRef;
-    private _selfHandle;
-    private _parentDrag;
+declare class DropListRef<T = any> {
     private _dragDropRegistry;
-    private readonly _destroyed;
-    private _handles;
-    private _previewTemplate;
-    private _placeholderTemplate;
-    /** Reference to the underlying drag instance. */
-    _dragRef: DragRef<CdkDrag<T>>;
-    /** Arbitrary data to attach to this drag instance. */
-    data: T;
-    /** Locks the position of the dragged element along the specified axis. */
-    lockAxis: DragAxis;
+    private _ngZone;
+    private _viewportRuler;
+    /** Element that the drop list is attached to. */
+    element: HTMLElement | ElementRef<HTMLElement>;
+    /** Whether starting a dragging sequence from this container is disabled. */
+    disabled: boolean;
+    /** Whether sorting items within the list is disabled. */
+    sortingDisabled: boolean;
+    /** Locks the position of the draggable elements inside the container along the specified axis. */
+    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.
+     * Whether auto-scrolling the view when the user
+     * moves their pointer close to the edges is disabled.
      */
-    rootElementSelector: string;
+    autoScrollDisabled: boolean;
+    /** Number of pixels to scroll for each frame when auto-scrolling an element. */
+    autoScrollStep: number;
     /**
-     * Node or selector that will be used to determine the element to which the draggable's
-     * position will be constrained. If a string is passed in, it'll be used as a selector that
-     * will be matched starting from the element's parent and going up the DOM until a match
-     * has been found.
+     * Function that is used to determine whether an item
+     * is allowed to be moved into a drop container.
      */
-    boundaryElement: string | ElementRef<HTMLElement> | HTMLElement;
+    enterPredicate: (drag: DragRef, drop: DropListRef) => boolean;
+    /** Function that is used to determine whether an item can be sorted into a particular index. */
+    sortPredicate: (index: number, drag: DragRef, drop: DropListRef) => boolean;
+    /** Emits right before dragging has started. */
+    readonly beforeStarted: Subject<void>;
     /**
-     * Amount of milliseconds to wait after the user has put their
-     * pointer down before starting to drag the element.
+     * Emits when the user has moved a new drag item into this container.
      */
-    dragStartDelay: DragStartDelay;
+    readonly entered: Subject<{
+        item: DragRef;
+        container: DropListRef;
+        currentIndex: number;
+    }>;
     /**
-     * Sets the position of a `CdkDrag` that is outside of a drop container.
-     * Can be used to restore the element's position for a returning user.
+     * Emits when the user removes an item from the container
+     * by dragging it into another container.
      */
-    freeDragPosition: Point;
-    /** Whether starting to drag this element is disabled. */
-    get disabled(): boolean;
-    set disabled(value: boolean);
-    private _disabled;
+    readonly exited: Subject<{
+        item: DragRef;
+        container: DropListRef;
+    }>;
+    /** Emits when the user drops an item inside the container. */
+    readonly dropped: Subject<{
+        item: DragRef;
+        currentIndex: number;
+        previousIndex: number;
+        container: DropListRef;
+        previousContainer: DropListRef;
+        isPointerOverContainer: boolean;
+        distance: Point;
+        dropPoint: Point;
+        event: MouseEvent | TouchEvent;
+    }>;
+    /** Emits as the user is swapping items while actively dragging. */
+    readonly sorted: Subject<{
+        previousIndex: number;
+        currentIndex: number;
+        container: DropListRef;
+        item: DragRef;
+    }>;
+    /** Emits when a dragging sequence is started in a list connected to the current one. */
+    readonly receivingStarted: Subject<{
+        receiver: DropListRef;
+        initiator: DropListRef;
+        items: DragRef[];
+    }>;
+    /** Emits when a dragging sequence is stopped from a list connected to the current one. */
+    readonly receivingStopped: Subject<{
+        receiver: DropListRef;
+        initiator: DropListRef;
+    }>;
+    /** Arbitrary data that can be attached to the drop list. */
+    data: T;
+    /** Element that is the direct parent of the drag items. */
+    private _container;
+    /** Whether an item in the list is being dragged. */
+    private _isDragging;
+    /** Keeps track of the positions of any parent scrollable elements. */
+    private _parentPositions;
+    /** Strategy being used to sort items within the list. */
+    private _sortStrategy;
+    /** Cached `DOMRect` of the drop list. */
+    private _domRect;
+    /** Draggable items in the container. */
+    private _draggables;
+    /** Drop lists that are connected to the current one. */
+    private _siblings;
+    /** Connected siblings that currently have a dragged item. */
+    private _activeSiblings;
+    /** Subscription to the window being scrolled. */
+    private _viewportScrollSubscription;
+    /** Vertical direction in which the list is currently scrolling. */
+    private _verticalScrollDirection;
+    /** Horizontal direction in which the list is currently scrolling. */
+    private _horizontalScrollDirection;
+    /** Node that is being auto-scrolled. */
+    private _scrollNode;
+    /** Used to signal to the current auto-scroll sequence when to stop. */
+    private readonly _stopScrollTimers;
+    /** Shadow root of the current element. Necessary for `elementFromPoint` to resolve correctly. */
+    private _cachedShadowRoot;
+    /** Reference to the document. */
+    private _document;
+    /** Elements that can be scrolled while the user is dragging. */
+    private _scrollableElements;
+    /** Initial value for the element's `scroll-snap-type` style. */
+    private _initialScrollSnap;
+    /** Direction of the list's layout. */
+    private _direction;
+    constructor(element: ElementRef<HTMLElement> | HTMLElement, _dragDropRegistry: DragDropRegistry, _document: any, _ngZone: NgZone, _viewportRuler: ViewportRuler);
+    /** Removes the drop list functionality from the DOM element. */
+    dispose(): void;
+    /** Whether an item from this list is currently being dragged. */
+    isDragging(): boolean;
+    /** Starts dragging an item. */
+    start(): void;
     /**
-     * Function that can be used to customize the logic of how the position of the drag item
-     * is limited while it's being dragged. Gets called with a point containing the current position
-     * of the user's pointer on the page, a reference to the item being dragged and its dimensions.
-     * Should return a point describing where the item should be rendered.
+     * Attempts to move 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.
+     * @param index Index at which the item entered. If omitted, the container will try to figure it
+     *   out automatically.
      */
-    constrainPosition?: (userPointerPosition: Point, dragRef: DragRef, dimensions: DOMRect, pickupPositionInElement: Point) => Point;
-    /** Class to be added to the preview element. */
-    previewClass: string | string[];
+    enter(item: DragRef, pointerX: number, pointerY: number, index?: number): void;
     /**
-     * Configures the place into which the preview of the item will be inserted. Can be configured
-     * globally through `CDK_DROP_LIST`. Possible values:
-     * - `global` - Preview will be inserted at the bottom of the `<body>`. The advantage is that
-     * you don't have to worry about `overflow: hidden` or `z-index`, but the item won't retain
-     * its inherited styles.
-     * - `parent` - Preview will be inserted into the parent of the drag item. The advantage is that
-     * inherited styles will be preserved, but it may be clipped by `overflow: hidden` or not be
-     * visible due to `z-index`. Furthermore, the preview is going to have an effect over selectors
-     * like `:nth-child` and some flexbox configurations.
-     * - `ElementRef<HTMLElement> | HTMLElement` - Preview will be inserted into a specific element.
-     * Same advantages and disadvantages as `parent`.
+     * Removes an item from the container after it was dragged into another container by the user.
+     * @param item Item that was dragged out.
      */
-    previewContainer: PreviewContainer;
+    exit(item: DragRef): void;
     /**
-     * If the parent of the dragged element has a `scale` transform, it can throw off the
-     * positioning when the user starts dragging. Use this input to notify the CDK of the scale.
+     * 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 previousIndex Index of the item when dragging started.
+     * @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.
+     * @param distance Distance the user has dragged since the start of the dragging sequence.
+     * @param event Event that triggered the dropping sequence.
+     *
+     * @breaking-change 15.0.0 `previousIndex` and `event` parameters to become required.
      */
-    scale: number;
-    /** Emits when the user starts dragging the item. */
-    readonly started: EventEmitter<CdkDragStart>;
-    /** Emits when the user has released a drag item, before any animations have started. */
-    readonly released: EventEmitter<CdkDragRelease>;
-    /** Emits when the user stops dragging an item in the container. */
-    readonly ended: EventEmitter<CdkDragEnd>;
-    /** Emits when the user has moved the item into a new container. */
-    readonly entered: EventEmitter<CdkDragEnter<any>>;
-    /** Emits when the user removes the item its container by dragging it into another container. */
-    readonly exited: EventEmitter<CdkDragExit<any>>;
-    /** Emits when the user drops the item inside a container. */
-    readonly dropped: EventEmitter<CdkDragDrop<any>>;
+    drop(item: DragRef, currentIndex: number, previousIndex: number, previousContainer: DropListRef, isPointerOverContainer: boolean, distance: Point, dropPoint: Point, event?: MouseEvent | TouchEvent): void;
     /**
-     * Emits as the user is dragging the item. Use with caution,
-     * because this event will fire for every pixel that the user has dragged.
+     * Sets the draggable items that are a part of this list.
+     * @param items Items that are a part of this list.
      */
-    readonly moved: Observable<CdkDragMove<T>>;
-    private _injector;
-    constructor(...args: unknown[]);
+    withItems(items: DragRef[]): this;
+    /** Sets the layout direction of the drop list. */
+    withDirection(direction: Direction): this;
     /**
-     * Returns the element that is being used as a placeholder
-     * while the current element is being dragged.
+     * Sets the containers that are connected to this one. When two or more containers are
+     * connected, the user will be allowed to transfer items between them.
+     * @param connectedTo Other containers that the current containers should be connected to.
      */
-    getPlaceholderElement(): HTMLElement;
-    /** Returns the root draggable element. */
-    getRootElement(): HTMLElement;
-    /** Resets a standalone drag item to its initial position. */
-    reset(): void;
+    connectedTo(connectedTo: DropListRef[]): this;
     /**
-     * Gets the pixel coordinates of the draggable outside of a drop container.
+     * Sets the orientation of the container.
+     * @param orientation New orientation for the container.
      */
-    getFreeDragPosition(): Readonly<Point>;
+    withOrientation(orientation: DropListOrientation): this;
     /**
-     * Sets the current position in pixels the draggable outside of a drop container.
-     * @param value New position to be set.
+     * Sets which parent elements are can be scrolled while the user is dragging.
+     * @param elements Elements that can be scrolled.
      */
-    setFreeDragPosition(value: Point): void;
-    ngAfterViewInit(): void;
-    ngOnChanges(changes: SimpleChanges): void;
-    ngOnDestroy(): void;
-    _addHandle(handle: CdkDragHandle): void;
-    _removeHandle(handle: CdkDragHandle): void;
-    _setPreviewTemplate(preview: CdkDragPreview): void;
-    _resetPreviewTemplate(preview: CdkDragPreview): void;
-    _setPlaceholderTemplate(placeholder: CdkDragPlaceholder): void;
-    _resetPlaceholderTemplate(placeholder: CdkDragPlaceholder): void;
-    /** Syncs the root element with the `DragRef`. */
-    private _updateRootElement;
-    /** Gets the boundary element, based on the `boundaryElement` value. */
-    private _getBoundaryElement;
-    /** Syncs the inputs of the CdkDrag with the options of the underlying DragRef. */
-    private _syncInputs;
-    /** Handles the events from the underlying `DragRef`. */
-    private _handleEvents;
-    /** Assigns the default input values based on a provided config object. */
-    private _assignDefaults;
-    /** Sets up the listener that syncs the handles with the drag ref. */
-    private _setupHandlesListener;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkDrag<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkDrag<any>, "[cdkDrag]", ["cdkDrag"], { "data": { "alias": "cdkDragData"; "required": false; }; "lockAxis": { "alias": "cdkDragLockAxis"; "required": false; }; "rootElementSelector": { "alias": "cdkDragRootElement"; "required": false; }; "boundaryElement": { "alias": "cdkDragBoundary"; "required": false; }; "dragStartDelay": { "alias": "cdkDragStartDelay"; "required": false; }; "freeDragPosition": { "alias": "cdkDragFreeDragPosition"; "required": false; }; "disabled": { "alias": "cdkDragDisabled"; "required": false; }; "constrainPosition": { "alias": "cdkDragConstrainPosition"; "required": false; }; "previewClass": { "alias": "cdkDragPreviewClass"; "required": false; }; "previewContainer": { "alias": "cdkDragPreviewContainer"; "required": false; }; "scale": { "alias": "cdkDragScale"; "required": false; }; }, { "started": "cdkDragStarted"; "released": "cdkDragReleased"; "ended": "cdkDragEnded"; "entered": "cdkDragEntered"; "exited": "cdkDragExited"; "dropped": "cdkDragDropped"; "moved": "cdkDragMoved"; }, never, never, true, never>;
-    static ngAcceptInputType_disabled: unknown;
-    static ngAcceptInputType_scale: unknown;
-}
-
-/** Event emitted when the user drops a draggable item inside a drop container. */
-export declare interface CdkDragDrop<T, O = T, I = any> {
-    /** Index of the item when it was picked up. */
-    previousIndex: number;
-    /** Current index of the item. */
-    currentIndex: number;
-    /** Item that is being dropped. */
-    item: CdkDrag<I>;
-    /** Container in which the item was dropped. */
-    container: CdkDropList<T>;
-    /** Container from which the item was picked up. Can be the same as the `container`. */
-    previousContainer: CdkDropList<O>;
-    /** Whether the user's pointer was over the container when the item was dropped. */
-    isPointerOverContainer: boolean;
-    /** Distance in pixels that the user has dragged since the drag sequence started. */
-    distance: {
-        x: number;
-        y: number;
-    };
-    /** Position where the pointer was when the item was dropped */
-    dropPoint: {
-        x: number;
-        y: number;
-    };
-    /** Native event that caused the drop event. */
-    event: MouseEvent | TouchEvent;
-}
-
-/** Event emitted when the user stops dragging a draggable. */
-export declare interface CdkDragEnd<T = any> {
-    /** Draggable that emitted the event. */
-    source: CdkDrag<T>;
-    /** Distance in pixels that the user has dragged since the drag sequence started. */
-    distance: {
-        x: number;
-        y: number;
-    };
-    /** Position where the pointer was when the item was dropped */
-    dropPoint: {
+    withScrollableParents(elements: HTMLElement[]): this;
+    /**
+     * Configures the drop list so that a different element is used as the container for the
+     * dragged items. This is useful for the cases when one might not have control over the
+     * full DOM that sets up the dragging.
+     * Note that the alternate container needs to be a descendant of the drop list.
+     * @param container New element container to be assigned.
+     */
+    withElementContainer(container: HTMLElement): this;
+    /** Gets the scrollable parents that are registered with this drop container. */
+    getScrollableParents(): readonly HTMLElement[];
+    /**
+     * Figures out the index of an item in the container.
+     * @param item Item whose index should be determined.
+     */
+    getItemIndex(item: DragRef): number;
+    /**
+     * Whether the list is able to receive the item that
+     * is currently being dragged inside a connected drop list.
+     */
+    isReceiving(): boolean;
+    /**
+     * 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: DragRef, pointerX: number, pointerY: number, pointerDelta: {
         x: number;
         y: number;
-    };
-    /** Native event that caused the dragging to stop. */
-    event: MouseEvent | TouchEvent;
-}
-
-/** Event emitted when the user moves an item into a new drop container. */
-export declare interface CdkDragEnter<T = any, I = T> {
-    /** Container into which the user has moved the item. */
-    container: CdkDropList<T>;
-    /** Item that was moved into the container. */
-    item: CdkDrag<I>;
-    /** Index at which the item has entered the container. */
-    currentIndex: number;
-}
-
-/**
- * Event emitted when the user removes an item from a
- * drop container by moving it into another one.
- */
-export declare interface CdkDragExit<T = any, I = T> {
-    /** Container from which the user has a removed an item. */
-    container: CdkDropList<T>;
-    /** Item that was removed from the container. */
-    item: CdkDrag<I>;
+    }): void;
+    /**
+     * Checks whether the user's pointer is close to the edges of either the
+     * viewport or the drop list and starts the auto-scroll sequence.
+     * @param pointerX User's pointer position along the x axis.
+     * @param pointerY User's pointer position along the y axis.
+     */
+    _startScrollingIfNecessary(pointerX: number, pointerY: number): void;
+    /** Stops any currently-running auto-scroll sequences. */
+    _stopScrolling(): void;
+    /** Starts the dragging sequence within the list. */
+    private _draggingStarted;
+    /** Caches the positions of the configured scrollable parents. */
+    private _cacheParentPositions;
+    /** Resets the container to its initial state. */
+    private _reset;
+    /** Starts the interval that'll auto-scroll the element. */
+    private _startScrollInterval;
+    /**
+     * 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;
+    /**
+     * 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: DragRef, x: number, y: number): DropListRef | undefined;
+    /**
+     * Checks whether the drop list can receive the passed-in item.
+     * @param item Item that is being dragged into the list.
+     * @param x Position of the item along the X axis.
+     * @param y Position of the item along the Y axis.
+     */
+    _canReceive(item: DragRef, x: number, y: number): boolean;
+    /**
+     * Called by one of the connected drop lists when a dragging sequence has started.
+     * @param sibling Sibling in which dragging has started.
+     */
+    _startReceiving(sibling: DropListRef, items: DragRef[]): void;
+    /**
+     * Called by a connected drop list when dragging has stopped.
+     * @param sibling Sibling whose dragging has stopped.
+     */
+    _stopReceiving(sibling: DropListRef): void;
+    /**
+     * Starts listening to scroll events on the viewport.
+     * Used for updating the internal state of the list.
+     */
+    private _listenToScrollEvents;
+    /**
+     * Lazily resolves and returns the shadow root of the element. We do this in a function, rather
+     * than saving it in property directly on init, because we want to resolve it as late as possible
+     * in order to ensure that the element has been moved into the shadow DOM. Doing it inside the
+     * constructor might be too early if the element is inside of something like `ngFor` or `ngIf`.
+     */
+    private _getShadowRoot;
+    /** Notifies any siblings that may potentially receive the item. */
+    private _notifyReceivingSiblings;
 }
 
-/** Handle that can be used to drag a CdkDrag instance. */
-export declare class CdkDragHandle implements AfterViewInit, OnDestroy {
+/** Container that wraps a set of draggable items. */
+declare class CdkDropList<T = any> implements OnDestroy {
     element: ElementRef<HTMLElement>;
-    private _parentDrag;
-    private _dragDropRegistry;
-    /** Emits when the state of the handle has changed. */
-    readonly _stateChanges: Subject<CdkDragHandle>;
-    /** Whether starting to drag through this handle is disabled. */
-    get disabled(): boolean;
-    set disabled(value: boolean);
-    private _disabled;
-    constructor(...args: unknown[]);
-    ngAfterViewInit(): void;
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkDragHandle, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkDragHandle, "[cdkDragHandle]", never, { "disabled": { "alias": "cdkDragHandleDisabled"; "required": false; }; }, {}, never, never, true, never>;
-    static ngAcceptInputType_disabled: unknown;
-}
-
-/** Event emitted as the user is dragging a draggable item. */
-export declare interface CdkDragMove<T = any> {
-    /** Item that is being dragged. */
-    source: CdkDrag<T>;
-    /** Position of the user's pointer on the page. */
-    pointerPosition: {
-        x: number;
-        y: number;
-    };
-    /** Native event that is causing the dragging. */
-    event: MouseEvent | TouchEvent;
-    /** Distance in pixels that the user has dragged since the drag sequence started. */
-    distance: {
-        x: number;
-        y: number;
-    };
-    /**
-     * Indicates the direction in which the user is dragging the element along each axis.
-     * `1` means that the position is increasing (e.g. the user is moving to the right or downwards),
-     * whereas `-1` means that it's decreasing (they're moving to the left or upwards). `0` means
-     * that the position hasn't changed.
-     */
-    delta: {
-        x: -1 | 0 | 1;
-        y: -1 | 0 | 1;
-    };
-}
-
-/**
- * Element that will be used as a template for the placeholder of a CdkDrag when
- * it is being dragged. The placeholder is displayed in place of the element being dragged.
- */
-export declare class CdkDragPlaceholder<T = any> implements OnDestroy {
-    templateRef: TemplateRef<T>;
-    private _drag;
-    /** Context data to be added to the placeholder template instance. */
-    data: T;
-    constructor(...args: unknown[]);
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkDragPlaceholder<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkDragPlaceholder<any>, "ng-template[cdkDragPlaceholder]", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, true, never>;
-}
-
-/**
- * Element that will be used as a template for the preview
- * of a CdkDrag when it is being dragged.
- */
-export declare class CdkDragPreview<T = any> implements OnDestroy {
-    templateRef: TemplateRef<T>;
-    private _drag;
-    /** Context data to be added to the preview template instance. */
-    data: T;
-    /** Whether the preview should preserve the same size as the item that is being dragged. */
-    matchSize: boolean;
-    constructor(...args: unknown[]);
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkDragPreview<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkDragPreview<any>, "ng-template[cdkDragPreview]", never, { "data": { "alias": "data"; "required": false; }; "matchSize": { "alias": "matchSize"; "required": false; }; }, {}, never, never, true, never>;
-    static ngAcceptInputType_matchSize: unknown;
-}
-
-/** Event emitted when the user releases an item, before any animations have started. */
-export declare interface CdkDragRelease<T = any> {
-    /** Draggable that emitted the event. */
-    source: CdkDrag<T>;
-    /** Native event that caused the release event. */
-    event: MouseEvent | TouchEvent;
-}
-
-/** Event emitted when the user swaps the position of two drag items. */
-export declare interface CdkDragSortEvent<T = any, I = T> {
-    /** Index from which the item was sorted previously. */
-    previousIndex: number;
-    /** Index that the item is currently in. */
-    currentIndex: number;
-    /** Container that the item belongs to. */
-    container: CdkDropList<T>;
-    /** Item that is being sorted. */
-    item: CdkDrag<I>;
-}
-
-/** Event emitted when the user starts dragging a draggable. */
-export declare interface CdkDragStart<T = any> {
-    /** Draggable that emitted the event. */
-    source: CdkDrag<T>;
-    /** Native event that started the drag sequence. */
-    event: MouseEvent | TouchEvent;
-}
-
-/** Container that wraps a set of draggable items. */
-export declare class CdkDropList<T = any> implements OnDestroy {
-    element: ElementRef<HTMLElement>;
-    private _changeDetectorRef;
-    private _scrollDispatcher;
-    private _dir;
-    private _group;
-    /** Emits when the list has been destroyed. */
-    private readonly _destroyed;
-    /** Whether the element's scrollable parents have been resolved. */
-    private _scrollableParentsResolved;
-    /** 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>>;
-    /**
-     * 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: DropListOrientation;
-    /**
-     * 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: DragAxis;
-    /** Whether starting a dragging sequence from this container is disabled. */
+    private _changeDetectorRef;
+    private _scrollDispatcher;
+    private _dir;
+    private _group;
+    /** Emits when the list has been destroyed. */
+    private readonly _destroyed;
+    /** Whether the element's scrollable parents have been resolved. */
+    private _scrollableParentsResolved;
+    /** 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>>;
+    /**
+     * 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: DropListOrientation;
+    /**
+     * 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: DragAxis;
+    /** Whether starting a dragging sequence from this container is disabled. */
     get disabled(): boolean;
     set disabled(value: boolean);
     private _disabled;
@@ -489,419 +418,293 @@ export declare class CdkDropList<T = any> implements OnDestroy {
     static ngAcceptInputType_autoScrollDisabled: unknown;
 }
 
+/** Event emitted when the user starts dragging a draggable. */
+interface CdkDragStart<T = any> {
+    /** Draggable that emitted the event. */
+    source: CdkDrag<T>;
+    /** Native event that started the drag sequence. */
+    event: MouseEvent | TouchEvent;
+}
+/** Event emitted when the user releases an item, before any animations have started. */
+interface CdkDragRelease<T = any> {
+    /** Draggable that emitted the event. */
+    source: CdkDrag<T>;
+    /** Native event that caused the release event. */
+    event: MouseEvent | TouchEvent;
+}
+/** Event emitted when the user stops dragging a draggable. */
+interface CdkDragEnd<T = any> {
+    /** Draggable that emitted the event. */
+    source: CdkDrag<T>;
+    /** Distance in pixels that the user has dragged since the drag sequence started. */
+    distance: {
+        x: number;
+        y: number;
+    };
+    /** Position where the pointer was when the item was dropped */
+    dropPoint: {
+        x: number;
+        y: number;
+    };
+    /** Native event that caused the dragging to stop. */
+    event: MouseEvent | TouchEvent;
+}
+/** Event emitted when the user moves an item into a new drop container. */
+interface CdkDragEnter<T = any, I = T> {
+    /** Container into which the user has moved the item. */
+    container: CdkDropList<T>;
+    /** Item that was moved into the container. */
+    item: CdkDrag<I>;
+    /** Index at which the item has entered the container. */
+    currentIndex: number;
+}
+/**
+ * Event emitted when the user removes an item from a
+ * drop container by moving it into another one.
+ */
+interface CdkDragExit<T = any, I = T> {
+    /** Container from which the user has a removed an item. */
+    container: CdkDropList<T>;
+    /** Item that was removed from the container. */
+    item: CdkDrag<I>;
+}
+/** Event emitted when the user drops a draggable item inside a drop container. */
+interface CdkDragDrop<T, O = T, I = any> {
+    /** Index of the item when it was picked up. */
+    previousIndex: number;
+    /** Current index of the item. */
+    currentIndex: number;
+    /** Item that is being dropped. */
+    item: CdkDrag<I>;
+    /** Container in which the item was dropped. */
+    container: CdkDropList<T>;
+    /** Container from which the item was picked up. Can be the same as the `container`. */
+    previousContainer: CdkDropList<O>;
+    /** Whether the user's pointer was over the container when the item was dropped. */
+    isPointerOverContainer: boolean;
+    /** Distance in pixels that the user has dragged since the drag sequence started. */
+    distance: {
+        x: number;
+        y: number;
+    };
+    /** Position where the pointer was when the item was dropped */
+    dropPoint: {
+        x: number;
+        y: number;
+    };
+    /** Native event that caused the drop event. */
+    event: MouseEvent | TouchEvent;
+}
+/** Event emitted as the user is dragging a draggable item. */
+interface CdkDragMove<T = any> {
+    /** Item that is being dragged. */
+    source: CdkDrag<T>;
+    /** Position of the user's pointer on the page. */
+    pointerPosition: {
+        x: number;
+        y: number;
+    };
+    /** Native event that is causing the dragging. */
+    event: MouseEvent | TouchEvent;
+    /** Distance in pixels that the user has dragged since the drag sequence started. */
+    distance: {
+        x: number;
+        y: number;
+    };
+    /**
+     * Indicates the direction in which the user is dragging the element along each axis.
+     * `1` means that the position is increasing (e.g. the user is moving to the right or downwards),
+     * whereas `-1` means that it's decreasing (they're moving to the left or upwards). `0` means
+     * that the position hasn't changed.
+     */
+    delta: {
+        x: -1 | 0 | 1;
+        y: -1 | 0 | 1;
+    };
+}
+/** Event emitted when the user swaps the position of two drag items. */
+interface CdkDragSortEvent<T = any, I = T> {
+    /** Index from which the item was sorted previously. */
+    previousIndex: number;
+    /** Index that the item is currently in. */
+    currentIndex: number;
+    /** Container that the item belongs to. */
+    container: CdkDropList<T>;
+    /** Item that is being sorted. */
+    item: CdkDrag<I>;
+}
+
 /**
- * Declaratively connects sibling `cdkDropList` instances together. All of the `cdkDropList`
- * elements that are placed inside a `cdkDropListGroup` will be connected to each other
- * automatically. Can be used as an alternative to the `cdkDropListConnectedTo` input
- * from `cdkDropList`.
+ * Injection token that can be used to reference instances of `CdkDragHandle`. It serves as
+ * alternative token to the actual `CdkDragHandle` class which could cause unnecessary
+ * retention of the class and its directive metadata.
  */
-export declare class CdkDropListGroup<T> implements OnDestroy {
-    /** Drop lists registered inside the group. */
-    readonly _items: Set<T>;
-    /** Whether starting a dragging sequence from inside this group is disabled. */
-    disabled: boolean;
+declare const CDK_DRAG_HANDLE: InjectionToken<CdkDragHandle>;
+/** Handle that can be used to drag a CdkDrag instance. */
+declare class CdkDragHandle implements AfterViewInit, OnDestroy {
+    element: ElementRef<HTMLElement>;
+    private _parentDrag;
+    private _dragDropRegistry;
+    /** Emits when the state of the handle has changed. */
+    readonly _stateChanges: Subject<CdkDragHandle>;
+    /** Whether starting to drag through this handle is disabled. */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _disabled;
+    constructor(...args: unknown[]);
+    ngAfterViewInit(): void;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkDropListGroup<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkDropListGroup<any>, "[cdkDropListGroup]", ["cdkDropListGroup"], { "disabled": { "alias": "cdkDropListGroupDisabled"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkDragHandle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkDragHandle, "[cdkDragHandle]", never, { "disabled": { "alias": "cdkDragHandleDisabled"; "required": false; }; }, {}, never, never, true, never>;
     static ngAcceptInputType_disabled: unknown;
 }
 
 /**
- * Copies an item from one array to another, leaving it in its
- * original position in current array.
- * @param currentArray Array from which to copy the item.
- * @param targetArray Array into which is copy the item.
- * @param currentIndex Index of the item in its current array.
- * @param targetIndex Index at which to insert the item.
- *
+ * Injection token that can be used to reference instances of `CdkDragPlaceholder`. It serves as
+ * alternative token to the actual `CdkDragPlaceholder` class which could cause unnecessary
+ * retention of the class and its directive metadata.
  */
-export declare function copyArrayItem<T = any>(currentArray: T[], targetArray: T[], currentIndex: number, targetIndex: number): void;
-
-/** Possible axis along which dragging can be locked. */
-export declare type DragAxis = 'x' | 'y';
-
-/** Function that can be used to constrain the position of a dragged element. */
-export declare type DragConstrainPosition = (point: Point, dragRef: DragRef) => Point;
-
+declare const CDK_DRAG_PLACEHOLDER: InjectionToken<CdkDragPlaceholder<any>>;
 /**
- * Service that allows for drag-and-drop functionality to be attached to DOM elements.
+ * Element that will be used as a template for the placeholder of a CdkDrag when
+ * it is being dragged. The placeholder is displayed in place of the element being dragged.
  */
-export declare class DragDrop {
-    private _document;
-    private _ngZone;
-    private _viewportRuler;
-    private _dragDropRegistry;
-    private _renderer;
+declare class CdkDragPlaceholder<T = any> implements OnDestroy {
+    templateRef: TemplateRef<T>;
+    private _drag;
+    /** Context data to be added to the placeholder template instance. */
+    data: T;
     constructor(...args: unknown[]);
-    /**
-     * Turns an element into a draggable item.
-     * @param element Element to which to attach the dragging functionality.
-     * @param config Object used to configure the dragging behavior.
-     */
-    createDrag<T = any>(element: ElementRef<HTMLElement> | HTMLElement, config?: DragRefConfig): DragRef<T>;
-    /**
-     * Turns an element into a drop list.
-     * @param element Element to which to attach the drop list functionality.
-     */
-    createDropList<T = any>(element: ElementRef<HTMLElement> | HTMLElement): DropListRef<T>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DragDrop, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<DragDrop>;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkDragPlaceholder<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkDragPlaceholder<any>, "ng-template[cdkDragPlaceholder]", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, true, never>;
 }
 
 /**
- * Object that can be used to configure the drag
- * items and drop lists within a module or a component.
+ * Injection token that can be used to reference instances of `CdkDragPreview`. It serves as
+ * alternative token to the actual `CdkDragPreview` class which could cause unnecessary
+ * retention of the class and its directive metadata.
  */
-export declare interface DragDropConfig extends Partial<DragRefConfig> {
-    lockAxis?: DragAxis;
-    dragStartDelay?: DragStartDelay;
-    constrainPosition?: DragConstrainPosition;
-    previewClass?: string | string[];
-    boundaryElement?: string;
-    rootElementSelector?: string;
-    draggingDisabled?: boolean;
-    sortingDisabled?: boolean;
-    listAutoScrollDisabled?: boolean;
-    listOrientation?: DropListOrientation;
-    zIndex?: number;
-    previewContainer?: 'global' | 'parent';
-}
-
-export declare class DragDropModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<DragDropModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<DragDropModule, never, [typeof i1.CdkDropList, typeof i2.CdkDropListGroup, typeof i3.CdkDrag, typeof i4.CdkDragHandle, typeof i5.CdkDragPreview, typeof i6.CdkDragPlaceholder], [typeof i7.CdkScrollableModule, typeof i1.CdkDropList, typeof i2.CdkDropListGroup, typeof i3.CdkDrag, typeof i4.CdkDragHandle, typeof i5.CdkDragPreview, typeof i6.CdkDragPlaceholder]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<DragDropModule>;
-}
-
+declare const CDK_DRAG_PREVIEW: InjectionToken<CdkDragPreview<any>>;
 /**
- * Service that keeps track of all the drag item and drop container
- * instances, and manages global event listeners on the `document`.
- * @docs-private
+ * Element that will be used as a template for the preview
+ * of a CdkDrag when it is being dragged.
  */
-export declare class DragDropRegistry<_ = unknown, __ = unknown> implements OnDestroy {
-    private _ngZone;
-    private _document;
-    private _styleLoader;
-    private _renderer;
-    private _cleanupDocumentTouchmove;
-    /** Registered drop container instances. */
-    private _dropInstances;
-    /** Registered drag item instances. */
-    private _dragInstances;
-    /** Drag item instances that are currently being dragged. */
-    private _activeDragInstances;
-    /** Keeps track of the event listeners that we've bound to the `document`. */
-    private _globalListeners;
-    /**
-     * Predicate function to check if an item is being dragged.  Moved out into a property,
-     * because it'll be called a lot and we don't want to create a new function every time.
-     */
-    private _draggingPredicate;
-    /**
-     * Map tracking DOM nodes and their corresponding drag directives. Note that this is different
-     * from looking through the `_dragInstances` and getting their root node, because the root node
-     * isn't necessarily the node that the directive is set on.
-     */
-    private _domNodesToDirectives;
-    /**
-     * Emits the `touchmove` or `mousemove` events that are dispatched
-     * while the user is dragging a drag item instance.
-     */
-    readonly pointerMove: Subject<TouchEvent | MouseEvent>;
-    /**
-     * Emits the `touchend` or `mouseup` events that are dispatched
-     * while the user is dragging a drag item instance.
-     */
-    readonly pointerUp: Subject<TouchEvent | MouseEvent>;
-    /**
-     * Emits when the viewport has been scrolled while the user is dragging an item.
-     * @deprecated To be turned into a private member. Use the `scrolled` method instead.
-     * @breaking-change 13.0.0
-     */
-    readonly scroll: Subject<Event>;
+declare class CdkDragPreview<T = any> implements OnDestroy {
+    templateRef: TemplateRef<T>;
+    private _drag;
+    /** Context data to be added to the preview template instance. */
+    data: T;
+    /** Whether the preview should preserve the same size as the item that is being dragged. */
+    matchSize: boolean;
     constructor(...args: unknown[]);
-    /** Adds a drop container to the registry. */
-    registerDropContainer(drop: DropListRef): void;
-    /** Adds a drag item instance to the registry. */
-    registerDragItem(drag: DragRef): void;
-    /** Removes a drop container from the registry. */
-    removeDropContainer(drop: DropListRef): void;
-    /** Removes a drag item instance from the registry. */
-    removeDragItem(drag: DragRef): void;
-    /**
-     * Starts the dragging sequence for a drag instance.
-     * @param drag Drag instance which is being dragged.
-     * @param event Event that initiated the dragging.
-     */
-    startDragging(drag: DragRef, event: TouchEvent | MouseEvent): void;
-    /** Stops dragging a drag item instance. */
-    stopDragging(drag: DragRef): void;
-    /** Gets whether a drag item instance is currently being dragged. */
-    isDragging(drag: DragRef): boolean;
-    /**
-     * Gets a stream that will emit when any element on the page is scrolled while an item is being
-     * dragged.
-     * @param shadowRoot Optional shadow root that the current dragging sequence started from.
-     *   Top-level listeners won't pick up events coming from the shadow DOM so this parameter can
-     *   be used to include an additional top-level listener at the shadow root level.
-     */
-    scrolled(shadowRoot?: DocumentOrShadowRoot | null): Observable<Event>;
-    /**
-     * Tracks the DOM node which has a draggable directive.
-     * @param node Node to track.
-     * @param dragRef Drag directive set on the node.
-     */
-    registerDirectiveNode(node: Node, dragRef: CdkDrag): void;
-    /**
-     * Stops tracking a draggable directive node.
-     * @param node Node to stop tracking.
-     */
-    removeDirectiveNode(node: Node): void;
-    /**
-     * Gets the drag directive corresponding to a specific DOM node, if any.
-     * @param node Node for which to do the lookup.
-     */
-    getDragDirectiveForNode(node: Node): CdkDrag | null;
     ngOnDestroy(): void;
-    /**
-     * Event listener that will prevent the default browser action while the user is dragging.
-     * @param event Event whose default action should be prevented.
-     */
-    private _preventDefaultWhileDragging;
-    /** Event listener for `touchmove` that is bound even if no dragging is happening. */
-    private _persistentTouchmoveListener;
-    /** Clears out the global event listeners from the `document`. */
-    private _clearGlobalListeners;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DragDropRegistry<any, any>, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<DragDropRegistry<any, any>>;
-}
-
-/** Template that can be used to create a drag helper element (e.g. a preview or a placeholder). */
-declare interface DragHelperTemplate<T = any> {
-    template: TemplateRef<T> | null;
-    viewContainer: ViewContainerRef;
-    context: T;
-}
-
-/** Template that can be used to create a drag preview element. */
-declare interface DragPreviewTemplate<T = any> {
-    matchSize?: boolean;
-    template: TemplateRef<T> | null;
-    viewContainer: ViewContainerRef;
-    context: T;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkDragPreview<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkDragPreview<any>, "ng-template[cdkDragPreview]", never, { "data": { "alias": "data"; "required": false; }; "matchSize": { "alias": "matchSize"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_matchSize: unknown;
 }
 
 /**
- * Reference to a draggable item. Used to manipulate or dispose of the item.
+ * Injection token that can be used to reference instances of `CdkDropList`. It serves as
+ * alternative token to the actual `CdkDropList` class which could cause unnecessary
+ * retention of the class and its directive metadata.
  */
-export declare class DragRef<T = any> {
-    private _config;
-    private _document;
+declare const CDK_DROP_LIST: InjectionToken<CdkDropList<any>>;
+/** Element that can be moved inside a CdkDropList container. */
+declare class CdkDrag<T = any> implements AfterViewInit, OnChanges, OnDestroy {
+    element: ElementRef<HTMLElement>;
+    dropContainer: CdkDropList<any>;
     private _ngZone;
-    private _viewportRuler;
+    private _viewContainerRef;
+    private _dir;
+    private _changeDetectorRef;
+    private _selfHandle;
+    private _parentDrag;
     private _dragDropRegistry;
-    private _renderer;
-    private _rootElementCleanups;
-    private _cleanupShadowRootSelectStart;
-    /** Element displayed next to the user's pointer while the element is dragged. */
-    private _preview;
-    /** Container into which to insert the preview. */
-    private _previewContainer;
-    /** Reference to the view of the placeholder element. */
-    private _placeholderRef;
-    /** Element that is rendered instead of the draggable item while it is being sorted. */
-    private _placeholder;
-    /** Coordinates within the element at which the user picked up the element. */
-    private _pickupPositionInElement;
-    /** Coordinates on the page at which the user picked up the element. */
-    private _pickupPositionOnPage;
-    /**
-     * Anchor node used to save the place in the DOM where the element was
-     * picked up so that it can be restored at the end of the drag sequence.
-     */
-    private _anchor;
-    /**
-     * CSS `transform` applied to the element when it isn't being dragged. We need a
-     * passive transform in order for the dragged element to retain its new position
-     * after the user has stopped dragging and because we need to know the relative
-     * position in case they start dragging again. This corresponds to `element.style.transform`.
-     */
-    private _passiveTransform;
-    /** CSS `transform` that is applied to the element while it's being dragged. */
-    private _activeTransform;
-    /** Inline `transform` value that the element had before the first dragging sequence. */
-    private _initialTransform?;
-    /**
-     * Whether the dragging sequence has been started. Doesn't
-     * necessarily mean that the element has been moved.
-     */
-    private _hasStartedDragging;
-    /** Whether the element has moved since the user started dragging it. */
-    private _hasMoved;
-    /** Drop container in which the DragRef resided when dragging began. */
-    private _initialContainer;
-    /** Index at which the item started in its initial container. */
-    private _initialIndex;
-    /** Cached positions of scrollable parent elements. */
-    private _parentPositions;
-    /** Emits when the item is being moved. */
-    private readonly _moveEvents;
-    /** Keeps track of the direction in which the user is dragging along each axis. */
-    private _pointerDirectionDelta;
-    /** Pointer position at which the last change in the delta occurred. */
-    private _pointerPositionAtLastDirectionChange;
-    /** Position of the pointer at the last pointer event. */
-    private _lastKnownPointerPosition;
-    /**
-     * Root DOM node of the drag instance. This is the element that will
-     * be moved around as the user is dragging.
-     */
-    private _rootElement;
-    /**
-     * Nearest ancestor SVG, relative to which coordinates are calculated if dragging SVGElement
-     */
-    private _ownerSVGElement;
-    /**
-     * 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 viewport being scrolled. */
-    private _scrollSubscription;
-    /** Subscription to the viewport being resized. */
-    private _resizeSubscription;
-    /**
-     * 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;
-    /** Time at which the last dragging sequence was started. */
-    private _dragStartTime;
-    /** Cached reference to the boundary element. */
-    private _boundaryElement;
-    /** Whether the native dragging interactions have been enabled on the root element. */
-    private _nativeInteractionsEnabled;
-    /** Client rect of the root element when the dragging sequence has started. */
-    private _initialDomRect?;
-    /** Cached dimensions of the preview element. Should be read via `_getPreviewRect`. */
-    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. */
-    private _previewTemplate?;
-    /** Template for placeholder element rendered to show where a draggable would be dropped. */
-    private _placeholderTemplate?;
-    /** Elements that can be used to drag the draggable item. */
+    private readonly _destroyed;
     private _handles;
-    /** Registered handles that are currently disabled. */
-    private _disabledHandles;
-    /** Droppable container that the draggable is a part of. */
-    private _dropContainer?;
-    /** Layout direction of the item. */
-    private _direction;
-    /** Ref that the current drag item is nested in. */
-    private _parentDragRef;
+    private _previewTemplate;
+    private _placeholderTemplate;
+    /** Reference to the underlying drag instance. */
+    _dragRef: DragRef<CdkDrag<T>>;
+    /** Arbitrary data to attach to this drag instance. */
+    data: T;
+    /** Locks the position of the dragged element along the specified axis. */
+    lockAxis: DragAxis;
     /**
-     * Cached shadow root that the element is placed in. `null` means that the element isn't in
-     * the shadow DOM and `undefined` means that it hasn't been resolved yet. Should be read via
-     * `_getShadowRoot`, not directly.
+     * 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.
      */
-    private _cachedShadowRoot;
-    /** Axis along which dragging is locked. */
-    lockAxis: 'x' | 'y';
+    rootElementSelector: string;
+    /**
+     * Node or selector that will be used to determine the element to which the draggable's
+     * position will be constrained. If a string is passed in, it'll be used as a selector that
+     * will be matched starting from the element's parent and going up the DOM until a match
+     * has been found.
+     */
+    boundaryElement: string | ElementRef<HTMLElement> | HTMLElement;
     /**
      * Amount of milliseconds to wait after the user has put their
      * pointer down before starting to drag the element.
      */
-    dragStartDelay: number | {
-        touch: number;
-        mouse: number;
-    };
-    /** Class to be added to the preview element. */
-    previewClass: string | string[] | undefined;
+    dragStartDelay: DragStartDelay;
     /**
-     * If the parent of the dragged element has a `scale` transform, it can throw off the
-     * positioning when the user starts dragging. Use this input to notify the CDK of the scale.
+     * Sets the position of a `CdkDrag` that is outside of a drop container.
+     * Can be used to restore the element's position for a returning user.
      */
-    scale: number;
+    freeDragPosition: Point;
     /** Whether starting to drag this element is disabled. */
     get disabled(): boolean;
     set disabled(value: boolean);
     private _disabled;
-    /** Emits as the drag sequence is being prepared. */
-    readonly beforeStarted: Subject<void>;
+    /**
+     * Function that can be used to customize the logic of how the position of the drag item
+     * is limited while it's being dragged. Gets called with a point containing the current position
+     * of the user's pointer on the page, a reference to the item being dragged and its dimensions.
+     * Should return a point describing where the item should be rendered.
+     */
+    constrainPosition?: (userPointerPosition: Point, dragRef: DragRef, dimensions: DOMRect, pickupPositionInElement: Point) => Point;
+    /** Class to be added to the preview element. */
+    previewClass: string | string[];
+    /**
+     * Configures the place into which the preview of the item will be inserted. Can be configured
+     * globally through `CDK_DROP_LIST`. Possible values:
+     * - `global` - Preview will be inserted at the bottom of the `<body>`. The advantage is that
+     * you don't have to worry about `overflow: hidden` or `z-index`, but the item won't retain
+     * its inherited styles.
+     * - `parent` - Preview will be inserted into the parent of the drag item. The advantage is that
+     * inherited styles will be preserved, but it may be clipped by `overflow: hidden` or not be
+     * visible due to `z-index`. Furthermore, the preview is going to have an effect over selectors
+     * like `:nth-child` and some flexbox configurations.
+     * - `ElementRef<HTMLElement> | HTMLElement` - Preview will be inserted into a specific element.
+     * Same advantages and disadvantages as `parent`.
+     */
+    previewContainer: PreviewContainer;
+    /**
+     * If the parent of the dragged element has a `scale` transform, it can throw off the
+     * positioning when the user starts dragging. Use this input to notify the CDK of the scale.
+     */
+    scale: number;
     /** Emits when the user starts dragging the item. */
-    readonly started: Subject<{
-        source: DragRef;
-        event: MouseEvent | TouchEvent;
-    }>;
+    readonly started: EventEmitter<CdkDragStart>;
     /** Emits when the user has released a drag item, before any animations have started. */
-    readonly released: Subject<{
-        source: DragRef;
-        event: MouseEvent | TouchEvent;
-    }>;
+    readonly released: EventEmitter<CdkDragRelease>;
     /** Emits when the user stops dragging an item in the container. */
-    readonly ended: Subject<{
-        source: DragRef;
-        distance: Point;
-        dropPoint: Point;
-        event: MouseEvent | TouchEvent;
-    }>;
+    readonly ended: EventEmitter<CdkDragEnd>;
     /** Emits when the user has moved the item into a new container. */
-    readonly entered: Subject<{
-        container: DropListRef;
-        item: DragRef;
-        currentIndex: number;
-    }>;
+    readonly entered: EventEmitter<CdkDragEnter<any>>;
     /** Emits when the user removes the item its container by dragging it into another container. */
-    readonly exited: Subject<{
-        container: DropListRef;
-        item: DragRef;
-    }>;
+    readonly exited: EventEmitter<CdkDragExit<any>>;
     /** Emits when the user drops the item inside a container. */
-    readonly dropped: Subject<{
-        previousIndex: number;
-        currentIndex: number;
-        item: DragRef;
-        container: DropListRef;
-        previousContainer: DropListRef;
-        distance: Point;
-        dropPoint: Point;
-        isPointerOverContainer: boolean;
-        event: MouseEvent | TouchEvent;
-    }>;
+    readonly dropped: EventEmitter<CdkDragDrop<any>>;
     /**
      * Emits as the user is dragging the item. Use with caution,
      * because this event will fire for every pixel that the user has dragged.
      */
-    readonly moved: Observable<{
-        source: DragRef;
-        pointerPosition: {
-            x: number;
-            y: number;
-        };
-        event: MouseEvent | TouchEvent;
-        distance: Point;
-        delta: {
-            x: -1 | 0 | 1;
-            y: -1 | 0 | 1;
-        };
-    }>;
-    /** Arbitrary data that can be attached to the drag item. */
-    data: T;
-    /**
-     * Function that can be used to customize the logic of how the position of the drag item
-     * is limited while it's being dragged. Gets called with a point containing the current position
-     * of the user's pointer on the page, a reference to the item being dragged and its dimensions.
-     * Should return a point describing where the item should be rendered.
-     */
-    constrainPosition?: (userPointerPosition: Point, dragRef: DragRef, dimensions: DOMRect, pickupPositionInElement: Point) => Point;
-    constructor(element: ElementRef<HTMLElement> | HTMLElement, _config: DragRefConfig, _document: Document, _ngZone: NgZone, _viewportRuler: ViewportRuler, _dragDropRegistry: DragDropRegistry, _renderer: Renderer2);
+    readonly moved: Observable<CdkDragMove<T>>;
+    private _injector;
+    constructor(...args: unknown[]);
     /**
      * Returns the element that is being used as a placeholder
      * while the current element is being dragged.
@@ -909,458 +712,565 @@ export declare class DragRef<T = any> {
     getPlaceholderElement(): HTMLElement;
     /** Returns the root draggable element. */
     getRootElement(): HTMLElement;
+    /** Resets a standalone drag item to its initial position. */
+    reset(): void;
     /**
-     * Gets the currently-visible element that represents the drag item.
-     * While dragging this is the placeholder, otherwise it's the root element.
+     * Gets the pixel coordinates of the draggable outside of a drop container.
      */
-    getVisibleElement(): HTMLElement;
-    /** Registers the handles that can be used to drag the element. */
-    withHandles(handles: (HTMLElement | ElementRef<HTMLElement>)[]): this;
+    getFreeDragPosition(): Readonly<Point>;
     /**
-     * Registers the template that should be used for the drag preview.
-     * @param template Template that from which to stamp out the preview.
+     * Sets the current position in pixels the draggable outside of a drop container.
+     * @param value New position to be set.
      */
-    withPreviewTemplate(template: DragPreviewTemplate | null): this;
+    setFreeDragPosition(value: Point): void;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    _addHandle(handle: CdkDragHandle): void;
+    _removeHandle(handle: CdkDragHandle): void;
+    _setPreviewTemplate(preview: CdkDragPreview): void;
+    _resetPreviewTemplate(preview: CdkDragPreview): void;
+    _setPlaceholderTemplate(placeholder: CdkDragPlaceholder): void;
+    _resetPlaceholderTemplate(placeholder: CdkDragPlaceholder): void;
+    /** Syncs the root element with the `DragRef`. */
+    private _updateRootElement;
+    /** Gets the boundary element, based on the `boundaryElement` value. */
+    private _getBoundaryElement;
+    /** Syncs the inputs of the CdkDrag with the options of the underlying DragRef. */
+    private _syncInputs;
+    /** Handles the events from the underlying `DragRef`. */
+    private _handleEvents;
+    /** Assigns the default input values based on a provided config object. */
+    private _assignDefaults;
+    /** Sets up the listener that syncs the handles with the drag ref. */
+    private _setupHandlesListener;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkDrag<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkDrag<any>, "[cdkDrag]", ["cdkDrag"], { "data": { "alias": "cdkDragData"; "required": false; }; "lockAxis": { "alias": "cdkDragLockAxis"; "required": false; }; "rootElementSelector": { "alias": "cdkDragRootElement"; "required": false; }; "boundaryElement": { "alias": "cdkDragBoundary"; "required": false; }; "dragStartDelay": { "alias": "cdkDragStartDelay"; "required": false; }; "freeDragPosition": { "alias": "cdkDragFreeDragPosition"; "required": false; }; "disabled": { "alias": "cdkDragDisabled"; "required": false; }; "constrainPosition": { "alias": "cdkDragConstrainPosition"; "required": false; }; "previewClass": { "alias": "cdkDragPreviewClass"; "required": false; }; "previewContainer": { "alias": "cdkDragPreviewContainer"; "required": false; }; "scale": { "alias": "cdkDragScale"; "required": false; }; }, { "started": "cdkDragStarted"; "released": "cdkDragReleased"; "ended": "cdkDragEnded"; "entered": "cdkDragEntered"; "exited": "cdkDragExited"; "dropped": "cdkDragDropped"; "moved": "cdkDragMoved"; }, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_scale: unknown;
+}
+
+/**
+ * Service that keeps track of all the drag item and drop container
+ * instances, and manages global event listeners on the `document`.
+ * @docs-private
+ */
+declare class DragDropRegistry<_ = unknown, __ = unknown> implements OnDestroy {
+    private _ngZone;
+    private _document;
+    private _styleLoader;
+    private _renderer;
+    private _cleanupDocumentTouchmove;
+    /** Registered drop container instances. */
+    private _dropInstances;
+    /** Registered drag item instances. */
+    private _dragInstances;
+    /** Drag item instances that are currently being dragged. */
+    private _activeDragInstances;
+    /** Keeps track of the event listeners that we've bound to the `document`. */
+    private _globalListeners;
     /**
-     * Registers the template that should be used for the drag placeholder.
-     * @param template Template that from which to stamp out the placeholder.
+     * Predicate function to check if an item is being dragged.  Moved out into a property,
+     * because it'll be called a lot and we don't want to create a new function every time.
      */
-    withPlaceholderTemplate(template: DragHelperTemplate | null): this;
+    private _draggingPredicate;
     /**
-     * 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.
+     * Map tracking DOM nodes and their corresponding drag directives. Note that this is different
+     * from looking through the `_dragInstances` and getting their root node, because the root node
+     * isn't necessarily the node that the directive is set on.
      */
-    withRootElement(rootElement: ElementRef<HTMLElement> | HTMLElement): this;
+    private _domNodesToDirectives;
     /**
-     * Element to which the draggable's position will be constrained.
+     * Emits the `touchmove` or `mousemove` events that are dispatched
+     * while the user is dragging a drag item instance.
      */
-    withBoundaryElement(boundaryElement: ElementRef<HTMLElement> | HTMLElement | null): this;
-    /** Sets the parent ref that the ref is nested in.  */
-    withParent(parent: DragRef<unknown> | 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;
+    readonly pointerMove: Subject<TouchEvent | MouseEvent>;
     /**
-     * Sets a handle as disabled. While a handle is disabled, it'll capture and interrupt dragging.
-     * @param handle Handle element that should be disabled.
+     * Emits the `touchend` or `mouseup` events that are dispatched
+     * while the user is dragging a drag item instance.
      */
-    disableHandle(handle: HTMLElement): void;
+    readonly pointerUp: Subject<TouchEvent | MouseEvent>;
     /**
-     * Enables a handle, if it has been disabled.
-     * @param handle Handle element to be enabled.
+     * Emits when the viewport has been scrolled while the user is dragging an item.
+     * @deprecated To be turned into a private member. Use the `scrolled` method instead.
+     * @breaking-change 13.0.0
      */
-    enableHandle(handle: HTMLElement): void;
-    /** Sets the layout direction of the draggable item. */
-    withDirection(direction: Direction): this;
-    /** Sets the container that the item is part of. */
-    _withDropContainer(container: DropListRef): void;
+    readonly scroll: Subject<Event>;
+    constructor(...args: unknown[]);
+    /** Adds a drop container to the registry. */
+    registerDropContainer(drop: DropListRef): void;
+    /** Adds a drag item instance to the registry. */
+    registerDragItem(drag: DragRef): void;
+    /** Removes a drop container from the registry. */
+    removeDropContainer(drop: DropListRef): void;
+    /** Removes a drag item instance from the registry. */
+    removeDragItem(drag: DragRef): void;
     /**
-     * Gets the current position in pixels the draggable outside of a drop container.
+     * Starts the dragging sequence for a drag instance.
+     * @param drag Drag instance which is being dragged.
+     * @param event Event that initiated the dragging.
+     */
+    startDragging(drag: DragRef, event: TouchEvent | MouseEvent): void;
+    /** Stops dragging a drag item instance. */
+    stopDragging(drag: DragRef): void;
+    /** Gets whether a drag item instance is currently being dragged. */
+    isDragging(drag: DragRef): boolean;
+    /**
+     * Gets a stream that will emit when any element on the page is scrolled while an item is being
+     * dragged.
+     * @param shadowRoot Optional shadow root that the current dragging sequence started from.
+     *   Top-level listeners won't pick up events coming from the shadow DOM so this parameter can
+     *   be used to include an additional top-level listener at the shadow root level.
      */
-    getFreeDragPosition(): Readonly<Point>;
+    scrolled(shadowRoot?: DocumentOrShadowRoot | null): Observable<Event>;
     /**
-     * Sets the current position in pixels the draggable outside of a drop container.
-     * @param value New position to be set.
+     * Tracks the DOM node which has a draggable directive.
+     * @param node Node to track.
+     * @param dragRef Drag directive set on the node.
      */
-    setFreeDragPosition(value: Point): this;
+    registerDirectiveNode(node: Node, dragRef: CdkDrag): void;
     /**
-     * Sets the container into which to insert the preview element.
-     * @param value Container into which to insert the preview.
+     * Stops tracking a draggable directive node.
+     * @param node Node to stop tracking.
      */
-    withPreviewContainer(value: PreviewContainer): this;
-    /** Updates the item's sort order based on the last-known pointer position. */
-    _sortFromLastPointerPosition(): void;
-    /** Unsubscribes from the global subscriptions. */
-    private _removeListeners;
-    /** Destroys the preview element and its ViewRef. */
-    private _destroyPreview;
-    /** Destroys the placeholder element and its ViewRef. */
-    private _destroyPlaceholder;
-    /** Handler for the `mousedown`/`touchstart` events. */
-    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;
+    removeDirectiveNode(node: Node): void;
     /**
-     * Clears subscriptions and stops the dragging sequence.
-     * @param event Browser event object that ended the sequence.
+     * Gets the drag directive corresponding to a specific DOM node, if any.
+     * @param node Node for which to do the lookup.
      */
-    private _endDragSequence;
-    /** Starts the dragging sequence. */
-    private _startDragSequence;
+    getDragDirectiveForNode(node: Node): CdkDrag | null;
+    ngOnDestroy(): void;
     /**
-     * Sets up the different variables and subscriptions
-     * that will be necessary for the dragging sequence.
-     * @param referenceElement Element that started the drag sequence.
-     * @param event Browser event object that started the sequence.
+     * Event listener that will prevent the default browser action while the user is dragging.
+     * @param event Event whose default action should be prevented.
      */
-    private _initializeDragSequence;
-    /** Cleans up the DOM artifacts that were added to facilitate the element being dragged. */
-    private _cleanupDragArtifacts;
+    private _preventDefaultWhileDragging;
+    /** Event listener for `touchmove` that is bound even if no dragging is happening. */
+    private _persistentTouchmoveListener;
+    /** Clears out the global event listeners from the `document`. */
+    private _clearGlobalListeners;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragDropRegistry<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DragDropRegistry<any, any>>;
+}
+
+/** Template that can be used to create a drag preview element. */
+interface DragPreviewTemplate<T = any> {
+    matchSize?: boolean;
+    template: TemplateRef<T> | null;
+    viewContainer: ViewContainerRef;
+    context: T;
+}
+
+/** Object that can be used to configure the behavior of DragRef. */
+interface DragRefConfig {
     /**
-     * Updates the item's position in its drop container, or moves it
-     * into a new one, depending on its current drag position.
+     * Minimum amount of pixels that the user should
+     * drag, before the CDK initiates a drag sequence.
      */
-    private _updateActiveDropContainer;
+    dragStartThreshold: number;
     /**
-     * Animates the preview element from its current position to the location of the drop placeholder.
-     * @returns Promise that resolves when the animation completes.
+     * Amount the pixels the user should drag before the CDK
+     * considers them to have changed the drag direction.
      */
-    private _animatePreviewToPlaceholder;
-    /** Creates an element that will be shown instead of the current element while dragging. */
-    private _createPlaceholderElement;
+    pointerDirectionChangeThreshold: number;
+    /** `z-index` for the absolutely-positioned elements that are created by the drag item. */
+    zIndex?: number;
+    /** Ref that the current drag item is nested in. */
+    parentDragRef?: DragRef;
+}
+/** Template that can be used to create a drag helper element (e.g. a preview or a placeholder). */
+interface DragHelperTemplate<T = any> {
+    template: TemplateRef<T> | null;
+    viewContainer: ViewContainerRef;
+    context: T;
+}
+/** Point on the page or within an element. */
+interface Point {
+    x: number;
+    y: number;
+}
+/**
+ * Possible places into which the preview of a drag item can be inserted.
+ * - `global` - Preview will be inserted at the bottom of the `<body>`. The advantage is that
+ * you don't have to worry about `overflow: hidden` or `z-index`, but the item won't retain
+ * its inherited styles.
+ * - `parent` - Preview will be inserted into the parent of the drag item. The advantage is that
+ * inherited styles will be preserved, but it may be clipped by `overflow: hidden` or not be
+ * visible due to `z-index`. Furthermore, the preview is going to have an effect over selectors
+ * like `:nth-child` and some flexbox configurations.
+ * - `ElementRef<HTMLElement> | HTMLElement` - Preview will be inserted into a specific element.
+ * Same advantages and disadvantages as `parent`.
+ */
+type PreviewContainer = 'global' | 'parent' | ElementRef<HTMLElement> | HTMLElement;
+/**
+ * Reference to a draggable item. Used to manipulate or dispose of the item.
+ */
+declare class DragRef<T = any> {
+    private _config;
+    private _document;
+    private _ngZone;
+    private _viewportRuler;
+    private _dragDropRegistry;
+    private _renderer;
+    private _rootElementCleanups;
+    private _cleanupShadowRootSelectStart;
+    /** Element displayed next to the user's pointer while the element is dragged. */
+    private _preview;
+    /** Container into which to insert the preview. */
+    private _previewContainer;
+    /** Reference to the view of the placeholder element. */
+    private _placeholderRef;
+    /** Element that is rendered instead of the draggable item while it is being sorted. */
+    private _placeholder;
+    /** Coordinates within the element at which the user picked up the element. */
+    private _pickupPositionInElement;
+    /** Coordinates on the page at which the user picked up the element. */
+    private _pickupPositionOnPage;
     /**
-     * Figures out the coordinates at which an element was picked up.
-     * @param referenceElement Element that initiated the dragging.
-     * @param event Event that initiated the dragging.
+     * Anchor node used to save the place in the DOM where the element was
+     * picked up so that it can be restored at the end of the drag sequence.
      */
-    private _getPointerPositionInElement;
-    /** 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;
-    /** Updates the current drag delta, based on the user's current pointer position on the page. */
-    private _updatePointerDirectionDelta;
-    /** 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;
+    private _anchor;
     /**
-     * Applies a `transform` to the root element, taking into account any existing transforms on it.
-     * @param x New transform value along the X axis.
-     * @param y New transform value along the Y axis.
+     * CSS `transform` applied to the element when it isn't being dragged. We need a
+     * passive transform in order for the dragged element to retain its new position
+     * after the user has stopped dragging and because we need to know the relative
+     * position in case they start dragging again. This corresponds to `element.style.transform`.
      */
-    private _applyRootElementTransform;
+    private _passiveTransform;
+    /** CSS `transform` that is applied to the element while it's being dragged. */
+    private _activeTransform;
+    /** Inline `transform` value that the element had before the first dragging sequence. */
+    private _initialTransform?;
     /**
-     * Applies a `transform` to the preview, taking into account any existing transforms on it.
-     * @param x New transform value along the X axis.
-     * @param y New transform value along the Y axis.
+     * Whether the dragging sequence has been started. Doesn't
+     * necessarily mean that the element has been moved.
      */
-    private _applyPreviewTransform;
+    private _hasStartedDragging;
+    /** Whether the element has moved since the user started dragging it. */
+    private _hasMoved;
+    /** Drop container in which the DragRef resided when dragging began. */
+    private _initialContainer;
+    /** Index at which the item started in its initial container. */
+    private _initialIndex;
+    /** Cached positions of scrollable parent elements. */
+    private _parentPositions;
+    /** Emits when the item is being moved. */
+    private readonly _moveEvents;
+    /** Keeps track of the direction in which the user is dragging along each axis. */
+    private _pointerDirectionDelta;
+    /** Pointer position at which the last change in the delta occurred. */
+    private _pointerPositionAtLastDirectionChange;
+    /** Position of the pointer at the last pointer event. */
+    private _lastKnownPointerPosition;
     /**
-     * Gets the distance that the user has dragged during the current drag sequence.
-     * @param currentPosition Current position of the user's pointer.
+     * Root DOM node of the drag instance. This is the element that will
+     * be moved around as the user is dragging.
      */
-    private _getDragDistance;
-    /** Cleans up any cached element dimensions that we don't need after dragging has stopped. */
-    private _cleanupCachedDimensions;
+    private _rootElement;
     /**
-     * Checks whether the element is still inside its boundary after the viewport has been resized.
-     * If not, the position is adjusted so that the element fits again.
+     * Nearest ancestor SVG, relative to which coordinates are calculated if dragging SVGElement
      */
-    private _containInsideBoundaryOnResize;
-    /** Gets the drag start delay, based on the event type. */
-    private _getDragStartDelay;
-    /** Updates the internal state of the draggable element when scrolling has occurred. */
-    private _updateOnScroll;
-    /** Gets the scroll position of the viewport. */
-    private _getViewportScrollPosition;
+    private _ownerSVGElement;
     /**
-     * Lazily resolves and returns the shadow root of the element. We do this in a function, rather
-     * than saving it in property directly on init, because we want to resolve it as late as possible
-     * in order to ensure that the element has been moved into the shadow DOM. Doing it inside the
-     * constructor might be too early if the element is inside of something like `ngFor` or `ngIf`.
+     * 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 _getShadowRoot;
-    /** Gets the element into which the drag preview should be inserted. */
-    private _getPreviewInsertionPoint;
-    /** Lazily resolves and returns the dimensions of the preview. */
-    private _getPreviewRect;
-    /** Handles a native `dragstart` event. */
-    private _nativeDragStart;
-    /** Gets a handle that is the target of an event. */
-    private _getTargetHandle;
-}
-
-/** Object that can be used to configure the behavior of DragRef. */
-export declare interface DragRefConfig {
+    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 viewport being scrolled. */
+    private _scrollSubscription;
+    /** Subscription to the viewport being resized. */
+    private _resizeSubscription;
     /**
-     * Minimum amount of pixels that the user should
-     * drag, before the CDK initiates a drag sequence.
+     * 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.
      */
-    dragStartThreshold: number;
+    private _lastTouchEventTime;
+    /** Time at which the last dragging sequence was started. */
+    private _dragStartTime;
+    /** Cached reference to the boundary element. */
+    private _boundaryElement;
+    /** Whether the native dragging interactions have been enabled on the root element. */
+    private _nativeInteractionsEnabled;
+    /** Client rect of the root element when the dragging sequence has started. */
+    private _initialDomRect?;
+    /** Cached dimensions of the preview element. Should be read via `_getPreviewRect`. */
+    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. */
+    private _previewTemplate?;
+    /** Template for placeholder element rendered to show where a draggable would be dropped. */
+    private _placeholderTemplate?;
+    /** Elements that can be used to drag the draggable item. */
+    private _handles;
+    /** Registered handles that are currently disabled. */
+    private _disabledHandles;
+    /** Droppable container that the draggable is a part of. */
+    private _dropContainer?;
+    /** Layout direction of the item. */
+    private _direction;
+    /** Ref that the current drag item is nested in. */
+    private _parentDragRef;
     /**
-     * Amount the pixels the user should drag before the CDK
-     * considers them to have changed the drag direction.
+     * Cached shadow root that the element is placed in. `null` means that the element isn't in
+     * the shadow DOM and `undefined` means that it hasn't been resolved yet. Should be read via
+     * `_getShadowRoot`, not directly.
      */
-    pointerDirectionChangeThreshold: number;
-    /** `z-index` for the absolutely-positioned elements that are created by the drag item. */
-    zIndex?: number;
-    /** Ref that the current drag item is nested in. */
-    parentDragRef?: DragRef;
-}
-
-/** Possible values that can be used to configure the drag start delay. */
-export declare type DragStartDelay = number | {
-    touch: number;
-    mouse: number;
-};
-
-/** Possible orientations for a drop list. */
-export declare type DropListOrientation = 'horizontal' | 'vertical' | 'mixed';
-
-/**
- * Reference to a drop list. Used to manipulate or dispose of the container.
- */
-export declare class DropListRef<T = any> {
-    private _dragDropRegistry;
-    private _ngZone;
-    private _viewportRuler;
-    /** Element that the drop list is attached to. */
-    element: HTMLElement | ElementRef<HTMLElement>;
-    /** Whether starting a dragging sequence from this container is disabled. */
-    disabled: boolean;
-    /** Whether sorting items within the list is disabled. */
-    sortingDisabled: boolean;
-    /** Locks the position of the draggable elements inside the container along the specified axis. */
+    private _cachedShadowRoot;
+    /** Axis along which dragging is locked. */
     lockAxis: 'x' | 'y';
     /**
-     * Whether auto-scrolling the view when the user
-     * moves their pointer close to the edges is disabled.
+     * Amount of milliseconds to wait after the user has put their
+     * pointer down before starting to drag the element.
      */
-    autoScrollDisabled: boolean;
-    /** Number of pixels to scroll for each frame when auto-scrolling an element. */
-    autoScrollStep: number;
+    dragStartDelay: number | {
+        touch: number;
+        mouse: number;
+    };
+    /** Class to be added to the preview element. */
+    previewClass: string | string[] | undefined;
     /**
-     * Function that is used to determine whether an item
-     * is allowed to be moved into a drop container.
+     * If the parent of the dragged element has a `scale` transform, it can throw off the
+     * positioning when the user starts dragging. Use this input to notify the CDK of the scale.
      */
-    enterPredicate: (drag: DragRef, drop: DropListRef) => boolean;
-    /** Function that is used to determine whether an item can be sorted into a particular index. */
-    sortPredicate: (index: number, drag: DragRef, drop: DropListRef) => boolean;
-    /** Emits right before dragging has started. */
+    scale: number;
+    /** Whether starting to drag this element is disabled. */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _disabled;
+    /** Emits as the drag sequence is being prepared. */
     readonly beforeStarted: Subject<void>;
-    /**
-     * Emits when the user has moved a new drag item into this container.
-     */
+    /** Emits when the user starts dragging the item. */
+    readonly started: Subject<{
+        source: DragRef;
+        event: MouseEvent | TouchEvent;
+    }>;
+    /** Emits when the user has released a drag item, before any animations have started. */
+    readonly released: Subject<{
+        source: DragRef;
+        event: MouseEvent | TouchEvent;
+    }>;
+    /** Emits when the user stops dragging an item in the container. */
+    readonly ended: Subject<{
+        source: DragRef;
+        distance: Point;
+        dropPoint: Point;
+        event: MouseEvent | TouchEvent;
+    }>;
+    /** Emits when the user has moved the item into a new container. */
     readonly entered: Subject<{
-        item: DragRef;
         container: DropListRef;
+        item: DragRef;
         currentIndex: number;
     }>;
-    /**
-     * Emits when the user removes an item from the container
-     * by dragging it into another container.
-     */
+    /** Emits when the user removes the item its container by dragging it into another container. */
     readonly exited: Subject<{
-        item: DragRef;
         container: DropListRef;
+        item: DragRef;
     }>;
-    /** Emits when the user drops an item inside the container. */
+    /** Emits when the user drops the item inside a container. */
     readonly dropped: Subject<{
-        item: DragRef;
-        currentIndex: number;
         previousIndex: number;
+        currentIndex: number;
+        item: DragRef;
         container: DropListRef;
         previousContainer: DropListRef;
-        isPointerOverContainer: boolean;
         distance: Point;
         dropPoint: Point;
+        isPointerOverContainer: boolean;
         event: MouseEvent | TouchEvent;
     }>;
-    /** Emits as the user is swapping items while actively dragging. */
-    readonly sorted: Subject<{
-        previousIndex: number;
-        currentIndex: number;
-        container: DropListRef;
-        item: DragRef;
-    }>;
-    /** Emits when a dragging sequence is started in a list connected to the current one. */
-    readonly receivingStarted: Subject<{
-        receiver: DropListRef;
-        initiator: DropListRef;
-        items: DragRef[];
-    }>;
-    /** Emits when a dragging sequence is stopped from a list connected to the current one. */
-    readonly receivingStopped: Subject<{
-        receiver: DropListRef;
-        initiator: DropListRef;
+    /**
+     * Emits as the user is dragging the item. Use with caution,
+     * because this event will fire for every pixel that the user has dragged.
+     */
+    readonly moved: Observable<{
+        source: DragRef;
+        pointerPosition: {
+            x: number;
+            y: number;
+        };
+        event: MouseEvent | TouchEvent;
+        distance: Point;
+        delta: {
+            x: -1 | 0 | 1;
+            y: -1 | 0 | 1;
+        };
     }>;
-    /** Arbitrary data that can be attached to the drop list. */
+    /** Arbitrary data that can be attached to the drag item. */
     data: T;
-    /** Element that is the direct parent of the drag items. */
-    private _container;
-    /** Whether an item in the list is being dragged. */
-    private _isDragging;
-    /** Keeps track of the positions of any parent scrollable elements. */
-    private _parentPositions;
-    /** Strategy being used to sort items within the list. */
-    private _sortStrategy;
-    /** Cached `DOMRect` of the drop list. */
-    private _domRect;
-    /** Draggable items in the container. */
-    private _draggables;
-    /** Drop lists that are connected to the current one. */
-    private _siblings;
-    /** Connected siblings that currently have a dragged item. */
-    private _activeSiblings;
-    /** Subscription to the window being scrolled. */
-    private _viewportScrollSubscription;
-    /** Vertical direction in which the list is currently scrolling. */
-    private _verticalScrollDirection;
-    /** Horizontal direction in which the list is currently scrolling. */
-    private _horizontalScrollDirection;
-    /** Node that is being auto-scrolled. */
-    private _scrollNode;
-    /** Used to signal to the current auto-scroll sequence when to stop. */
-    private readonly _stopScrollTimers;
-    /** Shadow root of the current element. Necessary for `elementFromPoint` to resolve correctly. */
-    private _cachedShadowRoot;
-    /** Reference to the document. */
-    private _document;
-    /** Elements that can be scrolled while the user is dragging. */
-    private _scrollableElements;
-    /** Initial value for the element's `scroll-snap-type` style. */
-    private _initialScrollSnap;
-    /** Direction of the list's layout. */
-    private _direction;
-    constructor(element: ElementRef<HTMLElement> | HTMLElement, _dragDropRegistry: DragDropRegistry, _document: any, _ngZone: NgZone, _viewportRuler: ViewportRuler);
-    /** Removes the drop list functionality from the DOM element. */
-    dispose(): void;
-    /** Whether an item from this list is currently being dragged. */
-    isDragging(): boolean;
-    /** Starts dragging an item. */
-    start(): void;
     /**
-     * Attempts to move 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.
-     * @param index Index at which the item entered. If omitted, the container will try to figure it
-     *   out automatically.
+     * Function that can be used to customize the logic of how the position of the drag item
+     * is limited while it's being dragged. Gets called with a point containing the current position
+     * of the user's pointer on the page, a reference to the item being dragged and its dimensions.
+     * Should return a point describing where the item should be rendered.
      */
-    enter(item: DragRef, pointerX: number, pointerY: number, index?: number): void;
+    constrainPosition?: (userPointerPosition: Point, dragRef: DragRef, dimensions: DOMRect, pickupPositionInElement: Point) => Point;
+    constructor(element: ElementRef<HTMLElement> | HTMLElement, _config: DragRefConfig, _document: Document, _ngZone: NgZone, _viewportRuler: ViewportRuler, _dragDropRegistry: DragDropRegistry, _renderer: Renderer2);
     /**
-     * Removes an item from the container after it was dragged into another container by the user.
-     * @param item Item that was dragged out.
+     * Returns the element that is being used as a placeholder
+     * while the current element is being dragged.
      */
-    exit(item: DragRef): void;
+    getPlaceholderElement(): HTMLElement;
+    /** Returns the root draggable element. */
+    getRootElement(): HTMLElement;
     /**
-     * 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 previousIndex Index of the item when dragging started.
-     * @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.
-     * @param distance Distance the user has dragged since the start of the dragging sequence.
-     * @param event Event that triggered the dropping sequence.
-     *
-     * @breaking-change 15.0.0 `previousIndex` and `event` parameters to become required.
+     * Gets the currently-visible element that represents the drag item.
+     * While dragging this is the placeholder, otherwise it's the root element.
      */
-    drop(item: DragRef, currentIndex: number, previousIndex: number, previousContainer: DropListRef, isPointerOverContainer: boolean, distance: Point, dropPoint: Point, event?: MouseEvent | TouchEvent): void;
+    getVisibleElement(): HTMLElement;
+    /** Registers the handles that can be used to drag the element. */
+    withHandles(handles: (HTMLElement | ElementRef<HTMLElement>)[]): this;
     /**
-     * Sets the draggable items that are a part of this list.
-     * @param items Items that are a part of this list.
+     * Registers the template that should be used for the drag preview.
+     * @param template Template that from which to stamp out the preview.
      */
-    withItems(items: DragRef[]): this;
-    /** Sets the layout direction of the drop list. */
-    withDirection(direction: Direction): this;
+    withPreviewTemplate(template: DragPreviewTemplate | null): this;
     /**
-     * Sets the containers that are connected to this one. When two or more containers are
-     * connected, the user will be allowed to transfer items between them.
-     * @param connectedTo Other containers that the current containers should be connected to.
+     * Registers the template that should be used for the drag placeholder.
+     * @param template Template that from which to stamp out the 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;
+    /** Sets the parent ref that the ref is nested in.  */
+    withParent(parent: DragRef<unknown> | 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;
+    /**
+     * Sets a handle as disabled. While a handle is disabled, it'll capture and interrupt dragging.
+     * @param handle Handle element that should be disabled.
      */
-    connectedTo(connectedTo: DropListRef[]): this;
+    disableHandle(handle: HTMLElement): void;
     /**
-     * Sets the orientation of the container.
-     * @param orientation New orientation for the container.
+     * Enables a handle, if it has been disabled.
+     * @param handle Handle element to be enabled.
      */
-    withOrientation(orientation: DropListOrientation): this;
+    enableHandle(handle: HTMLElement): void;
+    /** Sets the layout direction of the draggable item. */
+    withDirection(direction: Direction): this;
+    /** Sets the container that the item is part of. */
+    _withDropContainer(container: DropListRef): void;
     /**
-     * Sets which parent elements are can be scrolled while the user is dragging.
-     * @param elements Elements that can be scrolled.
+     * Gets the current position in pixels the draggable outside of a drop container.
      */
-    withScrollableParents(elements: HTMLElement[]): this;
+    getFreeDragPosition(): Readonly<Point>;
     /**
-     * Configures the drop list so that a different element is used as the container for the
-     * dragged items. This is useful for the cases when one might not have control over the
-     * full DOM that sets up the dragging.
-     * Note that the alternate container needs to be a descendant of the drop list.
-     * @param container New element container to be assigned.
+     * Sets the current position in pixels the draggable outside of a drop container.
+     * @param value New position to be set.
      */
-    withElementContainer(container: HTMLElement): this;
-    /** Gets the scrollable parents that are registered with this drop container. */
-    getScrollableParents(): readonly HTMLElement[];
+    setFreeDragPosition(value: Point): this;
     /**
-     * Figures out the index of an item in the container.
-     * @param item Item whose index should be determined.
+     * Sets the container into which to insert the preview element.
+     * @param value Container into which to insert the preview.
      */
-    getItemIndex(item: DragRef): number;
+    withPreviewContainer(value: PreviewContainer): this;
+    /** Updates the item's sort order based on the last-known pointer position. */
+    _sortFromLastPointerPosition(): void;
+    /** Unsubscribes from the global subscriptions. */
+    private _removeListeners;
+    /** Destroys the preview element and its ViewRef. */
+    private _destroyPreview;
+    /** Destroys the placeholder element and its ViewRef. */
+    private _destroyPlaceholder;
+    /** Handler for the `mousedown`/`touchstart` events. */
+    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;
     /**
-     * Whether the list is able to receive the item that
-     * is currently being dragged inside a connected drop list.
+     * Clears subscriptions and stops the dragging sequence.
+     * @param event Browser event object that ended the sequence.
      */
-    isReceiving(): boolean;
+    private _endDragSequence;
+    /** Starts the dragging sequence. */
+    private _startDragSequence;
     /**
-     * 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.
+     * Sets up the different variables and subscriptions
+     * that will be necessary for the dragging sequence.
+     * @param referenceElement Element that started the drag sequence.
+     * @param event Browser event object that started the sequence.
      */
-    _sortItem(item: DragRef, pointerX: number, pointerY: number, pointerDelta: {
-        x: number;
-        y: number;
-    }): void;
+    private _initializeDragSequence;
+    /** Cleans up the DOM artifacts that were added to facilitate the element being dragged. */
+    private _cleanupDragArtifacts;
     /**
-     * Checks whether the user's pointer is close to the edges of either the
-     * viewport or the drop list and starts the auto-scroll sequence.
-     * @param pointerX User's pointer position along the x axis.
-     * @param pointerY User's pointer position along the y axis.
+     * Updates the item's position in its drop container, or moves it
+     * into a new one, depending on its current drag position.
      */
-    _startScrollingIfNecessary(pointerX: number, pointerY: number): void;
-    /** Stops any currently-running auto-scroll sequences. */
-    _stopScrolling(): void;
-    /** Starts the dragging sequence within the list. */
-    private _draggingStarted;
-    /** Caches the positions of the configured scrollable parents. */
-    private _cacheParentPositions;
-    /** Resets the container to its initial state. */
-    private _reset;
-    /** Starts the interval that'll auto-scroll the element. */
-    private _startScrollInterval;
+    private _updateActiveDropContainer;
     /**
-     * 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.
+     * Animates the preview element from its current position to the location of the drop placeholder.
+     * @returns Promise that resolves when the animation completes.
      */
-    _isOverContainer(x: number, y: number): boolean;
+    private _animatePreviewToPlaceholder;
+    /** Creates an element that will be shown instead of the current element while dragging. */
+    private _createPlaceholderElement;
     /**
-     * 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.
+     * Figures out the coordinates at which an element was picked up.
+     * @param referenceElement Element that initiated the dragging.
+     * @param event Event that initiated the dragging.
      */
-    _getSiblingContainerFromPosition(item: DragRef, x: number, y: number): DropListRef | undefined;
+    private _getPointerPositionInElement;
+    /** 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;
+    /** Updates the current drag delta, based on the user's current pointer position on the page. */
+    private _updatePointerDirectionDelta;
+    /** 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;
     /**
-     * Checks whether the drop list can receive the passed-in item.
-     * @param item Item that is being dragged into the list.
-     * @param x Position of the item along the X axis.
-     * @param y Position of the item along the Y axis.
+     * Applies a `transform` to the root element, taking into account any existing transforms on it.
+     * @param x New transform value along the X axis.
+     * @param y New transform value along the Y axis.
      */
-    _canReceive(item: DragRef, x: number, y: number): boolean;
+    private _applyRootElementTransform;
     /**
-     * Called by one of the connected drop lists when a dragging sequence has started.
-     * @param sibling Sibling in which dragging has started.
+     * Applies a `transform` to the preview, taking into account any existing transforms on it.
+     * @param x New transform value along the X axis.
+     * @param y New transform value along the Y axis.
      */
-    _startReceiving(sibling: DropListRef, items: DragRef[]): void;
+    private _applyPreviewTransform;
     /**
-     * Called by a connected drop list when dragging has stopped.
-     * @param sibling Sibling whose dragging has stopped.
+     * Gets the distance that the user has dragged during the current drag sequence.
+     * @param currentPosition Current position of the user's pointer.
      */
-    _stopReceiving(sibling: DropListRef): void;
+    private _getDragDistance;
+    /** Cleans up any cached element dimensions that we don't need after dragging has stopped. */
+    private _cleanupCachedDimensions;
     /**
-     * Starts listening to scroll events on the viewport.
-     * Used for updating the internal state of the list.
+     * Checks whether the element is still inside its boundary after the viewport has been resized.
+     * If not, the position is adjusted so that the element fits again.
      */
-    private _listenToScrollEvents;
+    private _containInsideBoundaryOnResize;
+    /** Gets the drag start delay, based on the event type. */
+    private _getDragStartDelay;
+    /** Updates the internal state of the draggable element when scrolling has occurred. */
+    private _updateOnScroll;
+    /** Gets the scroll position of the viewport. */
+    private _getViewportScrollPosition;
     /**
      * Lazily resolves and returns the shadow root of the element. We do this in a function, rather
      * than saving it in property directly on init, because we want to resolve it as late as possible
@@ -1368,51 +1278,48 @@ export declare class DropListRef<T = any> {
      * constructor might be too early if the element is inside of something like `ngFor` or `ngIf`.
      */
     private _getShadowRoot;
-    /** Notifies any siblings that may potentially receive the item. */
-    private _notifyReceivingSiblings;
-}
-
-declare namespace i1 {
-    export {
-        CdkDropList
-    }
-}
-
-declare namespace i2 {
-    export {
-        CDK_DROP_LIST_GROUP,
-        CdkDropListGroup
-    }
-}
-
-declare namespace i3 {
-    export {
-        CDK_DROP_LIST,
-        CdkDrag
-    }
-}
-
-declare namespace i4 {
-    export {
-        CDK_DRAG_HANDLE,
-        CdkDragHandle
-    }
-}
-
-declare namespace i5 {
-    export {
-        CDK_DRAG_PREVIEW,
-        CdkDragPreview
-    }
+    /** Gets the element into which the drag preview should be inserted. */
+    private _getPreviewInsertionPoint;
+    /** Lazily resolves and returns the dimensions of the preview. */
+    private _getPreviewRect;
+    /** Handles a native `dragstart` event. */
+    private _nativeDragStart;
+    /** Gets a handle that is the target of an event. */
+    private _getTargetHandle;
 }
 
-declare namespace i6 {
-    export {
-        CDK_DRAG_PLACEHOLDER,
-        CdkDragPlaceholder
-    }
+/**
+ * Service that allows for drag-and-drop functionality to be attached to DOM elements.
+ */
+declare class DragDrop {
+    private _document;
+    private _ngZone;
+    private _viewportRuler;
+    private _dragDropRegistry;
+    private _renderer;
+    constructor(...args: unknown[]);
+    /**
+     * Turns an element into a draggable item.
+     * @param element Element to which to attach the dragging functionality.
+     * @param config Object used to configure the dragging behavior.
+     */
+    createDrag<T = any>(element: ElementRef<HTMLElement> | HTMLElement, config?: DragRefConfig): DragRef<T>;
+    /**
+     * Turns an element into a drop list.
+     * @param element Element to which to attach the drop list functionality.
+     */
+    createDropList<T = any>(element: ElementRef<HTMLElement> | HTMLElement): DropListRef<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragDrop, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DragDrop>;
 }
 
+/**
+ * Injection token that can be used for a `CdkDrag` to provide itself as a parent to the
+ * drag-specific child directive (`CdkDragHandle`, `CdkDragPreview` etc.). Used primarily
+ * to avoid circular imports.
+ * @docs-private
+ */
+declare const CDK_DRAG_PARENT: InjectionToken<CdkDrag<any>>;
 
 /**
  * Moves an item one index in an array to another.
@@ -1420,28 +1327,7 @@ declare namespace i6 {
  * @param fromIndex Starting index of the item.
  * @param toIndex Index to which the item should be moved.
  */
-export declare function moveItemInArray<T = any>(array: T[], fromIndex: number, toIndex: number): void;
-
-/** Point on the page or within an element. */
-export declare interface Point {
-    x: number;
-    y: number;
-}
-
-/**
- * Possible places into which the preview of a drag item can be inserted.
- * - `global` - Preview will be inserted at the bottom of the `<body>`. The advantage is that
- * you don't have to worry about `overflow: hidden` or `z-index`, but the item won't retain
- * its inherited styles.
- * - `parent` - Preview will be inserted into the parent of the drag item. The advantage is that
- * inherited styles will be preserved, but it may be clipped by `overflow: hidden` or not be
- * visible due to `z-index`. Furthermore, the preview is going to have an effect over selectors
- * like `:nth-child` and some flexbox configurations.
- * - `ElementRef<HTMLElement> | HTMLElement` - Preview will be inserted into a specific element.
- * Same advantages and disadvantages as `parent`.
- */
-export declare type PreviewContainer = 'global' | 'parent' | ElementRef<HTMLElement> | HTMLElement;
-
+declare function moveItemInArray<T = any>(array: T[], fromIndex: number, toIndex: number): void;
 /**
  * Moves an item from one array to another.
  * @param currentArray Array from which to transfer the item.
@@ -1449,6 +1335,45 @@ export declare type PreviewContainer = 'global' | 'parent' | ElementRef<HTMLElem
  * @param currentIndex Index of the item in its current array.
  * @param targetIndex Index at which to insert the item.
  */
-export declare function transferArrayItem<T = any>(currentArray: T[], targetArray: T[], currentIndex: number, targetIndex: number): void;
+declare function transferArrayItem<T = any>(currentArray: T[], targetArray: T[], currentIndex: number, targetIndex: number): void;
+/**
+ * Copies an item from one array to another, leaving it in its
+ * original position in current array.
+ * @param currentArray Array from which to copy the item.
+ * @param targetArray Array into which is copy the item.
+ * @param currentIndex Index of the item in its current array.
+ * @param targetIndex Index at which to insert the item.
+ *
+ */
+declare function copyArrayItem<T = any>(currentArray: T[], targetArray: T[], currentIndex: number, targetIndex: number): void;
+
+/**
+ * Injection token that can be used to reference instances of `CdkDropListGroup`. It serves as
+ * alternative token to the actual `CdkDropListGroup` class which could cause unnecessary
+ * retention of the class and its directive metadata.
+ */
+declare const CDK_DROP_LIST_GROUP: InjectionToken<CdkDropListGroup<unknown>>;
+/**
+ * Declaratively connects sibling `cdkDropList` instances together. All of the `cdkDropList`
+ * elements that are placed inside a `cdkDropListGroup` will be connected to each other
+ * automatically. Can be used as an alternative to the `cdkDropListConnectedTo` input
+ * from `cdkDropList`.
+ */
+declare class CdkDropListGroup<T> implements OnDestroy {
+    /** Drop lists registered inside the group. */
+    readonly _items: Set<T>;
+    /** Whether starting a dragging sequence from inside this group is disabled. */
+    disabled: boolean;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkDropListGroup<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkDropListGroup<any>, "[cdkDropListGroup]", ["cdkDropListGroup"], { "disabled": { "alias": "cdkDropListGroupDisabled"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+declare class DragDropModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragDropModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DragDropModule, never, [typeof CdkDropList, typeof CdkDropListGroup, typeof CdkDrag, typeof CdkDragHandle, typeof CdkDragPreview, typeof CdkDragPlaceholder], [typeof CdkScrollableModule, typeof CdkDropList, typeof CdkDropListGroup, typeof CdkDrag, typeof CdkDragHandle, typeof CdkDragPreview, typeof CdkDragPlaceholder]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DragDropModule>;
+}
 
-export { }
+export { CDK_DRAG_CONFIG, CDK_DRAG_HANDLE, CDK_DRAG_PARENT, CDK_DRAG_PLACEHOLDER, CDK_DRAG_PREVIEW, CDK_DROP_LIST, CDK_DROP_LIST_GROUP, CdkDrag, type CdkDragDrop, type CdkDragEnd, type CdkDragEnter, type CdkDragExit, CdkDragHandle, type CdkDragMove, CdkDragPlaceholder, CdkDragPreview, type CdkDragRelease, type CdkDragSortEvent, type CdkDragStart, CdkDropList, CdkDropListGroup, type DragAxis, type DragConstrainPosition, DragDrop, type DragDropConfig, DragDropModule, DragDropRegistry, DragRef, type DragRefConfig, type DragStartDelay, type DropListOrientation, DropListRef, type Point, type PreviewContainer, copyArrayItem, moveItemInArray, transferArrayItem };