@n8n/design-system 2.38.2 → 2.39.0

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

@@ -1,25 +1,21 @@
 import { CheckboxProps, CheckboxSlots } from './Checkbox.types';
 type __VLS_Props = CheckboxProps;
-type __VLS_PublicProps = {
+type __VLS_Slots = CheckboxSlots;
+type __VLS_ModelProps = {
     modelValue?: boolean;
-} & __VLS_Props;
-declare function __VLS_template(): {
-    attrs: Partial<{}>;
-    slots: Readonly<CheckboxSlots> & CheckboxSlots;
-    refs: {};
-    rootEl: any;
 };
-type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_base: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     "update:modelValue": (value: boolean) => any;
     change: (event: Event) => any;
 }, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
     "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
     onChange?: ((event: Event) => any) | undefined;
 }>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
 export default _default;
-type __VLS_WithTemplateSlots<T, S> = T & {
+type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;
     };

package/dist/v2/components/Combobox/Combobox.vue.d.ts

@@ -1,122 +1,7 @@
 import { nextTick } from 'vue';
 import { ComboboxProps, ComboboxSizes, ComboboxSlots } from './Combobox.types';
-declare function __VLS_template(): {
-    attrs: Partial<{}>;
-    slots: Readonly<ComboboxSlots> & ComboboxSlots;
-    refs: {
-        anchor: ({
-            $: import('vue').ComponentInternalInstance;
-            $data: {};
-            $props: {
-                readonly reference?: import('reka-ui').ReferenceElement | undefined;
-                readonly asChild?: boolean | undefined;
-                readonly as?: (import('reka-ui').AsTag | import('vue').Component) | undefined;
-            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
-            $attrs: {
-                [x: string]: unknown;
-            };
-            $refs: {
-                [x: string]: unknown;
-            };
-            $slots: Readonly<{
-                [name: string]: import('vue').Slot<any> | undefined;
-            }>;
-            $root: import('vue').ComponentPublicInstance | null;
-            $parent: import('vue').ComponentPublicInstance | null;
-            $host: Element | null;
-            $emit: (event: string, ...args: any[]) => void;
-            $el: any;
-            $options: import('vue').ComponentOptionsBase<Readonly<import('reka-ui').ComboboxAnchorProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
-                beforeCreate?: (() => void) | (() => void)[];
-                created?: (() => void) | (() => void)[];
-                beforeMount?: (() => void) | (() => void)[];
-                mounted?: (() => void) | (() => void)[];
-                beforeUpdate?: (() => void) | (() => void)[];
-                updated?: (() => void) | (() => void)[];
-                activated?: (() => void) | (() => void)[];
-                deactivated?: (() => void) | (() => void)[];
-                beforeDestroy?: (() => void) | (() => void)[];
-                beforeUnmount?: (() => void) | (() => void)[];
-                destroyed?: (() => void) | (() => void)[];
-                unmounted?: (() => void) | (() => void)[];
-                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
-                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
-                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
-            };
-            $forceUpdate: () => void;
-            $nextTick: typeof nextTick;
-            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
-        } & Readonly<{}> & Omit<Readonly<import('reka-ui').ComboboxAnchorProps> & Readonly<{}>, never> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
-            $slots: {
-                default?: (props: {}) => any;
-            };
-        }) | null;
-        input: ({
-            $: import('vue').ComponentInternalInstance;
-            $data: {};
-            $props: {
-                readonly displayValue?: ((val: any) => string) | undefined;
-                readonly modelValue?: string | undefined;
-                readonly autoFocus?: boolean | undefined;
-                readonly disabled?: boolean | undefined;
-                readonly asChild?: boolean | undefined;
-                readonly as?: (import('reka-ui').AsTag | import('vue').Component) | undefined;
-                readonly "onUpdate:modelValue"?: ((args_0: string) => any) | undefined | undefined;
-            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
-            $attrs: {
-                [x: string]: unknown;
-            };
-            $refs: {
-                [x: string]: unknown;
-            };
-            $slots: Readonly<{
-                [name: string]: import('vue').Slot<any> | undefined;
-            }>;
-            $root: import('vue').ComponentPublicInstance | null;
-            $parent: import('vue').ComponentPublicInstance | null;
-            $host: Element | null;
-            $emit: (event: "update:modelValue", args_0: string) => void;
-            $el: any;
-            $options: import('vue').ComponentOptionsBase<Readonly<import('reka-ui').ComboboxInputProps> & Readonly<{
-                "onUpdate:modelValue"?: ((args_0: string) => any) | undefined;
-            }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-                "update:modelValue": (args_0: string) => any;
-            }, string, {
-                as: import('reka-ui').AsTag | import('vue').Component;
-            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
-                beforeCreate?: (() => void) | (() => void)[];
-                created?: (() => void) | (() => void)[];
-                beforeMount?: (() => void) | (() => void)[];
-                mounted?: (() => void) | (() => void)[];
-                beforeUpdate?: (() => void) | (() => void)[];
-                updated?: (() => void) | (() => void)[];
-                activated?: (() => void) | (() => void)[];
-                deactivated?: (() => void) | (() => void)[];
-                beforeDestroy?: (() => void) | (() => void)[];
-                beforeUnmount?: (() => void) | (() => void)[];
-                destroyed?: (() => void) | (() => void)[];
-                unmounted?: (() => void) | (() => void)[];
-                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
-                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
-                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
-            };
-            $forceUpdate: () => void;
-            $nextTick: typeof nextTick;
-            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
-        } & Readonly<{
-            as: import('reka-ui').AsTag | import('vue').Component;
-        }> & Omit<Readonly<import('reka-ui').ComboboxInputProps> & Readonly<{
-            "onUpdate:modelValue"?: ((args_0: string) => any) | undefined;
-        }>, "as"> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
-            $slots: {
-                default?: (props: {}) => any;
-            };
-        }) | null;
-    };
-    rootEl: any;
-};
-type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<ComboboxProps, {
+type __VLS_Slots = ComboboxSlots;
+declare const __VLS_base: import('vue').DefineComponent<ComboboxProps, {
     anchorRef: Readonly<import('vue').ShallowRef<({
         $: import('vue').ComponentInternalInstance;
         $data: {};
@@ -182,122 +67,14 @@ declare const __VLS_component: import('vue').DefineComponent<ComboboxProps, {
     teleported: boolean;
     size: ComboboxSizes;
     clearable: boolean;
-    align: "center" | "start" | "end";
     side: "right" | "left" | "top" | "bottom";
     sideOffset: number;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
-    anchor: ({
-        $: import('vue').ComponentInternalInstance;
-        $data: {};
-        $props: {
-            readonly reference?: import('reka-ui').ReferenceElement | undefined;
-            readonly asChild?: boolean | undefined;
-            readonly as?: (import('reka-ui').AsTag | import('vue').Component) | undefined;
-        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
-        $attrs: {
-            [x: string]: unknown;
-        };
-        $refs: {
-            [x: string]: unknown;
-        };
-        $slots: Readonly<{
-            [name: string]: import('vue').Slot<any> | undefined;
-        }>;
-        $root: import('vue').ComponentPublicInstance | null;
-        $parent: import('vue').ComponentPublicInstance | null;
-        $host: Element | null;
-        $emit: (event: string, ...args: any[]) => void;
-        $el: any;
-        $options: import('vue').ComponentOptionsBase<Readonly<import('reka-ui').ComboboxAnchorProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
-            beforeCreate?: (() => void) | (() => void)[];
-            created?: (() => void) | (() => void)[];
-            beforeMount?: (() => void) | (() => void)[];
-            mounted?: (() => void) | (() => void)[];
-            beforeUpdate?: (() => void) | (() => void)[];
-            updated?: (() => void) | (() => void)[];
-            activated?: (() => void) | (() => void)[];
-            deactivated?: (() => void) | (() => void)[];
-            beforeDestroy?: (() => void) | (() => void)[];
-            beforeUnmount?: (() => void) | (() => void)[];
-            destroyed?: (() => void) | (() => void)[];
-            unmounted?: (() => void) | (() => void)[];
-            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
-            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
-            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
-        };
-        $forceUpdate: () => void;
-        $nextTick: typeof nextTick;
-        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
-    } & Readonly<{}> & Omit<Readonly<import('reka-ui').ComboboxAnchorProps> & Readonly<{}>, never> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
-        $slots: {
-            default?: (props: {}) => any;
-        };
-    }) | null;
-    input: ({
-        $: import('vue').ComponentInternalInstance;
-        $data: {};
-        $props: {
-            readonly displayValue?: ((val: any) => string) | undefined;
-            readonly modelValue?: string | undefined;
-            readonly autoFocus?: boolean | undefined;
-            readonly disabled?: boolean | undefined;
-            readonly asChild?: boolean | undefined;
-            readonly as?: (import('reka-ui').AsTag | import('vue').Component) | undefined;
-            readonly "onUpdate:modelValue"?: ((args_0: string) => any) | undefined | undefined;
-        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
-        $attrs: {
-            [x: string]: unknown;
-        };
-        $refs: {
-            [x: string]: unknown;
-        };
-        $slots: Readonly<{
-            [name: string]: import('vue').Slot<any> | undefined;
-        }>;
-        $root: import('vue').ComponentPublicInstance | null;
-        $parent: import('vue').ComponentPublicInstance | null;
-        $host: Element | null;
-        $emit: (event: "update:modelValue", args_0: string) => void;
-        $el: any;
-        $options: import('vue').ComponentOptionsBase<Readonly<import('reka-ui').ComboboxInputProps> & Readonly<{
-            "onUpdate:modelValue"?: ((args_0: string) => any) | undefined;
-        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-            "update:modelValue": (args_0: string) => any;
-        }, string, {
-            as: import('reka-ui').AsTag | import('vue').Component;
-        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
-            beforeCreate?: (() => void) | (() => void)[];
-            created?: (() => void) | (() => void)[];
-            beforeMount?: (() => void) | (() => void)[];
-            mounted?: (() => void) | (() => void)[];
-            beforeUpdate?: (() => void) | (() => void)[];
-            updated?: (() => void) | (() => void)[];
-            activated?: (() => void) | (() => void)[];
-            deactivated?: (() => void) | (() => void)[];
-            beforeDestroy?: (() => void) | (() => void)[];
-            beforeUnmount?: (() => void) | (() => void)[];
-            destroyed?: (() => void) | (() => void)[];
-            unmounted?: (() => void) | (() => void)[];
-            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
-            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
-            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
-        };
-        $forceUpdate: () => void;
-        $nextTick: typeof nextTick;
-        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
-    } & Readonly<{
-        as: import('reka-ui').AsTag | import('vue').Component;
-    }> & Omit<Readonly<import('reka-ui').ComboboxInputProps> & Readonly<{
-        "onUpdate:modelValue"?: ((args_0: string) => any) | undefined;
-    }>, "as"> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
-        $slots: {
-            default?: (props: {}) => any;
-        };
-    }) | null;
-}, any>;
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+    align: "center" | "start" | "end";
+}, {}, {}, {}, 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_WithTemplateSlots<T, S> = T & {
+type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;
     };

package/dist/v2/components/Combobox/ComboboxItem.vue.d.ts

@@ -1,16 +1,11 @@
 import { ComboboxItemSlots, ComboboxOptionBase } from './Combobox.types';
+type __VLS_Slots = ComboboxItemSlots;
 type __VLS_Props = ComboboxOptionBase;
-declare function __VLS_template(): {
-    attrs: Partial<{}>;
-    slots: Readonly<ComboboxItemSlots> & ComboboxItemSlots;
-    refs: {};
-    rootEl: any;
-};
-type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & 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_WithTemplateSlots<T, S> = T & {
+type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;
     };

package/dist/v2/components/Loading/Loading.vue.d.ts

@@ -1,5 +1,5 @@
 import { LoadingProps } from './Loading.types';
-declare const _default: import('vue').DefineComponent<LoadingProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<LoadingProps> & Readonly<{}>, {
+declare const __VLS_export: import('vue').DefineComponent<LoadingProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<LoadingProps> & Readonly<{}>, {
     variant: import('./Loading.types').SkeletonVariant;
     loading: boolean;
     rows: number;
@@ -7,4 +7,5 @@ declare const _default: import('vue').DefineComponent<LoadingProps, {}, {}, {},
     cols: number;
     shrinkLast: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
 export default _default;

package/dist/v2/components/Select/Select.types.d.ts

@@ -1,67 +1,73 @@
 import { SelectRootEmits, SelectRootProps } from 'reka-ui';
 import { IconName } from '../../../components/N8nIcon/icons';
-import { AcceptableValue, GetItemKeys, GetModelValue, GetModelValueEmits } from '../../utils/types';
-type VueCssClass = undefined | string | Record<string, boolean> | Array<string | VueCssClass>;
-export type SelectItemBaseProps = {
-    label?: string;
-    type?: 'label' | 'separator' | 'item';
-    value?: SelectValue;
-    disabled?: boolean;
-    onSelect?: (e: Event) => void;
+export type SelectValue = string | number;
+export type SelectOptionBase<TValue extends SelectValue = SelectValue> = {
+    type?: 'item';
+    value: TValue;
+    label: string;
     icon?: IconName;
-    class?: VueCssClass;
-    strokeWidth?: number;
+    disabled?: boolean;
+    textValue?: string;
+    onSelect?: (event: Event) => void;
+};
+export type SelectGroupItem<TValue extends SelectValue = SelectValue> = {
+    type: 'group';
+    label?: string;
+    items: Array<SelectOptionBase<TValue>>;
 };
-export type SelectItemProps = SelectItemBaseProps & {
-    [key: string]: unknown;
+export type SelectSeparatorItem = {
+    type: 'separator';
 };
-export type SelectValue = AcceptableValue;
-export type SelectItem = SelectValue | SelectItemProps;
-export type SelectVariants = 'default' | 'ghost';
-export type SelectSizes = 'xsmall' | 'small' | 'medium';
-export type SelectProps<T extends SelectItem[] = SelectItem[], VK extends GetItemKeys<T> = 'value', M extends boolean = false> = Omit<SelectRootProps<T>, 'dir' | 'multiple' | 'modelValue' | 'defaultValue' | 'by'> & {
+export type SelectStructuralItem<TValue extends SelectValue = SelectValue> = SelectGroupItem<TValue> | SelectSeparatorItem;
+export type SelectItem<TValue extends SelectValue = SelectValue> = SelectOptionBase<TValue> | SelectStructuralItem<TValue>;
+export type SelectVariants = 'default' | 'ghost' | 'flush';
+export type SelectSizes = 'mini' | 'small' | 'medium' | 'large' | 'xlarge';
+export type SelectModelValue<M extends boolean = false> = M extends true ? SelectValue[] : SelectValue;
+export type SelectProps<M extends boolean = false> = Omit<SelectRootProps, 'multiple' | 'modelValue' | 'defaultValue' | 'by' | 'side' | 'align' | 'position'> & {
     id?: string;
     placeholder?: string;
     size?: SelectSizes;
-    valueKey?: VK;
-    labelKey?: GetItemKeys<T>;
-    items?: T;
-    defaultValue?: GetModelValue<T, VK, M>;
-    modelValue?: GetModelValue<T, VK, M>;
+    items?: SelectItem[];
+    defaultValue?: SelectModelValue<M>;
+    modelValue?: SelectModelValue<M>;
     multiple?: M & boolean;
     variant?: SelectVariants;
     icon?: IconName;
-    position?: 'item-aligned' | 'popper';
-    side?: 'top' | 'right' | 'bottom' | 'left';
+    clearable?: boolean;
     sideOffset?: number;
     contentClass?: string;
 };
-export type SelectEmits<A extends SelectItem[], VK extends GetItemKeys<A> | undefined, M extends boolean> = Omit<SelectRootEmits, 'update:modelValue'> & GetModelValueEmits<A, VK, M>;
+export type SelectEmits<M extends boolean = false> = Omit<SelectRootEmits, 'update:modelValue'> & {
+    'update:modelValue': [value: SelectModelValue<M> | undefined];
+    clear: [];
+};
+export type SelectItemUi = {
+    class: string;
+    strokeWidth?: number;
+};
 export type SelectItemSlotProps = (props: {
-    item: SelectItemBaseProps;
-    ui: Record<string, unknown>;
+    item: SelectOptionBase;
+    ui: SelectItemUi;
 }) => unknown;
-type SlotProps = (props: {
-    item: SelectItemProps;
-    ui: Record<string, unknown>;
-}) => unknown;
-export type SelectSlots<A extends SelectItem[] = SelectItem[], VK extends GetItemKeys<A> | undefined = undefined, M extends boolean = false> = {
-    default(props: {
-        modelValue?: GetModelValue<A, VK, M>;
+export type SelectItemSlots = {
+    'item-leading'?: SelectItemSlotProps;
+    'item-label'?: (props: {
+        item: SelectOptionBase;
+    }) => unknown;
+    'item-trailing'?: SelectItemSlotProps;
+};
+export type SelectSlots<M extends boolean = false> = SelectItemSlots & {
+    default?: (props: {
+        modelValue?: SelectModelValue<M>;
         open: boolean;
-    }): unknown;
-    item: (props: {
-        item: SelectItemProps;
     }) => unknown;
-    label: (props: {
-        item: SelectItemProps;
+    item?: (props: {
+        item: SelectOptionBase;
     }) => unknown;
-    ['item-leading']: SlotProps;
-    ['item-label']: (props: {
-        item: SelectItemProps;
+    label?: (props: {
+        item: SelectGroupItem;
     }) => unknown;
-    ['item-trailing']: SlotProps;
     header?: () => unknown;
     footer?: () => unknown;
+    empty?: () => unknown;
 };
-export {};

package/dist/v2/components/Select/Select.vue.d.ts

@@ -1,11 +1,13 @@
-import { SelectItem, SelectProps, SelectSlots } from './Select.types';
-import { GetItemKeys, GetModelValue } from '../../utils/types';
-declare const _default: <T extends Array<SelectItem>, VK extends GetItemKeys<T> = "value", M extends boolean = false>(__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"?: ((value: GetModelValue<T, VK, M>) => any) | undefined;
-        readonly "onUpdate:open"?: ((value: boolean) => any) | undefined;
-    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:modelValue" | "onUpdate:open"> & SelectProps<T, VK, M> & Partial<{}>> & import('vue').PublicProps;
-    expose(exposed: import('vue').ShallowUnwrapRef<{
+import { SelectModelValue, SelectProps, SelectSlots } from './Select.types';
+declare const __VLS_export: <M extends boolean = false>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<SelectProps<M> & {
+        "onUpdate:modelValue"?: ((value: SelectModelValue<M> | undefined) => any) | undefined;
+        "onUpdate:open"?: ((value: boolean) => any) | undefined;
+        onClear?: (() => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import('vue').ShallowUnwrapRef<{
         triggerRef: Readonly<import('vue').ShallowRef<({
             $: import('vue').ComponentInternalInstance;
             $data: {};
@@ -50,7 +52,7 @@ declare const _default: <T extends Array<SelectItem>, VK extends GetItemKeys<T>
             };
             $forceUpdate: () => void;
             $nextTick: typeof import('vue').nextTick;
-            $watch<T_1 extends string | ((...args: any) => any)>(source: T_1, cb: T_1 extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
         } & Readonly<{
             as: import('reka-ui').AsTag | import('vue').Component;
         }> & Omit<Readonly<import('reka-ui').SelectTriggerProps> & Readonly<{}>, "as"> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
@@ -58,14 +60,17 @@ declare const _default: <T extends Array<SelectItem>, VK extends GetItemKeys<T>
                 default?: (props: {}) => any;
             };
         }) | null>>;
-    }>): void;
+    }>) => void;
     attrs: any;
-    slots: Readonly<SelectSlots<T, VK, M>> & SelectSlots<T, VK, M>;
-    emit: ((evt: "update:modelValue", value: GetModelValue<T, VK, M>) => void) & ((evt: "update:open", value: boolean) => void);
+    slots: SelectSlots<M>;
+    emit: ((evt: "update:modelValue", value: SelectModelValue<M> | undefined) => void) & ((evt: "update:open", value: boolean) => void) & ((evt: "clear") => void);
 }>) => import('vue').VNode & {
-    __ctx?: Awaited<typeof __VLS_setup>;
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };
+declare const _default: typeof __VLS_export;
 export default _default;
-type __VLS_PrettifyLocal<T> = {
+type __VLS_PrettifyLocal<T> = (T extends any ? {
     [K in keyof T]: T[K];
-} & {};
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/v2/components/Select/SelectItem.vue.d.ts

@@ -1,27 +1,14 @@
-import { SelectItemBaseProps, SelectItemSlotProps } from './Select.types';
-declare function __VLS_template(): {
-    attrs: Partial<{}>;
-    slots: Readonly<{
-        'item-leading'?: SelectItemSlotProps;
-        'item-label'?: (props: {
-            item: SelectItemBaseProps;
-        }) => unknown;
-        'item-trailing'?: SelectItemSlotProps;
-    }> & {
-        'item-leading'?: SelectItemSlotProps;
-        'item-label'?: (props: {
-            item: SelectItemBaseProps;
-        }) => unknown;
-        'item-trailing'?: SelectItemSlotProps;
-    };
-    refs: {};
-    rootEl: any;
+import { SelectItemSlots, SelectOptionBase } from './Select.types';
+type SelectItemComponentProps = SelectOptionBase & {
+    class?: string | Record<string, boolean> | Array<string | Record<string, boolean>>;
+    strokeWidth?: number;
 };
-type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<SelectItemBaseProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SelectItemBaseProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+type __VLS_Slots = SelectItemSlots;
+declare const __VLS_base: import('vue').DefineComponent<SelectItemComponentProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SelectItemComponentProps> & 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_WithTemplateSlots<T, S> = T & {
+type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;
     };

package/dist/v2/components/Select/index.d.ts

@@ -0,0 +1,3 @@
+export { default as N8nSelect2 } from './Select.vue';
+export { default as N8nSelect2Item } from './SelectItem.vue';
+export type * from './Select.types';

package/dist/v2/components/TagsInput/TagsInput.vue.d.ts

@@ -1,16 +1,8 @@
 import { TagsInputRootProps } from './reka-ui';
 import { TagsInputOwnProps, TagsInputSizes, TagsInputSlots, TagsInputValue } from './TagsInput.types';
 type __VLS_Props = TagsInputOwnProps & TagsInputRootProps<TagsInputValue>;
-declare function __VLS_template(): {
-    attrs: Partial<{}>;
-    slots: Readonly<TagsInputSlots> & TagsInputSlots;
-    refs: {
-        root: HTMLDivElement;
-    };
-    rootEl: any;
-};
-type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+type __VLS_Slots = TagsInputSlots;
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     "update:modelValue": (payload: import('reka-ui').AcceptableInputValue[]) => any;
     invalid: (payload: import('reka-ui').AcceptableInputValue) => any;
     addTag: (payload: import('reka-ui').AcceptableInputValue) => any;
@@ -26,12 +18,11 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}
     placeholder: string;
     embedded: boolean;
     delimiter: string | RegExp;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
-    root: HTMLDivElement;
-}, any>;
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+}, {}, {}, {}, 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_WithTemplateSlots<T, S> = T & {
+type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;
     };

package/dist/v2/components/Tree/Tree.vue.d.ts

@@ -1,12 +1,6 @@
 import { TreeProps, TreeSlots } from './Tree.types';
-declare function __VLS_template(): {
-    attrs: Partial<{}>;
-    slots: Readonly<TreeSlots> & TreeSlots;
-    refs: {};
-    rootEl: any;
-};
-type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<TreeProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+type __VLS_Slots = TreeSlots;
+declare const __VLS_base: import('vue').DefineComponent<TreeProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     "update:modelValue": (value: string[]) => any;
     "update:expanded": (val: string[]) => any;
 }, string, import('vue').PublicProps, Readonly<TreeProps> & Readonly<{
@@ -19,9 +13,10 @@ declare const __VLS_component: import('vue').DefineComponent<TreeProps, {}, {},
     virtualized: boolean;
     estimateSize: number;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
 export default _default;
-type __VLS_WithTemplateSlots<T, S> = T & {
+type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;
     };