@webx-ui/core 0.7.0 → 0.9.0

package/dist/components/Affix/Affix.d.ts

@@ -0,0 +1,37 @@
+import { AffixProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default?: (props: {
+            stuck: boolean;
+        }) => unknown;
+    }> & {
+        default?: (props: {
+            stuck: boolean;
+        }) => unknown;
+    };
+    refs: {
+        sentinel: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<AffixProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (stuck: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<AffixProps> & Readonly<{
+    onChange?: ((stuck: boolean) => any) | undefined;
+}>, {
+    disabled: boolean;
+    offset: number;
+    position: "top" | "bottom";
+    zIndex: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    sentinel: 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/Affix/index.d.ts

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

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

@@ -0,0 +1,14 @@
+export interface AffixProps {
+    /** How far from the edge it comes to rest, in pixels. */
+    offset?: number;
+    /** Which edge it sticks to. */
+    position?: 'top' | 'bottom';
+    /** Puts the element back in the flow, whatever the scroll is doing. */
+    disabled?: boolean;
+    /** Layer it sits on once it is stuck. */
+    zIndex?: number;
+}
+export interface AffixEmits {
+    /** Fires when it sticks, and again when it lets go. */
+    change: [stuck: boolean];
+}

package/dist/components/Avatar/Avatar.d.ts

@@ -0,0 +1,31 @@
+import { AvatarProps, AvatarTone } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLSpanElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<AvatarProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    error: (event: Event) => any;
+}, string, import('vue').PublicProps, Readonly<AvatarProps> & Readonly<{
+    onError?: ((event: Event) => any) | undefined;
+}>, {
+    name: string;
+    size: import('./types').AvatarSize;
+    icon: import('..').IconName;
+    tone: AvatarTone;
+    src: string;
+    alt: string;
+    shape: import('./types').AvatarShape;
+    fit: "cover" | "contain" | "fill" | "none" | "scale-down";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLSpanElement>;
+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/Avatar/index.d.ts

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

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

@@ -0,0 +1,30 @@
+import { IconName } from '../Icon/types';
+export type AvatarSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export type AvatarShape = 'circle' | 'square';
+/**
+ * Colour of the fallback. `auto` picks a tint from the name, so the same person is
+ * the same colour on every screen and a list of them is readable at a glance.
+ */
+export type AvatarTone = 'auto' | 'neutral' | 'primary' | 'success' | 'warning' | 'danger' | 'info';
+export interface AvatarProps {
+    /** Picture to show. Anything that fails to load falls through to the initials. */
+    src?: string;
+    /** Alternative text for the picture. Defaults to `name`. */
+    alt?: string;
+    /**
+     * Who this is. It supplies the initials, the tooltip-less title, and — with
+     * `tone="auto"` — the colour.
+     */
+    name?: string;
+    /** Shown instead of initials when there is no name. */
+    icon?: IconName;
+    size?: AvatarSize;
+    shape?: AvatarShape;
+    tone?: AvatarTone;
+    /** How the picture fills its box. */
+    fit?: 'cover' | 'contain' | 'fill' | 'none' | 'scale-down';
+}
+export interface AvatarEmits {
+    /** The picture could not be loaded, so the fallback is showing. */
+    error: [event: Event];
+}

package/dist/components/AvatarGroup/AvatarGroup.d.ts

@@ -0,0 +1,8 @@
+import { AvatarGroupProps } from './types';
+declare const _default: import('vue').DefineComponent<AvatarGroupProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<AvatarGroupProps> & Readonly<{}>, {
+    size: import('..').AvatarSize;
+    shape: import('..').AvatarShape;
+    max: number;
+    overlap: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

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

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

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

@@ -0,0 +1,12 @@
+import { AvatarShape, AvatarSize } from '../Avatar/types';
+export interface AvatarGroupProps {
+    /**
+     * How many to show before the rest become a count. `0` shows every one of them.
+     */
+    max?: number;
+    /** Size for every avatar in the group; each one may still set its own. */
+    size?: AvatarSize;
+    shape?: AvatarShape;
+    /** How far each avatar slides over the one before it, as a share of its width. */
+    overlap?: number;
+}

package/dist/components/Backtop/Backtop.d.ts

@@ -0,0 +1,31 @@
+import { BacktopProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default?: () => unknown;
+    }> & {
+        default?: () => unknown;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<BacktopProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<BacktopProps> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    target: string | HTMLElement | null;
+    right: number;
+    bottom: number;
+    ariaLabel: string;
+    visibilityHeight: number;
+    smooth: 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/Backtop/index.d.ts

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

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

@@ -0,0 +1,19 @@
+export interface BacktopProps {
+    /**
+     * What scrolls. A CSS selector, an element, or nothing for the window.
+     *
+     * Name it in an admin: the page there rarely scrolls — the main column does — and
+     * a button watching the window would appear when nothing has happened.
+     */
+    target?: string | HTMLElement | null;
+    /** How far down before the button appears, in pixels. */
+    visibilityHeight?: number;
+    /** Distance from the trailing edge, in pixels. */
+    right?: number;
+    /** Distance from the bottom, in pixels. */
+    bottom?: number;
+    /** Glides back up rather than jumping. */
+    smooth?: boolean;
+    /** Accessible name of the button. */
+    ariaLabel?: string;
+}

package/dist/components/Cascader/Cascader.d.ts

@@ -43,13 +43,13 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps,
     clearable: boolean;
     status: import('../..').ControlStatus;
     id: string;
+    load: import('./types').CascaderLoader;
     separator: string;
     expandTrigger: "click" | "hover";
     checkStrictly: boolean;
     emitPath: boolean;
     showAllLevels: boolean;
     lazy: boolean;
-    load: import('./types').CascaderLoader;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     panel: HTMLDivElement;
 }, any>;

package/dist/components/CheckboxGroup/CheckboxGroup.d.ts

@@ -25,8 +25,8 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps,
     disabled: boolean;
     options: import('./types').CheckboxOption[];
     inline: boolean;
-    min: number;
     max: number;
+    min: number;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;

package/dist/components/Container/Container.d.ts

@@ -12,6 +12,7 @@ declare const __VLS_component: import('vue').DefineComponent<ContainerProps, {},
     as: string | import('vue').Component;
     direction: import('./types').ContainerDirection;
     fullHeight: boolean;
+    viewport: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;

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

@@ -8,6 +8,16 @@ export interface ContainerProps {
     direction?: ContainerDirection;
     /** Makes the container at least as tall as the viewport. For the outermost one. */
     fullHeight?: boolean;
+    /**
+     * Makes the container exactly as tall as the viewport and stops it growing, so
+     * that what scrolls is a pane inside it rather than the page. This is the shape an
+     * admin shell has: a header that stays put and a main column that scrolls under
+     * it. Pair it with `scroll` on the `WxMain` inside.
+     *
+     * `fullHeight` is the other answer — at least the viewport, with the page itself
+     * scrolling. Use that for a document, this for an application.
+     */
+    viewport?: boolean;
     /** The element to render. */
     as?: string | Component;
 }

package/dist/components/Descriptions/Descriptions.d.ts

@@ -0,0 +1,33 @@
+import { DescriptionsProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        title?: () => unknown;
+        /** Beside the heading: an edit button, a status. */
+        extra?: () => unknown;
+        default?: () => unknown;
+    }> & {
+        title?: () => unknown;
+        /** Beside the heading: an edit button, a status. */
+        extra?: () => unknown;
+        default?: () => unknown;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<DescriptionsProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<DescriptionsProps> & Readonly<{}>, {
+    bordered: boolean;
+    size: import('../..').ControlSize;
+    title: string;
+    columns: number;
+    layout: import('./types').DescriptionsLayout;
+    labelWidth: string;
+}, {}, {}, {}, 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/Descriptions/context.d.ts

@@ -0,0 +1,5 @@
+import { InjectionKey } from 'vue';
+import { DescriptionsContext } from './types';
+export declare const descriptionsKey: InjectionKey<DescriptionsContext>;
+/** A pair on its own, outside any list, still has to render something sensible. */
+export declare function useDescriptions(): DescriptionsContext;

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

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

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

@@ -0,0 +1,30 @@
+import { ControlSize } from '../../composables/useFormField';
+/** Where the label sits: beside its value, or above it. */
+export type DescriptionsLayout = 'horizontal' | 'vertical';
+export interface DescriptionsProps {
+    /** Heading above the list. */
+    title?: string;
+    /**
+     * How many label-and-value pairs stand side by side. The list drops to one column
+     * on its own when the room runs out, so this is the most it will ever show.
+     */
+    columns?: number;
+    /** Rules around every cell, which is what turns a list into a table of facts. */
+    bordered?: boolean;
+    size?: ControlSize;
+    layout?: DescriptionsLayout;
+    /** Width of the label column when the layout is `horizontal`, e.g. `"140px"`. */
+    labelWidth?: string;
+}
+export interface DescriptionsItemProps {
+    /** The name of the fact. Use the `label` slot for anything richer than text. */
+    label?: string;
+    /** How many columns the pair takes up. */
+    span?: number;
+}
+/** What `WxDescriptions` hands down to the pairs inside it. */
+export interface DescriptionsContext {
+    bordered: boolean;
+    layout: DescriptionsLayout;
+    labelWidth: string | undefined;
+}

package/dist/components/DescriptionsItem/DescriptionsItem.d.ts

@@ -0,0 +1,25 @@
+import { DescriptionsItemProps } from '../Descriptions/types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        label?: () => unknown;
+        default?: () => unknown;
+    }> & {
+        label?: () => unknown;
+        default?: () => unknown;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<DescriptionsItemProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<DescriptionsItemProps> & Readonly<{}>, {
+    label: string;
+    span: number;
+}, {}, {}, {}, 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/DescriptionsItem/index.d.ts

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

package/dist/components/Empty/Empty.d.ts

@@ -0,0 +1,38 @@
+import { EmptyProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        /** Replaces the glyph — an illustration, a logo, whatever says it better. */
+        icon?: () => unknown;
+        title?: () => unknown;
+        /** The explanation. Overrides `description`. */
+        default?: () => unknown;
+        /** What to do about it: a button that clears the filter, one that adds a record. */
+        actions?: () => unknown;
+    }> & {
+        /** Replaces the glyph — an illustration, a logo, whatever says it better. */
+        icon?: () => unknown;
+        title?: () => unknown;
+        /** The explanation. Overrides `description`. */
+        default?: () => unknown;
+        /** What to do about it: a button that clears the filter, one that adds a record. */
+        actions?: () => unknown;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<EmptyProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<EmptyProps> & Readonly<{}>, {
+    plain: boolean;
+    size: import('./types').EmptySize;
+    title: string;
+    icon: import('..').IconName;
+    description: string;
+}, {}, {}, {}, 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/Empty/index.d.ts

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

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

@@ -0,0 +1,20 @@
+import { IconName } from '../Icon/types';
+export type EmptySize = 'sm' | 'md' | 'lg';
+export interface EmptyProps {
+    /**
+     * The glyph above the message. Pick one that says what is missing — `search` for
+     * a filter that matched nothing, `inbox` for a list nobody has written to yet.
+     */
+    icon?: IconName;
+    /** What is missing, in a few words. */
+    title?: string;
+    /** Why, or what to do about it. */
+    description?: string;
+    /**
+     * How much room to take. `sm` is a panel inside a screen; `lg` is a whole page
+     * with nothing on it.
+     */
+    size?: EmptySize;
+    /** Drops the icon, for a message that stands on its own. */
+    plain?: boolean;
+}

package/dist/components/EntityCard/EntityCard.d.ts

@@ -26,8 +26,8 @@ declare const __VLS_component: import('vue').DefineComponent<EntityCardProps, {}
     title: string;
     subtitle: string;
     href: string;
-    imageAlt: string;
     shape: import('./types').EntityCardShape;
+    imageAlt: string;
     imageSize: number | string;
     selected: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;

package/dist/components/Form/Form.d.ts

@@ -18,9 +18,9 @@ declare const __VLS_component: import('vue').DefineComponent<FormProps, {}, {},
 }>, {
     size: import('../..').ControlSize;
     disabled: boolean;
+    labelWidth: string;
     errors: ValidationErrors;
     labelPosition: "top" | "left";
-    labelWidth: string;
     gap: "sm" | "md" | "lg";
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLFormElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;

package/dist/components/Image/Image.d.ts

@@ -0,0 +1,43 @@
+import { ImageProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        /** Shown while the picture is on its way. */
+        placeholder?: () => unknown;
+        /** Shown instead of a picture that will not load. */
+        error?: () => unknown;
+    }> & {
+        /** Shown while the picture is on its way. */
+        placeholder?: () => unknown;
+        /** Shown instead of a picture that will not load. */
+        error?: () => unknown;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<ImageProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    error: (event: Event) => any;
+    load: (event: Event) => any;
+}, string, import('vue').PublicProps, Readonly<ImageProps> & Readonly<{
+    onError?: ((event: Event) => any) | undefined;
+    onLoad?: ((event: Event) => any) | undefined;
+}>, {
+    placeholder: string;
+    width: number | string;
+    src: string;
+    alt: string;
+    fit: import('./types').ImageFit;
+    lazy: boolean;
+    preview: boolean;
+    height: number | string;
+    radius: number | string;
+    previewLabel: string;
+}, {}, {}, {}, 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/Image/index.d.ts

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

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

@@ -0,0 +1,26 @@
+export type ImageFit = 'cover' | 'contain' | 'fill' | 'none' | 'scale-down';
+export interface ImageProps {
+    src?: string;
+    alt?: string;
+    /** How the picture fills its box. */
+    fit?: ImageFit;
+    width?: number | string;
+    height?: number | string;
+    /** Shape of the box: any CSS length, or a keyword from the radius scale. */
+    radius?: number | string;
+    /**
+     * Waits until the picture is near the screen before fetching it. On by default:
+     * a media library is a hundred pictures and a reader looks at four.
+     */
+    lazy?: boolean;
+    /** A tiny picture — or a colour — shown while the real one arrives. */
+    placeholder?: string;
+    /** Opens the picture full size when it is clicked. */
+    preview?: boolean;
+    /** Accessible name of the button that opens the preview. */
+    previewLabel?: string;
+}
+export interface ImageEmits {
+    load: [event: Event];
+    error: [event: Event];
+}

package/dist/components/Indicator/Indicator.d.ts

@@ -15,8 +15,8 @@ declare const __VLS_component: import('vue').DefineComponent<IndicatorProps, {},
     value: number | string;
     hidden: boolean;
     offset: [number, number];
-    dot: boolean;
     max: number;
+    dot: boolean;
     showZero: boolean;
     placement: import('./types').IndicatorPlacement;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLSpanElement>;

package/dist/components/InputNumber/InputNumber.d.ts

@@ -27,12 +27,12 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {
     ariaLabel: string;
     status: import('../..').ControlStatus;
     id: string;
-    min: number;
     max: number;
+    wheel: boolean;
+    min: number;
     readonly: boolean;
     step: number;
     precision: number;
-    wheel: boolean;
     controls: boolean;
     controlsPosition: "sides" | "right";
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {

package/dist/components/ListDetail/ListDetail.d.ts

@@ -0,0 +1,73 @@
+import { ListDetailProps } from './types';
+type __VLS_Props = ListDetailProps;
+type __VLS_PublicProps = {
+    'open'?: boolean;
+    'filtersOpen'?: boolean;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        /** What narrows the list: views, folders, filters. The column is optional. */
+        filters?: (props: {
+            inline: boolean;
+            close: () => void;
+        }) => unknown;
+        /** The records. */
+        list?: (props: {
+            filtersInline: boolean;
+            openFilters: () => void;
+        }) => unknown;
+        /** The record that is open. */
+        detail?: (props: {
+            inline: boolean;
+            back: () => void;
+        }) => unknown;
+        /** Shown in the pane's place while nothing is selected. */
+        empty?: () => unknown;
+    }> & {
+        /** What narrows the list: views, folders, filters. The column is optional. */
+        filters?: (props: {
+            inline: boolean;
+            close: () => void;
+        }) => unknown;
+        /** The records. */
+        list?: (props: {
+            filtersInline: boolean;
+            openFilters: () => void;
+        }) => unknown;
+        /** The record that is open. */
+        detail?: (props: {
+            inline: boolean;
+            back: () => void;
+        }) => unknown;
+        /** Shown in the pane's place while nothing is selected. */
+        empty?: () => unknown;
+    };
+    refs: {
+        root: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+    "update:filtersOpen": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    "onUpdate:filtersOpen"?: ((value: boolean) => any) | undefined;
+}>, {
+    filtersWidth: number | string;
+    listWidth: number | string;
+    detailMin: number;
+    filtersTitle: string;
+    detailLabel: string;
+}, {}, {}, {}, 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/ListDetail/index.d.ts

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