@webx-ui/core 0.5.0 → 0.7.0

package/dist/components/Alert/Alert.d.ts

@@ -0,0 +1,41 @@
+import { AlertProps } from './types';
+import { IconName } from '../Icon/types';
+type __VLS_Props = AlertProps;
+type __VLS_PublicProps = {
+    'visible'?: boolean;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        icon?(_: {}): any;
+        title?(_: {}): any;
+        default?(_: {}): any;
+        actions?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: (event: MouseEvent) => any;
+    "update:visible": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onClose?: ((event: MouseEvent) => any) | undefined;
+    "onUpdate:visible"?: ((value: boolean) => any) | undefined;
+}>, {
+    variant: import('./types').AlertVariant;
+    type: import('./types').AlertType;
+    title: string;
+    icon: IconName | false;
+    description: string;
+    closable: boolean;
+    closeLabel: string;
+    live: 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/Alert/index.d.ts

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

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

@@ -0,0 +1,29 @@
+import { IconName } from '../Icon/types';
+export type AlertType = 'info' | 'success' | 'warning' | 'danger';
+export type AlertVariant = 'soft' | 'solid' | 'outline';
+export interface AlertProps {
+    /** Semantic role of the message. */
+    type?: AlertType;
+    /** Visual weight. `soft` is the tinted panel an admin page usually wants. */
+    variant?: AlertVariant;
+    /** Headline above the body. Without it the body carries the message alone. */
+    title?: string;
+    /** The message, when a slot would be overkill. */
+    description?: string;
+    /**
+     * The leading icon. A name overrides the one implied by `type`; `false` drops it.
+     */
+    icon?: IconName | false;
+    /** Adds a × that closes the alert. */
+    closable?: boolean;
+    /** Accessible name of the close button. */
+    closeLabel?: string;
+    /**
+     * Announces the alert when it appears. Leave it off for a message that is part of
+     * the page from the start — a screen reader would read it out of nowhere.
+     */
+    live?: boolean;
+}
+export interface AlertEmits {
+    close: [event: MouseEvent];
+}

package/dist/components/Aside/Aside.d.ts

@@ -0,0 +1,25 @@
+import { AsideProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<AsideProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<AsideProps> & Readonly<{}>, {
+    bordered: boolean;
+    side: "start" | "end";
+    collapsed: boolean;
+    width: number | string;
+    collapsedWidth: number | string;
+    scroll: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLElement>;
+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/Aside/index.d.ts

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

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

@@ -0,0 +1,14 @@
+export interface AsideProps {
+    /** Width of the column: pixels as a number, or any CSS length. */
+    width?: number | string;
+    /** Width once `collapsed` is on — the icon rail of a sidebar. */
+    collapsedWidth?: number | string;
+    /** Narrows the column to `collapsedWidth`. Pair it with a collapsed `WxMenu`. */
+    collapsed?: boolean;
+    /** Which edge carries the rule: the sidebar's own side of the page. */
+    side?: 'start' | 'end';
+    /** Rule between the column and the page. */
+    bordered?: boolean;
+    /** Scrolls the column on its own, independently of the page. */
+    scroll?: boolean;
+}

package/dist/components/Badge/Badge.d.ts

@@ -18,9 +18,9 @@ declare const __VLS_component: import('vue').DefineComponent<BadgeProps, {}, {},
     size: import('./types').BadgeSize;
     type: import('./types').BadgeType;
     round: boolean;
-    dot: boolean;
     closable: boolean;
     closeLabel: string;
+    dot: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLSpanElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;

package/dist/components/Breadcrumb/Breadcrumb.d.ts

@@ -0,0 +1,23 @@
+import { BreadcrumbProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<BreadcrumbProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<BreadcrumbProps> & Readonly<{}>, {
+    size: import('./types').BreadcrumbSize;
+    label: string;
+    separator: string;
+    separatorIcon: import('..').IconName;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLElement>;
+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/Breadcrumb/index.d.ts

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

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

@@ -0,0 +1,13 @@
+import { IconName } from '../Icon/types';
+import { BreadcrumbSize } from '../../composables/useBreadcrumb';
+export type { BreadcrumbSize };
+export interface BreadcrumbProps {
+    /** Character drawn between items. */
+    separator?: string;
+    /** Icon drawn between items instead of the character — `chevron-right`, usually. */
+    separatorIcon?: IconName;
+    /** Text size of the trail. */
+    size?: BreadcrumbSize;
+    /** Accessible name of the navigation landmark. */
+    label?: string;
+}

package/dist/components/BreadcrumbItem/BreadcrumbItem.d.ts

@@ -0,0 +1,28 @@
+import { BreadcrumbItemProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<BreadcrumbItemProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<BreadcrumbItemProps> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    as: string | import('vue').Component;
+    target: string;
+    icon: import('..').IconName;
+    href: string;
+    current: 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/BreadcrumbItem/index.d.ts

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

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

@@ -0,0 +1,19 @@
+import { Component } from 'vue';
+import { IconName } from '../Icon/types';
+export interface BreadcrumbItemProps {
+    /** Where the crumb points. Without it the crumb is plain text. */
+    href?: string;
+    target?: string;
+    /** Renders through another component — `RouterLink`, say, with `to` in the attrs. */
+    as?: string | Component;
+    /** Icon before the label. */
+    icon?: IconName;
+    /**
+     * Marks the crumb as the page you are on. Left alone, a crumb that links nowhere
+     * counts as the current page, which is how the last crumb is normally written.
+     */
+    current?: boolean;
+}
+export interface BreadcrumbItemEmits {
+    click: [event: MouseEvent];
+}

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

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

package/dist/components/Col/Col.d.ts

@@ -0,0 +1,27 @@
+import { ColBreakpoint, ColProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<ColProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ColProps> & Readonly<{}>, {
+    sm: ColBreakpoint;
+    md: ColBreakpoint;
+    as: string | import('vue').Component;
+    span: number;
+    lg: ColBreakpoint;
+    offset: number;
+    xl: ColBreakpoint;
+    order: 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/Col/index.d.ts

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

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

@@ -0,0 +1,24 @@
+import { Component } from 'vue';
+/** A width at one breakpoint: the span alone, or the span with an offset. */
+export type ColBreakpoint = number | {
+    span?: number;
+    offset?: number;
+};
+export interface ColProps {
+    /** Columns out of 24 the cell takes. This is the base — it holds at every width. */
+    span?: number;
+    /** Empty columns before the cell, out of 24. */
+    offset?: number;
+    /** From 640px up. */
+    sm?: ColBreakpoint;
+    /** From 768px up. */
+    md?: ColBreakpoint;
+    /** From 1024px up. */
+    lg?: ColBreakpoint;
+    /** From 1280px up. */
+    xl?: ColBreakpoint;
+    /** Visual order within the row, without touching the source order. */
+    order?: number;
+    /** The element to render. */
+    as?: string | Component;
+}

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

@@ -0,0 +1,22 @@
+import { ContainerProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<ContainerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ContainerProps> & Readonly<{}>, {
+    as: string | import('vue').Component;
+    direction: import('./types').ContainerDirection;
+    fullHeight: 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/Container/index.d.ts

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

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

@@ -0,0 +1,13 @@
+import { Component } from 'vue';
+export type ContainerDirection = 'vertical' | 'horizontal';
+export interface ContainerProps {
+    /**
+     * How the children stack. A page is `vertical` — header, body, footer; the body
+     * itself is `horizontal` — sidebar beside the main column.
+     */
+    direction?: ContainerDirection;
+    /** Makes the container at least as tall as the viewport. For the outermost one. */
+    fullHeight?: boolean;
+    /** The element to render. */
+    as?: string | Component;
+}

package/dist/components/Dialog/Dialog.d.ts

@@ -0,0 +1,105 @@
+import { DialogLayout, DialogProps } from './types';
+type __VLS_Props = DialogProps;
+declare function close(): void;
+/** Back to the declared size, in the middle of the screen, and forgotten. */
+declare function reset(): void;
+type __VLS_PublicProps = {
+    'open'?: boolean;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        /** The control that opens the panel. Exactly one element. */
+        trigger?: (props: {
+            open: boolean;
+        }) => unknown;
+        /** The body. */
+        default?: (props: {
+            close: () => void;
+        }) => unknown;
+        /** Replaces `title`. */
+        title?: () => unknown;
+        /** Next to the heading — badges, or actions that belong to the whole panel. */
+        extra?: (props: {
+            close: () => void;
+        }) => unknown;
+        /** A column beside the body. Its presence is what splits the body in two. */
+        sidebar?: (props: {
+            close: () => void;
+        }) => unknown;
+        /** A row under the body — where the Save and Cancel go. */
+        footer?: (props: {
+            close: () => void;
+        }) => unknown;
+    }> & {
+        /** The control that opens the panel. Exactly one element. */
+        trigger?: (props: {
+            open: boolean;
+        }) => unknown;
+        /** The body. */
+        default?: (props: {
+            close: () => void;
+        }) => unknown;
+        /** Replaces `title`. */
+        title?: () => unknown;
+        /** Next to the heading — badges, or actions that belong to the whole panel. */
+        extra?: (props: {
+            close: () => void;
+        }) => unknown;
+        /** A column beside the body. Its presence is what splits the body in two. */
+        sidebar?: (props: {
+            close: () => void;
+        }) => unknown;
+        /** A row under the body — where the Save and Cancel go. */
+        footer?: (props: {
+            close: () => void;
+        }) => unknown;
+    };
+    refs: {
+        panel: HTMLDivElement;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {
+    close: typeof close;
+    reset: typeof reset;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: () => any;
+    open: () => any;
+    "update:open": (value: boolean) => any;
+    layout: (layout: DialogLayout) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onOpen?: (() => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    onLayout?: ((layout: DialogLayout) => any) | undefined;
+}>, {
+    title: string;
+    modal: boolean;
+    ariaLabel: string;
+    closable: boolean;
+    closeLabel: string;
+    width: number | string;
+    scroll: import('./types').DialogScroll;
+    height: number | string;
+    stickyFooter: boolean;
+    minWidth: number;
+    minHeight: number;
+    sidebarWidth: number | string;
+    closeOnOverlay: boolean;
+    closeOnEscape: boolean;
+    overlay: boolean;
+    draggable: boolean;
+    resizable: boolean;
+    persist: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    panel: HTMLDivElement;
+}, 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/Dialog/index.d.ts

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

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

@@ -0,0 +1,60 @@
+/**
+ * What scrolls when the content is longer than the screen: the body inside a panel that
+ * stops at the edge of the screen, or the whole panel inside the screen itself.
+ */
+export type DialogScroll = 'body' | 'panel';
+/** Where the panel was left: pixels, and the offset from the middle of the screen. */
+export interface DialogLayout {
+    width?: number;
+    height?: number;
+    x?: number;
+    y?: number;
+}
+export interface DialogProps {
+    /** Heading of the panel. The `title` slot replaces it. */
+    title?: string;
+    /** Width of the panel: a number in pixels, or any CSS length — `520`, `'60%'`. */
+    width?: number | string;
+    /** Height of the panel. Without it the panel grows with its content, up to the screen. */
+    height?: number | string;
+    /**
+     * Where a long panel scrolls. `body` keeps the panel within the screen and scrolls what
+     * is between the heading and the footer. `panel` lets the panel grow past the screen and
+     * scrolls the whole of it — the heading goes with it, and dragging and resizing are off.
+     */
+    scroll?: DialogScroll;
+    /** In `scroll="panel"`, keep the footer against the bottom of the screen. */
+    stickyFooter?: boolean;
+    /** Smallest width a resize may reach, in pixels. */
+    minWidth?: number;
+    /** Smallest height a resize may reach, in pixels. */
+    minHeight?: number;
+    /** Width of the `sidebar` column: a number in pixels, or any CSS length. */
+    sidebarWidth?: number | string;
+    /** Adds a × to the heading. */
+    closable?: boolean;
+    /** Label of that ×, for screen readers. */
+    closeLabel?: string;
+    /** A click outside the panel closes it. */
+    closeOnOverlay?: boolean;
+    /** Escape closes it. */
+    closeOnEscape?: boolean;
+    /** Dim the page behind the panel. */
+    overlay?: boolean;
+    /** Block the page behind the panel, trap focus inside it and lock the page's scroll. */
+    modal?: boolean;
+    /** The panel can be dragged by its heading. */
+    draggable?: boolean;
+    /** The panel can be resized by the grip in its bottom-right corner. */
+    resizable?: boolean;
+    /** Remember size and position under this key, in `localStorage`. */
+    persist?: string;
+    /** Accessible name for the panel when it has no visible heading. */
+    ariaLabel?: string;
+}
+export interface DialogEmits {
+    open: [];
+    close: [];
+    /** The panel was dragged or resized. Carries what `persist` would store. */
+    layout: [layout: DialogLayout];
+}

package/dist/components/Divider/Divider.d.ts

@@ -0,0 +1,24 @@
+import { DividerProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<DividerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<DividerProps> & Readonly<{}>, {
+    variant: import('./types').DividerVariant;
+    label: string;
+    align: import('./types').DividerAlign;
+    direction: import('./types').DividerDirection;
+    spacing: import('./types').DividerSpacing;
+}, {}, {}, {}, 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/Divider/index.d.ts

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

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

@@ -0,0 +1,16 @@
+export type DividerDirection = 'horizontal' | 'vertical';
+export type DividerVariant = 'solid' | 'dashed' | 'dotted';
+export type DividerAlign = 'start' | 'center' | 'end';
+export type DividerSpacing = 'none' | 'sm' | 'md' | 'lg';
+export interface DividerProps {
+    /** A rule across the flow, or a hairline between two things on one line. */
+    direction?: DividerDirection;
+    /** Line style. */
+    variant?: DividerVariant;
+    /** Where the label sits on the line. Ignored without a label. */
+    align?: DividerAlign;
+    /** Margin around the rule. */
+    spacing?: DividerSpacing;
+    /** Label on the line, when a slot would be overkill. */
+    label?: string;
+}

package/dist/components/Drawer/Drawer.d.ts

@@ -0,0 +1,98 @@
+import { DrawerLayout, DrawerProps } from './types';
+type __VLS_Props = DrawerProps;
+declare function close(): void;
+/** Back to the declared size, and forgotten. */
+declare function reset(): void;
+type __VLS_PublicProps = {
+    'open'?: boolean;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        /** The control that opens the panel. Exactly one element. */
+        trigger?: (props: {
+            open: boolean;
+        }) => unknown;
+        /** The body. The one part of the panel that scrolls. */
+        default?: (props: {
+            close: () => void;
+        }) => unknown;
+        /** Replaces `title`. */
+        title?: () => unknown;
+        /** Next to the heading — badges, or actions that belong to the whole panel. */
+        extra?: (props: {
+            close: () => void;
+        }) => unknown;
+        /** A column beside the body. Its presence is what splits the body in two. */
+        sidebar?: (props: {
+            close: () => void;
+        }) => unknown;
+        /** A row under the body — where the Save and Cancel go. */
+        footer?: (props: {
+            close: () => void;
+        }) => unknown;
+    }> & {
+        /** The control that opens the panel. Exactly one element. */
+        trigger?: (props: {
+            open: boolean;
+        }) => unknown;
+        /** The body. The one part of the panel that scrolls. */
+        default?: (props: {
+            close: () => void;
+        }) => unknown;
+        /** Replaces `title`. */
+        title?: () => unknown;
+        /** Next to the heading — badges, or actions that belong to the whole panel. */
+        extra?: (props: {
+            close: () => void;
+        }) => unknown;
+        /** A column beside the body. Its presence is what splits the body in two. */
+        sidebar?: (props: {
+            close: () => void;
+        }) => unknown;
+        /** A row under the body — where the Save and Cancel go. */
+        footer?: (props: {
+            close: () => void;
+        }) => unknown;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {
+    close: typeof close;
+    reset: typeof reset;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: () => any;
+    open: () => any;
+    "update:open": (value: boolean) => any;
+    layout: (layout: DrawerLayout) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onOpen?: (() => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    onLayout?: ((layout: DrawerLayout) => any) | undefined;
+}>, {
+    size: number | string;
+    title: string;
+    side: import('./types').DrawerSide;
+    modal: boolean;
+    ariaLabel: string;
+    closable: boolean;
+    closeLabel: string;
+    sidebarWidth: number | string;
+    closeOnOverlay: boolean;
+    closeOnEscape: boolean;
+    overlay: boolean;
+    resizable: boolean;
+    persist: string;
+    minSize: number;
+    resizeLabel: string;
+}, {}, {}, {}, 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/Drawer/index.d.ts

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