@nuxt/ui 2.16.0 → 2.18.0

package/dist/runtime/composables/usePopper.d.ts

@@ -2,23 +2,23 @@ import type { Ref } from 'vue';
 import type { VirtualElement } from '@popperjs/core/lib/popper-lite';
 import type { Instance } from '@popperjs/core';
 import type { MaybeElement } from '@vueuse/core';
-import type { PopperOptions } from '../types/popper';
-export declare const createPopper: <TModifier extends Partial<import("@popperjs/core").Modifier<any, any>>>(reference: Element | VirtualElement, popper: HTMLElement, options?: Partial<import("@popperjs/core").OptionsGeneric<TModifier>> | undefined) => Instance;
+import type { PopperOptions } from '../types/popper.js';
+export declare const createPopper: <TModifier extends Partial<import("@popperjs/core").Modifier<any, any>>>(reference: Element | VirtualElement, popper: HTMLElement, options?: Partial<import("@popperjs/core").OptionsGeneric<TModifier>>) => Instance;
 export declare function usePopper({ locked, overflowPadding, offsetDistance, offsetSkid, gpuAcceleration, adaptive, scroll, resize, arrow, placement, strategy }: PopperOptions, virtualReference?: Ref<Element | VirtualElement>): readonly [Ref<MaybeElement>, Ref<MaybeElement>, Ref<{
     state: {
         elements: {
             reference: Element | {
                 getBoundingClientRect: () => ClientRect | DOMRect;
-                contextElement?: Element | undefined;
+                contextElement?: Element;
             };
             popper: HTMLElement;
-            arrow?: HTMLElement | undefined;
+            arrow?: HTMLElement;
         };
         options: {
             placement: import("@popperjs/core").Placement;
             modifiers: any[];
             strategy: import("@popperjs/core").PositioningStrategy;
-            onFirstUpdate?: ((arg0: Partial<import("@popperjs/core").State>) => void) | undefined;
+            onFirstUpdate?: (arg0: Partial<import("@popperjs/core").State>) => void;
         };
         placement: import("@popperjs/core").Placement;
         strategy: import("@popperjs/core").PositioningStrategy;
@@ -26,12 +26,12 @@ export declare function usePopper({ locked, overflowPadding, offsetDistance, off
             name: any;
             enabled: boolean;
             phase: import("@popperjs/core").ModifierPhases;
-            requires?: string[] | undefined;
-            requiresIfExists?: string[] | undefined;
-            fn: (arg0: import("@popperjs/core").ModifierArguments<any>) => void | import("@popperjs/core").State;
-            effect?: ((arg0: import("@popperjs/core").ModifierArguments<any>) => void | (() => void)) | undefined;
-            options?: Partial<any> | undefined;
-            data?: import("@popperjs/core").Obj | undefined;
+            requires?: Array<string>;
+            requiresIfExists?: Array<string>;
+            fn: (arg0: import("@popperjs/core").ModifierArguments<any>) => import("@popperjs/core").State | void;
+            effect?: (arg0: import("@popperjs/core").ModifierArguments<any>) => (() => void) | void;
+            options?: Partial<any>;
+            data?: import("@popperjs/core").Obj;
         }[];
         rects: {
             reference: {
@@ -64,20 +64,38 @@ export declare function usePopper({ locked, overflowPadding, offsetDistance, off
                 toString: () => "[object Window]";
                 devicePixelRatio: number;
                 visualViewport?: {
-                    addEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions | undefined) => void;
-                    dispatchEvent: (event: Event) => boolean;
-                    removeEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions | undefined) => void;
+                    addEventListener: {
+                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                    };
+                    dispatchEvent: {
+                        (event: Event): boolean;
+                        (event: Event): boolean;
+                    };
+                    removeEventListener: {
+                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                    };
                     width: number;
                     height: number;
                     offsetLeft: number;
                     offsetTop: number;
                     scale: number;
-                } | undefined;
+                };
                 ShadowRoot: ShadowRoot;
             } | {
-                addEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions | undefined) => void;
-                dispatchEvent: (event: Event) => boolean;
-                removeEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions | undefined) => void;
+                addEventListener: {
+                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                };
+                dispatchEvent: {
+                    (event: Event): boolean;
+                    (event: Event): boolean;
+                };
+                removeEventListener: {
+                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                };
                 width: number;
                 height: number;
                 offsetLeft: number;
@@ -100,20 +118,38 @@ export declare function usePopper({ locked, overflowPadding, offsetDistance, off
                 toString: () => "[object Window]";
                 devicePixelRatio: number;
                 visualViewport?: {
-                    addEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions | undefined) => void;
-                    dispatchEvent: (event: Event) => boolean;
-                    removeEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions | undefined) => void;
+                    addEventListener: {
+                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                    };
+                    dispatchEvent: {
+                        (event: Event): boolean;
+                        (event: Event): boolean;
+                    };
+                    removeEventListener: {
+                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                    };
                     width: number;
                     height: number;
                     offsetLeft: number;
                     offsetTop: number;
                     scale: number;
-                } | undefined;
+                };
                 ShadowRoot: ShadowRoot;
             } | {
-                addEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions | undefined) => void;
-                dispatchEvent: (event: Event) => boolean;
-                removeEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions | undefined) => void;
+                addEventListener: {
+                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                };
+                dispatchEvent: {
+                    (event: Event): boolean;
+                    (event: Event): boolean;
+                };
+                removeEventListener: {
+                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                };
                 width: number;
                 height: number;
                 offsetLeft: number;
