@nuxt/ui 3.3.3 → 3.3.5

package/dist/runtime/components/Calendar.d.vue.ts

@@ -0,0 +1,112 @@
+import type { CalendarRootProps, CalendarRootEmits, RangeCalendarRootProps, RangeCalendarRootEmits, DateRange, CalendarCellTriggerProps } from 'reka-ui';
+import type { DateValue } from '@internationalized/date';
+import type { AppConfig } from '@nuxt/schema';
+import theme from '#build/ui/calendar';
+import type { ButtonProps } from '../types';
+import type { ComponentConfig } from '../types/utils';
+type Calendar = ComponentConfig<typeof theme, AppConfig, 'calendar'>;
+type CalendarDefaultValue<R extends boolean = false, M extends boolean = false> = R extends true ? DateRange : M extends true ? DateValue[] : DateValue;
+type CalendarModelValue<R extends boolean = false, M extends boolean = false> = R extends true ? (DateRange | null) : M extends true ? (DateValue[] | undefined) : (DateValue | undefined);
+type _CalendarRootProps = Omit<CalendarRootProps, 'as' | 'asChild' | 'modelValue' | 'defaultValue' | 'dir' | 'locale' | 'calendarLabel' | 'multiple'>;
+type _RangeCalendarRootProps = Omit<RangeCalendarRootProps, 'as' | 'asChild' | 'modelValue' | 'defaultValue' | 'dir' | 'locale' | 'calendarLabel' | 'multiple'>;
+export interface CalendarProps<R extends boolean = false, M extends boolean = false> extends _RangeCalendarRootProps, _CalendarRootProps {
+    /**
+     * The element or component this component should render as.
+     * @defaultValue 'div'
+     */
+    as?: any;
+    /**
+     * The icon to use for the next year control.
+     * @defaultValue appConfig.ui.icons.chevronDoubleRight
+     * @IconifyIcon
+     */
+    nextYearIcon?: string;
+    /**
+     * Configure the next year button.
+     * `{ color: 'neutral', variant: 'ghost' }`{lang="ts-type"}
+     */
+    nextYear?: ButtonProps;
+    /**
+     * The icon to use for the next month control.
+     * @defaultValue appConfig.ui.icons.chevronRight
+     * @IconifyIcon
+     */
+    nextMonthIcon?: string;
+    /**
+     * Configure the next month button.
+     * `{ color: 'neutral', variant: 'ghost' }`{lang="ts-type"}
+     */
+    nextMonth?: ButtonProps;
+    /**
+     * The icon to use for the previous year control.
+     * @defaultValue appConfig.ui.icons.chevronDoubleLeft
+     * @IconifyIcon
+     */
+    prevYearIcon?: string;
+    /**
+     * Configure the prev year button.
+     * `{ color: 'neutral', variant: 'ghost' }`{lang="ts-type"}
+     */
+    prevYear?: ButtonProps;
+    /**
+     * The icon to use for the previous month control.
+     * @defaultValue appConfig.ui.icons.chevronLeft
+     * @IconifyIcon
+     */
+    prevMonthIcon?: string;
+    /**
+     * Configure the prev month button.
+     * `{ color: 'neutral', variant: 'ghost' }`{lang="ts-type"}
+     */
+    prevMonth?: ButtonProps;
+    /**
+     * @defaultValue 'primary'
+     */
+    color?: Calendar['variants']['color'];
+    /**
+     * @defaultValue 'md'
+     */
+    size?: Calendar['variants']['size'];
+    /** Whether or not a range of dates can be selected */
+    range?: R & boolean;
+    /** Whether or not multiple dates can be selected */
+    multiple?: M & boolean;
+    /** Show month controls */
+    monthControls?: boolean;
+    /** Show year controls */
+    yearControls?: boolean;
+    defaultValue?: CalendarDefaultValue<R, M>;
+    modelValue?: CalendarModelValue<R, M>;
+    class?: any;
+    ui?: Calendar['slots'];
+}
+export interface CalendarEmits<R extends boolean, M extends boolean> extends Omit<CalendarRootEmits & RangeCalendarRootEmits, 'update:modelValue'> {
+    'update:modelValue': [date: CalendarModelValue<R, M>];
+}
+export interface CalendarSlots {
+    'heading': (props: {
+        value: string;
+    }) => any;
+    'day': (props: Pick<CalendarCellTriggerProps, 'day'>) => any;
+    'week-day': (props: {
+        day: string;
+    }) => any;
+}
+declare const _default: <R extends boolean, M extends boolean>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:modelValue"?: ((date: CalendarModelValue<R, M>) => any) | undefined;
+        readonly "onUpdate:placeholder"?: ((...args: unknown[]) => any) | undefined;
+        readonly "onUpdate:validModelValue"?: ((date: DateRange) => any) | undefined;
+        readonly "onUpdate:startValue"?: ((date: DateValue | undefined) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onUpdate:modelValue" | "onUpdate:placeholder" | "onUpdate:validModelValue" | "onUpdate:startValue"> & CalendarProps<R, M> & {}> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: CalendarSlots;
+    emit: ((evt: "update:modelValue", date: CalendarModelValue<R, M>) => void) & ((evt: "update:placeholder", ...args: [date: DateValue] & [date: DateValue]) => void) & ((evt: "update:validModelValue", date: DateRange) => void) & ((evt: "update:startValue", date: DateValue | undefined) => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T as K]: T[K];
+} & {};

