@n8n/design-system 2.35.2 → 2.36.0

package/dist/useIconBodyLoader-TKQVcLVc.js

@@ -0,0 +1,8 @@
+import { inject as e } from "vue";
+//#region src/composables/useIconBodyLoader.ts
+var t = Symbol("IconBodyLoader"), n = async () => null;
+function r() {
+	return e(t, n);
+}
+//#endregion
+export { r as n, t };

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

@@ -0,0 +1,67 @@
+import { ComboboxContentProps, ComboboxRootEmits, ComboboxRootProps } from './reka-ui';
+import { IconName } from '../../../components/N8nIcon/icons';
+import { InputSize } from '../../../components/N8nInput/Input.types';
+export type ComboboxValue = string;
+export type ComboboxOptionBase<TValue extends ComboboxValue = ComboboxValue> = {
+    type?: 'item';
+    value: TValue;
+    label: string;
+    icon?: IconName;
+    disabled?: boolean;
+    textValue?: string;
+    keywords?: string[];
+    onSelect?: (event: Event) => void;
+};
+export type ComboboxGroupItem<TValue extends ComboboxValue = ComboboxValue> = {
+    type: 'group';
+    label?: string;
+    items: Array<ComboboxOptionBase<TValue>>;
+};
+export type ComboboxSeparatorItem = {
+    type: 'separator';
+};
+export type ComboboxStructuralItem<TValue extends ComboboxValue = ComboboxValue> = ComboboxGroupItem<TValue> | ComboboxSeparatorItem;
+export type ComboboxItem<TValue extends ComboboxValue = ComboboxValue> = ComboboxOptionBase<TValue> | ComboboxStructuralItem<TValue>;
+export type ComboboxProps = Omit<ComboboxRootProps<ComboboxValue>, 'dir' | 'openOnFocus'> & Pick<ComboboxContentProps, 'side' | 'sideOffset' | 'align'> & {
+    size?: ComboboxSizes;
+    icon?: IconName;
+    placeholder?: string;
+    autoFocus?: boolean;
+    emptyText?: string;
+    items?: ComboboxItem[];
+    contentClass?: string;
+    id?: string;
+    clearable?: boolean;
+    teleported?: boolean;
+    portalTarget?: string | HTMLElement;
+};
+export type ComboboxEmits = ComboboxRootEmits<ComboboxValue | ComboboxValue[] | undefined>;
+export type ComboboxSizes = InputSize;
+type ComboboxItemUi = {
+    class: string;
+};
+type SlotProps = (props: {
+    item: ComboboxOptionBase;
+    ui: ComboboxItemUi;
+}) => unknown;
+export type ComboboxItemSlots = {
+    ['item-leading']?: SlotProps;
+    ['item-label']?: (props: {
+        item: ComboboxOptionBase;
+    }) => unknown;
+    ['item-trailing']?: SlotProps;
+};
+export type ComboboxSlots = {
+    item?: (props: {
+        item: ComboboxOptionBase;
+    }) => unknown;
+    label?: (props: {
+        item: ComboboxGroupItem;
+    }) => unknown;
+    ['item-leading']?: SlotProps;
+    ['item-label']?: (props: {
+        item: ComboboxOptionBase;
+    }) => unknown;
+    ['item-trailing']?: SlotProps;
+};
+export {};

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

