@n8n/design-system 2.33.4 → 2.34.0

package/dist/types/action-dropdown.d.ts

@@ -0,0 +1,18 @@
+import { KeyboardShortcut } from './keyboardshortcut';
+import { IconName } from '../components/N8nIcon/icons';
+export interface ActionDropdownItem<T extends string> {
+    id: T;
+    label: string;
+    testId?: string;
+    badge?: string;
+    description?: string;
+    badgeProps?: Record<string, unknown>;
+    icon?: IconName;
+    divided?: boolean;
+    disabled?: boolean;
+    shortcut?: KeyboardShortcut;
+    customClass?: string;
+    checked?: boolean;
+    variant?: 'default' | 'destructive';
+    children?: Array<ActionDropdownItem<T>>;
+}

package/dist/types/assistant.d.ts

@@ -0,0 +1,190 @@
+export declare namespace ChatUI {
+    export interface TextMessage {
+        id?: string;
+        role: 'assistant' | 'user';
+        type: 'text';
+        content: string;
+        codeSnippet?: string;
+        focusedNodeNames?: string[];
+        revertVersion?: {
+            id: string;
+            createdAt: string;
+        };
+    }
+    export interface TaskAbortedMessage extends Omit<TextMessage, 'role' | 'codeSnippet'> {
+        role: 'assistant';
+        aborted: true;
+    }
+    export interface SummaryBlock {
+        role: 'assistant';
+        type: 'block';
+        title: string;
+        content: string;
+    }
+    export interface CodeDiffMessage {
+        role: 'assistant';
+        type: 'code-diff';
+        description?: string;
+        codeDiff?: string;
+        replacing?: boolean;
+        replaced?: boolean;
+        error?: boolean;
+        suggestionId: string;
+        sdkSessionId?: string;
+        nodeName?: string;
+    }
+    export interface EndSessionMessage {
+        role: 'assistant';
+        type: 'event';
+        eventName: 'end-session';
+    }
+    export interface SessionTimeoutMessage {
+        role: 'assistant';
+        type: 'event';
+        eventName: 'session-timeout';
+    }
+    export interface SessionErrorMessage {
+        role: 'assistant';
+        type: 'event';
+        eventName: 'session-error';
+    }
+    export interface QuickReply {
+        type: string;
+        text: string;
+        isFeedback?: boolean;
+    }
+    export interface ErrorMessage {
+        id?: string;
+        role: 'assistant';
+        type: 'error';
+        content: string;
+        retry?: () => Promise<void>;
+    }
+    export interface AgentSuggestionMessage {
+        role: 'assistant';
+        type: 'agent-suggestion';
+        title: string;
+        content: string;
+        suggestionId: string;
+    }
+    export interface WorkflowUpdatedMessage {
+        role: 'assistant';
+        type: 'workflow-updated';
+        codeSnippet: string;
+    }
+    export interface ToolMessage {
+        id?: string;
+        role: 'assistant';
+        type: 'tool';
+        toolName: string;
+        toolCallId?: string;
+        displayTitle?: string;
+        customDisplayTitle?: string;
+        status: 'running' | 'completed' | 'error';
+        updates: Array<{
+            type: 'input' | 'output' | 'progress' | 'error';
+            data: Record<string, unknown>;
+            timestamp?: string;
+        }>;
+    }
+    export interface ThinkingItem {
+        id: string;
+        displayTitle: string;
+        status: 'pending' | 'running' | 'completed' | 'error';
+    }
+    export interface ThinkingGroupMessage {
+        id?: string;
+        role: 'assistant';
+        type: 'thinking-group';
+        items: ThinkingItem[];
+        latestStatusText: string;
+    }
+    export interface CustomMessage {
+        id?: string;
+        role: 'assistant' | 'user';
+        type: 'custom';
+        message?: string;
+        customType: string;
+        data: unknown;
+    }
+    type MessagesWithReplies = (TextMessage | CodeDiffMessage | SummaryBlock | AgentSuggestionMessage) & {
+        quickReplies?: QuickReply[];
+    };
+    export type AssistantMessage = (TextMessage | TaskAbortedMessage | MessagesWithReplies | ErrorMessage | EndSessionMessage | SessionTimeoutMessage | SessionErrorMessage | AgentSuggestionMessage | WorkflowUpdatedMessage | ToolMessage | ThinkingGroupMessage | CustomMessage) & {
+        id?: string;
+        read?: boolean;
+        showRating?: boolean;
+        ratingStyle?: 'regular' | 'minimal';
+        showFeedback?: boolean;
+    };
+    export {};
+}
+export type RatingFeedback = {
+    rating?: 'up' | 'down';
+    feedback?: string;
+};
+export declare function isTextMessage(msg: ChatUI.AssistantMessage): msg is ChatUI.TextMessage & {
+    id?: string;
+    read?: boolean;
+    quickReplies?: ChatUI.QuickReply[];
+};
+export declare function isTaskAbortedMessage(msg: ChatUI.AssistantMessage): msg is ChatUI.TaskAbortedMessage & {
+    id?: string;
+    read?: boolean;
+};
+export declare function isSummaryBlock(msg: ChatUI.AssistantMessage): msg is ChatUI.SummaryBlock & {
+    id?: string;
+    read?: boolean;
+    quickReplies?: ChatUI.QuickReply[];
+};
+export declare function isCodeDiffMessage(msg: ChatUI.AssistantMessage): msg is ChatUI.CodeDiffMessage & {
+    id?: string;
+    read?: boolean;
+    quickReplies?: ChatUI.QuickReply[];
+};
+export declare function isErrorMessage(msg: ChatUI.AssistantMessage): msg is ChatUI.ErrorMessage & {
+    id?: string;
+    read?: boolean;
+};
+export declare function isEndSessionMessage(msg: ChatUI.AssistantMessage): msg is ChatUI.EndSessionMessage & {
+    id?: string;
+    read?: boolean;
+};
+export declare function isSessionTimeoutMessage(msg: ChatUI.AssistantMessage): msg is ChatUI.SessionTimeoutMessage & {
+    id?: string;
+    read?: boolean;
+};
+export declare function isSessionErrorMessage(msg: ChatUI.AssistantMessage): msg is ChatUI.SessionErrorMessage & {
+    id?: string;
+    read?: boolean;
+};
+export declare function isAgentSuggestionMessage(msg: ChatUI.AssistantMessage): msg is ChatUI.AgentSuggestionMessage & {
+    id?: string;
+    read?: boolean;
+    quickReplies?: ChatUI.QuickReply[];
+};
+export declare function isWorkflowUpdatedMessage(msg: ChatUI.AssistantMessage): msg is ChatUI.WorkflowUpdatedMessage & {
+    id?: string;
+    read?: boolean;
+};
+export declare function isToolMessage(msg: ChatUI.AssistantMessage): msg is ChatUI.ToolMessage & {
+    id?: string;
+    read?: boolean;
+};
+export declare function isCustomMessage(msg: ChatUI.AssistantMessage): msg is ChatUI.CustomMessage & {
+    id?: string;
+    read?: boolean;
+};
+export declare function isThinkingGroupMessage(msg: ChatUI.AssistantMessage): msg is ChatUI.ThinkingGroupMessage & {
+    id?: string;
+    read?: boolean;
+};
+export declare function hasRequiredProps<T extends ChatUI.AssistantMessage>(msg: T): msg is T & {
+    id: string;
+    read: boolean;
+};
+export interface WorkflowSuggestion {
+    id: string;
+    summary: string;
+    prompt: string;
+}

