@webx-ui/core 0.2.0 → 0.3.0

package/dist/components/Action/Action.d.ts

@@ -0,0 +1,35 @@
+import { ActionProps, ActionTone, ActionType } from './types';
+import { IconName } from '../Icon/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<ActionProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<ActionProps> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    size: import('./types').ActionSize;
+    label: string;
+    type: ActionType;
+    title: string;
+    icon: IconName;
+    tone: ActionTone;
+    href: string;
+    target: string;
+    as: string | import('vue').Component;
+    disabled: boolean;
+    hidden: 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/Action/index.d.ts

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

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

@@ -0,0 +1,37 @@
+import { Component } from 'vue';
+import { IconName } from '../Icon/types';
+/**
+ * What the action does. It picks the icon, the colour and the accessible name, so a
+ * row of actions stays consistent across screens — `icon`, `tone` and `label`
+ * override any of those when a screen needs something else.
+ */
+export type ActionType = 'add' | 'edit' | 'remove' | 'copy' | 'link' | 'goto' | 'details' | 'view' | 'hide' | 'upload' | 'download' | 'sort' | 'search' | 'restore' | 'settings' | 'send' | 'more';
+export type ActionTone = 'primary' | 'danger' | 'success' | 'warning' | 'neutral';
+export type ActionSize = 'sm' | 'md' | 'lg';
+export interface ActionProps {
+    type?: ActionType;
+    /** Icon to draw instead of the one the type picks. */
+    icon?: IconName;
+    /** Colour to use instead of the one the type picks. */
+    tone?: ActionTone;
+    /** Native tooltip; also the accessible name when `label` is not given. */
+    title?: string;
+    /** Accessible name. Needed whenever `title` is absent and the type is not enough. */
+    label?: string;
+    /** Renders an `<a>` instead of a `<button>`. */
+    href?: string;
+    target?: string;
+    /** Renders through another component — `RouterLink`, say, with `to` in the attrs. */
+    as?: string | Component;
+    disabled?: boolean;
+    /**
+     * Keeps the space but draws nothing. A row where one record may not be deleted
+     * stays lined up with the rows where it may.
+     */
+    hidden?: boolean;
+    /** Defaults to the size of the enclosing `WxActions`. */
+    size?: ActionSize;
+}
+export interface ActionEmits {
+    click: [event: MouseEvent];
+}

package/dist/components/Actions/Actions.d.ts