package/dist/runtime/components/Card.d.vue.ts

@@ -0,0 +1,29 @@
+import type { AppConfig } from '@nuxt/schema';
+import theme from '#build/ui/card';
+import type { ComponentConfig } from '../types/utils';
+type Card = ComponentConfig<typeof theme, AppConfig, 'card'>;
+export interface CardProps {
+    /**
+     * The element or component this component should render as.
+     * @defaultValue 'div'
+     */
+    as?: any;
+    /**
+     * @defaultValue 'outline'
+     */
+    variant?: Card['variants']['variant'];
+    class?: any;
+    ui?: Card['slots'];
+}
+export interface CardSlots {
+    header(props?: {}): any;
+    default(props?: {}): any;
+    footer(props?: {}): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<CardProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<CardProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, CardSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/Carousel.d.vue.ts

@@ -0,0 +1,127 @@
+import type { AppConfig } from '@nuxt/schema';
+import type { AcceptableValue } from 'reka-ui';
+import type { EmblaCarouselType, EmblaOptionsType } from 'embla-carousel';
+import type { AutoplayOptionsType } from 'embla-carousel-autoplay';
+import type { AutoScrollOptionsType } from 'embla-carousel-auto-scroll';
+import type { AutoHeightOptionsType } from 'embla-carousel-auto-height';
+import type { ClassNamesOptionsType } from 'embla-carousel-class-names';
+import type { FadeOptionsType } from 'embla-carousel-fade';
+import type { WheelGesturesPluginOptions } from 'embla-carousel-wheel-gestures';
+import theme from '#build/ui/carousel';
+import type { ButtonProps } from '../types';
+import type { ComponentConfig } from '../types/utils';
+type Carousel = ComponentConfig<typeof theme, AppConfig, 'carousel'>;
+interface _CarouselItem {
+    class?: any;
+    ui?: Pick<Carousel['slots'], 'item'>;
+    [key: string]: any;
+}
+export type CarouselItem = _CarouselItem | AcceptableValue;
+export interface CarouselProps<T extends CarouselItem = CarouselItem> extends Omit<EmblaOptionsType, 'axis' | 'container' | 'slides' | 'direction'> {
+    /**
+     * The element or component this component should render as.
+     * @defaultValue 'div'
+     */
+    as?: any;
+    /**
+     * Configure the prev button when arrows are enabled.
+     * @defaultValue { size: 'md', color: 'neutral', variant: 'link' }
+     */
+    prev?: ButtonProps;
+    /**
+     * The icon displayed in the prev button.
+     * @defaultValue appConfig.ui.icons.arrowLeft
+     * @IconifyIcon
+     */
+    prevIcon?: string;
+    /**
+     * Configure the next button when arrows are enabled.
+     * @defaultValue { size: 'md', color: 'neutral', variant: 'link' }
+     */
+    next?: ButtonProps;
+    /**
+     * The icon displayed in the next button.
+     * @defaultValue appConfig.ui.icons.arrowRight
+     * @IconifyIcon
+     */
+    nextIcon?: string;
+    /**
+     * Display prev and next buttons to scroll the carousel.
+     * @defaultValue false
+     */
+    arrows?: boolean;
+    /**
+     * Display dots to scroll to a specific slide.
+     * @defaultValue false
+     */
+    dots?: boolean;
+    /**
+     * The orientation of the carousel.
+     * @defaultValue 'horizontal'
+     */
+    orientation?: Carousel['variants']['orientation'];
+    items?: T[];
+    /**
+     * Enable Autoplay plugin
+     * @link https://www.embla-carousel.com/plugins/autoplay/
+     */
+    autoplay?: boolean | AutoplayOptionsType;
+    /**
+     * Enable Auto Scroll plugin
+     * @link https://www.embla-carousel.com/plugins/auto-scroll/
+     */
+    autoScroll?: boolean | AutoScrollOptionsType;
+    /**
+     * Enable Auto Height plugin
+     * @link https://www.embla-carousel.com/plugins/auto-height/
+     */
+    autoHeight?: boolean | AutoHeightOptionsType;
+    /**
+     * Enable Class Names plugin
+     * @link https://www.embla-carousel.com/plugins/class-names/
+     */
+    classNames?: boolean | ClassNamesOptionsType;
+    /**
+     * Enable Fade plugin
+     * @link https://www.embla-carousel.com/plugins/fade/
+     */
+    fade?: boolean | FadeOptionsType;
+    /**
+     * Enable Wheel Gestures plugin
+     * @link https://www.embla-carousel.com/plugins/wheel-gestures/
+     */
+    wheelGestures?: boolean | WheelGesturesPluginOptions;
+    class?: any;
+    ui?: Carousel['slots'];
+}
+export type CarouselSlots<T extends CarouselItem = CarouselItem> = {
+    default(props: {
+        item: T;
+        index: number;
+    }): any;
+};
+export interface CarouselEmits {
+    /**
+     * Emitted when the selected slide changes
+     * @param selectedIndex The index of the selected slide
+     */
+    select: [selectedIndex: number];
+}
+declare const _default: <T extends CarouselItem>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onSelect?: ((selectedIndex: number) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onSelect"> & CarouselProps<T> & {}> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{
+        emblaRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        emblaApi: import("vue").Ref<EmblaCarouselType | undefined, EmblaCarouselType | undefined>;
+    }>): void;
+    attrs: any;
+    slots: CarouselSlots<T>;
+    emit: (evt: "select", selectedIndex: number) => void;
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T as K]: T[K];
+} & {};

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

