vue-devui 1.6.34 → 1.6.36-alpha.0

package/types/dragdrop-new/src/droppable.directive.d.ts

@@ -1,137 +1,137 @@
-import { Subject } from 'rxjs';
-import { EventEmitter } from './preserve-next-event-emitter';
-import { DragDropService } from './drag-drop.service';
-import { DirectiveBinding, InjectionKey, VNode } from 'vue';
-import { NgDirectiveBase } from './directive-base';
-export type DropIndexFlag = 'beforeAll' | 'afterAll';
-export interface IDroppableBinding {
-    dragOverClass?: string;
-    dropScope?: string | Array<string>;
-    placeholderTag?: string;
-    placeholderStyle?: Record<string, string>;
-    placeholderText?: string;
-    allowDropOnItem?: boolean;
-    dragOverItemClass?: string;
-    nestingTargetRect?: {
-        height?: number;
-        width?: number;
-    };
-    switchWhileCrossEdge?: boolean;
-    defaultDropPosition?: 'closest' | 'before' | 'after';
-    dropSortCountSelector: string;
-    dropSortVirtualScrollOption?: {
-        totalLength?: number;
-        startIndex?: number;
-    };
-}
-export interface IDroppableListener {
-    '@dragEnterEvent'?: (_: any) => void;
-    '@dragOverEvent'?: (_: any) => void;
-    '@dragLeaveEvent'?: (_: any) => void;
-    '@dropEvent'?: (_: any) => void;
-}
-export declare class DropEvent {
-    nativeEvent: any;
-    dragData: any;
-    batchDragData: any;
-    dropSubject: Subject<any>;
-    dropIndex?: number;
-    dragFromIndex?: number;
-    dropOnItem?: boolean;
-    dropOnOrigin?: boolean;
-    constructor(event: any, data: any, dropSubject: Subject<any>, dropIndex?: number, dragFromIndex?: number, dropOnItem?: boolean, dropOnOrigin?: boolean, batchDragData?: Array<any>);
-}
-export interface DragPlaceholderInsertionEvent {
-    command: 'insertBefore' | 'append' | 'remove';
-    container?: HTMLElement;
-    relatedEl?: Element;
-}
-export interface DragPlaceholderInsertionIndexEvent {
-    command: 'insertBefore' | 'append' | 'remove';
-    index?: number;
-}
-export declare class DroppableDirective extends NgDirectiveBase<IDroppableBinding, IDroppableListener> {
-    static INSTANCE_KEY: string;
-    static TOKEN: InjectionKey<DroppableDirective>;
-    hostListenerMap?: {
-        [key: string]: string;
-    } | undefined;
-    dragEnterEvent: EventEmitter<any>;
-    dragOverEvent: EventEmitter<any>;
-    dragLeaveEvent: EventEmitter<any>;
-    dropEvent: EventEmitter<DropEvent>;
-    dragOverClass?: string;
-    dropScope: string | Array<string>;
-    placeholderTag: string;
-    placeholderStyle: any;
-    placeholderText: string;
-    allowDropOnItem: boolean;
-    dragOverItemClass?: string;
-    nestingTargetRect?: {
-        height?: number;
-        width?: number;
-    };
-    switchWhileCrossEdge: boolean;
-    defaultDropPosition: 'closest' | 'before' | 'after';
-    dropSortCountSelector?: string;
-    dropSortVirtualScrollOption?: {
-        totalLength?: number;
-        startIndex?: number;
-    };
-    private dropFlag?;
-    private sortContainer;
-    private sortDirection?;
-    private sortDirectionZMode?;
-    private placeholder;
-    private dragCount;
-    private dropIndex?;
-    private dragStartSubscription?;
-    private dragEndSubscription?;
-    private dropEndSubscription?;
-    private overElement?;
-    private dragPartEventSub?;
-    private allowDropCache?;
-    private dragElIndex?;
-    placeholderInsertionEvent: Subject<DragPlaceholderInsertionEvent>;
-    placeholderRenderEvent: Subject<any>;
-    document: Document;
-    el: {
-        nativeElement: any;
-    };
-    private dragDropService;
-    constructor(el: HTMLElement, dragDropService: DragDropService);
-    ngOnInit(): void;
-    ngAfterViewInit(): void;
-    ngOnDestroy(): void;
-    dragEnter(e: DragEvent): void;
-    dragOver(e: DragEvent): void;
-    dragLeave(e: DragEvent): void;
-    drop(e: DragEvent): void;
-    allowDrop(e: DragEvent): boolean;
-    private dropSortCountSelectorFilterFn;
-    private findSortableEl;
-    private calcPosition;
-    private calcPositionOutside;
-    setPlaceholder: () => void;
-    private insertPlaceholder;
-    private isDragPlaceholderPosition;
-    private hitDragOriginPlaceholder;
-    private removePlaceholder;
-    private removeDragoverItemClass;
-    private checkSelfFromIndex;
-    private getRealIndex;
-    getBoundingRectAndRealPosition(targetElement: HTMLElement): any;
-    getSortContainer(): any;
-}
-declare const _default: {
-    mounted(el: HTMLElement & {
-        [props: string]: any;
-    }, binding: DirectiveBinding<IDroppableBinding & IDroppableListener>, vNode: VNode): void;
-    updated(el: HTMLElement & {
-        [props: string]: any;
-    }, binding: DirectiveBinding<IDroppableBinding & IDroppableListener>): void;
-    beforeUnmount(el: HTMLElement & {
-        [props: string]: any;
-    }): void;
-};
-export default _default;
+import { Subject } from 'rxjs';
+import { EventEmitter } from './preserve-next-event-emitter';
+import { DragDropService } from './drag-drop.service';
+import { DirectiveBinding, InjectionKey, VNode } from 'vue';
+import { NgDirectiveBase } from './directive-base';
+export type DropIndexFlag = 'beforeAll' | 'afterAll';
+export interface IDroppableBinding {
+    dragOverClass?: string;
+    dropScope?: string | Array<string>;
+    placeholderTag?: string;
+    placeholderStyle?: Record<string, string>;
+    placeholderText?: string;
+    allowDropOnItem?: boolean;
+    dragOverItemClass?: string;
+    nestingTargetRect?: {
+        height?: number;
+        width?: number;
+    };
+    switchWhileCrossEdge?: boolean;
+    defaultDropPosition?: 'closest' | 'before' | 'after';
+    dropSortCountSelector: string;
+    dropSortVirtualScrollOption?: {
+        totalLength?: number;
+        startIndex?: number;
+    };
+}
+export interface IDroppableListener {
+    '@dragEnterEvent'?: (_: any) => void;
+    '@dragOverEvent'?: (_: any) => void;
+    '@dragLeaveEvent'?: (_: any) => void;
+    '@dropEvent'?: (_: any) => void;
+}
+export declare class DropEvent {
+    nativeEvent: any;
+    dragData: any;
+    batchDragData: any;
+    dropSubject: Subject<any>;
+    dropIndex?: number;
+    dragFromIndex?: number;
+    dropOnItem?: boolean;
+    dropOnOrigin?: boolean;
+    constructor(event: any, data: any, dropSubject: Subject<any>, dropIndex?: number, dragFromIndex?: number, dropOnItem?: boolean, dropOnOrigin?: boolean, batchDragData?: Array<any>);
+}
+export interface DragPlaceholderInsertionEvent {
+    command: 'insertBefore' | 'append' | 'remove';
+    container?: HTMLElement;
+    relatedEl?: Element;
+}
+export interface DragPlaceholderInsertionIndexEvent {
+    command: 'insertBefore' | 'append' | 'remove';
+    index?: number;
+}
+export declare class DroppableDirective extends NgDirectiveBase<IDroppableBinding, IDroppableListener> {
+    static INSTANCE_KEY: string;
+    static TOKEN: InjectionKey<DroppableDirective>;
+    hostListenerMap?: {
+        [key: string]: string;
+    } | undefined;
+    dragEnterEvent: EventEmitter<any>;
+    dragOverEvent: EventEmitter<any>;
+    dragLeaveEvent: EventEmitter<any>;
+    dropEvent: EventEmitter<DropEvent>;
+    dragOverClass?: string;
+    dropScope: string | Array<string>;
+    placeholderTag: string;
+    placeholderStyle: any;
+    placeholderText: string;
+    allowDropOnItem: boolean;
+    dragOverItemClass?: string;
+    nestingTargetRect?: {
+        height?: number;
+        width?: number;
+    };
+    switchWhileCrossEdge: boolean;
+    defaultDropPosition: 'closest' | 'before' | 'after';
+    dropSortCountSelector?: string;
+    dropSortVirtualScrollOption?: {
+        totalLength?: number;
+        startIndex?: number;
+    };
+    private dropFlag?;
+    private sortContainer;
+    private sortDirection?;
+    private sortDirectionZMode?;
+    private placeholder;
+    private dragCount;
+    private dropIndex?;
+    private dragStartSubscription?;
+    private dragEndSubscription?;
+    private dropEndSubscription?;
+    private overElement?;
+    private dragPartEventSub?;
+    private allowDropCache?;
+    private dragElIndex?;
+    placeholderInsertionEvent: Subject<DragPlaceholderInsertionEvent>;
+    placeholderRenderEvent: Subject<any>;
+    document: Document;
+    el: {
+        nativeElement: any;
+    };
+    private dragDropService;
+    constructor(el: HTMLElement, dragDropService: DragDropService);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    dragEnter(e: DragEvent): void;
+    dragOver(e: DragEvent): void;
+    dragLeave(e: DragEvent): void;
+    drop(e: DragEvent): void;
+    allowDrop(e: DragEvent): boolean;
+    private dropSortCountSelectorFilterFn;
+    private findSortableEl;
+    private calcPosition;
+    private calcPositionOutside;
+    setPlaceholder: () => void;
+    private insertPlaceholder;
+    private isDragPlaceholderPosition;
+    private hitDragOriginPlaceholder;
+    private removePlaceholder;
+    private removeDragoverItemClass;
+    private checkSelfFromIndex;
+    private getRealIndex;
+    getBoundingRectAndRealPosition(targetElement: HTMLElement): any;
+    getSortContainer(): any;
+}
+declare const _default: {
+    mounted(el: HTMLElement & {
+        [props: string]: any;
+    }, binding: DirectiveBinding<IDroppableBinding & IDroppableListener>, vNode: VNode): void;
+    updated(el: HTMLElement & {
+        [props: string]: any;
+    }, binding: DirectiveBinding<IDroppableBinding & IDroppableListener>): void;
+    beforeUnmount(el: HTMLElement & {
+        [props: string]: any;
+    }): void;
+};
+export default _default;

