@moubing/bing-ui 0.1.0 → 0.1.1

package/dist/components/BingResizable/BingResizable.types.d.ts

@@ -0,0 +1,63 @@
+export type BingResizableDirection = 'top' | 'right' | 'bottom' | 'left' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+export type BingResizableMode = 'fixed' | 'mirror';
+export type BingResizableSnapMode = 'live' | 'end';
+export type BingResizableSizeValue = number | string;
+export interface BingResizableSize {
+    width?: BingResizableSizeValue;
+    height?: BingResizableSizeValue;
+}
+export interface BingResizableResolvedSize {
+    width: number;
+    height: number;
+}
+export interface BingResizablePosition {
+    x: number;
+    y: number;
+}
+export type BingResizableStep = number | {
+    x?: number;
+    y?: number;
+};
+export interface BingResizableDelta {
+    x: number;
+    y: number;
+}
+export interface BingResizablePayload {
+    direction: BingResizableDirection;
+    size: BingResizableResolvedSize;
+    position: BingResizablePosition;
+    delta: BingResizableDelta;
+    event: PointerEvent | KeyboardEvent;
+}
+export interface BingResizableProps {
+    size?: BingResizableSize;
+    defaultSize?: BingResizableSize;
+    position?: Partial<BingResizablePosition>;
+    defaultPosition?: Partial<BingResizablePosition>;
+    minWidth?: BingResizableSizeValue;
+    minHeight?: BingResizableSizeValue;
+    maxWidth?: BingResizableSizeValue;
+    maxHeight?: BingResizableSizeValue;
+    mode?: BingResizableMode;
+    snapMode?: BingResizableSnapMode;
+    directions?: BingResizableDirection[];
+    step?: BingResizableStep;
+    disabled?: boolean;
+    lockAspectRatio?: boolean;
+    contain?: boolean;
+    showSize?: boolean;
+    handleSize?: number;
+    ariaLabel?: string;
+}
+export interface BingResizableEmits {
+    'update:size': [size: BingResizableResolvedSize];
+    'update:position': [position: BingResizablePosition];
+    'resize-start': [payload: BingResizablePayload];
+    resize: [payload: BingResizablePayload];
+    'resize-end': [payload: BingResizablePayload];
+}
+export interface BingResizableExpose {
+    reset: () => void;
+    getSize: () => BingResizableResolvedSize;
+    getPosition: () => BingResizablePosition;
+}

package/dist/components/BingResizable/BingResizable.vue.d.ts

@@ -0,0 +1,50 @@
+import { BingResizableDirection, BingResizableExpose, BingResizablePayload, BingResizablePosition, BingResizableProps, BingResizableResolvedSize, BingResizableSize } from './BingResizable.types';
+declare var __VLS_1: {}, __VLS_3: {
+    direction: BingResizableDirection;
+    active: boolean;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    handle?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<BingResizableProps, BingResizableExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    resize: (payload: BingResizablePayload) => any;
+    "update:size": (size: BingResizableResolvedSize) => any;
+    "update:position": (position: BingResizablePosition) => any;
+    "resize-start": (payload: BingResizablePayload) => any;
+    "resize-end": (payload: BingResizablePayload) => any;
+}, string, import('vue').PublicProps, Readonly<BingResizableProps> & Readonly<{
+    onResize?: ((payload: BingResizablePayload) => any) | undefined;
+    "onUpdate:size"?: ((size: BingResizableResolvedSize) => any) | undefined;
+    "onUpdate:position"?: ((position: BingResizablePosition) => any) | undefined;
+    "onResize-start"?: ((payload: BingResizablePayload) => any) | undefined;
+    "onResize-end"?: ((payload: BingResizablePayload) => any) | undefined;
+}>, {
+    disabled: boolean;
+    maxHeight: import('./BingResizable.types').BingResizableSizeValue;
+    maxWidth: import('./BingResizable.types').BingResizableSizeValue;
+    minHeight: import('./BingResizable.types').BingResizableSizeValue;
+    minWidth: import('./BingResizable.types').BingResizableSizeValue;
+    position: Partial<BingResizablePosition>;
+    ariaLabel: string;
+    size: BingResizableSize;
+    mode: import('./BingResizable.types').BingResizableMode;
+    defaultSize: BingResizableSize;
+    defaultPosition: Partial<BingResizablePosition>;
+    snapMode: import('./BingResizable.types').BingResizableSnapMode;
+    directions: BingResizableDirection[];
+    step: import('./BingResizable.types').BingResizableStep;
+    lockAspectRatio: boolean;
+    contain: boolean;
+    showSize: boolean;
+    handleSize: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/BingResizable/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BingResizable } from './BingResizable.vue';
+export type { BingResizableDelta, BingResizableDirection, BingResizableEmits, BingResizableExpose, BingResizableMode, BingResizablePayload, BingResizablePosition, BingResizableProps, BingResizableResolvedSize, BingResizableSize, BingResizableSizeValue, BingResizableStep, } from './BingResizable.types';