@@ -0,0 +1,73 @@
+import type { CheckboxRootProps } from 'reka-ui';
+import type { AppConfig } from '@nuxt/schema';
+import theme from '#build/ui/checkbox';
+import type { ComponentConfig } from '../types/utils';
+type Checkbox = ComponentConfig<typeof theme, AppConfig, 'checkbox'>;
+export interface CheckboxProps extends Pick<CheckboxRootProps, 'disabled' | 'required' | 'name' | 'value' | 'id' | 'defaultValue'> {
+    /**
+     * The element or component this component should render as.
+     * @defaultValue 'div'
+     */
+    as?: any;
+    label?: string;
+    description?: string;
+    /**
+     * @defaultValue 'primary'
+     */
+    color?: Checkbox['variants']['color'];
+    /**
+     * @defaultValue 'list'
+     */
+    variant?: Checkbox['variants']['variant'];
+    /**
+     * @defaultValue 'md'
+     */
+    size?: Checkbox['variants']['size'];
+    /**
+     * Position of the indicator.
+     * @defaultValue 'start'
+     */
+    indicator?: Checkbox['variants']['indicator'];
+    /**
+     * The icon displayed when checked.
+     * @defaultValue appConfig.ui.icons.check
+     * @IconifyIcon
+     */
+    icon?: string;
+    /**
+     * The icon displayed when the checkbox is indeterminate.
+     * @defaultValue appConfig.ui.icons.minus
+     * @IconifyIcon
+     */
+    indeterminateIcon?: string;
+    class?: any;
+    ui?: Checkbox['slots'];
+}
+export type CheckboxEmits = {
+    change: [event: Event];
+};
+export interface CheckboxSlots {
+    label(props: {
+        label?: string;
+    }): any;
+    description(props: {
+        description?: string;
+    }): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<CheckboxProps & {
+    modelValue?: boolean | "indeterminate";
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (event: Event) => any;
+    "update:modelValue": (value: boolean | "indeterminate") => any;
+}, string, import("vue").PublicProps, Readonly<CheckboxProps & {
+    modelValue?: boolean | "indeterminate";
+}> & Readonly<{
+    onChange?: ((event: Event) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: boolean | "indeterminate") => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, CheckboxSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/CheckboxGroup.d.vue.ts

@@ -0,0 +1,84 @@
+import type { CheckboxGroupRootProps, CheckboxGroupRootEmits } from 'reka-ui';
+import type { AppConfig } from '@nuxt/schema';
+import theme from '#build/ui/checkbox-group';
+import type { CheckboxProps } from '../types';
+import type { AcceptableValue, ComponentConfig } from '../types/utils';
+type CheckboxGroup = ComponentConfig<typeof theme, AppConfig, 'checkboxGroup'>;
+export type CheckboxGroupValue = AcceptableValue;
+export type CheckboxGroupItem = {
+    label?: string;
+    description?: string;
+    disabled?: boolean;
+    value?: string;
+    class?: any;
+    ui?: Pick<CheckboxGroup['slots'], 'item'> & Omit<Required<CheckboxProps>['ui'], 'root'>;
+    [key: string]: any;
+} | CheckboxGroupValue;
+export interface CheckboxGroupProps<T extends CheckboxGroupItem = CheckboxGroupItem> extends Pick<CheckboxGroupRootProps, 'defaultValue' | 'disabled' | 'loop' | 'modelValue' | 'name' | 'required'>, Pick<CheckboxProps, 'color' | 'indicator' | 'icon'> {
+    /**
+     * The element or component this component should render as.
+     * @defaultValue 'div'
+     */
+    as?: any;
+    legend?: string;
+    /**
+     * When `items` is an array of objects, select the field to use as the value.
+     * @defaultValue 'value'
+     */
+    valueKey?: string;
+    /**
+     * When `items` is an array of objects, select the field to use as the label.
+     * @defaultValue 'label'
+     */
+    labelKey?: string;
+    /**
+     * When `items` is an array of objects, select the field to use as the description.
+     * @defaultValue 'description'
+     */
+    descriptionKey?: string;
+    items?: T[];
+    /**
+     * @defaultValue 'md'
+     */
+    size?: CheckboxGroup['variants']['size'];
+    /**
+     * @defaultValue 'list'
+     */
+    variant?: CheckboxGroup['variants']['variant'];
+    /**
+     * The orientation the checkbox buttons are laid out.
+     * @defaultValue 'vertical'
+     */
+    orientation?: CheckboxGroupRootProps['orientation'];
+    class?: any;
+    ui?: CheckboxGroup['slots'] & CheckboxProps['ui'];
+}
+export type CheckboxGroupEmits = CheckboxGroupRootEmits & {
+    change: [event: Event];
+};
+type SlotProps<T extends CheckboxGroupItem> = (props: {
+    item: T & {
+        id: string;
+    };
+}) => any;
+export interface CheckboxGroupSlots<T extends CheckboxGroupItem = CheckboxGroupItem> {
+    legend(props?: {}): any;
+    label: SlotProps<T>;
+    description: SlotProps<T>;
+}
+declare const _default: <T extends CheckboxGroupItem>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onChange?: ((event: Event) => any) | undefined;
+        readonly "onUpdate:modelValue"?: ((value: import("reka-ui").AcceptableValue[]) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onChange" | "onUpdate:modelValue"> & CheckboxGroupProps<T> & {}> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: CheckboxGroupSlots<T>;
+    emit: ((evt: "change", event: Event) => void) & ((evt: "update:modelValue", value: import("reka-ui").AcceptableValue[]) => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T as K]: T[K];
+} & {};

package/dist/runtime/components/Chip.d.vue.ts

@@ -0,0 +1,57 @@
+import type { AppConfig } from '@nuxt/schema';
+import theme from '#build/ui/chip';
+import type { ComponentConfig } from '../types/utils';
+type Chip = ComponentConfig<typeof theme, AppConfig, 'chip'>;
+export interface ChipProps {
+    /**
+     * The element or component this component should render as.
+     * @defaultValue 'div'
+     */
+    as?: any;
+    /** Display some text inside the chip. */
+    text?: string | number;
+    /**
+     * @defaultValue 'primary'
+     */
+    color?: Chip['variants']['color'];
+    /**
+     * @defaultValue 'md'
+     */
+    size?: Chip['variants']['size'];
+    /**
+     * The position of the chip.
+     * @defaultValue 'top-right'
+     */
+    position?: Chip['variants']['position'];
+    /** When `true`, keep the chip inside the component for rounded elements. */
+    inset?: boolean;
+    /** When `true`, render the chip relatively to the parent. */
+    standalone?: boolean;
+    class?: any;
+    ui?: Chip['slots'];
+}
+export interface ChipEmits {
+    'update:show': [value: boolean];
+}
+export interface ChipSlots {
+    default(props?: {}): any;
+    content(props?: {}): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<ChipProps & {
+    show?: boolean;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:show": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<ChipProps & {
+    show?: boolean;
+}> & Readonly<{
+    "onUpdate:show"?: ((value: boolean) => any) | undefined;
+}>, {
+    inset: boolean;
+    standalone: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ChipSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/Collapsible.d.vue.ts

@@ -0,0 +1,35 @@
+import type { CollapsibleRootProps, CollapsibleRootEmits } from 'reka-ui';
+import type { AppConfig } from '@nuxt/schema';
+import theme from '#build/ui/collapsible';
+import type { ComponentConfig } from '../types/utils';
+type Collapsible = ComponentConfig<typeof theme, AppConfig, 'collapsible'>;
+export interface CollapsibleProps extends Pick<CollapsibleRootProps, 'defaultOpen' | 'open' | 'disabled' | 'unmountOnHide'> {
+    /**
+     * The element or component this component should render as.
+     * @defaultValue 'div'
+     */
+    as?: any;
+    class?: any;
+    ui?: Collapsible['slots'];
+}
+export interface CollapsibleEmits extends CollapsibleRootEmits {
+}
+export interface CollapsibleSlots {
+    default(props: {
+        open: boolean;
+    }): any;
+    content(props?: {}): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<CollapsibleProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<CollapsibleProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {
+    unmountOnHide: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, CollapsibleSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,48 @@
+import type { AppConfig } from '@nuxt/schema';
+import theme from '#build/ui/color-picker';
+import type { ComponentConfig } from '../types/utils';
+type ColorPicker = ComponentConfig<typeof theme, AppConfig, 'colorPicker'>;
+export type ColorPickerProps = {
+    /**
+     * The element or component this component should render as.
+     * @defaultValue 'div'
+     */
+    as?: any;
+    /**
+     * Throttle time in ms for the color picker
+     */
+    throttle?: number;
+    /**
+     * Disable the color picker
+     */
+    disabled?: boolean;
+    /**
+     * The default value of the color picker
+     */
+    defaultValue?: string;
+    /**
+     * Format of the color
+     * @defaultValue 'hex'
+     */
+    format?: 'hex' | 'rgb' | 'hsl' | 'cmyk' | 'lab';
+    /**
+     * @defaultValue 'md'
+     */
+    size?: ColorPicker['variants']['size'];
+    class?: any;
+    ui?: ColorPicker['slots'];
+};
+declare const _default: import("vue").DefineComponent<ColorPickerProps & {
+    modelValue?: string;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<ColorPickerProps & {
+    modelValue?: string;
+}> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | undefined) => any) | undefined;
+}>, {
+    format: "hex" | "rgb" | "hsl" | "cmyk" | "lab";
+    defaultValue: string;
+    throttle: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;