@progress/kendo-angular-utils 24.2.2-develop.9 → 25.0.0-develop.1

package/index.d.ts

@@ -2,17 +2,1097 @@
 * Copyright © 2026 Progress Software Corporation. All rights reserved.
 * Licensed under commercial license. See LICENSE.md in the project root for more information
 *-------------------------------------------------------------------------------------------*/
-export * from './directives';
-export { UtilsModule } from './utils.module';
-export { DragAndDropModule } from './drag-and-drop.module';
-export { DragTargetDirective } from './drag-and-drop/dragtarget.directive';
-export { DragHandleDirective } from './drag-and-drop/draghandle.directive';
-export { DropTargetDirective } from './drag-and-drop/droptarget.directive';
-export { DragTargetContainerDirective } from './drag-and-drop/dragtarget-container.directive';
-export { DropTargetContainerDirective } from './drag-and-drop/droptarget-container.directive';
-export { HintComponent } from './drag-and-drop/hint.component';
-export * from './drag-and-drop/models/index';
-export { DropTargetEvent } from './drag-and-drop/events';
-export * from './drag-and-drop/events/drag-target';
+import * as i0 from '@angular/core';
+import { ElementRef, TemplateRef, ViewContainerRef, OnInit, AfterContentInit, OnDestroy, EventEmitter, QueryList, Renderer2, NgZone, AfterViewInit, ChangeDetectorRef, InjectionToken } from '@angular/core';
+import { NormalizedDragEvent, DragTarget, DropTarget, DragAndDropState, DragAndDropAction } from '@progress/kendo-draggable-common';
 export { NormalizedDragEvent } from '@progress/kendo-draggable-common';