package/dist/components/BingScrollbar/BingScrollbar.types.d.ts

@@ -0,0 +1,20 @@
+export interface BingScrollbarProps {
+    height?: string | number;
+    maxHeight?: string | number;
+    minThumbSize?: number;
+    overflowTolerance?: number;
+    vertical?: boolean;
+    horizontal?: boolean;
+    always?: boolean;
+    disabled?: boolean;
+    ariaLabel?: string;
+}
+export interface BingScrollbarEmits {
+    scroll: [event: Event];
+}
+export interface BingScrollbarExpose {
+    scrollBy: (options: ScrollToOptions | number) => void;
+    scrollTo: (options: ScrollToOptions | number) => void;
+    update: () => void;
+    viewport: HTMLElement | null;
+}

package/dist/components/BingScrollbar/BingScrollbar.vue.d.ts

@@ -0,0 +1,28 @@
+import { BingScrollbarExpose, BingScrollbarProps } from './BingScrollbar.types';
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<BingScrollbarProps, BingScrollbarExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    scroll: (event: Event) => any;
+}, string, import('vue').PublicProps, Readonly<BingScrollbarProps> & Readonly<{
+    onScroll?: ((event: Event) => any) | undefined;
+}>, {
+    always: boolean;
+    disabled: boolean;
+    height: string | number;
+    maxHeight: string | number;
+    ariaLabel: string;
+    horizontal: boolean;
+    vertical: boolean;
+    minThumbSize: number;
+    overflowTolerance: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/BingScrollbar/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BingScrollbar } from './BingScrollbar.vue';
+export type { BingScrollbarEmits, BingScrollbarExpose, BingScrollbarProps, } from './BingScrollbar.types';

package/dist/components/BingSelect/BingSelect.types.d.ts

@@ -0,0 +1,57 @@
+import { BingGlassEffectProps } from '../../utils/glass';
+export type BingSelectValue = string | number;
+export type BingSelectModelValue = BingSelectValue | BingSelectValue[] | null;
+export type BingSelectSize = 'sm' | 'md' | 'lg';
+export type BingSelectVirtualMode = boolean | 'auto';
+export type BingSelectSearchable = boolean | 'auto';
+export type BingSelectOptionMetaValue = string | number | boolean | null | undefined;
+export interface BingSelectOption {
+    label: string;
+    value: BingSelectValue;
+    disabled?: boolean;
+    description?: string;
+    detail?: string;
+    meta?: Record<string, BingSelectOptionMetaValue>;
+    [key: string]: unknown;
+}
+export interface BingSelectProps extends BingGlassEffectProps {
+    id?: string;
+    modelValue?: BingSelectModelValue;
+    options?: BingSelectOption[];
+    multiple?: boolean;
+    placeholder?: string;
+    disabled?: boolean;
+    clearable?: boolean;
+    showSelectAll?: boolean;
+    selectAllText?: string;
+    clearAllText?: string;
+    emptyText?: string;
+    searchable?: BingSelectSearchable;
+    searchPlaceholder?: string;
+    noSearchResultsText?: string;
+    size?: BingSelectSize;
+    block?: boolean;
+    width?: string | number;
+    minWidth?: string | number;
+    panelMinHeight?: string | number;
+    panelMaxHeight?: string | number;
+    virtual?: BingSelectVirtualMode;
+    virtualThreshold?: number;
+    virtualItemHeight?: number;
+    virtualOverscan?: number;
+    ariaLabel?: string;
+    ariaDescribedby?: string;
+    status?: 'default' | 'error' | 'success' | 'warning';
+}
+export interface BingSelectChangePayload {
+    value: BingSelectModelValue;
+    option?: BingSelectOption;
+    options: BingSelectOption[];
+}
+export interface BingSelectEmits {
+    'update:modelValue': [value: BingSelectModelValue];
+    change: [payload: BingSelectChangePayload];
+    clear: [];
+    open: [];
+    close: [];
+}