@@ -132,10 +168,10 @@ export declare function usePopper({ locked, overflowPadding, offsetDistance, off
         modifiersData: {
             [x: string]: any;
             arrow?: {
-                x?: number | undefined;
-                y?: number | undefined;
+                x?: number;
+                y?: number;
                 centerOffset: number;
-            } | undefined;
+            };
             hide?: {
                 isReferenceHidden: boolean;
                 hasPopperEscaped: boolean;
@@ -151,77 +187,77 @@ export declare function usePopper({ locked, overflowPadding, offsetDistance, off
                     right: number;
                     bottom: number;
                 };
-            } | undefined;
+            };
             offset?: {
                 "bottom-end"?: {
                     y: number;
                     x: number;
-                } | undefined;
+                };
                 "bottom-start"?: {
                     y: number;
                     x: number;
-                } | undefined;
-                bottom?: {
+                };
+                auto?: {
                     y: number;
                     x: number;
-                } | undefined;
-                left?: {
+                };
+                right?: {
                     y: number;
                     x: number;
-                } | undefined;
-                right?: {
+                };
+                left?: {
                     y: number;
                     x: number;
-                } | undefined;
-                top?: {
+                };
+                "auto-start"?: {
                     y: number;
                     x: number;
-                } | undefined;
-                auto?: {
+                };
+                "auto-end"?: {
                     y: number;
                     x: number;
-                } | undefined;
-                "auto-start"?: {
+                };
+                top?: {
                     y: number;
                     x: number;
-                } | undefined;
-                "auto-end"?: {
+                };
+                bottom?: {
                     y: number;
                     x: number;
-                } | undefined;
+                };
                 "top-start"?: {
                     y: number;
                     x: number;
-                } | undefined;
+                };
                 "top-end"?: {
                     y: number;
                     x: number;
-                } | undefined;
+                };
                 "right-start"?: {
                     y: number;
                     x: number;
-                } | undefined;
+                };
                 "right-end"?: {
                     y: number;
                     x: number;
-                } | undefined;
+                };
                 "left-start"?: {
                     y: number;
                     x: number;
-                } | undefined;
+                };
                 "left-end"?: {
                     y: number;
                     x: number;
-                } | undefined;
-            } | undefined;
+                };
+            };
             preventOverflow?: {
                 y: number;
                 x: number;
-            } | undefined;
+            };
             popperOffsets?: {
                 y: number;
                 x: number;
-            } | undefined;
+            };
         };
         reset: boolean;
     };
