bm-core-ui 2.11.9-beta.2 → 2.12.0-beta.10

package/build/@types/index.d.ts

@@ -4585,9 +4585,10 @@ export class BMView {
 	 * and handle key presses. Subclasses that override this method should invoke the base implementation to allow
 	 * keyboard shortcuts to be handled correctly.
 	 * @param event 			The event that triggered this action.
+	 * @return           `YES` if a keyboard shortcut was handled, `NO` or `undefined` otherwise.
 	 *  
 	 */
-	keyPressedWithEvent(event: KeyboardEvent): void;
+	keyPressedWithEvent(event: KeyboardEvent): boolean | null | undefined;
 
 
 	/**
@@ -4612,6 +4613,20 @@ export class BMView {
 	private _disableKeyboardShortcuts(): void;
 
 
+	/**
+	 * Initiates a drag session with the specified drag delegate from a touch or mouse event.
+	 * @param event       The event that triggered the drag gesture.
+	 * @param delegate             The drag session delegate supplying items and
+	 *                                              handling events for the session.
+	 * @param touchIdentifier    If the event is a touch event and this is specified,
+	 *                                              it represents the identifier of the touch point that
+	 *                                              will be tracked throughout the drag session. If not
+	 *                                              specified, the first changed touch will be used.
+	 *     
+	 */
+	performDragWithEvent(event: MouseEvent | TouchEvent, {delegate, touchIdentifier}: {delegate: BMDragDelegate, touchIdentifier?: number | null | undefined}): void;
+
+
 	/**
 	 * An internal list of layout constraints that affect this view. This array will contain both constraints having
 	 * this view as the source view and constraints having this view as the target view. It also contains constraints
@@ -5468,41 +5483,1721 @@ export class BMTextField extends BMView {
 
 
 	/**
-	 * Constructs and returns a DOM node for a menu item with the given label.
-	 * @param label                 The text to display in the menu item.
-	 * @param action        An action that occurs when the menu item is selected.
-	 * @return                     A DOM node to be added to a menu.
+	 * Constructs and returns a DOM node for a menu item with the given label.
+	 * @param label                 The text to display in the menu item.
+	 * @param action        An action that occurs when the menu item is selected.
+	 * @return                     A DOM node to be added to a menu.
+	 *     
+	 */
+	private _menuItemWithLabel(label: string, {action}: {action: (($0: Event) => void)}): DOMNode;
+
+
+	/**
+	 * Creates and brings up a context menu at the given coordinates, relative to the viewport.
+	 * @param point                The point at which to show the menu.
+	 * @param withOptions       The options that the menu should display.
+	 * @param kind   Defaults to .Menu. The kind of menu to show.
+	 * @return                     The menu element.
+	 *     
+	 */
+	private _showMenuAtPoint(point: BMPoint, {withOptions, kind}: {withOptions: DOMNode[], kind?: BMMenuKind | null | undefined}): DOMNode;
+
+
+	/**
+	 * Constructs and returns a text field with a new DOM node.
+	 * @return         A text field.
+	 * 
+	 */
+	static textField (): BMTextField;
+
+
+	/**
+	 * Constructs and returns a text field for the given input DOM node.
+	 * @param node         An input DOM node.
+	 * @return         A text field.
+	 * 
+	 */
+	static textFieldForInputNode (node: DOMNode): BMTextField;
+
+}
+
+
+/**
+ * A list of constants describing what happens to source objects when they are transferred
+ * as part of drag session a different target than the one they were dragged from.
+ * 
+ */
+export class BMDragTransferKind {
+	/**
+	 * Indicates that the items should be moved from the source to the target. This must
+	 * be specified by both the source and the target for the movement to take place.
+	 *  
+	 */
+	static Move: BMDragTransferKind;
+
+	/**
+	 * Indicates that a copy of the items will be transferred to the target. If either the
+	 * target or the source of the transfer specifies this transfer kind, a copy is performed
+	 * regardless of the transfer kind specified by the other.
+	 *  
+	 */
+	static Copy: BMDragTransferKind;
+
+	private constructor(); 
+}
+
+/**
+ * An object that describes the action that should be performed for a drag session when it ends.
+ * 
+ */
+export class BMDragSessionAction {
+
+	/**
+	 * The action to perform at the end of the drag session.
+	 *     
+	 */
+	readonly action: BMDragSessionActionKind;
+
+	/**
+	 * The message to display on the drag indicator describing the action.
+	 *     
+	 */
+	readonly message: any;
+
+	/**
+	 * The HTML message to display on the drag indicator describing the action.
+	 *     
+	 */
+	readonly messageHTML: any;
+
+	/**
+	 * Initializes this drag action with the specified drop action kind. Optionally,
+	 * a message and an item count override may be provided.
+	 * @param action       The action to perform at the end of the drag session.
+	 * @param message            If specified, an optional message to display on the
+	 *                                              drag indicator describing the drop action.
+	 * @param messageHTML        If specified, an optional HTML message to display on the
+	 *                                              drag indicator describing the drop action. If `message` is
+	 *                                              also specified, this parameter is not used.
+	 * @return                        This drag action.
+	 *     
+	 */
+	initWithAction(action: BMDragSessionActionKind, {message, messageHTML}?: {message?: string | null | undefined, messageHTML?: string | null | undefined}): BMDragAction;
+
+
+	/**
+	 * Creates and initializes a drag action with the specified drag action kind. Optionally,
+	 * a message and an item override may be provided.
+	 * @param action   The action to perform at the end of the drag session.
+	 * @param message            If specified, an optional message to display on the
+	 *                                              drag indicator describing the drop action.
+	 * @param messageHTML        If specified, an optional HTML message to display on the
+	 *                                              drag indicator describing the drop action. If `message` is
+	 *                                              also specified, this parameter is not used.
+	 * @return                 A drag action.
+	 * 
+	 */
+	static actionWithKind (action: BMDragSessionDropActionKind, {message, messageHTML}?: {message?: string | null | undefined, messageHTML?: string | null | undefined}): BMDragSessionAction;
+
+}
+
+
+/**
+ * An object that describes the action that should be performed for a drop session when it ends.
+ * 
+ */
+export class BMDropSessionAction {
+
+	/**
+	 * The action to perform at the end of the drag session.
+	 *     
+	 */
+	readonly action: BMDragSessionActionKind;
+
+	/**
+	 * The message to display on the drag indicator describing the action.
+	 *     
+	 */
+	readonly message: any;
+
+	/**
+	 * The HTML message to display on the drag indicator describing the action.
+	 *     
+	 */
+	readonly messageHTML: any;
+
+	/**
+	 * If specified when the action is `.AcceptPartially`, the drag items that are actually acceptable.
+	 *     
+	 */
+	readonly acceptableItems: any;
+
+	/**
+	 * Initializes this drop action with the specified drop action kind. Optionally,
+	 * a message and an item count override may be provided.
+	 * @param action       The action to perform at the end of the drop session.
+	 * @param message            If specified, an optional message to display on the
+	 *                                              drag indicator describing the drop action.
+	 * @param messageHTML        If specified, an optional HTML message to display on the
+	 *                                              drag indicator describing the drop action. If `message` is
+	 *                                              also specified, this parameter is not used.
+	 * @param items        If specified, the items that are acceptable for the current drop target.
+	 *                                              Requires the `action` to be set to `.AcceptPartially` to take effect.
+	 *                                              These items must be part of the drag or drop session.
+	 * @return                        This drop action.
+	 *     
+	 */
+	initWithAction(action: BMDropSessionActionKind, {message, messageHTML, items}?: {message?: string | null | undefined, messageHTML?: string | null | undefined, items?: BMDragItem[] | null | undefined}): BMDragAction;
+
+
+	/**
+	 * Creates and initializes a drop action with the specified drop action kind. Optionally,
+	 * a message and an item override may be provided.
+	 * @param action   The action to perform at the end of the drop session.
+	 * @param message            If specified, an optional message to display on the
+	 *                                              drag indicator describing the drop action.
+	 * @param messageHTML        If specified, an optional HTML message to display on the
+	 *                                              drag indicator describing the drop action. If `message` is
+	 *                                              also specified, this parameter is not used.
+	 * @param items        If specified, the items that are acceptable for the current drop target.
+	 *                                              Requires the `action` to be set to `.AcceptPartially` to take effect.
+	 *                                              These items must be part of the drop session.
+	 * @return                 A drop action.
+	 * 
+	 */
+	static actionWithKind (action: BMDragSessionDropActionKind, {message, messageHTML, items}?: {message?: string | null | undefined, messageHTML?: string | null | undefined, items?: BMDragItem[] | null | undefined}): BMDropSessionAction;
+
+}
+
+
+/**
+ * An object that describes an in-progress drag session. Drag sessions are automatically created by
+ * views that begin drag operations and supplied to potential drop targets when the drag gesture
+ * intersects their frame.
+ * 
+ * To start a drag session, use the static `beginDragWithEvent` method, passing in the starting
+ * event and a delegate object providing the contents of the drag session.
+ * 
+ * The session can be used to obtain the items that participate in the drag gesture and to update
+ * the state and messaging presented to the user.
+ * 
+ */
+export class BMDragSession implements EventHandlerObject {
+
+	/**
+	 * The drag delegate of hte object that initiated this drag session.
+	 *     
+	 */
+	private _dragDelegate: BMDragDelegate;
+
+	/**
+	 * The view that initiated this drag session.
+	 *     
+	 */
+	private _sourceView: BMView;
+
+	/**
+	 * The items participating in this drag session.
+	 *     
+	 */
+	private readonly _items: any;
+
+	/**
+	 * An array of nodes corresponding to the previews of the items being dragged.
+	 * There may be fewer previews than items, and the preview positions in this array
+	 * correspond 
+	 *     
+	 */
+	private readonly _itemPreviews: any;
+
+	/**
+	 * The node displaying the items in this drag session.
+	 *     
+	 */
+	private _itemCountNode: DOMNode;
+
+	/**
+	 * The current drop action as specified by the source view.
+	 *     
+	 */
+	private _sourceDropAction: BMDragSessionAction;
+
+	/**
+	 * The current drop action as specified by the target view.
+	 *     
+	 */
+	private _targetDropAction?: BMDropSessionAction | null | undefined;
+
+	/**
+	 * The outcome of ending the drag session at the current position.
+	 *     
+	 */
+	private _dropAction: _BMDragDropSessionAction;
+
+	/**
+	 * The final drop action at the end of the session. This property is only accessible since the
+	 * `dragSessionWillFinish` delegate method is invoked.
+	 *     
+	 */
+	readonly action: BMDragSessionAction | BMDropSessionAction | undefined;
+
+	/**
+	 * The event that started this drag session.
+	 *     
+	 */
+	private _startEvent: MouseEvent | TouchEvent;
+
+	/**
+	 * The touch identifier tracked for this drag session if the session
+	 * was started via a touch event.
+	 *     
+	 */
+	private _touchIdentifier?: number | null | undefined;
+
+	/**
+	 * The drag delegate object.
+	 *     
+	 */
+	private _delegate: BMDragDelegate;
+
+	/**
+	 * Initializes this drag session with the specified initial mouse or touch event
+	 * and drag delegate object.
+	 * @param event       The initial event that starts this drag session.
+	 * @param dragDelegate         The drag delegate object providing information about
+	 *                                              the items in this drag session.
+	 * @param view                         The view initiating this drag session.
+	 * @param touchIdentifier    If the event is a touch event, the identifier of the
+	 *                                              touch that should be tracked for the drag session.
+	 *                                              If not specified, the first touch will be used instead.
+	 * @return                       This drag session.
+	 *     
+	 */
+	private _initWithEvent(event: MouseEvent | TouchEvent, {dragDelegate, view, touchIdentifier}: {dragDelegate: BMDragDelegate, view: BMView, touchIdentifier?: number | null | undefined}): BMDragSession;
+
+
+	/**
+	 * The current position of the drag session, relative to the viewport.
+	 *     
+	 */
+	readonly position: BMPoint;
+
+	/**
+	 * The drag indicator displaying information about the drag and drop session.
+	 *     
+	 */
+	private _dragIndicator?: _BMDragIndicator | null | undefined;
+
+	/**
+	 * The current drop target view, if any.
+	 *     
+	 */
+	private _dropTarget?: BMView | null | undefined;
+
+	/**
+	 * A map containing the views that represent valid drop targets for this session as keys
+	 * and the drop sessions that were created for each as the associated values.
+	 *     
+	 */
+	private _dropSessions: Map<BMView, BMDropSession | BMDragSession>;
+
+	/**
+	 * For touch drag sessions, an event handler used to determine when a new drop target
+	 * has been reached as the touch pointer moves over a new drop target.
+	 *     
+	 */
+	private _touchDropTargetHandler?: (($0: TouchEvent) => void) | null | undefined;
+
+	/**
+	 * A dictionary of event handlers that have been attached to the source view for which this
+	 * drag session was created.
+	 *     
+	 */
+	private _eventHandlers: Dictionary<unknown>;
+
+	/**
+	 * The preview set managing the drag previews.
+	 *     
+	 */
+	private _previewSet: _BMDragPreviewSet;
+
+	/**
+	 * An array of drop previews that can be used to customize the drop animation. This property is only
+	 * initialized at the end of the drag session if the delegate object implemented the
+	 * `dragSessionRequiresCustomDropAnimationForItems` method and returned `YES` from it when it was
+	 * invoked.
+	 *     
+	 */
+	readonly dropPreviews?: BMDropPreview[] | null | undefined;
+
+	/**
+	 * The kind of transfer that will be performed. Only set after the `dragSessionWillFinish` delegate
+	 * method returns if the outcome of the drag and drop gesture is transfer to a different view.
+	 * `undefined` in all other cases.
+	 *     
+	 */
+	readonly transferKind?: BMDragTransferKind | null | undefined;
+
+	/**
+	 * Sets up the drag previews and indicator and appropriate event handlers and starts tracking
+	 * a drag originating from the event with which this drag session was initialized.
+	 *     
+	 */
+	private _beginDrag(): void;
+
+
+	/**
+	 * Invoked when a key is pressed while this drag session is in progress.
+	 * @param event          The event.
+	 *     
+	 */
+	private _keyPressedWithEvent(event: KeyboardEvent): void;
+
+
+	/**
+	 * Invoked whenever the pointer moves while this drag session is in progress.
+	 * @param event        The event.
+	 *     
+	 */
+	private _dragDidMoveWithEvent(event: MouseEvent | TouchEvent): void;
+
+
+	/**
+	 * Invoked when the pointer is released or cancelled while this drag session is in progress.
+	 * @param event  The event.
+	 * @return                                   A promise that resolves when all associated animations finish.
+	 *     
+	 */
+	private _dragDidFinishWithEvent(event: MouseEvent | TouchEvent | KeyboardEvent): Promise<void>;
+
+
+	/**
+	 * Sets up the event handlers that are used to determine when the drag moves over one
+	 * of the valid drop targets.
+	 *     
+	 */
+	private _initDropTargetHandlers(): void;
+
+
+	/**
+	 * Removes the event handlers used to determine the drop target that have been set up for this drag session.
+	 *     
+	 */
+	private _releaseDropTargetHandlers(): void;
+
+
+	/**
+	 * An identifier for the timeout registered to update the item previews after the
+	 * drag gesture moves over a new drop target.
+	 *     
+	 */
+	private _itemPreviewsUpdateIdentifier?: number | null | undefined;
+
+	/**
+	 * Updates the drop target, invoking the appropriate method on the delegate objects.
+	 * @param target      The current drop target, or `undefined` if the drag gesture
+	 *                                      is not currently over any drop target.
+	 *     
+	 */
+	private _setDropTarget(target?: BMView | null | undefined): void;
+
+
+	/**
+	 * Updates the drop action displayed by this drag session, based on the current
+	 * source and target drop actions.
+	 *     
+	 */
+	private _updateDropAction(): void;
+
+
+	/**
+	 * Starts a drag and drop session from the specified mouse or touch event.
+	 * using a delegate to supply information about the items that are being transferred.
+	 * @param event       The event starting the drag.
+	 * @param dragDelegate         The delegate object providing information about the
+	 *                                              items being dragged.
+	 * @param view                         The view initiating this drag session.
+	 * @param touchIdentifier    If the event is a touch event, the identifier of the
+	 *                                              touch that should be tracked for the drag session.
+	 *                                              If not specified, the first touch will be used instead.
+	 * 
+	 */
+	private static _beginDragWithEvent (event: MouseEvent | TouchEvent, {dragDelegate, view, touchIdentifier}: {dragDelegate: BMDragDelegate, view: BMView, touchIdentifier?: number | null | undefined}): void;
+
+
+	/**
+	 * Sets the maximum number of additional drag previews for multi-item drag sessions that can be displayed
+	 * in addition to the drag preview of the first item. Updating this value only affects drag sessions
+	 * started after this method returns.
+	 * @param max           The new maximum number of previews to display.
+	 * 
+	 */
+	static setMaximumAdditionalDragPreviews (max: number): void;
+
+
+	/**
+	 * A map containing views that are drop targets as keys and their associated drop delegate objects as values.
+	 * 
+	 */
+	private static _dropTargets (): void;
+
+
+	/**
+	 * Registers a view as a potential drop target for future drag sessions, using the specified delegate
+	 * to handle updates to the associated drop sessions and the drop actions.
+	 * 
+	 * If the view is already registered as a drop target, this will replace the delegate handling future
+	 * drop sessions for the view with the specified object.
+	 * @param target                The view that will act as a drop target.
+	 * @param delegate     The delegate that will handle actions and events from the drop
+	 *                                      session on behalf of the target view.
+	 * 
+	 */
+	static registerDropTarget (target: BMView, {delegate}: {delegate: BMDropDelegate}): void;
+
+
+	/**
+	 * Unregisters a view as a potential drop target for future drag sessions. This has no effect on any
+	 * in-progress drop sessions which will continue using the previously registered delegate to handle
+	 * events and actions.
+	 * 
+	 * This method has no effect if the view is not registered as a drop target.
+	 * @param target                The view that was previously registered as a drop target.
+	 * 
+	 */
+	static unregisterDropTarget (target: BMView): void;
+
+}
+
+
+export class BMDropSession {
+
+	/**
+	 * The drag session managing the drag gesture for which this drop session was created.
+	 *     
+	 */
+	private _dragSession: BMDragSession;
+
+	/**
+	 * The drop delegate specifying the behaviour of the drop over this drop target.
+	 *     
+	 */
+	private _delegate: BMDropDelegate;
+
+	/**
+	 * A dictionary of event handlers that have been attached to the drop target view for which this
+	 * drop session was created.
+	 *     
+	 */
+	private _eventHandlers: Dictionary<unknown>;
+
+	/**
+	 * The current drop action.
+	 *     
+	 */
+	readonly dropAction: BMDropSessionAction;
+
+	/**
+	 * An array of drop previews that can be used to customize the drop animation. This property is only
+	 * initialized at the end of accepted drop sessions if the delegate object implemented the
+	 * `dropSessionRequiresCustomDropAnimationForItems` method and returned `YES` from it.
+	 *     
+	 */
+	readonly dropPreviews?: BMDropPreview[] | null | undefined;
+
+	/**
+	 * The kind of transfer that will be performed. Only set before the `dropSessionPerformDrop` delegate
+	 * method is invoked if the outcome of this drop session is a transfer of items into the target view.
+	 *     
+	 */
+	readonly transferKind?: BMDragTransferKind | null | undefined;
+
+	/**
+	 * Initializes this drop session with the specified drag session and the drop delegate.
+	 * @param session            The drag session associated with this drop session
+	 * @param delegate         The drop delegate used to determine the outcome of the drop.
+	 * @return                  This drop session.
+	 *     
+	 */
+	private _initWithDragSession(session: BMDragSession, {delegate}: {delegate: BMDropDelegate}): BMDropSession;
+
+
+	/**
+	 * The current position of the drag and drop gesture.
+	 *     
+	 */
+	readonly position: BMPoint;
+
+	/**
+	 * The items being transferred in the drag and drop gesture.
+	 *     
+	 */
+	readonly items: BMDragItem[];
+
+	/**
+	 * The items that have been accepted through this drop session. This property is only initialized
+	 * before the `dropSessionPerformDrop` delegate method is invoked.
+	 *     
+	 */
+	readonly dropItems?: BMDragItem[] | null | undefined;
+
+	/**
+	 * Creates and returns a drop session initialized with the specified drag session and the drop delegate.
+	 * @param session            The drag session associated with the drop session
+	 * @param delegate         The drop delegate used to determine the outcome of the drop.
+	 * @return                  A drop session.
+	 * 
+	 */
+	private static _sessionForDragSession (session: BMDragSession, {delegate}: {delegate: BMDropDelegate}): BMDropSession;
+
+}
+
+
+/**
+ * The specification of a `BMDragDelegate` object which is used to obtain information about a dragging session
+ * from the object that starts it and customize its behaviour depending on its position in the viewport.
+ * 
+ */
+export interface BMDragDelegate {
+
+	/**
+	 * Invoked at the beginning of a drag session to obtain the initial items that will be
+	 * part of the drag session.
+	 * 
+	 * The delegate object implementing this method must provide an array of drag items that
+	 * will be transferred as part of the drag session. The array must contain at least one item.
+	 * @param session        The drag session that is starting.
+	 * @return               An array of drag items that will be part of the drag session.
+	 *     
+	 */
+	dragSessionInitialItems(session: BMDragSession): BMDragItem[];
+
+
+	/**
+	 * Invoked by a drag session to obtain a preview for the specified drag item at the beginning
+	 * of a drag session. The drag session will invoke this method only for the first few items
+	 * that will be visible while the drag session is in progress.
+	 * 
+	 * Delegate objects implementing this method must provide an appropriate preview for the
+	 * specified item by returning a {@link BMDragPreview} object initialized for the specified
+	 * drag item.
+	 * @param session        The drag session for which to supply an item preview.
+	 * @param item              An item that is part of the drag session whose preview
+	 *                                      should be provided.
+	 * @return              The preview that will be displayed for the item.
+	 *     
+	 */
+	dragSessionPreviewForItem(session: BMDragSession, item: BMDragItem): BMDragPreview;
+
+
+	/**
+	 * Invoked when a drag session is about to end and there items that will not be transferred to determine if
+	 * the drag delegate wants to play a customized drop animation for the specified items which for
+	 * which drag previews are currently displayed. This method is only invoked if there is at least one item
+	 * with a preview that will not be transferred or deleted as part of the drag session.
+	 * 
+	 * Implementing and returning `YES` from this method will cause the drag session to not play the
+	 * standard drop animation for the specified items. Instead, in the `dragSessionAnimateDropWithPreviews`,
+	 * `dragSessionPerformMoveForItems` and `dragSessionPerformDelete` methods,
+	 * the drag session's `dropPreviews` property will contain an array of drag previews that can be
+	 * used to obtain a reference to the preview elements and use them to play an appropriate drop animation.
+	 * @param session        The drag session.
+	 * @param items           The items that have not been accepted for transferring or deleted.
+	 * @return                    `NO` to play the standard drop animation, or `YES` to play
+	 *                                      a customized drop animation.
+	 *     
+	 */
+	dragSessionRequiresCustomDropAnimationForItems?(session: BMDragSession, items: BMDragItem[]): boolean;
+
+
+	/**
+	 * Invoked after returning `YES` from `dragSessionRequiresCustomDropAnimationForItems` to play a drop animation
+	 * for the specified drop previews. Delegate objects implementing this method should play an appropriate drop animation
+	 * for the specified drop previews, then detach them from the document.
+	 * @param session        The drag session for which to play the drop animation.
+	 * @param previews     The drop previews that should be animated.
+	 *     
+	 */
+	dragSessionAnimateDropWithPreviews?(session: BMDragSession, previews: BMDropPreview[]): void;
+
+
+	/**
+	 * Invoked by a drag session after a drop target accepts or partially accepts the items in the session
+	 * and both this delegate and the associated drop delegate have specified that the transfer should
+	 * be a transfer of kind `.Move`.
+	 * 
+	 * Delegate objects that support moving items must implement this method and remove the specified
+	 * items that have been moved into the drop target.
+	 * @param session            The drag session through which items have been moved.
+	 * @param items               The items that have been moved into the drop target. These
+	 *                                          may be a subset of the session's items if the drop target
+	 *                                          has specified a drop action of `.AcceptPartially`.
+	 *     
+	 */
+	dragSessionPerformMoveForItems?(session: BMDragSession, items: BMDragItem[]): void;
+
+
+	/**
+	 * Invoked by a drag session if a drop occurs in a location where this delegate has specified that
+	 * the action should be to delete the items.
+	 * 
+	 * Delegate objects that support deleting items must implement this method and remove all items in
+	 * the drag session.
+	 * @param session        The drag session through which the items have been removed.
+	 *     
+	 */
+	dragSessionPerformDelete?(session: BMDragSession): void;
+
+
+	/**
+	 * Invoked by a drag session to determine if items can be transferred to other drop targets.
+	 * 
+	 * Delegate objects implementing this method should return a boolean indicating whether
+	 * transfers can be performed or not. A return value of `YES` is assumed when this method
+	 * is not implemented by the delegate object.
+	 * @param session        The drag session that will be transferring items.
+	 * @return                     `YES` if item transfer is supported, `NO` otherwise.
+	 *     
+	 */
+	dragSessionCanTransferItems?(session: BMDragSession): boolean;
+
+
+	/**
+	 * Invoked by a drag session that is about to begin from this delegate.
+	 * @param session        The drag session that is about to begin.
+	 *     
+	 */
+	dragSessionWillBegin?(session: BMDragSession): void;
+
+
+	/**
+	 * Invoked when a drag session enters the frame of the source view.
+	 * @param session        The drag session that entered the view's frame.
+	 *     
+	 */
+	dragSessionDidEnter?(session: BMDragSession): void;
+
+
+	/**
+	 * Invoked by a drag session whenever its position is updated. This method is continually
+	 * invoked as the drag position changes, even while the gesture moves outside of the
+	 * source view's frame.
+	 * Delegates implementing this method should return a drop action indicating the outcome of
+	 * dropping the items at the session's current position.
+	 * @param session            The drag session. Its position may be retrieved via
+	 *                                          the `position` property.
+	 * @return   The new action the source view would like to perform if the
+	 *                                          drop session ended at the current position, or `undefined`
+	 *                                          if the current action should be retained.
+	 *     
+	 */
+	dragSessionDidUpdate?(session: BMDragSession): BMDragSessionAction | null | undefined;
+
+
+	/**
+	 * Invoked when a drag session exits the frame of the source view.
+	 * @param session            The drag session that exited the view's frame.
+	 *     
+	 */
+	dragSessionDidExit?(session: BMDragSession): void;
+
+
+	/**
+	 * Invoked by a drag session to obtain the kind of transfer to perform for the items being dragged.
+	 * This method is invoked when the drop occurs on a drop target that accepted the transfer or whenever
+	 * a drop requests a drop action that requires a specific transfer kind.
+	 * 
+	 * Delegate objects implementing this method should return an appropriate transfer kind for
+	 * the items. When this method is not implemented, the transfer defaults to a `.Copy` transfer.
+	 * @param session        The drag session through which the item transfer was performed.
+	 * @return          The kind of transfer to perform.
+	 *     
+	 */
+	dragSessionTransferKind?(session: BMDragSession): BMDragTransferKind;
+
+
+	/**
+	 * Invoked by a drag session that is about to finish.
+	 * 
+	 * Delegate objects may optionally implement this method to perform any necessary cleanup
+	 * before the drag session ends.
+	 * @param session                            The drag session.
+	 *     
+	 */
+	dragSessionWillFinish?(session: BMDragSession): void;
+
+
+	/**
+	 * Invoked by a drag session that has finished and all associated animations have concluded.
+	 * 
+	 * Delegate objects may optionally implement this method to perform any necessary cleanup
+	 * before the drag session ends.
+	 * @param session                            The drag session.
+	 *     
+	 */
+	dragSessionDidFinish?(session: BMDragSession): void;
+
+}
+
+
+/**
+ * The specification of a `BMDropDelegate` object which is used to obtain information about
+ * whether a drag session can be accepted by potential drop targets and to customize the information
+ * presented to users as the drag moves over the drop area.
+ * 
+ */
+export interface BMDropDelegate {
+
+	/**
+	 * Invoked when a drag session starts to verify if the target view can accept the items
+	 * in the specified drop session. When returning `YES` from this method, the view will
+	 * be considered a valid drop target for the session and will receive updates when the
+	 * drag will enter the view's frame.
+	 * @param session        The drop session containing the items to be verified.
+	 * @return                    `YES` if at least one item is acceptable for dropping,
+	 *                                      `NO` otherwise.
+	 *     
+	 */
+	dropSessionCanBegin(session: BMDropSession): boolean;
+
+
+	/**
+	 * Invoked when a drop session ends while in the target view's frame. Delegate objects implementing
+	 * this method should perform the appropriate changes based on the session's drop action.
+	 * @param session        The drop session for which to perform the drop action.
+	 *     
+	 */
+	dropSessionPerformDrop(session: BMDropSession): void;
+
+
+	/**
+	 * Invoked when a drop session is about to end while in the target view's frame to determine if
+	 * the drop delegate wants to play a customized drop animation for the specified items which for
+	 * which drag previews are currently displayed. This method is only invoked if the specified drop
+	 * action is `.Accept` or `.AcceptPartially`.
+	 * 
+	 * Implementing and returning `YES` from this method will cause the drop session to not play the
+	 * standard drop animation for the specified items. Instead, in the `dropSessionPerformDrop` method,
+	 * the drop session's `dropPreviews` property will contain an array of drop previews that can be
+	 * used to obtain a reference to the preview elements and use them to play an appropriate drop animation.
+	 * @param session        The drop session.
+	 * @param items           The items that have been accepted by the drop target and which
+	 *                                      have drag previews associated with them.
+	 * @return                    `NO` to play the standard drop animation, or `YES` to play
+	 *                                      a customized drop animation.
+	 *     
+	 */
+	dropSessionRequiresCustomDropAnimationForItems?(session: BMDropSession, items: BMDragItem[]): boolean;
+
+
+	/**
+	 * Invoked by a drop session to obtain the kind of transfer to perform for the items being dragged.
+	 * This method is invoked when the drop occurs on a drop target that accepted the transfer.
+	 * Delegate objects implementing this method should return an appropriate transfer kind for
+	 * the items. When this method is not implemented, the transfer defaults to a `.Copy` transfer.
+	 * @param session        The drop session through which the item transfer was performed.
+	 * @return          The kind of transfer to perform.
+	 *     
+	 */
+	dropSessionTransferKind?(session: BMDropSession): BMDragTransferKind;
+
+
+	/**
+	 * Invoked when a drop session enters the frame of the target view.
+	 * @param session        The drop session that entered the view's frame.
+	 *     
+	 */
+	dropSessionDidEnter?(session: BMDropSession): void;
+
+
+	/**
+	 * Invoked by a drop session whenever it updates while over the target view's frame. This method
+	 * is invoked when the session enters the frame and whenever it moves.
+	 * Delegates implementing this method should return a drop action indicating the outcome of
+	 * dropping the items at the session's current position.
+	 * @param session            The drop session that updated.
+	 * @return   The new action the target view would like to perform if the
+	 *                                          drop session ended at the current position, or `undefined`
+	 *                                          if the current action should be retained.
+	 *     
+	 */
+	dropSessionDidUpdate?(session: BMDropSession): BMDropSessionAction | null | undefined;
+
+
+	/**
+	 * Invoked when a drop session exits the frame of the target view. Subsequent updates for this drop
+	 * session will no longer be provided until the drop session moves into the target view again.
+	 * @param session            The drop session that exited the view's frame.
+	 *     
+	 */
+	dropSessionDidExit?(session: BMDropSession): void;
+
+
+	/**
+	 * Invoked to notify the delegate that the specified drop session is about to finish. This is invoked for a drop
+	 * delegate that has returned `YES` from `dropSessionCanBegin` regardless of whether the drop finished
+	 * in the target view's frame or not.
+	 * @param session            The drop session that ended.
+	 *     
+	 */
+	dropSessionWillFinish?(session: BMDropSession): void;
+
+
+	/**
+	 * Invoked to notify the delegate that the specified drop session has finished. This is invoked for a drop
+	 * delegate that has returned `YES` from `dropSessionCanBegin` regardless of whether the drop finished
+	 * in the target view's frame or not.
+	 * @param session            The drop session that ended.
+	 *     
+	 */
+	dropSessionDidFinish?(session: BMDropSession): void;
+
+
+	/**
+	 * Invoked by a drop session to obtain a preview for the specified drag item while the session is in
+	 * the target view's frame.
+	 * 
+	 * Delegate objects implementing this method may provide an appropriate preview for the
+	 * specified item by returning a {@link BMDragPreview} object initialized for the specified
+	 * drag item. When this method is not implemented, or when returning `undefined`, the preview
+	 * already in use for the item will continue to be used while the session is the target view's frame.
+	 * @param session        The drop session for which to supply an item preview.
+	 * @param item              An item that is part of the drop session whose preview
+	 *                                      should be provided.
+	 * @return    If specified, the preview that will be displayed for the item.
+	 *                                      If omitted, the current preview will continue to be used.
+	 *     
+	 */
+	dropSessionPreviewForItem?(session: BMDropSession, item: BMDragItem): BMDragPreview | null | undefined;
+
+}
+
+
+/**
+ * A provider that can supply the contents of an item that is part of a drag and drop gesture
+ * in various representations.
+ * 
+ */
+export interface BMDragItem {
+
+	/**
+	 * Invoked to determine whether the contents of this drag item supports being represented
+	 * as the specified developer-defined type.
+	 * @param type              The type being checked.
+	 * @return                `YES` if the content can be represented as the specified
+	 *                                  type, `NO` otherwise.
+	 *     
+	 */
+	canConformToType(type: string): boolean;
+
+
+	/**
+	 * Invoked to obtain the representation of the contents in this drag item converted to the specified
+	 * developer-defined type. If `canConformToType` returns `YES` for that type, this method must be able
+	 * to return an object of that type.
+	 * 
+	 * Core UI may invoke this method supplying a type of `default` to obtain a representation to use for
+	 * legacy APIs. In this case, this method can return any representation, but multiple invocations of
+	 * this method with the `default` type must return the same representation.
+	 * @param type              The type of object to return.
+	 * @return                An object if the specified type representing this drag item's contents.
+	 *     
+	 */
+	itemOfType(type: string): unknown;
+
+}
+
+
+export class BMDropSessionActionKind {
+	/**
+	 * Indicates that this drag session is ignored by the drop target and should be treated
+	 * as if the items are simply dragged out of the source view.
+	 *     
+	 */
+	static Ignore: BMDropSessionActionKind;
+
+	/**
+	 * Indicates that the drop target can normally accept items from the source view but none
+	 * of the items in the current session are acceptable. Finishing the gesture over the
+	 * current drop target should cancel the gesture.
+	 *     
+	 */
+	static Reject: BMDropSessionActionKind;
+
+	/**
+	 * Indicates that the drop target can accept the items in the drag session, but dropping them
+	 * will cause the items to be deleted. Requires the source view to specify a `.Move` transfer
+	 * for this drag session, otherwise the action reverts to `.Reject`.
+	 *     
+	 */
+	static Delete: BMDropSessionActionKind;
+
+	/**
+	 * Indicates that the drop target can accept all the items in the drag session.
+	 *     
+	 */
+	static Accept: BMDropSessionActionKind;
+
+	/**
+	 * Indicates that the drop target can accept only some of the items in the drag session.
+	 * Finishing the gesture will cause the unacceptable items to be discarded.
+	 *     
+	 */
+	static AcceptPartially: BMDropSessionActionKind;
+
+	private constructor(); 
+}
+
+export class BMDragSessionActionKind {
+	/**
+	 * Indicates that dropping the items at the current location will have no additional effect.
+	 *     
+	 */
+	static Ignore: BMDragSessionActionKind;
+
+	/**
+	 * Indicates that ending the drag session at the current location will cause the items to be
+	 * deleted.
+	 *     
+	 */
+	static Delete: BMDragSessionActionKind;
+
+	/**
+	 * Indicates that dropping the items at the current location would normally cause an effect,
+	 * but that action cannot currently be performed.
+	 * Finishing the gesture over the current drop target should cancel the gesture.
+	 *     
+	 */
+	static Reject: BMDragSessionActionKind;
+
+	private constructor(); 
+}
+
+/**
+ * An object that describes the action that should be performed for a drag or drop
+ * session when it ends.
+ * 
+ */
+export class _BMDragDropSessionAction {
+
+	/**
+	 * The action to perform at the end of the drag session.
+	 *     
+	 */
+	private _action: BMDragSessionActionKind | BMDropSessionActionKind;
+
+	/**
+	 * If specified, the message text to display for this outcome.
+	 *     
+	 */
+	private _message?: string | null | undefined;
+
+	/**
+	 * If specified, the message markup to display for this outcome.
+	 *     
+	 */
+	private _messageHTML?: string | null | undefined;
+
+	/**
+	 * If specified when the action is `.AcceptPartially`, the drag items that are actually acceptable.
+	 * If omitted, the UI will not indicate which items are acceptable.
+	 *     
+	 */
+	private _acceptableItems?: BMDragItem[] | null | undefined;
+}
+
+
+/**
+ * An object that represents a preview of a drag item and is displayed during a drag session.
+ * 
+ */
+export class BMDragPreview {
+
+	/**
+	 * The drag item represented by this drag preview.
+	 *     
+	 */
+	private _dragItem: BMDragItem;
+
+	/**
+	 * Initializes this drag preview by creating a copy of the specified source node.
+	 * @param node         The source node.
+	 * @param forItem  The drag item for which a preview is created.
+	 * @return      This drag preview.
+	 *     
+	 */
+	initWithCopyOfSourceNode(node: DOMNode, {forItem}: {forItem: BMDragItem}): BMDragPreview;
+
+
+	/**
+	 * Designated initializer. Initializes this drag preview with the specified preview node
+	 * and optionally a source node.
+	 * @param node                         The node representing the preview.
+	 * @param forItem                  The drag item for which a preview is created.
+	 * @param sourceNode        If specified, the node that the drag item represents.
+	 * @return                      This drag preview.
+	 *     
+	 */
+	initWithPreviewNode(node: DOMNode, {forItem, sourceNode}: {forItem: BMDragItem, sourceNode?: DOMNode | null | undefined}): BMDragPreview;
+
+
+	/**
+	 * The source node for which a preview is generated. This is used to run an appropriate animation
+	 * from the node corresponding to the drag item when the drag session starts or finishes.
+	 * 
+	 * If the source node is not provided, a generic animation will typically play instead for the preview node.
+	 *     
+	 */
+	private _sourceNode?: DOMNode | null | undefined;
+
+	/**
+	 * The node representing the preview. This node should not be modified while a drag
+	 * session is in progress.
+	 *     
+	 */
+	readonly previewNode: DOMNode;
+
+	/**
+	 * When set to `YES`, this indicates that the preview node is an exact copy of the source node
+	 * and a transition between the preview and source node is not required.
+	 *     
+	 */
+	private _isCopyOfSourceNode: boolean;
+
+	/**
+	 * The current frame of the drag preview, before any transforms are applied.
+	 *     
+	 */
+	readonly frame: BMRect;
+
+	/**
+	 * Updates this preview's position on screen.
+	 * @param position         The new position, relative to the center of this preview's frame.
+	 *     
+	 */
+	private _setPosition(position: BMPoint): void;
+
+
+	/**
+	 * Applies the specified frame to the preview node.
+	 * @param frame         The frame to apply.
+	 *     
+	 */
+	private _applyFrame(frame: BMRect): void;
+
+
+	/**
+	 * A dictionary containing transform property names as keys and their applied values, expressed
+	 * in pixels as the value. The contents of object should not be modified while the drag session
+	 * is in progress.
+	 *     
+	 */
+	readonly transform: Dictionary<number>;
+
+	/**
+	 * Applies the transform to the preview node.
+	 * @param transform         The transform dictionary. See {@link BMDragPreview.transform}.
+	 *     
+	 */
+	private _applyTransform(transform: Dictionary<number>): void;
+
+
+	/**
+	 * The total amount of displacement to apply for this preview when rejected.
+	 *     
+	 */
+	private _rejectionDistance: number;
+
+	/**
+	 * Set to YES when this preview is displaced to indicate that it is rejected.
+	 *     
+	 */
+	private _rejected: boolean;
+
+	/**
+	 * Updates the rejection distance to the specified number of pixels. If this preview is
+	 * currently rejected, its position will be animated to the new distance.
+	 * @param distance          The number of pixels to displace this preview by when rejected.
+	 *     
+	 */
+	private _setRejectionDistance(distance: number): void;
+
+
+	/**
+	 * Set to `YES` while this preview is playing the rejection animation.
+	 *     
+	 */
+	private _rejecting: boolean;
+
+	/**
+	 * Updates the rejection state of this drag preview.
+	 * @param rejected         `YES` if this preview's item is rejected, `NO` otherwise.
+	 *     
+	 */
+	private _setRejected(rejected: boolean): void;
+
+
+	/**
+	 * Set to `YES` while this preview's frame is animating.
+	 *     
+	 */
+	private _animatingFrame: boolean;
+
+	/**
+	 * Set to `YES` after the preview node has been measured.
+	 *     
+	 */
+	private _measured: boolean;
+
+	/**
+	 * Measures the preview node and updates the frame to the measured size.
+	 *     
+	 */
+	private _measure(): void;
+
+
+	/**
+	 * Attaches this drag session preview to the document and applies its frame and transform properties.
+	 * @param position   If specified, the point at which the preview will be attached,
+	 *                                      relative to the viewport.
+	 * @param before    If specified, a node before which the preview node will be attached.
+	 * @return              An iterator that must be iterated to sync DOM reads and writes
+	 *                                      when multiple previews are attached at the same time.
+	 *     
+	 */
+	private _attachAtPosition(position?: BMPoint | null | undefined, {before}?: {before?: DOMNode | null | undefined}): Iterator<void>;
+
+
+	/**
+	 * Set to the source animation during the lift animation.
+	 *     
+	 */
+	private _animationSourceNode?: DOMNode | null | undefined;
+
+	/**
+	 * Plays the lift animation for this drag preview at the beginning of a drag session or when the associated
+	 * item is added to an in-progress drag session.
+	 * @return       A promise that resolves when the associated animation completes.
+	 *     
+	 */
+	private _performLift(): Promise<void>;
+
+
+	/**
+	 * Set to `YES` if this preview's drop animation is handled by the drop delegate.
+	 *     
+	 */
+	private _dropHandled: boolean;
+
+	/**
+	 * Plays the drop animation for this drag preview at the end of the drag session, if the current
+	 * drop target did not handle the drop animation on its own.
+	 * @return       A promise that resolves when the associated animation completes.
+	 *     
+	 */
+	private _performDrop(): Promise<void>;
+
+
+	/**
+	 * Plays the delete animation for this drag preview at the end of the drag session, if the drop
+	 * action was set to `.Delete`.
+	 * @return       A promise that resolves when the associated animation completes.
+	 *     
+	 */
+	private _performDelete(): Promise<void>;
+
+
+	/**
+	 * If specified, the preview this preview is transitioning from, while the transition
+	 * is in progress. `undefined` in all other cases.
+	 *     
+	 */
+	private _transitionPreview: BMDragPreview;
+
+	/**
+	 * A unique identifier for transitions, used to perform the appropriate cleanup at the end
+	 * of the transition only when needed.
+	 *     
+	 */
+	private _transitionUID: number;
+
+	/**
+	 * Plays a transition animation from the specified drag preview to this drag preview, when the drag
+	 * session transitions to a new drop target. Detaches the specified drag preview from the document
+	 * if different from the current one.
+	 * @param preview            The drag preview from which to play a transition.
+	 * @param fromRejectionDistance    The reject distance prior to this transition taking place.
+	 * @return                   A promise that resolves when the associated animation completes.
+	 *     
+	 */
+	private _performTransitionFromDragPreview(preview: BMDragPreview, {fromRejectionDistance}: {fromRejectionDistance: number}): Promise<void>;
+
+
+	/**
+	 * Controls whether this drag preview is detachable. Active drag previews are not detachable.
+	 *     
+	 */
+	private _detachable: boolean;
+
+	/**
+	 * Detaches this drag preview from the document and resets its transform to the values of the `_transform` property.
+	 * The preview should be reattached to the document using {@link BMDragPreview._attach} before being reused.
+	 *     
+	 */
+	private _detach(): void;
+
+
+	/**
+	 * Creates and returns a drag preview initialized by creating a copy of the specified source node.
+	 * @param node         The source node.
+	 * @param forItem  The drag item for which a preview is created.
+	 * @return      A drag preview.
+	 * 
+	 */
+	static dragPreviewWithCopyOfSourceNode (node: DOMNode, {forItem}: {forItem: BMDragItem}): BMDragPreview;
+
+
+	/**
+	 * Creates and returns a drag preview initialized with the specified preview node and optionally a source node.
+	 * @param node                         The node representing the preview.
+	 * @param forItem                  The drag item for which a preview is created.
+	 * @param sourceNode        If specified, the node that the drag item represents.
+	 * @return                      A drag preview.
+	 * 
+	 */
+	static dragPreviewWithPreviewNode (node: DOMNode, {forItem, sourceNode}: {forItem: BMDragItem, sourceNode?: DOMNode | null | undefined}): BMDragPreview;
+
+}
+
+
+/**
+ * An object that represents a preview of a drag item at the end of a drop session that can be used
+ * by the drop delegate to play an appropriate drop animation for the item. When using the drop preview
+ * to customize the drop animation, it is the responsibility of the drop delegate object to detach
+ * the drop preview at the end of the animation, unless using one of the built-in animations provided
+ * by the drop preview.
+ * 
+ * Drop previews should not be created manually. Core UI will automatically create drop previews for
+ * the appropriate items at the end of a drop session if there are items that have been accepted
+ * by the drop target.
+ * 
+ */
+export class BMDropPreview {
+
+	/**
+	 * The original drag preview from which this drop preview was created.
+	 *     
+	 */
+	private _preview: BMDragPreview;
+
+	/**
+	 * The drag item represented by this drop preview.
+	 *     
+	 */
+	readonly item: BMDragItem;
+
+	/**
+	 * Initializes this drop preview with the specified drag preview and drag item.
+	 * @param preview        The original drag preview.
+	 * @param forItem          The item represented by this preview.
+	 * @return              This drop preview.
+	 *     
+	 */
+	private _initWithDragPreview(preview: BMDragPreview, {forItem}: {forItem: BMDragItem}): BMDropPreview;
+
+
+	/**
+	 * The HTML element representing this preview.
+	 *     
+	 */
+	readonly previewNode: any;
+
+	/**
+	 * A rect that describes the current position and size of the preview node relative to the viewport.
+	 *     
+	 */
+	readonly frame: any;
+
+	/**
+	 * An object that describes the transform currently applied to the preview node. Its keys are transform
+	 * function names and its values are numbers representing the associated values. The units for the values are:
+	 *  - `deg` for rotation properties
+	 *  - `px` for translation properties
+	 *  - untyped for scale properties
+	 * 
+	 * The rotation transforms are always applied after all other transforms.
+	 *     
+	 */
+	readonly transform: any;
+
+	/**
+	 * Plays a generic drop animation for this drop preview. This method must be invoked while an animation context is active.
+	 * When the animation finishes this drag preview is detached from the document.
+	 *     
+	 */
+	performDrop(): void;
+
+
+	/**
+	 * Plays a drop animation that visually transforms this drop preview into the specified node. This method must be invoked
+	 * while an animation context is active. When the animation finishes this drag preview is detached from the document.
+	 * @param node         The node towards which to play the drop animation.
+	 *     
+	 */
+	performDropToNode(node: DOMNode): void;
+
+}
+
+
+export class _BMDragIndicatorOrientation {
+	/**
+	 * Indicates that the drag indicator should appear on the top left corner.
+	 *     
+	 */
+	static Left: _BMDragIndicatorOrientation;
+
+	/**
+	 * Indicates that the drag indicator should appear on the top right corner.
+	 *     
+	 */
+	static Right: _BMDragIndicatorOrientation;
+
+	private constructor(); 
+}
+
+/**
+ * An object that manages the indicator that appears during a drag and drop gesture.
+ * 
+ */
+export class _BMDragIndicator {
+
+	/**
+	 * The number of items that are acceptable for the current drop target. This should be equal to
+	 * or lower than the total number of items in this drag session.
+	 *     
+	 */
+	private _acceptableItemCount: number;
+
+	/**
+	 * The node containing the indicator.
+	 *     
+	 */
+	private _containerNode: DOMNode;
+
+	/**
+	 * The node displaying the item count, drop outcome and message.
+	 *     
+	 */
+	private _indicatorNode: DOMNode;
+
+	/**
+	 * The node displaying the icon associated with the current drop icon.
+	 *     
+	 */
+	private _iconNode: DOMNode;
+
+	/**
+	 * The HTML element representing the message displayed to the user.
+	 *     
+	 */
+	private _messageNode: DOMNode;
+
+	/**
+	 * The HTML element used to measure the message text.
+	 *     
+	 */
+	private _messageMeasurementNode: DOMNode;
+
+	/**
+	 * The message text currently displayed on the drag indicator.
+	 *     
+	 */
+	private _message?: string | null | undefined;
+
+	/**
+	 * The message HTML markup currently displayed on the drag indicator.
+	 *     
+	 */
+	private _message?: string | null | undefined;
+
+	/**
+	 * The kind of action displayed on the indicator.
+	 *     
+	 */
+	private _dropActionKind: BMDragSessionActionKind | BMDropSessionActionKind;
+
+	/**
+	 * Initializes this drag indicator and attaches it to the document.
+	 * @return            This drag indicator.
+	 *     
+	 */
+	init(): _BMDragIndicator;
+
+
+	/**
+	 * Updates the contents of this drag indicator using the details of the specified
+	 * drag or drop action.
+	 * @param action        The action.
+	 *     
+	 */
+	setAction(action: BMDragSessionAction | BMDropSessionAction): void;
+
+
+	/**
+	 * The offset between the drag pointer and the center of this drag indicator.
+	 *     
+	 */
+	private _offset: BMPoint;
+
+	/**
+	 * The unique sequence identifier of the current offset animation.
+	 *     
+	 */
+	private _offsetAnimationID: number;
+
+	/**
+	 * Updates the offset of the indicator from the pointer's position.
+	 * @param offset               The new offset to use.
+	 * @param animated  Defaults to `NO`. When set to `YES` this change will be
+	 *                                      animated, otherwise it will be instant.
+	 *     
+	 */
+	setOffset(offset: BMPoint, {animated}?: {animated?: boolean | null | undefined}): void;
+
+
+	/**
+	 * The current position of the drag session, relative to the viewport.
+	 *     
+	 */
+	private _position: BMPoint;
+
+	/**
+	 * Updates the position of the drag gesture and all the drag previews.
+	 * @param position         The new position.
+	 *     
+	 */
+	setPosition(position: BMPoint): void;
+
+
+	/**
+	 * Updates the drop action displayed on the drag indicator.
+	 * @param action      The new drop action to display.
+	 *     
+	 */
+	private _setDropActionKind(action: _BMDragDropSessionAction): void;
+
+
+	/**
+	 * Updates the item count displayed on the drag indicator.
+	 * @param count         The new item count to display.
+	 *     
+	 */
+	setAcceptableItemCount(count: number): void;
+
+
+	/**
+	 * Updates the message currently displayed on the drag indicator.
+	 * @param message     The message to display, or `undefined` to not show any message.
+	 *     
+	 */
+	private _setMessage(message?: string | null | undefined): void;
+
+
+	/**
+	 * Updates the message currently displayed on the drag indicator using the specified HTML text.
+	 * @param message     The message HTML to display, or `undefined` to not show any message.
+	 *     
+	 */
+	private _setMessageHTML(message?: string | null | undefined): void;
+
+
+	/**
+	 * Plays the lift animation for this drag indicator.
+	 * @return           A promise that resolves when the animation completes.
+	 *     
+	 */
+	performLift(): Promise<void>;
+
+
+	/**
+	 * Plays the drop animation for this drag indicator.
+	 * @return       A promise that resolves when the animation completes.
+	 *     
+	 */
+	performDrop(): Promise<void>;
+
+
+	/**
+	 * Detaches this drag indicator from the document.
+	 * The drag indicator should not be reused after this method returns.
+	 *     
+	 */
+	release(): void;
+
+}
+
+
+/**
+ * An object that manages the appearance, position and animations of the preview elements
+ * for items included in a drag session and the drag indicator.
+ * 
+ */
+export class _BMDragPreviewSet {
+
+	/**
+	 * The offset between the drag pointer and the center the from of the view from which the drag session
+	 * started, expressed in percentages relative to the view's frame.
+	 *     
+	 */
+	private _offsetPercent: BMPoint;
+
+	/**
+	 * The offset between the drag pointer and the center of the frames of the preview elements.
+	 *     
+	 */
+	private _offset: BMPoint;
+
+	/**
+	 * The current position of the drag session.
+	 *     
+	 */
+	private _position: BMPoint;
+
+	/**
+	 * The indicator displaying information about the associated drag session.
+	 *     
+	 */
+	private _dragIndicator: _BMDragIndicator;
+
+	/**
+	 * A mapping between drag items and their associated drag previews.
+	 *     
+	 */
+	private _dragPreviews: Map<BMDragItem, BMDragPreview>;
+
+	/**
+	 * A mapping between drag items and the drag previews provided initially for each.
+	 *     
+	 */
+	private _baseDragPreviews: Map<BMDragItem, BMDragPreview>;
+
+	/**
+	 * A set that controls which items appear as rejected.
+	 *     
+	 */
+	private _rejectedItems: Set<BMDragItem>;
+
+	/**
+	 * The total displacement to apply to rejected previews.
+	 *     
+	 */
+	private _rejectionDistance: number;
+
+	/**
+	 * Initializes this drag preview set with the specified item previews and offset position.
+	 * @param previews             The previews for items in the drag session.
+	 * @param pointerOffset               The offset between the drag pointer and the
+	 *                                              center of the frames of the view from which the
+	 *                                              drag session started.
+	 * @return                   This preview set.
+	 *     
+	 */
+	initWithPreviews(previews: BMDragPreview[], {pointerOffset}: {pointerOffset: BMPoint}): _BMDragPreviewSet;
+
+
+	/**
+	 * An additional preview to display when all items are rejected.
+	 *     
+	 */
+	private _additionalPreview?: BMDragPreview | null | undefined;
+
+	/**
+	 * Displays the specified additional preview, or clears it.
+	 * @param preview      The additional preview to display, or `undefined` to
+	 *                                              clear the additional preview.
+	 *     
+	 */
+	setAdditionalPreview(preview?: BMDragPreview | null | undefined): void;
+
+
+	/**
+	 * Updates the position of the drag gesture and all the drag previews.
+	 * @param position         The new position.
+	 *     
+	 */
+	setPosition(position: BMPoint): void;
+
+
+	/**
+	 * Causes the previews for the specified items to appear as rejected. All other items will
+	 * appear as acceptable even if they had been previously set as rejected using this method.
+	 * @param items         The items that should appear as rejected,
+	 *                                              or `undefined` to clear the rejected items. 
+	 *     
+	 */
+	setRejectedItems(items?: BMDragItem[] | null | undefined): void;
+
+
+	/**
+	 * Attaches the drag previews and plays their lift animations.
+	 * @param position         The position of the drag session.
+	 *     
+	 */
+	beginLiftAtPosition(position: BMPoint): void;
+
+
+	/**
+	 * Updates or resets the previews for the specified items using a map.
+	 * @param previews     The drag previews to use, or `undefined` to reset it for each item.
+	 *     
+	 */
+	updatePreviewsWithMap(previews: Map<BMDragItem, BMDragPreview | undefined>): void;
+
+
+	/**
+	 * Determines the rejection distance based on the size of all current previews.
+	 *     
+	 */
+	private _updateRejectionDistance(): void;
+
+
+	/**
+	 * The orientation of the drag indicator relative to the top edge of the drag previews.
+	 *     
+	 */
+	private readonly _indicatorOrientation: any;
+
+	/**
+	 * Updates the orientation of the drag indicator. If the orientation changes as a result
+	 * of this method, the change will be animated.
+	 * @param orientation      The new orientation to use.
 	 *     
 	 */
-	private _menuItemWithLabel(label: string, {action}: {action: (($0: Event) => void)}): DOMNode;
+	private _setIndicatorOrientation(orientation: _BMDragIndicatorOrientation): void;
 
 
 	/**
-	 * Creates and brings up a context menu at the given coordinates, relative to the viewport.
-	 * @param point                The point at which to show the menu.
-	 * @param withOptions       The options that the menu should display.
-	 * @param kind   Defaults to .Menu. The kind of menu to show.
-	 * @return                     The menu element.
+	 * The offset the indicator would use if the orientation was set to `.Right`.
 	 *     
 	 */
-	private _showMenuAtPoint(point: BMPoint, {withOptions, kind}: {withOptions: DOMNode[], kind?: BMMenuKind | null | undefined}): DOMNode;
-
+	private _indicatorOffsetRight: number;
 
 	/**
-	 * Constructs and returns a text field with a new DOM node.
-	 * @return         A text field.
-	 * 
+	 * Updates the drag indicator offset from the drag session's position based on the size
+	 * and scale of the first displayed item preview.
+	 * The offset for the indicator is set such that it will appear to the top left of
+	 * the first preview.
+	 * @param animated           Defaults to `YES`. Whether this change is animated.
+	 *     
 	 */
-	static textField (): BMTextField;
+	private _updateDragIndicatorOffsetAnimated(animated?: boolean | null | undefined): void;
 
 
 	/**
-	 * Constructs and returns a text field for the given input DOM node.
-	 * @param node         An input DOM node.
-	 * @return         A text field.
-	 * 
+	 * Plays the drop animation for the current drag previews, then detaches them.
+	 *     
 	 */
-	static textFieldForInputNode (node: DOMNode): BMTextField;
+	performDrop(): void;
 
 }
 
