@n8n/design-system 2.33.4 → 2.34.0

package/dist/components/N8nFormInput/FormInput.vue.d.ts

@@ -0,0 +1,355 @@
+import { Rule, RuleGroup, IValidator, Validatable, InputAutocompletePropType } from '../../types';
+export interface Props {
+    modelValue: Validatable;
+    label: string;
+    infoText?: string;
+    required?: boolean;
+    showRequiredAsterisk?: boolean;
+    type?: string;
+    placeholder?: string;
+    tooltipText?: string;
+    showValidationWarnings?: boolean;
+    validateOnBlur?: boolean;
+    documentationUrl?: string;
+    documentationText?: string;
+    validationRules?: Array<Rule | RuleGroup>;
+    validators?: {
+        [key: string]: IValidator | RuleGroup;
+    };
+    maxlength?: number;
+    options?: Array<{
+        value: string | number;
+        label: string;
+        disabled?: boolean;
+    }>;
+    autocomplete?: InputAutocompletePropType;
+    name?: string;
+    focusInitially?: boolean;
+    labelSize?: 'small' | 'medium' | 'large';
+    disabled?: boolean;
+    activeLabel?: string;
+    activeColor?: string;
+    inactiveLabel?: string;
+    inactiveColor?: string;
+    teleported?: boolean;
+    tagSize?: 'small' | 'medium' | 'large';
+    autosize?: boolean | {
+        minRows: number;
+        maxRows: number;
+    };
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        inputRef: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly modelValue?: string | number | null | undefined;
+                readonly type?: import('../N8nInput').InputType | undefined;
+                readonly size?: import('../N8nInput').InputSize | undefined;
+                readonly placeholder?: string | undefined;
+                readonly disabled?: boolean | undefined;
+                readonly readonly?: boolean | undefined;
+                readonly required?: boolean | undefined;
+                readonly clearable?: boolean | undefined;
+                readonly rows?: number | undefined;
+                readonly masked?: boolean | undefined;
+                readonly maxlength?: number | undefined;
+                readonly autosize?: boolean | {
+                    minRows?: number;
+                    maxRows?: number;
+                } | undefined;
+                readonly autofocus?: boolean | undefined;
+                readonly autocomplete?: import('../N8nInput').InputAutocomplete | undefined;
+                readonly name?: string | undefined;
+                readonly onInput?: ((value: string) => any) | undefined;
+                readonly onFocus?: ((event: FocusEvent) => any) | undefined;
+                readonly "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                readonly onBlur?: ((event: FocusEvent) => any) | undefined;
+                readonly onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+                readonly onMousedown?: ((event: MouseEvent) => any) | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            } & {
+                inputRef: HTMLTextAreaElement;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "input", value: string) => void) & ((event: "focus", event: FocusEvent) => void) & ((event: "update:modelValue", value: string) => void) & ((event: "blur", event: FocusEvent) => void) & ((event: "keydown", event: KeyboardEvent) => void) & ((event: "mousedown", event: MouseEvent) => void);
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('../N8nInput').InputProps> & Readonly<{
+                onInput?: ((value: string) => any) | undefined;
+                onFocus?: ((event: FocusEvent) => any) | undefined;
+                "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                onBlur?: ((event: FocusEvent) => any) | undefined;
+                onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+                onMousedown?: ((event: MouseEvent) => any) | undefined;
+            }>, {
+                focus: () => void | undefined;
+                blur: () => void | undefined;
+                select: () => void | undefined;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                input: (value: string) => any;
+                focus: (event: FocusEvent) => any;
+                "update:modelValue": (value: string) => any;
+                blur: (event: FocusEvent) => any;
+                keydown: (event: KeyboardEvent) => any;
+                mousedown: (event: MouseEvent) => any;
+            }, string, {
+                type: import('../N8nInput').InputType;
+                name: string;
+                disabled: boolean;
+                required: boolean;
+                size: import('../N8nInput').InputSize;
+                placeholder: string;
+                rows: number;
+                modelValue: string | number | null;
+                readonly: boolean;
+                clearable: boolean;
+                masked: boolean;
+                maxlength: number;
+                autosize: boolean | {
+                    minRows?: number;
+                    maxRows?: number;
+                };
+                autofocus: boolean;
+                autocomplete: import('../N8nInput').InputAutocomplete;
+            }, {}, 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 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<{
+            type: import('../N8nInput').InputType;
+            name: string;
+            disabled: boolean;
+            required: boolean;
+            size: import('../N8nInput').InputSize;
+            placeholder: string;
+            rows: number;
+            modelValue: string | number | null;
+            readonly: boolean;
+            clearable: boolean;
+            masked: boolean;
+            maxlength: number;
+            autosize: boolean | {
+                minRows?: number;
+                maxRows?: number;
+            };
+            autofocus: boolean;
+            autocomplete: import('../N8nInput').InputAutocomplete;
+        }> & Omit<Readonly<import('../N8nInput').InputProps> & Readonly<{
+            onInput?: ((value: string) => any) | undefined;
+            onFocus?: ((event: FocusEvent) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            onBlur?: ((event: FocusEvent) => any) | undefined;
+            onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+            onMousedown?: ((event: MouseEvent) => any) | undefined;
+        }>, "select" | "focus" | "blur" | ("type" | "name" | "disabled" | "required" | "size" | "placeholder" | "rows" | "modelValue" | "readonly" | "clearable" | "masked" | "maxlength" | "autosize" | "autofocus" | "autocomplete")> & import('vue').ShallowUnwrapRef<{
+            focus: () => void | undefined;
+            blur: () => void | undefined;
+            select: () => void | undefined;
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: Readonly<import('../N8nInput').InputSlots> & import('../N8nInput').InputSlots;
+        }) | null;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {
+    inputRef: import('vue').Ref<HTMLTextAreaElement | null, HTMLTextAreaElement | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    focus: () => any;
+    "update:modelValue": (value: Validatable) => any;
+    blur: () => any;
+    validate: (shouldValidate: boolean) => any;
+    enter: () => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onFocus?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((value: Validatable) => any) | undefined;
+    onBlur?: (() => any) | undefined;
+    onValidate?: ((shouldValidate: boolean) => any) | undefined;
+    onEnter?: (() => any) | undefined;
+}>, {
+    type: string;
+    teleported: boolean;
+    tagSize: "small" | "medium" | "large";
+    autosize: boolean | {
+        minRows: number;
+        maxRows: number;
+    };
+    showRequiredAsterisk: boolean;
+    validateOnBlur: boolean;
+    documentationText: string;
+    labelSize: "small" | "medium" | "large";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    inputRef: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly modelValue?: string | number | null | undefined;
+            readonly type?: import('../N8nInput').InputType | undefined;
+            readonly size?: import('../N8nInput').InputSize | undefined;
+            readonly placeholder?: string | undefined;
+            readonly disabled?: boolean | undefined;
+            readonly readonly?: boolean | undefined;
+            readonly required?: boolean | undefined;
+            readonly clearable?: boolean | undefined;
+            readonly rows?: number | undefined;
+            readonly masked?: boolean | undefined;
+            readonly maxlength?: number | undefined;
+            readonly autosize?: boolean | {
+                minRows?: number;
+                maxRows?: number;
+            } | undefined;
+            readonly autofocus?: boolean | undefined;
+            readonly autocomplete?: import('../N8nInput').InputAutocomplete | undefined;
+            readonly name?: string | undefined;
+            readonly onInput?: ((value: string) => any) | undefined;
+            readonly onFocus?: ((event: FocusEvent) => any) | undefined;
+            readonly "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            readonly onBlur?: ((event: FocusEvent) => any) | undefined;
+            readonly onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+            readonly onMousedown?: ((event: MouseEvent) => any) | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            inputRef: HTMLTextAreaElement;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "input", value: string) => void) & ((event: "focus", event: FocusEvent) => void) & ((event: "update:modelValue", value: string) => void) & ((event: "blur", event: FocusEvent) => void) & ((event: "keydown", event: KeyboardEvent) => void) & ((event: "mousedown", event: MouseEvent) => void);
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('../N8nInput').InputProps> & Readonly<{
+            onInput?: ((value: string) => any) | undefined;
+            onFocus?: ((event: FocusEvent) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            onBlur?: ((event: FocusEvent) => any) | undefined;
+            onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+            onMousedown?: ((event: MouseEvent) => any) | undefined;
+        }>, {
+            focus: () => void | undefined;
+            blur: () => void | undefined;
+            select: () => void | undefined;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            input: (value: string) => any;
+            focus: (event: FocusEvent) => any;
+            "update:modelValue": (value: string) => any;
+            blur: (event: FocusEvent) => any;
+            keydown: (event: KeyboardEvent) => any;
+            mousedown: (event: MouseEvent) => any;
+        }, string, {
+            type: import('../N8nInput').InputType;
+            name: string;
+            disabled: boolean;
+            required: boolean;
+            size: import('../N8nInput').InputSize;
+            placeholder: string;
+            rows: number;
+            modelValue: string | number | null;
+            readonly: boolean;
+            clearable: boolean;
+            masked: boolean;
+            maxlength: number;
+            autosize: boolean | {
+                minRows?: number;
+                maxRows?: number;
+            };
+            autofocus: boolean;
+            autocomplete: import('../N8nInput').InputAutocomplete;
+        }, {}, 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 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<{
+        type: import('../N8nInput').InputType;
+        name: string;
+        disabled: boolean;
+        required: boolean;
+        size: import('../N8nInput').InputSize;
+        placeholder: string;
+        rows: number;
+        modelValue: string | number | null;
+        readonly: boolean;
+        clearable: boolean;
+        masked: boolean;
+        maxlength: number;
+        autosize: boolean | {
+            minRows?: number;
+            maxRows?: number;
+        };
+        autofocus: boolean;
+        autocomplete: import('../N8nInput').InputAutocomplete;
+    }> & Omit<Readonly<import('../N8nInput').InputProps> & Readonly<{
+        onInput?: ((value: string) => any) | undefined;
+        onFocus?: ((event: FocusEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        onBlur?: ((event: FocusEvent) => any) | undefined;
+        onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+        onMousedown?: ((event: MouseEvent) => any) | undefined;
+    }>, "select" | "focus" | "blur" | ("type" | "name" | "disabled" | "required" | "size" | "placeholder" | "rows" | "modelValue" | "readonly" | "clearable" | "masked" | "maxlength" | "autosize" | "autofocus" | "autocomplete")> & import('vue').ShallowUnwrapRef<{
+        focus: () => void | undefined;
+        blur: () => void | undefined;
+        select: () => void | undefined;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: Readonly<import('../N8nInput').InputSlots> & import('../N8nInput').InputSlots;
+    }) | 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/components/N8nFormInput/index.d.ts

@@ -0,0 +1,2 @@
+import { default as N8nFormInput } from './FormInput.vue';
+export default N8nFormInput;

package/dist/components/N8nFormInput/validators.d.ts

@@ -0,0 +1,46 @@
+import { IValidator, RuleGroup, Validatable } from '../../types';
+export declare const emailRegex: RegExp;
+export declare const requiredValidator: IValidator<{}>;
+export declare const minLengthValidator: IValidator<{
+    minimum: number;
+}>;
+export declare const maxLengthValidator: IValidator<{
+    maximum: number;
+}>;
+export declare const containsNumberValidator: IValidator<{
+    minimum: number;
+}>;
+export declare const emailValidator: IValidator<{}>;
+export declare const containsUpperCaseValidator: IValidator<{
+    minimum: number;
+}>;
+export declare const matchRegex: IValidator<{
+    regex: RegExp;
+    message: string;
+}>;
+export declare const createPasswordRules: (minLength?: number) => RuleGroup;
+export declare const defaultPasswordRules: RuleGroup;
+export declare const VALIDATORS: {
+    REQUIRED: IValidator<{}>;
+    MIN_LENGTH: IValidator<{
+        minimum: number;
+    }>;
+    MAX_LENGTH: IValidator<{
+        maximum: number;
+    }>;
+    CONTAINS_NUMBER: IValidator<{
+        minimum: number;
+    }>;
+    VALID_EMAIL: IValidator<{}>;
+    CONTAINS_UPPERCASE: IValidator<{
+        minimum: number;
+    }>;
+    DEFAULT_PASSWORD_RULES: RuleGroup;
+    MATCH_REGEX: IValidator<{
+        regex: RegExp;
+        message: string;
+    }>;
+};
+export declare const getValidationError: <T extends Validatable, C>(value: T, validators: {
+    [key: string]: IValidator | RuleGroup;
+}, validator: IValidator | RuleGroup, config?: C) => ReturnType<IValidator["validate"]>;

package/dist/components/N8nFormInputs/FormInputs.vue.d.ts

@@ -0,0 +1,39 @@
+import { FormFieldValue, IFormInput, FormFieldValueUpdate, FormValues } from '../../types';
+import { FormEventBus } from '../../utils';
+export interface FormInputsProps {
+    inputs: IFormInput[];
+    eventBus?: FormEventBus;
+    columnView?: boolean;
+    verticalSpacing?: '' | 'xs' | 's' | 'm' | 'l' | 'xl';
+    teleported?: boolean;
+    tagSize?: 'small' | 'medium' | 'large';
+}
+declare function getValues(): {
+    [x: string]: FormFieldValue;
+};
+declare function getValuesWithMetadata<Metadata = Record<string, unknown>>(): Record<string, {
+    value: FormFieldValue;
+    metadata: Metadata;
+}>;
+declare function clearValues(fieldNames: string[]): void;
+declare const _default: import('vue').DefineComponent<FormInputsProps, {
+    getValues: typeof getValues;
+    getValuesWithMetadata: typeof getValuesWithMetadata;
+    clearValues: typeof clearValues;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: FormValues) => any;
+    submit: (value: FormValues) => any;
+    update: (value: FormFieldValueUpdate) => any;
+    ready: (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<FormInputsProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: FormValues) => any) | undefined;
+    onSubmit?: ((value: FormValues) => any) | undefined;
+    onUpdate?: ((value: FormFieldValueUpdate) => any) | undefined;
+    onReady?: ((value: boolean) => any) | undefined;
+}>, {
+    teleported: boolean;
+    eventBus: FormEventBus;
+    columnView: boolean;
+    verticalSpacing: "" | "xs" | "s" | "m" | "l" | "xl";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/components/N8nFormInputs/index.d.ts

@@ -0,0 +1,2 @@
+import { default as N8nFormInputs } from './FormInputs.vue';
+export default N8nFormInputs;

package/dist/components/N8nHeaderAction/HeaderAction.vue.d.ts

@@ -0,0 +1,18 @@
+import { IconName } from '../N8nIcon/icons';
+export interface Props {
+    icon: IconName;
+    label: string;
+    tooltip?: string;
+    danger?: boolean;
+    testId?: string;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    danger: boolean;
+    tooltip: string;
+    testId: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/N8nHeaderAction/index.d.ts

@@ -0,0 +1,2 @@
+import { default as HeaderAction } from './HeaderAction.vue';
+export default HeaderAction;

package/dist/components/N8nHeading/Heading.vue.d.ts

@@ -0,0 +1,33 @@
+import { TextStep } from '../../types/text';
+declare const SIZES: readonly ["2xlarge", "xlarge", "large", "medium", "small"];
+declare const COLORS: readonly ["primary", "text-dark", "text-base", "text-light", "text-xlight", "danger"];
+declare const ALIGN: readonly ["right", "left", "center"];
+interface HeadingProps {
+    tag?: string;
+    bold?: boolean;
+    size?: (typeof SIZES)[number];
+    step?: TextStep;
+    color?: (typeof COLORS)[number];
+    align?: (typeof ALIGN)[number];
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<HeadingProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<HeadingProps> & Readonly<{}>, {
+    bold: boolean;
+    size: (typeof SIZES)[number];
+    tag: string;
+}, {}, {}, {}, 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/components/N8nHeading/index.d.ts

@@ -0,0 +1,2 @@
+import { default as N8nHeading } from './Heading.vue';
+export default N8nHeading;

package/dist/components/N8nHoverCard/HoverCard.vue.d.ts

@@ -0,0 +1,70 @@
+import { HoverCardContentProps, HoverCardRootProps, ReferenceElement } from 'reka-ui';
+interface Props extends Pick<HoverCardRootProps, 'open' | 'defaultOpen' | 'openDelay' | 'closeDelay'>, Pick<HoverCardContentProps, 'side' | 'align' | 'sideOffset' | 'alignOffset' | 'avoidCollisions' | 'collisionPadding' | 'sideFlip' | 'forceMount'> {
+    disabled?: boolean;
+    reference?: ReferenceElement;
+    maxWidth?: string;
+    maxHeight?: string;
+    enableScrolling?: boolean;
+    showArrow?: boolean;
+    teleported?: boolean;
+    contentClass?: string;
+    triggerClass?: string;
+    triggerAsChild?: boolean;
+    hideTrigger?: boolean;
+}
+declare function close(): void;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        trigger?(_: {}): any;
+        content?(_: {
+            close: typeof close;
+        }): any;
+        content?(_: {
+            close: typeof close;
+        }): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:open": (value: boolean) => any;
+    "before-enter": () => any;
+    "after-leave": () => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    "onBefore-enter"?: (() => any) | undefined;
+    "onAfter-leave"?: (() => any) | undefined;
+}>, {
+    showArrow: boolean;
+    disabled: boolean;
+    open: boolean;
+    teleported: boolean;
+    align: "center" | "start" | "end";
+    avoidCollisions: boolean;
+    contentClass: string;
+    side: "right" | "left" | "top" | "bottom";
+    sideOffset: number;
+    alignOffset: number;
+    collisionPadding: number | Partial<Record<"right" | "left" | "top" | "bottom", number>>;
+    forceMount: boolean;
+    defaultOpen: boolean;
+    reference: ReferenceElement;
+    maxHeight: string;
+    maxWidth: string;
+    sideFlip: boolean;
+    openDelay: number;
+    closeDelay: number;
+    enableScrolling: boolean;
+    triggerClass: string;
+    triggerAsChild: boolean;
+    hideTrigger: 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/components/N8nHoverCard/index.d.ts

@@ -0,0 +1,2 @@
+import { default as N8nHoverCard } from './HoverCard.vue';
+export default N8nHoverCard;

package/dist/components/N8nIcon/Icon.vue.d.ts

@@ -0,0 +1,15 @@
+import { IconName, NodeIconName } from './icons';
+import { IconSize, IconColor } from '../../types/icon';
+interface IconProps {
+    icon: IconName | NodeIconName | (string & {});
+    size?: IconSize | number;
+    spin?: boolean;
+    color?: IconColor | (string & {});
+    strokeWidth?: number | undefined;
+}
+declare const _default: import('vue').DefineComponent<IconProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<IconProps> & Readonly<{}>, {
+    color: IconColor | (string & {});
+    size: IconSize | number;
+    spin: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/N8nIcon/iconColor.d.ts

@@ -0,0 +1,2 @@
+import { IconColor } from '../../types/icon';
+export declare function resolveIconColor(color: IconColor | (string & {}) | undefined): string | undefined;