package/dist/components/BingSelect/BingSelect.vue.d.ts

@@ -0,0 +1,72 @@
+import { BingSelectChangePayload, BingSelectModelValue, BingSelectOption, BingSelectProps } from './BingSelect.types';
+declare var __VLS_1: {
+    selectedOptions: BingSelectOption[];
+    placeholder: string;
+}, __VLS_77: {
+    option: BingSelectOption;
+    selected: boolean;
+}, __VLS_79: {
+    option: BingSelectOption;
+    selected: boolean;
+    index: number;
+};
+type __VLS_Slots = {} & {
+    value?: (props: typeof __VLS_1) => any;
+} & {
+    option?: (props: typeof __VLS_77) => any;
+} & {
+    'option-detail'?: (props: typeof __VLS_79) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<BingSelectProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    clear: () => any;
+    "update:modelValue": (value: BingSelectModelValue) => any;
+    change: (payload: BingSelectChangePayload) => any;
+    close: () => any;
+    open: () => any;
+}, string, import('vue').PublicProps, Readonly<BingSelectProps> & Readonly<{
+    onClear?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((value: BingSelectModelValue) => any) | undefined;
+    onChange?: ((payload: BingSelectChangePayload) => any) | undefined;
+    onClose?: (() => any) | undefined;
+    onOpen?: (() => any) | undefined;
+}>, {
+    disabled: boolean;
+    minWidth: string | number;
+    width: string | number;
+    glass: boolean;
+    ariaLabel: string;
+    modelValue: BingSelectModelValue;
+    size: import('./BingSelect.types').BingSelectSize;
+    block: boolean;
+    glassBlur: string | number;
+    glassOpacity: number;
+    glassSaturation: number;
+    id: string;
+    ariaDescribedby: string;
+    status: "default" | "error" | "success" | "warning";
+    placeholder: string;
+    clearable: boolean;
+    panelMaxHeight: string | number;
+    options: BingSelectOption[];
+    multiple: boolean;
+    showSelectAll: boolean;
+    selectAllText: string;
+    clearAllText: string;
+    emptyText: string;
+    searchable: import('./BingSelect.types').BingSelectSearchable;
+    searchPlaceholder: string;
+    noSearchResultsText: string;
+    panelMinHeight: string | number;
+    virtual: import('./BingSelect.types').BingSelectVirtualMode;
+    virtualThreshold: number;
+    virtualItemHeight: number;
+    virtualOverscan: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/BingSelect/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BingSelect } from './BingSelect.vue';
+export type { BingSelectChangePayload, BingSelectEmits, BingSelectModelValue, BingSelectOption, BingSelectProps, BingSelectSize, BingSelectValue, BingSelectVirtualMode, } from './BingSelect.types';

package/dist/components/BingSideNav/BingSideNav.types.d.ts