@@ -0,0 +1,304 @@
+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, {
+    anchorRef: Readonly<import('vue').ShallowRef<({
+        $: 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>>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    highlight: (payload: {
+        ref: HTMLElement;
+        value: string | string[] | undefined;
+    } | undefined) => any;
+    "update:modelValue": (value: string | string[] | undefined) => any;
+    "update:open": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<ComboboxProps> & Readonly<{
+    onHighlight?: ((payload: {
+        ref: HTMLElement;
+        value: string | string[] | undefined;
+    } | undefined) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string | string[] | undefined) => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {
+    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"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,17 @@
+import { ComboboxItemSlots, ComboboxOptionBase } from './Combobox.types';
+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"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,3 @@
+export { default as N8nCombobox2 } from './Combobox.vue';
+export { default as N8nCombobox2Item } from './ComboboxItem.vue';
+export type { ComboboxEmits, ComboboxGroupItem, ComboboxItem, ComboboxItemSlots, ComboboxOptionBase, ComboboxProps, ComboboxSeparatorItem, ComboboxSizes, ComboboxSlots, ComboboxStructuralItem, ComboboxValue, } from './Combobox.types';

package/dist/v2/components/Combobox/reka-ui.d.ts

@@ -0,0 +1,2 @@
+export { ComboboxAnchor, ComboboxContent, ComboboxEmpty, ComboboxGroup, ComboboxInput, ComboboxItem, ComboboxItemIndicator, ComboboxLabel, ComboboxPortal, ComboboxRoot, ComboboxTrigger, ComboboxViewport, useForwardPropsEmits, } from 'reka-ui';
+export type { ComboboxContentProps, ComboboxItemProps, ComboboxRootEmits, ComboboxRootProps, } from 'reka-ui';

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

@@ -1,10 +1,14 @@
-import { AcceptableInputValue, TagsInputInputProps, TagsInputRootEmits, TagsInputRootProps } from './reka-ui';
+import { AcceptableInputValue, TagsInputRootEmits, TagsInputRootProps } from './reka-ui';
 import { InputSize } from '../../../components/N8nInput/Input.types';
 export type TagsInputValue = AcceptableInputValue;
 export type TagsInputSizes = InputSize;
-export type TagsInputProps = TagsInputRootProps<TagsInputValue> & Pick<TagsInputInputProps, 'placeholder' | 'autoFocus'> & {
+export interface TagsInputOwnProps {
     size?: TagsInputSizes;
-};
+    embedded?: boolean;
+    placeholder?: string;
+    autoFocus?: boolean;
+}
+export type TagsInputProps = TagsInputRootProps<TagsInputValue> & TagsInputOwnProps;
 export type TagsInputEmits = TagsInputRootEmits<TagsInputValue>;
 export type TagsInputTagUi = {
     text: string;

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

@@ -1,4 +1,6 @@
-import { TagsInputProps, TagsInputSizes, TagsInputSlots } from './TagsInput.types';
+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;
@@ -8,12 +10,12 @@ declare function __VLS_template(): {
     rootEl: any;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<TagsInputProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+declare const __VLS_component: 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;
     removeTag: (payload: import('reka-ui').AcceptableInputValue) => any;
-}, string, import('vue').PublicProps, Readonly<TagsInputProps> & Readonly<{
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onUpdate:modelValue"?: ((payload: import('reka-ui').AcceptableInputValue[]) => any) | undefined;
     onInvalid?: ((payload: import('reka-ui').AcceptableInputValue) => any) | undefined;
     onAddTag?: ((payload: import('reka-ui').AcceptableInputValue) => any) | undefined;
@@ -22,6 +24,7 @@ declare const __VLS_component: import('vue').DefineComponent<TagsInputProps, {},
     disabled: boolean;
     size: TagsInputSizes;
     placeholder: string;
+    embedded: boolean;
     delimiter: string | RegExp;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     root: HTMLDivElement;

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@n8n/design-system",
-  "version": "2.35.2",
+  "version": "2.36.0",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -14,6 +14,10 @@
       "types": "./dist/icons/lucide/index.d.ts",
       "import": "./dist/icons/lucide/index.js"
     },
+    "./plugin": {
+      "types": "./dist/plugin.d.ts",
+      "import": "./dist/plugin.js"
+    },
     "./style.css": "./dist/style.css",
     "./theme.css": "./dist/theme.css",
     "./css/*": "./dist/css/*",
@@ -63,9 +67,9 @@
     "sanitize-html": "2.17.5",
     "vue-boring-avatars": "^1.3.0",
     "xss": "1.0.15",
-    "@n8n/utils": "1.44.0",
-    "@n8n/composables": "1.26.2",
-    "@n8n/frontend-utils": "0.4.0"
+    "@n8n/composables": "1.27.0",
+    "@n8n/frontend-utils": "0.4.0",
+    "@n8n/utils": "1.45.0"
   },
   "peerDependencies": {
     "vue": "^3.5.13",

package/dist/components/N8nRadioButtons/RadioButtons.types.d.ts

@@ -1,13 +0,0 @@
-export interface RadioOption<Value extends string | boolean = string | boolean> {
-    label: string;
-    value: Value;
-    disabled?: boolean;
-    data?: Record<string, string | number | boolean | undefined>;
-}
-export interface RadioButtonsProps<Value extends string | boolean = string | boolean> {
-    modelValue?: Value;
-    options?: Array<RadioOption<Value>>;
-    size?: 'small' | 'small-medium' | 'medium';
-    disabled?: boolean;
-    squareButtons?: boolean;
-}