@@ -229,4 +265,4 @@ export declare function usePopper({ locked, overflowPadding, offsetDistance, off
     forceUpdate: () => void;
     update: () => Promise<Partial<import("@popperjs/core").State>>;
     setOptions: (setOptionsAction: Partial<import("@popperjs/core").OptionsGeneric<any>> | ((prev: Partial<import("@popperjs/core").OptionsGeneric<any>>) => Partial<import("@popperjs/core").OptionsGeneric<any>>)) => Promise<Partial<import("@popperjs/core").State>>;
-} | null>];
+}>];

package/dist/runtime/composables/useShortcuts.d.ts

@@ -1,12 +1,12 @@
 export declare const _useShortcuts: () => {
-    macOS: import("vue").ComputedRef<false | "" | RegExpMatchArray | null | undefined>;
+    macOS: import("vue").ComputedRef<RegExpMatchArray>;
     metaSymbol: import("vue").Ref<string>;
-    activeElement: import("vue").Ref<HTMLElement | null | undefined>;
+    activeElement: import("vue").Ref<HTMLElement>;
     usingInput: import("vue").ComputedRef<string | boolean>;
 };
 export declare const useShortcuts: () => {
-    macOS: import("vue").ComputedRef<false | "" | RegExpMatchArray | null | undefined>;
+    macOS: import("vue").ComputedRef<RegExpMatchArray>;
     metaSymbol: import("vue").Ref<string>;
-    activeElement: import("vue").Ref<HTMLElement | null | undefined>;
+    activeElement: import("vue").Ref<HTMLElement>;
     usingInput: import("vue").ComputedRef<string | boolean>;
 };

package/dist/runtime/composables/useSlideover.d.ts

@@ -1,12 +1,12 @@
 import type { ShallowRef, Component, InjectionKey } from 'vue';
-import type { ComponentProps } from '../types/component';
-import type { Slideover, SlideoverState } from '../types/slideover';
+import type { ComponentProps } from '../types/component.js';
+import type { Slideover, SlideoverState } from '../types/slideover.js';
 export declare const slidOverInjectionKey: InjectionKey<ShallowRef<SlideoverState>>;
 declare function _useSlideover(): {
     open: <T extends Component>(component: T, props?: Slideover & ComponentProps<T>) => void;
     close: () => Promise<void>;
     reset: () => void;
-    patch: <T_1 extends Component = {}>(props: Partial<Slideover & ComponentProps<T_1>>) => void;
+    patch: <T extends Component = {}>(props: Partial<Slideover & ComponentProps<T>>) => void;
     isOpen: import("vue").Ref<boolean>;
 };
 export declare const useSlideover: typeof _useSlideover;

package/dist/runtime/composables/{useSlideover.mjs → useSlideover.js}

