iryx-ui 0.2.0 → 0.3.0

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

@@ -0,0 +1,57 @@
+export interface PaginationProps {
+    /** Total number of records, not pages. */
+    total?: number;
+    itemsPerPage?: number;
+    /** How many pages to show either side of the current one. */
+    siblingCount?: number;
+    /** Keep the first and last page visible however far away they are. */
+    showEdges?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    /** Accessible names — override for non-English apps. */
+    prevLabel?: string;
+    nextLabel?: string;
+    label?: string;
+    /** Skip built-in classes; you take over styling entirely. */
+    unstyled?: boolean;
+    class?: string;
+    /** Override classes per slot, e.g. `{ item: 'rounded-full' }`. */
+    ui?: {
+        root?: string;
+        list?: string;
+        item?: string;
+        ellipsis?: string;
+    };
+}
+type __VLS_Props = PaginationProps;
+type __VLS_ModelProps = {
+    'page'?: number;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_20: {}, __VLS_45: {};
+type __VLS_Slots = {} & {
+    prev?: (props: typeof __VLS_20) => any;
+} & {
+    next?: (props: typeof __VLS_45) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:page": (value: number) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:page"?: ((value: number) => any) | undefined;
+}>, {
+    unstyled: boolean;
+    label: string;
+    total: number;
+    itemsPerPage: number;
+    siblingCount: number;
+    showEdges: boolean;
+    prevLabel: string;
+    nextLabel: 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/Progress.vue.d.ts

@@ -0,0 +1,52 @@
+export interface ProgressProps {
+    /** Current value. `null` (or `indeterminate`) means unknown duration. */
+    modelValue?: number | null;
+    max?: number;
+    variant?: 'primary' | 'success' | 'warning' | 'danger' | 'info';
+    size?: 'sm' | 'md' | 'lg';
+    /** Unknown duration — animates instead of tracking a value. */
+    indeterminate?: boolean;
+    /** Text shown above the track. */
+    label?: string;
+    /** Show the value beside the label. Defaults to a percentage. */
+    showValue?: boolean;
+    /**
+     * Format the displayed value and the accessible label. Override for
+     * non-percentage units or non-English locales.
+     */
+    formatValue?: (value: number, max: number) => string;
+    /** Skip built-in classes; you take over styling entirely. */
+    unstyled?: boolean;
+    class?: string;
+    /** Override classes per slot, e.g. `{ track: 'h-4' }`. */
+    ui?: {
+        root?: string;
+        header?: string;
+        label?: string;
+        value?: string;
+        track?: string;
+        indicator?: string;
+    };
+}
+declare var __VLS_1: {}, __VLS_3: {
+    value: number | null;
+    percent: number;
+    formatted: string;
+};
+type __VLS_Slots = {} & {
+    label?: (props: typeof __VLS_1) => any;
+} & {
+    value?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<ProgressProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProgressProps> & Readonly<{}>, {
+    unstyled: boolean;
+    max: number;
+}, {}, {}, {}, 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/Separator.vue.d.ts

@@ -0,0 +1,36 @@
+export interface SeparatorProps {
+    orientation?: 'horizontal' | 'vertical';
+    /** Text shown in the middle of the rule. */
+    label?: string;
+    /**
+     * Purely visual, so it is hidden from assistive tech. Set false when the
+     * rule genuinely divides sections of content.
+     */
+    decorative?: boolean;
+    /** Skip built-in classes; you take over styling entirely. */
+    unstyled?: boolean;
+    class?: string;
+    /** Override classes per slot, e.g. `{ line: 'bg-primary' }`. */
+    ui?: {
+        root?: string;
+        line?: string;
+        label?: string;
+    };
+}
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<SeparatorProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SeparatorProps> & Readonly<{}>, {
+    unstyled: boolean;
+    orientation: "horizontal" | "vertical";
+    decorative: boolean;
+}, {}, {}, {}, 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/Skeleton.vue.d.ts

@@ -0,0 +1,20 @@
+export interface SkeletonProps {
+    /** Render as a different element or component. */
+    as?: string;
+    variant?: 'text' | 'rect' | 'circle';
+    /** Repeat as stacked lines. Useful for paragraphs of placeholder copy. */
+    lines?: number;
+    /** Accessible description of what is loading. */
+    label?: string;
+    /** Skip built-in classes; you take over styling entirely. */
+    unstyled?: boolean;
+    class?: string;
+}
+declare const __VLS_export: import("vue").DefineComponent<SkeletonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SkeletonProps> & Readonly<{}>, {
+    as: string;
+    unstyled: boolean;
+    label: string;
+    lines: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,57 @@
+export interface StatProps {
+    /** Render as a different element or component. */
+    as?: string;
+    label?: string;
+    value?: string | number;
+    /** Change since the previous period. Sign picks the colour and the arrow. */
+    delta?: number;
+    /**
+     * Override the colour of the delta. Useful when down is the good direction —
+     * falling costs, for example — since the sign alone cannot tell.
+     */
+    trend?: 'up' | 'down' | 'neutral';
+    /** Secondary text under the value. */
+    hint?: string;
+    size?: 'sm' | 'md' | 'lg';
+    /**
+     * Format the delta. Defaults to a signed percentage; override for other
+     * units or locales.
+     */
+    formatDelta?: (delta: number) => string;
+    /** Skip built-in classes; you take over styling entirely. */
+    unstyled?: boolean;
+    class?: string;
+    /** Override classes per slot, e.g. `{ value: 'text-4xl' }`. */
+    ui?: {
+        root?: string;
+        label?: string;
+        value?: string;
+        delta?: string;
+        hint?: string;
+        row?: string;
+    };
+}
+declare var __VLS_8: {}, __VLS_10: {}, __VLS_12: {
+    trend: "neutral" | "up" | "down";
+}, __VLS_19: {};
+type __VLS_Slots = {} & {
+    label?: (props: typeof __VLS_8) => any;
+} & {
+    default?: (props: typeof __VLS_10) => any;
+} & {
+    delta?: (props: typeof __VLS_12) => any;
+} & {
+    hint?: (props: typeof __VLS_19) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<StatProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<StatProps> & Readonly<{}>, {
+    as: string;
+    unstyled: boolean;
+}, {}, {}, {}, 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/Stepper.vue.d.ts

@@ -0,0 +1,61 @@
+export interface StepperItemOption {
+    title: string;
+    description?: string;
+    disabled?: boolean;
+}
+export interface StepperProps {
+    items?: (StepperItemOption | string)[];
+    orientation?: 'horizontal' | 'vertical';
+    /**
+     * Require steps to be completed in order.
+     *
+     * Off by default, because when on, a later step cannot be reached until the
+     * ones before it are marked complete — which makes plain `v-model`
+     * increments silently do nothing. Turn it on only if you are driving
+     * navigation through the stepper's own triggers.
+     */
+    linear?: boolean;
+    /** Skip built-in classes; you take over styling entirely. */
+    unstyled?: boolean;
+    class?: string;
+    /** Override classes per slot, e.g. `{ indicator: 'size-10' }`. */
+    ui?: {
+        root?: string;
+        item?: string;
+        trigger?: string;
+        indicator?: string;
+        content?: string;
+        title?: string;
+        description?: string;
+        separator?: string;
+    };
+}
+type __VLS_Props = StepperProps;
+type __VLS_ModelProps = {
+    /** Steps are 1-indexed, matching how they read to a user. */
+    modelValue?: number;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_26: {
+    step: number;
+    item: StepperItemOption;
+};
+type __VLS_Slots = {} & {
+    indicator?: (props: typeof __VLS_26) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: number) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: number) => any) | undefined;
+}>, {
+    unstyled: boolean;
+    linear: boolean;
+}, {}, {}, {}, 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/Tabs.vue.d.ts

@@ -0,0 +1,63 @@
+import type { IconLike } from '../composables/icon';
+export interface TabsItem {
+    label: string;
+    /** Identifies the tab. Defaults to the label. */
+    value?: string;
+    icon?: IconLike;
+    disabled?: boolean;
+}
+export interface TabsProps {
+    items?: (TabsItem | string)[];
+    variant?: 'solid' | 'line';
+    orientation?: 'horizontal' | 'vertical';
+    /**
+     * Keep inactive panels mounted. Useful when a panel holds form state that
+     * should survive switching away.
+     */
+    keepMounted?: boolean;
+    /** Skip built-in classes; you take over styling entirely. */
+    unstyled?: boolean;
+    class?: string;
+    /** Override classes per slot, e.g. `{ list: 'w-full' }`. */
+    ui?: {
+        root?: string;
+        list?: string;
+        indicator?: string;
+        trigger?: string;
+        content?: string;
+    };
+}
+type __VLS_Props = TabsProps;
+type __VLS_ModelProps = {
+    modelValue?: string;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_19: {}, __VLS_27: {
+    item: TabsItem;
+}, __VLS_34: {}, __VLS_43: string, __VLS_44: {
+    item: TabsItem;
+};
+type __VLS_Slots = {} & {
+    [K in NonNullable<typeof __VLS_43>]?: (props: typeof __VLS_44) => any;
+} & {
+    list?: (props: typeof __VLS_19) => any;
+} & {
+    trigger?: (props: typeof __VLS_27) => any;
+} & {
+    default?: (props: typeof __VLS_34) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    unstyled: boolean;
+}, {}, {}, {}, 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/Toaster.vue.d.ts

@@ -0,0 +1,28 @@
+export interface ToasterProps {
+    position?: 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+    /** Default milliseconds before auto-dismiss; a toast's own `duration` wins. */
+    duration?: number;
+    /** Accessible name for each dismiss button — override for non-English apps. */
+    closeLabel?: string;
+    /** Skip built-in classes; you take over styling entirely. */
+    unstyled?: boolean;
+    class?: string;
+    /** Override classes per slot, e.g. `{ viewport: 'sm:max-w-md' }`. */
+    ui?: {
+        viewport?: string;
+        root?: string;
+        icon?: string;
+        content?: string;
+        title?: string;
+        description?: string;
+        action?: string;
+        close?: string;
+    };
+}
+declare const __VLS_export: import("vue").DefineComponent<ToasterProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ToasterProps> & Readonly<{}>, {
+    closeLabel: string;
+    unstyled: boolean;
+    duration: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,49 @@
+export interface TooltipProps {
+    /** Tooltip text. Ignored when the `content` slot is used. */
+    text?: string;
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    align?: 'start' | 'center' | 'end';
+    sideOffset?: number;
+    /** Milliseconds to hover before it opens. */
+    delay?: number;
+    /** Render the little pointer against the trigger. */
+    arrow?: boolean;
+    disabled?: boolean;
+    /** Skip built-in classes; you take over styling entirely. */
+    unstyled?: boolean;
+    class?: string;
+    /** Override classes per slot, e.g. `{ content: 'max-w-sm' }`. */
+    ui?: {
+        content?: string;
+        arrow?: string;
+    };
+}
+type __VLS_Props = TooltipProps;
+type __VLS_ModelProps = {
+    'open'?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_20: {}, __VLS_34: {};
+type __VLS_Slots = {} & {
+    trigger?: (props: typeof __VLS_20) => any;
+} & {
+    content?: (props: typeof __VLS_34) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {
+    unstyled: boolean;
+    side: "top" | "right" | "bottom" | "left";
+    sideOffset: number;
+    delay: number;
+}, {}, {}, {}, 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/index.d.ts

@@ -1,14 +1,29 @@
 export { default as Alert } from './Alert.vue';
 export { default as App } from './App.vue';
 export { default as Badge } from './Badge.vue';
+export { default as Breadcrumb } from './Breadcrumb.vue';
 export { default as Button } from './Button.vue';
+export { default as ButtonGroup } from './ButtonGroup.vue';
 export { default as Card } from './Card.vue';
 export { default as Checkbox } from './Checkbox.vue';
+export { default as ConfirmDialog } from './ConfirmDialog.vue';
+export { default as Dialog } from './Dialog.vue';
+export { default as DropdownMenu } from './DropdownMenu.vue';
+export { default as EmptyState } from './EmptyState.vue';
 export { default as Form } from './Form.vue';
 export { default as FormField } from './FormField.vue';
 export { default as Input } from './Input.vue';
 export { default as Label } from './Label.vue';
+export { default as Pagination } from './Pagination.vue';
+export { default as Progress } from './Progress.vue';
 export { default as RadioGroup } from './RadioGroup.vue';
 export { default as Select } from './Select.vue';
+export { default as Separator } from './Separator.vue';
+export { default as Skeleton } from './Skeleton.vue';
+export { default as Stat } from './Stat.vue';
+export { default as Stepper } from './Stepper.vue';
 export { default as Switch } from './Switch.vue';
+export { default as Tabs } from './Tabs.vue';
 export { default as Textarea } from './Textarea.vue';
+export { default as Toaster } from './Toaster.vue';
+export { default as Tooltip } from './Tooltip.vue';

package/dist/composables/button-group.d.ts

@@ -0,0 +1,12 @@
+import type { ComputedRef, InjectionKey } from 'vue';
+export type ButtonSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+/** Context a `ButtonGroup` exposes to the buttons it wraps. */
+export interface ButtonGroupContext {
+    size: ComputedRef<ButtonSize | undefined>;
+}
+export declare const buttonGroupContextKey: InjectionKey<ButtonGroupContext>;
+/**
+ * Access the enclosing `ButtonGroup`, if any. Buttons use this to pick up a
+ * shared size, so it only has to be set once on the group.
+ */
+export declare function useButtonGroup(): ButtonGroupContext | undefined;

package/dist/composables/confirm.d.ts

@@ -0,0 +1,36 @@
+export interface ConfirmOptions {
+    title: string;
+    description?: string;
+    /** Text for the confirming button. Supply your own for non-English apps. */
+    confirmLabel?: string;
+    /** Text for the dismissing button. Supply your own for non-English apps. */
+    cancelLabel?: string;
+    /** Style the confirming button as destructive. */
+    danger?: boolean;
+}
+/** An open request, plus the resolver its promise is waiting on. */
+export interface ConfirmRequest extends ConfirmOptions {
+    id: number;
+    resolve: (confirmed: boolean) => void;
+}
+/** Internal: the request `<IConfirmDialog>` should currently render. */
+export declare function useConfirmState(): import("vue").ShallowRef<ConfirmRequest | null, ConfirmRequest | null>;
+/** Settle the open request and clear it. */
+export declare function resolveConfirm(confirmed: boolean): void;
+export interface ConfirmApi {
+    /** Resolves `true` if the user confirms, `false` if they cancel or dismiss. */
+    confirm: (options: ConfirmOptions | string) => Promise<boolean>;
+}
+/**
+ * Promise-based confirmation for destructive actions.
+ *
+ * Requires a single `<IConfirmDialog />` mounted somewhere in the app —
+ * typically just inside `<IApp>`.
+ *
+ * ```ts
+ * const { confirm } = useConfirm()
+ * if (await confirm({ title: 'Delete draft?', danger: true }))
+ *   await remove()
+ * ```
+ */
+export declare function useConfirm(): ConfirmApi;

package/dist/composables/dropdown-menu.d.ts

@@ -0,0 +1,22 @@
+import type { IconLike } from './icon';
+export interface DropdownMenuItemOption {
+    label: string;
+    /** Leading icon component. */
+    icon?: IconLike;
+    disabled?: boolean;
+    /** Style the item as destructive. */
+    danger?: boolean;
+    /** Run when the item is chosen. Omit on an entry that opens a submenu. */
+    onSelect?: () => void;
+    /** Nested entries. Turns this item into a submenu trigger. */
+    items?: DropdownMenuEntry[];
+}
+/**
+ * One row of a menu.
+ *
+ * `'-'` renders a separator. An option with `items` opens a submenu, and one
+ * with neither `items` nor `onSelect` is a non-interactive group label.
+ */
+export type DropdownMenuEntry = DropdownMenuItemOption | '-';
+export declare function isSeparator(entry: DropdownMenuEntry): entry is '-';
+export declare function isSubmenu(entry: DropdownMenuItemOption): boolean;

package/dist/composables/icon.d.ts

@@ -0,0 +1,10 @@
+import type { IconArray } from '@hugeicons/vue';
+import type { Component } from 'vue';
+/**
+ * Anything that can be rendered as an icon.
+ *
+ * Hugeicons ships icons as data arrays rather than components, so both forms
+ * are accepted: pass a Hugeicons export, or any component that renders an SVG.
+ */
+export type IconLike = Component | IconArray;
+export declare function isIconArray(icon: IconLike): icon is IconArray;

package/dist/composables/toast.d.ts

@@ -0,0 +1,42 @@
+export type ToastVariant = 'neutral' | 'success' | 'warning' | 'danger' | 'info';
+export interface ToastOptions {
+    title?: string;
+    description?: string;
+    variant?: ToastVariant;
+    /** Milliseconds before auto-dismiss. `0` keeps it until dismissed. */
+    duration?: number;
+    /** Optional action button. */
+    action?: {
+        label: string;
+        onClick: () => void;
+    };
+}
+export interface ToastRecord extends ToastOptions {
+    id: number;
+}
+/** Internal: the toasts `<IToaster>` should currently render. */
+export declare function useToastState(): import("vue").ShallowRef<ToastRecord[], ToastRecord[]>;
+export interface ToastApi {
+    /** Show a toast. Returns its id, so it can be dismissed early. */
+    toast: (options: ToastOptions | string) => number;
+    success: (options: ToastOptions | string) => number;
+    warning: (options: ToastOptions | string) => number;
+    danger: (options: ToastOptions | string) => number;
+    info: (options: ToastOptions | string) => number;
+    /** Dismiss one toast by id. */
+    dismiss: (id: number) => void;
+    /** Dismiss every open toast. */
+    clear: () => void;
+}
+/**
+ * Imperative toast notifications.
+ *
+ * Requires a single `<IToaster />` mounted somewhere in the app — typically
+ * just inside `<IApp>`.
+ *
+ * ```ts
+ * const toast = useToast()
+ * toast.success('Saved')
+ * ```
+ */
+export declare function useToast(): ToastApi;

package/dist/config.d.ts

@@ -8,4 +8,13 @@ export interface IryxUiConfig {
 }
 export declare const defaultConfig: IryxUiConfig;
 export declare const iryxUiConfigKey: InjectionKey<IryxUiConfig>;
+/**
+ * Read the global config, falling back to the defaults.
+ *
+ * Any component resolving a boolean against this config must declare an
+ * explicit `undefined` default in `withDefaults` — Vue casts an absent boolean
+ * prop to `false`, which would shadow the config and make it do nothing. The
+ * same applies to props whose type merely includes `false`. `test/config.test.ts`
+ * guards this for every component.
+ */
 export declare function useIryxUiConfig(): IryxUiConfig;

package/dist/index.d.ts

@@ -4,19 +4,38 @@ export * from './components';
 export type { AlertProps } from './components/Alert.vue';
 export type { AppProps } from './components/App.vue';
 export type { BadgeProps } from './components/Badge.vue';
+export type { BreadcrumbItem, BreadcrumbProps } from './components/Breadcrumb.vue';
 export type { ButtonProps } from './components/Button.vue';
+export type { ButtonGroupProps } from './components/ButtonGroup.vue';
 export type { CardProps } from './components/Card.vue';
 export type { CheckboxProps } from './components/Checkbox.vue';
+export type { ConfirmDialogProps } from './components/ConfirmDialog.vue';
+export type { DialogProps } from './components/Dialog.vue';
+export type { DropdownMenuProps } from './components/DropdownMenu.vue';
+export type { EmptyStateProps } from './components/EmptyState.vue';
 export type { FormProps } from './components/Form.vue';
 export type { FormFieldProps } from './components/FormField.vue';
 export type { InputProps } from './components/Input.vue';
 export type { LabelProps } from './components/Label.vue';
+export type { PaginationProps } from './components/Pagination.vue';
+export type { ProgressProps } from './components/Progress.vue';
 export type { RadioGroupItemOption, RadioGroupProps } from './components/RadioGroup.vue';
 export type { SelectItemOption, SelectProps } from './components/Select.vue';
+export type { SeparatorProps } from './components/Separator.vue';
+export type { SkeletonProps } from './components/Skeleton.vue';
+export type { StatProps } from './components/Stat.vue';
+export type { StepperItemOption, StepperProps } from './components/Stepper.vue';
 export type { SwitchProps } from './components/Switch.vue';
+export type { TabsItem, TabsProps } from './components/Tabs.vue';
 export type { TextareaProps } from './components/Textarea.vue';
+export type { ToasterProps } from './components/Toaster.vue';
+export type { TooltipProps } from './components/Tooltip.vue';
 export * from './composables/appearance';
+export * from './composables/button-group';
+export * from './composables/confirm';
+export * from './composables/dropdown-menu';
 export * from './composables/form';
+export * from './composables/toast';
 export { defaultConfig, iryxUiConfigKey, useIryxUiConfig } from './config';
 export type { IryxUiConfig } from './config';
 export { createIryxUi, IryxUi } from './plugin';