@codemonster-ru/vueforge 0.93.0 → 0.95.0

package/dist/package/components/diff-viewer.vue.d.ts

@@ -0,0 +1,45 @@
+type DiffMode = 'inline' | 'split';
+type DiffFormat = 'auto' | 'text' | 'json';
+interface Props {
+    before?: unknown;
+    after?: unknown;
+    mode?: DiffMode;
+    format?: DiffFormat;
+    showToolbar?: boolean;
+    copyable?: boolean;
+    disabled?: boolean;
+    ariaLabel?: string;
+    emptyText?: string;
+    inlineLabel?: string;
+    splitLabel?: string;
+    beforeLabel?: string;
+    afterLabel?: string;
+    copyLabel?: string;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    copy: (payload: {
+        text: string;
+    }) => any;
+    "update:mode": (value: DiffMode) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onCopy?: ((payload: {
+        text: string;
+    }) => any) | undefined;
+    "onUpdate:mode"?: ((value: DiffMode) => any) | undefined;
+}>, {
+    disabled: boolean;
+    ariaLabel: string;
+    emptyText: string;
+    mode: DiffMode;
+    format: DiffFormat;
+    showToolbar: boolean;
+    copyable: boolean;
+    before: undefined;
+    after: undefined;
+    inlineLabel: string;
+    splitLabel: string;
+    beforeLabel: string;
+    afterLabel: string;
+    copyLabel: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLElement>;
+export default _default;

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

@@ -43,10 +43,10 @@ declare const __VLS_component: import('vue').DefineComponent<Props, {
     size: "sm" | "md" | "lg";
     overlay: boolean;
     closeOnOverlay: boolean;
-    position: "left" | "right" | "top" | "bottom";
     closeOnEsc: boolean;
     showClose: boolean;
     lockScroll: boolean;
+    position: "left" | "right" | "top" | "bottom";
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     panel: HTMLDivElement;
 }, any>;

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

@@ -52,9 +52,9 @@ declare const __VLS_component: import('vue').DefineComponent<Props, {
     disabled: boolean;
     modelValue: boolean;
     items: Array<Item>;
+    closeOnEsc: boolean;
     placement: Placement;
     offset: number;
-    closeOnEsc: boolean;
     closeOnSelect: boolean;
     matchTriggerWidth: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {

package/dist/package/components/dynamic-dialog.vue.d.ts

@@ -0,0 +1,35 @@
+import { DynamicDialogService } from '../services/dynamic-dialog-service';
+interface Props {
+    service?: DynamicDialogService;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {
+            entry: import('../services/dynamic-dialog-service').DynamicDialogEntry<unknown, Record<string, unknown>> | null;
+            close: <TResult = unknown>(result?: TResult) => boolean;
+            dismiss: () => boolean;
+        }): any;
+        footer?(_: {
+            entry: import('../services/dynamic-dialog-service').DynamicDialogEntry<unknown, Record<string, unknown>>;
+            close: <TResult = unknown>(result?: TResult) => boolean;
+            dismiss: () => boolean;
+        }): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {
+    closeCurrent: <TResult = unknown>(result?: TResult) => boolean;
+    dismissCurrent: () => boolean;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    service: DynamicDialogService;
+}, {}, {}, {}, 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/package/components/file-manager.vue.d.ts

@@ -0,0 +1,89 @@
+type FileManagerView = 'list' | 'grid';
+type FileManagerId = string | number;
+export interface FileManagerItem {
+    id?: FileManagerId;
+    name: string;
+    kind?: 'file' | 'folder';
+    size?: number;
+    thumbnail?: string;
+    updatedAt?: string;
+    disabled?: boolean;
+}
+interface FileManagerBulkAction {
+    id: string;
+    label: string;
+    disabled?: boolean;
+}
+interface Props {
+    items?: Array<FileManagerItem>;
+    modelValue?: Array<FileManagerId>;
+    view?: FileManagerView;
+    rowKey?: string | ((item: FileManagerItem, index: number) => FileManagerId);
+    selectable?: boolean;
+    multi?: boolean;
+    previewable?: boolean;
+    showToolbar?: boolean;
+    bulkActions?: Array<FileManagerBulkAction>;
+    loading?: boolean;
+    loadingText?: string;
+    emptyText?: string;
+    disabled?: boolean;
+    ariaLabel?: string;
+    previewAriaLabel?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        loading?(_: {}): any;
+        empty?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    change: (value: FileManagerId[]) => any;
+    "update:modelValue": (value: FileManagerId[]) => any;
+    itemClick: (item: FileManagerItem) => any;
+    preview: (item: FileManagerItem) => any;
+    "update:view": (value: FileManagerView) => any;
+    bulkAction: (payload: {
+        actionId: string;
+        items: Array<FileManagerItem>;
+        ids: Array<FileManagerId>;
+    }) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onChange?: ((value: FileManagerId[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: FileManagerId[]) => any) | undefined;
+    onItemClick?: ((item: FileManagerItem) => any) | undefined;
+    onPreview?: ((item: FileManagerItem) => any) | undefined;
+    "onUpdate:view"?: ((value: FileManagerView) => any) | undefined;
+    onBulkAction?: ((payload: {
+        actionId: string;
+        items: Array<FileManagerItem>;
+        ids: Array<FileManagerId>;
+    }) => any) | undefined;
+}>, {
+    disabled: boolean;
+    view: FileManagerView;
+    modelValue: Array<FileManagerId>;
+    ariaLabel: string;
+    items: Array<FileManagerItem>;
+    loading: boolean;
+    previewAriaLabel: string;
+    loadingText: string;
+    emptyText: string;
+    showToolbar: boolean;
+    rowKey: string | ((item: FileManagerItem, index: number) => FileManagerId);
+    selectable: boolean;
+    multi: boolean;
+    previewable: boolean;
+    bulkActions: Array<FileManagerBulkAction>;
+}, {}, {}, {}, 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/package/components/footer.vue.d.ts

@@ -0,0 +1,45 @@
+interface Props {
+    as?: string;
+    bordered?: boolean;
+    dense?: boolean;
+    wrap?: boolean;
+    stackOnMobile?: boolean;
+    mobileBreakpoint?: number;
+    ariaLabel?: string;
+    groupAriaLabel?: string;
+    leftAriaLabel?: string;
+    centerAriaLabel?: string;
+    rightAriaLabel?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        left?(_: {}): any;
+        center?(_: {}): any;
+        right?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    as: string;
+    wrap: boolean;
+    dense: boolean;
+    ariaLabel: string;
+    groupAriaLabel: string;
+    centerAriaLabel: string;
+    bordered: boolean;
+    mobileBreakpoint: number;
+    stackOnMobile: boolean;
+    leftAriaLabel: string;
+    rightAriaLabel: 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/package/components/hide.vue.d.ts

@@ -0,0 +1,29 @@
+type Breakpoint = 'sm' | 'md' | 'lg' | 'xl';
+interface Props {
+    as?: string;
+    from?: Breakpoint;
+    to?: Breakpoint;
+    when?: 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<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    to: Breakpoint;
+    as: string;
+    from: Breakpoint;
+    when: 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/package/components/infinite-scroll.vue.d.ts

@@ -0,0 +1,72 @@
+export type InfiniteScrollLoadTrigger = 'intersection' | 'scroll' | 'retry' | 'manual';
+export type InfiniteScrollLoadPayload = {
+    trigger: InfiniteScrollLoadTrigger;
+};
+interface Props {
+    loading?: boolean;
+    error?: boolean;
+    hasMore?: boolean;
+    disabled?: boolean;
+    root?: HTMLElement | null;
+    scrollTarget?: Window | HTMLElement | null;
+    rootMargin?: string;
+    threshold?: number;
+    fallbackOffset?: number;
+    debounceMs?: number;
+    observeOnMount?: boolean;
+    loadingText?: string;
+    endText?: string;
+    retryLabel?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        error?(_: {
+            retry: () => void;
+        }): any;
+        loading?(_: {}): any;
+        end?(_: {}): any;
+        sentinel?(_: {}): any;
+    };
+    refs: {
+        sentinel: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {
+    loadMore: () => void;
+    refresh: () => void;
+    retry: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    load: (payload: InfiniteScrollLoadPayload) => any;
+    retry: () => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onLoad?: ((payload: InfiniteScrollLoadPayload) => any) | undefined;
+    onRetry?: (() => any) | undefined;
+}>, {
+    disabled: boolean;
+    error: boolean;
+    loading: boolean;
+    root: HTMLElement | null;
+    loadingText: string;
+    rootMargin: string;
+    threshold: number;
+    hasMore: boolean;
+    scrollTarget: Window | HTMLElement | null;
+    fallbackOffset: number;
+    debounceMs: number;
+    observeOnMount: boolean;
+    endText: string;
+    retryLabel: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    sentinel: HTMLDivElement;
+}, 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/package/components/inline-message.vue.d.ts

@@ -0,0 +1,40 @@
+type InlineMessageSeverity = 'neutral' | 'info' | 'success' | 'warn' | 'danger';
+type InlineMessageSize = 'small' | 'normal' | 'large';
+type InlineMessageRole = 'auto' | 'status' | 'alert' | 'none';
+type InlineMessageAriaLive = 'auto' | 'off' | 'polite' | 'assertive';
+interface Props {
+    title?: string;
+    message?: string;
+    severity?: InlineMessageSeverity;
+    icon?: string;
+    size?: InlineMessageSize;
+    role?: InlineMessageRole;
+    ariaLive?: InlineMessageAriaLive;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        icon?(_: {}): any;
+        title?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    title: string;
+    size: InlineMessageSize;
+    role: InlineMessageRole;
+    icon: string;
+    severity: InlineMessageSeverity;
+    message: string;
+    ariaLive: InlineMessageAriaLive;
+}, {}, {}, {}, 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/package/components/json-viewer.vue.d.ts

@@ -0,0 +1,57 @@
+interface Props {
+    value?: unknown;
+    expandedDepth?: number;
+    sortKeys?: boolean;
+    showRoot?: boolean;
+    copyable?: boolean;
+    showToolbar?: boolean;
+    disabled?: boolean;
+    ariaLabel?: string;
+    emptyText?: string;
+    expandLabel?: string;
+    collapseLabel?: string;
+    expandAllLabel?: string;
+    collapseAllLabel?: string;
+    copyPathLabel?: string;
+    copyJsonLabel?: string;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    copy: (payload: {
+        text: string;
+    }) => any;
+    toggle: (payload: {
+        path: string;
+        expanded: boolean;
+    }) => any;
+    copyPath: (payload: {
+        path: string;
+    }) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onCopy?: ((payload: {
+        text: string;
+    }) => any) | undefined;
+    onToggle?: ((payload: {
+        path: string;
+        expanded: boolean;
+    }) => any) | undefined;
+    onCopyPath?: ((payload: {
+        path: string;
+    }) => any) | undefined;
+}>, {
+    disabled: boolean;
+    expandLabel: string;
+    collapseLabel: string;
+    ariaLabel: string;
+    value: undefined;
+    emptyText: string;
+    showToolbar: boolean;
+    expandedDepth: number;
+    sortKeys: boolean;
+    showRoot: boolean;
+    copyable: boolean;
+    expandAllLabel: string;
+    collapseAllLabel: string;
+    copyPathLabel: string;
+    copyJsonLabel: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLElement>;
+export default _default;

package/dist/package/components/kanban-board.vue.d.ts

@@ -18,32 +18,22 @@ interface Props {
     items?: Array<KanbanBoardItem>;
     ariaLabel?: string;
     emptyColumnText?: string;
+    virtualization?: boolean;
+    virtualizationThreshold?: number;
+    itemHeight?: number;
+    swimlaneHeight?: number;
+    overscan?: number;
+    keyboardDnD?: boolean;
 }
 declare function __VLS_template(): {
     attrs: Partial<{}>;
     slots: {
         'column-header'?(_: {
             column: KanbanColumn;
-            items: {
-                id: KanbanId;
-                columnId: KanbanId;
-                title: string;
-                description?: string | undefined;
-                assignee?: string | undefined;
-                priority?: KanbanPriority | undefined;
-                tags?: Array<string> | undefined;
-            }[];
+            items: KanbanBoardItem[];
         }): any;
         card?(_: {
-            item: {
-                id: KanbanId;
-                columnId: KanbanId;
-                title: string;
-                description?: string | undefined;
-                assignee?: string | undefined;
-                priority?: KanbanPriority | undefined;
-                tags?: Array<string> | undefined;
-            };
+            item: KanbanBoardItem;
             column: KanbanColumn;
             index: number;
         }): any;
@@ -52,15 +42,7 @@ declare function __VLS_template(): {
         }): any;
         'column-footer'?(_: {
             column: KanbanColumn;
-            items: {
-                id: KanbanId;
-                columnId: KanbanId;
-                title: string;
-                description?: string | undefined;
-                assignee?: string | undefined;
-                priority?: KanbanPriority | undefined;
-                tags?: Array<string> | undefined;
-            }[];
+            items: KanbanBoardItem[];
         }): any;
     };
     refs: {};
@@ -79,7 +61,13 @@ declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {},
     ariaLabel: string;
     columns: Array<KanbanColumn>;
     items: Array<KanbanBoardItem>;
+    virtualizationThreshold: number;
+    itemHeight: number;
+    overscan: number;
     emptyColumnText: string;
+    virtualization: boolean;
+    swimlaneHeight: number;
+    keyboardDnD: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;

package/dist/package/components/kpi-stat-card.vue.d.ts

@@ -0,0 +1,46 @@
+type TrendDirection = 'up' | 'down' | 'neutral' | 'auto';
+type DeltaFormat = 'number' | 'percent';
+interface Props {
+    title?: string;
+    subtitle?: string;
+    value?: string | number;
+    caption?: string;
+    trend?: TrendDirection;
+    trendLabel?: string;
+    delta?: number | null;
+    deltaFormat?: DeltaFormat;
+    showDelta?: boolean;
+    ariaLabel?: string;
+    locale?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        sparkline?(_: {}): any;
+        value?(_: {}): any;
+        caption?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    caption: string;
+    title: string;
+    subtitle: string;
+    ariaLabel: string;
+    value: string | number;
+    locale: string;
+    trend: TrendDirection;
+    trendLabel: string;
+    delta: number | null;
+    deltaFormat: DeltaFormat;
+    showDelta: boolean;
+}, {}, {}, {}, 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/package/components/member-picker.vue.d.ts

@@ -0,0 +1,89 @@
+type MemberValue = string | number;
+export interface MemberPickerItem {
+    id: MemberValue;
+    name: string;
+    email?: string;
+    avatar?: string;
+    roleHint?: string;
+    org?: string;
+    disabled?: boolean;
+}
+interface Props {
+    modelValue?: MemberValue | Array<MemberValue> | null;
+    options?: Array<MemberPickerItem>;
+    multiple?: boolean;
+    disabled?: boolean;
+    readonly?: boolean;
+    placeholder?: string;
+    ariaLabel?: string;
+    loading?: boolean;
+    loadingText?: string;
+    emptyText?: string;
+    removeLabel?: string;
+    filterLocal?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        selection?(_: {
+            member: MemberPickerItem;
+            remove: () => void;
+        }): any;
+        option?(_: {
+            member: MemberPickerItem;
+            index: number;
+            selected: boolean;
+        }): any;
+        'role-hint'?(_: {
+            member: MemberPickerItem;
+        }): any;
+    };
+    refs: {
+        root: HTMLDivElement;
+        inputRef: HTMLInputElement;
+        panelRef: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    search: (query: string) => any;
+    blur: (ev: FocusEvent) => any;
+    change: (value: MemberValue | MemberValue[] | null) => any;
+    focus: (ev: FocusEvent) => any;
+    select: (member: MemberPickerItem) => any;
+    "update:modelValue": (value: MemberValue | MemberValue[] | null) => any;
+    remove: (member: MemberPickerItem) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onSearch?: ((query: string) => any) | undefined;
+    onBlur?: ((ev: FocusEvent) => any) | undefined;
+    onChange?: ((value: MemberValue | MemberValue[] | null) => any) | undefined;
+    onFocus?: ((ev: FocusEvent) => any) | undefined;
+    onSelect?: ((member: MemberPickerItem) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: MemberValue | MemberValue[] | null) => any) | undefined;
+    onRemove?: ((member: MemberPickerItem) => any) | undefined;
+}>, {
+    disabled: boolean;
+    modelValue: MemberValue | Array<MemberValue> | null;
+    ariaLabel: string;
+    multiple: boolean;
+    loading: boolean;
+    placeholder: string;
+    readonly: boolean;
+    loadingText: string;
+    emptyText: string;
+    options: Array<MemberPickerItem>;
+    removeLabel: string;
+    filterLocal: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    root: HTMLDivElement;
+    inputRef: HTMLInputElement;
+    panelRef: HTMLDivElement;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};