package/dist/types/badge.d.ts

@@ -0,0 +1,3 @@
+declare const BADGE_THEME: readonly ["default", "success", "warning", "danger", "primary", "secondary", "tertiary"];
+export type BadgeTheme = (typeof BADGE_THEME)[number];
+export {};

package/dist/types/binary.d.ts

@@ -0,0 +1,8 @@
+declare const BINARY_METADATA_KEYS: readonly ["data", "mimeType", "fileType", "fileName", "directory", "fileExtension", "fileSize", "id", "bytes"];
+export type BinaryMetadata = {
+    [K in (typeof BINARY_METADATA_KEYS)[number] as K extends 'mimeType' | 'id' | 'data' ? K : never]: K extends 'mimeType' | 'id' | 'data' ? string : never;
+} & {
+    [K in Exclude<(typeof BINARY_METADATA_KEYS)[number], 'mimeType' | 'id' | 'data'>]?: K extends 'bytes' ? number : string;
+};
+export declare const isBinary: (obj: unknown) => obj is BinaryMetadata;
+export {};

package/dist/types/button.d.ts

@@ -0,0 +1,30 @@
+import { ClassValue } from 'clsx';
+import { IconSize } from './icon';
+import { IconName } from '../components/N8nIcon/icons';
+declare const BUTTON_VARIANT: readonly ["solid", "subtle", "ghost", "outline", "destructive", "success"];
+export type ButtonVariant = (typeof BUTTON_VARIANT)[number];
+export type LegacyButtonVariant = 'highlight' | 'highlight-fill';
+declare const BUTTON_SIZE: readonly ["mini", "xmini", "small", "medium", "large", "xlarge", "xsmall"];
+export type ButtonSize = (typeof BUTTON_SIZE)[number];
+export interface ButtonProps {
+    variant?: ButtonVariant | LegacyButtonVariant;
+    size?: ButtonSize;
+    href?: string;
+    loading?: boolean;
+    iconOnly?: boolean;
+    disabled?: boolean;
+    class?: ClassValue;
+    icon?: IconName;
+    iconSize?: IconSize;
+    label?: string;
+}
+export interface IconButtonProps extends ButtonProps {
+    icon: IconName;
+}
+export type IN8nButton = {
+    attrs: ButtonProps & {
+        'data-test-id'?: string;
+    };
+    listeners?: Record<string, (event: Event) => void>;
+};
+export {};

