@webx-ui/core 0.8.0 → 0.10.0

package/dist/components/Popconfirm/Popconfirm.d.ts

@@ -0,0 +1,69 @@
+import { PopconfirmProps } from './types';
+type __VLS_Props = PopconfirmProps;
+declare function cancel(): void;
+type __VLS_PublicProps = {
+    'open'?: boolean;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        /** The control that asks. Exactly one element. */
+        trigger?: (props: {
+            open: boolean;
+        }) => unknown;
+        /** Replaces the question and its explanation. */
+        default?: () => unknown;
+        /** Replaces the two buttons. */
+        actions?: (props: {
+            confirm: () => void;
+            cancel: () => void;
+        }) => unknown;
+    }> & {
+        /** The control that asks. Exactly one element. */
+        trigger?: (props: {
+            open: boolean;
+        }) => unknown;
+        /** Replaces the question and its explanation. */
+        default?: () => unknown;
+        /** Replaces the two buttons. */
+        actions?: (props: {
+            confirm: () => void;
+            cancel: () => void;
+        }) => unknown;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {
+    close: typeof cancel;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+    cancel: () => any;
+    confirm: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    onCancel?: (() => any) | undefined;
+    onConfirm?: (() => any) | undefined;
+}>, {
+    disabled: boolean;
+    title: string;
+    icon: import('..').IconName | false;
+    side: import('..').PopoverSide;
+    align: import('..').PopoverAlign;
+    offset: number;
+    description: string;
+    width: number | string;
+    loading: boolean;
+    confirmText: string;
+    cancelText: string;
+    confirmType: import('..').ButtonType;
+    arrow: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,2 @@
+export { default as WxPopconfirm } from './Popconfirm';
+export type * from './types';

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

@@ -0,0 +1,33 @@
+import { ButtonType } from '../Button/types';
+import { IconName } from '../Icon/types';
+import { PopoverAlign, PopoverSide } from '../Popover/types';
+export interface PopconfirmProps {
+    /** The question. Keep it about what will happen, not about the button. */
+    title?: string;
+    /** What else the reader should know before answering. */
+    description?: string;
+    /** Label of the button that goes ahead. */
+    confirmText?: string;
+    /** Label of the button that does not. */
+    cancelText?: string;
+    /** Colour of the confirming button — `danger` for anything that destroys. */
+    confirmType?: ButtonType;
+    /** The glyph beside the question. `false` drops it. */
+    icon?: IconName | false;
+    side?: PopoverSide;
+    align?: PopoverAlign;
+    /** Distance from the trigger, in pixels. */
+    offset?: number;
+    /** Draws the little pointer at the trigger. */
+    arrow?: boolean;
+    /** Width of the panel: a number in pixels, or any CSS length. */
+    width?: number | string;
+    /** The trigger stops asking anything. */
+    disabled?: boolean;
+    /** Keeps the panel open and the confirming button busy — for an async answer. */
+    loading?: boolean;
+}
+export interface PopconfirmEmits {
+    confirm: [];
+    cancel: [];
+}

package/dist/components/Progress/Progress.d.ts

@@ -0,0 +1,41 @@
+import { ProgressProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        /** Replaces the figure — a count, a size, a time remaining. */
+        default?: (props: {
+            value: number;
+            max: number;
+            percent: number;
+        }) => unknown;
+    }> & {
+        /** Replaces the figure — a count, a size, a time remaining. */
+        default?: (props: {
+            value: number;
+            max: number;
+            percent: number;
+        }) => unknown;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<ProgressProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ProgressProps> & Readonly<{}>, {
+    size: import('./types').ProgressSize;
+    type: import('./types').ProgressType;
+    value: number;
+    ariaLabel: string;
+    status: import('./types').ProgressStatus;
+    max: number;
+    indeterminate: boolean;
+    formatter: (value: number, max: number) => string;
+    thickness: number;
+    showValue: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,2 @@
+export { default as WxProgress } from './Progress';
+export type * from './types';

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

@@ -0,0 +1,26 @@
+export type ProgressType = 'line' | 'circle';
+export type ProgressStatus = 'default' | 'success' | 'warning' | 'danger';
+export type ProgressSize = 'sm' | 'md' | 'lg';
+export interface ProgressProps {
+    /** How far along, from `0` to `max`. */
+    value?: number;
+    /** What finished looks like. */
+    max?: number;
+    type?: ProgressType;
+    /** Colour of the bar. `success` and `danger` are outcomes, not decorations. */
+    status?: ProgressStatus;
+    size?: ProgressSize;
+    /** Thickness of the track. Overrides what `size` would give it. */
+    thickness?: number;
+    /** Shows the figure beside the bar, or inside the ring. */
+    showValue?: boolean;
+    /** Turns the figure into whatever the reader should see: `3 of 8`, `1.2 MB`. */
+    formatter?: (value: number, max: number) => string;
+    /**
+     * Work with no end in sight: the bar travels rather than fills, and reports
+     * nothing to a screen reader beyond the fact that it is busy.
+     */
+    indeterminate?: boolean;
+    /** Accessible name. Give one whenever there is no visible label beside it. */
+    ariaLabel?: string;
+}

package/dist/components/Rate/Rate.d.ts

@@ -18,7 +18,7 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {},
     id: string;
     max: number;
     readonly: boolean;
-    allowHalf: boolean;
     showValue: boolean;
+    allowHalf: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/components/Result/Result.d.ts

@@ -0,0 +1,38 @@
+import { IconName } from '../Icon/types';
+import { ResultProps, ResultStatus } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        icon?: () => unknown;
+        title?: () => unknown;
+        subtitle?: () => unknown;
+        /** The way out: back to the list, try again, contact somebody. */
+        actions?: () => unknown;
+        /** Anything under the actions — a stack trace behind a disclosure, a reference. */
+        default?: () => unknown;
+    }> & {
+        icon?: () => unknown;
+        title?: () => unknown;
+        subtitle?: () => unknown;
+        /** The way out: back to the list, try again, contact somebody. */
+        actions?: () => unknown;
+        /** Anything under the actions — a stack trace behind a disclosure, a reference. */
+        default?: () => unknown;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<ResultProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ResultProps> & Readonly<{}>, {
+    title: string;
+    subtitle: string;
+    icon: IconName;
+    status: ResultStatus;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,2 @@
+export { default as WxResult } from './Result';
+export type * from './types';

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

@@ -0,0 +1,15 @@
+import { IconName } from '../Icon/types';
+/**
+ * What happened. The three numbers are the HTTP replies an admin panel actually
+ * shows a page for; the rest are outcomes of something the user just did.
+ */
+export type ResultStatus = 'success' | 'warning' | 'danger' | 'info' | '403' | '404' | '500';
+export interface ResultProps {
+    status?: ResultStatus;
+    /** The outcome in a few words: `Order placed`, `Page not found`. */
+    title?: string;
+    /** What it means, or what to do next. */
+    subtitle?: string;
+    /** Icon to draw instead of the one the status picks. */
+    icon?: IconName;
+}

package/dist/components/Segmented/Segmented.d.ts

@@ -0,0 +1,44 @@
+import { SegmentedOption, SegmentedProps, SegmentedValue } from './types';
+type __VLS_Props = SegmentedProps;
+type __VLS_PublicProps = {
+    modelValue?: SegmentedValue | undefined;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        /** A segment's contents, when a label and an icon are not enough. */
+        option?: (props: {
+            option: SegmentedOption;
+            selected: boolean;
+        }) => unknown;
+    }> & {
+        /** A segment's contents, when a label and an icon are not enough. */
+        option?: (props: {
+            option: SegmentedOption;
+            selected: boolean;
+        }) => unknown;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (value: SegmentedValue) => any;
+    "update:modelValue": (value: SegmentedValue | undefined) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onChange?: ((value: SegmentedValue) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: SegmentedValue | undefined) => any) | undefined;
+}>, {
+    size: import('../..').ControlSize;
+    disabled: boolean;
+    ariaLabel: string;
+    options: SegmentedOption[];
+    block: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,2 @@
+export { default as WxSegmented } from './Segmented';
+export type * from './types';

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

@@ -0,0 +1,23 @@
+import { ControlSize } from '../../composables/useFormField';
+import { IconName } from '../Icon/types';
+export type SegmentedValue = string | number;
+export interface SegmentedOption {
+    label?: string;
+    value: SegmentedValue;
+    icon?: IconName;
+    disabled?: boolean;
+    /** Accessible name when the segment shows only an icon. */
+    ariaLabel?: string;
+}
+export interface SegmentedProps {
+    options?: SegmentedOption[];
+    size?: ControlSize;
+    /** Stretches to the width it is given, the segments sharing it equally. */
+    block?: boolean;
+    disabled?: boolean;
+    /** Accessible name for the group. */
+    ariaLabel?: string;
+}
+export interface SegmentedEmits {
+    change: [value: SegmentedValue];
+}

package/dist/components/SelectionArea/SelectionArea.d.ts

@@ -0,0 +1,48 @@
+import { SelectionAreaProps, SelectionAreaSlotProps, SelectionValue } from './types';
+type __VLS_Props = SelectionAreaProps;
+declare function selectAll(): void;
+declare function clear(): void;
+type __VLS_PublicProps = {
+    modelValue?: SelectionValue[];
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default?: (props: SelectionAreaSlotProps) => unknown;
+    }> & {
+        default?: (props: SelectionAreaSlotProps) => unknown;
+    };
+    refs: {
+        root: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {
+    selectAll: typeof selectAll;
+    clear: typeof clear;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    start: () => any;
+    end: (value: SelectionValue[]) => any;
+    "update:modelValue": (value: SelectionValue[]) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onStart?: (() => any) | undefined;
+    onEnd?: ((value: SelectionValue[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: SelectionValue[]) => any) | undefined;
+}>, {
+    disabled: boolean;
+    match: import('./types').SelectionMatch;
+    threshold: number;
+    touch: boolean;
+    clickSelect: boolean;
+    edgeScroll: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    root: HTMLDivElement;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/SelectionArea/directive.d.ts

@@ -0,0 +1,19 @@
+import { ObjectDirective } from 'vue';
+import { SelectionValue } from './types';
+/** Marks an element as something a selection box can catch. */
+export declare const SELECTABLE = "data-wx-selectable";
+/**
+ * The value of a selectable element. Falls back to the attribute, so markup that is not
+ * written in Vue can say `data-wx-selectable="42"` and be caught the same way — as the
+ * string `'42'`, since that is all an attribute can hold.
+ */
+export declare function valueOf(el: Element): SelectionValue | undefined;
+/**
+ * `v-wx-select="item.id"` hands an element to the selection area around it.
+ *
+ * A directive rather than a component, because the element is already there — a card, a
+ * row, a list item — and wrapping every one of them in a box of ours would break the grid
+ * or table it sits in. It also keeps the value's type: an attribute could only carry the
+ * string `'42'`, and the selection would stop matching the numbers the model holds.
+ */
+export declare const vWxSelect: ObjectDirective<HTMLElement, SelectionValue>;

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

@@ -0,0 +1,3 @@
+export { default as WxSelectionArea } from './SelectionArea';
+export { vWxSelect, SELECTABLE } from './directive';
+export type * from './types';

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

@@ -0,0 +1,26 @@
+export type SelectionValue = string | number;
+export type SelectionMatch = 'intersect' | 'contain';
+export interface SelectionAreaProps {
+    /** Whether the box has to cover an item or merely touch it. */
+    match?: SelectionMatch;
+    /** How far the pointer travels before it is a drag rather than a click, in pixels. */
+    threshold?: number;
+    /** A click picks one item; a click on the background clears the selection. */
+    clickSelect?: boolean;
+    /** Drag with a finger too. Off, because on a touch screen a drag scrolls. */
+    touch?: boolean;
+    /** How near the scroller's edge the pointer scrolls it, in pixels. `0` never does. */
+    edgeScroll?: number;
+    disabled?: boolean;
+}
+export interface SelectionAreaEmits {
+    /** The pointer has moved past the threshold and a box is being drawn. */
+    start: [];
+    /** The drag is over. Carries the selection it ended with. */
+    end: [value: SelectionValue[]];
+}
+export interface SelectionAreaSlotProps {
+    selected: Set<SelectionValue>;
+    isSelected: (value: SelectionValue) => boolean;
+    selecting: boolean;
+}

package/dist/components/Skeleton/Skeleton.d.ts

@@ -0,0 +1,33 @@
+import { SkeletonProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        /** The real thing, once it has arrived. */
+        default?: () => unknown;
+        /** A placeholder shaped like the real thing, instead of the rows. */
+        template?: () => unknown;
+    }> & {
+        /** The real thing, once it has arrived. */
+        default?: () => unknown;
+        /** A placeholder shaped like the real thing, instead of the rows. */
+        template?: () => unknown;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<SkeletonProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SkeletonProps> & Readonly<{}>, {
+    title: boolean;
+    loading: boolean;
+    delay: number;
+    rows: number;
+    animated: boolean;
+    avatar: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,2 @@
+export { default as WxSkeleton } from './Skeleton';
+export type * from './types';

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

@@ -0,0 +1,31 @@
+/** What shape the placeholder stands in for. */
+export type SkeletonVariant = 'text' | 'title' | 'circle' | 'square' | 'image' | 'button';
+export interface SkeletonProps {
+    /**
+     * Whether the placeholder is showing. Once it is off, the default slot is what
+     * renders — so the same markup covers both states and the caller writes one `v-if`
+     * fewer.
+     */
+    loading?: boolean;
+    /** How many lines of text to stand in for. The last one is drawn short. */
+    rows?: number;
+    /** Adds a circle beside the lines, for a row that begins with a face. */
+    avatar?: boolean;
+    /** Draws the first line heavier, as a heading. */
+    title?: boolean;
+    /** The shimmer. Off for anything that will be on screen for a long time. */
+    animated?: boolean;
+    /**
+     * How long the content may take before the placeholder appears, in milliseconds.
+     * A request that answers in 80ms should not flash a skeleton on the way.
+     */
+    delay?: number;
+}
+export interface SkeletonItemProps {
+    variant?: SkeletonVariant;
+    /** Any CSS length, or pixels as a number. */
+    width?: string | number;
+    height?: string | number;
+    /** Follows the enclosing `WxSkeleton` unless set here. */
+    animated?: boolean;
+}

package/dist/components/SkeletonItem/SkeletonItem.d.ts

@@ -0,0 +1,8 @@
+import { SkeletonItemProps } from '../Skeleton/types';
+declare const _default: import('vue').DefineComponent<SkeletonItemProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SkeletonItemProps> & Readonly<{}>, {
+    variant: import('..').SkeletonVariant;
+    width: string | number;
+    height: string | number;
+    animated: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLSpanElement>;
+export default _default;

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

@@ -0,0 +1 @@
+export { default as WxSkeletonItem } from './SkeletonItem';

package/dist/components/Slider/Slider.d.ts

@@ -15,9 +15,9 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {},
     disabled: boolean;
     ariaLabel: string;
     id: string;
+    max: number;
     range: boolean;
     min: number;
-    max: number;
     step: number;
     showValue: boolean;
     marks: Record<number, string>;

package/dist/components/SortableList/SortableList.d.ts

@@ -0,0 +1,53 @@
+import { SortableListProps } from './types';
+declare const _default: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:modelValue"?: ((value: T[]) => any) | undefined;
+        readonly onMove?: ((move: import('./types').SortableMove<T>) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:modelValue" | "onMove"> & ({
+        modelValue?: T[];
+    } & SortableListProps<T>) & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: Readonly<{
+        /** Replaces the title. */
+        header?: () => unknown;
+        /** The end of the heading — a search button, a menu, whatever the list can do. */
+        extra?: () => unknown;
+        /** One row. */
+        default?: (props: {
+            item: T;
+            index: number;
+        }) => unknown;
+        /** The end of a row, where the buttons that act on it go. */
+        actions?: (props: {
+            item: T;
+            index: number;
+        }) => unknown;
+        /** Shown in place of an empty list. */
+        empty?: () => unknown;
+    }> & {
+        /** Replaces the title. */
+        header?: () => unknown;
+        /** The end of the heading — a search button, a menu, whatever the list can do. */
+        extra?: () => unknown;
+        /** One row. */
+        default?: (props: {
+            item: T;
+            index: number;
+        }) => unknown;
+        /** The end of a row, where the buttons that act on it go. */
+        actions?: (props: {
+            item: T;
+            index: number;
+        }) => unknown;
+        /** Shown in place of an empty list. */
+        empty?: () => unknown;
+    };
+    emit: ((evt: "move", move: import('./types').SortableMove<T>) => void) & ((evt: "update:modelValue", value: T[]) => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

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

@@ -0,0 +1,2 @@
+export { default as WxSortableList } from './SortableList';
+export type * from './types';

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

@@ -0,0 +1,38 @@
+export type SortableListSize = 'sm' | 'md';
+/** How something was moved — worth knowing when you animate or undo. */
+export type SortableVia = 'pointer' | 'keyboard';
+/** Where a row came from and where it went. */
+export interface SortableMove<T = unknown> {
+    item: T;
+    from: number;
+    to: number;
+    via: SortableVia;
+}
+export interface SortableListProps<T = unknown> {
+    /** Heading above the list. */
+    title?: string;
+    /**
+     * What a drag starts from: the grip at the start of every row (`grip`), anywhere on
+     * the row (`row`), or a CSS selector for a handle of your own.
+     */
+    handle?: 'grip' | 'row' | string;
+    /** Field to key a row by, or a function. Falls back to the position. */
+    itemKey?: string | ((item: T, index: number) => string | number);
+    /** Lists that share a name pass rows between them. */
+    group?: string;
+    /** Nothing can be moved. */
+    disabled?: boolean;
+    size?: SortableListSize;
+    /** Drops the frame, for a list that already sits in a card. */
+    plain?: boolean;
+    /** Shown when there is nothing in the list. */
+    emptyText?: string;
+    /** What the grip is called, before the name of the row it holds. */
+    dragLabel?: string;
+    /** Accessible name for the list. */
+    ariaLabel?: string;
+}
+export interface SortableListEmits<T = unknown> {
+    /** A row changed position. The list has already been reordered. */
+    move: [move: SortableMove<T>];
+}

package/dist/components/Step/Step.d.ts

@@ -0,0 +1,38 @@
+import { StepProps } from '../Steps/types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        title?: () => unknown;
+        /** The explanation. Overrides `description`. */
+        default?: () => unknown;
+        /** Replaces the marker — a number by default, a tick once it is done. */
+        marker?: (props: {
+            index: number;
+            state: string;
+        }) => unknown;
+    }> & {
+        title?: () => unknown;
+        /** The explanation. Overrides `description`. */
+        default?: () => unknown;
+        /** Replaces the marker — a number by default, a tick once it is done. */
+        marker?: (props: {
+            index: number;
+            state: string;
+        }) => unknown;
+    };
+    refs: {};
+    rootEl: HTMLLIElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<StepProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<StepProps> & Readonly<{}>, {
+    title: string;
+    icon: import('..').IconName;
+    description: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLLIElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};