@@ -0,0 +1,57 @@
+import { Component } from 'vue';
+export type BingSideNavValue = string | number;
+export type BingSideNavSize = 'sm' | 'md' | 'lg';
+export type BingSideNavVariant = 'glass' | 'soft' | 'quiet';
+export interface BingSideNavItem {
+    value: BingSideNavValue;
+    label: string;
+    href?: string;
+    target?: string;
+    rel?: string;
+    disabled?: boolean;
+    badge?: string | number;
+    icon?: Component;
+    children?: BingSideNavItem[];
+    defaultExpanded?: boolean;
+    ariaLabel?: string;
+    [key: string]: unknown;
+}
+export interface BingSideNavSection {
+    value?: BingSideNavValue;
+    label?: string;
+    items: BingSideNavItem[];
+    [key: string]: unknown;
+}
+export interface BingSideNavProps {
+    modelValue?: BingSideNavValue;
+    items?: BingSideNavItem[];
+    sections?: BingSideNavSection[];
+    expandedValues?: BingSideNavValue[];
+    defaultExpandedValues?: BingSideNavValue[];
+    size?: BingSideNavSize;
+    variant?: BingSideNavVariant;
+    disabled?: boolean;
+    block?: boolean;
+    collapsible?: boolean;
+    animated?: boolean;
+    respectReducedMotion?: boolean;
+    ariaLabel?: string;
+}
+export interface BingSideNavSelectPayload {
+    value: BingSideNavValue;
+    item: BingSideNavItem;
+    event: MouseEvent | KeyboardEvent;
+}
+export interface BingSideNavTogglePayload {
+    value: BingSideNavValue;
+    item: BingSideNavItem;
+    expanded: boolean;
+    event: MouseEvent | KeyboardEvent;
+}
+export interface BingSideNavEmits {
+    'update:modelValue': [value: BingSideNavValue];
+    'update:expandedValues': [values: BingSideNavValue[]];
+    select: [payload: BingSideNavSelectPayload];
+    expand: [payload: BingSideNavTogglePayload];
+    collapse: [payload: BingSideNavTogglePayload];
+}

package/dist/components/BingSideNav/BingSideNav.vue.d.ts

@@ -0,0 +1,89 @@
+import { BingSideNavItem, BingSideNavProps, BingSideNavSection, BingSideNavValue } from './BingSideNav.types';
+declare var __VLS_1: {}, __VLS_3: {
+    section: BingSideNavSection;
+    index: number;
+}, __VLS_14: {
+    item: BingSideNavItem;
+    active: boolean;
+    expanded: boolean;
+    depth: number;
+}, __VLS_21: {
+    item: BingSideNavItem;
+    active: boolean;
+    expanded: boolean;
+    disabled: boolean;
+    depth: number;
+}, __VLS_23: {
+    item: BingSideNavItem;
+    active: boolean;
+    depth: number;
+}, __VLS_39: {
+    item: BingSideNavItem;
+    active: boolean;
+    expanded: boolean;
+    depth: number;
+}, __VLS_46: {
+    item: BingSideNavItem;
+    active: boolean;
+    expanded: boolean;
+    disabled: boolean;
+    depth: number;
+}, __VLS_48: {
+    item: BingSideNavItem;
+    active: boolean;
+    depth: number;
+}, __VLS_50: {};
+type __VLS_Slots = {} & {
+    header?: (props: typeof __VLS_1) => any;
+} & {
+    'section-label'?: (props: typeof __VLS_3) => any;
+} & {
+    icon?: (props: typeof __VLS_14) => any;
+} & {
+    item?: (props: typeof __VLS_21) => any;
+} & {
+    badge?: (props: typeof __VLS_23) => any;
+} & {
+    icon?: (props: typeof __VLS_39) => any;
+} & {
+    item?: (props: typeof __VLS_46) => any;
+} & {
+    badge?: (props: typeof __VLS_48) => any;
+} & {
+    footer?: (props: typeof __VLS_50) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<BingSideNavProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (payload: import('./BingSideNav.types').BingSideNavSelectPayload) => any;
+    "update:modelValue": (value: BingSideNavValue) => any;
+    collapse: (payload: import('./BingSideNav.types').BingSideNavTogglePayload) => any;
+    "update:expandedValues": (values: BingSideNavValue[]) => any;
+    expand: (payload: import('./BingSideNav.types').BingSideNavTogglePayload) => any;
+}, string, import('vue').PublicProps, Readonly<BingSideNavProps> & Readonly<{
+    onSelect?: ((payload: import('./BingSideNav.types').BingSideNavSelectPayload) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: BingSideNavValue) => any) | undefined;
+    onCollapse?: ((payload: import('./BingSideNav.types').BingSideNavTogglePayload) => any) | undefined;
+    "onUpdate:expandedValues"?: ((values: BingSideNavValue[]) => any) | undefined;
+    onExpand?: ((payload: import('./BingSideNav.types').BingSideNavTogglePayload) => any) | undefined;
+}>, {
+    disabled: boolean;
+    ariaLabel: string;
+    modelValue: BingSideNavValue;
+    items: BingSideNavItem[];
+    size: import('./BingSideNav.types').BingSideNavSize;
+    variant: import('./BingSideNav.types').BingSideNavVariant;
+    block: boolean;
+    animated: boolean;
+    respectReducedMotion: boolean;
+    sections: BingSideNavSection[];
+    expandedValues: BingSideNavValue[];
+    defaultExpandedValues: BingSideNavValue[];
+    collapsible: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/BingSideNav/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BingSideNav } from './BingSideNav.vue';
+export type { BingSideNavEmits, BingSideNavItem, BingSideNavProps, BingSideNavSection, BingSideNavSelectPayload, BingSideNavSize, BingSideNavTogglePayload, BingSideNavValue, BingSideNavVariant, } from './BingSideNav.types';