package/types/dragdrop-new/src/preserve-next-event-emitter.d.ts

@@ -1,15 +1,15 @@
-import { Subject, Subscription } from 'rxjs';
-export declare class EventEmitter<T = any> extends Subject<T> {
-    protected __isAsync: boolean;
-    constructor(isAsync?: boolean);
-    emit(value?: any): void;
-    subscribe(generatorOrNext?: any, error?: any, complete?: any): Subscription;
-}
-export declare class PreserveNextEventEmitter<T> extends EventEmitter<T> {
-    private _schedulerFns;
-    private _isAsync;
-    get schedulerFns(): Set<any> | undefined;
-    forceCallback(value: T, once?: boolean): void;
-    cleanCallbackFn(): void;
-    subscribe(generatorOrNext?: any, error?: any, complete?: any): any;
-}
+import { Subject, Subscription } from 'rxjs';
+export declare class EventEmitter<T = any> extends Subject<T> {
+    protected __isAsync: boolean;
+    constructor(isAsync?: boolean);
+    emit(value?: any): void;
+    subscribe(generatorOrNext?: any, error?: any, complete?: any): Subscription;
+}
+export declare class PreserveNextEventEmitter<T> extends EventEmitter<T> {
+    private _schedulerFns;
+    private _isAsync;
+    get schedulerFns(): Set<any> | undefined;
+    forceCallback(value: T, once?: boolean): void;
+    cleanCallbackFn(): void;
+    subscribe(generatorOrNext?: any, error?: any, complete?: any): any;
+}

