@progress/kendo-angular-sortable 24.2.2 → 25.0.0-develop.2

package/index.d.ts

@@ -2,19 +2,928 @@
 * Copyright © 2026 Progress Software Corporation. All rights reserved.
 * Licensed under commercial license. See LICENSE.md in the project root for more information
 *-------------------------------------------------------------------------------------------*/
-export { SortableComponent } from './sortable.component';
-export { SortableModule } from './sortable.module';
-export { PreventableEvent } from './events/preventable-event';
-export { DraggableEvent } from './events/draggable-event';
-export { DragStartEvent, DragEndEvent, DragOverEvent } from './events/sortable-events';
-export { SortableEvent } from './events/sortable-event-args.interface';
-export { NavigateEvent } from './events/navigate-event';
-export { DataEvent } from './events/data-event-args.interface';
-export { DataMoveEvent, DataAddEvent, DataRemoveEvent } from './events/data-events';
-export { DraggableDirective } from "./draggable.directive";
-export { SortableBindingDirective } from "./binding.directive";
-export { PlaceholderTemplateDirective } from './item-template.directive';
-export { ItemTemplateDirective } from './item-template.directive';
-export { SortableService } from './sortable.service';
-export { SortableContainer } from './sortable-container';
-export * from './directives';
+import * as i0 from '@angular/core';
+import { OnInit, ElementRef, Renderer2, OnDestroy, NgZone, AfterViewInit, AfterViewChecked, AfterContentInit, TrackByFunction, QueryList, TemplateRef, EventEmitter, ChangeDetectorRef, Injector } from '@angular/core';
+import { Subject } from 'rxjs';
+import { LocalizationService } from '@progress/kendo-angular-l10n';
+
+/**
+ * @hidden
+ */
+declare abstract class SortableContainer {
+    abstract activeIndex: number;
+    abstract removeDataItem(index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortableContainer, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SortableContainer>;
+}
+
+/**
+ * @hidden
+ */
+declare class DraggableDirective implements OnInit {
+    parent: SortableContainer;
+    el: ElementRef;
+    private renderer;
+    set index(value: number);
+    get index(): number;
+    set disabled(value: boolean);
+    get disabled(): boolean;
+    set hidden(value: boolean);
+    get hidden(): boolean;
+    get _focused(): boolean;
+    get display(): string;
+    set display(display: string);
+    private _display;
+    private _index;
+    private _disabled;
+    private _hidden;
+    constructor(parent: SortableContainer, el: ElementRef, renderer: Renderer2);
+    ngOnInit(): void;
+    private updateDisplayStyle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DraggableDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DraggableDirective, "[kendoDraggable]", never, { "index": { "alias": "index"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "hidden": { "alias": "hidden"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * The `SortableService` is a service that manages the drag-and-drop functionality
+ * for transferring items between Sortable components.
+ */
+declare class SortableService implements OnDestroy {
+    private ngZone;
+    /**
+     * Specifies the Draggable item that is currently being moved.
+     */
+    activeDraggable: DraggableDirective;
+    /**
+     * Specifies the Draggable item from which the dragging started.
+     */
+    originDraggable: DraggableDirective;
+    /**
+     * @hidden
+     */
+    originIndex: number;
+    /**
+     * @hidden
+     */
+    targetSortable: {
+        component: SortableComponent;
+        index: number;
+    };
+    /**
+     * Specifies the Draggable item that last emitted an event.
+     */
+    lastDraggable: DraggableDirective;
+    /**
+     * @hidden
+     */
+    onPressSubject: Subject<any>;
+    /**
+     * @hidden
+     */
+    onDragSubject: Subject<any>;
+    /**
+     * @hidden
+     */
+    onReleaseSubject: Subject<any>;
+    /**
+     * Specifies the `SortableComponent` instance under the currently dragged item.
+     */
+    set target(target: SortableComponent);
+    get target(): SortableComponent;
+    private subscriptions;
+    private source;
+    private _target;
+    private sortableCounter;
+    private sortableRegister;
+    private pressArgs;
+    /**
+     * @hidden
+     */
+    readonly source$: i0.Signal<SortableComponent>;
+    /**
+     * @hidden
+     */
+    constructor(ngZone: NgZone);
+    /**
+     * @hidden
+     */
+    onPress(e: any): void;
+    /**
+     * @hidden
+     */
+    onDrag(e: any): void;
+    /**
+     * @hidden
+     */
+    onRelease(e: any): void;
+    /**
+     * @hidden
+     */
+    ngOnDestroy(): void;
+    /**
+     * Registers a `SortableComponent` with the `SortableService` so that it can be managed by the service.
+     *
+     * @param sortableComponent - The `SortableComponent`.
+     * @return - The unique key that the current `SortableComponent` gets when registered.
+     */
+    registerComponent(sortableComponent: SortableComponent): string;
+    /**
+     * Removes a `SortableComponent` from the registered `SortableComponents` with which the service operates.
+     *
+     * @param key - The key of the `SortableComponent` which will be removed from the register.
+     * Obtained when `registerComponent` is called.
+     */
+    unregisterComponent(key: string): void;
+    /**
+     * Sets the `SortableComponent` as a source component. When dragging an item from one Sortable to another,
+     * the source component is the one from which the item originates.
+     *
+     * @param sortable - The `SortableComponent`.
+     */
+    setSource(sortable: SortableComponent): void;
+    /**
+     * Returns the source `SortableComponent` from which
+     * an item is dragged to other Sortable components.
+     *
+     * @return - The `SourceComponent`.
+     */
+    getSource(): SortableComponent;
+    /**
+     * The method that finds the `SortableComponent` which is registered to
+     * the `SortableService` by using the arguments of the `touch` event.
+     *
+     * @param touch - A Touch-Object of the `Touch` type interface.
+     * Represents a single contact point (finger or stylus)
+     * on a touch-sensitive device (touchscreen or trackpad).
+     *
+     * @return { component: SortableComponent, index: number } - An object where the component is the `SortableComponent` that owns the item and the index is the index of the touched item.
+     */
+    getSortableComponentFromTouch(touch: any): {
+        component: SortableComponent;
+        index: number;
+    };
+    private start;
+    private release;
+    private drag;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortableService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SortableService>;
+}
+
+/**
+ * Defines an event whose default action can be prevented
+ * by calling the `preventDefault` method.
+ *
+ * @hidden
+ */
+declare abstract class PreventableEvent {
+    private prevented;
+    /**
+     * Prevents the default action for a specified event.
+     * In this way, the source component suppresses
+     * the built-in behavior that follows the event.
+     */
+    preventDefault(): void;
+    /**
+     * If the event was prevented
+     * by any of its subscribers, returns `true`.
+     *
+     * @returns `true` if the default action was prevented. Otherwise, returns `false`.
+     */
+    isDefaultPrevented(): boolean;
+}
+
+/**
+ * Represents the arguments for the `dataAdd` and `dataRemove` events.
+ * @hidden
+ */
+interface DataEvent {
+    /**
+     * Specifies the index of the data item.
+     */
+    index: number;
+    /**
+     * Specifies the data item to add or remove.
+     */
+    dataItem: object;
+    /**
+     * Specifies the Sortable component that emits the event.
+     */
+    sender: SortableComponent;
+}
+
+/**
+ * Represents the arguments for the `SortableComponent` `dataAdd` event.
+ */
+declare class DataAddEvent implements DataEvent {
+    /**
+     * Specifies the index of the data item.
+     */
+    index: number;
+    /**
+     * Specifies the data item to add.
+     */
+    dataItem: any;
+    /**
+     * Specifies the Sortable component that emits the event.
+     */
+    sender: SortableComponent;
+    /**
+     * @hidden
+     */
+    constructor(options: any);
+}
+/**
+ * Represents the arguments for the `SortableComponent` `dataRemove` event.
+ */
+declare class DataRemoveEvent implements DataEvent {
+    /**
+     * Specifies the index of the data item.
+     */
+    index: number;
+    /**
+     * Specifies the data item to remove.
+     */
+    dataItem: any;
+    /**
+     * Specifies the Sortable component that emits the event.
+     */
+    sender: SortableComponent;
+    /**
+     * @hidden
+     */
+    constructor(options: any);
+}
+/**
+ * Represents the arguments for the `SortableComponent` `dataMove` event.
+ */
+declare class DataMoveEvent extends PreventableEvent implements DataEvent {
+    /**
+     * Specifies the index of the data item.
+     */
+    index: number;
+    /**
+     * Specifies the old index of the data item.
+     */
+    oldIndex: number;
+    /**
+     * Specifies the data item to move.
+     */
+    dataItem: any;
+    /**
+     * Specifies the Sortable component that emits the event.
+     */
+    sender: SortableComponent;
+    /**
+     * @hidden
+     */
+    constructor(options: any);
+}
+
+/**
+ * Represents the [Kendo UI Sortable component for Angular](https://www.telerik.com/kendo-angular-ui/components/sortable).
+ *
+ * @example
+ * ```html
+ * <kendo-sortable [data]="['Item 1', 'Item 2', 'Item 3']"></kendo-sortable>
+ * ```
+ */
+declare class SortableComponent implements OnInit, OnDestroy, AfterViewInit, AfterViewChecked, AfterContentInit, SortableContainer {
+    private ngZone;
+    private renderer;
+    private cdr;
+    private localization;
+    private injector;
+    /**
+     * Specifies the tab index of the Sortable component.
+     */
+    set tabIndex(value: number);
+    get tabIndex(): number;
+    /**
+     * Configures how the Sortable component tracks changes in its items collection.
+     */
+    set trackBy(value: TrackByFunction<any>);
+    get trackBy(): TrackByFunction<any>;
+    /**
+     * Sets an array of any data that is used as a data source for the Sortable.
+     */
+    set data(data: Array<any>);
+    get data(): Array<any>;
+    /**
+     * Sets a boolean value that determines whether the Sortable items are navigable using the keyboard. [See example](https://www.telerik.com/kendo-angular-ui/components/sortable/keyboard-navigation).
+     * @default true
+     *
+     * @remarks
+     * This property is related to accessibility.
+     */
+    set navigable(value: boolean);
+    get navigable(): boolean;
+    /**
+     * Enables or disables built-in animations.
+     * @default false
+     */
+    set animation(value: boolean);
+    get animation(): boolean;
+    /**
+     * Sets an array of integers that represent the indexes of the disabled items from the data array. [See example](https://www.telerik.com/kendo-angular-ui/components/sortable/items#disabling-items).
+     */
+    set disabledIndexes(value: number[]);
+    get disabledIndexes(): number[];
+    /**
+     * Sets a string that represents the name of the zone to which the Sortable belongs
+     * ([see example](https://www.telerik.com/kendo-angular-ui/components/sortable/items#transferring-items)). Items can be transferred
+     * between Sortables in the same zone.
+     */
+    set zone(value: string);
+    get zone(): string;
+    /**
+     * Defines the zones from which items can be transferred onto the current Sortable component
+     * ([see example](https://www.telerik.com/kendo-angular-ui/components/sortable/items#transferring-items)). If the `acceptZones` property
+     * of the target Sortable is set, you can transfer items between Sortables in different zones.
+     */
+    set acceptZones(value: string[]);
+    get acceptZones(): string[];
+    /**
+     * Represents the CSS styles applied to each Sortable item.
+     */
+    set itemStyle(value: {
+        [key: string]: string;
+    });
+    get itemStyle(): {
+        [key: string]: string;
+    };
+    /**
+     * Defines the CSS styles applied to an empty item ([see example](https://www.telerik.com/kendo-angular-ui/components/sortable/templates)).
+     */
+    set emptyItemStyle(value: {
+        [key: string]: string;
+    });
+    get emptyItemStyle(): {
+        [key: string]: string;
+    };
+    /**
+     * Defines the CSS styles which are applied to the currently dragged item ([see example](https://www.telerik.com/kendo-angular-ui/components/sortable/templates)).
+     */
+    set activeItemStyle(value: {
+        [key: string]: string;
+    });
+    get activeItemStyle(): {
+        [key: string]: string;
+    };
+    /**
+     * Defines the CSS styles which are applied to all disabled items.
+     */
+    set disabledItemStyle(value: {
+        [key: string]: string;
+    });
+    get disabledItemStyle(): {
+        [key: string]: string;
+    };
+    /**
+     * Defines the class which is applied to each Sortable item.
+     */
+    set itemClass(value: string | string[] | Set<string>);
+    get itemClass(): string | string[] | Set<string>;
+    /**
+     * Defines the class which is applied to the active Sortable item.
+     */
+    set activeItemClass(value: string | string[] | Set<string>);
+    get activeItemClass(): string | string[] | Set<string>;
+    /**
+     * Defines the class which is applied to the empty item when the Sortable has empty data.
+     */
+    set emptyItemClass(value: string | string[] | Set<string>);
+    get emptyItemClass(): string | string[] | Set<string>;
+    /**
+     * Defines the class which is applied to each disabled Sortable item.
+     */
+    set disabledItemClass(value: string | string[] | Set<string>);
+    get disabledItemClass(): string | string[] | Set<string>;
+    /**
+     * Sets the text message that will be displayed when the Sortable has no items.
+     */
+    set emptyText(value: string);
+    get emptyText(): string;
+    /**
+     * @hidden
+     */
+    defaultTemplateRef: QueryList<TemplateRef<any>>;
+    /**
+     * Defines the template that will be used for rendering the items.
+     * @hidden
+     */
+    itemTemplateDirectiveRef: QueryList<TemplateRef<any>>;
+    /**
+     * Defines the template that will be used for rendering the placeholder.
+     * @hidden
+     */
+    placeholderTemplateDirectiveRef: QueryList<TemplateRef<any>>;
+    itemWrappers: QueryList<any>;
+    draggables: QueryList<DraggableDirective>;
+    noDataContainer: ElementRef;
+    hint: ElementRef;
+    /**
+     * Fires when the dragging of an item is started.
+     */
+    dragStart: EventEmitter<any>;
+    /**
+     * Fires when the dragging of an item is completed.
+     */
+    dragEnd: EventEmitter<any>;
+    /**
+     * Fires while the dragging of an item is in progress.
+     */
+    dragOver: EventEmitter<any>;
+    /**
+     * Fires when dragging an item outside of the component.
+     */
+    dragLeave: EventEmitter<any>;
+    /**
+     * Fires while the moving an item from one position to another.
+     */
+    dataMove: EventEmitter<DataMoveEvent>;
+    /**
+     * Fires when a new item is added to the Sortable.
+     */
+    dataAdd: EventEmitter<DataAddEvent>;
+    /**
+     * Fires when an item is removed from the Sortable.
+     */
+    dataRemove: EventEmitter<DataRemoveEvent>;
+    /**
+     * Fires when navigating using the keyboard.
+     */
+    navigate: EventEmitter<any>;
+    /**
+     * The index of the currently focused item.
+     * If no item is focused, set to `-1`.
+     */
+    set activeIndex(value: number);
+    get activeIndex(): number;
+    get touchAction(): string;
+    get dir(): string;
+    hostRole: string;
+    /**
+     * Flag indicating if the component is currently playing animations.
+     * @hidden
+     */
+    animating: boolean;
+    /**
+     * The index of the currently dragged item.
+     */
+    set dragIndex(value: number);
+    get dragIndex(): number;
+    /**
+     * The index of the item above which the dragged item is.
+     */
+    set dragOverIndex(value: number);
+    get dragOverIndex(): number;
+    onDragStartSubject: Subject<any>;
+    onDragOverSubject: Subject<any>;
+    onDragLeaveSubject: Subject<any>;
+    onDragEndSubject: Subject<any>;
+    /**
+     * The SortableComponent's HTMLElement.
+     */
+    wrapper: HTMLElement;
+    /**
+     * The location of the hint indicator when dragging on mobile devices.
+     */
+    set hintLocation(value: {
+        x: number;
+        y: number;
+    });
+    get hintLocation(): {
+        x: number;
+        y: number;
+    };
+    id: string;
+    itemTemplateRef: TemplateRef<any>;
+    placeholderTemplateRef: TemplateRef<any>;
+    _localData: Array<any>;
+    /**
+     * @hidden
+     */
+    ariaKeyShortcuts: string;
+    private _tabIndex;
+    private _trackBy;
+    private _data;
+    private _navigable;
+    private _animation;
+    private _disabledIndexes;
+    private _zone;
+    private _acceptZones;
+    private _itemStyle;
+    private _emptyItemStyle;
+    private _activeItemStyle;
+    private _disabledItemStyle;
+    private _itemClass;
+    private _activeItemClass;
+    private _emptyItemClass;
+    private _disabledItemClass;
+    private _emptyText;
+    private _activeIndex;
+    private _dragIndex;
+    private _dragOverIndex;
+    private _hintLocation;
+    private localizationChangeSubscription;
+    private dragStartSubscription;
+    private dragOverSubscription;
+    private dragLeaveSubscription;
+    private dragEndSubscription;
+    private childrenTabindexSubscription;
+    private focusableItems;
+    private animationDuration;
+    private afterKeyPress;
+    private sortableService;
+    private _hideActiveItem;
+    private prevActiveIndex;
+    private _direction;
+    private _animating;
+    private draggable;
+    private offsetParent;
+    protected setItemData(data: any, i: number): any;
+    /**
+     * @hidden
+     */
+    itemTemplate(index: number): TemplateRef<any>;
+    /**
+     * @hidden
+     */
+    readonly hintVisible: i0.Signal<boolean>;
+    constructor(ngZone: NgZone, renderer: Renderer2, cdr: ChangeDetectorRef, localization: LocalizationService, wrapper: ElementRef, sortableService: SortableService, injector: Injector);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    ngAfterContentInit(): void;
+    ngAfterViewChecked(): void;
+    /**
+     * @hidden
+     */
+    setFocusableChildren(): void;
+    /**
+     * @hidden
+     */
+    updateCacheIndices(): void;
+    /**
+     * @hidden
+     */
+    cacheData(): void;
+    /**
+     * @hidden
+     */
+    startDrag(event: any): boolean;
+    /**
+     * @hidden
+     */
+    setInitialItemTabindex(): void;
+    /**
+     * @hidden
+     */
+    drag(event: any): boolean;
+    /**
+     * @hidden
+     */
+    leave(event: any): boolean;
+    /**
+     * @hidden
+     */
+    endDrag(event: any): boolean;
+    /**
+     * @hidden
+     */
+    currentItemStyle(index: number): {
+        [key: string]: string;
+    };
+    /**
+     * @hidden
+     */
+    currentItemClass(index: number): string | string[] | Set<string>;
+    /**
+     * @hidden
+     */
+    hintStyle(): {
+        [key: string]: string;
+    };
+    /**
+     * @hidden
+     */
+    itemEnabled(index: number): boolean;
+    /**
+     * @hidden
+     */
+    acceptDragFrom(sortableComponent: SortableComponent): boolean;
+    /**
+     * @hidden
+     */
+    ariaDropEffect(index: number): string;
+    /**
+     * @hidden
+     */
+    focusHandler(index: number): void;
+    /**
+     * @hidden
+     */
+    blurHandler(): void;
+    /**
+     * @hidden
+     */
+    onArrowHandler(event: any, keyCode: string): void;
+    /**
+     * @hidden
+     */
+    onEnterHandler(item: any): void;
+    /**
+     * @hidden
+     */
+    onEscapeHandler(event: KeyboardEvent): void;
+    /**
+     * @hidden
+     */
+    keydownHandler: (event: KeyboardEvent) => void;
+    /**
+     * Removes the currently active item from the Data collection that the Sortable uses.
+     */
+    removeDataItem(index: number): void;
+    /**
+     * Sets a boolean value that indicates whether the item will be hidden or not.
+     * @hidden
+     */
+    hideItem(index: number, hidden?: boolean): void;
+    /**
+     * Gets or sets a boolean value that indicates whether the currently dragged item will be hidden.
+     *
+     * If the currently dragged item is hidden, returns `true`.
+     * If the currently dragged item is visible, returns `false`.
+     */
+    get hideActiveItem(): boolean;
+    set hideActiveItem(value: boolean);
+    /**
+     * Clears the active item.
+     * An active item is the one that is currently focused when the user navigates with the keyboard.
+     */
+    clearActiveItem(): void;
+    /**
+     * Returns the currently active item when the user navigates with the keyboard.
+     * @return - The data item which is currently active.
+     */
+    getActiveItem(): any;
+    /**
+     * Inserts a new data item at a particular index in the Sortable component.
+     * @param dataItem - The data item.
+     * @param index - The index at which the data item is inserted.
+     */
+    addDataItem(dataItem: any, index: number): void;
+    /**
+     * Moves a data item from one index to another in the Sortable component.
+     * @param fromIndex - The data item's index.
+     * @param toIndex - The index which the data item should be moved to. Item currently sitting at that index is pushed back one position.
+     */
+    moveItem(fromIndex: number, toIndex: number): void;
+    /**
+     * @hidden
+     */
+    animate(draggables: any[]): void;
+    /**
+     * @hidden
+     */
+    positionHintFromEvent(event: any): void;
+    /**
+     * @hidden
+     */
+    parentOffset(): any;
+    /**
+     * @hidden
+     */
+    markForCheck(): void;
+    /**
+     * @hidden
+     */
+    reflow(element: any): void;
+    /**
+     * @hidden
+     */
+    swapFocusableChildren(firstItemIndex: number, secondItemIndex: number): void;
+    /**
+     * @hidden
+     */
+    applyAnimationStyle(el: any, prop: any, val: string): void;
+    private subscribeEvents;
+    private unsubscribeEvents;
+    private placeHolderItemData;
+    private fixFocus;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SortableComponent, "kendo-sortable", ["kendoSortable"], { "tabIndex": { "alias": "tabIndex"; "required": false; }; "trackBy": { "alias": "trackBy"; "required": false; }; "data": { "alias": "data"; "required": false; }; "navigable": { "alias": "navigable"; "required": false; }; "animation": { "alias": "animation"; "required": false; }; "disabledIndexes": { "alias": "disabledIndexes"; "required": false; }; "zone": { "alias": "zone"; "required": false; }; "acceptZones": { "alias": "acceptZones"; "required": false; }; "itemStyle": { "alias": "itemStyle"; "required": false; }; "emptyItemStyle": { "alias": "emptyItemStyle"; "required": false; }; "activeItemStyle": { "alias": "activeItemStyle"; "required": false; }; "disabledItemStyle": { "alias": "disabledItemStyle"; "required": false; }; "itemClass": { "alias": "itemClass"; "required": false; }; "activeItemClass": { "alias": "activeItemClass"; "required": false; }; "emptyItemClass": { "alias": "emptyItemClass"; "required": false; }; "disabledItemClass": { "alias": "disabledItemClass"; "required": false; }; "emptyText": { "alias": "emptyText"; "required": false; }; "activeIndex": { "alias": "activeIndex"; "required": false; }; }, { "dragStart": "dragStart"; "dragEnd": "dragEnd"; "dragOver": "dragOver"; "dragLeave": "dragLeave"; "dataMove": "dataMove"; "dataAdd": "dataAdd"; "dataRemove": "dataRemove"; "navigate": "navigate"; }, ["defaultTemplateRef", "itemTemplateDirectiveRef", "placeholderTemplateDirectiveRef"], never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class ItemTemplateDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItemTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ItemTemplateDirective, "[kendoSortableItemTemplate]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * @hidden
+ */
+declare class PlaceholderTemplateDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<PlaceholderTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PlaceholderTemplateDirective, "[kendoSortablePlaceholderTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Represents a directive that handles common scenarios such as reordering and moving items between Sortables, reducing boilerplate code.
+ *
+ * This directive subscribes to the Sortable's events and handles them using the provided API methods.
+ *
+ * @example
+ * ```html
+ * <kendo-sortable
+ *      [kendoSortableBinding]="items"
+ *      [navigable]="true"
+ *      [animation]="true"
+ *      itemClass="item col-xs-6 col-sm-3"
+ *      activeItemClass="item col-xs-6 col-sm-3 active">
+ * </kendo-sortable>
+ * ```
+ *
+ * @remarks
+ * Applied to: {@link SortableComponent}
+ */
+declare class SortableBindingDirective implements OnInit, OnDestroy {
+    sortable: SortableComponent;
+    private sortableService;
+    private removeHiddenSubscription;
+    private dragOverSubscription;
+    private navigateSubscription;
+    private dragEndSubscription;
+    private dragStartSubscription;
+    private lastTarget;
+    private originalSource;
+    private addedItemIndex;
+    private pendingDataAdd;
+    private pendingDataRemove;
+    /**
+     * Sets a data-bound array that is used as a data source for the Sortable ([see example](https://www.telerik.com/kendo-angular-ui/components/sortable)).
+     */
+    set data(data: any[]);
+    constructor(sortable: SortableComponent, sortableService: SortableService);
+    private nextEnabledIndex;
+    private addItem;
+    private removeItem;
+    private moveItem;
+    /**
+     * Removes the Draggable item from which the drag started.
+     * @hidden
+     */
+    private removeOriginDraggable;
+    private onDragOver;
+    private onNavigate;
+    private onDragStart;
+    private onDragEnd;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortableBindingDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SortableBindingDirective, "[kendoSortableBinding]", never, { "data": { "alias": "kendoSortableBinding"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Represents the [`NgModule`](link:site.data.urls.angular['ngmoduleapi']) definition for the Sortable component.
+ *
+ * @example
+ * ```typescript
+ * import { NgModule } from '@angular/core';
+ * import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
+ * import { SortableModule } from '@progress/kendo-angular-sortable';
+ * import { AppComponent } from './app.component';
+ *
+ * @NgModule({
+ *     declarations: [AppComponent],
+ *     imports:      [BrowserModule, SortableModule],
+ *     bootstrap:    [AppComponent]
+ * })
+ * export class AppModule {}
+ * ```
+ */
+declare class SortableModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SortableModule, never, [typeof SortableComponent, typeof DraggableDirective, typeof PlaceholderTemplateDirective, typeof ItemTemplateDirective, typeof SortableBindingDirective], [typeof SortableComponent, typeof DraggableDirective, typeof PlaceholderTemplateDirective, typeof ItemTemplateDirective, typeof SortableBindingDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SortableModule>;
+}
+
+/**
+ * Represents the arguments for the `DraggableDirective` events.
+ * @hidden
+ */
+declare class DraggableEvent extends PreventableEvent {
+    /**
+     * Specifies the target `DraggableDirective` instance.
+     */
+    target: DraggableDirective;
+    /**
+     * Specifies the browser event emitted by the target's native element.
+     */
+    originalEvent: any;
+    /**
+     * @hidden
+     */
+    constructor(options: any);
+}
+
+/**
+ * Represents the arguments for the `dragStart`, `dragOver`, and `dragEnd` events.
+ * @hidden
+ */
+interface SortableEvent {
+    /**
+     * Specifies the index of the data item.
+     */
+    index: number;
+    /**
+     * Specifies the previous index of the data item.
+     */
+    oldIndex: number;
+}
+
+/**
+ * Represents the arguments for the `dragStart` event.
+ */
+declare class DragStartEvent extends PreventableEvent implements SortableEvent {
+    /**
+     * Specifies the index of the draggable item.
+     */
+    index: number;
+    /**
+     * Specifies the previous index of the draggable item.
+     * This property is used for the `dragEnd and `dragOver` events to determine the original position of the item before dragging.
+     * It doesn't apply to the `dragStart` event as there is no previous position at that point.
+     */
+    oldIndex: number;
+    /**
+     * @hidden
+     */
+    constructor(options: any);
+}
+/**
+ * Represents the arguments for the `dragOver` event.
+ */
+declare class DragOverEvent extends DragStartEvent {
+}
+/**
+ * Represents the arguments for the `dragEnd` event.
+ */
+declare class DragEndEvent extends DragOverEvent {
+}
+
+/**
+ * Represents the event arguments for the `navigate` event, which is emitted when you use the keyboard arrows.
+ */
+declare class NavigateEvent extends PreventableEvent implements SortableEvent {
+    /**
+     * Specifies the index of the draggable item.
+     */
+    index: number;
+    /**
+     * Specifies the old index of the draggable item.
+     */
+    oldIndex: number;
+    /**
+     * Indicates whether the `Ctrl` or meta keys are pressed.
+     */
+    ctrlKey: boolean;
+    /**
+     * @hidden
+     */
+    constructor(options: any);
+}
+
+/**
+ * Use this utility array to access all `@progress/kendo-angular-sortable`-related components and directives in a standalone Angular component.
+ *
+ * @example
+ * ```typescript
+ * import { Component } from '@angular/core';
+ * import { KENDO_SORTABLE } from '@progress/kendo-angular-sortable';
+ *
+ * @Component({
+ *   selector: 'my-app',
+ *   standalone: true,
+ *   imports: [KENDO_SORTABLE],
+ *   template: `
+ *      <kendo-sortable [kendoSortableBinding]="items">
+ *      </kendo-sortable>
+ *   `
+ * })
+ *
+ * export class AppComponent {
+ *    public items = ['Item 1', 'Item 2', 'Item 3'];
+ * }
+ * ```
+ */
+declare const KENDO_SORTABLE: readonly [typeof SortableComponent, typeof DraggableDirective, typeof PlaceholderTemplateDirective, typeof ItemTemplateDirective, typeof SortableBindingDirective];
+
+export { DataAddEvent, DataMoveEvent, DataRemoveEvent, DragEndEvent, DragOverEvent, DragStartEvent, DraggableDirective, DraggableEvent, ItemTemplateDirective, KENDO_SORTABLE, NavigateEvent, PlaceholderTemplateDirective, PreventableEvent, SortableBindingDirective, SortableComponent, SortableContainer, SortableModule, SortableService };
+export type { DataEvent, SortableEvent };