@octans/ui 1.0.0

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

@@ -0,0 +1,15 @@
+import { TimezonePickerProps } from './types';
+declare const __VLS_export: import('vue').DefineComponent<TimezonePickerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: string | undefined) => any;
+}, string, import('vue').PublicProps, Readonly<TimezonePickerProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | undefined) => any) | undefined;
+}>, {
+    disabled: boolean;
+    inline: boolean;
+    readonly: boolean;
+    condensed: boolean;
+    guess: boolean;
+    groupByCountry: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,2 @@
+export { default as TimezonePicker } from './TimezonePicker.vue';
+export * from './types';

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

@@ -0,0 +1,50 @@
+export interface TimezonePickerProps {
+    /** The selected IANA timezone id, e.g. `Australia/Sydney`. */
+    modelValue?: string;
+    label?: string;
+    error?: string;
+    /** Help text to show below the control. */
+    helpText?: string;
+    /** Renders help text as raw HTML. Use with caution. */
+    helpTextHtml?: string;
+    /** Renders a help icon next to the label which links to an external page. */
+    helpLink?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    /**
+     * When `true` and `modelValue` is empty, the picker guesses the user's
+     * timezone on mount and emits it.
+     */
+    guess?: boolean;
+    /**
+     * Shows a Location field above the timezone field and narrows the list to
+     * that country's zones. **On by default** — picking a country first turns
+     * ~420 zones into a handful, which is what makes the picker feel manageable.
+     *
+     * Set to `false` for a single searchable list of every zone, which suits
+     * users who already know the city they want. That also avoids loading the
+     * bundled zone → country map, which is imported on demand.
+     */
+    groupByCountry?: boolean;
+    /**
+     * Renders the fields directly instead of behind a summary field and a modal.
+     *
+     * Use this when the picker already sits inside a form that has its own save
+     * action — the modal's Update/Cancel would then be a second, redundant
+     * commit step.
+     *
+     * **Changes emit immediately.** There is no Update button to press, so
+     * `update:modelValue` fires as soon as a selection is made. Selecting a
+     * country also emits, because it moves the value to that country's first
+     * zone.
+     */
+    inline?: boolean;
+    /**
+     * Narrows the fields so they stay side by side in tighter containers.
+     *
+     * Inline fields already sit side by side and wrap when there isn't room;
+     * this lowers the width at which they wrap. Only applies when `inline` and
+     * `groupByCountry` are both on.
+     */
+    condensed?: boolean;
+}

package/dist/components/TimezonePicker/zoneCountries.d.ts

@@ -0,0 +1,2 @@
+export declare const ZONE_COUNTRIES: Record<string, string>;
+export default ZONE_COUNTRIES;

package/dist/components/ToastManager/ProgressBar.vue.d.ts

@@ -0,0 +1,8 @@
+export interface ProgressBarProps {
+    value?: number;
+}
+declare const __VLS_export: import('vue').DefineComponent<ProgressBarProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ProgressBarProps> & Readonly<{}>, {
+    value: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/ToastManager/Toast.vue.d.ts

@@ -0,0 +1,14 @@
+import { ToastProps } from './types';
+declare const __VLS_export: import('vue').DefineComponent<ToastProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    pause: (...args: any[]) => void;
+    remove: (...args: any[]) => void;
+    resume: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<ToastProps> & Readonly<{
+    onPause?: ((...args: any[]) => any) | undefined;
+    onRemove?: ((...args: any[]) => any) | undefined;
+    onResume?: ((...args: any[]) => any) | undefined;
+}>, {
+    contrasting: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,19 @@
+import { ToastPosition } from './types';
+type __VLS_Props = {
+    position?: ToastPosition;
+    offset?: number | {
+        x?: number;
+        y?: number;
+    };
+    contrasting?: boolean;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    position: ToastPosition;
+    contrasting: boolean;
+    offset: number | {
+        x?: number;
+        y?: number;
+    };
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/ToastManager/host.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Removes the auto-mounted host. `app.unmount()` is a real teardown — leave
+ * transitions are skipped but every `onUnmounted` runs — so nothing is left
+ * behind on the page or in memory.
+ */
+export declare function teardownHost(): void;
+/**
+ * Mounts the default host the first time a toast is shown.
+ *
+ * Does nothing if the consumer already has a `<ToastManager>` of their own, and
+ * nothing at all without a DOM — `toast()` under SSR still records the item, it
+ * just has nowhere to draw it until the client takes over.
+ */
+export declare function ensureHost(): void;

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

@@ -0,0 +1,24 @@
+import { default as ToastManager } from './ToastManager.vue';
+import { ToastManagerConfig, ToastManagerItemType } from './types';
+/**
+ * Shows a toast, and returns it. The returned object is reactive: assigning to
+ * `title`, `content`, `progress` or `loading` updates the toast on screen, and
+ * `remove()` dismisses it.
+ *
+ * A host is mounted on first use, so nothing has to be placed in the page for
+ * this to work. Render a `<ToastManager>` yourself if you want to control the
+ * position with props — `toast()` will use it.
+ */
+declare function toast(opts: Partial<ToastManagerItemType>): ToastManagerItemType;
+declare namespace toast {
+    var clearAll: () => void;
+    var configure: (config: ToastManagerConfig) => void;
+    var promise: <T>(promise: Promise<T>, opts: {
+        loading: string | Partial<ToastManagerItemType>;
+        success?: ToastPromiseState;
+        error?: ToastPromiseState;
+    }) => ToastManagerItemType;
+}
+type ToastPromiseState = string | Partial<ToastManagerItemType> | ((value: any) => string | Partial<ToastManagerItemType>);
+export { toast, ToastManager };
+export type { ToastItemType, ToastManagerItemType, ToastManagerConfig, ToastActionType, ToastPosition, ToastTone } from './types';

package/dist/components/ToastManager/manager.d.ts

@@ -0,0 +1,45 @@
+import { ToastManagerConfig, ToastManagerItemType, ToastTone } from './types';
+export declare const TONE_ICONS: Record<ToastTone, string>;
+interface TimerState {
+    handle: ReturnType<typeof setTimeout>;
+    startedAt: number;
+    remaining: number;
+}
+export declare class Manager {
+    nextId: number;
+    items: ToastManagerItemType[];
+    /** `toast.configure()` defaults. A mounted host falls back to its own props
+     * for anything not set here. */
+    config: ToastManagerConfig;
+    timers: Map<number, TimerState>;
+    /** How many `<ToastManager>`s are currently rendering these items. */
+    hosts: number;
+    private hostWatchers;
+    constructor();
+    addItem(data: Partial<ToastManagerItemType>): ToastManagerItemType;
+    startTimer(item: ToastManagerItemType, duration?: number): void;
+    pauseTimer(item: ToastManagerItemType): void;
+    resumeTimer(item: ToastManagerItemType): void;
+    clearTimer(item: ToastManagerItemType): void;
+    removeItem(item: ToastManagerItemType): void;
+    clearAll(): void;
+    configure(config: ToastManagerConfig): void;
+    addHost(): void;
+    removeHost(): void;
+    /** Notified whenever a host mounts. Used by `ensureHost()` to retire its own
+     * auto-mounted host once the consumer supplies one. */
+    watchHosts(fn: () => void): () => void;
+}
+/**
+ * The single store every `toast()` call writes to, and every mounted
+ * `<ToastManager>` reads from.
+ *
+ * State lives here rather than inside the component on purpose. It used to be
+ * the other way round, which meant `toast()` had to find a component instance
+ * by DOM id, read Vue's private `_vnode` off the element and call through
+ * `component.exposed` — and a `<ToastManager>` in the consumer's own tree was
+ * invisible to it, so their props were silently ignored in favour of a second,
+ * auto-mounted manager.
+ */
+export declare const manager: Manager;
+export {};

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

@@ -0,0 +1,44 @@
+export type ToastPosition = 'n' | 'ne' | 'e' | 'se' | 's' | 'sw' | 'w' | 'nw';
+export type ToastTone = 'success' | 'warning' | 'error' | 'info';
+export interface ToastActionType {
+    label: string;
+    onAction?(): void;
+}
+export interface ToastItemType {
+    title: string;
+    content?: string;
+    progress?: number;
+    icon?: string;
+    loading?: boolean;
+    actions?: ToastActionType[];
+    /** Corner or edge of the viewport the toast stacks at. Defaults to the
+     * manager's `position` (out of the box `'se'`, the bottom right). */
+    position?: ToastPosition;
+    /** Sets a default icon and accent color for common toast flavors. */
+    tone?: ToastTone;
+    /** Dark toast on a light UI (the default). Pass `false` for a white toast.
+     * Defaults to the manager's `contrasting`. */
+    contrasting?: boolean;
+}
+export interface ToastProps {
+    item: ToastItemType;
+    contrasting?: boolean;
+}
+export interface ToastManagerItemType extends ToastItemType {
+    _id: number;
+    duration: number;
+    remove(): void;
+}
+export interface ToastManagerConfig {
+    /** Default stack position for toasts that don't set their own. */
+    position?: ToastPosition;
+    /** Distance in pixels between each stack and the viewport edges it anchors
+     * to, in addition to the toasts' built-in 16px margin. A number applies to
+     * both axes. */
+    offset?: number | {
+        x?: number;
+        y?: number;
+    };
+    /** Default theme for toasts that don't set their own `contrasting`. */
+    contrasting?: boolean;
+}

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

@@ -0,0 +1,35 @@
+import { ToggleSwitchProps } from './types';
+declare var __VLS_1: {
+    checked: boolean;
+};
+type __VLS_Slots = {} & {
+    handle?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<ToggleSwitchProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (v: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<ToggleSwitchProps> & Readonly<{
+    "onUpdate:modelValue"?: ((v: boolean) => any) | undefined;
+}>, {
+    disabled: boolean;
+    size: "small" | "medium" | "large";
+    color: string;
+    checked: boolean;
+    trueValue: any;
+    falseValue: any;
+    colorOn: string;
+    colorOff: string;
+    icons: boolean;
+    iconOn: string;
+    iconOff: string;
+    iconColor: string;
+    iconColorOn: string;
+    iconColorOff: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,2 @@
+export { default as ToggleSwitch } from './ToggleSwitch.vue';
+export * from './types';

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

@@ -0,0 +1,84 @@
+export interface ToggleSwitchProps {
+    /**
+     * The bound value / v-model.
+     */
+    modelValue?: any;
+    /**
+     * The model value to use when checked.
+     */
+    trueValue?: any;
+    /**
+     * The model value to use when not checked.
+     */
+    falseValue?: any;
+    /**
+     * When `true` the checkbox will be checked. This is an alternative
+     * to assigning `value` to be `trueValue`.
+     */
+    checked?: boolean;
+    disabled?: boolean;
+    /**
+     * Shorthand for `colorOn` — the track colour when checked. `colorOn` wins if
+     * both are given.
+     */
+    color?: string;
+    /**
+     * Track colour when checked. Any CSS colour.
+     *
+     * Defaults to `var(--octans-primary)`, so it follows the active theme.
+     */
+    colorOn?: string;
+    /**
+     * Track colour when unchecked. Any CSS colour.
+     *
+     * Defaults to `var(--octans-border-input)`. Setting this also colours the
+     * off icon, which otherwise stays subdued grey — the default track is too
+     * pale to read as an icon against the white knob.
+     */
+    colorOff?: string;
+    /**
+     * Visual size of the switch. All dimensions scale proportionally.
+     *
+     * - `"small"` — 42×24
+     * - `"medium"` — 60×34 (default)
+     * - `"large"` — 78×44
+     */
+    size?: 'small' | 'medium' | 'large';
+    /**
+     * Shows a tick / cross inside the knob. **On by default** — state then reads
+     * at a glance instead of relying on position and colour alone, which is the
+     * more accessible default and the one most people want.
+     *
+     * Set `:icons="false"` for a plain knob.
+     */
+    icons?: boolean;
+    /**
+     * Icon shown in the knob when checked. Any name the `Icon` component
+     * accepts. Defaults to `mdi:check`.
+     */
+    iconOn?: string;
+    /**
+     * Icon shown in the knob when unchecked. Any name the `Icon` component
+     * accepts. Defaults to `mdi:close`.
+     */
+    iconOff?: string;
+    /**
+     * Shorthand for both icon colours. `iconColorOn` / `iconColorOff` win over
+     * this for the state they name.
+     */
+    iconColor?: string;
+    /**
+     * Colour of the knob icon when checked.
+     *
+     * Defaults to the on track colour, which ties the knob to the track. Worth
+     * overriding if you give the knob a non-white background.
+     */
+    iconColorOn?: string;
+    /**
+     * Colour of the knob icon when unchecked.
+     *
+     * Defaults to `colorOff` when you set one, otherwise subdued grey — the
+     * default off track is too pale to read against the white knob.
+     */
+    iconColorOff?: string;
+}

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

@@ -0,0 +1,20 @@
+import { PopperPlacementType } from '../Popper';
+export interface TooltipProps {
+    placement?: PopperPlacementType;
+    content?: string;
+}
+declare var __VLS_26: {}, __VLS_34: {};
+type __VLS_Slots = {} & {
+    content?: (props: typeof __VLS_26) => any;
+} & {
+    default?: (props: typeof __VLS_34) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<TooltipProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<TooltipProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

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

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

@@ -0,0 +1,16 @@
+/**
+ * Lets Tooltip tell whether it is already inside a provider. Without it every
+ * Tooltip has to supply its own, which works but breaks radix's grouping —
+ * moving between two tooltips no longer skips the open delay.
+ */
+export declare const hasTooltipProviderKey: unique symbol;
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,2 @@
+export { default as UiProvider } from './UiProvider.vue';
+export * from './types';

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

@@ -0,0 +1,2 @@
+import { ToastManager } from '../ToastManager';
+export type ToastManagerInstance = InstanceType<typeof ToastManager>;

package/dist/components/UiProvider/utils.d.ts

@@ -0,0 +1,5 @@
+import { InjectionKey, Ref } from 'vue';
+import { ToastManagerInstance } from './types';
+export declare const ToastManagerKey: InjectionKey<Ref<ToastManagerInstance | undefined>>;
+export declare function provideToastManager(instanceRef: Ref<ToastManagerInstance | undefined>): void;
+export declare function injectToastManager(): ToastManagerInstance;

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

@@ -0,0 +1,5 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

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

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

package/dist/components/all.d.ts

@@ -0,0 +1,92 @@
+/**
+ * HEY YOU! Don't import this file from components.
+ *
+ * For now this is only to be used by the library entry point `src/lib.ts` to
+ * conveniently import all components and their types.
+ *
+ * Components should always import other components via explicit imports to keep
+ * their dependencies at a minimum e.g.:
+ *
+ * ```
+ * import {Select, type SelectOptionType} from '@/components/Select'
+ * ```
+ */
+export * from './ActionList';
+export * from './AppFrame';
+export * from './Badge';
+export * from './Banner';
+export * from './Button';
+export * from './Calendar';
+export * from './CalendarHeatmap';
+export * from './Caption';
+export * from './Card';
+export * from './Checkbox';
+export * from './Choice';
+export * from './ChoiceList';
+export * from './ColorPicker';
+export * from './ColorSelector';
+export * from './DataTable';
+export * from './DatePicker';
+export * from './Divider';
+export * from './EventDelegator';
+export * from './FileInput';
+export * from './Filters';
+export * from './FooterHelp';
+export * from './Formatter';
+export * from './FormLayout';
+export * from './GlobalNav';
+export * from './GradientPicker';
+export * from './Heading';
+export * from './Icon';
+export * from './InlineError';
+export * from './Labelled';
+export * from './Layout';
+export * from './Link';
+export * from './List';
+export * from './LoaderOverlay';
+export * from './LoadingBar';
+export * from './MaybeMountingPortal';
+export * from './MaybeRouterLink';
+export * from './Modal';
+export * from './NavField';
+export * from './Navigation';
+export * from './OtpInput';
+export * from './Page';
+export * from './PageActions';
+export * from './Pagination';
+export * from './Popper';
+export * from './PreventAutoComplete';
+export * from './ProgressBar';
+export * from './RadioButton';
+export * from './RangeSlider';
+export * from './Rating';
+export * from './SaveBar';
+export * from './SaveBarController';
+export * from './ScrollPane';
+export * from './SegmentedControl';
+export * from './Select';
+export * from './Sheet';
+export * from './SkeletonBodyText';
+export * from './SkeletonCard';
+export * from './SkeletonDisplayText';
+export * from './Spinner';
+export * from './Splitter';
+export * from './Stack';
+export * from './StatGroup';
+export * from './Tabs';
+export * from './Tag';
+export * from './TextContainer';
+export * from './TextField';
+export * from './TextStyle';
+export * from './Thumbnail';
+export * from './ToastManager';
+export * from './TimePicker';
+export * from './TimezonePicker';
+export * from './ToggleSwitch';
+export * from './Tooltip';
+export * from './UiProvider';
+export * from './UnstyledLink';
+export * from './LineClamper';
+export * from './Sticky';
+export * from './SyntaxHighlighter';
+export * from './ResourceList';

package/dist/components/types.d.ts

@@ -0,0 +1,74 @@
+export type ActionTypeType = 'default' | 'primary' | 'secondary' | 'destructive' | 'outline' | 'plain' | 'link';
+/**
+ * The colour role a button (or similar action) draws from. Orthogonal to the
+ * action TYPE, which sets its visual weight — any role can ride any type.
+ */
+export type ActionColorType = 'primary' | 'secondary' | 'tertiary' | 'info' | 'success' | 'warning' | 'error';
+export type ActionTooltipPositionType = 'top' | 'bottom' | 'right' | 'left';
+export interface ActionType {
+    label: string;
+    type?: ActionTypeType;
+    icon?: string;
+    disabled?: boolean;
+    url?: string;
+    tooltip?: string;
+    tooltipPosition?: ActionTooltipPositionType;
+    external?: boolean;
+    visible?: boolean;
+    /**
+     * Called when the action is chosen. Takes no arguments — an action knows
+     * what it acts on, because you closed over it when you built the action.
+     *
+     * Components that DO have something to hand back declare their own action
+     * type saying so, rather than widening this one: `DataTableRowActionType`
+     * passes the row, `DataTableBulkActionType` the selected rows, and
+     * `NavigationSecondaryItemType` the item.
+     */
+    onAction?(): void;
+}
+/**
+ * An action bound to one thing — a table row, a list entry — which receives
+ * that thing when chosen.
+ *
+ * `ActionType` with a typed argument rather than a looser `ActionType`: the
+ * argument is the whole reason these exist, so it belongs in the type where
+ * an editor will offer it.
+ */
+export interface ActionWithSubjectType<T> extends Omit<ActionType, 'onAction'> {
+    onAction?(subject: T): void;
+}
+export interface BadgeType {
+    label: string;
+    progress?: BadgeProgressType;
+    size?: BadgeSizeType;
+    status?: BadgeStatusType;
+}
+export type BadgeProgressType = `incomplete` | `partiallyComplete` | `complete`;
+export type BadgeStatusType = `info` | `success` | `warning` | `error` | `attention` | `new`;
+export type BadgeSizeType = `small` | `medium`;
+/**
+ * The status of a badge overlaid on an icon or a button, as distinct from
+ * `BadgeStatusType` which belongs to the standalone Badge component.
+ */
+export type IconBadgeStatusType = `info` | `success` | `warning` | `error`;
+/**
+ * The long form of a button badge. The short form is a bare string: either a
+ * status (`badge="warning"`) or some text, optionally coloured with
+ * `badgeStatus` (`badge="3" badge-status="error"`).
+ */
+export interface IconBadgeType {
+    /**
+     * Text to show in a pill on the corner of the button, e.g. a count. Without
+     * it the badge is drawn as a small glyph on the button's icon instead.
+     */
+    text?: string | number;
+    status?: IconBadgeStatusType;
+    /**
+     * An Iconify name to use for the glyph instead of the status default.
+     */
+    icon?: string;
+    /**
+     * A colour to use instead of the status default.
+     */
+    color?: string;
+}

package/dist/globalExtensions.d.ts

@@ -0,0 +1,7 @@
+import { default as UI } from './lib';
+export {};
+declare module 'vue' {
+    interface ComponentCustomProperties {
+        $ui: typeof UI;
+    }
+}