package/types/dragdrop-new/src/sortable.directive.d.ts

@@ -1,32 +1,32 @@
-import { DirectiveBinding } from 'vue';
-import { NgDirectiveBase } from './directive-base';
-export interface ISortableBinding {
-    dSortableZMode?: any;
-    dSortable?: 'v' | 'h';
-    [props: string]: any;
-}
-export declare class SortableDirective extends NgDirectiveBase<ISortableBinding> {
-    static INSTANCE_KEY: string;
-    dSortDirection: string;
-    dSortableZMode: boolean;
-    dSortable: boolean;
-    hostBindingMap?: {
-        [key: string]: string;
-    } | undefined;
-    inputNameMap?: {
-        [key: string]: string;
-    } | undefined;
-    el: {
-        nativeElement: any;
-    };
-    constructor(el: HTMLElement);
-}
-declare const _default: {
-    mounted(el: HTMLElement & {
-        [props: string]: any;
-    }, binding: DirectiveBinding<ISortableBinding>): void;
-    updated(el: HTMLElement & {
-        [props: string]: any;
-    }, binding: DirectiveBinding<ISortableBinding>): void;
-};
-export default _default;
+import { DirectiveBinding } from 'vue';
+import { NgDirectiveBase } from './directive-base';
+export interface ISortableBinding {
+    dSortableZMode?: any;
+    dSortable?: 'v' | 'h';
+    [props: string]: any;
+}
+export declare class SortableDirective extends NgDirectiveBase<ISortableBinding> {
+    static INSTANCE_KEY: string;
+    dSortDirection: string;
+    dSortableZMode: boolean;
+    dSortable: boolean;
+    hostBindingMap?: {
+        [key: string]: string;
+    } | undefined;
+    inputNameMap?: {
+        [key: string]: string;
+    } | undefined;
+    el: {
+        nativeElement: any;
+    };
+    constructor(el: HTMLElement);
+}
+declare const _default: {
+    mounted(el: HTMLElement & {
+        [props: string]: any;
+    }, binding: DirectiveBinding<ISortableBinding>): void;
+    updated(el: HTMLElement & {
+        [props: string]: any;
+    }, binding: DirectiveBinding<ISortableBinding>): void;
+};
+export default _default;