package/dist/types/callout.d.ts

@@ -0,0 +1,3 @@
+declare const CALLOUT_THEMES: readonly ["info", "success", "secondary", "warning", "danger", "custom"];
+export type CalloutTheme = (typeof CALLOUT_THEMES)[number];
+export {};

package/dist/types/datatable.d.ts

@@ -0,0 +1,14 @@
+import { Component, VNode } from 'vue';
+export type DatatableRowDataType = string | number | boolean | null | undefined;
+export interface DatatableRow {
+    id: string | number;
+    [key: string]: unknown;
+}
+export interface DatatableColumn {
+    id: string | number;
+    path: string;
+    label: string;
+    classes?: string[];
+    width?: string;
+    render?: Component | ((row: DatatableRow) => (() => VNode | VNode[]) | DatatableRowDataType);
+}

package/dist/types/form.d.ts

@@ -0,0 +1,87 @@
+import { N8nLocaleTranslateFnOptions } from './i18n';
+export type FormFieldValue = string | number | boolean | null | undefined;
+export type FormInputsToFormValues<T extends IFormInput[], V> = {
+    [K in T[number]['name']]: V;
+};
+export type FormFieldValueUpdate<Metadata = Record<string, unknown>> = {
+    name: string;
+    value: FormFieldValue;
+    metadata?: Metadata;
+};
+export type Rule = {
+    name: string;
+    config?: unknown;
+};
+export type RuleGroup = {
+    rules: Array<Rule | RuleGroup>;
+    defaultError?: {
+        messageKey: string;
+        options?: N8nLocaleTranslateFnOptions;
+    };
+};
+export type Validatable = string | number | boolean | null | undefined;
+export type IValidator<T = unknown> = {
+    validate: (value: Validatable, config: T) => false | {
+        message: string;
+        options?: N8nLocaleTranslateFnOptions;
+    } | {
+        messageKey: string;
+        options?: N8nLocaleTranslateFnOptions;
+    } | null;
+};
+export type FormState = {
+    isTyping: boolean;
+    hasBlutted: boolean;
+};
+export type IFormInput<Metadata = Record<string, unknown>> = {
+    name: string;
+    initialValue?: string | number | boolean | null;
+    metadata?: Metadata;
+    properties: {
+        label?: string;
+        type?: 'text' | 'email' | 'password' | 'select' | 'multi-select' | 'number' | 'info' | 'checkbox' | 'toggle';
+        maxlength?: number;
+        required?: boolean;
+        showRequiredAsterisk?: boolean;
+        validators?: {
+            [name: string]: IValidator;
+        };
+        validationRules?: Array<Rule | RuleGroup>;
+        validateOnBlur?: boolean;
+        infoText?: string;
+        placeholder?: string;
+        options?: Array<{
+            label: string;
+            value: string;
+            disabled?: boolean;
+        }>;
+        autocomplete?: InputAutocompletePropType;
+        capitalize?: boolean;
+        focusInitially?: boolean;
+        disabled?: boolean;
+        labelSize?: 'small' | 'medium' | 'large';
+        tagSize?: 'small' | 'medium' | 'large';
+        labelAlignment?: 'left' | 'right' | 'center';
+        tooltipText?: string;
+    };
+    shouldDisplay?: (values: {
+        [key: string]: unknown;
+    }) => boolean;
+};
+export type IFormInputs = IFormInput[];
+export type FormValues = FormInputsToFormValues<IFormInput[], FormFieldValue>;
+export type IFormBoxConfig = {
+    title: string;
+    buttonText?: string;
+    secondaryButtonText?: string;
+    inputs: IFormInputs;
+    redirectLink?: string;
+    redirectText?: string;
+};
+export type CheckboxLabelSizePropType = 'small' | 'medium' | undefined;
+export type CheckboxModelValuePropType = boolean | undefined;
+export type SwitchModelValuePropType = boolean | undefined;
+export type InputModelValuePropType = string | number | null | undefined;
+export type InputTypePropType = 'text' | 'email' | 'password' | 'textarea' | 'number' | undefined;
+export type InputAutocompletePropType = 'off' | 'new-password' | 'current-password' | 'given-name' | 'family-name' | 'one-time-code' | 'email';
+export type ElementPlusSizePropType = '' | 'small' | 'large' | 'default' | undefined;