package/dist/components/BingSortableList/BingSortableList.types.d.ts

@@ -0,0 +1,62 @@
+import { ComponentPublicInstance, HTMLAttributes } from 'vue';
+export type BingSortableListKey = string | number;
+export type BingSortableListAxis = 'vertical' | 'horizontal';
+export type BingSortableListReorderMode = 'drop' | 'live';
+export type BingSortableListItemKey<T> = keyof T | ((item: T, index: number) => BingSortableListKey);
+export type BingSortableListItemDisabled<T> = keyof T | ((item: T, index: number) => boolean);
+export interface BingSortableListPayload<T = Record<string, unknown>> {
+    key: BingSortableListKey;
+    item: T;
+    from: number;
+    to: number;
+    order: BingSortableListKey[];
+    event?: PointerEvent | KeyboardEvent;
+}
+export interface BingSortableListDragPayload<T = Record<string, unknown>> {
+    key: BingSortableListKey;
+    item: T;
+    index: number;
+    order: BingSortableListKey[];
+    event: PointerEvent;
+}
+export interface BingSortableListProps<T = Record<string, unknown>> {
+    items?: T[];
+    order?: BingSortableListKey[];
+    itemKey?: BingSortableListItemKey<T>;
+    itemDisabled?: BingSortableListItemDisabled<T>;
+    disabledKeys?: BingSortableListKey[];
+    axis?: BingSortableListAxis;
+    disabled?: boolean;
+    keyboard?: boolean;
+    flip?: boolean;
+    reorderMode?: BingSortableListReorderMode;
+    duration?: number;
+    settleDuration?: number;
+    dragThreshold?: number;
+    ariaLabel?: string;
+    handleAriaLabel?: string | ((item: T, index: number) => string);
+}
+export interface BingSortableListEmits<T = Record<string, unknown>> {
+    'update:order': [order: BingSortableListKey[]];
+    reorder: [payload: BingSortableListPayload<T>];
+    'drag-start': [payload: BingSortableListDragPayload<T>];
+    drag: [payload: BingSortableListDragPayload<T>];
+    'drag-end': [payload: BingSortableListDragPayload<T>];
+}
+export interface BingSortableListHandleProps extends HTMLAttributes {
+    ref: (element: Element | ComponentPublicInstance | null) => void;
+    role: 'button';
+    tabindex: number;
+    'aria-label': string;
+    'aria-disabled': 'true' | 'false';
+    onKeydown: (event: KeyboardEvent) => void;
+}
+export interface BingSortableListSlotProps<T = Record<string, unknown>> {
+    item: T;
+    key: BingSortableListKey;
+    index: number;
+    active: boolean;
+    dragging: boolean;
+    disabled: boolean;
+    handleProps: BingSortableListHandleProps;
+}

