@n8n/design-system 2.33.4 → 2.34.0

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

@@ -0,0 +1,18 @@
+import { NumberFieldRootProps, NumberFieldRootEmits } from 'reka-ui';
+export type InputNumberSize = 'mini' | 'small' | 'medium' | 'large' | 'xlarge';
+export type InputNumberControlsPosition = 'both' | 'right';
+export type InputNumberProps = Omit<NumberFieldRootProps, 'formatOptions'> & {
+    size?: InputNumberSize;
+    precision?: number;
+    controls?: boolean;
+    controlsPosition?: InputNumberControlsPosition;
+    placeholder?: string;
+};
+export type InputNumberEmits = NumberFieldRootEmits & {
+    focus: [event: FocusEvent];
+    blur: [event: FocusEvent];
+};
+export type InputNumberSlots = {
+    increment: () => unknown;
+    decrement: () => unknown;
+};

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

@@ -0,0 +1,29 @@
+import { InputNumberProps, InputNumberSlots } from './InputNumber.types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<InputNumberSlots> & InputNumberSlots;
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<InputNumberProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    focus: (event: FocusEvent) => any;
+    "update:modelValue": (val: number) => any;
+    blur: (event: FocusEvent) => any;
+}, string, import('vue').PublicProps, Readonly<InputNumberProps> & Readonly<{
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((val: number) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+}>, {
+    size: import('./InputNumber.types').InputNumberSize;
+    step: number;
+    controls: boolean;
+    controlsPosition: import('./InputNumber.types').InputNumberControlsPosition;
+}, {}, {}, {}, 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/InputNumber/index.d.ts

@@ -0,0 +1,2 @@
+export { default as N8nInputNumber2 } from './InputNumber.vue';
+export type * from './InputNumber.types';

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

@@ -0,0 +1,10 @@
+export declare const SKELETON_VARIANTS: readonly ["custom", "p", "text", "h1", "h3", "caption", "button", "image", "circle", "rect"];
+export type SkeletonVariant = (typeof SKELETON_VARIANTS)[number];
+export interface LoadingProps {
+    animated?: boolean;
+    loading?: boolean;
+    rows?: number;
+    cols?: number;
+    shrinkLast?: boolean;
+    variant?: SkeletonVariant;
+}

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

@@ -0,0 +1,10 @@
+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<{}>, {
+    variant: import('./Loading.types').SkeletonVariant;
+    loading: boolean;
+    rows: number;
+    animated: boolean;
+    cols: number;
+    shrinkLast: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,3 @@
+export { default as N8nLoading } from './Loading.vue';
+export type { LoadingProps, SkeletonVariant } from './Loading.types';
+export { SKELETON_VARIANTS } from './Loading.types';

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

@@ -0,0 +1,49 @@
+import { PaginationRootEmits, PaginationRootProps } from 'reka-ui';
+import { IconName } from '../../../components/N8nIcon/icons';
+export type PaginationSizes = 'small' | 'medium';
+export type PaginationVariants = 'default' | 'ghost';
+export type PaginationProps = Omit<PaginationRootProps, 'dir' | 'asChild' | 'as' | 'itemsPerPage'> & {
+    currentPage?: number;
+    pageSize?: number;
+    pageCount?: number;
+    itemsPerPage?: number;
+    pagerCount?: number;
+    background?: boolean;
+    layout?: string;
+    pageSizes?: number[];
+    hideOnSinglePage?: boolean;
+    prevText?: string;
+    nextText?: string;
+    prevIcon?: IconName;
+    nextIcon?: IconName;
+    popperClass?: string;
+    teleported?: boolean;
+    defaultPageSize?: number;
+    defaultCurrentPage?: number;
+    size?: PaginationSizes;
+    variant?: PaginationVariants;
+    total?: number;
+};
+export type PaginationEmits = PaginationRootEmits & {
+    'update:currentPage': [value: number];
+    'update:pageSize': [value: number];
+    'size-change': [value: number];
+    'current-change': [value: number];
+    'prev-click': [value: number];
+    'next-click': [value: number];
+};
+export type PaginationSlots = {
+    default?: (props?: Record<string, never>) => unknown;
+    prev?: (props?: {
+        disabled?: boolean;
+    }) => unknown;
+    next?: (props?: {
+        disabled?: boolean;
+    }) => unknown;
+    first?: (props?: {
+        disabled?: boolean;
+    }) => unknown;
+    last?: (props?: {
+        disabled?: boolean;
+    }) => unknown;
+};

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

@@ -0,0 +1,45 @@
+import { PaginationProps, PaginationSlots, PaginationSizes, PaginationVariants } from './Pagination.types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<PaginationSlots> & PaginationSlots;
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<PaginationProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:currentPage": (value: number) => any;
+    "update:page": (value: number) => any;
+    "update:pageSize": (value: number) => any;
+    "size-change": (value: number) => any;
+    "current-change": (value: number) => any;
+    "prev-click": (value: number) => any;
+    "next-click": (value: number) => any;
+}, string, import('vue').PublicProps, Readonly<PaginationProps> & Readonly<{
+    "onUpdate:currentPage"?: ((value: number) => any) | undefined;
+    "onUpdate:page"?: ((value: number) => any) | undefined;
+    "onUpdate:pageSize"?: ((value: number) => any) | undefined;
+    "onSize-change"?: ((value: number) => any) | undefined;
+    "onCurrent-change"?: ((value: number) => any) | undefined;
+    "onPrev-click"?: ((value: number) => any) | undefined;
+    "onNext-click"?: ((value: number) => any) | undefined;
+}>, {
+    disabled: boolean;
+    size: PaginationSizes;
+    variant: PaginationVariants;
+    layout: string;
+    background: boolean;
+    pageSizes: number[];
+    prevIcon: import('../../..').IconName;
+    nextIcon: import('../../..').IconName;
+    hideOnSinglePage: boolean;
+    defaultPage: number;
+    siblingCount: number;
+    showEdges: boolean;
+}, {}, {}, {}, 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/RadioGroup/RadioGroup.types.d.ts

@@ -0,0 +1,12 @@
+import { RadioGroupRootProps } from './reka-ui';
+export type RadioGroupValue = string;
+export type RadioGroupProps = Omit<RadioGroupRootProps, 'modelValue' | 'defaultValue'> & {
+    modelValue?: RadioGroupValue;
+    defaultValue?: RadioGroupValue;
+};
+export type RadioGroupEmits = {
+    'update:modelValue': [value: RadioGroupValue];
+};
+export type RadioGroupSlots = {
+    default(): unknown;
+};

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

@@ -0,0 +1,27 @@
+import { RadioGroupProps, RadioGroupSlots } from './RadioGroup.types';
+type __VLS_Props = Omit<RadioGroupProps, 'modelValue'>;
+type __VLS_PublicProps = {
+    modelValue?: RadioGroupProps['modelValue'];
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<RadioGroupSlots> & RadioGroupSlots;
+    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, {
+    "update:modelValue": (value: string | undefined) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | undefined) => any) | undefined;
+}>, {
+    disabled: boolean;
+    orientation: "horizontal" | "vertical";
+}, {}, {}, {}, 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/RadioGroup/RadioGroupItem.types.d.ts