package/dist/types/i18n.d.ts

@@ -0,0 +1,3 @@
+export type N8nLocaleTranslateFnOptions = string[] | Record<string, unknown>;
+export type N8nLocaleTranslateFn = (path: string, options?: N8nLocaleTranslateFnOptions) => string;
+export type N8nLocale = Record<string, string | ((...args: unknown[]) => string)>;

package/dist/types/icon.d.ts

@@ -0,0 +1,7 @@
+import { TextColor } from './text';
+declare const ICON_SIZE: readonly ["xsmall", "small", "medium", "large", "xlarge", "xxlarge"];
+export type IconSize = (typeof ICON_SIZE)[number];
+export type IconColor = TextColor;
+declare const ICON_ORIENTATION: readonly ["horizontal", "vertical"];
+export type IconOrientation = (typeof ICON_ORIENTATION)[number];
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,20 @@
+export type * from './action-dropdown';
+export * from './assistant';
+export type * from './badge';
+export type * from './button';
+export type * from './callout';
+export type * from './datatable';
+export type * from './form';
+export type * from './i18n';
+export type * from './icon';
+export type * from './input';
+export type * from './keyboardshortcut';
+export * from './menu';
+export type * from './node-creator-node';
+export type * from './recycle-scroller';
+export * from './resize';
+export type * from './select';
+export type * from './tabs';
+export type * from './text';
+export type * from './user';
+export * from './binary';

package/dist/types/input.d.ts

@@ -0,0 +1,5 @@
+declare const INPUT_TYPES: readonly ["text", "textarea", "number", "password", "email", "url"];
+declare const INPUT_SIZES: readonly ["mini", "small", "medium", "large", "xlarge"];
+export type InputType = (typeof INPUT_TYPES)[number];
+export type InputSize = (typeof INPUT_SIZES)[number];
+export {};

package/dist/types/keyboardshortcut.d.ts

@@ -0,0 +1,6 @@
+export interface KeyboardShortcut {
+    metaKey?: boolean;
+    altKey?: boolean;
+    shiftKey?: boolean;
+    keys: string[];
+}

package/dist/types/menu.d.ts

