@n8n/design-system 2.33.4 → 2.34.0

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

@@ -0,0 +1,301 @@
+import { PropType } from 'vue';
+import { InnerSelectRef } from './Select.types';
+import { SelectSize } from '../../types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default?: () => unknown;
+        prepend?: () => unknown;
+        prefix?: () => unknown;
+        suffix?: () => unknown;
+        footer?: () => unknown;
+        empty?: () => unknown;
+    }> & {
+        default?: () => unknown;
+        prepend?: () => unknown;
+        prefix?: () => unknown;
+        suffix?: () => unknown;
+        footer?: () => unknown;
+        empty?: () => unknown;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    modelValue: {};
+    size: {
+        type: PropType<SelectSize>;
+        default: string;
+    };
+    placeholder: {
+        type: StringConstructor;
+    };
+    disabled: {
+        type: BooleanConstructor;
+    };
+    filterable: {
+        type: BooleanConstructor;
+    };
+    defaultFirstOption: {
+        type: BooleanConstructor;
+    };
+    multiple: {
+        type: BooleanConstructor;
+    };
+    multipleLimit: {
+        type: NumberConstructor;
+        default: number;
+    };
+    filterMethod: {
+        type: FunctionConstructor;
+    };
+    loading: {
+        type: BooleanConstructor;
+    };
+    loadingText: {
+        type: StringConstructor;
+    };
+    popperClass: {
+        type: StringConstructor;
+    };
+    popperAppendToBody: {
+        type: BooleanConstructor;
+    };
+    limitPopperWidth: {
+        type: BooleanConstructor;
+    };
+    noDataText: {
+        type: StringConstructor;
+    };
+    id: {
+        type: PropType<string | undefined>;
+    };
+    name: {
+        type: PropType<string | undefined>;
+    };
+    persistent: {
+        type: PropType<boolean | undefined>;
+    };
+    ariaLabel: {
+        type: PropType<string | undefined>;
+    };
+    teleported: {
+        type: PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined>;
+    };
+    effect: {
+        type: PropType<string | undefined>;
+    };
+    placement: {
+        type: PropType<string | undefined>;
+    };
+    popperOptions: {
+        type: PropType<any>;
+    };
+    clearable: {
+        type: PropType<boolean | undefined>;
+    };
+    autocomplete: {
+        type: PropType<string | undefined>;
+    };
+    validateEvent: {
+        type: PropType<boolean | undefined>;
+    };
+    automaticDropdown: {
+        type: PropType<boolean | undefined>;
+    };
+    allowCreate: {
+        type: PropType<boolean | undefined>;
+    };
+    remote: {
+        type: PropType<boolean | undefined>;
+    };
+    noMatchText: {
+        type: PropType<string | undefined>;
+    };
+    remoteMethod: {
+        type: PropType<Function | undefined>;
+    };
+    reserveKeyword: {
+        type: PropType<boolean | undefined>;
+    };
+    valueKey: {
+        type: PropType<string | undefined>;
+    };
+    collapseTags: {
+        type: PropType<boolean | undefined>;
+    };
+    collapseTagsTooltip: {
+        type: PropType<boolean | undefined>;
+    };
+    maxCollapseTags: {
+        type: PropType<number | undefined>;
+    };
+    clearIcon: {
+        type: PropType<string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions, {}, any> | undefined>;
+    };
+    fitInputWidth: {
+        type: PropType<boolean | undefined>;
+    };
+    suffixIcon: {
+        type: PropType<string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions, {}, any> | undefined>;
+    };
+    tagType: {
+        type: PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<StringConstructor, "" | "info" | "success" | "warning" | "danger", unknown> | undefined>;
+    };
+    remoteShowSuffix: {
+        type: PropType<boolean | undefined>;
+    };
+    suffixTransition: {
+        type: PropType<boolean | undefined>;
+    };
+}>, {
+    focus: () => void;
+    blur: () => void;
+    focusOnInput: () => void;
+    innerSelect: InnerSelectRef | null;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    modelValue: {};
+    size: {
+        type: PropType<SelectSize>;
+        default: string;
+    };
+    placeholder: {
+        type: StringConstructor;
+    };
+    disabled: {
+        type: BooleanConstructor;
+    };
+    filterable: {
+        type: BooleanConstructor;
+    };
+    defaultFirstOption: {
+        type: BooleanConstructor;
+    };
+    multiple: {
+        type: BooleanConstructor;
+    };
+    multipleLimit: {
+        type: NumberConstructor;
+        default: number;
+    };
+    filterMethod: {
+        type: FunctionConstructor;
+    };
+    loading: {
+        type: BooleanConstructor;
+    };
+    loadingText: {
+        type: StringConstructor;
+    };
+    popperClass: {
+        type: StringConstructor;
+    };
+    popperAppendToBody: {
+        type: BooleanConstructor;
+    };
+    limitPopperWidth: {
+        type: BooleanConstructor;
+    };
+    noDataText: {
+        type: StringConstructor;
+    };
+    id: {
+        type: PropType<string | undefined>;
+    };
+    name: {
+        type: PropType<string | undefined>;
+    };
+    persistent: {
+        type: PropType<boolean | undefined>;
+    };
+    ariaLabel: {
+        type: PropType<string | undefined>;
+    };
+    teleported: {
+        type: PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined>;
+    };
+    effect: {
+        type: PropType<string | undefined>;
+    };
+    placement: {
+        type: PropType<string | undefined>;
+    };
+    popperOptions: {
+        type: PropType<any>;
+    };
+    clearable: {
+        type: PropType<boolean | undefined>;
+    };
+    autocomplete: {
+        type: PropType<string | undefined>;
+    };
+    validateEvent: {
+        type: PropType<boolean | undefined>;
+    };
+    automaticDropdown: {
+        type: PropType<boolean | undefined>;
+    };
+    allowCreate: {
+        type: PropType<boolean | undefined>;
+    };
+    remote: {
+        type: PropType<boolean | undefined>;
+    };
+    noMatchText: {
+        type: PropType<string | undefined>;
+    };
+    remoteMethod: {
+        type: PropType<Function | undefined>;
+    };
+    reserveKeyword: {
+        type: PropType<boolean | undefined>;
+    };
+    valueKey: {
+        type: PropType<string | undefined>;
+    };
+    collapseTags: {
+        type: PropType<boolean | undefined>;
+    };
+    collapseTagsTooltip: {
+        type: PropType<boolean | undefined>;
+    };
+    maxCollapseTags: {
+        type: PropType<number | undefined>;
+    };
+    clearIcon: {
+        type: PropType<string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions, {}, any> | undefined>;
+    };
+    fitInputWidth: {
+        type: PropType<boolean | undefined>;
+    };
+    suffixIcon: {
+        type: PropType<string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions, {}, any> | undefined>;
+    };
+    tagType: {
+        type: PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<StringConstructor, "" | "info" | "success" | "warning" | "danger", unknown> | undefined>;
+    };
+    remoteShowSuffix: {
+        type: PropType<boolean | undefined>;
+    };
+    suffixTransition: {
+        type: PropType<boolean | undefined>;
+    };
+}>> & Readonly<{}>, {
+    disabled: boolean;
+    size: "small" | "mini" | "medium" | "large" | "xlarge";
+    loading: boolean;
+    filterable: boolean;
+    multiple: boolean;
+    multipleLimit: number;
+    defaultFirstOption: boolean;
+    popperAppendToBody: boolean;
+    limitPopperWidth: boolean;
+}, {}, {}, {}, 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/N8nSelect/index.d.ts

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