@@ -0,0 +1,13 @@
+import { RadioGroupValue } from './RadioGroup.types';
+import { RadioGroupItemProps as RekaRadioGroupItemProps } from './reka-ui';
+export type RadioGroupItemProps = Omit<RekaRadioGroupItemProps, 'value'> & {
+    value: RadioGroupValue;
+    label?: string;
+    description?: string;
+};
+export type RadioGroupItemSlots = {
+    label(props: {
+        label?: string;
+        description?: string;
+    }): unknown;
+};

package/dist/v2/components/RadioGroup/RadioGroupItem.vue.d.ts

@@ -0,0 +1,16 @@
+import { RadioGroupItemProps, RadioGroupItemSlots } from './RadioGroupItem.types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<RadioGroupItemSlots> & RadioGroupItemSlots;
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<RadioGroupItemProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<RadioGroupItemProps> & 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/RadioGroup/index.d.ts

@@ -0,0 +1,4 @@
+export { default as N8nRadioGroupItem } from './RadioGroupItem.vue';
+export { default as N8nRadioGroup } from './RadioGroup.vue';
+export type * from './RadioGroupItem.types';
+export type * from './RadioGroup.types';

package/dist/v2/components/RadioGroup/radio-group-context.d.ts

@@ -0,0 +1,3 @@
+import { InjectionKey, Ref } from 'vue';
+export declare const radioGroupArrowKeyPressedKey: InjectionKey<Ref<boolean>>;
+export declare const RADIO_GROUP_ARROW_KEYS: readonly ["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight"];

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