@@ -0,0 +1,56 @@
+import { ElTooltipProps } from 'element-plus';
+import { AnchorHTMLAttributes, Component } from 'vue';
+import { RouteLocationRaw, RouterLinkProps } from 'vue-router';
+import { IconColor } from './icon';
+import { IconName } from '../components/N8nIcon/icons';
+export type IMenuItem = {
+    id: string;
+    label: string;
+    icon?: IconName | (string & {}) | {
+        type: 'icon';
+        value: IconName | (string & {});
+        color?: IconColor | (string & {});
+    } | {
+        type: 'emoji';
+        value: string;
+        color?: IconColor | (string & {});
+    };
+    secondaryIcon?: {
+        name: IconName;
+        size?: 'xsmall' | 'small' | 'medium' | 'large';
+        tooltip?: Partial<ElTooltipProps>;
+    };
+    customIconSize?: 'medium' | 'small';
+    available?: boolean;
+    position?: 'top' | 'bottom';
+    link?: ILinkMenuItemProperties;
+    route?: RouterLinkProps;
+    activateOnRouteNames?: string[];
+    activateOnRoutePaths?: string[];
+    children?: IMenuElement[];
+    isLoading?: boolean;
+    disabled?: boolean;
+    disabledReason?: string;
+    notification?: boolean;
+    size?: 'medium' | 'small';
+    preview?: boolean;
+    new?: boolean;
+    creditsTag?: string;
+};
+export interface ICustomMenuItem {
+    id: string;
+    component: Component;
+    props?: Record<string, unknown>;
+    available?: boolean;
+    position?: 'top' | 'bottom';
+}
+export type IMenuElement = IMenuItem | ICustomMenuItem;
+export declare const isCustomMenuItem: (e: IMenuElement) => e is ICustomMenuItem;
+export type IRouteMenuItemProperties = {
+    route: RouteLocationRaw;
+};
+export type ILinkMenuItemProperties = {
+    href: string;
+    target?: AnchorHTMLAttributes['target'];
+    rel?: AnchorHTMLAttributes['rel'];
+};

package/dist/types/node-creator-node.d.ts

@@ -0,0 +1,7 @@
+import { ElTag } from 'element-plus';
+export type NodeCreatorTag = {
+    text: string;
+    type?: (typeof ElTag)['type'];
+    pill?: boolean;
+    preview?: boolean;
+};

package/dist/types/recycle-scroller.d.ts

@@ -0,0 +1,5 @@
+export type ItemWithKey<Key extends string> = {
+    [K in Key]: string;
+} & {
+    [key: string]: unknown;
+};

package/dist/types/resize.d.ts

@@ -0,0 +1,20 @@
+export declare const directionsCursorMaps: {
+    readonly right: "ew-resize";
+    readonly top: "ns-resize";
+    readonly bottom: "ns-resize";
+    readonly left: "ew-resize";
+    readonly topLeft: "nw-resize";
+    readonly topRight: "ne-resize";
+    readonly bottomLeft: "sw-resize";
+    readonly bottomRight: "se-resize";
+};
+export type Direction = keyof typeof directionsCursorMaps;
+export interface ResizeData {
+    height: number;
+    width: number;
+    dX: number;
+    dY: number;
+    x: number;
+    y: number;
+    direction: Direction;
+}

package/dist/types/select.d.ts

@@ -0,0 +1,3 @@
+declare const SELECT_SIZES: readonly ["mini", "small", "medium", "large", "xlarge"];
+export type SelectSize = (typeof SELECT_SIZES)[number];
+export {};

package/dist/types/tabs.d.ts

@@ -0,0 +1,17 @@
+import { RouteLocationRaw } from 'vue-router';
+import { IconName } from '../components/N8nIcon/icons';
+export interface TabOptions<Value extends string | number> {
+    value: Value;
+    label?: string;
+    icon?: IconName;
+    iconPosition?: 'left' | 'right';
+    variant?: 'default' | 'danger';
+    href?: string;
+    disabled?: boolean;
+    tooltip?: string;
+    align?: 'left' | 'right';
+    to?: RouteLocationRaw;
+    notification?: boolean;
+    tag?: string;
+    preview?: boolean;
+}

package/dist/types/text.d.ts

@@ -0,0 +1,11 @@
+declare const TEXT_SIZE: readonly ["xsmall", "small", "mini", "medium", "large", "xlarge"];
+export type TextSize = (typeof TEXT_SIZE)[number];
+declare const TEXT_STEP: readonly ["4xs", "3xs", "2xs", "xs", "sm", "md", "lg", "xl", "2xl"];
+export type TextStep = (typeof TEXT_STEP)[number];
+declare const TEXT_COLOR: readonly ["primary", "secondary", "text-dark", "text-base", "text-light", "text-xlight", "danger", "success", "warning", "foreground-dark", "foreground-xdark"];
+export type TextColor = (typeof TEXT_COLOR)[number];
+declare const TEXT_ALIGN: readonly ["right", "left", "center"];
+export type TextAlign = (typeof TEXT_ALIGN)[number];
+declare const TEXT_FLOAT: readonly ["left", "right"];
+export type TextFloat = (typeof TEXT_FLOAT)[number];
+export {};

