vue-devui 1.2.0 → 1.2.1-alpha.0

package/types/transfer/src/components/transfer-panel.d.ts

@@ -0,0 +1,148 @@
+import { TKey } from '../transfer-types';
+declare const _default: import("vue").DefineComponent<{
+    readonly title: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly height: {
+        readonly type: NumberConstructor;
+        readonly default: 320;
+    };
+    readonly data: {
+        readonly type: import("vue").PropType<import("../transfer-types").IItem[]>;
+        readonly default: () => never[];
+    };
+    readonly defaultChecked: {
+        readonly type: import("vue").PropType<TKey[]>;
+        readonly default: () => never[];
+    };
+    readonly filter: {
+        readonly type: import("vue").PropType<import("../transfer-types").filterValue>;
+        readonly default: false;
+    };
+    readonly unit: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly placeholder: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly isKeyupSearch: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly search: {
+        readonly type: import("vue").PropType<(direction: string, data: import("../transfer-types").IItem[], keyword: TKey) => void>;
+    };
+    readonly direction: {
+        readonly type: StringConstructor;
+        readonly default: "source";
+    };
+    readonly isDrag: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly sortMethods: {
+        readonly type: import("vue").PropType<(data: import("../transfer-types").IItem[]) => import("../transfer-types").IItem[]>;
+    };
+    readonly dragstart: {
+        readonly type: import("vue").PropType<(event: DragEvent, item: import("../transfer-types").IItem) => void>;
+    };
+    readonly drop: {
+        readonly type: import("vue").PropType<(event: DragEvent, item: import("../transfer-types").IItem) => void>;
+    };
+    readonly dragend: {
+        readonly type: import("vue").PropType<(event: DragEvent, item: import("../transfer-types").IItem) => void>;
+    };
+    readonly onUpdateAllChecked: {
+        readonly type: import("vue").PropType<(value: boolean) => void>;
+    };
+    readonly onChangeChecked: {
+        readonly type: import("vue").PropType<([]: TKey) => void>;
+    };
+    readonly renderContent: {
+        readonly type: import("vue").PropType<(h: import("vue").RenderFunction, option: import("../transfer-types").IItem) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>>;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, "updateAllChecked" | "changeChecked" | "changeButtonState", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly title: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly height: {
+        readonly type: NumberConstructor;
+        readonly default: 320;
+    };
+    readonly data: {
+        readonly type: import("vue").PropType<import("../transfer-types").IItem[]>;
+        readonly default: () => never[];
+    };
+    readonly defaultChecked: {
+        readonly type: import("vue").PropType<TKey[]>;
+        readonly default: () => never[];
+    };
+    readonly filter: {
+        readonly type: import("vue").PropType<import("../transfer-types").filterValue>;
+        readonly default: false;
+    };
+    readonly unit: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly placeholder: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly isKeyupSearch: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly search: {
+        readonly type: import("vue").PropType<(direction: string, data: import("../transfer-types").IItem[], keyword: TKey) => void>;
+    };
+    readonly direction: {
+        readonly type: StringConstructor;
+        readonly default: "source";
+    };
+    readonly isDrag: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly sortMethods: {
+        readonly type: import("vue").PropType<(data: import("../transfer-types").IItem[]) => import("../transfer-types").IItem[]>;
+    };
+    readonly dragstart: {
+        readonly type: import("vue").PropType<(event: DragEvent, item: import("../transfer-types").IItem) => void>;
+    };
+    readonly drop: {
+        readonly type: import("vue").PropType<(event: DragEvent, item: import("../transfer-types").IItem) => void>;
+    };
+    readonly dragend: {
+        readonly type: import("vue").PropType<(event: DragEvent, item: import("../transfer-types").IItem) => void>;
+    };
+    readonly onUpdateAllChecked: {
+        readonly type: import("vue").PropType<(value: boolean) => void>;
+    };
+    readonly onChangeChecked: {
+        readonly type: import("vue").PropType<([]: TKey) => void>;
+    };
+    readonly renderContent: {
+        readonly type: import("vue").PropType<(h: import("vue").RenderFunction, option: import("../transfer-types").IItem) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>>;
+    };
+}>>, {
+    readonly filter: import("../transfer-types").filterValue;
+    readonly data: import("../transfer-types").IItem[];
+    readonly height: number;
+    readonly direction: string;
+    readonly title: string;
+    readonly unit: string;
+    readonly placeholder: string;
+    readonly isKeyupSearch: boolean;
+    readonly defaultChecked: TKey[];
+    readonly isDrag: boolean;
+}>;
+export default _default;

package/types/transfer/src/composables/use-transfer-body.d.ts

@@ -0,0 +1,80 @@
+import { PropType, ExtractPropTypes, RenderFunction, VNode } from 'vue';
+import type { SetupContext } from 'vue';
+import { IItem, TKey, filterValue } from '../transfer-types';
+export declare const transferBodyProps: {
+    readonly height: {
+        readonly type: NumberConstructor;
+        readonly default: 320;
+    };
+    readonly data: {
+        readonly type: PropType<IItem[]>;
+        readonly default: () => never[];
+    };
+    readonly defaultChecked: {
+        readonly type: PropType<string[]>;
+        readonly default: () => never[];
+    };
+    readonly filter: {
+        readonly type: PropType<filterValue>;
+        readonly default: false;
+    };
+    readonly queryString: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly placeholder: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly isKeyupSearch: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly search: {
+        readonly type: PropType<(data: IItem[], keyword: TKey) => void>;
+    };
+    readonly isDrag: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly onChange: {
+        readonly type: PropType<(v: string[]) => void>;
+        readonly default: undefined;
+    };
+    readonly dragstart: {
+        readonly type: PropType<(event: DragEvent, item: IItem) => void>;
+    };
+    readonly drop: {
+        readonly type: PropType<(event: DragEvent, item: IItem) => void>;
+    };
+    readonly dragend: {
+        readonly type: PropType<(event: DragEvent, item: IItem) => void>;
+    };
+    readonly renderContent: {
+        readonly type: PropType<(h: RenderFunction, option: IItem) => VNode>;
+    };
+};
+export declare type TTransferBodyProps = ExtractPropTypes<typeof transferBodyProps>;
+export declare const transferBodyState: (props: TTransferBodyProps, ctx: SetupContext) => {
+    bodyHeight: import("vue").ComputedRef<string>;
+    query: import("vue").Ref<string>;
+    checkedListModels: import("vue").Ref<{
+        value: string | number;
+        checked: boolean;
+        name: string;
+    }[]>;
+    dragHighlight: import("vue").Ref<TKey | null>;
+    dragOverNodeKey: import("vue").Ref<any>;
+    dropPosition: import("vue").Ref<number | null>;
+    dragTimer: import("vue").Ref<number>;
+    dragRef: import("vue").Ref<HTMLElement | null>;
+    updateFilterQueryHandle: (value: TKey) => void;
+    updateCheckedListModels: (idx: number, value: boolean) => void;
+    setCurrentDragItem: (event: Event, item: IItem, reset: boolean) => void;
+    setDragOverNodeKeyHandle: (event: DragEvent, item: IItem) => void;
+    dragoverHandle: (event: DragEvent, item: IItem) => void;
+    dragleaveHandle: (event: DragEvent, item: IItem) => void;
+    dropHandle: (event: DragEvent, item: IItem) => void;
+    dragendHandle: (event: DragEvent, item: IItem) => void;
+    dragstartHandle: (event: DragEvent, item: IItem) => void;
+};

package/types/transfer/src/composables/use-transfer-header.d.ts

@@ -0,0 +1,39 @@
+import { ExtractPropTypes, PropType } from 'vue';
+import type { SetupContext } from 'vue';
+import { IItem, TKey } from '../transfer-types';
+export declare const transferHeaderProps: {
+    readonly title: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly checked: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly halfchecked: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly total: {
+        readonly type: NumberConstructor;
+        readonly default: 0;
+    };
+    readonly checkedNum: {
+        readonly type: NumberConstructor;
+        readonly default: 0;
+    };
+    readonly unit: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly onChange: {
+        readonly type: PropType<(value: boolean) => void>;
+    };
+    readonly search: {
+        readonly type: PropType<(direction: string, data: IItem[], keyword: TKey) => void>;
+    };
+};
+export declare type TTransferHeaderProps = ExtractPropTypes<typeof transferHeaderProps>;
+export declare const transferHeaderState: (props: TTransferHeaderProps, ctx: SetupContext) => {
+    allCheckedChangeHandle: (value: boolean) => void;
+};

package/types/transfer/src/composables/use-transfer-operate.d.ts

@@ -0,0 +1,23 @@
+import { ExtractPropTypes, PropType } from 'vue';
+import type { SetupContext } from 'vue';
+export declare const transferOperateProps: {
+    readonly sourceDisabled: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly targetDisabled: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly onToTarget: {
+        readonly type: PropType<() => void>;
+    };
+    readonly onToSource: {
+        readonly type: PropType<() => void>;
+    };
+};
+export declare type TTransferOperateProps = ExtractPropTypes<typeof transferOperateProps>;
+export declare const transferHeaderState: (props: TTransferOperateProps, ctx: SetupContext) => {
+    toTargetHandle: () => void;
+    toSourceHandle: () => void;
+};

package/types/transfer/src/composables/use-transfer-panel.d.ts

@@ -0,0 +1,84 @@
+import { PropType, ExtractPropTypes, RenderFunction, VNode } from 'vue';
+import type { SetupContext } from 'vue';
+import { IItem, TKey, filterValue } from '../transfer-types';
+export declare const transferPanelProps: {
+    readonly title: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly height: {
+        readonly type: NumberConstructor;
+        readonly default: 320;
+    };
+    readonly data: {
+        readonly type: PropType<IItem[]>;
+        readonly default: () => never[];
+    };
+    readonly defaultChecked: {
+        readonly type: PropType<TKey[]>;
+        readonly default: () => never[];
+    };
+    readonly filter: {
+        readonly type: PropType<filterValue>;
+        readonly default: false;
+    };
+    readonly unit: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly placeholder: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly isKeyupSearch: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly search: {
+        readonly type: PropType<(direction: string, data: IItem[], keyword: TKey) => void>;
+    };
+    readonly direction: {
+        readonly type: StringConstructor;
+        readonly default: "source";
+    };
+    readonly isDrag: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly sortMethods: {
+        readonly type: PropType<(data: IItem[]) => IItem[]>;
+    };
+    readonly dragstart: {
+        readonly type: PropType<(event: DragEvent, item: IItem) => void>;
+    };
+    readonly drop: {
+        readonly type: PropType<(event: DragEvent, item: IItem) => void>;
+    };
+    readonly dragend: {
+        readonly type: PropType<(event: DragEvent, item: IItem) => void>;
+    };
+    readonly onUpdateAllChecked: {
+        readonly type: PropType<(value: boolean) => void>;
+    };
+    readonly onChangeChecked: {
+        readonly type: PropType<([]: TKey) => void>;
+    };
+    readonly renderContent: {
+        readonly type: PropType<(h: RenderFunction, option: IItem) => VNode>;
+    };
+};
+export declare type TTransferPanelProps = ExtractPropTypes<typeof transferPanelProps>;
+export declare const transferPanelState: (props: TTransferPanelProps, ctx: SetupContext) => {
+    bodyHeight: import("vue").ComputedRef<string>;
+    filterData: import("vue").ComputedRef<IItem[]>;
+    checkableData: import("vue").ComputedRef<IItem[]>;
+    allChecked: import("vue").Ref<boolean>;
+    allHalfchecked: import("vue").ComputedRef<boolean>;
+    allNum: import("vue").ComputedRef<number>;
+    checkedNum: import("vue").ComputedRef<number>;
+    query: import("vue").Ref<string>;
+    changeAllCheckedHandle: (value: boolean) => void;
+    updateModelValueHandle: (value: TKey) => void;
+    updateCheckedDataHandle: (value: TKey[]) => void;
+    updateDataHandle: (startValue: TKey, endValue: TKey) => void;
+};

package/types/transfer/src/composables/use-transfer.d.ts

@@ -0,0 +1,30 @@
+import type { SetupContext } from 'vue';
+import { TTransferProps, TKey } from '../transfer-types';
+export declare const transferState: (props: TTransferProps, ctx: SetupContext) => {
+    sourceTitle: import("vue").ComputedRef<string>;
+    targetTitle: import("vue").ComputedRef<string>;
+    sourceData: import("vue").Ref<{
+        value: string | number;
+        name: string;
+        disabled: boolean;
+    }[]>;
+    targetData: import("vue").Ref<{
+        value: string | number;
+        name: string;
+        disabled: boolean;
+    }[]>;
+    sourceDisabled: import("vue").ComputedRef<boolean>;
+    targetDisabled: import("vue").ComputedRef<boolean>;
+    sourceChecked: import("vue").Ref<TKey[]>;
+    targetChecked: import("vue").Ref<TKey[]>;
+    sourceDirection: import("vue").Ref<string>;
+    targetDirection: import("vue").Ref<string>;
+    updateSourceAllCheckedHandle: (value: TKey[]) => void;
+    updateTargetAllCheckedHandle: (value: TKey[]) => void;
+    updateSourceCheckedHandle: (value: TKey[]) => void;
+    updateTargetCheckedHandle: (value: TKey[]) => void;
+    toMoveTargetHandle: () => void;
+    toMoveSourceHandle: () => void;
+    updateSourceDataHandle: (startValue: TKey, endValue: TKey) => void;
+    updateTargetDataHandle: (startValue: TKey, endValue: TKey) => void;
+};

package/types/transfer/src/transfer-types.d.ts

@@ -0,0 +1,96 @@
+import { PropType, ExtractPropTypes, VNode, RenderFunction } from 'vue';
+export interface IItem {
+    value: string | number;
+    name: string;
+    disabled: boolean;
+}
+export interface ICheckList {
+    value: string | number;
+    checked: boolean;
+    name: string;
+}
+export interface IDargItemAndDropItem {
+    startIndex: number;
+    endIndex: number;
+    dragItem: IItem;
+    dropItem: IItem;
+}
+export declare type TKey = string | number;
+export declare type filterValue = boolean | ((data: IItem, key: string) => IItem[]);
+export declare const transferProps: {
+    readonly modelValue: {
+        readonly type: PropType<string | number[]>;
+        readonly default: () => never[];
+    };
+    readonly data: {
+        readonly type: PropType<IItem[]>;
+        readonly default: () => never[];
+    };
+    readonly sourceDefaultChecked: {
+        readonly type: PropType<string | number[]>;
+        readonly default: () => never[];
+    };
+    readonly targetDefaultChecked: {
+        readonly type: PropType<string | number[]>;
+        readonly default: () => never[];
+    };
+    readonly titles: {
+        readonly type: PropType<string[]>;
+        readonly default: () => string[];
+    };
+    readonly sourceOption: {
+        readonly type: PropType<IItem[]>;
+        readonly default: () => never[];
+    };
+    readonly targetOption: {
+        readonly type: PropType<IItem[]>;
+        readonly default: () => never[];
+    };
+    readonly filter: {
+        readonly type: PropType<filterValue>;
+        readonly default: false;
+    };
+    readonly height: {
+        readonly type: NumberConstructor;
+        readonly default: 320;
+    };
+    readonly unit: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly placeholder: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly isKeyupSearch: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly isSourceDrag: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly isTargetDrag: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly search: {
+        readonly type: PropType<(data: IItem[], keyword: TKey) => void>;
+    };
+    readonly sortMethods: {
+        readonly type: PropType<(data: IItem[]) => IItem[]>;
+    };
+    readonly dragstart: {
+        readonly type: PropType<(event: DragEvent, item: IItem) => void>;
+    };
+    readonly drop: {
+        readonly type: PropType<(event: DragEvent, item: IItem) => void>;
+    };
+    readonly dragend: {
+        readonly type: PropType<(event: DragEvent, item: IItem) => void>;
+    };
+    readonly renderContent: {
+        readonly type: PropType<(h: RenderFunction, option: IItem) => VNode>;
+    };
+};
+export declare type TTransferProps = ExtractPropTypes<typeof transferProps>;

package/types/transfer/src/transfer.d.ts

@@ -0,0 +1,173 @@
+import { TKey, IItem } from './transfer-types';
+import './transfer.scss';
+declare const _default: import("vue").DefineComponent<{
+    readonly modelValue: {
+        readonly type: import("vue").PropType<string | number[]>;
+        readonly default: () => never[];
+    };
+    readonly data: {
+        readonly type: import("vue").PropType<IItem[]>;
+        readonly default: () => never[];
+    };
+    readonly sourceDefaultChecked: {
+        readonly type: import("vue").PropType<string | number[]>;
+        readonly default: () => never[];
+    };
+    readonly targetDefaultChecked: {
+        readonly type: import("vue").PropType<string | number[]>;
+        readonly default: () => never[];
+    };
+    readonly titles: {
+        readonly type: import("vue").PropType<string[]>;
+        readonly default: () => string[];
+    };
+    readonly sourceOption: {
+        readonly type: import("vue").PropType<IItem[]>;
+        readonly default: () => never[];
+    };
+    readonly targetOption: {
+        readonly type: import("vue").PropType<IItem[]>;
+        readonly default: () => never[];
+    };
+    readonly filter: {
+        readonly type: import("vue").PropType<import("./transfer-types").filterValue>;
+        readonly default: false;
+    };
+    readonly height: {
+        readonly type: NumberConstructor;
+        readonly default: 320;
+    };
+    readonly unit: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly placeholder: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly isKeyupSearch: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly isSourceDrag: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly isTargetDrag: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly search: {
+        readonly type: import("vue").PropType<(data: IItem[], keyword: TKey) => void>;
+    };
+    readonly sortMethods: {
+        readonly type: import("vue").PropType<(data: IItem[]) => IItem[]>;
+    };
+    readonly dragstart: {
+        readonly type: import("vue").PropType<(event: DragEvent, item: IItem) => void>;
+    };
+    readonly drop: {
+        readonly type: import("vue").PropType<(event: DragEvent, item: IItem) => void>;
+    };
+    readonly dragend: {
+        readonly type: import("vue").PropType<(event: DragEvent, item: IItem) => void>;
+    };
+    readonly renderContent: {
+        readonly type: import("vue").PropType<(h: import("vue").RenderFunction, option: IItem) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>>;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, "change" | "update:modelValue", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly modelValue: {
+        readonly type: import("vue").PropType<string | number[]>;
+        readonly default: () => never[];
+    };
+    readonly data: {
+        readonly type: import("vue").PropType<IItem[]>;
+        readonly default: () => never[];
+    };
+    readonly sourceDefaultChecked: {
+        readonly type: import("vue").PropType<string | number[]>;
+        readonly default: () => never[];
+    };
+    readonly targetDefaultChecked: {
+        readonly type: import("vue").PropType<string | number[]>;
+        readonly default: () => never[];
+    };
+    readonly titles: {
+        readonly type: import("vue").PropType<string[]>;
+        readonly default: () => string[];
+    };
+    readonly sourceOption: {
+        readonly type: import("vue").PropType<IItem[]>;
+        readonly default: () => never[];
+    };
+    readonly targetOption: {
+        readonly type: import("vue").PropType<IItem[]>;
+        readonly default: () => never[];
+    };
+    readonly filter: {
+        readonly type: import("vue").PropType<import("./transfer-types").filterValue>;
+        readonly default: false;
+    };
+    readonly height: {
+        readonly type: NumberConstructor;
+        readonly default: 320;
+    };
+    readonly unit: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly placeholder: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly isKeyupSearch: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly isSourceDrag: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly isTargetDrag: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly search: {
+        readonly type: import("vue").PropType<(data: IItem[], keyword: TKey) => void>;
+    };
+    readonly sortMethods: {
+        readonly type: import("vue").PropType<(data: IItem[]) => IItem[]>;
+    };
+    readonly dragstart: {
+        readonly type: import("vue").PropType<(event: DragEvent, item: IItem) => void>;
+    };
+    readonly drop: {
+        readonly type: import("vue").PropType<(event: DragEvent, item: IItem) => void>;
+    };
+    readonly dragend: {
+        readonly type: import("vue").PropType<(event: DragEvent, item: IItem) => void>;
+    };
+    readonly renderContent: {
+        readonly type: import("vue").PropType<(h: import("vue").RenderFunction, option: IItem) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>>;
+    };
+}>>, {
+    readonly filter: import("./transfer-types").filterValue;
+    readonly data: IItem[];
+    readonly height: number;
+    readonly unit: string;
+    readonly placeholder: string;
+    readonly modelValue: string | number[];
+    readonly isKeyupSearch: boolean;
+    readonly sourceDefaultChecked: string | number[];
+    readonly targetDefaultChecked: string | number[];
+    readonly titles: string[];
+    readonly sourceOption: IItem[];
+    readonly targetOption: IItem[];
+    readonly isSourceDrag: boolean;
+    readonly isTargetDrag: boolean;
+}>;
+export default _default;