@@ -0,0 +1,2 @@
+export { injectRadioGroupRootContext, Label, RadioGroupIndicator, RadioGroupItem, RadioGroupRoot, useForwardProps, } from 'reka-ui';
+export type { RadioGroupItemProps, RadioGroupRootProps } from 'reka-ui';

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

@@ -0,0 +1,67 @@
+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;
+    icon?: IconName;
+    class?: VueCssClass;
+    strokeWidth?: number;
+};
+export type SelectItemProps = SelectItemBaseProps & {
+    [key: string]: unknown;
+};
+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'> & {
+    id?: string;
+    placeholder?: string;
+    size?: SelectSizes;
+    valueKey?: VK;
+    labelKey?: GetItemKeys<T>;
+    items?: T;
+    defaultValue?: GetModelValue<T, VK, M>;
+    modelValue?: GetModelValue<T, VK, M>;
+    multiple?: M & boolean;
+    variant?: SelectVariants;
+    icon?: IconName;
+    position?: 'item-aligned' | 'popper';
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    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 SelectItemSlotProps = (props: {
+    item: SelectItemBaseProps;
+    ui: Record<string, unknown>;
+}) => 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>;
+        open: boolean;
+    }): unknown;
+    item: (props: {
+        item: SelectItemProps;
+    }) => unknown;
+    label: (props: {
+        item: SelectItemProps;
+    }) => unknown;
+    ['item-leading']: SlotProps;
+    ['item-label']: (props: {
+        item: SelectItemProps;
+    }) => unknown;
+    ['item-trailing']: SlotProps;
+    header?: () => unknown;
+    footer?: () => unknown;
+};
+export {};

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

@@ -0,0 +1,71 @@
+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<{
+        triggerRef: Readonly<import('vue').ShallowRef<({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly disabled?: boolean | undefined;
+                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').SelectTriggerProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, 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 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;
+        } & Readonly<{
+            as: import('reka-ui').AsTag | import('vue').Component;
+        }> & Omit<Readonly<import('reka-ui').SelectTriggerProps> & Readonly<{}>, "as"> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                default?: (props: {}) => any;
+            };
+        }) | null>>;
+    }>): 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);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

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

@@ -0,0 +1,28 @@
+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;
+};
+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"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,28 @@
+import { AcceptableInputValue, TagsInputInputProps, 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'> & {
+    size?: TagsInputSizes;
+};
+export type TagsInputEmits = TagsInputRootEmits<TagsInputValue>;
+export type TagsInputTagUi = {
+    text: string;
+    delete: string;
+};
+export type TagsInputSlots = {
+    input?: (props: {
+        id?: string;
+        placeholder: string;
+        autoFocus?: boolean;
+        disabled?: boolean;
+        class: string;
+    }) => unknown;
+    tag?: (props: {
+        value: TagsInputValue;
+        displayValue: string;
+        index: number;
+        disabled: boolean;
+        ui: TagsInputTagUi;
+    }) => unknown;
+};

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

@@ -0,0 +1,35 @@
+import { TagsInputProps, TagsInputSizes, TagsInputSlots } from './TagsInput.types';
+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<TagsInputProps, {}, {}, {}, {}, 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<{
+    "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;
+    onRemoveTag?: ((payload: import('reka-ui').AcceptableInputValue) => any) | undefined;
+}>, {
+    disabled: boolean;
+    size: TagsInputSizes;
+    placeholder: string;
+    delimiter: string | RegExp;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    root: HTMLDivElement;
+}, 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/TagsInput/index.d.ts

@@ -0,0 +1,3 @@
+export { default as N8nTagsInput2 } from './TagsInput.vue';
+export type * from './TagsInput.types';
+export { TagsInputInput, TagsInputItemDelete, TagsInputItemText } from './reka-ui';

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

@@ -0,0 +1,2 @@
+export { TagsInputInput, TagsInputItem, TagsInputItemDelete, TagsInputItemText, TagsInputRoot, useForwardPropsEmits, } from 'reka-ui';
+export type { AcceptableInputValue, TagsInputInputProps, TagsInputRootEmits, TagsInputRootProps, } from 'reka-ui';

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