-export * from './adaptive-breakpoints';
+import { PreventableEvent } from '@progress/kendo-angular-common';
+import { Subject } from 'rxjs';
+
+/**
+ * Represents the Kendo UI DragHandle directive for Angular.
+ * Use this directive to specify an element inside a drag target as a handle for dragging instead of the drag target itself.
+ *
+ * ```html
+ * <div kendoDragTarget>
+ *  <button kendoDragHandle kendoButton>
+ *   Drag me
+ *  </button>
+ * </div>
+ * ```
+ */
+declare class DragHandleDirective {
+    element: ElementRef;
+    touchActionStyle: string;
+    /**
+     * Sets the cursor style of the drag handle. Accepts same values as the [CSS `cursor` property](https://developer.mozilla.org/en-US/docs/Web/CSS/cursor#values).
+     *
+     * @default 'move'
+     */
+    cursorStyle: string;
+    constructor(element: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragHandleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DragHandleDirective, "[kendoDragHandle]", ["kendoDragHandle"], { "cursorStyle": { "alias": "cursorStyle"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Represents the autoscroll direction during drag-and-drop operations.
+ */
+interface ScrollDirection {
+    horizontal: boolean;
+    vertical: boolean;
+}
+
+/**
+ * Represents additional configuration options for the autoScroll feature of the DragTarget.
+ */
+interface AutoScrollOptions {
+    /**
+     * Sets the element for boundary detection. Used to calculate the autoScroll velocity.
+     */
+    boundaryElementRef?: ElementRef;
+    /**
+     * Sets the direction for the autoScroll feature.
+     */
+    direction?: ScrollDirection;
+    /**
+     * Enables or disables the autoScroll feature.
+     */
+    enabled?: boolean;
+}
+
+/**
+ * Represents the callback used by the `dragData` property of the [`DragTarget`](https://www.telerik.com/kendo-angular-ui/components/utils/api/dragtargetdirective) and [`DragTargetContainer`](https://www.telerik.com/kendo-angular-ui/components/utils/api/dragtargetcontainerdirective) directives.
+ * It returns the custom data that will be available in the events of the respective [`DropTarget`](https://www.telerik.com/kendo-angular-ui/components/utils/api/droptargetdirective) or [`DropTargetContainer`](https://www.telerik.com/kendo-angular-ui/components/utils/api/droptargetcontainerdirective) directives upon interaction.
+ *
+ */
+type DragTargetDataFn = (args: DragTargetDataArgs) => any;
+/**
+ * Represents the callback used by the `dragTargetId` property of the [`DragTargetContainer`](https://www.telerik.com/kendo-angular-ui/components/utils/api/dragtargetcontainerdirective) directive.
+ * It returns a custom identifier that will be available in the events of the respective directive upon its interaction with a valid DropTarget.
+ */
+type DragTargetIdFn = (args: DragTargetIdArgs) => any;
+/**
+ * Represents the callback arguments for the `dragData` property.
+ */
+interface DragTargetDataArgs {
+    /**
+     * The drag target HTML element.
+     */
+    dragTarget: HTMLElement;
+    /**
+     * The drag target unique identifier, result from executing the callback used by the `dragTargetId` property. Applies to `DragTargetContainerDirective`.
+     */
+    dragTargetId: any;
+    /**
+     * The index of the current drag target in the collection. Applies to `DragTargetContainerDirective`.
+     */
+    dragTargetIndex: number;
+}
+/**
+ * Represents the callback arguments for the `dragTargetId` property.
+ */
+interface DragTargetIdArgs {
+    /**
+     * The drag target HTML element.
+     */
+    dragTarget: HTMLElement;
+    /**
+     * The index of the current drag target in the collection. Applies to `DragTargetContainerDirective`.
+     */
+    dragTargetIndex: number;
+}
+
+/**
+ * Represents a unified type for all coordinates.
+ */
+interface Coordinates {
+    x: number;
+    y: number;
+}
+
+/**
+ * Represents additional configuration options for the hint element of the DragTarget and DragTargetContainer directives.
+ */
+interface HintSettings {
+    /**
+     * Renders the given template as a hint for the current drag target.
+     */
+    hintTemplate?: TemplateRef<any>;
+    /**
+     * Sets the CSS classes for the hint host element when using the default hint. Supports values accepted by [`ngClass`](link:site.data.urls.angular['ngclassapi']).
+     */
+    hintClass?: any;
+    /**
+     * Controls the hint container. By default, the hint is appended to the document body.
+     */
+    appendTo?: ViewContainerRef;
+}
+
+/**
+ * Represents the axis to which the dragging will be restricted.
+ */
+type DragAxis = 'horizontal' | 'vertical';
+
+/**
+ * Represents the available modes for the drag action.
+ */
+type DragMode = 'auto' | 'manual';
+
+/**
+ * Arguments for the press event of the `DragTarget` and `DragTargetContainer`.
+ */
+declare class DragTargetPressEvent {
+    /**
+     * The information related to the current drag event.
+     * This is the normalized drag event that contains details about the drag operation.
+     */
+    dragEvent: NormalizedDragEvent;
+    /**
+     * The DOM element 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. Applies to `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
+     */
+    constructor(args?: any);
+}
+
+/**
+ * Arguments for the dragReady event of the `DragTarget` and `DragTargetContainer`.
+ */
+declare class DragTargetDragReadyEvent {
+    /**
+     * The information related to the current drag event.
+     * This is the normalized drag event that contains details about the drag operation.
+     */
+    dragEvent: NormalizedDragEvent;
+    /**
+     * The DOM element 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. Applies to `DragTargetContainer` directive.
+     */
+    dragTargetIndex?: number;
+    /**
+     * @hidden
+     */
+    constructor(args?: any);
+}
+
+/**
+ * Arguments for the `dragStart` event of the `DragTarget` and `DragTargetContainer`.
+ */
+declare class DragTargetDragStartEvent extends PreventableEvent {
+    /**
+     * The information related to the current drag event.
+     * This is the normalized drag event that contains details about the drag operation.
+     */
+    dragEvent: NormalizedDragEvent;
+    /**
+     * The DOM element 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. Applies to `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
+     */
+    constructor(args?: any);
+}
+
+/**
+ * Arguments for the dragEnd event of the `DragTarget` and `DragTargetContainer`.
+ */
+declare class DragTargetDragEndEvent {
+    /**
+     * The information related to the current drag event.
+     * This is the normalized drag event that contains details about the drag operation.
+     */
+    dragEvent: NormalizedDragEvent;
+    /**
+     * The DOM element 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. Applies to `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
+     */
+    constructor(args?: any);
+}
+
+/**
+ * Arguments for the drag event of the `DragTarget` and `DragTargetContainer`.
+ */
+declare class DragTargetDragEvent extends PreventableEvent {
+    /**
+     * The information related to the current drag event.
+     * This is the normalized drag event that contains details about the drag operation.
+     */
+    dragEvent: NormalizedDragEvent;
+    /**
+     * The DOM element being dragged.
+     */
+    dragTarget: HTMLElement;
+    /**
+     * The hint element 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. Applies to `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
+     */
+    constructor(args?: any);
+}
+
+/**
+ * Arguments for the release event of the `DragTarget` and `DragTargetContainer`.
+ */
+declare class DragTargetReleaseEvent {
+    /**
+     * The information related to the current drag event.
+     * This is the normalized drag event that contains details about the drag operation.
+     */
+    dragEvent: NormalizedDragEvent;
+    /**
+     * The DOM element 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. Applies to `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
+     */
+    constructor(args?: any);
+}
+
+/**
+ * Represents the Kendo UI DragTarget directive for Angular.
+ * Use this directive to make an element draggable.
+ */
+declare class DragTargetDirective implements OnInit, AfterContentInit, OnDestroy {
+    private element;
+    private renderer;
+    private ngZone;
+    private service;
+    private viewContainer;
+    get touchActionStyle(): string;
+    /**
+     * Defines whether a hint will be used for dragging. By default, the hint is a copy of the drag target. ([see example](https://www.telerik.com/kendo-angular-ui/components/utils/draganddrop/hint)).
+     *
+     * @default false
+     */
+    hint: boolean | HintSettings;
+    /**
+     * Sets the number of pixels the pointer must move before dragging starts. Applies when `manualDrag` is `false`. [See example](https://www.telerik.com/kendo-angular-ui/components/utils/draganddrop/threshold).
+     *
+     * @default 0
+     */
+    threshold: number;
+    /**
+     * Sets the automatic container scrolling behavior when close to the edge. [See example](https://www.telerik.com/kendo-angular-ui/components/utils/draganddrop/autoscroll).
+     *
+     * @default true
+     */
+    autoScroll: boolean | AutoScrollOptions;
+    /**
+     * Sets a unique identifier for the drag target.
+     */
+    dragTargetId: string | DragTargetIdFn;
+    /**
+     * Sets the delay in milliseconds before dragging begins. [See example](https://www.telerik.com/kendo-angular-ui/components/utils/draganddrop/delay).
+     *
+     * @default 0
+     */
+    dragDelay: number;
+    /**
+     * Restricts dragging to horizontal or vertical only. Applies when `mode` is `auto`. [See example](https://www.telerik.com/kendo-angular-ui/components/utils/draganddrop/axis).
+     */
+    restrictByAxis: DragAxis;
+    /**
+     * Specifies whether to use the default dragging behavior or handle it manually.
+     *
+     * @default 'auto'
+     */
+    mode: DragMode;
+    /**
+     * Defines a callback function used for attaching custom data to the drag target.
+     * The data is available in the events of the respective [`DropTarget`](https://www.telerik.com/kendo-angular-ui/components/utils/api/droptargetdirective) or [`DropTargetContainer`](https://www.telerik.com/kendo-angular-ui/components/utils/api/droptargetcontainerdirective) directives.
+     * The current DragTarget HTML element and its `dragTargetId` will be available as arguments.
+     */
+    set dragData(fn: DragTargetDataFn);
+    get dragData(): DragTargetDataFn;
+    /**
+     * Sets the cursor style of the drag target. Accepts same values as the [CSS `cursor` property](https://developer.mozilla.org/en-US/docs/Web/CSS/cursor#values).
+     *
+     * @default 'move'
+     */
+    cursorStyle: string;
+    /**
+     * Fires when the user presses the drag target element.
+     */
+    onPress: EventEmitter<DragTargetPressEvent>;
+    /**
+     * Fires when dragging of the drag target element begins.
+     */
+    onDragStart: EventEmitter<DragTargetDragStartEvent>;
+    /**
+     * Fires while the user drags the drag target element.
+     */
+    onDrag: EventEmitter<DragTargetDragEvent>;
+    /**
+     * Fires when the drag target's `dragDelay` has passed and the user can drag the element.
+     */
+    onDragReady: EventEmitter<DragTargetDragReadyEvent>;
+    /**
+     * Fires when `DragTarget` is released, either by dropping it on a drop target or by releasing the mouse button.
+     */
+    onRelease: EventEmitter<DragTargetReleaseEvent>;
+    /**
+     * Fires when dragging of the drag target ends and the element is released.
+     */
+    onDragEnd: EventEmitter<DragTargetDragEndEvent>;
+    private dragTarget;
+    private hintComponent;
+    private dragStarted;
+    private pressed;
+    private dragReady;
+    private dragTimeout;
+    private initialPosition;
+    private position;
+    private scrollableParent;
+    private defaultHint;
+    private _dragData;
+    private prevUserSelect;
+    private get hintTemplate();
+    private get nativeElement();
+    private get hintElem();
+    private onPointerDown;
+    private onTouchStart;
+    private onPointerMove;
+    private onTouchMove;
+    private onPointerUp;
+    private onContextMenu;
+    private onNativeDragStart;
+    dragHandles: QueryList<DragHandleDirective>;
+    constructor(element: ElementRef, renderer: Renderer2, ngZone: NgZone, service: DragStateService, viewContainer: ViewContainerRef);
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    private handlePress;
+    private handleDragStart;
+    private handleDrag;
+    private handleRelease;
+    private handleDragEnd;
+    private initializeDragTarget;
+    private get supportPointerEvent();
+    private removeListeners;
+    private attachDomHandlers;
+    private isDragHandle;
+    private getAutoScrollContainer;
+    private createHint;
+    private createDefaultHint;
+    private createCustomHint;
+    private destroyHint;
+    private emitZoneAwareEvent;
+    private get dragTargetIdResult();
+    private performDrag;
+    private calculatePosition;
+    private getStylesPerElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragTargetDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DragTargetDirective, "[kendoDragTarget]", ["kendoDragTarget"], { "hint": { "alias": "hint"; "required": false; }; "threshold": { "alias": "threshold"; "required": false; }; "autoScroll": { "alias": "autoScroll"; "required": false; }; "dragTargetId": { "alias": "dragTargetId"; "required": false; }; "dragDelay": { "alias": "dragDelay"; "required": false; }; "restrictByAxis": { "alias": "restrictByAxis"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "dragData": { "alias": "dragData"; "required": false; }; "cursorStyle": { "alias": "cursorStyle"; "required": false; }; }, { "onPress": "onPress"; "onDragStart": "onDragStart"; "onDrag": "onDrag"; "onDragReady": "onDragReady"; "onRelease": "onRelease"; "onDragEnd": "onDragEnd"; }, ["dragHandles"], never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class DragStateService implements OnDestroy {
+    constructor();
+    dragTarget: DragTarget | null;
+    dropTarget: DropTarget | null;
+    dragTargets: DragTarget[];
+    dropTargets: DropTarget[];
+    pressed: boolean;
+    ignoreMouse: boolean;
+    autoScroll: boolean;
+    isScrolling: boolean;
+    scrollableParent: HTMLElement | null;
+    autoScrollDirection: ScrollDirection;
+    initialClientOffset: Coordinates;
+    clientOffset: Coordinates;
+    initialScrollOffset: Coordinates;
+    scrollOffset: Coordinates;
+    offset: Coordinates;
+    pageOffset: Coordinates;
+    velocity: Coordinates;
+    dragTargetDirective: DragTargetDirective;
+    state: DragAndDropState;
+    dragIndex: number;
+    dropIndex: number;
+    dragData: any;
+    dragTargetId: any;
+    private callbacks;
+    private scrollInterval;
+    handleDragAndDrop(action: DragAndDropAction): void;
+    setPressed(pressed: boolean): void;
+    setScrolling(isScrolling: boolean): void;
+    setVelocity(velocity: Coordinates): void;
+    setOffset(offset: Coordinates): void;
+    setClientOffset(clientOffset: Coordinates): void;
+    setPageOffset(pageOffset: Coordinates): void;
+    setInitialClientOffset(initialClientOffset: Coordinates): void;
+    setScrollOffset(scrollOffset: Coordinates): void;
+    setInitialScrollOffset(initialScrollOffset: Coordinates): void;
+    get dragTargetPresent(): boolean;
+    get dropTargetPresent(): boolean;
+    private updateState;
+    private setCallbacks;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DragStateService>;
+}
+
+/**
+ * Represents the [Kendo UI DragTargetContainer directive for Angular](https://www.telerik.com/kendo-angular-ui/components/utils/api/dragtargetcontainerdirective).
+ * Use this directive to make multiple elements draggable inside a container.
+ *
+ * @example
+ * ```html
+ * <ul kendoDragTargetContainer dragTargetFilter=".my-draggable">
+ *   <li class="my-draggable"> Item 1</li>
+ *   <li class="my-draggable"> Item 2</li>
+ *   <li class="my-draggable"> Item 3</li>
+ * </ul>
+ * ```
+ */
+declare class DragTargetContainerDirective implements AfterViewInit, OnDestroy {
+    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](https://www.telerik.com/kendo-angular-ui/components/utils/draganddrop/hint).
+     *
+     * @default false
+     */
+    hint: boolean | HintSettings;
+    /**
+     * Sets a selector for elements in the container to make them draggable. The possible values include any
+     * DOM `selector`. [See example](https://www.telerik.com/kendo-angular-ui/components/utils/draganddrop/drag-container).
+     */
+    set dragTargetFilter(value: string);
+    get dragTargetFilter(): string;
+    /**
+     * Sets a selector for elements inside each drag target to use as drag handles.
+     */
+    dragHandle: string;
+    /**
+     * Sets the delay in milliseconds before dragging begins. [See example](https://www.telerik.com/kendo-angular-ui/components/utils/draganddrop/drag-container#events).
+     *
+     * @default 0
+     */
+    dragDelay: number;
+    /**
+     * Sets the number of pixels the pointer must move before dragging starts. [See example](https://www.telerik.com/kendo-angular-ui/components/utils/draganddrop/threshold).
+     *
+     * @default 0
+     */
+    threshold: number;
+    /**
+     * Sets a unique identifier for each drag target.
+     * It exposes the current drag target HTML element and its index in the collection of drag targets as arguments.
+     */
+    set dragTargetId(fn: DragTargetIdFn);
+    get dragTargetId(): DragTargetIdFn;
+    /**
+     * Sets a callback function to return custom data for `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;
+    /**
+     * Disables dragging of drag targets in the container when set to `true`.
+     *
+     * @default false
+     */
+    set dragDisabled(value: boolean);
+    get dragDisabled(): boolean;
+    /**
+     * Sets whether to use the default dragging behavior or handle it manually.
+     *
+     * @default 'auto'
+     */
+    mode: DragMode;
+    /**
+     * Sets the cursor style of the drag targets. Accepts same values as the [CSS `cursor` property](https://developer.mozilla.org/en-US/docs/Web/CSS/cursor#values).
+     *
+     * @default 'move'
+     */
+    cursorStyle: string;
+    /**
+     * @hidden
+     */
+    hintContext: any;
+    /**
+     * Fires when a drag target's `dragDelay` has passed and the user can drag the element.
+     */
+    onDragReady: EventEmitter<DragTargetDragReadyEvent>;
+    /**
+     * Fires when the user presses a drag target element.
+     */
+    onPress: EventEmitter<DragTargetPressEvent>;
+    /**
+     * Fires when dragging of a drag target element begins.
+     */
+    onDragStart: EventEmitter<DragTargetDragStartEvent>;
+    /**
+     * Fires while the user drags a drag target element.
+     */
+    onDrag: EventEmitter<DragTargetDragEvent>;
+    /**
+     * Fires when the user releases a drag target element after pressing it.
+     */
+    onRelease: EventEmitter<DragTargetReleaseEvent>;
+    /**
+     * Fires when dragging of a drag target ends and the element is released.
+     */
+    onDragEnd: EventEmitter<DragTargetDragEndEvent>;
+    /**
+     * Notifies the `DragTargetContainer` that its content has changed.
+     */
+    notify(): void;
+    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 prevUserSelect;
+    private get allDragTargets();
+    private get dragHandles();
+    private get hintTemplate();
+    constructor(wrapper: ElementRef, ngZone: NgZone, renderer: Renderer2, service: DragStateService, viewContainer: ViewContainerRef, cdr: ChangeDetectorRef);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private onPointerDown;
+    private onTouchStart;
+    private onPointerMove;
+    private onTouchMove;
+    private onPointerUp;
+    private onContextMenu;
+    private onNativeDragStart;
+    private handlePress;
+    private handleDragStart;
+    private handleDrag;
+    private handleRelease;
+    private handleDragEnd;
+    private get nativeElement();
+    private get hintElem();
+    private removeListeners;
+    private get supportPointerEvent();
+    private subscribe;
+    private emitZoneAwareEvent;
+    private createHint;
+    private createDefaultHint;
+    private createCustomHint;
+    private destroyHint;
+    private getDragIndex;
+    private initializeDragTargets;
+    private isDragHandle;
+    private get isHandleSelectorValid();
+    private setTargetStyles;
+    private queryHost;
+    private clearPreviousTargets;
+    private performDrag;
+    private calculatePosition;
+    private getStylesPerElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragTargetContainerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DragTargetContainerDirective, "[kendoDragTargetContainer]", ["kendoDragTargetContainer"], { "hint": { "alias": "hint"; "required": false; }; "dragTargetFilter": { "alias": "dragTargetFilter"; "required": false; }; "dragHandle": { "alias": "dragHandle"; "required": false; }; "dragDelay": { "alias": "dragDelay"; "required": false; }; "threshold": { "alias": "threshold"; "required": false; }; "dragTargetId": { "alias": "dragTargetId"; "required": false; }; "dragData": { "alias": "dragData"; "required": false; }; "dragDisabled": { "alias": "dragDisabled"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "cursorStyle": { "alias": "cursorStyle"; "required": false; }; "hintContext": { "alias": "hintContext"; "required": false; }; }, { "onDragReady": "onDragReady"; "onPress": "onPress"; "onDragStart": "onDragStart"; "onDrag": "onDrag"; "onRelease": "onRelease"; "onDragEnd": "onDragEnd"; }, never, never, true, never>;
+}
+
+/**
+ * Arguments for the drag events of the `DropTarget` and `DropTargetContainer` directives.
+ */
+declare class DropTargetEvent {
+    /**
+     * The current drag target element.
+     */
+    dragTarget: HTMLElement;
+    /**
+     * The current drop target element.
+     */
+    dropTarget: HTMLElement;
+    /**
+     * The information related to the current drag event.
+     */
+    dragEvent: NormalizedDragEvent;
+    /**
+     * The data passed to the `dragData` input property of the `DragTarget` or `DragTargetContainer` directive.
+     */
+    dragData: any;
+    /**
+     * The index of the current drop target in the collection of drop targets. Applies to `DropTargetContainer` directive.
+     */
+    dropTargetIndex?: number;
+    /**
+     * The hint element of the `DragTarget`.
+     */
+    hintElement?: HTMLElement;
+    /**
+     * Left for backward compatibility for the DropTarget deprecated events.
+     * @hidden
+     */
+    get normalizedEvent(): NormalizedDragEvent;
+    /**
+     * Left for backward compatibility for the DropTarget deprecated events.
+     * @hidden
+     */
+    get hostElement(): HTMLElement;
+    /**
+     * @hidden
+     */
+    constructor(args?: any);
+}
+
+/**
+ * Represents the [Kendo UI DropTargetContainer directive for Angular](https://www.telerik.com/kendo-angular-ui/components/utils/api/droptargetcontainerdirective).
+ * Use this directive to make multiple elements drop targets inside a container.
+ *
+ * @example
+ * ```html
+ * <div kendoDropTargetContainer dropTargetFilter=".my-droptarget">
+ *   <div class="my-droptarget">
+ *     Drop here
+ *   </div>
+ * </div>
+ * ```
+ */
+declare class DropTargetContainerDirective implements AfterViewInit {
+    private service;
+    private element;
+    private ngZone;
+    private cdr;
+    /**
+     * Sets a selector for elements in the container to make them drop targets. [See example](https://www.telerik.com/kendo-angular-ui/components/utils/draganddrop/drop-container).
+     */
+    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 drag target enters a drop target.
+     */
+    onDragEnter: EventEmitter<DropTargetEvent>;
+    /**
+     * Fires when a drag target is dragged over a drop target.
+     */
+    onDragOver: EventEmitter<DropTargetEvent>;
+    /**
+     * Fires when a drag target leaves a drop target.
+     */
+    onDragLeave: EventEmitter<DropTargetEvent>;
+    /**
+     * Fires when a drag target is dropped over a drop target.
+     */
+    onDrop: EventEmitter<DropTargetEvent>;
+    /**
+     * Notifies the `DropTargetContainer` that its content has changed.
+     */
+    notify(): void;
+    constructor(service: DragStateService, element: ElementRef, ngZone: NgZone, cdr: ChangeDetectorRef);
+    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": { "alias": "dropTargetFilter"; "required": false; }; "dropDisabled": { "alias": "dropDisabled"; "required": false; }; }, { "onDragEnter": "onDragEnter"; "onDragOver": "onDragOver"; "onDragLeave": "onDragLeave"; "onDrop": "onDrop"; }, never, never, true, never>;
+}
+
+/**
+ * Represents the Kendo UI DropTarget directive for Angular.
+ * Use this directive to make an element a drop target for draggable items.
+ *
+ * ```html
+ * <div kendoDropTarget>
+ *   Drop here
+ * </div>
+ * ```
+ *
+ */
+declare class DropTargetDirective implements OnInit, OnDestroy {
+    private service;
+    private element;
+    private ngZone;
+    /**
+     * Fires when a drag target enters the drop target.
+     */
+    onDragEnter: EventEmitter<DropTargetEvent>;
+    /**
+     * Fires when a drag target is dragged over the drop target.
+     */
+    onDragOver: EventEmitter<DropTargetEvent>;
+    /**
+     * Fires when a drag target leaves the drop target.
+     */
+    onDragLeave: EventEmitter<DropTargetEvent>;
+    /**
+     * Fires when a drag target is dropped over the drop target.
+     */
+    onDrop: EventEmitter<DropTargetEvent>;
+    constructor(service: DragStateService, element: ElementRef, ngZone: NgZone);
+    private dropTarget;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * @hidden
+     */
+    handleDragEnter(event: NormalizedDragEvent): void;
+    /**
+     * @hidden
+     */
+    handleDragLeave(event: NormalizedDragEvent): void;
+    /**
+     * @hidden
+     */
+    handleDragOver(event: NormalizedDragEvent): void;
+    /**
+     * @hidden
+     */
+    handleDrop(event: NormalizedDragEvent): void;
+    private initializeDropTarget;
+    private emitZoneAwareEvent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropTargetDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DropTargetDirective, "[kendoDropTarget]", ["kendoDropTarget"], {}, { "onDragEnter": "onDragEnter"; "onDragOver": "onDragOver"; "onDragLeave": "onDragLeave"; "onDrop": "onDrop"; }, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class HintComponent {
+    element: ElementRef;
+    template: TemplateRef<any>;
+    directive: any;
+    targetIndex: number;
+    contextData: any;
+    customContext: any;
+    pointerEvents: string;
+    constructor(element: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<HintComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HintComponent, "kendo-draghint", never, { "template": { "alias": "template"; "required": false; }; "directive": { "alias": "directive"; "required": false; }; "targetIndex": { "alias": "targetIndex"; "required": false; }; "contextData": { "alias": "contextData"; "required": false; }; "customContext": { "alias": "customContext"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Use this utility array to access all Drag and Drop-related components and directives in a standalone Angular component.
+ *
+ * @example
+ * ```typescript
+ * import { Component } from '@angular/core';
+ * import { KENDO_DRAGANDDROP } from '@progress/kendo-angular-utils';
+ *
+ * @Component({
+ *   selector: 'my-app',
+ *   standalone: true,
+ *   imports: [KENDO_DRAGANDDROP],
+ *   template: `
+ *      <div kendoDragTarget>Drag me</div>
+ *      <div kendoDropTarget>Drop here</div>
+ *   `
+ * })
+ * export class AppComponent {}
+ * ```
+ */
+declare const KENDO_DRAGANDDROP: readonly [typeof DragTargetDirective, typeof DragHandleDirective, typeof DropTargetDirective, typeof DragTargetContainerDirective, typeof DropTargetContainerDirective, typeof HintComponent];
+/**
+* Use this utility array to access all `@progress/kendo-angular-utils`-related components and directives in a standalone Angular component.
+* > Currently, `KENDO_UTILS` includes only the `KENDO_DRAGANDDROP` utility array and their usage is equivalent.
+*/
+declare const KENDO_UTILS: readonly [typeof DragTargetDirective, typeof DragHandleDirective, typeof DropTargetDirective, typeof DragTargetContainerDirective, typeof DropTargetContainerDirective, typeof HintComponent];
+
+/**
+ * Represents the [`NgModule`](link:site.data.urls.angular['ngmodules'])
+ * definition for the Utils components.
+ *
+ * @example
+ * ```ts
+ * import { UtilsModule } from '@progress/kendo-angular-utils';
+ * import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
+ * import { NgModule } from '@angular/core';
+ * import { AppComponent } from './app.component';
+ *
+ * @NgModule({
+ *     declarations: [AppComponent],
+ *     imports:      [BrowserModule, UtilsModule],
+ *     bootstrap:    [AppComponent]
+ * })
+ * export class AppModule {}
+ * ```
+ */
+declare class UtilsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<UtilsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<UtilsModule, never, [typeof DragTargetDirective, typeof DragHandleDirective, typeof DropTargetDirective, typeof DragTargetContainerDirective, typeof DropTargetContainerDirective, typeof HintComponent], [typeof DragTargetDirective, typeof DragHandleDirective, typeof DropTargetDirective, typeof DragTargetContainerDirective, typeof DropTargetContainerDirective, typeof HintComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<UtilsModule>;
+}
+
+/**
+ * Represents the [`NgModule`](link:site.data.urls.angular['ngmodules'])
+ * definition for the Drag and Drop directives.
+ *
+ * @example
+ * ```ts
+ * import { DragAndDropModule } from '@progress/kendo-angular-utils';
+ * import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
+ * import { NgModule } from '@angular/core';
+ * import { AppComponent } from './app.component';
+ *
+ * @NgModule({
+ *     declarations: [AppComponent],
+ *     imports:      [BrowserModule, DragAndDropModule],
+ *     bootstrap:    [AppComponent]
+ * })
+ * export class AppModule {}
+ * ```
+ */
+declare class DragAndDropModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragAndDropModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DragAndDropModule, never, [typeof DragTargetDirective, typeof DragHandleDirective, typeof DropTargetDirective, typeof DragTargetContainerDirective, typeof DropTargetContainerDirective, typeof HintComponent], [typeof DragTargetDirective, typeof DragHandleDirective, typeof DropTargetDirective, typeof DragTargetContainerDirective, typeof DropTargetContainerDirective, typeof HintComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DragAndDropModule>;
+}
+
+/**
+ * Represents the adaptive settings for Kendo UI for Angular components.
+ *
+ * Allows customization of adaptive breakpoints to ensure optimal rendering
+ * across different screen resolutions and device types.
+ */
+interface AdaptiveSettings {
+    /**
+     * Sets the screen width in pixels up to which the component renders a full-screen modal.
+     *
+     * @default 500
+     */
+    small?: number;
+    /**
+     * Sets the screen width in pixels up to which the component renders a docked-to-bottom modal. Uses the `small` adaptive breakpoint as a lower boundary.
+     *
+     * @default 768
+     */
+    medium?: number;
+}
+
+/**
+ * A service that lets you change the current adaptive settings dynamically. Use the public `notify` method to update the settings. [See example](https://www.telerik.com/kendo-angular-ui/components/utils/adaptive-settings#changing-the-adaptive-settings-dynamically).
+ */
+declare class AdaptiveSettingsService {
+    /**
+     * @hidden
+     */
+    readonly changes: Subject<AdaptiveSettings>;
+    /**
+     * Notifies subscribers that the adaptive settings have changed.
+     *
+     * @param adaptiveSettings - (Optional) A new value for the adaptive settings token.
+     */
+    notify(adaptiveSettings?: AdaptiveSettings): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdaptiveSettingsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AdaptiveSettingsService>;
+}
+
+/**
+ * Specifies the possible adaptive size options based on the window width in pixels.
+ * @hidden
+ */
+type AdaptiveSize = 'small' | 'medium' | 'large';
+
+/**
+ * The service responsible for handling changes in adaptive settings. Add it to the providers array when using adaptive breakpoints in a standalone component.
+ *
+ * @example
+ * ```ts
+ * import { AdaptiveService } from '@progress/kendo-angular-utils';
+ *
+ * @Component({
+ *   selector: 'my-component',
+ *   standalone: true,
+ *   providers: [AdaptiveService, { provide: ADAPTIVE_SETTINGS, useValue: { small: 300 } }],
+ *   template: '...'
+ * })
+ * export class AppComponent {}
+ * ```
+ */
+declare class AdaptiveService implements OnDestroy {
+    private _adaptiveSettings;
+    private zone;
+    /**
+     * Notifies subscribers of the initial adaptive settings, and upon each call to `notify`.
+     * @hidden
+     */
+    readonly changes: Subject<AdaptiveSettings>;
+    /**
+     * Notifies subscribers when the window size changes to any of small, medium, or large depending on the set adaptive size breakpoints.
+     * @hidden
+     */
+    readonly sizeChanges: Subject<AdaptiveSize>;
+    private subs;
+    private previousSize;
+    /**
+     * @hidden
+     */
+    constructor(_adaptiveSettings: AdaptiveSettings, adaptiveSettingsService: AdaptiveSettingsService, zone: NgZone);
+    /**
+     * @hidden
+     */
+    get adaptiveSettings(): AdaptiveSettings;
+    /**
+     * @hidden
+     */
+    get size(): AdaptiveSize;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdaptiveService, [{ optional: true; }, { optional: true; }, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AdaptiveService>;
+}
+
+/**
+ * A token that specifies the `AdaptiveSettings` for Kendo UI for Angular components.
+ *
+ * @example
+ * ```ts
+ * import { NgModule } from '@angular/core';
+ *
+ * @NgModule({
+ *   ...,
+ *   providers: [{ provide: ADAPTIVE_SETTINGS, useValue: { small: 400, medium: 600 } }]
+ * })
+ * export class AppModule {}
+ * ```
+ */
+declare const ADAPTIVE_SETTINGS: InjectionToken<AdaptiveSettings>;
+
+export { ADAPTIVE_SETTINGS, AdaptiveService, AdaptiveSettingsService, DragAndDropModule, DragHandleDirective, DragTargetContainerDirective, DragTargetDirective, DragTargetDragEndEvent, DragTargetDragEvent, DragTargetDragReadyEvent, DragTargetDragStartEvent, DragTargetPressEvent, DragTargetReleaseEvent, DropTargetContainerDirective, DropTargetDirective, DropTargetEvent, HintComponent, KENDO_DRAGANDDROP, KENDO_UTILS, UtilsModule };
+export type { AdaptiveSettings, AdaptiveSize, AutoScrollOptions, Coordinates, DragAxis, DragMode, DragTargetDataArgs, DragTargetDataFn, DragTargetIdArgs, DragTargetIdFn, HintSettings, ScrollDirection };