package/types/dragdrop-new/src/sync/desc-reg.service.d.ts

@@ -1,31 +1,31 @@
-import { Observable, Subject, Subscription } from 'rxjs';
-import { QueryList } from './query-list';
-import { NgDirectiveBase } from '../directive-base';
-export declare class DescendantRegisterService<T> {
-    protected _result: Array<T>;
-    protected changeSubject: Subject<Array<T>>;
-    changes: Observable<Array<T>>;
-    register(t: T): void;
-    unregister(t: T): void;
-    queryResult(): T[];
-}
-export declare class DescendantChildren<T, I extends {
-    [prop: string]: any;
-} = {
-    [prop: string]: any;
-}, O = {
-    [prop: string]: (e: any) => void;
-}> extends NgDirectiveBase<I, O> {
-    private drs;
-    constructor(drs: DescendantRegisterService<T>);
-    protected descendantItem: T;
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-}
-export declare class DescendantRoot<T> extends QueryList<T> {
-    private drs;
-    protected sub: Subscription;
-    constructor(drs: DescendantRegisterService<T>);
-    on(): void;
-    off(): void;
-}
+import { Observable, Subject, Subscription } from 'rxjs';
+import { QueryList } from './query-list';
+import { NgDirectiveBase } from '../directive-base';
+export declare class DescendantRegisterService<T> {
+    protected _result: Array<T>;
+    protected changeSubject: Subject<Array<T>>;
+    changes: Observable<Array<T>>;
+    register(t: T): void;
+    unregister(t: T): void;
+    queryResult(): T[];
+}
+export declare class DescendantChildren<T, I extends {
+    [prop: string]: any;
+} = {
+    [prop: string]: any;
+}, O = {
+    [prop: string]: (e: any) => void;
+}> extends NgDirectiveBase<I, O> {
+    private drs;
+    constructor(drs: DescendantRegisterService<T>);
+    protected descendantItem: T;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+}
+export declare class DescendantRoot<T> extends QueryList<T> {
+    private drs;
+    protected sub: Subscription;
+    constructor(drs: DescendantRegisterService<T>);
+    on(): void;
+    off(): void;
+}

