@n8n/design-system 2.33.4 → 2.34.0

package/dist/components/DateRangePicker/DateRangePicker.vue.d.ts

@@ -0,0 +1,43 @@
+import { N8nDateRangePickerProps } from './index';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        presets?: {};
+        trigger?: {};
+        footer?: {
+            close: () => void;
+        };
+    }> & {
+        presets?: {};
+        trigger?: {};
+        footer?: {
+            close: () => void;
+        };
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<N8nDateRangePickerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (date: import('reka-ui').DateRange) => any;
+    "update:open": (value: boolean) => any;
+    "update:placeholder": (date: import('reka-ui').DateValue) => any;
+    "update:startValue": (date: import('reka-ui').DateValue | undefined) => any;
+}, string, import('vue').PublicProps, Readonly<N8nDateRangePickerProps> & Readonly<{
+    "onUpdate:modelValue"?: ((date: import('reka-ui').DateRange) => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    "onUpdate:placeholder"?: ((date: import('reka-ui').DateValue) => any) | undefined;
+    "onUpdate:startValue"?: ((date: import('reka-ui').DateValue | undefined) => any) | undefined;
+}>, {
+    weekStartsOn: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    weekdayFormat: import('reka-ui/date').WeekDayFormat;
+    fixedWeeks: boolean;
+    hourCycle: 12 | 24;
+}, {}, {}, {}, 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/DateRangePicker/DateRangePickerField.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

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

@@ -0,0 +1,7 @@
+import { DateRangePickerRootEmits, DateRangePickerRootProps, PopoverRootEmits } from 'reka-ui';
+export { default as N8nDateRangePicker } from './DateRangePicker.vue';
+export type N8nDateRangePickerProps = DateRangePickerRootProps & {
+    hideInputs?: boolean;
+};
+export type N8nDateRangePickerRootEmits = DateRangePickerRootEmits & PopoverRootEmits;
+export type { DateRange, DateValue } from 'reka-ui';

package/dist/components/IconTextButton/IconTextButton.vue.d.ts

@@ -0,0 +1,41 @@
+import { IconSize } from '../../types/icon';
+import { IconName } from '../N8nIcon/icons';
+interface Props {
+    icon: IconName;
+    iconSize?: IconSize;
+    iconPosition?: 'left' | 'right';
+    disabled?: boolean;
+    active?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        buttonRef: HTMLButtonElement;
+    };
+    rootEl: HTMLButtonElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {
+    buttonRef: import('vue').Ref<HTMLButtonElement | null, HTMLButtonElement | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: () => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onClick?: (() => any) | undefined;
+}>, {
+    disabled: boolean;
+    iconSize: IconSize;
+    active: boolean;
+    iconPosition: "left" | "right";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    buttonRef: HTMLButtonElement;
+}, HTMLButtonElement>;
+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/IconTextButton/index.d.ts

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

package/dist/components/InlineAskAssistantButton/InlineAskAssistantButton.vue.d.ts

@@ -0,0 +1,16 @@
+interface Props {
+    size?: 'small' | 'medium';
+    static?: boolean;
+    asked?: boolean;
+    label?: string;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: () => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onClick?: (() => any) | undefined;
+}>, {
+    size: "small" | "medium";
+    static: boolean;
+    asked: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLButtonElement>;
+export default _default;

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

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

package/dist/components/N8nActionDropdown/ActionDropdown.types.d.ts

@@ -0,0 +1,16 @@
+import { ActionDropdownItem, ButtonSize, IconSize } from '../../types';
+import { IconName } from '../N8nIcon/icons';
+export interface ActionDropdownProps<T extends string = string> {
+    items: Array<ActionDropdownItem<T>>;
+    placement?: 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end';
+    activatorIcon?: IconName;
+    activatorSize?: ButtonSize;
+    iconSize?: IconSize;
+    trigger?: 'click' | 'hover';
+    teleported?: boolean;
+    disabled?: boolean;
+    extraPopperClass?: string;
+    maxHeight?: string | number;
+    width?: string;
+    modal?: boolean;
+}

package/dist/components/N8nActionDropdown/ActionDropdown.vue.d.ts

@@ -0,0 +1,41 @@
+import { ActionDropdownItem } from '../../types';
+import { ActionDropdownProps } from './ActionDropdown.types';
+declare const _default: <T extends string>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onSelect?: ((action: T) => any) | undefined;
+        readonly onVisibleChange?: ((open: boolean) => any) | undefined;
+        readonly "onBadge-click"?: ((action: T) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onSelect" | "onVisibleChange" | "onBadge-click"> & ActionDropdownProps<T> & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        open: () => void | undefined;
+        close: () => void | undefined;
+    }>): void;
+    attrs: any;
+    slots: {
+        activator?(_: {}): any;
+        menuItem?(_: {
+            id: T;
+            label: string;
+            testId?: string;
+            badge?: string;
+            description?: string;
+            badgeProps?: Record<string, unknown>;
+            icon?: import('..').IconName;
+            divided?: boolean;
+            disabled?: boolean;
+            shortcut?: import('../..').KeyboardShortcut;
+            customClass?: string;
+            checked?: boolean;
+            variant?: "default" | "destructive";
+            children?: ActionDropdownItem<T>[] | undefined;
+        }): any;
+        footer?(_: {}): any;
+    };
+    emit: ((evt: "select", action: T) => void) & ((evt: "visibleChange", open: boolean) => void) & ((evt: "badge-click", action: T) => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

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

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

package/dist/components/N8nActionPill/ActionPill.vue.d.ts

@@ -0,0 +1,35 @@
+type __VLS_Props = {
+    text?: string;
+    hoverText?: string;
+    clickable?: boolean;
+    size?: 'small' | 'medium';
+    type?: 'default' | 'danger';
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLSpanElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    text: string;
+    type: "default" | "danger";
+    size: "small" | "medium";
+    hoverText: string;
+    clickable: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLSpanElement>;
+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/N8nActionToggle/ActionToggle.types.d.ts

@@ -0,0 +1,23 @@
+export type ActionToggleItem<T extends string = string> = {
+    label: string;
+    disabled?: boolean;
+    type?: 'external-link';
+    tooltip?: string;
+} & ({
+    id: T;
+    value?: T;
+} | {
+    id?: T;
+    value: T;
+});
+export interface ActionToggleProps<T extends string = string> {
+    actions?: Array<ActionToggleItem<T>>;
+    placement?: 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end';
+    theme?: 'default' | 'dark';
+    iconOrientation?: 'horizontal' | 'vertical';
+    loading?: boolean;
+    loadingRowCount?: number;
+    disabled?: boolean;
+    popperClass?: string;
+    trigger?: 'click' | 'hover';
+}

package/dist/components/N8nActionToggle/ActionToggle.vue.d.ts

@@ -0,0 +1,24 @@
+import { DropdownMenuItemProps } from '../N8nDropdownMenu/DropdownMenu.types';
+import { ActionToggleItem, ActionToggleProps } from './ActionToggle.types';
+declare const _default: <T extends string>(__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"?: ((open: boolean) => any) | undefined;
+        readonly "onItem-mouseup"?: ((action: DropdownMenuItemProps<T, ActionToggleItem<T>>) => any) | undefined;
+        readonly onAction?: ((value: T) => any) | undefined;
+        readonly "onVisible-change"?: ((open: boolean) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:modelValue" | "onItem-mouseup" | "onAction" | "onVisible-change"> & ActionToggleProps<T> & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        openActionToggle: (isOpen: boolean) => void;
+    }>): void;
+    attrs: any;
+    slots: {
+        default?(_: {}): any;
+    };
+    emit: ((evt: "update:modelValue", open: boolean) => void) & ((evt: "item-mouseup", action: DropdownMenuItemProps<T, ActionToggleItem<T>>) => void) & ((evt: "action", value: T) => void) & ((evt: "visible-change", open: 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/components/N8nActionToggle/index.d.ts

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

package/dist/components/N8nAiActivityStep/AiActivityStep.vue.d.ts

@@ -0,0 +1,32 @@
+type __VLS_Props = {
+    label: string;
+    loading?: boolean;
+    error?: string;
+    hasContent?: boolean;
+    wrapContent?: boolean;
+    hideErrorCallout?: boolean;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+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<{}>, {
+    error: string;
+    loading: boolean;
+    hasContent: boolean;
+    wrapContent: boolean;
+    hideErrorCallout: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+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/N8nAiActivityStep/context.d.ts

@@ -0,0 +1,2 @@
+import { InjectionKey } from 'vue';
+export declare const aiActivityStepGroupContext: InjectionKey<boolean>;

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

@@ -0,0 +1 @@
+export { default } from './AiActivityStep.vue';

package/dist/components/N8nAiActivityStepButton/AiActivityStepButton.vue.d.ts

@@ -0,0 +1,34 @@
+type __VLS_Props = {
+    size?: 'small' | 'medium';
+    loading?: boolean;
+    interactive?: boolean;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        prefix?: () => unknown;
+        suffix?: () => unknown;
+        icon?: () => unknown;
+        default?: () => unknown;
+    }> & {
+        prefix?: () => unknown;
+        suffix?: () => unknown;
+        icon?: () => unknown;
+        default?: () => 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<{}>, {
+    size: "small" | "medium";
+    loading: boolean;
+    interactive: 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/N8nAiActivityStepButton/index.d.ts

@@ -0,0 +1 @@
+export { default } from './AiActivityStepButton.vue';

package/dist/components/N8nAiActivityStepChevron/AiActivityStepChevron.vue.d.ts

@@ -0,0 +1,5 @@
+type __VLS_Props = {
+    open: boolean;
+};
+declare const _default: 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>;
+export default _default;

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

@@ -0,0 +1 @@
+export { default } from './AiActivityStepChevron.vue';

package/dist/components/N8nAiActivityStepGroup/AiActivityStepGroup.vue.d.ts

@@ -0,0 +1,27 @@
+type __VLS_Props = {
+    label: string;
+    size?: 'small' | 'medium';
+    loading?: boolean;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default?: () => unknown;
+    }> & {
+        default?: () => 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<{}>, {
+    size: "small" | "medium";
+    loading: 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/N8nAiActivityStepGroup/index.d.ts

@@ -0,0 +1 @@
+export { default } from './AiActivityStepGroup.vue';

package/dist/components/N8nAiActivityStepResultSection/AiActivityStepResultSection.vue.d.ts

@@ -0,0 +1,17 @@
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+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/N8nAiActivityStepResultSection/index.d.ts

@@ -0,0 +1 @@
+export { default } from './AiActivityStepResultSection.vue';

package/dist/components/N8nAiModelSelectorDropdown/AiModelSelectorDropdown.types.d.ts

@@ -0,0 +1,15 @@
+import { DropdownMenuItemProps } from '../N8nDropdownMenu/DropdownMenu.types';
+export interface AiModelSelectorMenuItemData {
+    badgeLabel?: string;
+    actionPill?: {
+        text: string;
+        type?: 'default' | 'danger';
+    };
+    description?: string;
+    descriptionTooltipTeleported?: boolean;
+    fullName?: string;
+    parts?: string[];
+    credentialType?: string;
+    leadingIcon?: string;
+}
+export type AiModelSelectorMenuItem<TData extends AiModelSelectorMenuItemData = AiModelSelectorMenuItemData> = DropdownMenuItemProps<string, TData>;

package/dist/components/N8nAiModelSelectorDropdown/AiModelSelectorDropdown.vue.d.ts

@@ -0,0 +1,54 @@
+import { AiModelSelectorMenuItem, AiModelSelectorMenuItemData } from './AiModelSelectorDropdown.types';
+declare const _default: <TData extends AiModelSelectorMenuItemData = AiModelSelectorMenuItemData>(__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 onSearch?: ((query: string) => any) | undefined;
+        readonly onSelect?: ((id: string) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onSelect" | "onSearch"> & {
+        items: Array<AiModelSelectorMenuItem<TData>>;
+        selectedLabel: string;
+        selectedCredentialName?: string;
+        credentialsMissing?: boolean;
+        credentialsMissingLabel?: string;
+        noMatchLabel: string;
+        showBorder?: boolean;
+        disabled?: boolean;
+        dataTestId: string;
+        credentialDataTestId: string;
+    } & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        open: () => void;
+    }>): void;
+    attrs: any;
+    slots: Readonly<{
+        'trigger-leading'?: (props: {
+            ui: {
+                class: string;
+            };
+        }) => void;
+        'item-leading'?: (props: {
+            item: AiModelSelectorMenuItem<TData>;
+            ui: {
+                class: string;
+            };
+        }) => void;
+    }> & {
+        'trigger-leading'?: (props: {
+            ui: {
+                class: string;
+            };
+        }) => void;
+        'item-leading'?: (props: {
+            item: AiModelSelectorMenuItem<TData>;
+            ui: {
+                class: string;
+            };
+        }) => void;
+    };
+    emit: ((evt: "search", query: string) => void) & ((evt: "select", id: string) => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

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

@@ -0,0 +1,2 @@
+export { default } from './AiModelSelectorDropdown.vue';
+export type { AiModelSelectorMenuItem, AiModelSelectorMenuItemData, } from './AiModelSelectorDropdown.types';

package/dist/components/N8nAlert/Alert.vue.d.ts

@@ -0,0 +1,34 @@
+type AlertProps = {
+    title?: string;
+    type?: 'success' | 'warning' | 'info' | 'error';
+    description?: string;
+    center?: boolean;
+    showIcon?: boolean;
+    effect?: 'light' | 'dark';
+    background?: boolean;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        icon?(_: {}): any;
+        title?(_: {}): any;
+        default?(_: {}): any;
+        aside?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<AlertProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<AlertProps> & Readonly<{}>, {
+    type: "success" | "warning" | "info" | "error";
+    effect: "light" | "dark";
+    showIcon: boolean;
+    background: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+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/N8nAlert/index.d.ts

@@ -0,0 +1 @@
+export { default } from './Alert.vue';

package/dist/components/N8nAlertDialog/AlertDialog.vue.d.ts

@@ -0,0 +1,51 @@
+export type AlertDialogActionVariant = 'solid' | 'destructive';
+export type AlertDialogSize = 'small' | 'medium';
+export interface AlertDialogProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    title: string;
+    description?: string;
+    actionLabel?: string;
+    actionVariant?: AlertDialogActionVariant;
+    cancelLabel?: string;
+    loading?: boolean;
+    size?: AlertDialogSize;
+}
+export interface AlertDialogEmits {
+    'update:open': [open: boolean];
+    action: [];
+    cancel: [];
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default?: () => unknown;
+    }> & {
+        default?: () => unknown;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<AlertDialogProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:open": (open: boolean) => any;
+    cancel: () => any;
+    action: () => any;
+}, string, import('vue').PublicProps, Readonly<AlertDialogProps> & Readonly<{
+    "onUpdate:open"?: ((open: boolean) => any) | undefined;
+    onCancel?: (() => any) | undefined;
+    onAction?: (() => any) | undefined;
+}>, {
+    size: AlertDialogSize;
+    loading: boolean;
+    actionLabel: string;
+    actionVariant: AlertDialogActionVariant;
+    cancelLabel: 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/N8nAlertDialog/index.d.ts

@@ -0,0 +1,2 @@
+export { default as N8nAlertDialog } from './AlertDialog.vue';
+export type { AlertDialogProps, AlertDialogEmits, AlertDialogActionVariant, AlertDialogSize, } from './AlertDialog.vue';

package/dist/components/N8nAnimatedCollapsibleContent/AnimatedCollapsibleContent.vue.d.ts

@@ -0,0 +1,22 @@
+type __VLS_Props = {
+    blur?: boolean;
+};
+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<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    blur: 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/N8nAnimatedCollapsibleContent/index.d.ts

@@ -0,0 +1 @@
+export { default } from './AnimatedCollapsibleContent.vue';

package/dist/components/N8nAvatar/Avatar.vue.d.ts

@@ -0,0 +1,14 @@
+import { AvatarSize } from './avatarSizes';
+interface AvatarProps {
+    firstName?: string | null;
+    lastName?: string | null;
+    size?: AvatarSize;
+    colors?: string[];
+}
+declare const _default: import('vue').DefineComponent<AvatarProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<AvatarProps> & Readonly<{}>, {
+    size: AvatarSize;
+    firstName: string | null;
+    lastName: string | null;
+    colors: string[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLSpanElement>;
+export default _default;

package/dist/components/N8nAvatar/avatarSizes.d.ts

@@ -0,0 +1,8 @@
+export declare const AVATAR_SIZES: {
+    readonly xxsmall: 16;
+    readonly xsmall: 20;
+    readonly small: 28;
+    readonly medium: 40;
+    readonly large: 48;
+};
+export type AvatarSize = keyof typeof AVATAR_SIZES;

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

@@ -0,0 +1,3 @@
+import { default as N8nAvatar } from './Avatar.vue';
+export { AVATAR_SIZES, type AvatarSize } from './avatarSizes';
+export default N8nAvatar;