@n8n/design-system 2.33.4 → 2.34.0

package/dist/components/N8nDropdownMenu/DropdownMenu.types.d.ts

@@ -0,0 +1,104 @@
+import { InjectionKey, Ref } from 'vue';
+import { IconOrEmoji } from '../N8nIconPicker/types';
+export declare const DropdownMenuPortalTargetKey: InjectionKey<Ref<string | HTMLElement | undefined>>;
+export declare const DropdownMenuSubMaxHeightKey: InjectionKey<Ref<string | undefined>>;
+type VueCssClass = undefined | string | Record<string, boolean> | Array<string | VueCssClass>;
+export type DropdownMenuPlacement = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end' | 'right' | 'right-start' | 'right-end';
+export type DropdownMenuSide = 'top' | 'bottom' | 'left' | 'right';
+export type DropdownMenuAlign = 'start' | 'end' | 'center';
+export type DropdownMenuTrigger = 'click' | 'hover';
+export type DropdownMenuItemProps<T = string, D = never> = {
+    id: T;
+    testId?: string;
+    label: string;
+    icon?: IconOrEmoji;
+    disabled?: boolean;
+    divided?: boolean;
+    checked?: boolean;
+    keepOpen?: boolean;
+    header?: boolean;
+    checkbox?: boolean;
+    class?: VueCssClass;
+    children?: Array<DropdownMenuItemProps<T, D>>;
+    loading?: boolean;
+    loadingItemCount?: number;
+    searchable?: boolean;
+    searchPlaceholder?: string;
+    highlighted?: boolean;
+    subMenuOpen?: boolean;
+    data?: D;
+};
+export interface DropdownMenuProps<T = string, D = never> {
+    id?: string;
+    contentTestId?: string;
+    portalTarget?: string | HTMLElement;
+    modal?: boolean;
+    items: Array<DropdownMenuItemProps<T, D>>;
+    modelValue?: boolean;
+    defaultOpen?: boolean;
+    placement?: DropdownMenuPlacement;
+    trigger?: DropdownMenuTrigger;
+    activatorIcon?: IconOrEmoji;
+    disabled?: boolean;
+    teleported?: boolean;
+    maxHeight?: string | number;
+    width?: string;
+    subMenuMaxHeight?: string | number;
+    loading?: boolean;
+    loadingItemCount?: number;
+    extraPopperClass?: string;
+    dataTestId?: string;
+    searchable?: boolean;
+    searchPlaceholder?: string;
+    searchDebounce?: number;
+    emptyText?: string;
+}
+export interface DropdownMenuEmits<T = string, D = never> {
+    (e: 'update:modelValue', open: boolean): void;
+    (e: 'select', value: T): void;
+    (e: 'search', searchTerm: string, itemId?: T): void;
+    (e: 'submenu:toggle', itemId: T, open: boolean): void;
+    (e: 'item-mouseup', item: DropdownMenuItemProps<T, D>): void;
+}
+type SlotUiProps = {
+    class: string;
+};
+export interface DropdownMenuSlots<T = string, D = never> {
+    trigger?: () => void;
+    content?: () => void;
+    item?: (props: {
+        item: DropdownMenuItemProps<T, D>;
+    }) => void;
+    'item-leading'?: (props: {
+        item: DropdownMenuItemProps<T, D>;
+        ui: SlotUiProps;
+    }) => void;
+    'item-label'?: (props: {
+        item: DropdownMenuItemProps<T, D>;
+        ui: SlotUiProps;
+    }) => void;
+    'item-trailing'?: (props: {
+        item: DropdownMenuItemProps<T, D>;
+        ui: SlotUiProps;
+    }) => void;
+    loading?: () => void;
+    empty?: () => void;
+    footer?: () => void;
+    'search-prefix'?: () => void;
+    'search-suffix'?: () => void;
+}
+export interface DropdownMenuItemSlots<T = string, D = never> {
+    'item-leading'?: (props: {
+        item: DropdownMenuItemProps<T, D>;
+        ui: SlotUiProps;
+    }) => void;
+    'item-label'?: (props: {
+        item: DropdownMenuItemProps<T, D>;
+        ui: SlotUiProps;
+    }) => void;
+    'item-trailing'?: (props: {
+        item: DropdownMenuItemProps<T, D>;
+        ui: SlotUiProps;
+    }) => void;
+}
+export {};