package/types/dragdrop-new/src/sync/drag-drop-descendant-sync.service.d.ts

@@ -1,10 +1,10 @@
-import { DragSyncDirective } from './drag-sync.directive';
-import { DropSortSyncDirective } from './drop-sort-sync.directive';
-import { DescendantRegisterService } from './desc-reg.service';
-import { InjectionKey } from 'vue';
-export declare class DragSyncDescendantRegisterService extends DescendantRegisterService<DragSyncDirective> {
-    static TOKEN: InjectionKey<DragSyncDescendantRegisterService>;
-}
-export declare class DropSortSyncDescendantRegisterService extends DescendantRegisterService<DropSortSyncDirective> {
-    static TOKEN: InjectionKey<DropSortSyncDescendantRegisterService>;
-}
+import { DragSyncDirective } from './drag-sync.directive';
+import { DropSortSyncDirective } from './drop-sort-sync.directive';
+import { DescendantRegisterService } from './desc-reg.service';
+import { InjectionKey } from 'vue';
+export declare class DragSyncDescendantRegisterService extends DescendantRegisterService<DragSyncDirective> {
+    static TOKEN: InjectionKey<DragSyncDescendantRegisterService>;
+}
+export declare class DropSortSyncDescendantRegisterService extends DescendantRegisterService<DropSortSyncDirective> {
+    static TOKEN: InjectionKey<DropSortSyncDescendantRegisterService>;
+}

package/types/dragdrop-new/src/sync/drag-drop-sync-box.directive.d.ts