package/dist/components/N8nSelectableList/SelectableList.vue.d.ts

@@ -0,0 +1,30 @@
+declare const _default: <Value, Item extends {
+    name: string;
+    initialValue: Value;
+}>(__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: Record<string, Value>) => any) | undefined;
+        readonly onRemoveItem?: ((name: string) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:modelValue" | "onRemoveItem"> & ({
+        modelValue: Record<string, Value>;
+    } & {
+        inputs: Item[];
+        disabled?: boolean;
+    }) & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: Readonly<{
+        addItem: (props: Item) => unknown;
+        displayItem: (props: Item) => unknown;
+    }> & {
+        addItem: (props: Item) => unknown;
+        displayItem: (props: Item) => unknown;
+    };
+    emit: ((evt: "removeItem", name: string) => void) & ((evt: "update:modelValue", value: Record<string, Value>) => 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/N8nSelectableList/index.d.ts

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

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

@@ -0,0 +1,23 @@
+export interface N8nSendStopButtonProps {
+    streaming?: boolean;
+    disabled?: boolean;
+    size?: 'mini' | 'small' | 'medium' | 'large';
+    label?: string;
+    sendButtonTestId?: string;
+    stopButtonTestId?: string;
+}
+declare const _default: import('vue').DefineComponent<N8nSendStopButtonProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    send: () => any;
+    stop: () => any;
+}, string, import('vue').PublicProps, Readonly<N8nSendStopButtonProps> & Readonly<{
+    onSend?: (() => any) | undefined;
+    onStop?: (() => any) | undefined;
+}>, {
+    disabled: boolean;
+    size: "mini" | "small" | "medium" | "large";
+    label: string;
+    streaming: boolean;
+    sendButtonTestId: string;
+    stopButtonTestId: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

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

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

package/dist/components/N8nSettingsLayout/SettingsLayout.vue.d.ts

@@ -0,0 +1,33 @@
+export interface SettingsLayoutProps {
+    tag?: string;
+    showBack?: boolean;
+    backLabel?: string;
+    fullWidth?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        back?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<SettingsLayoutProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    back: () => any;
+}, string, import('vue').PublicProps, Readonly<SettingsLayoutProps> & Readonly<{
+    onBack?: (() => any) | undefined;
+}>, {
+    tag: string;
+    showBack: boolean;
+    backLabel: string;
+    fullWidth: 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/N8nSettingsLayout/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './SettingsLayout.vue';
+export type { SettingsLayoutProps } from './SettingsLayout.vue';

package/dist/components/N8nSettingsPageHeader/SettingsPageHeader.vue.d.ts

@@ -0,0 +1,34 @@
+export interface SettingsPageHeaderProps {
+    title: string;
+    description?: string;
+    showDocsLink?: boolean;
+    docsUrl?: string;
+    docsLabel?: string;
+    docsLeadingText?: string;
+    headingTag?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        titleTrailing?(_: {}): any;
+        description?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<SettingsPageHeaderProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SettingsPageHeaderProps> & Readonly<{}>, {
+    description: string;
+    showDocsLink: boolean;
+    docsUrl: string;
+    docsLabel: string;
+    docsLeadingText: string;
+    headingTag: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLElement>;
+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/N8nSettingsPageHeader/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './SettingsPageHeader.vue';
+export type { SettingsPageHeaderProps } from './SettingsPageHeader.vue';

package/dist/components/N8nSettingsRow/SettingsRow.vue.d.ts

@@ -0,0 +1,197 @@
+export type SettingsRowLayout = 'horizontal' | 'vertical' | 'custom';
+export interface SettingsRowProps {
+    title?: string;
+    description?: string;
+    layout?: SettingsRowLayout;
+    maxDescriptionLines?: number;
+    truncateTitle?: boolean;
+    actionMaxWidth?: string | false;
+    actionFill?: boolean;
+    showDivider?: boolean;
+    showVisual?: boolean;
+    expandable?: boolean;
+    disclosure?: boolean;
+    expandLabel?: string;
+    collapseLabel?: string;
+    hoverable?: boolean;
+    clickable?: boolean;
+    revealActionsOnHover?: boolean;
+}
+type __VLS_Props = SettingsRowProps;
+type __VLS_PublicProps = {
+    modelValue?: boolean;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default?: () => unknown;
+        visual?: () => unknown;
+        info?: () => unknown;
+        action?: () => unknown;
+        expanded?: () => unknown;
+    }> & {
+        default?: () => unknown;
+        visual?: () => unknown;
+        info?: () => unknown;
+        action?: () => unknown;
+        expanded?: () => unknown;
+    };
+    refs: {
+        descriptionRef: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly bold?: boolean | undefined;
+                readonly size?: import('../..').TextSize | undefined;
+                readonly step?: import('../..').TextStep | undefined;
+                readonly color?: import('../..').TextColor | undefined;
+                readonly align?: import('../..').TextAlign | undefined;
+                readonly compact?: boolean | undefined;
+                readonly tag?: string | 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('../N8nText/Text.vue').TextProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                bold: boolean;
+                size: import('../..').TextSize;
+                compact: boolean;
+                tag: string;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof 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<{
+            bold: boolean;
+            size: import('../..').TextSize;
+            compact: boolean;
+            tag: string;
+        }> & Omit<Readonly<import('../N8nText/Text.vue').TextProps> & Readonly<{}>, "bold" | "size" | "compact" | "tag"> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                default?(_: {}): any;
+            };
+        }) | null;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (event: MouseEvent | KeyboardEvent) => any;
+    "update:modelValue": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onClick?: ((event: MouseEvent | KeyboardEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {
+    title: string;
+    description: string;
+    hoverable: boolean;
+    layout: SettingsRowLayout;
+    clickable: boolean;
+    maxDescriptionLines: number;
+    truncateTitle: boolean;
+    actionMaxWidth: string | false;
+    actionFill: boolean;
+    showDivider: boolean;
+    showVisual: boolean;
+    expandable: boolean;
+    disclosure: boolean;
+    expandLabel: string;
+    collapseLabel: string;
+    revealActionsOnHover: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    descriptionRef: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly bold?: boolean | undefined;
+            readonly size?: import('../..').TextSize | undefined;
+            readonly step?: import('../..').TextStep | undefined;
+            readonly color?: import('../..').TextColor | undefined;
+            readonly align?: import('../..').TextAlign | undefined;
+            readonly compact?: boolean | undefined;
+            readonly tag?: string | 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('../N8nText/Text.vue').TextProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+            bold: boolean;
+            size: import('../..').TextSize;
+            compact: boolean;
+            tag: string;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof 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<{
+        bold: boolean;
+        size: import('../..').TextSize;
+        compact: boolean;
+        tag: string;
+    }> & Omit<Readonly<import('../N8nText/Text.vue').TextProps> & Readonly<{}>, "bold" | "size" | "compact" | "tag"> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            default?(_: {}): any;
+        };
+    }) | null;
+}, 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/N8nSettingsRow/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './SettingsRow.vue';
+export type { SettingsRowProps, SettingsRowLayout } from './SettingsRow.vue';

package/dist/components/N8nSettingsRowConfigure/SettingsRowConfigure.vue.d.ts

@@ -0,0 +1,7 @@
+export interface SettingsRowConfigureProps {
+    value?: string;
+}
+declare const _default: import('vue').DefineComponent<SettingsRowConfigureProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SettingsRowConfigureProps> & Readonly<{}>, {
+    value: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLSpanElement>;
+export default _default;

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

@@ -0,0 +1,2 @@
+export { default } from './SettingsRowConfigure.vue';
+export type { SettingsRowConfigureProps } from './SettingsRowConfigure.vue';

package/dist/components/N8nSettingsRowGroup/SettingsRowGroup.vue.d.ts

@@ -0,0 +1,22 @@
+export interface SettingsRowGroupProps {
+    tag?: string;
+}
+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<SettingsRowGroupProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SettingsRowGroupProps> & Readonly<{}>, {
+    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;
+    };
+};