@@ -15,8 +15,7 @@ function _useSlideover() {
     isOpen.value = true;
   }
   async function close() {
-    if (!slideoverState)
-      return;
+    if (!slideoverState) return;
     isOpen.value = false;
   }
   function reset() {
@@ -26,8 +25,7 @@ function _useSlideover() {
     };
   }
   function patch(props) {
-    if (!slideoverState)
-      return;
+    if (!slideoverState) return;
     slideoverState.value = {
       ...slideoverState.value,
       props: {

package/dist/runtime/composables/useTimer.d.ts

@@ -4,5 +4,5 @@ export declare function useTimer(cb: (...args: unknown[]) => any, interval: numb
     stop: () => void;
     pause: () => void;
     resume: () => void;
-    remaining: import("vue-demi").ComputedRef<number>;
+    remaining: import("vue").ComputedRef<number>;
 };

package/dist/runtime/composables/useToast.d.ts

@@ -1,17 +1,17 @@
-import type { Notification } from '../types/notification';
+import type { Notification } from '../types/notification.js';
 export declare function useToast(): {
     add: (notification: Partial<Notification>) => {
         id: string;
-        title?: string | undefined;
-        description?: string | undefined;
-        icon?: string | undefined;
-        avatar?: import("../types").Avatar | undefined;
-        closeButton?: import("../types").Button | undefined;
-        timeout?: number | undefined;
-        actions?: import("../types/notification").NotificationAction[] | undefined;
-        click?: Function | undefined;
-        callback?: Function | undefined;
-        color?: any;
+        title?: string;
+        description?: string;
+        icon?: string;
+        avatar?: import("../types").Avatar;
+        closeButton?: import("../types").Button;
+        timeout?: number;
+        actions?: import("../types").NotificationAction[];
+        click?: Function;
+        callback?: Function;
+        color?: import("../types").NotificationColor;
         ui?: any;
     };
     remove: (id: string) => void;

package/dist/runtime/composables/useUI.d.ts

@@ -1,5 +1,5 @@
 import type { Ref } from 'vue';
-import type { Strategy } from '../types';
+import type { Strategy } from '../types.js';
 export declare const useUI: <T>(key: any, $ui?: Ref<(Partial<T> & {
     strategy?: Strategy;
 }) | undefined>, $config?: Ref<T> | T, $wrapperClass?: Ref<string>, withAppConfig?: boolean) => {

package/dist/runtime/composables/{useUI.mjs → useUI.js}

@@ -1,6 +1,6 @@
 import { computed, toValue, useAttrs } from "vue";
 import { useAppConfig } from "#imports";
-import { mergeConfig, omit, get } from "../utils/index.mjs";
+import { mergeConfig, omit, get } from "../utils/index.js";
 export const useUI = (key, $ui, $config, $wrapperClass, withAppConfig = false) => {
   const $attrs = useAttrs();
   const appConfig = useAppConfig();

package/dist/runtime/plugins/colors.d.ts

@@ -1,2 +1,2 @@
-declare const _default: any;
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
 export default _default;

package/dist/runtime/plugins/{colors.mjs → colors.js}

@@ -1,5 +1,5 @@
 import { computed } from "vue";
-import { hexToRgb } from "../utils/index.mjs";
+import { hexToRgb } from "../utils/index.js";
 import { defineNuxtPlugin, useAppConfig, useNuxtApp, useHead } from "#imports";
 import colors from "#tailwind-config/theme/colors";
 export default defineNuxtPlugin(() => {

package/dist/runtime/plugins/modals.d.ts

@@ -1,2 +1,2 @@
-declare const _default: any;
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
 export default _default;

package/dist/runtime/plugins/{modals.mjs → modals.js}

@@ -1,6 +1,6 @@
 import { defineNuxtPlugin } from "#imports";
 import { shallowRef } from "vue";
-import { modalInjectionKey } from "../composables/useModal.mjs";
+import { modalInjectionKey } from "../composables/useModal.js";
 export default defineNuxtPlugin((nuxtApp) => {
   const modalState = shallowRef({
     component: "div",

package/dist/runtime/plugins/slideovers.d.ts

@@ -1,2 +1,2 @@
-declare const _default: any;
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
 export default _default;

package/dist/runtime/plugins/{slideovers.mjs → slideovers.js}

@@ -1,6 +1,6 @@
 import { defineNuxtPlugin } from "#imports";
 import { shallowRef } from "vue";
-import { slidOverInjectionKey } from "../composables/useSlideover.mjs";
+import { slidOverInjectionKey } from "../composables/useSlideover.js";
 export default defineNuxtPlugin((nuxtApp) => {
   const slideoverState = shallowRef({
     component: "div",

package/dist/runtime/types/accordion.d.ts

@@ -1,9 +1,8 @@
-import type { Button } from './button'
-
+import type { Button } from './button.js';
 export interface AccordionItem extends Button {
-  slot?: string
-  disabled?: boolean
-  content?: string
-  defaultOpen?: boolean
-  closeOthers?: boolean
+    slot?: string;
+    disabled?: boolean;
+    content?: string;
+    defaultOpen?: boolean;
+    closeOthers?: boolean;
 }

package/dist/runtime/types/alert.d.ts

@@ -1,12 +1,10 @@
-import { alert } from '../ui.config'
-import type { NestedKeyOf, ExtractDeepKey, ExtractDeepObject } from '.'
-import type { Button } from './button'
-import colors from '#ui-colors'
-import type { AppConfig } from 'nuxt/schema'
-
-export type AlertColor = keyof typeof alert.color | ExtractDeepKey<AppConfig, ['ui', 'alert', 'color']> | typeof colors[number]
-export type AlertVariant = keyof typeof alert.variant | ExtractDeepKey<AppConfig, ['ui', 'alert', 'variant']> | NestedKeyOf<typeof alert.color> | NestedKeyOf<ExtractDeepObject<AppConfig, ['ui', 'alert', 'color']>>
-
+import { alert } from '../ui.config.js';
+import type { NestedKeyOf, ExtractDeepKey, ExtractDeepObject } from '.';
+import type { Button } from './button.js';
+import colors from '#ui-colors';
+import type { AppConfig } from 'nuxt/schema';
+export type AlertColor = keyof typeof alert.color | ExtractDeepKey<AppConfig, ['ui', 'alert', 'color']> | typeof colors[number];
+export type AlertVariant = keyof typeof alert.variant | ExtractDeepKey<AppConfig, ['ui', 'alert', 'variant']> | NestedKeyOf<typeof alert.color> | NestedKeyOf<ExtractDeepObject<AppConfig, ['ui', 'alert', 'color']>>;
 export interface AlertAction extends Button {
-  click?: Function
+    click?: Function;
 }

package/dist/runtime/types/avatar.d.ts

@@ -1,17 +1,15 @@
-import { avatar } from '../ui.config'
-import type { ExtractDeepKey } from '.'
-import colors from '#ui-colors'
-import type { AppConfig } from 'nuxt/schema'
-
-export type AvatarSize = keyof typeof avatar.size | ExtractDeepKey<AppConfig, ['ui', 'avatar', 'size']>
-export type AvatarChipColor = 'gray' | typeof colors[number]
-export type AvatarChipPosition = keyof typeof avatar.chip.position
-
+import { avatar } from '../ui.config.js';
+import type { ExtractDeepKey } from '.';
+import colors from '#ui-colors';
+import type { AppConfig } from 'nuxt/schema';
+export type AvatarSize = keyof typeof avatar.size | ExtractDeepKey<AppConfig, ['ui', 'avatar', 'size']>;
+export type AvatarChipColor = 'gray' | typeof colors[number];
+export type AvatarChipPosition = keyof typeof avatar.chip.position;
 export interface Avatar {
-  src?: string | boolean
-  alt?: string
-  text?: string
-  size?: AvatarSize
-  chipColor?: AvatarChipColor
-  chipPosition?: AvatarChipPosition
+    src?: string | boolean;
+    alt?: string;
+    text?: string;
+    size?: AvatarSize;
+    chipColor?: AvatarChipColor;
+    chipPosition?: AvatarChipPosition;
 }

package/dist/runtime/types/badge.d.ts

@@ -1,15 +1,13 @@
-import { badge } from '../ui.config'
-import type { NestedKeyOf, ExtractDeepKey, ExtractDeepObject } from '.'
-import colors from '#ui-colors'
-import type { AppConfig } from 'nuxt/schema'
-
-export type BadgeSize = keyof typeof badge.size | ExtractDeepKey<AppConfig, ['ui', 'badge', 'size']>
-export type BadgeColor = keyof typeof badge.color | ExtractDeepKey<AppConfig, ['ui', 'badge', 'color']> | typeof colors[number]
-export type BadgeVariant = keyof typeof badge.variant | ExtractDeepKey<AppConfig, ['ui', 'badge', 'variant']> | NestedKeyOf<typeof badge.color> | NestedKeyOf<ExtractDeepObject<AppConfig, ['ui', 'badge', 'color']>>
-
+import { badge } from '../ui.config.js';
+import type { NestedKeyOf, ExtractDeepKey, ExtractDeepObject } from '.';
+import colors from '#ui-colors';
+import type { AppConfig } from 'nuxt/schema';
+export type BadgeSize = keyof typeof badge.size | ExtractDeepKey<AppConfig, ['ui', 'badge', 'size']>;
+export type BadgeColor = keyof typeof badge.color | ExtractDeepKey<AppConfig, ['ui', 'badge', 'color']> | typeof colors[number];
+export type BadgeVariant = keyof typeof badge.variant | ExtractDeepKey<AppConfig, ['ui', 'badge', 'variant']> | NestedKeyOf<typeof badge.color> | NestedKeyOf<ExtractDeepObject<AppConfig, ['ui', 'badge', 'color']>>;
 export interface Badge {
-  label?: string
-  size?: BadgeSize
-  color?: BadgeColor
-  variant?: BadgeVariant
+    label?: string;
+    size?: BadgeSize;
+    color?: BadgeColor;
+    variant?: BadgeVariant;
 }

package/dist/runtime/types/breadcrumb.d.ts

@@ -1,10 +1,8 @@
-import type { Link } from './link'
-
+import type { Link } from './link.js';
 export interface BreadcrumbLink extends Link {
-  label: string
-  labelClass?: string
-  icon?: string
-  iconClass?: string
-  // FIXME: This is a workaround for `link.to` not being resolved although it extends `NuxtLinkProps`
-  [key: string]: any
+    label: string;
+    labelClass?: string;
+    icon?: string;
+    iconClass?: string;
+    [key: string]: any;
 }

package/dist/runtime/types/button.d.ts

@@ -1,31 +1,29 @@
-import type { Link } from './link'
-import { button } from '../ui.config'
-import type { NestedKeyOf, ExtractDeepKey, ExtractDeepObject } from '.'
-import colors from '#ui-colors'
-import type { AppConfig } from 'nuxt/schema'
-
-export type ButtonSize = keyof typeof button.size | ExtractDeepKey<AppConfig, ['ui', 'button', 'size']>
-export type ButtonColor = keyof typeof button.color | ExtractDeepKey<AppConfig, ['ui', 'button', 'color']> | typeof colors[number]
-export type ButtonVariant = keyof typeof button.variant | ExtractDeepKey<AppConfig, ['ui', 'button', 'variant']> | NestedKeyOf<typeof button.color> | NestedKeyOf<ExtractDeepObject<AppConfig, ['ui', 'button', 'color']>>
-
+import type { Link } from './link.js';
+import { button } from '../ui.config.js';
+import type { NestedKeyOf, ExtractDeepKey, ExtractDeepObject } from '.';
+import colors from '#ui-colors';
+import type { AppConfig } from 'nuxt/schema';
+export type ButtonSize = keyof typeof button.size | ExtractDeepKey<AppConfig, ['ui', 'button', 'size']>;
+export type ButtonColor = keyof typeof button.color | ExtractDeepKey<AppConfig, ['ui', 'button', 'color']> | typeof colors[number];
+export type ButtonVariant = keyof typeof button.variant | ExtractDeepKey<AppConfig, ['ui', 'button', 'variant']> | NestedKeyOf<typeof button.color> | NestedKeyOf<ExtractDeepObject<AppConfig, ['ui', 'button', 'color']>>;
 export interface Button extends Link {
-  type?: string
-  block?: boolean
-  label?: string
-  loading?: boolean
-  disabled?: boolean
-  padded?: boolean
-  size?: ButtonSize
-  color?: ButtonColor
-  variant?: ButtonVariant
-  icon?: string
-  loadingIcon?: string
-  leadingIcon?: string
-  trailingIcon?: string
-  trailing?: boolean
-  leading?: boolean
-  to?: string | object
-  target?: string
-  square?: boolean
-  truncate?: boolean
+    type?: string;
+    block?: boolean;
+    label?: string;
+    loading?: boolean;
+    disabled?: boolean;
+    padded?: boolean;
+    size?: ButtonSize;
+    color?: ButtonColor;
+    variant?: ButtonVariant;
+    icon?: string;
+    loadingIcon?: string;
+    leadingIcon?: string;
+    trailingIcon?: string;
+    trailing?: boolean;
+    leading?: boolean;
+    to?: string | object;
+    target?: string;
+    square?: boolean;
+    truncate?: boolean;
 }