@@ -1,36 +1,36 @@
-import { DirectiveBinding } from 'vue';
-import { Subscription } from 'rxjs';
-import { DescendantRoot } from './desc-reg.service';
-import { DragSyncDescendantRegisterService, DropSortSyncDescendantRegisterService } from './drag-drop-descendant-sync.service';
-import { DragDropSyncService } from './drag-drop-sync.service';
-import { DragSyncDirective } from './drag-sync.directive';
-import { DropSortSyncDirective } from './drop-sort-sync.directive';
-import { NgDirectiveBase } from '../directive-base';
-export declare class DragDropSyncBoxDirective extends NgDirectiveBase {
-    private dragDropSyncService;
-    private dragSyncDrs;
-    private dropSortSyncDrs;
-    static INSTANCE_KEY: string;
-    sub: Subscription;
-    dragSyncList: DescendantRoot<DragSyncDirective>;
-    dropSyncList: DescendantRoot<DropSortSyncDirective>;
-    constructor(dragDropSyncService: DragDropSyncService, dragSyncDrs: DragSyncDescendantRegisterService, dropSortSyncDrs: DropSortSyncDescendantRegisterService);
-    ngOnInit(): void;
-    ngAfterViewInit(): void;
-    ngOnDestroy(): void;
-}
-declare const _default: {
-    created(el: HTMLElement & {
-        [props: string]: any;
-    }, binding: DirectiveBinding<{}>, vNode: any): void;
-    mounted(el: HTMLElement & {
-        [props: string]: any;
-    }, binding: DirectiveBinding<{}>, vNode: any): void;
-    updated(el: HTMLElement & {
-        [props: string]: any;
-    }, binding: DirectiveBinding<{}>): void;
-    beforeUnmount(el: HTMLElement & {
-        [props: string]: any;
-    }): void;
-};
-export default _default;
+import { DirectiveBinding } from 'vue';
+import { Subscription } from 'rxjs';
+import { DescendantRoot } from './desc-reg.service';
+import { DragSyncDescendantRegisterService, DropSortSyncDescendantRegisterService } from './drag-drop-descendant-sync.service';
+import { DragDropSyncService } from './drag-drop-sync.service';
+import { DragSyncDirective } from './drag-sync.directive';
+import { DropSortSyncDirective } from './drop-sort-sync.directive';
+import { NgDirectiveBase } from '../directive-base';
+export declare class DragDropSyncBoxDirective extends NgDirectiveBase {
+    private dragDropSyncService;
+    private dragSyncDrs;
+    private dropSortSyncDrs;
+    static INSTANCE_KEY: string;
+    sub: Subscription;
+    dragSyncList: DescendantRoot<DragSyncDirective>;
+    dropSyncList: DescendantRoot<DropSortSyncDirective>;
+    constructor(dragDropSyncService: DragDropSyncService, dragSyncDrs: DragSyncDescendantRegisterService, dropSortSyncDrs: DropSortSyncDescendantRegisterService);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+}
+declare const _default: {
+    created(el: HTMLElement & {
+        [props: string]: any;
+    }, binding: DirectiveBinding<{}>, vNode: any): void;
+    mounted(el: HTMLElement & {
+        [props: string]: any;
+    }, binding: DirectiveBinding<{}>, vNode: any): void;
+    updated(el: HTMLElement & {
+        [props: string]: any;
+    }, binding: DirectiveBinding<{}>): void;
+    beforeUnmount(el: HTMLElement & {
+        [props: string]: any;
+    }): void;
+};
+export default _default;

package/types/dragdrop-new/src/sync/drag-drop-sync.service.d.ts

@@ -1,13 +1,13 @@
-import { InjectionKey } from 'vue';
-import { DragSyncDirective } from './drag-sync.directive';
-import { DropSortSyncDirective } from './drop-sort-sync.directive';
-import { QueryList } from './query-list';
-export declare class DragDropSyncService {
-    static TOKEN: InjectionKey<DragDropSyncService>;
-    dragSyncList: QueryList<DragSyncDirective>;
-    dropSortSyncList: QueryList<DropSortSyncDirective>;
-    updateDragSyncList(list: QueryList<DragSyncDirective>): void;
-    getDragSyncByGroup(groupName: string): DragSyncDirective[];
-    updateDropSyncList(list: QueryList<DropSortSyncDirective>): void;
-    getDropSyncByGroup(groupName: string): DropSortSyncDirective[];
-}
+import { InjectionKey } from 'vue';
+import { DragSyncDirective } from './drag-sync.directive';
+import { DropSortSyncDirective } from './drop-sort-sync.directive';
+import { QueryList } from './query-list';
+export declare class DragDropSyncService {
+    static TOKEN: InjectionKey<DragDropSyncService>;
+    dragSyncList: QueryList<DragSyncDirective>;
+    dropSortSyncList: QueryList<DropSortSyncDirective>;
+    updateDragSyncList(list: QueryList<DragSyncDirective>): void;
+    getDragSyncByGroup(groupName: string): DragSyncDirective[];
+    updateDropSyncList(list: QueryList<DropSortSyncDirective>): void;
+    getDropSyncByGroup(groupName: string): DropSortSyncDirective[];
+}