package/dist/components/BingSortableList/BingSortableList.vue.d.ts

@@ -0,0 +1,51 @@
+import { BingSortableListDragPayload, BingSortableListKey, BingSortableListPayload, BingSortableListProps } from './BingSortableList.types';
+type ListItem = any;
+type __VLS_Props = BingSortableListProps<ListItem>;
+type __VLS_Slots = {
+    default?(props: {
+        item: ListItem;
+        key: BingSortableListKey;
+        index: number;
+        active: boolean;
+        dragging: boolean;
+        disabled: boolean;
+        handleProps: any;
+    }): unknown;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    drag: (payload: BingSortableListDragPayload<any>) => any;
+    "update:order": (order: BingSortableListKey[]) => any;
+    reorder: (payload: BingSortableListPayload<any>) => any;
+    "drag-start": (payload: BingSortableListDragPayload<any>) => any;
+    "drag-end": (payload: BingSortableListDragPayload<any>) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onDrag?: ((payload: BingSortableListDragPayload<any>) => any) | undefined;
+    "onUpdate:order"?: ((order: BingSortableListKey[]) => any) | undefined;
+    onReorder?: ((payload: BingSortableListPayload<any>) => any) | undefined;
+    "onDrag-start"?: ((payload: BingSortableListDragPayload<any>) => any) | undefined;
+    "onDrag-end"?: ((payload: BingSortableListDragPayload<any>) => any) | undefined;
+}>, {
+    disabled: boolean;
+    order: BingSortableListKey[];
+    ariaLabel: string;
+    items: any[];
+    duration: number;
+    flip: boolean;
+    itemKey: import('./BingSortableList.types').BingSortableListItemKey<any>;
+    axis: import('./BingSortableList.types').BingSortableListAxis;
+    itemDisabled: import('./BingSortableList.types').BingSortableListItemDisabled<any>;
+    disabledKeys: BingSortableListKey[];
+    keyboard: boolean;
+    reorderMode: import('./BingSortableList.types').BingSortableListReorderMode;
+    settleDuration: number;
+    dragThreshold: number;
+    handleAriaLabel: string | ((item: any, index: number) => string);
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/BingSortableList/BingSortableListItem.vue.d.ts

@@ -0,0 +1,34 @@
+import { BingSortableListAxis, BingSortableListKey, BingSortableListSlotProps } from './BingSortableList.types';
+type ListItem = any;
+type __VLS_Props = {
+    item: ListItem;
+    itemKey: BingSortableListKey;
+    index: number;
+    activeKey: BingSortableListKey | null;
+    disabled?: boolean;
+    axis?: BingSortableListAxis;
+    flip?: boolean;
+    duration?: number;
+    handleLabel: string;
+};
+type __VLS_Slots = {
+    default?(props: BingSortableListSlotProps<ListItem>): unknown;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "keyboard-move": (event: KeyboardEvent) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onKeyboard-move"?: ((event: KeyboardEvent) => any) | undefined;
+}>, {
+    disabled: boolean;
+    duration: number;
+    flip: boolean;
+    axis: BingSortableListAxis;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/BingSortableList/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BingSortableList } from './BingSortableList.vue';
+export type { BingSortableListAxis, BingSortableListDragPayload, BingSortableListEmits, BingSortableListHandleProps, BingSortableListItemDisabled, BingSortableListItemKey, BingSortableListKey, BingSortableListPayload, BingSortableListProps, BingSortableListReorderMode, BingSortableListSlotProps, } from './BingSortableList.types';