package/dist/types/user.d.ts

@@ -0,0 +1,25 @@
+export type IUser = {
+    id: string;
+    firstName?: string | null;
+    lastName?: string | null;
+    fullName?: string;
+    role?: string;
+    email?: string | null;
+    signInType?: string;
+    isOwner?: boolean;
+    isPendingUser?: boolean;
+    inviteAcceptUrl?: string;
+    disabled?: boolean;
+    mfaEnabled?: boolean;
+};
+export interface UserAction<UserType extends IUser> {
+    label: string;
+    value: string;
+    disabled?: boolean;
+    type?: 'external-link';
+    tooltip?: string;
+    guard?: (user: UserType) => boolean;
+}
+export type UserStackGroups = {
+    [groupName: string]: IUser[];
+};

package/dist/utils/cn.d.ts

@@ -0,0 +1,2 @@
+import { ClassValue } from 'clsx';
+export declare function cn(...inputs: ClassValue[]): string;

package/dist/utils/colorUtils.d.ts

@@ -0,0 +1,3 @@
+export declare function isValidHexColor(color: string): boolean;
+export declare function getContrastTextColor(bgHex: string): string;
+export declare function adjustColorLightness(hexColor: string, percent: number): string;

package/dist/utils/form-event-bus.d.ts

@@ -0,0 +1,5 @@
+export interface FormEventBusEvents {
+    submit: never;
+}
+export type FormEventBus = ReturnType<typeof createFormEventBus>;
+export declare const createFormEventBus: () => import('@n8n/utils/event-bus').EventBus<FormEventBusEvents>;

package/dist/utils/index.d.ts

@@ -0,0 +1,7 @@
+export * from './colorUtils';
+export * from './form-event-bus';
+export * from './markdown';
+export * from './typeguards';
+export * from './uid';
+export * from './valueByPath';
+export * from './testUtils';

package/dist/utils/labelUtil.d.ts

@@ -0,0 +1 @@
+export declare const getInitials: (label: string) => string;

package/dist/utils/markdown.d.ts

@@ -0,0 +1,2 @@
+export declare const toggleCheckbox: (markdown: string, index: number) => string;
+export declare function serializeAttr(tag: string, name: string, value: string): string;

package/dist/utils/testUtils.d.ts

@@ -0,0 +1 @@
+export declare function removeDynamicAttributes(container: Element): void;

package/dist/utils/typeguards.d.ts

@@ -0,0 +1 @@
+export declare function isEventBindingElementAttribute(_attributeValue: unknown, attributeName: string): _attributeValue is (...args: unknown[]) => {};

package/dist/utils/uid.d.ts

@@ -0,0 +1 @@
+export declare function uid(baseId?: string): string;

package/dist/utils/valueByPath.d.ts

@@ -0,0 +1 @@
+export declare function getValueByPath<T = any>(object: any, path: string): T;

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

@@ -0,0 +1,13 @@
+import { CheckboxRootProps } from 'reka-ui';
+export type CheckboxProps = Pick<CheckboxRootProps, 'disabled' | 'required' | 'name' | 'value' | 'id' | 'defaultValue' | 'as'> & {
+    label?: string;
+    indeterminate?: boolean;
+};
+export type CheckboxSlots = {
+    label(props: {
+        label?: string;
+    }): unknown;
+};
+export type CheckboxEmits = {
+    change: [event: Event];
+};

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

@@ -0,0 +1,26 @@
+import { CheckboxProps, CheckboxSlots } from './Checkbox.types';
+type __VLS_Props = CheckboxProps;
+type __VLS_PublicProps = {
+    modelValue?: boolean;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<CheckboxSlots> & CheckboxSlots;
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+    change: (event: Event) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    onChange?: ((event: Event) => any) | undefined;
+}>, {}, {}, {}, {}, 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;
+    };
+};