@@ -0,0 +1,45 @@
+import { ActionsProps } from './types';
+/**
+ * The row is measured against the space its container gives it. When it collapses
+ * the row is not unmounted, only taken out of the flow — it keeps its natural width,
+ * which is the only way to know when there is room for it again.
+ */
+declare function measure(): void;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        default?(_: {}): any;
+        trigger?(_: {}): any;
+        collapsed?(_: {}): any;
+    };
+    refs: {
+        root: HTMLDivElement;
+        row: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<ActionsProps, {
+    collapsed: import('vue').Ref<boolean, boolean>;
+    measure: typeof measure;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    collapse: (collapsed: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<ActionsProps> & Readonly<{
+    onCollapse?: ((collapsed: boolean) => any) | undefined;
+}>, {
+    size: import('..').ActionSize;
+    align: import('./types').ActionsAlign;
+    collapse: boolean;
+    ariaLabel: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    root: HTMLDivElement;
+    row: 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/Actions/index.d.ts

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

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

@@ -0,0 +1,20 @@
+import { ActionSize } from '../Action/types';
+export type ActionsAlign = 'start' | 'center' | 'end';
+export interface ActionsProps {
+    /** Where the row sits when it has room to spare. */
+    align?: ActionsAlign;
+    /** Size handed to every action that does not set its own. */
+    size?: ActionSize;
+    /**
+     * Collapses the row into a dropdown as soon as it no longer fits the container.
+     * The container has to have a width of its own — a table cell, a card, a column —
+     * otherwise there is nothing to measure against.
+     */
+    collapse?: boolean;
+    /** Accessible name of the group, e.g. "Row actions". */
+    ariaLabel?: string;
+}
+export interface ActionsEmits {
+    /** The row collapsed into the dropdown, or came back out of it. */
+    collapse: [collapsed: boolean];
+}

package/dist/components/Autocomplete/Autocomplete.d.ts

@@ -0,0 +1,60 @@
+import { AutocompleteOption, AutocompleteProps } from './types';
+type __VLS_Props = AutocompleteProps;
+type __VLS_PublicProps = {
+    modelValue?: string;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        prefix?(_: {}): any;
+        suffix?(_: {}): any;
+        option?(_: {
+            option: AutocompleteOption;
+        }): 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: () => any;
+    search: (term: string) => any;
+    select: (option: AutocompleteOption) => any;
+    clear: () => any;
+    open: () => any;
+    change: (value: string) => any;
+    "update:modelValue": (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onSearch?: ((term: string) => any) | undefined;
+    onSelect?: ((option: AutocompleteOption) => any) | undefined;
+    onClear?: (() => any) | undefined;
+    onOpen?: (() => any) | undefined;
+    onChange?: ((value: string) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    name: string;
+    size: import('../..').ControlSize;
+    disabled: boolean;
+    teleport: boolean;
+    placeholder: string;
+    ariaLabel: string;
+    options: AutocompleteOption[];
+    remote: boolean;
+    debounce: number;
+    loading: boolean;
+    loadingText: string;
+    emptyText: string;
+    minLength: number;
+    clearable: boolean;
+    openOnFocus: boolean;
+    status: import('../..').ControlStatus;
+    id: 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/Autocomplete/index.d.ts

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

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

@@ -0,0 +1,58 @@
+import { ControlSize, ControlStatus } from '../../composables/useFormField';
+/**
+ * A suggestion. `value` is the text that lands in the input when it is picked, so it
+ * is what the user sees after choosing; anything else you attach (an id, a record)
+ * comes back untouched in the `select` event and in the `option` slot.
+ */
+export interface AutocompleteOption {
+    value: string;
+    /** Shown in the list instead of `value`. */
+    label?: string;
+    /** Second line under the label — a hint, a path, a category. */
+    description?: string;
+    disabled?: boolean;
+    [key: string]: unknown;
+}
+export interface AutocompleteProps {
+    /** The suggestions to show. With `remote`, this is whatever the backend returned. */
+    options?: AutocompleteOption[];
+    /**
+     * The list is filtered by the backend: keep every option as given instead of
+     * matching it against the typed text again.
+     */
+    remote?: boolean;
+    /** Milliseconds of quiet typing before `search` fires. */
+    debounce?: number;
+    /** Shows that a request is in flight. */
+    loading?: boolean;
+    loadingText?: string;
+    /** Text shown when nothing matches. */
+    emptyText?: string;
+    /** Characters needed before the list opens and `search` fires. */
+    minLength?: number;
+    placeholder?: string;
+    /** Shows a button that empties the field. */
+    clearable?: boolean;
+    /** Opens the list as soon as the field is focused. */
+    openOnFocus?: boolean;
+    /** Render the list in a portal so it escapes `overflow: hidden`. */
+    teleport?: boolean;
+    disabled?: boolean;
+    size?: ControlSize;
+    status?: ControlStatus;
+    id?: string;
+    name?: string;
+    /** Accessible label used when there is no visible `<label>`. */
+    ariaLabel?: string;
+}
+export interface AutocompleteEmits {
+    /** The text changed — typed or picked. */
+    change: [value: string];
+    /** Debounced search term. Load your options in response to this. */
+    search: [term: string];
+    /** A suggestion was picked. */
+    select: [option: AutocompleteOption];
+    clear: [];
+    open: [];
+    close: [];
+}

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

@@ -0,0 +1,31 @@
+import { BadgeProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        icon?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLSpanElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<BadgeProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<BadgeProps> & Readonly<{
+    onClose?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    size: import('./types').BadgeSize;
+    type: import('./types').BadgeType;
+    round: boolean;
+    variant: import('./types').BadgeVariant;
+    dot: boolean;
+    closable: boolean;
+    closeLabel: string;
+}, {}, {}, {}, 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/Badge/index.d.ts

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

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

@@ -0,0 +1,21 @@
+export type BadgeType = 'default' | 'primary' | 'success' | 'warning' | 'danger' | 'info';
+export type BadgeVariant = 'soft' | 'solid' | 'outline';
+export type BadgeSize = 'sm' | 'md' | 'lg';
+export interface BadgeProps {
+    /** Semantic colour of the badge. */
+    type?: BadgeType;
+    /** Visual weight: tinted, filled or bordered. */
+    variant?: BadgeVariant;
+    size?: BadgeSize;
+    /** Pill shape instead of the default rounded rectangle. */
+    round?: boolean;
+    /** Shows a coloured dot before the label — a status badge rather than a tag. */
+    dot?: boolean;
+    /** Adds a × that emits `close`; the caller decides what to remove. */
+    closable?: boolean;
+    /** Label for the close button, for screen readers. */
+    closeLabel?: string;
+}
+export interface BadgeEmits {
+    close: [event: MouseEvent];
+}

package/dist/components/Button/Button.d.ts

@@ -14,15 +14,15 @@ declare const __VLS_component: import('vue').DefineComponent<ButtonProps, {}, {}
 }, string, import('vue').PublicProps, Readonly<ButtonProps> & Readonly<{
     onClick?: ((event: MouseEvent) => any) | undefined;
 }>, {
-    type: import('./types').ButtonType;
-    variant: import('./types').ButtonVariant;
     size: import('./types').ButtonSize;
-    disabled: boolean;
-    loading: boolean;
-    block: boolean;
+    type: import('./types').ButtonType;
     round: boolean;
     href: string;
     target: string;
+    disabled: boolean;
+    loading: boolean;
+    variant: import('./types').ButtonVariant;
+    block: boolean;
     nativeType: import('./types').ButtonNativeType;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;

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

@@ -3,10 +3,11 @@ export type ButtonVariant = 'solid' | 'outline' | 'text';
 export type ButtonSize = 'sm' | 'md' | 'lg';
 export type ButtonNativeType = 'button' | 'submit' | 'reset';
 export interface ButtonProps {
-    /** Semantic colour of the button. */
+    /** Semantic colour of the button. Defaults to `default`, or to the group's. */
     type?: ButtonType;
-    /** Visual weight: filled, bordered or borderless. */
+    /** Visual weight: filled, bordered or borderless. Defaults to `solid`, or to the group's. */
     variant?: ButtonVariant;
+    /** Defaults to `md`, or to the enclosing `WxButtonGroup`. */
     size?: ButtonSize;
     disabled?: boolean;
     /** Shows a spinner and blocks interaction. */

package/dist/components/ButtonGroup/ButtonGroup.d.ts

@@ -0,0 +1,26 @@
+import { ButtonGroupProps } 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<ButtonGroupProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ButtonGroupProps> & Readonly<{}>, {
+    size: import('..').ButtonSize;
+    type: import('..').ButtonType;
+    disabled: boolean;
+    ariaLabel: string;
+    variant: import('..').ButtonVariant;
+    vertical: boolean;
+    attached: 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/ButtonGroup/index.d.ts

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

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

@@ -0,0 +1,20 @@
+import { ButtonSize, ButtonType, ButtonVariant } from '../Button/types';
+export interface ButtonGroupProps {
+    /** Colour handed to every button that does not set its own. */
+    type?: ButtonType;
+    /** Variant handed to every button that does not set its own. */
+    variant?: ButtonVariant;
+    /** Size handed to every button that does not set its own. */
+    size?: ButtonSize;
+    /** Disables every button in the group. */
+    disabled?: boolean;
+    /** Stacks the buttons instead of lining them up. */
+    vertical?: boolean;
+    /**
+     * Joins the buttons into one segmented control — shared borders, rounded only at
+     * the ends. Turn it off for a plain row of separate buttons.
+     */
+    attached?: boolean;
+    /** Accessible name for the group, e.g. "Row actions". */
+    ariaLabel?: string;
+}

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

@@ -0,0 +1,62 @@
+import { CascaderModelValue, CascaderOption, CascaderProps } from './types';
+type __VLS_Props = CascaderProps;
+type __VLS_PublicProps = {
+    modelValue?: CascaderModelValue;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        option?(_: {
+            option: CascaderOption;
+            level: number;
+        }): any;
+    };
+    refs: {
+        panel: HTMLDivElement;
+    };
+    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: () => any;
+    clear: () => any;
+    open: () => any;
+    change: (value: CascaderModelValue) => any;
+    "update:modelValue": (value: CascaderModelValue) => any;
+    expand: (path: CascaderOption[]) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onClear?: (() => any) | undefined;
+    onOpen?: (() => any) | undefined;
+    onChange?: ((value: CascaderModelValue) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: CascaderModelValue) => any) | undefined;
+    onExpand?: ((path: CascaderOption[]) => any) | undefined;
+}>, {
+    name: string;
+    size: import('../..').ControlSize;
+    disabled: boolean;
+    teleport: boolean;
+    placeholder: string;
+    ariaLabel: string;
+    options: CascaderOption[];
+    emptyText: string;
+    clearable: boolean;
+    status: import('../..').ControlStatus;
+    id: string;
+    expandTrigger: "click" | "hover";
+    checkStrictly: boolean;
+    emitPath: boolean;
+    showAllLevels: boolean;
+    separator: string;
+    lazy: boolean;
+    load: import('./types').CascaderLoader;
+}, {}, {}, {}, 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/Cascader/index.d.ts

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

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

@@ -0,0 +1,55 @@
+import { ControlSize, ControlStatus } from '../../composables/useFormField';
+export type CascaderValue = string | number;
+export interface CascaderOption {
+    label: string;
+    value: CascaderValue;
+    children?: CascaderOption[];
+    disabled?: boolean;
+    /**
+     * Says this node has nothing under it. Only needed with `lazy`, where an empty
+     * `children` cannot tell "not loaded yet" from "nothing there".
+     */
+    leaf?: boolean;
+}
+/** The whole path by default (`['content', 'news']`), or the last value with `emit-path: false`. */
+export type CascaderModelValue = CascaderValue[] | CascaderValue | null;
+/** Loads one level. Called with `null` for the root, otherwise with the node opened. */
+export type CascaderLoader = (option: CascaderOption | null, path: CascaderOption[]) => CascaderOption[] | Promise<CascaderOption[]>;
+export interface CascaderProps {
+    /** The tree. Leave empty and use `lazy` to build it from the backend instead. */
+    options?: CascaderOption[];
+    /** Whether a child list opens on click or on hover. */
+    expandTrigger?: 'click' | 'hover';
+    /** Lets a parent be chosen, not only a leaf. */
+    checkStrictly?: boolean;
+    /** The model is the path of values; turn it off to store the last value alone. */
+    emitPath?: boolean;
+    /** Shows the whole path in the field; off shows the chosen label alone. */
+    showAllLevels?: boolean;
+    /** What goes between the levels in the field. */
+    separator?: string;
+    /** Levels are fetched as they open. Requires `load`. */
+    lazy?: boolean;
+    /** Fetches one level. Required when `lazy`. */
+    load?: CascaderLoader;
+    placeholder?: string;
+    emptyText?: string;
+    clearable?: boolean;
+    /** Render the panel in a portal so it escapes `overflow: hidden`. */
+    teleport?: boolean;
+    disabled?: boolean;
+    size?: ControlSize;
+    status?: ControlStatus;
+    id?: string;
+    name?: string;
+    /** Accessible label used when there is no visible `<label>`. */
+    ariaLabel?: string;
+}
+export interface CascaderEmits {
+    change: [value: CascaderModelValue];
+    /** A level was opened — the path of options leading to it. */
+    expand: [path: CascaderOption[]];
+    clear: [];
+    open: [];
+    close: [];
+}

package/dist/components/Checkbox/Checkbox.d.ts

@@ -23,12 +23,12 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps,
 }>, {
     name: string;
     size: import('../..').ControlSize;
-    disabled: boolean;
     label: string;
+    disabled: boolean;
+    ariaLabel: string;
     value: import('../../composables/useFormField').ChoiceValue;
-    indeterminate: boolean;
     id: string;
-    ariaLabel: string;
+    indeterminate: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     inputRef: HTMLInputElement;
 }, any>;

package/dist/components/ColorPicker/ColorPicker.d.ts

@@ -13,13 +13,13 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {},
     name: string;
     size: import('../..').ControlSize;
     disabled: boolean;
-    id: string;
+    teleport: boolean;
+    placeholder: string;
     ariaLabel: string;
-    presets: string[];
     clearable: boolean;
-    placeholder: string;
-    teleport: boolean;
-    readonly: boolean;
     status: import('../..').ControlStatus;
+    id: string;
+    presets: string[];
+    readonly: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/components/Countdown/Countdown.d.ts

@@ -0,0 +1,42 @@
+import { CountdownProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        title?(_: {}): any;
+        prefix?(_: {}): any;
+        suffix?(_: {}): any;
+        value?(_: {
+            remaining: number;
+            text: string;
+        }): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<CountdownProps, {
+    remaining: import('vue').Ref<number, number>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (remaining: number) => any;
+    finish: () => any;
+}, string, import('vue').PublicProps, Readonly<CountdownProps> & Readonly<{
+    onChange?: ((remaining: number) => any) | undefined;
+    onFinish?: (() => any) | undefined;
+}>, {
+    size: import('..').StatisticSize;
+    title: string;
+    tone: import('..').TextTone;
+    align: import('..').TextAlign;
+    prefix: string;
+    suffix: string;
+    format: string;
+    interval: number;
+}, {}, {}, {}, 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/Countdown/format.d.ts

@@ -0,0 +1,12 @@
+import { CountdownTarget } from './types';
+/**
+ * Renders a span of milliseconds against a pattern of `DD`, `HH`, `mm`, `ss`, `SSS`.
+ *
+ * Only the tokens the pattern actually contains consume time, so `mm:ss` on two hours
+ * prints `120:00` rather than silently dropping the hours. Everything else in the
+ * pattern is copied through — mind that a literal word containing a token (`ss` in
+ * "passed") would be replaced.
+ */
+export declare function formatCountdown(ms: number, format?: string): string;
+/** Normalises whatever the caller passed as a target into a timestamp. */
+export declare function toTimestamp(value: CountdownTarget): number;

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

@@ -0,0 +1,3 @@
+export { default as WxCountdown } from './Countdown';
+export { formatCountdown, toTimestamp } from './format';
+export type * from './types';