package/dist/components/N8nDropdownMenu/DropdownMenu.utils.d.ts

@@ -0,0 +1,10 @@
+import { DropdownMenuItemProps } from './DropdownMenu.types';
+export type NavigationDirection = 'up' | 'down';
+export type IndexDirection = 1 | -1;
+export declare function hasSubMenu<T, D>(item: DropdownMenuItemProps<T, D>): boolean;
+export declare function isNavigableItem<T, D>(item: DropdownMenuItemProps<T, D> | undefined): item is DropdownMenuItemProps<T, D>;
+export declare function getNextValidIndex<T, D>(items: Array<DropdownMenuItemProps<T, D>>, current: number, direction: IndexDirection): number;
+export declare function getItemDomId(instanceId: string, index: number): string;
+export declare function scrollHighlightedItemIntoView(container: HTMLElement | null): void;
+export declare function isInputCursorAtEnd(event: KeyboardEvent): boolean;
+export declare function isInputCursorAtStart(event: KeyboardEvent): boolean;

package/dist/components/N8nDropdownMenu/DropdownMenu.vue.d.ts

@@ -0,0 +1,23 @@
+import { DropdownMenuItemProps, DropdownMenuProps, DropdownMenuSlots } from './DropdownMenu.types';
+declare const _default: <T = string, D = never>(__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?: ((searchTerm: string, itemId?: T | undefined) => any) | undefined;
+        readonly onSelect?: ((value: T) => any) | undefined;
+        readonly "onUpdate:modelValue"?: ((open: boolean) => any) | undefined;
+        readonly "onSubmenu:toggle"?: ((itemId: T, open: boolean) => any) | undefined;
+        readonly "onItem-mouseup"?: ((item: DropdownMenuItemProps<T, D>) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onSelect" | "onUpdate:modelValue" | "onSearch" | "onSubmenu:toggle" | "onItem-mouseup"> & DropdownMenuProps<T, D> & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        open: () => void;
+        close: () => void;
+    }>): void;
+    attrs: any;
+    slots: Readonly<DropdownMenuSlots<T, D>> & DropdownMenuSlots<T, D>;
+    emit: ((evt: "search", searchTerm: string, itemId?: T | undefined) => void) & ((evt: "select", value: T) => void) & ((evt: "update:modelValue", open: boolean) => void) & ((evt: "submenu:toggle", itemId: T, open: boolean) => void) & ((evt: "item-mouseup", item: DropdownMenuItemProps<T, D>) => 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/N8nDropdownMenu/DropdownMenuItem.vue.d.ts

@@ -0,0 +1,23 @@
+import { DropdownMenuItemProps, DropdownMenuItemSlots } from './DropdownMenu.types';
+declare const _default: <T = string, D = never>(__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?: ((searchTerm: string, itemId: T) => any) | undefined;
+        readonly onSelect?: ((value: T) => any) | undefined;
+        readonly onPointermove?: ((event: PointerEvent) => any) | undefined;
+        readonly "onUpdate:subMenuOpen"?: ((open: boolean) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onSelect" | "onPointermove" | "onSearch" | "onUpdate:subMenuOpen"> & (DropdownMenuItemProps<T, D> & {
+        htmlId?: string;
+        disablePointerFocus?: boolean;
+        closeOnSelect?: boolean;
+    }) & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: Readonly<DropdownMenuItemSlots<T, D>> & DropdownMenuItemSlots<T, D>;
+    emit: ((evt: "search", searchTerm: string, itemId: T) => void) & ((evt: "select", value: T) => void) & ((evt: "pointermove", event: PointerEvent) => void) & ((evt: "update:subMenuOpen", 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/N8nDropdownMenu/DropdownMenuItems.vue.d.ts

@@ -0,0 +1,29 @@
+import { DropdownMenuItemProps, DropdownMenuSlots } from './DropdownMenu.types';
+declare const _default: <T = string, D = never>(__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?: ((searchTerm: string, itemId: T) => any) | undefined;
+        readonly onSelect?: ((value: T) => any) | undefined;
+        readonly "onSubmenu:toggle"?: ((index: number, open: boolean) => any) | undefined;
+        readonly "onItem-mouseup"?: ((item: DropdownMenuItemProps<T, D>) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onSelect" | "onSearch" | "onSubmenu:toggle" | "onItem-mouseup"> & {
+        items: Array<DropdownMenuItemProps<T, D>>;
+        loading?: boolean;
+        loadingItemCount?: number;
+        emptyText?: string;
+        highlightedIndex?: number;
+        openSubMenuIndex?: number;
+        getItemDomId?: (index: number) => string;
+        onItemHover?: (index: number) => void;
+        disablePointerFocus?: boolean;
+    } & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: Readonly<Pick<DropdownMenuSlots<T, D>, "loading" | "item" | "item-leading" | "item-label" | "item-trailing" | "empty">> & Pick<DropdownMenuSlots<T, D>, "loading" | "item" | "item-leading" | "item-label" | "item-trailing" | "empty">;
+    emit: ((evt: "search", searchTerm: string, itemId: T) => void) & ((evt: "select", value: T) => void) & ((evt: "submenu:toggle", index: number, open: boolean) => void) & ((evt: "item-mouseup", item: DropdownMenuItemProps<T, D>) => 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/N8nDropdownMenu/DropdownMenuSearch.vue.d.ts

@@ -0,0 +1,42 @@
+type __VLS_Props = {
+    modelValue?: string;
+    placeholder?: string;
+    ariaActiveDescendant?: string;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        'search-prefix'?: () => void;
+        'search-suffix'?: () => void;
+    }> & {
+        'search-prefix'?: () => void;
+        'search-suffix'?: () => void;
+    };
+    refs: {
+        inputRef: HTMLInputElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {
+    focus: (options?: FocusOptions) => void;
+    inputRef: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+    keydown: (event: KeyboardEvent) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+}>, {
+    placeholder: string;
+    modelValue: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    inputRef: HTMLInputElement;
+}, 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/N8nDropdownMenu/DropdownMenuSearchableContent.vue.d.ts

@@ -0,0 +1,44 @@
+import { DropdownMenuItemProps, DropdownMenuSlots } from './DropdownMenu.types';
+declare const _default: <T = string, D = never>(__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?: ((searchTerm: string, itemId?: T | undefined) => any) | undefined;
+        readonly onSelect?: ((value: T) => any) | undefined;
+        readonly onClose?: (() => any) | undefined;
+        readonly "onSubmenu:toggle"?: ((itemId: T, open: boolean) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onSelect" | "onClose" | "onSearch" | "onSubmenu:toggle"> & {
+        open: boolean;
+        items: Array<DropdownMenuItemProps<T, D>>;
+        searchPlaceholder?: string;
+        searchDebounce?: number;
+    } & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        resetNavigation: () => void;
+    }>): void;
+    attrs: any;
+    slots: Readonly<Pick<DropdownMenuSlots<T, D>, "search-prefix" | "search-suffix"> & {
+        default?: (props: {
+            highlightedIndex: number;
+            openSubMenuIndex: number;
+            onSubMenuOpenChange: (index: number, open: boolean) => void;
+            onItemHover: (index: number) => void;
+            resetNavigation: () => void;
+            getItemDomId: (index: number) => string;
+        }) => void;
+    }> & Pick<DropdownMenuSlots<T, D>, "search-prefix" | "search-suffix"> & {
+        default?: (props: {
+            highlightedIndex: number;
+            openSubMenuIndex: number;
+            onSubMenuOpenChange: (index: number, open: boolean) => void;
+            onItemHover: (index: number) => void;
+            resetNavigation: () => void;
+            getItemDomId: (index: number) => string;
+        }) => void;
+    };
+    emit: ((evt: "search", searchTerm: string, itemId?: T | undefined) => void) & ((evt: "select", value: T) => void) & ((evt: "close") => void) & ((evt: "submenu:toggle", itemId: T, 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/N8nDropdownMenu/composables/useDropdownSearch.d.ts

@@ -0,0 +1,16 @@
+import { MaybeRefOrGetter } from 'vue';
+import { DropdownMenuItemProps } from '../DropdownMenu.types';
+type SearchField = string | null | undefined;
+interface UseDropdownSearchOptions<T, D> {
+    flatList?: boolean;
+    searchFields?: (item: DropdownMenuItemProps<T, D>) => SearchField[];
+    isSearchable?: (item: DropdownMenuItemProps<T, D>) => boolean;
+    includeChildrenWhenParentMatches?: boolean;
+    mapResult?: (item: DropdownMenuItemProps<T, D>, path: Array<DropdownMenuItemProps<T, D>>) => DropdownMenuItemProps<T, D>;
+}
+export declare function useDropdownSearch<T = string, D = never>(items: MaybeRefOrGetter<Array<DropdownMenuItemProps<T, D>>>, options?: UseDropdownSearchOptions<T, D>): {
+    search: import('vue').Ref<string, string>;
+    filteredItems: import('vue').ComputedRef<DropdownMenuItemProps<T, D>[]>;
+    handleSearch: (query: string) => void;
+};
+export {};

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

@@ -0,0 +1,4 @@
+export { default as N8nDropdownMenu } from './DropdownMenu.vue';
+export { default as N8nDropdownMenuItem } from './DropdownMenuItem.vue';
+export { useDropdownSearch } from './composables/useDropdownSearch';
+export type { DropdownMenuProps, DropdownMenuItemProps, DropdownMenuSlots, DropdownMenuItemSlots, DropdownMenuEmits, DropdownMenuTrigger, DropdownMenuPlacement, } from './DropdownMenu.types';

package/dist/components/N8nEmptyState/EmptyState.vue.d.ts

@@ -0,0 +1,40 @@
+import { EmptyStateIconCards as EmptyStateIconCardsIcon } from './types';
+import { ButtonVariant } from '../../types/button';
+import { CalloutTheme } from '../N8nCallout';
+import { IconName } from '../N8nIcon/icons';
+import { IconOrEmoji } from '../N8nIconPicker/types';
+interface EmptyStateProps {
+    icon?: IconOrEmoji | EmptyStateIconCardsIcon;
+    heading?: string;
+    buttonText?: string;
+    buttonVariant?: ButtonVariant;
+    buttonDisabled?: boolean;
+    buttonIcon?: IconName;
+    description?: string;
+    calloutText?: string;
+    calloutTheme?: CalloutTheme;
+    calloutIcon?: IconName;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        heading?(_: {}): any;
+        description?(_: {}): any;
+        disabledButtonTooltip?(_: {}): any;
+        additionalContent?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<EmptyStateProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<EmptyStateProps> & Readonly<{}>, {
+    buttonIcon: IconName;
+    calloutTheme: CalloutTheme;
+}, {}, {}, {}, 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/N8nEmptyState/EmptyStateIconCards.vue.d.ts

@@ -0,0 +1,11 @@
+import { EmptyStateCardIcon } from './types';
+import { IconName } from '../N8nIcon/icons';
+interface EmptyStateIconCardsProps {
+    centerIcon: IconName | (string & {});
+    sideIcons: EmptyStateCardIcon[];
+    animated?: boolean;
+}
+declare const _default: import('vue').DefineComponent<EmptyStateIconCardsProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<EmptyStateIconCardsProps> & Readonly<{}>, {
+    animated: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,3 @@
+import { default as N8nEmptyState } from './EmptyState.vue';
+export type { EmptyStateCardIcon, EmptyStateIconCards } from './types';
+export default N8nEmptyState;

package/dist/components/N8nEmptyState/types.d.ts

@@ -0,0 +1,9 @@
+import { Component } from 'vue';
+import { IconName } from '../N8nIcon/icons';
+export type EmptyStateCardIcon = IconName | (string & {}) | Component;
+export interface EmptyStateIconCards {
+    type: 'cards';
+    center: IconName | (string & {});
+    sides: EmptyStateCardIcon[];
+    animated?: boolean;
+}

package/dist/components/N8nExternalLink/ExternalLink.vue.d.ts

@@ -0,0 +1,27 @@
+import { IconSize } from '../../types';
+interface ExternalLinkProps {
+    href?: string;
+    size?: IconSize;
+    newWindow?: 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<ExternalLinkProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ExternalLinkProps> & Readonly<{}>, {
+    size: IconSize;
+    href: string;
+    newWindow: 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/N8nExternalLink/index.d.ts

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

package/dist/components/N8nFloatingWindow/FloatingWindow.vue.d.ts

@@ -0,0 +1,75 @@
+export interface Props {
+    width?: number;
+    height?: number;
+    minWidth?: number;
+    minHeight?: number;
+    initialPosition?: {
+        x: number;
+        y: number;
+    };
+}
+declare function resetPosition(position: {
+    x: number;
+    y: number;
+}, size: {
+    width: number;
+    height: number;
+}): void;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        'header-icon': {};
+        header: {};
+        'header-actions': {};
+        default: {};
+    }> & {
+        'header-icon': {};
+        header: {};
+        'header-actions': {};
+        default: {};
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {
+    resetPosition: typeof resetPosition;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    resize: (args_0: {
+        width: number;
+        height: number;
+    }) => any;
+    close: () => any;
+    move: (args_0: {
+        x: number;
+        y: number;
+    }) => any;
+    "header-double-click": () => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onResize?: ((args_0: {
+        width: number;
+        height: number;
+    }) => any) | undefined;
+    onClose?: (() => any) | undefined;
+    onMove?: ((args_0: {
+        x: number;
+        y: number;
+    }) => any) | undefined;
+    "onHeader-double-click"?: (() => any) | undefined;
+}>, {
+    width: number;
+    height: number;
+    minHeight: number;
+    minWidth: number;
+    initialPosition: {
+        x: number;
+        y: number;
+    };
+}, {}, {}, {}, 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/N8nFloatingWindow/index.d.ts

@@ -0,0 +1,3 @@
+import { default as FloatingWindow } from './FloatingWindow.vue';
+export default FloatingWindow;
+export type { Props as FloatingWindowProps } from './FloatingWindow.vue';

package/dist/components/N8nFormBox/FormBox.vue.d.ts

@@ -0,0 +1,41 @@
+import { IFormInput, FormFieldValueUpdate, FormValues } from '../../types';
+interface FormBoxProps {
+    title?: string;
+    inputs?: IFormInput[];
+    buttonText?: string;
+    buttonLoading?: boolean;
+    secondaryButtonText?: string;
+    redirectText?: string;
+    redirectLink?: string;
+}
+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<FormBoxProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    submit: (value: FormValues) => any;
+    update: (value: FormFieldValueUpdate) => any;
+    secondaryClick: (value: Event) => any;
+}, string, import('vue').PublicProps, Readonly<FormBoxProps> & Readonly<{
+    onSubmit?: ((value: FormValues) => any) | undefined;
+    onUpdate?: ((value: FormFieldValueUpdate) => any) | undefined;
+    onSecondaryClick?: ((value: Event) => any) | undefined;
+}>, {
+    title: string;
+    inputs: IFormInput[];
+    buttonLoading: boolean;
+    redirectText: string;
+    redirectLink: string;
+}, {}, {}, {}, 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/N8nFormBox/index.d.ts

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