@@ -8296,6 +9991,13 @@ export class BMMenu {
 	 */
 	_delaysClosing: boolean;
 
+	/**
+	 * When set to `YES`, the menu item actions and item selection delegate callbacks will be invoked
+	 * with a slight delay to allow time for the menu closing animation to play.
+	 *     
+	 */
+	delaysActions: boolean;
+
 	/**
 	 * Initializes this menu with the specified items.
 	 * The menu will be hidden by default; the method showAtPoint(_) should be used to make the menu visible.
@@ -8332,6 +10034,20 @@ export class BMMenu {
 	private _renderMenuItems(): void;
 
 
+	/**
+	 * Temporarily set to the menu item that was selected until its action is performed.
+	 *     
+	 */
+	private _selectedMenuItem?: BMMenuItem | null | undefined;
+
+	/**
+	 * Performs the action for the specified menu item and invokes the delegate selection callback for it.
+	 * @param item          The menu item whose action should be performed.
+	 *     
+	 */
+	private _performActionForMenuItem(item: BMMenuItem): void;
+
+
 	/**
 	 * The kind of menu currently displayed.
 	 *     
@@ -8454,7 +10170,7 @@ export class BMMenu {
 	 * @param forKeyboardShortcut      The keyboard shortcut that was triggered.
 	 *     
 	 */
-	private _selectMenuItemWithEvent(event: KeyboardEvent, {forKeyboardShortcut}: {forKeyboardShortcut: BMKeyboardShortcut}): void;
+	protected _selectMenuItemWithEvent(event: KeyboardEvent, {forKeyboardShortcut}: {forKeyboardShortcut: BMKeyboardShortcut}): void;
 
 
 	/**
@@ -10055,6 +11771,19 @@ export class BMCollectionViewLayoutInvalidationContext {
  */
 export class BMCollectionViewTransitionLayout extends BMCollectionViewLayout {
 
+	/**
+	 * When set to `YES` this transition layout will no longer perform updates.
+	 *     
+	 */
+	private _transitionStopped: boolean;
+
+	/**
+	 * Stops the current transition in its tracks, instantly setting the final attributes on all cells.
+	 *     
+	 */
+	private _stopTransition(): void;
+
+
 	/**
 	 * Controls how close to completion the transition is.
 	 *  
@@ -10557,6 +12286,12 @@ export class BMCollectionViewFlowLayout extends BMCollectionViewLayout {
 	 */
 	pinsFootersToContentEdge: boolean;
 
+	/**
+	 * Set to `YES` while the current layout is using scrollbar offsets, `NO` otherwise.
+	 *  
+	 */
+	private _usingScrollbarOffset: boolean;
+
 	/**
 	 * Prepares the layout, optionally taking the scrollbar size into account.
 	 * @param useOffset 			When set to `YES` the layout will take the scrollbar size into account.
@@ -11221,6 +12956,41 @@ export class BMCollectionViewAcceptPolicy {
 	private constructor(); 
 }
 
+export class BMCollectionViewAcceptRegion {
+	/**
+	 * Indicates that the drop session will have the same drop action regardless of where
+	 * in the collection view's frame it is.
+	 *  
+	 */
+	static Anywhere: BMCollectionViewAcceptRegion;
+
+	/**
+	 * Indicates that the drop session's drop action changes based on the cell in which the
+	 * drop occurs. Drops outside of any cell's frame are rejected. The delegate object is
+	 * expected to implement the {@link BMCollectionViewDelegate.collectionViewDropSessionDidEnterCell} method
+	 * provide the appropriate drop action for each cell.
+	 *  
+	 */
+	static Cell: BMCollectionViewAcceptRegion;
+
+	/**
+	 * Indicates the drop session's drop action depends on the specific position in which the drop occurs.
+	 * The delegate object is expected to implement the {@link BMCollectionViewDelegate.collectionViewDropSessionDidUpdate}
+	 * method to provide the appropriate action as the drop session's position updates.
+	 *  
+	 */
+	static Position: BMCollectionViewAcceptRegion;
+
+	/**
+	 * Indicates that the collection view cannot process the session's items and no further updates will
+	 * be provided regarding this drop session.
+	 *  
+	 */
+	static Nowhere: BMCollectionViewAcceptRegion;
+
+	private constructor(); 
+}
+
 
 
 /**
@@ -11319,7 +13089,7 @@ export class BMCollectionViewScrollingDirection {
 }
 
 /**
- * Controls the final horizontal scrolling position of a programatic scroll.
+ * Controls the final horizontal scrolling position of a programmatic scroll.
  * 
  */
 export class BMCollectionViewScrollingGravityHorizontal {
@@ -11345,7 +13115,7 @@ export class BMCollectionViewScrollingGravityHorizontal {
 }
 
 /**
- * Controls the final vertical scrolling position of a programatic scroll.
+ * Controls the final vertical scrolling position of a programmatic scroll.
  * 
  */
 export class BMCollectionViewScrollingGravityVertical {
@@ -11396,7 +13166,7 @@ export class BMCollectionViewScrollingGravityVertical {
  * 
  * 
  */
-export class BMCollectionView<T = any> extends BMView {
+export class BMCollectionView<T = any> extends BMView implements BMDragDelegate, BMDropDelegate {
 
 	/**
 	 * The last measured intrinsic size for this collection view.
@@ -12087,10 +13857,138 @@ export class BMCollectionView<T = any> extends BMView {
 	 * @param items 							An array of items.
 	 * @param toIndexPath 					The suggested index path at which to add the items.
 	 * @param withDropShadows 	A map containing the link between drop shadows and the items.
+	 * @return 								A promise that resolves when the associated data update
+	 * 														has completed.
+	 *  
+	 */
+	private _insertItems(items: any[], {toIndexPath, withDropShadows}: {toIndexPath: BMIndexPath<T>, withDropShadows: Map<any, DOMNode>}): Promise<void>;
+
+
+	/**
+	 * An array containing the cells whose index paths are part of the current drag session, or
+	 * `undefined` while there is no drag session in progress for this collection view.
+	 *  
+	 */
+	private _draggingCells?: BMCollectionViewCell[] | null | undefined;
+
+	/**
+	 * A map that keeps track of the association between drag items in a drag session and the cells
+	 * whose items they represent.
+	 *  
+	 */
+	private _cellItemMap: Map<BMDragItem, BMCollectionViewCell>;
+
+	/**
+	 * Begins a drag gesture from the specified event. The drag event will move the cell from which
+	 * the event originates, or all selected cells if that cell is selected.
+	 * @param event 						The event triggering this action.
+	 * @param forCell 	The cell from which this event originates.
+	 * @param touchIdentifier 		If this event is a `TouchEvent`, this represents the identifier
+	 * 											of the touch point that will control this drag & drop operation.
+	 *  
+	 */
+	beginDragWithEvent(event: Event, {forCell, touchIdentifier}: {forCell: BMCollectionViewCell, touchIdentifier: any}): void;
+
+
+	/**
+	 * Creates and returns a fallback drag item for the specified index path if the data source
+	 * object cannot provide a customized drag item.
+	 * @param indexPath 		The index path for which to return a drag item.
+	 * @return 					A drag item;
+	 *  
+	 */
+	private _defaultDragItemForIndexPath(indexPath: BMIndexPath): BMDragItem;
+
+
+	/**
+	 * The current drag action to use based on the current drag position.
+	 *  
+	 */
+	private _dragAction?: BMDragSessionAction | null | undefined;
+
+	/**
+	 * Set to `YES` while a drag session started by this collection view is in its frame.
+	 *  
+	 */
+	private _dragSessionInFrame: boolean;
+
+	/**
+	 * The amount by which to scroll on the Y axis during the current drag session.
+	 *  
+	 */
+	private _dragScrollDirectionY: number;
+
+	/**
+	 * The amount by which to scroll on the X axis during the current drag session.
+	 *  
+	 */
+	private _dragScrollDirectionX: number;
+
+	/**
+	 * Whenever the pointer moves to the edges of this collection view during a drag session,
+	 * this method periodically scrolls the collection view's contents appropriately.
+	 *  
+	 */
+	private _dragScroll(): void;
+
+
+	/**
+	 * The identifier of the animation frame callback used to scroll this collection during a drag session while the
+	 * mouse pointer 
+	 *  
+	 */
+	private _scrollFrameIdentifier?: number | null | undefined;
+
+	/**
+	 * The kind of region being tracked during a drop session. `undefined` if a drop session is
+	 * not in progress.
+	 *  
+	 */
+	private _dropSessionRegionKind?: BMCollectionViewAcceptRegion | null | undefined;
+
+	/**
+	 * The current drop action to use based on the current drop session position.
+	 *  
+	 */
+	private _dropAction?: BMDropSessionAction | null | undefined;
+
+	/**
+	 * The index path associated with the current drop session, if any.
+	 *  
+	 */
+	private _dropIndexPath?: BMIndexPath | null | undefined;
+
+	/**
+	 * Returns the position of the specified drag or drop session relative to the collection view's bounds.
+	 * @param session 		The drag or drop session.
+	 * @return 									The coordinates relative to the bounds.
+	 *  
+	 */
+	positionOfDragSession(session: BMDragSession | BMDropSession): BMPoint;
+
+
+	/**
+	 * Determines the index path at the specified point whose coordinates are relative to the bounds.
+	 * @param point 					The point.
+	 * @return 			The index path, if any cell's frame intersects the point,
+	 * 											or `undefined` otherwise.
+	 *  
+	 */
+	indexPathAtPoint(point: BMPoint): BMIndexPath | null | undefined;
+
+
+	/**
+	 * The most recent index path the current drop session has been over.
 	 *  
 	 */
-	private _insertItems(items: any[], {toIndexPath, withDropShadows}: {toIndexPath: BMIndexPath<T>, withDropShadows: Map<any, DOMNode>}): void;
+	private _lastDropIndexPath: BMIndexPath;
 
+	/**
+	 * The drop previews that must be animated at the end of a successful drop session. Only set while performing
+	 * the data update associated with accepting items via a drop session.
+	 *  
+	 */
+	private _dropPreviews?: BMDropPreview[] | null | undefined;
 
 	/**
 	 * Begins a drag gesture from the given event. The drag event will move the cell from which
@@ -12101,7 +13999,7 @@ export class BMCollectionView<T = any> extends BMView {
 	 * 											of the touch point that will control this drag & drop operation.
 	 *  
 	 */
-	beginDragWithEvent(event: Event, {forCell, touchIdentifier}: {forCell: BMCollectionViewCell, touchIdentifier: any}): void;
+	private _beginDragWithEvent(event: Event, {forCell, touchIdentifier}: {forCell: BMCollectionViewCell, touchIdentifier: any}): void;
 
 
 	/**
@@ -12300,7 +14198,7 @@ export class BMCollectionView<T = any> extends BMView {
 	 * Invoked when an arrow is pressed while this collection view has keyboard focus.
 	 * Highlights the index path to the specified direction of the currently highlighted index path.
 	 * @param arrow 				The key code of the keyboard arrow that was pressed.
-	 * @param withEvent 	The event that triggerred this action.
+	 * @param withEvent 	The event that triggered this action.
 	 *  
 	 */
 	keyboardArrowPressed(arrow: string, {withEvent}: {withEvent: KeyboardEvent}): void;
@@ -12364,6 +14262,14 @@ export class BMCollectionView<T = any> extends BMView {
 	setLayout(layout: BMCollectionViewLayout, {animated, completionHandler}?: {animated?: boolean | null | undefined, completionHandler?: (() => void) | null | undefined}): void;
 
 
+	/**
+	 * If a layout transition is currently in progress it is stopped, allowing data updates to
+	 * start without affecting the retained cells.
+	 *  
+	 */
+	private _stopLayoutTransition(): void;
+
+
 	/**
 	 * Invoked internally by CoreUI to perform a batched update of layout properties.
 	 * Using this method requires the layout object used by this collection view to support copying.
@@ -12436,6 +14342,20 @@ export class BMCollectionView<T = any> extends BMView {
 	 */
 	readonly dataUpdated?: Promise<void> | null | undefined;
 
+	/**
+	 * Finds and returns the drop preview associated with the specified layout attributes, if any exists.
+	 * @param attributes 		Tha attributes for which to find the drop preview.
+	 * @param previewMap 
+	 * 															An optional mapping between index paths and drop items
+	 * 															used to find the drop preview for the item representation
+	 * 															that the data set actually inserted. The default item
+	 * 															representation will be used if this is not provided.
+	 * @return 						The drop preview if it was found, `undefined` otherwise.
+	 *  
+	 */
+	private _dropPreviewForLayoutAttributes(attributes: BMCollectionViewLayoutAttributes, {previewMap}?: {previewMap?: Map<BMIndexPath<T>, BMDropPreview> | null | undefined}): BMDropPreview | null | undefined;
+
+
 	/**
 	 * Should be invoked when the entire data set is updated in bulk.
 	 * This method should be invoked when the data set object has access to the new data;
@@ -12636,6 +14556,14 @@ export class BMCollectionView<T = any> extends BMView {
 }
 
 
+/**
+ * Cleans up the changes performed by the current transition.
+ * 	 
+ */
+export function cleanupTransition(): void;
+
+
+
 /**
  * @deprecated - Use the static `collectionViewForNode` factory method.
  * 
@@ -12817,11 +14745,12 @@ export interface BMCollectionViewDataSet<T = any> {
 	 * For collection views that support moving items, this method must be implemented by the data sets these collection views
 	 * use. In this case, data sets that don't support moving items may simply return `NO` from this method.
 	 * @param indexPath 			The item's current index path.
-	 * @param toIndexPath 		The index path to which the item should move.
-	 * @return 						`YES` if the data set has performed the requested change, `NO` otherwise.
+	 * @param toIndexPath 			The index path to which the item should move.
+	 * @param session 				The drag session through which this change was performed.
+	 * @return 							`YES` if the data set has performed the requested change, `NO` otherwise.
 	 *  
 	 */
-	moveItemFromIndexPath?(indexPath: BMIndexPath<T>, {toIndexPath}: {toIndexPath: BMIndexPath<T>}): boolean;
+	moveItemFromIndexPath?(indexPath: BMIndexPath<T>, {toIndexPath, session}: {toIndexPath: BMIndexPath<T>, session: BMDragSession}): boolean;
 
 
 	/**
@@ -12835,14 +14764,15 @@ export interface BMCollectionViewDataSet<T = any> {
 	 * `moveItemFromIndexPath(_, {toIndexPath})` passing in each of the items that need to be moved.
 	 * @param indexPaths 		An array of index paths identifying which items have to be moved.
 	 * @param toIndexPath 		The starting index path to which the items should move. This represents the index path of the current layout
-	 * 											before any items may have moved. It is the data set's responsability to adjust this index path as the items shift
+	 * 											before any items may have moved. It is the data set's responsibility to adjust this index path as the items shift
 	 * 											within its data structure.
-	 * @return 					An array of index paths specifying the positions of the items after they have been moved.
+	 * @param session 			The drag session through which this change was performed.
+	 * @return 				An array of index paths specifying the positions of the items after they have been moved.
 	 * 											The index paths in this array are not required to match either of the lists supplied by
-	 * 											collection view.
+	 * 										collection view.
 	 *  
 	 */
-	moveItemsFromIndexPaths?(indexPaths: BMIndexPath<T>[], {toIndexPath}: {toIndexPath: BMIndexPath<T>}): BMIndexPath<T>[];
+	moveItemsFromIndexPaths?(indexPaths: BMIndexPath<T>[], {toIndexPath, session}: {toIndexPath: BMIndexPath<T>, session: BMDragSession}): BMIndexPath<T>[];
 
 
 	/**
@@ -12852,10 +14782,12 @@ export interface BMCollectionViewDataSet<T = any> {
 	 * Optionally, data sets may reject the change and not perform any action or only partially accept the update
 	 * and remove just some of the items, by changing their internal data structures appropriately.
 	 * The order of the items in the array is guaranteed to be such that the target index paths are in ascending order.
-	 * @param indexPaths 		An array of index paths identifying which items have to be removed.
+	 * @param indexPaths 			An array of index paths identifying which items have to be removed.
+	 * @param session 	The drag session through which this change was performed, if it occurred
+	 * 												through a drag and drop gesture.
 	 *  
 	 */
-	removeItemsAtIndexPaths?(indexPaths: BMIndexPath<T>[]): void;
+	removeItemsAtIndexPaths?(indexPaths: BMIndexPath<T>[], {session}?: {session?: BMDragSession | null | undefined}): void;
 
 
 	/**
@@ -12864,14 +14796,49 @@ export interface BMCollectionViewDataSet<T = any> {
 	 * the items, then trigger a data update to run on the collection view.
 	 * Optionally, data sets may reject the change and not perform any action or only partially accept the update
 	 * and add just some of the items, by changing their internal data structures appropriately.
-	 * @param items 					An array of objects to add to the collection view.
-	 * @param toIndexPath 		The starting index path to which the items should be inserted.
+	 * @param items 								An array of objects to add to the collection view, using the default representation
+	 * 															of the items in the drop session. Additional representations, if needed, can be obtained
+	 * 															from the drop session.
+	 * @param toIndexPath 						The starting index path to which the items should be inserted.
+	 * @param session 				The drop session through which this change was performed, if it occurred
+	 * 															through a drag and drop gesture.
+	 * @return 							An optional promise that resolves when data has updated, if it cannot be updated synchronously.
+	 *  
+	 */
+	insertItems?(items: any[], {toIndexPath, session}: {toIndexPath: BMIndexPath<T>, session?: BMDropSession | null | undefined}): Promise<void> | void;
+
+
+	/**
+	 * Invoked by collection after a successful transfer via a drop session to determine the index path associated
+	 * with the specified drag item during the associated data update. Data set objects which implement this method
+	 * should return the index path associated with the appropriate representation of the specified drag item that
+	 * was accepted through the drop session.
+	 * @param item 						The drag item for which to obtain the associated index path.
+	 * @return 			The associated index path if it could be determined, `undefined` otherwise.
+	 *  
+	 */
+	indexPathForDragItem?(item: BMDragItem): BMIndexPath<T> | null | undefined;
+
+
+	/**
+	 * This method should be implemented by data set objects that support transferring items via drag and drop
+	 * to create the drag items that will be part of a drag session.
+	 * 
+	 * Data set objects implementing this method should return a drag item for the specified index path with
+	 * the appropriate representations that potential drop targets can verify to determine if they can accept
+	 * the items being transferred through the session.
+	 * @param indexPath 		The index path for which to create a drag item.
+	 * @param session 			The drag session that will be used to transfer the items.
+	 * @return 						The drag item.
 	 *  
 	 */
-	insertItems?(items: any[], {toIndexPath}: {toIndexPath: BMIndexPath<T>}): void;
+	dragItemForIndexPath?(indexPath: BMIndexPath<T>, {session}: {session: BMDragSession}): BMDragItem;
 
 
 	/**
+	 * @deprecated Not used if `dragItemForIndexPath` is implemented.
+	 * 
+	 * ------
 	 * This method may be implemented by data set objects that support transferring items to another collection view.
 	 * Data set objects implementing this method are expected to create a copy of the specified item and return it.
 	 * The item is guaranteed to be an object that was returned at some point by the data set when it provided an index path.
@@ -13006,10 +14973,11 @@ export interface BMCollectionViewDataSource<T = any> {
 	 * @param collectionView          The collection view that is moving the item.
 	 * @param indexPath 			    The item's current index path.
 	 * @param toIndexPath 		        The index path to which the item should move.
+	 * @param session 					The drag session through which this change was performed.
 	 * @return 						        `YES` if the data set has performed the requested change, `NO` otherwise.
 	 *  
 	 */
-	collectionViewMoveItemFromIndexPath?(collectionView: BMCollectionView, indexPath: BMIndexPath<T>, {toIndexPath}: {toIndexPath: BMIndexPath<T>}): boolean;
+	collectionViewMoveItemFromIndexPath?(collectionView: BMCollectionView, indexPath: BMIndexPath<T>, {toIndexPath, session}: {toIndexPath: BMIndexPath<T>, session: BMDragSession}): boolean;
 
 
 	/**
@@ -13026,12 +14994,13 @@ export interface BMCollectionViewDataSource<T = any> {
 	 * @param toIndexPath 		    The starting index path to which the items should move. This represents the index path of the current layout
 	 * 											    before any items may have moved. It is the data source's responsibility to adjust this index path as the items shift
 	 * 											    within its data structure.
+	 * @param session 				The drag session through which this change was performed.
 	 * @return 					An array of index paths specifying the positions of the items after they have been moved.
 	 * 											    The index paths in this array are not required to match either of the lists supplied by
 	 * 											collection view.
 	 *  
 	 */
-	collectionViewMoveItemsFromIndexPaths?(collectionView: BMCollectionView, indexPaths: BMIndexPath<T>[], {toIndexPath}: {toIndexPath: BMIndexPath<T>}): BMIndexPath<T>[];
+	collectionViewMoveItemsFromIndexPaths?(collectionView: BMCollectionView, indexPaths: BMIndexPath<T>[], {toIndexPath, session}: {toIndexPath: BMIndexPath<T>, session: BMDragSession}): BMIndexPath<T>[];
 
 
 	/**
@@ -13043,9 +15012,11 @@ export interface BMCollectionViewDataSource<T = any> {
 	 * The order of the items in the array is guaranteed to be such that the target index paths are in ascending order.
 	 * @param collectionView      The collection view that is removing the items.
 	 * @param indexPaths 		    An array of index paths identifying which items have to be removed.
+	 * @param session 	If this change occurred via a drag session, the session through which
+	 * 												the items were removed.
 	 *     
 	 */
-	collectionViewRemoveItemsAtIndexPaths?(collectionView: BMCollectionView, indexPaths: BMIndexPath<T>[]): void;
+	collectionViewRemoveItemsAtIndexPaths?(collectionView: BMCollectionView, indexPaths: BMIndexPath<T>[], {session}?: {session?: BMDragSession | null | undefined}): void;
 
 
 	/**
@@ -13055,15 +15026,56 @@ export interface BMCollectionViewDataSource<T = any> {
 	 * this method returns for the appropriate animation to play on the items being transferred.
 	 * Optionally, data sources may reject the change and not perform any action or only partially accept the update
 	 * and add just some of the items, by changing their internal data structures appropriately.
-	 * @param collectionView      The collection view into which items are being inserted.
-	 * @param items 					An array of objects to add to the collection view.
-	 * @param toIndexPath 		    The starting index path to which the items should be inserted.
+	 * @param collectionView      			The collection view into which items are being inserted.
+	 * @param items 								An array of objects to add to the collection view. If this change
+	 * 															occurred trough a drop session, this represents the default representation
+	 * 															of the drag items.
+	 * @param toIndexPath 		    			The starting index path to which the items should be inserted.
+	 * @param session 				The drop session through which this change was performed, if this
+	 * 															occurred via a drag and drop gesture.
+	 * @param indexPaths 		
+	 * 															If the data set inserted a different representation of the items than the default,
+	 * 															this map must be filled out with the new index paths associated with each item in
+	 * 															the drop session that was actually inserted.
+	 * @return 							An optional promise that resolves when data has updated, if it cannot be updated synchronously.
 	 *     
 	 */
-	collectionViewInsertItems?(collectionView: BMCollectionView, items: any[], {toIndexPath}: {toIndexPath: BMIndexPath<T>}): void;
+	collectionViewInsertItems?(collectionView: BMCollectionView, items: any[], {toIndexPath, session, indexPaths}: {toIndexPath: BMIndexPath<T>, session?: BMDropSession | null | undefined, indexPaths?: Map<BMDragItem, BMIndexPath<T>> | null | undefined}): Promise<void> | void;
+
+
+	/**
+	 * This method should be implemented by data source objects that support transferring items via drag and drop
+	 * to create the drag items that will be part of a drag session.
+	 * 
+	 * Data source objects implementing this method should return a drag item for the specified index path with
+	 * the appropriate representations that potential drop targets can verify to determine if they can accept
+	 * the items being transferred through the session.
+	 * @param collectionView      The collection view that started the dragging session.
+	 * @param indexPath 			The index path for which to create a drag item.
+	 * @param session 				The drag session that will be used to transfer the items.
+	 * @return 							The drag item.
+	 *  
+	 */
+	collectionViewDragItemForIndexPath?(collectionView: BMCollectionView, indexPath: BMIndexPath<T>, {session}: {session: BMDragSession}): BMDragItem;
+
+
+	/**
+	 * Invoked by collection after a successful transfer via a drop session to determine the index path associated
+	 * with the specified drag item during the associated data update. Data source objects which implement this method
+	 * should return the index path associated with the appropriate representation of the specified drag item that
+	 * was accepted through the drop session.
+	 * @param collectionView 		The collection view that accepted items from a drop session.
+	 * @param item 						The drag item for which to obtain the associated index path.
+	 * @return 			The associated index path if it could be determined, `undefined` otherwise.
+	 *  
+	 */
+	collectionViewIndexPathForDragItem?(collectionView: BMCollectionView, item: BMDragItem): BMIndexPath<T> | null | undefined;
 
 
 	/**
+	 * @deprecated Not used if `dragItemForIndexPath` is implemented.
+	 * 
+	 * ------
 	 * This method may be implemented by data source objects that support transferring items to another collection view.
 	 * Data source objects implementing this method are expected to create a copy of the specified item and return it.
 	 * The item is guaranteed to be an object that was returned at some point by the data set when it provided an index path.
@@ -13165,7 +15177,7 @@ export interface BMCollectionViewDelegate {
 
 	/**
 	 * Invoked by the collection view whenever any cell should be selected to determine whether that selection is allowed. 
-	 * The actuall cell may not be visible on screen and as such it may not have a BMCollectionViewCell object associated with it.
+	 * The actual cell may not be visible on screen and as such it may not have a BMCollectionViewCell object associated with it.
 	 * You may invoke the cellAtIndexPath(indexPath) method to obtain a reference to the cell if it is visible.
 	 * If this method is not implemented by the delegate object, the collection view will assume that the cell may be selected.
 	 * @param collectionView 		The calling collection view.
@@ -13189,7 +15201,7 @@ export interface BMCollectionViewDelegate {
 
 	/**
 	 * Invoked by the collection view whenever any cell should be deselected to determine whether that selection is allowed. 
-	 * The actuall cell may not be visible on screen and as such it may not have a BMCollectionViewCell object associated with it.
+	 * The actual cell may not be visible on screen and as such it may not have a BMCollectionViewCell object associated with it.
 	 * You may invoke the cellAtIndexPath(indexPath) method to obtain a reference to the cell if it is visible.
 	 * If this method is not implemented by the delegate object, the collection view will assume that the cell may be deselected.
 	 * @param collectionView 		The calling collection view.
@@ -13324,8 +15336,8 @@ export interface BMCollectionViewDelegate {
 	 * Invoked by the collection view whenever any cell is clicked or tapped. Delegate objects can implement this method to react
 	 * to cell click or tap events.
 	 * Delegate objects can optionally return YES from this method to signal to the collection view that they wish to handle this event
-	 * and prevent the default actions from occuring.
-	 * By default, when returning NO or nothing from this method, the collection view will togle the selection state of the clicked cell.
+	 * and prevent the default actions from occurring.
+	 * By default, when returning NO or nothing from this method, the collection view will toggle the selection state of the clicked cell.
 	 * @param collectionView 		The calling collection view.
 	 * @param cell 			The cell that triggered this event.
 	 * @param withEvent 					The event that triggered this action.
@@ -13339,7 +15351,7 @@ export interface BMCollectionViewDelegate {
 	 * Invoked by the collection view whenever any cell is double clicked or double tapped. Delegate objects can implement this method to react
 	 * to cell click or tap events.
 	 * Delegate objects can optionally return YES from this method to signal to the collection view that they wish to handle this event
-	 * and prevent the default actions from occuring.
+	 * and prevent the default actions from occurring.
 	 * @param collectionView 		The calling collection view.
 	 * @param cell 			The cell that triggered this event.
 	 * @param withEvent 					The event that triggered this action.
@@ -13353,7 +15365,7 @@ export interface BMCollectionViewDelegate {
 	 * Invoked by the collection view whenever any cell is long clicked or long tapped. Delegate objects can implement this method to react
 	 * to cell click or tap events.
 	 * Delegate objects can optionally return YES from this method to signal to the collection view that they wish to handle this event
-	 * and prevent the default actions from occuring.
+	 * and prevent the default actions from occurring.
 	 * @param collectionView 		The calling collection view.
 	 * @param cell 			The cell that triggered this event.
 	 * @param withEvent 					The event that triggered this action.
@@ -13367,7 +15379,7 @@ export interface BMCollectionViewDelegate {
 	 * Invoked by the collection view whenever any cell is right clicked. Delegate objects can implement this method to react
 	 * to cell click events.
 	 * Delegate objects can optionally return YES from this method to signal to the collection view that they wish to handle this event
-	 * and prevent the default actions from occuring.
+	 * and prevent the default actions from occurring.
 	 * By default, when returning NO or nothing from this method, the browser's default context menu will appear.
 	 * @param collectionView 		The calling collection view.
 	 * @param cell 			The cell that triggered this event.
@@ -13419,7 +15431,7 @@ export interface BMCollectionViewDelegate {
 
 	/**
 	 * Invoked by the collection view immediately before starting an interactive drag gesture for a cell.
-	 * Delegate objects can implement this method to perform any changes that might be needed to accomodate this gesture.
+	 * Delegate objects can implement this method to perform any changes that might be needed to accommodate this gesture.
 	 * @param collectionView 		The calling collection view.
 	 * @param cell 			The cell that is about to be dragged.
 	 * @param atIndexPath 			The cell's current index path.
@@ -13435,81 +15447,217 @@ export interface BMCollectionViewDelegate {
 	 * If this method is not implemented, collection view will assume that items cannot be transferred.
 	 * @param collectionView 		The calling collection view.
 	 * @param indexPaths 			The index paths that may be transferred by the drag gesture.
+	 * @param session 				The drag session through which the items may be transferred.
 	 * @return 							`YES` if the index paths can be removed, `NO` otherwise.
 	 *  
 	 */
-	collectionViewCanTransferItemsAtIndexPaths?(collectionView: BMCollectionView, indexPaths: BMIndexPath[]): boolean;
+	collectionViewCanTransferItemsAtIndexPaths?(collectionView: BMCollectionView, indexPaths: BMIndexPath[], {session}: {session: BMDragSession}): boolean;
 
 
 	/**
-	 * Invoked by collection view to determine how to handle the transfer of the given items to a different
-	 * collection view.
+	 * Invoked by collection view to determine whether the items at the specified index paths may be reordered as
+	 * a result of a drag and drop gesture.
+	 * 
+	 * Delegate objects may implement this method and return `YES` to allow items to be reordered during the drag
+	 * and drop gesture or `NO` to prevent this behaviour. **The default return value is assumed to be `YES` when
+	 * this method is not implemented.**
+	 * @param collectionView 		The collection view that started the drag session.
+	 * @param indexPaths 			The index paths of the items that are part of the drag session.
+	 * @param session 				The drag session through which the items are reordered.
+	 * @return 							`YES` if the items can be moved, `NO` otherwise.
+	 *  
+	 */
+	collectionViewCanReorderItemsAtIndexPaths?(collectionView: BMCollectionView, indexPaths: BMIndexPath[], {session}: {session: BMDragSession}): boolean;
+
+
+	/**
+	 * Invoked by collection view to determine how to handle the transfer of the items at the specified index paths to
+	 * a different view.
 	 * @param collectionView 		The calling collection view.
 	 * @param indexPaths 			The index paths that will be transferred by the drag gesture.
+	 * @param session 				The drag session through which the items are transferred.
 	 * @return 		The desired accept policy.
 	 *  
 	 */
-	collectionViewTransferPolicyForItemsAtIndexPaths?(collectionView: BMCollectionView, indexPaths: BMIndexPath[]): BMCollectionViewTransferPolicy;
+	collectionViewTransferPolicyForItemsAtIndexPaths?(collectionView: BMCollectionView, indexPaths: BMIndexPath[], {session}: {session: BMDragSession}): BMCollectionViewTransferPolicy;
 
 
 	/**
 	 * Invoked by collection view to determine if the given items may be imported from another collection view.
+	 * 
 	 * Delegate object can implement this method to let collection view know whether or not it can import the items.
 	 * If this method is not implemented, collection view will assume that items cannot be imported.
-	 * @param collectionView 		The calling collection view.
-	 * @param items 					The items that might be imported.
-	 * @return 							`YES` if the items can be imported, `NO` otherwise.
+	 * @param collectionView 				The calling collection view.
+	 * @param items 							The items that might be imported, using the default representation
+	 * 												        supplied by the item provider. The actual item providers can be obtained
+	 *                                                      from the drop session.
+	 * @param session 						The associated drop session.
+	 * @return 	`YES` if the items can be imported, `NO` if they can not
+	 * 														or an accept region to further customize how the items can be
+	 * 														imported from the source view.
+	 *  
+	 */
+	collectionViewCanAcceptItems?(collectionView: BMCollectionView, items: any[], {session}: {session: BMDropSession}): boolean | BMCollectionViewAcceptRegion;
+
+
+	/**
+	 * Invoked by collection view to obtain a preview element for the specified drop session item.
+	 * 
+	 * Delegate objects may optionally implement and return an element to customize the appearance of
+	 * the specified element when the drop session enters the collection view's frame.
+	 * @param collectionView 		The collection view.
+	 * @param session 				The drop session.
+	 * @param item 					The item for which to return a preview.
+	 * @return 					A preview for the item, or `undefined` to retain the
+	 * 												preview supplied by the view that started the drag session.
+	 *  
+	 */
+	collectionViewPreviewForDropSession?(collectionView: BMCollectionView, session: BMDropSession, {item}: {item: BMDragItem}): DOMNode | null | undefined;
+
+
+	/**
+	 * Invoked by collection view at the start of a drag and drop gesture when the accept region was set to `.Anywhere` or
+	 * `YES` was returned from `collectionViewCanAcceptItems`.
+	 * 
+	 * Delegate objects implementing this method should provide the drop action that will be used for this drop session.
+	 * A default action of kind `.Accept` is used when this method is not implemented.
+	 * @param collectionView      The collection view for which the drop session started.
+	 * @param session                The drop session that started.
+	 * @return                        The drop action to use.
+	 *     
+	 */
+	collectionViewDropActionForDropSession?(collectionView: BMCollectionView, session: BMDropSession): BMDropAction;
+
+
+	/**
+	 * Invoked by collection view during a drag and drop gesture if the accept region has been specified as `.Position` in
+	 * `collectionViewCanAcceptItems`, to determine the appropriate drop action for the drop session's new position.
+	 * 
+	 * Delegate objects implementing this method may return a `BMDropSessionAction` object describing the behaviour of
+	 * ending the session at its current position, or `undefined` to retain the previous action.
+	 * @param collectionView 		The collection view the drop session is tracking.
+	 * @param session 				The drop session.
+	 * @param position 					The position of the drop session relative to the collection view's bounds.
+	 * @return 		The new drop action, or `undefined` to retain the current action.
+	 *  
+	 */
+	collectionViewDropSessionDidUpdate?(collectionView: BMCollectionView, session: BMDropSession, {position}: {position: BMPoint}): BMDropSessionAction | null | undefined;
+
+
+	/**
+	 * Invoked by collection view during a drag and drop gesture if the accept region has been specified as `.Position` or
+	 * `.Cell` in `collectionViewCanAcceptItems`, to determine the appropriate drop action for the drop session's new position
+	 * when the gesture enters the frame of the cell at the specified index path.
+	 * 
+	 * Delegate objects implementing this method may return a `BMDropSessionAction` object describing the behaviour of
+	 * ending the session at its current position, or `undefined` to retain the previous action.
+	 * @param collectionView 		The collection view the drop session is tracking.
+	 * @param session 				The drop session.
+	 * @param indexPath 				The index path of the cell the drag and drop gesture has entered.
+	 * @return 		The new drop action, or `undefined` to retain the current action.
+	 *  
+	 */
+	collectionViewDropSessionDidEnterIndexPath?(collectionView: BMCollectionView, session: BMDropSession, {indexPath}: {indexPath: BMIndexPath}): BMDropSessionAction | null | undefined;
+
+
+	/**
+	 * Invoked by collection view during a drag and drop gesture if the accept region has been specified as `.Position` or
+	 * `.Cell` in `collectionViewCanAcceptItems` when the gesture exits the frame of the cell at the specified index path.
+	 * 
+	 * If the accept region was set to `.Cell` in `collectionViewCanAcceptItems`, collection view will automatically update
+	 * the drop session to ignore the drop. If the accept region was set to `.Position`, `collectionViewDropSessionDidUpdate`
+	 * will be subsequently invoked to obtain a new drop action.
+	 * 
+	 * Delegate objects can optionally implement this method to perform any necessary cleanup if the drop session is no
+	 * longer acceptable outside of any cell.
+	 * @param collectionView 		The collection view the drop session is tracking.
+	 * @param session 				The drop session.
+	 * @param indexPath 				The index path of the cell the drag and drop gesture has entered.
+	 *  
+	 */
+	collectionViewDropSessionDidExitIndexPath?(collectionView: BMCollectionView, session: BMDropSession, {indexPath}: {indexPath: BMIndexPath}): void;
+
+
+	/**
+	 * Invoked by collection when a drop session is about to finish, regardless of its outcome.
+	 * 
+	 * Delegate objects can optionally implement this method to perform any cleanup.
+	 * @param collectionView 		The collection view for which the drop session is ending.
+	 * @param session 				The drop session that will end.
 	 *  
 	 */
-	collectionViewCanAcceptItems?(collectionView: BMCollectionView, items: any[]): boolean;
+	collectionViewDropSessionWillFinish?(collectionView: BMCollectionView, session: BMDropSession): void;
 
 
 	/**
 	 * Invoked by collection view to determine how to handle the import of the given items from a different
 	 * collection view.
 	 * @param collectionView 		The calling collection view.
-	 * @param items 					The items that might be imported.
+	 * @param items 					The items that might be imported, using the default representation
+	 * 												supplied by the item provider. The actual item providers can be obtained
+	 *                                              from the drop session.
+	 * @param session 				The associated drop session.
 	 * @return 		The desired accept policy.
 	 *  
 	 */
-	collectionViewAcceptPolicyForItems?(collectionView: BMCollectionView, items: any[]): BMCollectionViewAcceptPolicy;
+	collectionViewAcceptPolicyForItems?(collectionView: BMCollectionView, items: any[], {session}: {session: BMDropSession}): BMCollectionViewAcceptPolicy;
 
 
 	/**
 	 * Invoked by collection view to determine if the items at the specified index paths may be removed by an interactive
 	 * drag gesture.
+	 * 
 	 * Delegate object can implement this method to let collection view know whether or not it can remove the items.
 	 * If this method is not implemented, collection view will assume that items cannot be removed.
 	 * @param collectionView 		The calling collection view.
 	 * @param indexPaths 			The index paths that may be removed by the drag gesture.
+	 * @param session 				The associated drag session.
 	 * @return 							`YES` if the index paths can be removed, `NO` otherwise.
 	 *  
 	 */
-	collectionViewCanRemoveItemsAtIndexPaths?(collectionView: BMCollectionView, indexPaths: BMIndexPath[]): boolean;
+	collectionViewCanRemoveItemsAtIndexPaths?(collectionView: BMCollectionView, indexPaths: BMIndexPath[], {session}: {session: BMDropSession}): boolean;
+
+
+	/**
+	 * Invoked by collection view to determine what message to display for a drag session that will delete
+	 * the items at the specified index paths.
+	 * 
+	 * Delegate object can implement this method to provide a customized message that will be displayed to
+	 * the user while the drag session is in progress. The default message that will be displayed when this
+	 * method is not implemented is `"Remove"`.
+	 * @param collectionView 		The calling collection view.
+	 * @param indexPaths 			The index paths that may be removed by the drag gesture.
+	 * @param session 				The associated drag session.
+	 * @return 								The message to display.
+	 *  
+	 */
+	collectionDeleteMessageForIndexPaths?(collectionView: BMCollectionView, indexPaths: BMIndexPath[], {session}: {session: BMDropSession}): string;
 
 
 	/**
 	 * Invoked by the collection view immediately before a drag gesture is about to end for a cell. This is invoked before any
 	 * associated animations begin.
-	 * Delegate objects can implement this method to perform any changes that might be needed to accomodate this gesture.
+	 * Delegate objects can implement this method to perform any changes that might be needed to accommodate this gesture.
 	 * @param collectionView 		The calling collection view.
 	 * @param cell 			The cell that is about to be dragged.
 	 * @param atIndexPath 			The cell's new index path.
+	 * @param session 				The drag session managing the interactive movement.
 	 *  
 	 */
-	collectionViewWillFinishInteractiveMovementForCell?(collectionView: BMCollectionView, cell: BMCollectionViewCell, {atIndexPath}: {atIndexPath: BMIndexPath}): void;
+	collectionViewWillFinishInteractiveMovementForCell?(collectionView: BMCollectionView, cell: BMCollectionViewCell, {atIndexPath, session}: {atIndexPath: BMIndexPath, session: BMDragSession}): void;
 
 
 	/**
 	 * Invoked by the collection view immediately after a drag gesture has ended for a cell. This is invoked after any
 	 * associated animations end.
-	 * Delegate objects can implement this method to perform any changes that might be needed to accomodate this gesture.
+	 * Delegate objects can implement this method to perform any changes that might be needed to accommodate this gesture.
 	 * @param collectionView 		The calling collection view.
 	 * @param cell 			The cell that is about to be dragged.
 	 * @param atIndexPath 			The cell's new index path.
+	 * @param session 				The drag session managing the interactive movement.
 	 *  
 	 */
-	collectionViewDidFinishInteractiveMovementForCell?(collectionView: BMCollectionView, cell: BMCollectionViewCell, {atIndexPath}: {atIndexPath: BMIndexPath}): void;
+	collectionViewDidFinishInteractiveMovementForCell?(collectionView: BMCollectionView, cell: BMCollectionViewCell, {atIndexPath, session}: {atIndexPath: BMIndexPath, session: BMDragSession}): void;
 
 }
 
@@ -13918,6 +16066,18 @@ export class BMWindow extends BMView {
 	 */
 	readonly toolbar: DOMNode;
 
+	/**
+	 * Defined for non-modal windows. The drag handle used to resize the window.
+	 *  
+	 */
+	private _dragHandle: DOMNode;
+
+	/**
+	 * Controls whether the window resize handle appears.
+	 *  
+	 */
+	resizable: boolean;
+
 	/**
 	 * The window overlay.
 	 *  
@@ -14327,6 +16487,12 @@ export class BMToolWindow extends BMWindow {
 	 */
 	opensAutomatically: boolean;
 
+	/**
+	 * The window to which this tool window is associated.
+	 *  
+	 */
+	private _parentWindow: BMWindow;
+
 	/**
 	 * Initializes this tool window with the given frame and associates it with the given window.
 	 * @param frame 		The window's frame.