package/types/dragdrop-new/src/sync/drag-sync.directive.d.ts

@@ -1,44 +1,44 @@
-import { DirectiveBinding } from 'vue';
-import { Subscription } from 'rxjs';
-import { DescendantChildren } from './desc-reg.service';
-import { DragSyncDescendantRegisterService } from './drag-drop-descendant-sync.service';
-import { DragDropSyncService } from './drag-drop-sync.service';
-import { DragDropService } from '../drag-drop.service';
-import { DraggableDirective } from '../draggable.directive';
-export interface IDragSyncBinding {
-    dragSync?: string;
-    dragSyncGroup?: string;
-    [props: string]: any;
-}
-export declare class DragSyncDirective extends DescendantChildren<DragSyncDirective, IDragSyncBinding> {
-    private draggable;
-    private dragDropSyncService;
-    private dragDropService;
-    static INSTANCE_KEY: string;
-    inputNameMap?: {
-        [key: string]: string;
-    } | undefined;
-    dragSyncGroup: string;
-    subscription: Subscription;
-    syncGroupDirectives?: Array<DragSyncDirective>;
-    el: {
-        nativeElement: any;
-    };
-    constructor(el: HTMLElement, draggable: DraggableDirective, dragDropSyncService: DragDropSyncService, dragDropService: DragDropService, dragSyncDrs: DragSyncDescendantRegisterService);
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    subDragElEvent: (bool: boolean) => void;
-    renderDisplay(nativeEl: HTMLElement, bool: boolean): void;
-}
-declare const _default: {
-    mounted(el: HTMLElement & {
-        [props: string]: any;
-    }, binding: DirectiveBinding<IDragSyncBinding>, vNode: any): void;
-    updated(el: HTMLElement & {
-        [props: string]: any;
-    }, binding: DirectiveBinding<IDragSyncBinding>): void;
-    beforeUnmount(el: HTMLElement & {
-        [props: string]: any;
-    }): void;
-};
-export default _default;
+import { DirectiveBinding } from 'vue';
+import { Subscription } from 'rxjs';
+import { DescendantChildren } from './desc-reg.service';
+import { DragSyncDescendantRegisterService } from './drag-drop-descendant-sync.service';
+import { DragDropSyncService } from './drag-drop-sync.service';
+import { DragDropService } from '../drag-drop.service';
+import { DraggableDirective } from '../draggable.directive';
+export interface IDragSyncBinding {
+    dragSync?: string;
+    dragSyncGroup?: string;
+    [props: string]: any;
+}
+export declare class DragSyncDirective extends DescendantChildren<DragSyncDirective, IDragSyncBinding> {
+    private draggable;
+    private dragDropSyncService;
+    private dragDropService;
+    static INSTANCE_KEY: string;
+    inputNameMap?: {
+        [key: string]: string;
+    } | undefined;
+    dragSyncGroup: string;
+    subscription: Subscription;
+    syncGroupDirectives?: Array<DragSyncDirective>;
+    el: {
+        nativeElement: any;
+    };
+    constructor(el: HTMLElement, draggable: DraggableDirective, dragDropSyncService: DragDropSyncService, dragDropService: DragDropService, dragSyncDrs: DragSyncDescendantRegisterService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    subDragElEvent: (bool: boolean) => void;
+    renderDisplay(nativeEl: HTMLElement, bool: boolean): void;
+}
+declare const _default: {
+    mounted(el: HTMLElement & {
+        [props: string]: any;
+    }, binding: DirectiveBinding<IDragSyncBinding>, vNode: any): void;
+    updated(el: HTMLElement & {
+        [props: string]: any;
+    }, binding: DirectiveBinding<IDragSyncBinding>): void;
+    beforeUnmount(el: HTMLElement & {
+        [props: string]: any;
+    }): void;
+};
+export default _default;