@@ -0,0 +1,79 @@
+import { FlattenedItem, TreeRootEmits, TreeRootProps } from 'reka-ui';
+import { Component } from 'vue';
+import { IconName } from '../../../components/N8nIcon/icons';
+export type TreeItem = {
+    id: string;
+    label: string;
+    icon?: IconName;
+};
+export interface TreeBranch extends TreeItem {
+    children?: TreeBranch[];
+}
+export type TreeNodeContext<T extends TreeItem = TreeBranch> = {
+    item: FlattenedItem<T>;
+    handleToggle: () => void;
+    handleSelect: () => void;
+    isExpanded: boolean;
+    hasChildren: boolean;
+};
+export type TreeDefaultNodeProps = {
+    label: string;
+};
+export type TreeGetNodeProps<T extends TreeItem = TreeBranch, P extends Record<string, unknown> = TreeDefaultNodeProps> = (context: TreeNodeContext<T>) => P;
+export type TreeProps = Omit<TreeRootProps<TreeBranch, TreeBranch, boolean>, 'asChild' | 'as' | 'getKey' | 'getChildren' | 'modelValue' | 'defaultValue'> & {
+    items: TreeBranch[];
+    getKey?: (item: TreeBranch) => string;
+    getChildren?: (item: TreeBranch) => TreeBranch[] | undefined;
+    modelValue?: string[];
+    defaultValue?: string[];
+    showExpandArrow?: boolean;
+    virtualized?: boolean;
+    estimateSize?: number;
+    overscan?: number;
+    textContent?: (item: TreeBranch) => string;
+    node?: Component;
+    getNodeProps?: TreeGetNodeProps;
+};
+export type TreeEmits = Omit<TreeRootEmits<TreeBranch, boolean>, 'update:modelValue'> & {
+    'update:modelValue': [value: string[]];
+};
+export type TreeDefaultSlotProps = TreeNodeContext;
+type TreeNodeDefaultIconSlotProps = {
+    icon?: IconName;
+    disabled?: boolean;
+    isSelected: boolean;
+    ui: {
+        class: string;
+    };
+};
+type TreeNodeDefaultLabelSlotProps = {
+    label: string;
+    disabled?: boolean;
+    handleSelect: () => void;
+    ui: {
+        class: string;
+    };
+};
+type TreeNodeDefaultToggleSlotProps = {
+    label: string;
+    disabled?: boolean;
+    isExpanded: boolean;
+    handleToggle: () => void;
+    ui: {
+        class: string;
+        iconClass: string;
+        iconExpandedClass: string;
+    };
+};
+export type TreeNodeDefaultSlots = {
+    icon?: (props: TreeNodeDefaultIconSlotProps) => unknown;
+    label?: (props: TreeNodeDefaultLabelSlotProps) => unknown;
+    toggle?: (props: TreeNodeDefaultToggleSlotProps) => unknown;
+};
+export type TreeSlots = {
+    default?: (props: TreeDefaultSlotProps) => unknown;
+    icon?: (props: TreeNodeDefaultIconSlotProps) => unknown;
+    label?: (props: TreeNodeDefaultLabelSlotProps) => unknown;
+    toggle?: (props: TreeNodeDefaultToggleSlotProps) => unknown;
+};
+export {};

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

@@ -0,0 +1,28 @@
+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, {
+    "update:modelValue": (value: string[]) => any;
+    "update:expanded": (val: string[]) => any;
+}, string, import('vue').PublicProps, Readonly<TreeProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string[]) => any) | undefined;
+    "onUpdate:expanded"?: ((val: string[]) => any) | undefined;
+}>, {
+    disabled: boolean;
+    multiple: boolean;
+    showExpandArrow: boolean;
+    virtualized: boolean;
+    estimateSize: number;
+}, {}, {}, {}, 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/Tree/TreeNode.vue.d.ts

@@ -0,0 +1,30 @@
+import { Component } from 'vue';
+import { TreeDefaultSlotProps, TreeGetNodeProps, TreeNodeDefaultSlots } from './Tree.types';
+type __VLS_Props = {
+    flattenedItem: TreeDefaultSlotProps['item'];
+    disabled?: boolean;
+    showExpandArrow?: boolean;
+    node?: Component;
+    getNodeProps: TreeGetNodeProps;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<TreeNodeDefaultSlots & {
+        default?: (props: TreeDefaultSlotProps) => unknown;
+    }> & TreeNodeDefaultSlots & {
+        default?: (props: TreeDefaultSlotProps) => unknown;
+    };
+    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<{}>, {
+    showExpandArrow: boolean;
+}, {}, {}, {}, 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;
+    };
+};