@progress/kendo-angular-utils 12.0.0-develop.8 → 12.0.0

package/drag-and-drop/drag-state.service.d.ts

@@ -32,6 +32,10 @@ export declare class DragStateService implements OnDestroy {
     velocity: Coordinates;
     dragTargetDirective: DragTargetDirective;
     state: DragAndDropState;
+    dragIndex: number;
+    dropIndex: number;
+    dragData: any;
+    dragTargetId: any;
     private callbacks;
     private scrollInterval;
     handleDragAndDrop(action: DragAndDropAction): void;

package/drag-and-drop/draghandle.directive.d.ts

@@ -6,6 +6,7 @@ import { ElementRef } from "@angular/core";
 import * as i0 from "@angular/core";
 /**
  * Represents the Kendo UI DragHandle directive for Angular.
+ * It is used to specify a concrete element within a drag target as a handle for dragging, instead the drag target itself.
  */
 export declare class DragHandleDirective {
     element: ElementRef;

package/drag-and-drop/dragtarget-container.directive.d.ts

@@ -0,0 +1,164 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2023 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { AfterViewInit, ChangeDetectorRef, ElementRef, EventEmitter, NgZone, Renderer2, ViewContainerRef } from '@angular/core';
+import { DragStateService } from './drag-state.service';
+import { DragMode, DragTargetDataFn, HintSettings } from './models';
+import { DragTargetIdFn } from './models/functions';
+import { DragTargetDragEndEvent, DragTargetDragEvent, DragTargetDragReadyEvent, DragTargetDragStartEvent, DragTargetPressEvent, DragTargetReleaseEvent } from './events/drag-target';
+import * as i0 from "@angular/core";
+/**
+ * Represents the [Kendo UI DragTargetContainer directive for Angular]({% slug api_utils_dragtargetcontainerdirective %}).
+ * Used to configure multiple elements as draggable.
+ *
+ * @example
+ * ```ts-no-run
+ * <ul kendoDragTargetContainer dragTargetFilter=".my-draggable">
+ *    <li class="my-draggable">foo</li>
+ * </ul>
+ * ```
+ */
+export declare class DragTargetContainerDirective implements AfterViewInit {
+    wrapper: ElementRef;
+    ngZone: NgZone;
+    private renderer;
+    private service;
+    private viewContainer;
+    private cdr;
+    /**
+     * Defines whether a hint will be used for dragging. By default, the hint is a copy of the current drag target. ([see example]({% slug drag_target_container_hint %})).
+     *
+     * @default false
+     */
+    hint: boolean | HintSettings;
+    /**
+     * Specifies a selector for elements within a container which will be configured as draggable
+     * ([see example]({% slug drag_target_container %})). The possible values include any
+     * DOM `selector`.
+     */
+    set dragTargetFilter(value: string);
+    get dragTargetFilter(): string;
+    /**
+     * Specifies a selector for elements within each DragTarget which will be configured as drag handles ([see example]({% slug drag_target_container_handle %})).
+     */
+    dragHandle: string;
+    /**
+     * Defines the delay in milliseconds after which the drag will begin ([see example]({% slug drag_target_container_delay %})).
+     *
+     * @default 0
+     */
+    dragDelay: number;
+    /**
+     * The number of pixels the pointer moves in any direction before the dragging starts ([see example]({% slug drag_target_container_minimum_distance %})).
+     *
+     * @default 0
+     */
+    threshold: number;
+    /**
+     * Defines a unique identifier for each drag target.
+     * It exposes the current DragTarget HTML element and its index in the collection of drag targets as arguments.
+     */
+    set dragTargetId(fn: DragTargetIdFn);
+    get dragTargetId(): DragTargetIdFn;
+    /**
+     * Defines a callback function which returns custom data passed to the DropTarget events.
+     * It exposes the current DragTarget HTML element, its `dragTargetId` and its index in the collection of drag targets as arguments.
+     */
+    set dragData(fn: DragTargetDataFn);
+    get dragData(): DragTargetDataFn;
+    /**
+     * If set to true, the dragging of DragTargets within the container will be disabled.
+     *
+     * @default false
+     */
+    set dragDisabled(value: boolean);
+    get dragDisabled(): boolean;
+    /**
+     * Specifies whether the default dragging behavior will be performed or the developer will manually handle the drag action.
+     *
+     * @default 'auto'
+     */
+    mode: DragMode;
+    /**
+     * Fires when a DragTarget's `dragDelay` has passed and the user is able to drag the element.
+     */
+    dragReady: EventEmitter<DragTargetDragReadyEvent>;
+    /**
+     * Fires when the user presses a DragTarget element.
+     */
+    press: EventEmitter<DragTargetPressEvent>;
+    /**
+     * Fires when the dragging of a DragTarget element begins.
+    */
+    dragStart: EventEmitter<DragTargetDragStartEvent>;
+    /**
+     * Fires while the user drags a DragTarget element.
+     */
+    drag: EventEmitter<DragTargetDragEvent>;
+    /**
+     * Fires when the user releases a DragTarget element after being pressed.
+     */
+    release: EventEmitter<DragTargetReleaseEvent>;
+    /**
+     * Fires when the dragging of a DragTarget ends and the element is released.
+     */
+    dragEnd: EventEmitter<DragTargetDragEndEvent>;
+    /**
+     * Used for notifying the DragTargetContainer that its content has changed.
+     */
+    notify(): void;
+    private pointerDownSubscription;
+    private pointerMoveSubscription;
+    private pointerUpSubscription;
+    private scrollSubscription;
+    private currentDragTarget;
+    private dragTimeout;
+    private pressed;
+    private dragStarted;
+    private hintComponent;
+    private defaultHint;
+    private currentDragTargetElement;
+    private scrollableParent;
+    private previousDragTargets;
+    private initialPosition;
+    private position;
+    private positionsMap;
+    private _dragTargetFilter;
+    private _dragDisabled;
+    private _dragData;
+    private _dragTargetId;
+    private get allDragTargets();
+    private get dragHandles();
+    private get hintTemplate();
+    constructor(wrapper: ElementRef, ngZone: NgZone, renderer: Renderer2, service: DragStateService, viewContainer: ViewContainerRef, cdr: ChangeDetectorRef);
+    ngAfterViewInit(): void;
+    private onPointerDown;
+    private onPointerMove;
+    private onPointerUp;
+    private handlePress;
+    private handleDragStart;
+    private handleDrag;
+    private handleRelease;
+    private handleDragEnd;
+    private get nativeElement();
+    private get hintElem();
+    private unsubscribe;
+    private subscribe;
+    private emitZoneAwareEvent;
+    private createHint;
+    private createDefaultHint;
+    private createCustomHint;
+    private destroyHint;
+    private getDragIndex;
+    private initializeDragTargets;
+    private isDragHandle;
+    private setCursorStyle;
+    private queryHost;
+    private clearPreviousTargets;
+    private performDrag;
+    private calculatePosition;
+    private getStylesPerElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragTargetContainerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DragTargetContainerDirective, "[kendoDragTargetContainer]", ["kendoDragTargetContainer"], { "hint": "hint"; "dragTargetFilter": "dragTargetFilter"; "dragHandle": "dragHandle"; "dragDelay": "dragDelay"; "threshold": "threshold"; "dragTargetId": "dragTargetId"; "dragData": "dragData"; "dragDisabled": "dragDisabled"; "mode": "mode"; }, { "dragReady": "dragReady"; "press": "press"; "dragStart": "dragStart"; "drag": "drag"; "release": "release"; "dragEnd": "dragEnd"; }, never>;
+}

package/drag-and-drop/dragtarget.directive.d.ts

@@ -2,11 +2,14 @@
 * Copyright © 2023 Progress Software Corporation. All rights reserved.
 * Licensed under commercial license. See LICENSE.md in the project root for more information
 *-------------------------------------------------------------------------------------------*/
-import { EventEmitter, AfterContentInit, ElementRef, Renderer2, NgZone, OnInit, OnDestroy, QueryList, TemplateRef, ViewContainerRef, ComponentFactoryResolver } from "@angular/core";
+import { EventEmitter, AfterContentInit, ElementRef, Renderer2, NgZone, OnInit, OnDestroy, QueryList, ViewContainerRef } from "@angular/core";
 import { DragHandleDirective } from "./draghandle.directive";
-import { DragTargetDragStartEvent, DragTargetDragEndEvent, DragTargetPressEvent, DragTargetDragEvent } from "./events/drag-target";
 import { DragStateService } from "./drag-state.service";
-import { AutoScrollOptions, DragAxis } from './models';
+import { AutoScrollOptions, DragTargetDataFn, HintSettings, DragAxis, DragMode } from './models';
+import { DragTargetIdFn } from "./models/functions";
+import { DragTargetDragEndEvent, DragTargetDragEvent, DragTargetDragStartEvent, DragTargetPressEvent } from "./events/drag-target";
+import { DragTargetReleaseEvent } from "./events/drag-target/release-event";
+import { DragTargetDragReadyEvent } from "./events/drag-target/dragready-event";
 import * as i0 from "@angular/core";
 /**
  * Represents the Kendo UI DragTarget directive for Angular.
@@ -17,13 +20,14 @@ export declare class DragTargetDirective implements OnInit, AfterContentInit, On
     private ngZone;
     private service;
     private viewContainer;
-    private resolver;
     /**
-     * Renders the passed template as a hint of the DragTarget ([see example]({% slug drag_hint %})).
+     * Defines whether a hint will be used for dragging. By default, the hint is a copy of the drag target. ([see example]({% slug drag_hint %})).
+     *
+     * @default false
      */
-    hintTemplate: TemplateRef<any>;
+    hint: boolean | HintSettings;
     /**
-     * The number of pixels the pointer moves in any direction before the dragging starts ([see example]({% slug minimum_distance %})).
+     * The number of pixels the pointer moves in any direction before the dragging starts ([see example]({% slug minimum_distance %})). Applicable when `manualDrag` is set to `false`.
      *
      * @default 0
      */
@@ -35,9 +39,9 @@ export declare class DragTargetDirective implements OnInit, AfterContentInit, On
      */
     autoScroll: boolean | AutoScrollOptions;
     /**
-     * The identifier that associates the drag target with a specific drop target.
+     * Defines a unique identifier for the dragTarget.
      */
-    link: string;
+    dragTargetId: string | DragTargetIdFn;
     /**
      * Defines the delay in milliseconds after which the drag will begin ([see example]({% slug drag_delay %})).
      *
@@ -45,87 +49,86 @@ export declare class DragTargetDirective implements OnInit, AfterContentInit, On
      */
     dragDelay: number;
     /**
-     * Restricts the element to be dragged horizontally or vertically only ([see example]({% slug axis_lock %})).
+     * Restricts the element to be dragged horizontally or vertically only ([see example]({% slug axis_lock %})). Applicable when `mode` is set to `auto`.
      */
     restrictByAxis: DragAxis;
+    /**
+     * Specifies whether the default dragging behavior will be performed or the developer will manually handle the drag action.
+     *
+     * @default 'auto'
+     */
+    mode: DragMode;
+    /**
+     * Defines a callback function used for attaching custom data to the dragTarget.
+     * The data will be available in the events of the respective [`DropTarget`]({% slug api_utils_droptargetdirective %}) or [`DropTargetContainer`]({% slug api_utils_droptargetcontainerdirective %}) directives.
+     * The current DragTarget HTML element and its `dragTargetId` will be available as arguments.
+     */
+    set dragData(fn: DragTargetDataFn);
+    get dragData(): DragTargetDataFn;
     /**
      * Fires when the user presses the DragTarget element.
      */
     press: EventEmitter<DragTargetPressEvent>;
     /**
      * Fires when the dragging of the DragTarget element begins.
-     * This event is preventable.
      */
     dragStart: EventEmitter<DragTargetDragStartEvent>;
     /**
      * Fires while the user drags the DragTarget element.
-     * This event is preventable.
      */
     drag: EventEmitter<DragTargetDragEvent>;
     /**
      * Fires when the DragTarget's `dragDelay` has passed and the user is able to drag the element.
      */
-    dragReady: EventEmitter<any>;
+    dragReady: EventEmitter<DragTargetDragReadyEvent>;
     /**
      * Fires when the user releases the DragTarget element after being pressed.
      */
-    release: EventEmitter<DragTargetPressEvent>;
+    release: EventEmitter<DragTargetReleaseEvent>;
     /**
      * Fires when the dragging of the DragTarget ends and the element is released.
      */
     dragEnd: EventEmitter<DragTargetDragEndEvent>;
-    touchAction: string;
     private dragTarget;
     private domSubscriptions;
-    private hint;
-    private initialPosition;
+    private hintComponent;
     private dragStarted;
     private pressed;
     private dragTimeout;
+    private initialPosition;
     private position;
-    /**
-     * @hidden
-     */
+    private scrollableParent;
+    private defaultHint;
+    private _dragData;
+    private get hintTemplate();
     private get nativeElement();
-    /**
-     * @hidden
-     */
     private get hintElem();
-    /**
-     * @hidden
-     */
     private onPointerDown;
-    /**
-     * @hidden
-     */
     private onPointerMove;
-    /**
-     * @hidden
-     */
     private onPointerUp;
     dragHandles: QueryList<DragHandleDirective>;
-    constructor(element: ElementRef, renderer: Renderer2, ngZone: NgZone, service: DragStateService, viewContainer: ViewContainerRef, resolver: ComponentFactoryResolver);
+    constructor(element: ElementRef, renderer: Renderer2, ngZone: NgZone, service: DragStateService, viewContainer: ViewContainerRef);
     ngOnInit(): void;
     ngAfterContentInit(): void;
     ngOnDestroy(): void;
-    /**
-     * @hidden
-     */
     private handlePress;
-    /**
-     * @hidden
-     */
     private handleDragStart;
     private handleDrag;
     private handleRelease;
     private handleDragEnd;
-    private initializeDraggable;
+    private initializeDragTarget;
     private attachDomHandlers;
     private isDragHandle;
     private getAutoScrollContainer;
     private createHint;
+    private createDefaultHint;
+    private createCustomHint;
     private destroyHint;
-    private emitEvent;
+    private emitZoneAwareEvent;
+    private get dragTargetIdResult();
+    private performDrag;
+    private calculatePosition;
+    private getStylesPerElement;
     static ɵfac: i0.ɵɵFactoryDeclaration<DragTargetDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DragTargetDirective, "[kendoDragTarget]", ["kendoDragTarget"], { "hintTemplate": "hintTemplate"; "threshold": "threshold"; "autoScroll": "autoScroll"; "link": "link"; "dragDelay": "dragDelay"; "restrictByAxis": "restrictByAxis"; }, { "press": "press"; "dragStart": "dragStart"; "drag": "drag"; "dragReady": "dragReady"; "release": "release"; "dragEnd": "dragEnd"; }, ["dragHandles"]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DragTargetDirective, "[kendoDragTarget]", ["kendoDragTarget"], { "hint": "hint"; "threshold": "threshold"; "autoScroll": "autoScroll"; "dragTargetId": "dragTargetId"; "dragDelay": "dragDelay"; "restrictByAxis": "restrictByAxis"; "mode": "mode"; "dragData": "dragData"; }, { "press": "press"; "dragStart": "dragStart"; "drag": "drag"; "dragReady": "dragReady"; "release": "release"; "dragEnd": "dragEnd"; }, ["dragHandles"]>;
 }

package/drag-and-drop/droptarget-container.directive.d.ts

@@ -0,0 +1,89 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2023 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { AfterViewInit, ChangeDetectorRef, ElementRef, EventEmitter, NgZone } from '@angular/core';
+import { NormalizedDragEvent } from '@progress/kendo-draggable-common';
+import { DragStateService } from './drag-state.service';
+import { DropTargetEvent } from './events/drop-target-event';
+import * as i0 from "@angular/core";
+/**
+ * Represents the [Kendo UI DropTargetContainer directive for Angular]({% slug api_utils_droptargetcontainerdirective %}).
+ * Used to configure multiple elements as drop targets.
+ *
+ * @example
+ * ```ts-no-run
+ * <div kendoDropTargetContainer dropTargetFilter=".my-droptarget">
+ *    <div class="my-droptarget">foo</div>
+ * </div>
+ * ```
+ */
+export declare class DropTargetContainerDirective implements AfterViewInit {
+    private service;
+    private element;
+    private ngZone;
+    private cdr;
+    /**
+     * Specifies a selector for elements within a container which will be configured as drop targets
+     * ([see example]({% slug drop_target_container %})). The possible values include any
+     * DOM `selector`.
+     */
+    set dropTargetFilter(value: string);
+    get dropTargetFilter(): string;
+    /**
+     * Specifies whether the Drop Targets within the container will emit the corresponding events upon interaction with a Drag Target.
+     */
+    set dropDisabled(value: boolean);
+    get dropDisabled(): boolean;
+    /**
+     * Fires when a DragTarget element enters the DropTarget.
+     */
+    dragEnter: EventEmitter<DropTargetEvent>;
+    /**
+     * Fires when a DragTarget element is being dragged over the DropTarget.
+     */
+    dragOver: EventEmitter<DropTargetEvent>;
+    /**
+     * Fires when a DragTarget element leaves the DropTarget.
+     */
+    dragLeave: EventEmitter<DropTargetEvent>;
+    /**
+     * Fires when a DragTarget element is dropped over the DropTarget.
+     */
+    drop: EventEmitter<DropTargetEvent>;
+    /**
+     * Used for notifying the DropTargetContainer that its content has changed.
+     */
+    notify(): void;
+    constructor(service: DragStateService, element: ElementRef, ngZone: NgZone, cdr: ChangeDetectorRef);
+    private currentDropTarget;
+    private currentDropTargetElement;
+    private previousDropTargets;
+    private _dropTargetFilter;
+    private _dropDisabled;
+    private get nativeElement();
+    ngAfterViewInit(): void;
+    private get allDropTargets();
+    /**
+     * @hidden
+     */
+    handleDragEnter(event: NormalizedDragEvent): void;
+    /**
+     * @hidden
+     */
+    handleDragLeave(event: NormalizedDragEvent): void;
+    /**
+     * @hidden
+     */
+    handleDragOver(event: NormalizedDragEvent): void;
+    /**
+     * @hidden
+     */
+    handleDrop(event: NormalizedDragEvent): void;
+    private initializeDropTargets;
+    private emitZoneAwareEvent;
+    private getDropIndex;
+    private clearPreviousTargets;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropTargetContainerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DropTargetContainerDirective, "[kendoDropTargetContainer]", ["kendoDropTargetContainer"], { "dropTargetFilter": "dropTargetFilter"; "dropDisabled": "dropDisabled"; }, { "dragEnter": "dragEnter"; "dragOver": "dragOver"; "dragLeave": "dragLeave"; "drop": "drop"; }, never>;
+}

package/drag-and-drop/droptarget.directive.d.ts

@@ -5,8 +5,7 @@
 import { ElementRef, EventEmitter, NgZone, OnInit } from "@angular/core";
 import { NormalizedDragEvent } from "@progress/kendo-draggable-common";
 import { DragStateService } from "./drag-state.service";
-import { DropTargetDragEnterEvent, DropTargetDragOverEvent, DropTargetDragLeaveEvent, DropTargetDropEvent } from './events/drop-target';
-import { AllowedTargetFn } from "./models";
+import { DropTargetEvent } from './events/drop-target-event';
 import * as i0 from "@angular/core";
 /**
  * Represents the Kendo UI DropTarget directive for Angular.
@@ -15,30 +14,22 @@ export declare class DropTargetDirective implements OnInit {
     private service;
     private element;
     private ngZone;
-    /**
-     * The allowed drag targets that can interact with the current drop target.
-     */
-    allowedDragTargets: string | Array<string> | AllowedTargetFn;
     /**
      * Fires when a DragTarget element enters the DropTarget.
-     * This event is preventable. Preventing it allows full logic customization.
      */
-    dragEnter: EventEmitter<DropTargetDragEnterEvent>;
+    dragEnter: EventEmitter<DropTargetEvent>;
     /**
      * Fires when a DragTarget element is being dragged over the DropTarget.
-     * This event is preventable. Preventing it allows full logic customization.
      */
-    dragOver: EventEmitter<DropTargetDragOverEvent>;
+    dragOver: EventEmitter<DropTargetEvent>;
     /**
      * Fires when a DragTarget element leaves the DropTarget.
-     * This event is preventable. Preventing it allows full logic customization.
      */
-    dragLeave: EventEmitter<DropTargetDragLeaveEvent>;
+    dragLeave: EventEmitter<DropTargetEvent>;
     /**
      * Fires when a DragTarget element is dropped over the DropTarget.
-     * This event is preventable. Preventing it allows full logic customization.
      */
-    drop: EventEmitter<DropTargetDropEvent>;
+    drop: EventEmitter<DropTargetEvent>;
     constructor(service: DragStateService, element: ElementRef, ngZone: NgZone);
     private dropTarget;
     ngOnInit(): void;
@@ -58,10 +49,8 @@ export declare class DropTargetDirective implements OnInit {
      * @hidden
      */
     handleDrop(event: NormalizedDragEvent): void;
-    /**
-     * @hidden
-     */
     private initializeDropTarget;
+    private emitEvent;
     static ɵfac: i0.ɵɵFactoryDeclaration<DropTargetDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DropTargetDirective, "[kendoDropTarget]", ["kendoDropTarget"], { "allowedDragTargets": "allowedDragTargets"; }, { "dragEnter": "dragEnter"; "dragOver": "dragOver"; "dragLeave": "dragLeave"; "drop": "drop"; }, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DropTargetDirective, "[kendoDropTarget]", ["kendoDropTarget"], {}, { "dragEnter": "dragEnter"; "dragOver": "dragOver"; "dragLeave": "dragLeave"; "drop": "drop"; }, never>;
 }

package/drag-and-drop/events/drag-target/drag-event.d.ts

@@ -5,21 +5,39 @@
 import { NormalizedDragEvent } from '@progress/kendo-draggable-common';
 import { PreventableEvent } from '@progress/kendo-angular-common';
 /**
- * Arguments for the drag event of the DragTarget.
+ * Arguments for the drag event of the DragTarget and DragTargetContainer.
  */
 export declare class DragTargetDragEvent extends PreventableEvent {
     /**
      * The normalized drag event.
      */
-    normalizedEvent: NormalizedDragEvent;
+    dragEvent: NormalizedDragEvent;
     /**
      * The DOM element that is being dragged.
      */
-    hostElement: HTMLElement;
+    dragTarget: HTMLElement;
     /**
-    * The hint of the DragTarget.
-    */
+     * The hint of the DragTarget.
+     */
     hintElement?: HTMLElement;
+    /**
+     * The identifier passed to the `dragTargetId` input property of the `DragTarget` or `DragTargetContainer` directive.
+     */
+    dragTargetId?: any;
+    /**
+     * The index of the current drag target in the collection of drag targets (applicable for the `DragTargetContainer` directive).
+     */
+    dragTargetIndex?: number;
+    /**
+     * Left for backward compatibility for the DragTarget deprecated events.
+     * @hidden
+     */
+    get normalizedEvent(): NormalizedDragEvent;
+    /**
+     * Left for backward compatibility for the DragTarget deprecated events.
+     * @hidden
+     */
+    get hostElement(): HTMLElement;
     /**
      * @hidden
      */

package/drag-and-drop/events/drag-target/dragready-event.d.ts

@@ -0,0 +1,30 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2023 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { NormalizedDragEvent } from '@progress/kendo-draggable-common';
+/**
+ * Arguments for the dragReady event of the DragTarget and DragTargetContainer.
+ */
+export declare class DragTargetDragReadyEvent {
+    /**
+     * The normalized drag event.
+     */
+    dragEvent: NormalizedDragEvent;
+    /**
+     * The DOM element that is being dragged.
+     */
+    dragTarget: HTMLElement;
+    /**
+     * The identifier passed to the `dragTargetId` input property of the `DragTarget` or `DragTargetContainer` directive.
+     */
+    dragTargetId?: any;
+    /**
+     * The index of the current drag target in the collection of drag targets (applicable for the `DragTargetContainer` directive).
+     */
+    dragTargetIndex?: number;
+    /**
+     * @hidden
+     */
+    constructor(args?: any);
+}

package/drag-and-drop/events/drag-target/end-event.d.ts

@@ -4,17 +4,35 @@
 *-------------------------------------------------------------------------------------------*/
 import { NormalizedDragEvent } from '@progress/kendo-draggable-common';
 /**
- * Arguments for the dragEnd event of the DragTarget.
+ * Arguments for the dragEnd event of the DragTarget and DragTargetContainer.
  */
 export declare class DragTargetDragEndEvent {
     /**
      * The normalized drag event.
      */
-    normalizedEvent: NormalizedDragEvent;
+    dragEvent: NormalizedDragEvent;
     /**
-     * The DOM element that was dragged.
+     * The DOM element that is being dragged.
      */
-    hostElement: HTMLElement;
+    dragTarget: HTMLElement;
+    /**
+     * The identifier passed to the `dragTargetId` input property of the `DragTarget` or `DragTargetContainer` directive.
+     */
+    dragTargetId?: any;
+    /**
+     * The index of the current drag target in the collection of drag targets (applicable for the `DragTargetContainer` directive).
+     */
+    dragTargetIndex?: number;
+    /**
+     * Left for backward compatibility for the DragTarget deprecated events.
+     * @hidden
+     */
+    get normalizedEvent(): NormalizedDragEvent;
+    /**
+     * Left for backward compatibility for the DragTarget deprecated events.
+     * @hidden
+     */
+    get hostElement(): HTMLElement;
     /**
      * @hidden
      */

package/drag-and-drop/events/drag-target/index.d.ts

@@ -3,6 +3,8 @@
 * Licensed under commercial license. See LICENSE.md in the project root for more information
 *-------------------------------------------------------------------------------------------*/
 export { DragTargetPressEvent } from './press-event';
+export { DragTargetDragReadyEvent } from './dragready-event';
 export { DragTargetDragStartEvent } from './start-event';
 export { DragTargetDragEndEvent } from './end-event';
 export { DragTargetDragEvent } from './drag-event';
+export { DragTargetReleaseEvent } from './release-event';

package/drag-and-drop/events/drag-target/press-event.d.ts

@@ -4,17 +4,35 @@
 *-------------------------------------------------------------------------------------------*/
 import { NormalizedDragEvent } from '@progress/kendo-draggable-common';
 /**
- * Arguments for the press event of the DragTarget.
+ * Arguments for the press event of the DragTarget and DragTargetContainer.
  */
 export declare class DragTargetPressEvent {
     /**
-     * The normalized event.
+     * The normalized drag event.
      */
-    normalizedEvent: NormalizedDragEvent;
+    dragEvent: NormalizedDragEvent;
     /**
-     * The DOM element that is pressed.
+     * The DOM element that is being dragged.
      */
-    hostElement: HTMLElement;
+    dragTarget: HTMLElement;
+    /**
+     * The identifier passed to the `dragTargetId` input property of the `DragTarget` or `DragTargetContainer` directive.
+     */
+    dragTargetId?: any;
+    /**
+     * The index of the current drag target in the collection of drag targets (applicable for the `DragTargetContainer` directive).
+     */
+    dragTargetIndex?: number;
+    /**
+     * Left for backward compatibility for the DragTarget deprecated events.
+     * @hidden
+     */
+    get normalizedEvent(): NormalizedDragEvent;
+    /**
+     * Left for backward compatibility for the DragTarget deprecated events.
+     * @hidden
+     */
+    get hostElement(): HTMLElement;
     /**
      * @hidden
      */