@trilogy-data/trilogy-studio-components 0.1.12 → 0.1.14

package/dist/components/sidebar/Sidebar.vue.d.ts

@@ -0,0 +1,3966 @@
+export interface SidebarProps {
+    active?: string;
+    activeEditor?: string;
+    activeModelKey?: string;
+    activeDocumentationKey?: string;
+    activeConnectionKey?: string;
+    activeLLMKey?: string;
+    activeJobsKey?: string;
+    activeDashboardKey?: string;
+    containerWidth?: number;
+}
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    readonly active: {
+        readonly type: StringConstructor;
+        readonly default: string | null;
+    };
+    readonly activeEditor: {
+        readonly type: StringConstructor;
+        readonly default: string | null;
+    };
+    readonly activeModelKey: {
+        readonly type: StringConstructor;
+        readonly default: string | null;
+    };
+    readonly activeDocumentationKey: {
+        readonly type: StringConstructor;
+        readonly default: string | null;
+    };
+    readonly activeConnectionKey: {
+        readonly type: StringConstructor;
+        readonly default: string | null;
+    };
+    readonly activeJobsKey: {
+        readonly type: StringConstructor;
+        readonly default: string | null;
+    };
+    readonly activeLLMKey: {
+        readonly type: StringConstructor;
+        readonly default: string | null;
+    };
+    readonly activeDashboardKey: {
+        readonly type: StringConstructor;
+        readonly default: string | null;
+    };
+    readonly containerWidth: {
+        readonly type: NumberConstructor;
+        readonly default: 200;
+    };
+}>, {
+    isSaving: import('vue').Ref<boolean, boolean>;
+    previousUnSaved: import('vue').Ref<null, null>;
+}, {
+    trilogyIcon: string;
+    sidebarItems: {
+        name: string;
+        tooltip: string;
+        icon: string;
+        screen: string;
+    }[];
+    sidebarFeatureItems: {
+        name: string;
+        tooltip: string;
+        icon: string;
+        screen: string;
+    }[];
+    isMobile: CallableFunction;
+    unSaved: number | Number;
+    saveAll: CallableFunction;
+    notMobile: boolean;
+    contentCollapsed: boolean;
+}, {}, {
+    triggerSaveAnimation(): void;
+    handleSave(): Promise<void>;
+    selectItem(index: string): void;
+    toggleCollapse(): void;
+    editorSelected(editor: string): void;
+    modelKeySelected(key: string): void;
+    documentationKeySelected(key: string): void;
+    jobsKeySelected(key: string): void;
+    connectionKeySelected(key: string): void;
+    dashboardKeySelected(key: string): void;
+    toggleMobileMenu(): void;
+    llmKeySelected(key: string): void;
+    llmOpenView(connectionName: string, tab: string, chatId?: string): void;
+    createNewChat(connectionName: string): void;
+    saveEditors(): void;
+    saveDashboards(): void;
+    openSettings(): void;
+    openProfile(): void;
+    getUrl(screen: string): string;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    readonly active: {
+        readonly type: StringConstructor;
+        readonly default: string | null;
+    };
+    readonly activeEditor: {
+        readonly type: StringConstructor;
+        readonly default: string | null;
+    };
+    readonly activeModelKey: {
+        readonly type: StringConstructor;
+        readonly default: string | null;
+    };
+    readonly activeDocumentationKey: {
+        readonly type: StringConstructor;
+        readonly default: string | null;
+    };
+    readonly activeConnectionKey: {
+        readonly type: StringConstructor;
+        readonly default: string | null;
+    };
+    readonly activeJobsKey: {
+        readonly type: StringConstructor;
+        readonly default: string | null;
+    };
+    readonly activeLLMKey: {
+        readonly type: StringConstructor;
+        readonly default: string | null;
+    };
+    readonly activeDashboardKey: {
+        readonly type: StringConstructor;
+        readonly default: string | null;
+    };
+    readonly containerWidth: {
+        readonly type: NumberConstructor;
+        readonly default: 200;
+    };
+}>> & Readonly<{}>, {
+    readonly activeEditor: string;
+    readonly active: string;
+    readonly activeConnectionKey: string;
+    readonly containerWidth: number;
+    readonly activeLLMKey: string;
+    readonly activeDocumentationKey: string;
+    readonly activeModelKey: string;
+    readonly activeJobsKey: string;
+    readonly activeDashboardKey: string;
+}, {}, {
+    EditorList: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        activeEditor: StringConstructor;
+        testTag: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>, {
+        isMobile: boolean;
+        communityStore: import('pinia').Store<"communityApi", import('../../stores/communityApiStore').CommunityApiState, {
+            allFiles: (state: {
+                stores: ({
+                    type: "github";
+                    owner: string;
+                    repo: string;
+                    branch: string;
+                    name: string;
+                    id: string;
+                } | {
+                    type: "generic";
+                    baseUrl: string;
+                    token?: string | undefined;
+                    name: string;
+                    id: string;
+                })[];
+                filesByStore: Record<string, import('../../remotes/models').ModelFile[]>;
+                errors: Record<string, string>;
+                storeStatus: Record<string, import('../../stores/communityApiStore').StoreStatus>;
+                loading: boolean;
+                showAddStoreModal: boolean;
+                addingStore: boolean;
+                newStore: {
+                    type: "github" | "generic";
+                    name: string;
+                    baseUrl: string;
+                    owner: string;
+                    repo: string;
+                    branch: string;
+                };
+            } & import('pinia').PiniaCustomStateProperties<import('../../stores/communityApiStore').CommunityApiState>) => import('../../remotes/models').ModelFile[];
+            availableEngines: (state: {
+                stores: ({
+                    type: "github";
+                    owner: string;
+                    repo: string;
+                    branch: string;
+                    name: string;
+                    id: string;
+                } | {
+                    type: "generic";
+                    baseUrl: string;
+                    token?: string | undefined;
+                    name: string;
+                    id: string;
+                })[];
+                filesByStore: Record<string, import('../../remotes/models').ModelFile[]>;
+                errors: Record<string, string>;
+                storeStatus: Record<string, import('../../stores/communityApiStore').StoreStatus>;
+                loading: boolean;
+                showAddStoreModal: boolean;
+                addingStore: boolean;
+                newStore: {
+                    type: "github" | "generic";
+                    name: string;
+                    baseUrl: string;
+                    owner: string;
+                    repo: string;
+                    branch: string;
+                };
+            } & import('pinia').PiniaCustomStateProperties<import('../../stores/communityApiStore').CommunityApiState>) => string[];
+            hasErrors: (state: {
+                stores: ({
+                    type: "github";
+                    owner: string;
+                    repo: string;
+                    branch: string;
+                    name: string;
+                    id: string;
+                } | {
+                    type: "generic";
+                    baseUrl: string;
+                    token?: string | undefined;
+                    name: string;
+                    id: string;
+                })[];
+                filesByStore: Record<string, import('../../remotes/models').ModelFile[]>;
+                errors: Record<string, string>;
+                storeStatus: Record<string, import('../../stores/communityApiStore').StoreStatus>;
+                loading: boolean;
+                showAddStoreModal: boolean;
+                addingStore: boolean;
+                newStore: {
+                    type: "github" | "generic";
+                    name: string;
+                    baseUrl: string;
+                    owner: string;
+                    repo: string;
+                    branch: string;
+                };
+            } & import('pinia').PiniaCustomStateProperties<import('../../stores/communityApiStore').CommunityApiState>) => boolean;
+            errorList: (state: {
+                stores: ({
+                    type: "github";
+                    owner: string;
+                    repo: string;
+                    branch: string;
+                    name: string;
+                    id: string;
+                } | {
+                    type: "generic";
+                    baseUrl: string;
+                    token?: string | undefined;
+                    name: string;
+                    id: string;
+                })[];
+                filesByStore: Record<string, import('../../remotes/models').ModelFile[]>;
+                errors: Record<string, string>;
+                storeStatus: Record<string, import('../../stores/communityApiStore').StoreStatus>;
+                loading: boolean;
+                showAddStoreModal: boolean;
+                addingStore: boolean;
+                newStore: {
+                    type: "github" | "generic";
+                    name: string;
+                    baseUrl: string;
+                    owner: string;
+                    repo: string;
+                    branch: string;
+                };
+            } & import('pinia').PiniaCustomStateProperties<import('../../stores/communityApiStore').CommunityApiState>) => Array<{
+                root: string;
+                name: string;
+                error: string;
+            }>;
+        }, {
+            loadStoresFromStorage(): void;
+            saveStoresToStorage(): void;
+            fetchAllFiles(): Promise<void>;
+            refreshData(): Promise<void>;
+            fetchStoreFiles(storeId: string): Promise<void>;
+            filteredFiles(searchQuery: string, selectedEngine: string, importStatus: "all" | "imported" | "not-imported", modelStore: import('../../stores/modelStore').ModelConfigStoreType, remote?: string | null): import('../../remotes/models').ModelFile[];
+            getFilesByStore(storeId: string): import('../../remotes/models').ModelFile[];
+            initialize(): Promise<void>;
+            addStore(store: import('../../remotes/models').AnyModelStore): Promise<boolean>;
+            removeStore(storeId: string): void;
+            updateStoreToken(storeId: string, token: string): void;
+            openAddStoreModal(): void;
+            closeAddStoreModal(): void;
+            handleAddStore(): Promise<void>;
+            clearErrors(): void;
+            clearStoreError(storeId: string): void;
+            getStoreStatus(storeId: string): import('../../stores/communityApiStore').StoreStatus;
+        }>;
+        connectionStore: import('pinia').Store<"connections", {
+            connections: Record<string, import('../../connections').Connection>;
+        }, {
+            connectionList: (state: {
+                connections: Record<string, import('../../connections').Connection>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                connections: Record<string, import('../../connections').Connection>;
+            }>) => import('../../connections').Connection[];
+            unsavedConnections: (state: {
+                connections: Record<string, import('../../connections').Connection>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                connections: Record<string, import('../../connections').Connection>;
+            }>) => number;
+        }, {
+            addConnection(connection: import('../../connections').Connection): import('../../connections').Connection;
+            connectConnection(name: string): Promise<any>;
+            resetConnection(name: string): Promise<any>;
+            deleteConnection(name: string): void;
+            connectionStateToStatus(connection: import('../../connections').Connection | null): "running" | "failed" | "disabled" | "connected";
+            getConnectionSources(name: string): import('../../stores').ContentInput[];
+            newConnection(name: string, type: string, options: Record<string, any>): import('../../connections').Connection;
+        }>;
+        editorStore: import('pinia').Store<"editors", {
+            editors: Record<string, import('../../editors').Editor>;
+            activeEditorName: string;
+            activeEditorId: string;
+            refinementExecutions: Record<string, import('../../stores/editorStore').RefinementExecution>;
+        }, {
+            editorList: (state: {
+                editors: Record<string, import('../../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+                refinementExecutions: Record<string, import('../../stores/editorStore').RefinementExecution>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                editors: Record<string, import('../../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+                refinementExecutions: Record<string, import('../../stores/editorStore').RefinementExecution>;
+            }>) => import('../../editors').Editor[];
+            unsavedEditors: (state: {
+                editors: Record<string, import('../../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+                refinementExecutions: Record<string, import('../../stores/editorStore').RefinementExecution>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                editors: Record<string, import('../../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+                refinementExecutions: Record<string, import('../../stores/editorStore').RefinementExecution>;
+            }>) => number;
+            getRefinementExecution: (state: {
+                editors: Record<string, import('../../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+                refinementExecutions: Record<string, import('../../stores/editorStore').RefinementExecution>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                editors: Record<string, import('../../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+                refinementExecutions: Record<string, import('../../stores/editorStore').RefinementExecution>;
+            }>) => (editorId: string) => import('../../stores/editorStore').RefinementExecution | null;
+            isRefinementExecuting: (state: {
+                editors: Record<string, import('../../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+                refinementExecutions: Record<string, import('../../stores/editorStore').RefinementExecution>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                editors: Record<string, import('../../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+                refinementExecutions: Record<string, import('../../stores/editorStore').RefinementExecution>;
+            }>) => (editorId: string) => boolean;
+            getRefinementActiveToolName: (state: {
+                editors: Record<string, import('../../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+                refinementExecutions: Record<string, import('../../stores/editorStore').RefinementExecution>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                editors: Record<string, import('../../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+                refinementExecutions: Record<string, import('../../stores/editorStore').RefinementExecution>;
+            }>) => (editorId: string) => string;
+        }, {
+            newEditor(name: string, type: import('../../editors/fileTypes').EditorType, connection: string, contents: string | undefined, options?: {
+                storage?: string;
+                remoteStoreId?: string | null;
+                remotePath?: string | null;
+                remotePersisted?: boolean;
+            }): import('../../editors').Editor;
+            addEditor(editor: import('../../editors').Editor): void;
+            getEditorByName(name: string): import('../../editors').Editor | undefined;
+            getConnectionEditors(connection: string, tags?: import('../../editors').EditorTag[]): import('../../editors').Editor[];
+            updateEditorName(id: string, newName: string): void;
+            removeEditor(id: string): false | undefined;
+            setEditorScrollPosition(id: string, scrollPosition: {
+                line: number;
+                column: number;
+            }): void;
+            setEditorContents(id: string, contents: string): void;
+            setEditorResults(id: string, results: import('../../editors/results').Results): void;
+            getCurrentEditorAutocomplete(word: string): import('../../stores/resolver').CompletionItem[];
+            startRefinementSession(editorId: string, options?: {
+                selectedText?: string;
+                selectionRange?: {
+                    start: number;
+                    end: number;
+                };
+            }): void;
+            updateRefinementSession(editorId: string, updates: Partial<import('../../editors/editor').EditorRefinementSession>): void;
+            addRefinementMessage(editorId: string, message: import('../llm').ChatMessage): void;
+            addRefinementArtifact(editorId: string, artifact: import('../llm').ChatArtifactType): void;
+            clearRefinementSession(editorId: string): void;
+            startRefinementExecution(editorId: string): void;
+            setRefinementActiveToolName(editorId: string, toolName: string): void;
+            completeRefinementExecution(editorId: string, error?: string): void;
+            stopRefinementExecution(editorId: string): void;
+            executeRefinementMessage(editorId: string, message: string, deps: import('../../stores/editorStore').RefinementExecutionDependencies, options?: {
+                onContentChange?: (content: string, replaceSelection?: boolean) => void;
+                onChartConfigChange?: (config: import('../../editors/results').ChartConfig) => void;
+                onFinish?: (message?: string) => void;
+                onRunActiveEditorQuery?: () => Promise<import('../../llm/editorRefinementToolExecutor').QueryExecutionResult>;
+            }): Promise<{
+                terminated: boolean;
+                finalMessage?: string;
+                stopped?: boolean;
+            }>;
+            discardRefinement(editorId: string, callbacks?: {
+                onContentChange?: (content: string) => void;
+                onChartConfigChange?: (config: import('../../editors/results').ChartConfig) => void;
+                onDiscard?: () => void;
+            }): void;
+            acceptRefinement(editorId: string, callbacks?: {
+                onFinish?: (message?: string) => void;
+            }): void;
+        }>;
+        EditorTag: typeof import('../../editors').EditorTag;
+        toggleTagFilter: (tag: string) => void;
+        contentList: import('vue').ComputedRef<{
+            key: string;
+            objectKey: string;
+            label: string;
+            type: string;
+            indent: number;
+            editor?: any;
+            connection?: string;
+            storage?: string;
+            remoteStoreId?: string | null;
+        }[]>;
+        toggleCollapse: (key: string) => void;
+        collapsed: import('vue').Ref<Record<string, boolean>, Record<string, boolean>>;
+        hiddenTags: import('vue').Ref<Set<string> & Omit<Set<string>, keyof Set<any>>, Set<string> | (Set<string> & Omit<Set<string>, keyof Set<any>>)>;
+        creatorVisible: import('vue').Ref<boolean, boolean>;
+        filterMenuOpen: import('vue').Ref<boolean, boolean>;
+        filterDropdown: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+        filterSummary: import('vue').ComputedRef<string>;
+        showDeleteConfirmationState: import('vue').Ref<boolean, boolean>;
+        showDeleteConfirmation: (item: import('../../editors').Editor) => void;
+        cancelDelete: () => void;
+        confirmDelete: () => Promise<void>;
+        refreshStore: (storeId: string) => Promise<void>;
+    }, {}, {}, {
+        formatEditorTag(tag: string): string;
+        saveEditors(): void;
+        clickAction(type: string, objectKey: string, key: string): void;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        activeEditor: StringConstructor;
+        testTag: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>> & Readonly<{}>, {
+        testTag: string;
+    }, {}, {
+        EditorCreatorInline: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            connection: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            visible: {
+                type: BooleanConstructor;
+                required: true;
+            };
+            testTag: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+        }>, {
+            editorDetails: import('vue').Ref<{
+                name: string;
+                type: string;
+                connection: string;
+            }, {
+                name: string;
+                type: string;
+                connection: string;
+            } | {
+                name: string;
+                type: string;
+                connection: string;
+            }>;
+            connections: Record<string, import('../../connections').Connection>;
+            createEditor: () => void;
+            submitEditorCreation: () => void;
+            close: () => void;
+            error: import('vue').Ref<string, string>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            connection: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            visible: {
+                type: BooleanConstructor;
+                required: true;
+            };
+            testTag: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            connection: string;
+            testTag: string;
+        }, {}, {
+            Tooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                position: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {}, {
+                visible: boolean;
+                hoverTimeout: ReturnType<typeof setTimeout> | null;
+            }, {
+                positionClass(): string;
+            }, {
+                showTooltip(): void;
+                hideTooltip(): void;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                position: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                position: string;
+                inline: boolean;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            InlineErrorMessage: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        SidebarList: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            title: {
+                type: StringConstructor;
+                required: true;
+            };
+        }>, {
+            title: string;
+            isMobile: boolean | undefined;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            title: {
+                type: StringConstructor;
+                required: true;
+            };
+        }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        LoadingButton: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            action: {
+                type: FunctionConstructor;
+                required: true;
+            };
+            useDefaultStyle: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            keyCombination: {
+                type: {
+                    (arrayLength: number): string[];
+                    (...items: string[]): string[];
+                    new (arrayLength: number): string[];
+                    new (...items: string[]): string[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                default: null;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            testId: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {
+            errorMessage: import('vue').Ref<string | null, string | null>;
+            isLoading: import('vue').Ref<boolean, boolean>;
+            status: import('vue').Ref<"success" | "error" | null, "success" | "error" | null>;
+            handleClick: () => Promise<void>;
+            handleKeydown: (event: KeyboardEvent) => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            action: {
+                type: FunctionConstructor;
+                required: true;
+            };
+            useDefaultStyle: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            keyCombination: {
+                type: {
+                    (arrayLength: number): string[];
+                    (...items: string[]): string[];
+                    new (arrayLength: number): string[];
+                    new (...items: string[]): string[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                default: null;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            testId: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            disabled: boolean;
+            useDefaultStyle: boolean;
+            keyCombination: string[];
+            testId: string;
+        }, {}, {
+            Tooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                position: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {}, {
+                visible: boolean;
+                hoverTimeout: ReturnType<typeof setTimeout> | null;
+            }, {
+                positionClass(): string;
+            }, {
+                showTooltip(): void;
+                hideTooltip(): void;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                position: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                position: string;
+                inline: boolean;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        EditorListItem: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            item: {
+                type: ObjectConstructor;
+                required: true;
+            };
+            activeEditor: {
+                type: StringConstructor;
+                default: string;
+            };
+            isCollapsed: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            isMobile: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {
+            connectionStore: import('pinia').Store<"connections", {
+                connections: Record<string, import('../../connections').Connection>;
+            }, {
+                connectionList: (state: {
+                    connections: Record<string, import('../../connections').Connection>;
+                } & import('pinia').PiniaCustomStateProperties<{
+                    connections: Record<string, import('../../connections').Connection>;
+                }>) => import('../../connections').Connection[];
+                unsavedConnections: (state: {
+                    connections: Record<string, import('../../connections').Connection>;
+                } & import('pinia').PiniaCustomStateProperties<{
+                    connections: Record<string, import('../../connections').Connection>;
+                }>) => number;
+            }, {
+                addConnection(connection: import('../../connections').Connection): import('../../connections').Connection;
+                connectConnection(name: string): Promise<any>;
+                resetConnection(name: string): Promise<any>;
+                deleteConnection(name: string): void;
+                connectionStateToStatus(connection: import('../../connections').Connection | null): "running" | "failed" | "disabled" | "connected";
+                getConnectionSources(name: string): import('../../stores').ContentInput[];
+                newConnection(name: string, type: string, options: Record<string, any>): import('../../connections').Connection;
+            }>;
+            trilogyIcon: string;
+            createDefaultModel: (connectionName: string) => Promise<void>;
+            createNewEditor: (connection: string, type: string, root?: string) => Promise<void>;
+            contextMenuItems: import('vue').ComputedRef<import('../ContextMenu.vue').ContextMenuItem[]>;
+            handleClick: () => void;
+            handleToggle: () => void;
+        }, {}, {}, {
+            handleContextMenuItemClick(item: import('../ContextMenu.vue').ContextMenuItem): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("toggle" | "item-click" | "delete-editor" | "refresh-store")[], "toggle" | "item-click" | "delete-editor" | "refresh-store", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            item: {
+                type: ObjectConstructor;
+                required: true;
+            };
+            activeEditor: {
+                type: StringConstructor;
+                default: string;
+            };
+            isCollapsed: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            isMobile: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            onToggle?: ((...args: any[]) => any) | undefined;
+            "onItem-click"?: ((...args: any[]) => any) | undefined;
+            "onDelete-editor"?: ((...args: any[]) => any) | undefined;
+            "onRefresh-store"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            isMobile: boolean;
+            isCollapsed: boolean;
+            activeEditor: string;
+        }, {}, {
+            SidebarItem: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                itemId: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                name: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                indent: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                isSelected: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                isCollapsible: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                isCollapsed: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                icon: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                extraInfo: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: string;
+                };
+                itemType: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>, {}, {}, {}, {
+                handleClick(): void;
+                handleToggle(): void;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("click" | "toggle")[], "click" | "toggle", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                itemId: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                name: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                indent: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                isSelected: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                isCollapsible: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                isCollapsed: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                icon: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                extraInfo: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: string;
+                };
+                itemType: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>> & Readonly<{
+                onClick?: ((...args: any[]) => any) | undefined;
+                onToggle?: ((...args: any[]) => any) | undefined;
+            }>, {
+                icon: string;
+                indent: number;
+                isSelected: boolean;
+                isCollapsible: boolean;
+                isCollapsed: boolean;
+                extraInfo: string | number;
+                itemType: string;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            Tooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                position: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {}, {
+                visible: boolean;
+                hoverTimeout: ReturnType<typeof setTimeout> | null;
+            }, {
+                positionClass(): string;
+            }, {
+                showTooltip(): void;
+                hideTooltip(): void;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                position: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                position: string;
+                inline: boolean;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            ConnectionStatusIcon: import('vue').DefineComponent<import('./ConnectionStatusIcon.vue').StatusIconProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('./ConnectionStatusIcon.vue').StatusIconProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+            SidebarTagChip: import('vue').DefineComponent<import('./SidebarTagChip.vue').SidebarTagChipProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('./SidebarTagChip.vue').SidebarTagChipProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLSpanElement>;
+            SidebarOverflowMenu: import('vue').DefineComponent<import('./SidebarOverflowMenu.vue').SidebarOverflowMenuProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                select: (item: import('../ContextMenu.vue').ContextMenuItem) => any;
+            }, string, import('vue').PublicProps, Readonly<import('./SidebarOverflowMenu.vue').SidebarOverflowMenuProps> & Readonly<{
+                onSelect?: ((item: import('../ContextMenu.vue').ContextMenuItem) => any) | undefined;
+            }>, {
+                tooltip: string;
+                menuWidth: number;
+                buttonClass: string;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        ConfirmDialog: import('vue').DefineComponent<import('../ConfirmDialog.vue').ConfirmDialogProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            close: () => any;
+            confirm: () => any;
+        }, string, import('vue').PublicProps, Readonly<import('../ConfirmDialog.vue').ConfirmDialogProps> & Readonly<{
+            onClose?: (() => any) | undefined;
+            onConfirm?: (() => any) | undefined;
+        }>, {
+            confirmLabel: string;
+            cancelLabel: string;
+            confirmTestId: string;
+            cancelTestId: string;
+            confirmDisabled: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    ConnectionList: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        activeConnectionKey: {
+            type: StringConstructor;
+            default: string;
+            optional: boolean;
+        };
+        testTag: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>, {
+        connectionStore: import('pinia').Store<"connections", {
+            connections: Record<string, import('../../connections').Connection>;
+        }, {
+            connectionList: (state: {
+                connections: Record<string, import('../../connections').Connection>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                connections: Record<string, import('../../connections').Connection>;
+            }>) => import('../../connections').Connection[];
+            unsavedConnections: (state: {
+                connections: Record<string, import('../../connections').Connection>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                connections: Record<string, import('../../connections').Connection>;
+            }>) => number;
+        }, {
+            addConnection(connection: import('../../connections').Connection): import('../../connections').Connection;
+            connectConnection(name: string): Promise<any>;
+            resetConnection(name: string): Promise<any>;
+            deleteConnection(name: string): void;
+            connectionStateToStatus(connection: import('../../connections').Connection | null): "running" | "failed" | "disabled" | "connected";
+            getConnectionSources(name: string): import('../../stores').ContentInput[];
+            newConnection(name: string, type: string, options: Record<string, any>): import('../../connections').Connection;
+        }>;
+        editorStore: import('pinia').Store<"editors", {
+            editors: Record<string, import('../../editors').Editor>;
+            activeEditorName: string;
+            activeEditorId: string;
+            refinementExecutions: Record<string, import('../../stores/editorStore').RefinementExecution>;
+        }, {
+            editorList: (state: {
+                editors: Record<string, import('../../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+                refinementExecutions: Record<string, import('../../stores/editorStore').RefinementExecution>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                editors: Record<string, import('../../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+                refinementExecutions: Record<string, import('../../stores/editorStore').RefinementExecution>;
+            }>) => import('../../editors').Editor[];
+            unsavedEditors: (state: {
+                editors: Record<string, import('../../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+                refinementExecutions: Record<string, import('../../stores/editorStore').RefinementExecution>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                editors: Record<string, import('../../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+                refinementExecutions: Record<string, import('../../stores/editorStore').RefinementExecution>;
+            }>) => number;
+            getRefinementExecution: (state: {
+                editors: Record<string, import('../../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+                refinementExecutions: Record<string, import('../../stores/editorStore').RefinementExecution>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                editors: Record<string, import('../../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+                refinementExecutions: Record<string, import('../../stores/editorStore').RefinementExecution>;
+            }>) => (editorId: string) => import('../../stores/editorStore').RefinementExecution | null;
+            isRefinementExecuting: (state: {
+                editors: Record<string, import('../../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+                refinementExecutions: Record<string, import('../../stores/editorStore').RefinementExecution>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                editors: Record<string, import('../../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+                refinementExecutions: Record<string, import('../../stores/editorStore').RefinementExecution>;
+            }>) => (editorId: string) => boolean;
+            getRefinementActiveToolName: (state: {
+                editors: Record<string, import('../../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+                refinementExecutions: Record<string, import('../../stores/editorStore').RefinementExecution>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                editors: Record<string, import('../../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+                refinementExecutions: Record<string, import('../../stores/editorStore').RefinementExecution>;
+            }>) => (editorId: string) => string;
+        }, {
+            newEditor(name: string, type: import('../../editors/fileTypes').EditorType, connection: string, contents: string | undefined, options?: {
+                storage?: string;
+                remoteStoreId?: string | null;
+                remotePath?: string | null;
+                remotePersisted?: boolean;
+            }): import('../../editors').Editor;
+            addEditor(editor: import('../../editors').Editor): void;
+            getEditorByName(name: string): import('../../editors').Editor | undefined;
+            getConnectionEditors(connection: string, tags?: import('../../editors').EditorTag[]): import('../../editors').Editor[];
+            updateEditorName(id: string, newName: string): void;
+            removeEditor(id: string): false | undefined;
+            setEditorScrollPosition(id: string, scrollPosition: {
+                line: number;
+                column: number;
+            }): void;
+            setEditorContents(id: string, contents: string): void;
+            setEditorResults(id: string, results: import('../../editors/results').Results): void;
+            getCurrentEditorAutocomplete(word: string): import('../../stores/resolver').CompletionItem[];
+            startRefinementSession(editorId: string, options?: {
+                selectedText?: string;
+                selectionRange?: {
+                    start: number;
+                    end: number;
+                };
+            }): void;
+            updateRefinementSession(editorId: string, updates: Partial<import('../../editors/editor').EditorRefinementSession>): void;
+            addRefinementMessage(editorId: string, message: import('../llm').ChatMessage): void;
+            addRefinementArtifact(editorId: string, artifact: import('../llm').ChatArtifactType): void;
+            clearRefinementSession(editorId: string): void;
+            startRefinementExecution(editorId: string): void;
+            setRefinementActiveToolName(editorId: string, toolName: string): void;
+            completeRefinementExecution(editorId: string, error?: string): void;
+            stopRefinementExecution(editorId: string): void;
+            executeRefinementMessage(editorId: string, message: string, deps: import('../../stores/editorStore').RefinementExecutionDependencies, options?: {
+                onContentChange?: (content: string, replaceSelection?: boolean) => void;
+                onChartConfigChange?: (config: import('../../editors/results').ChartConfig) => void;
+                onFinish?: (message?: string) => void;
+                onRunActiveEditorQuery?: () => Promise<import('../../llm/editorRefinementToolExecutor').QueryExecutionResult>;
+            }): Promise<{
+                terminated: boolean;
+                finalMessage?: string;
+                stopped?: boolean;
+            }>;
+            discardRefinement(editorId: string, callbacks?: {
+                onContentChange?: (content: string) => void;
+                onChartConfigChange?: (config: import('../../editors/results').ChartConfig) => void;
+                onDiscard?: () => void;
+            }): void;
+            acceptRefinement(editorId: string, callbacks?: {
+                onFinish?: (message?: string) => void;
+            }): void;
+        }>;
+        contentList: import('vue').ComputedRef<{
+            id: string;
+            name: string;
+            indent: number;
+            count: number;
+            type: string;
+            searchPath: string;
+            connection: any | undefined;
+        }[]>;
+        filteredContentList: import('vue').ComputedRef<{
+            id: string;
+            name: string;
+            indent: number;
+            count: number;
+            type: string;
+            searchPath: string;
+            connection: any | undefined;
+            object?: any;
+        }[]>;
+        toggleCollapse: (id: string, connection: string, type: string) => Promise<void>;
+        handleItemClick: (id: string, _: string, __: string) => Promise<void>;
+        toggleMobileMenu: () => void;
+        collapsed: import('vue').Ref<Record<string, boolean>, Record<string, boolean>>;
+        saveConnections: Function;
+        modelStore: import('pinia').Store<"models", {
+            models: Record<string, import('../../models').ModelConfig>;
+        }, {
+            modelList: (state: {
+                models: Record<string, import('../../models').ModelConfig>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                models: Record<string, import('../../models').ModelConfig>;
+            }>) => import('../../models').ModelConfig[];
+            unsavedModels: (state: {
+                models: Record<string, import('../../models').ModelConfig>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                models: Record<string, import('../../models').ModelConfig>;
+            }>) => number;
+        }, {
+            newModelConfig(name: string, force?: boolean): import('../../models').ModelConfig;
+            addModelConfig(model: import('../../models').ModelConfig): void;
+            removeModelConfig(name: string): void;
+            updateModelName(name: string, newName: string): void;
+            addEditorAsModelSource(model: string, editor: import('../../editors').Editor): void;
+            addModelConfigSource(name: string, contents: import('../../models').ModelSource): void;
+            removeModelConfigSource(name: string, contents: string): void;
+            setModelConfigParseResults(name: string, results: import('../../models').ModelParseResults): void;
+            setModelParseError(name: string, error: string): void;
+        }>;
+        connectionModelVisible: import('vue').Ref<Record<string, boolean>, Record<string, boolean>>;
+        updateMotherDuckToken: (connection: import('../../connections').MotherDuckConnection, token: string) => void;
+        updateSnowflakePrivateKey: (connection: import('../../connections').SnowflakeJwtConnection, token: string) => Promise<void>;
+        updateSnowflakeAccount: (connection: import('../../connections').SnowflakeJwtConnection, account: string) => Promise<void>;
+        updateSnowflakeUsername: (connection: import('../../connections').SnowflakeJwtConnection, username: string) => Promise<void>;
+        toggleSaveCredential: (connection: any) => void;
+        updateBigqueryProject: (connection: import('../../connections').BigQueryOauthConnection, project: string) => Promise<void>;
+        updateBigqueryBrowsingProject: (connection: import('../../connections').BigQueryOauthConnection, project: string) => Promise<void>;
+        refreshId: (id: string, connection: string, type: string) => Promise<void>;
+        rightSplit: (str: string) => string;
+        creatorVisible: import('vue').Ref<boolean, boolean>;
+        isMobile: import('vue').Ref<boolean, boolean>;
+        searchTerm: import('vue').Ref<string, string>;
+        clearSearch: () => void;
+    }, {
+        showDeleteConfirmationState: boolean;
+        connectionToDelete: string;
+    }, {
+        connections(): import('../../connections').Connection[];
+        modelList(): string[];
+    }, {
+        resetConnection(connection: import('../../connections').Connection): Promise<any>;
+        showDeleteConfirmation(connection: import('../../connections').Connection): void;
+        cancelDelete(): void;
+        confirmDelete(): void;
+        deleteConnection(editor: any): void;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        activeConnectionKey: {
+            type: StringConstructor;
+            default: string;
+            optional: boolean;
+        };
+        testTag: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>> & Readonly<{}>, {
+        testTag: string;
+        activeConnectionKey: string;
+    }, {}, {
+        SidebarList: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            title: {
+                type: StringConstructor;
+                required: true;
+            };
+        }>, {
+            title: string;
+            isMobile: boolean | undefined;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            title: {
+                type: StringConstructor;
+                required: true;
+            };
+        }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        ConnectionCreatorInline: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            visible: {
+                type: BooleanConstructor;
+                required: true;
+            };
+            testTag: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+        }>, {
+            connectionDetails: import('vue').Ref<{
+                name: string;
+                type: string;
+                options: {
+                    mdToken: string;
+                    account: string;
+                    projectId: string;
+                    username: string;
+                    password: string;
+                    privateKey: string;
+                    saveCredential: boolean;
+                };
+            }, {
+                name: string;
+                type: string;
+                options: {
+                    mdToken: string;
+                    account: string;
+                    projectId: string;
+                    username: string;
+                    password: string;
+                    privateKey: string;
+                    saveCredential: boolean;
+                };
+            } | {
+                name: string;
+                type: string;
+                options: {
+                    mdToken: string;
+                    account: string;
+                    projectId: string;
+                    username: string;
+                    password: string;
+                    privateKey: string;
+                    saveCredential: boolean;
+                };
+            }>;
+            connections: Record<string, import('../../connections').Connection>;
+            createConnection: () => void;
+            submitConnectionCreation: () => Promise<void>;
+        }, {}, {}, {
+            close(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            visible: {
+                type: BooleanConstructor;
+                required: true;
+            };
+            testTag: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            testTag: string;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        LoadingButton: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            action: {
+                type: FunctionConstructor;
+                required: true;
+            };
+            useDefaultStyle: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            keyCombination: {
+                type: {
+                    (arrayLength: number): string[];
+                    (...items: string[]): string[];
+                    new (arrayLength: number): string[];
+                    new (...items: string[]): string[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                default: null;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            testId: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {
+            errorMessage: import('vue').Ref<string | null, string | null>;
+            isLoading: import('vue').Ref<boolean, boolean>;
+            status: import('vue').Ref<"success" | "error" | null, "success" | "error" | null>;
+            handleClick: () => Promise<void>;
+            handleKeydown: (event: KeyboardEvent) => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            action: {
+                type: FunctionConstructor;
+                required: true;
+            };
+            useDefaultStyle: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            keyCombination: {
+                type: {
+                    (arrayLength: number): string[];
+                    (...items: string[]): string[];
+                    new (arrayLength: number): string[];
+                    new (...items: string[]): string[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                default: null;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            testId: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            disabled: boolean;
+            useDefaultStyle: boolean;
+            keyCombination: string[];
+            testId: string;
+        }, {}, {
+            Tooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                position: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {}, {
+                visible: boolean;
+                hoverTimeout: ReturnType<typeof setTimeout> | null;
+            }, {
+                positionClass(): string;
+            }, {
+                showTooltip(): void;
+                hideTooltip(): void;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                position: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                position: string;
+                inline: boolean;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        StatusIcon: import('vue').DefineComponent<import('../StatusIcon.vue').StatusIconProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('../StatusIcon.vue').StatusIconProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+        Tooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            content: {
+                type: StringConstructor;
+                required: true;
+            };
+            position: {
+                type: StringConstructor;
+                default: string;
+            };
+            inline: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {}, {
+            visible: boolean;
+            hoverTimeout: ReturnType<typeof setTimeout> | null;
+        }, {
+            positionClass(): string;
+        }, {
+            showTooltip(): void;
+            hideTooltip(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            content: {
+                type: StringConstructor;
+                required: true;
+            };
+            position: {
+                type: StringConstructor;
+                default: string;
+            };
+            inline: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, {
+            position: string;
+            inline: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        ConnectionListItem: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            item: {
+                type: import('vue').PropType<import('./ConnectionListItem.vue').ListItem>;
+                required: true;
+            };
+            isCollapsed: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            isSelected: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            testTag: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {
+            isMobile: boolean;
+            isExpandable: import('vue').ComputedRef<boolean>;
+            getItemName: () => string;
+            handleItemClick: () => void;
+            handleToggle: () => void;
+            toggleMobileMenu: () => void;
+            handleRefreshConnectionClick: () => void;
+            handleRefreshDatabaseClick: () => void;
+            handleRefreshSchemaClick: () => void;
+            deleteConnection: (connection: import('../../connections').Connection) => void;
+            contextMenuItems: import('vue').ComputedRef<import('../ContextMenu.vue').ContextMenuItem[]>;
+            handleContextMenuItemClick: (item: import('../ContextMenu.vue').ContextMenuItem) => void;
+            bigqueryProject: import('vue').Ref<string, string>;
+            bigqueryBrowsingProject: import('vue').Ref<string, string>;
+            mdToken: import('vue').Ref<string, string>;
+            snowflakePrivateKey: import('vue').Ref<string, string>;
+            snowflakeAccount: import('vue').Ref<string, string>;
+            snowflakeUsername: import('vue').Ref<string, string>;
+            showBillingSuccess: import('vue').Ref<boolean, boolean>;
+            showBrowsingSuccess: import('vue').Ref<boolean, boolean>;
+            showPrivateKeySuccess: import('vue').Ref<boolean, boolean>;
+            showAccountSuccess: import('vue').Ref<boolean, boolean>;
+            showUsernameSuccess: import('vue').Ref<boolean, boolean>;
+            debouncedUpdateBigqueryProject: (...args: any[]) => void;
+            debouncedUpdateBigqueryBrowsingProject: (...args: any[]) => void;
+            debouncedUpdateSnowflakePrivateKey: (...args: any[]) => void;
+            debouncedUpdateSnowflakeAccount: (...args: any[]) => void;
+            debouncedUpdateSnowflakeUsername: (...args: any[]) => void;
+            updateMotherDuckToken: (connection: import('../../connections').MotherDuckConnection, token: string) => void;
+            toggleSaveCredential: (connection: any) => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("click" | "toggle" | "deleteConnection" | "refresh" | "updateBigqueryProject" | "updateBigqueryBrowsingProject" | "updateMotherDuckToken" | "updateSnowflakePrivateKey" | "updateSnowflakeAccount" | "updateSnowflakeUsername" | "toggleSaveCredential" | "toggleMobileMenu")[], "click" | "toggle" | "deleteConnection" | "refresh" | "updateBigqueryProject" | "updateBigqueryBrowsingProject" | "updateMotherDuckToken" | "updateSnowflakePrivateKey" | "updateSnowflakeAccount" | "updateSnowflakeUsername" | "toggleSaveCredential" | "toggleMobileMenu", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            item: {
+                type: import('vue').PropType<import('./ConnectionListItem.vue').ListItem>;
+                required: true;
+            };
+            isCollapsed: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            isSelected: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            testTag: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{
+            onClick?: ((...args: any[]) => any) | undefined;
+            onToggle?: ((...args: any[]) => any) | undefined;
+            onRefresh?: ((...args: any[]) => any) | undefined;
+            onDeleteConnection?: ((...args: any[]) => any) | undefined;
+            onUpdateBigqueryProject?: ((...args: any[]) => any) | undefined;
+            onUpdateBigqueryBrowsingProject?: ((...args: any[]) => any) | undefined;
+            onUpdateMotherDuckToken?: ((...args: any[]) => any) | undefined;
+            onUpdateSnowflakePrivateKey?: ((...args: any[]) => any) | undefined;
+            onUpdateSnowflakeAccount?: ((...args: any[]) => any) | undefined;
+            onUpdateSnowflakeUsername?: ((...args: any[]) => any) | undefined;
+            onToggleSaveCredential?: ((...args: any[]) => any) | undefined;
+            onToggleMobileMenu?: ((...args: any[]) => any) | undefined;
+        }>, {
+            testTag: string;
+            isSelected: boolean;
+            isCollapsed: boolean;
+        }, {}, {
+            SidebarItem: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                itemId: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                name: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                indent: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                isSelected: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                isCollapsible: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                isCollapsed: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                icon: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                extraInfo: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: string;
+                };
+                itemType: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>, {}, {}, {}, {
+                handleClick(): void;
+                handleToggle(): void;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("click" | "toggle")[], "click" | "toggle", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                itemId: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                name: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                indent: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                isSelected: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                isCollapsible: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                isCollapsed: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                icon: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                extraInfo: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: string;
+                };
+                itemType: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>> & Readonly<{
+                onClick?: ((...args: any[]) => any) | undefined;
+                onToggle?: ((...args: any[]) => any) | undefined;
+            }>, {
+                icon: string;
+                indent: number;
+                isSelected: boolean;
+                isCollapsible: boolean;
+                isCollapsed: boolean;
+                extraInfo: string | number;
+                itemType: string;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            ConnectionIcon: import('vue').DefineComponent<import('./ConnectionIcon.vue').ConnectionIconProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('./ConnectionIcon.vue').ConnectionIconProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+            ConnectionStatusIcon: import('vue').DefineComponent<import('./ConnectionStatusIcon.vue').StatusIconProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('./ConnectionStatusIcon.vue').StatusIconProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+            ConnectionRefresh: import('vue').DefineComponent<import('./ConnectionRefresh.vue').RefreshButtonProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+                refresh: (connectionName: string) => any;
+            }, string, import('vue').PublicProps, Readonly<import('./ConnectionRefresh.vue').RefreshButtonProps> & Readonly<{
+                onRefresh?: ((connectionName: string) => any) | undefined;
+            }>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+            CreateEditorFromDatasourcePopup: import('vue').DefineComponent<import('./CreateEditorFromDatasourcePopup.vue').CreateDatasourcePopupProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+                close: () => any;
+            }, string, import('vue').PublicProps, Readonly<import('./CreateEditorFromDatasourcePopup.vue').CreateDatasourcePopupProps> & Readonly<{
+                onClose?: (() => any) | undefined;
+            }>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+                nameInput: HTMLInputElement;
+            }, HTMLDivElement>;
+            DuckDBImporter: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                connection: {
+                    type: () => import('../../connections').DuckDBConnection;
+                    required: true;
+                };
+            }>, {
+                isDragging: import('vue').Ref<boolean, boolean>;
+                isLoading: import('vue').Ref<boolean, boolean>;
+                loadingMessage: import('vue').Ref<string, string>;
+                successMessage: import('vue').Ref<string, string>;
+                fileInput: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+                openFilePicker: () => void;
+                handleDragOver: () => void;
+                handleDragLeave: () => void;
+                handleDrop: (event: DragEvent) => Promise<void>;
+                handleFileInput: (event: Event) => Promise<void>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                connection: {
+                    type: () => import('../../connections').DuckDBConnection;
+                    required: true;
+                };
+            }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            ModelSelector: import('vue').DefineComponent<import('../model/ModelSelector.vue').ModelSelectorProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('../model/ModelSelector.vue').ModelSelectorProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+            Tooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                position: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {}, {
+                visible: boolean;
+                hoverTimeout: ReturnType<typeof setTimeout> | null;
+            }, {
+                positionClass(): string;
+            }, {
+                showTooltip(): void;
+                hideTooltip(): void;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                position: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                position: string;
+                inline: boolean;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            SidebarOverflowMenu: import('vue').DefineComponent<import('./SidebarOverflowMenu.vue').SidebarOverflowMenuProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                select: (item: import('../ContextMenu.vue').ContextMenuItem) => any;
+            }, string, import('vue').PublicProps, Readonly<import('./SidebarOverflowMenu.vue').SidebarOverflowMenuProps> & Readonly<{
+                onSelect?: ((item: import('../ContextMenu.vue').ContextMenuItem) => any) | undefined;
+            }>, {
+                tooltip: string;
+                menuWidth: number;
+                buttonClass: string;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    Tooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        content: {
+            type: StringConstructor;
+            required: true;
+        };
+        position: {
+            type: StringConstructor;
+            default: string;
+        };
+        inline: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>, {}, {
+        visible: boolean;
+        hoverTimeout: ReturnType<typeof setTimeout> | null;
+    }, {
+        positionClass(): string;
+    }, {
+        showTooltip(): void;
+        hideTooltip(): void;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        content: {
+            type: StringConstructor;
+            required: true;
+        };
+        position: {
+            type: StringConstructor;
+            default: string;
+        };
+        inline: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{}>, {
+        position: string;
+        inline: boolean;
+    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    TutorialSidebar: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        activeDocumentationKey: {
+            type: StringConstructor;
+            default: string;
+            optional: boolean;
+        };
+    }>, {
+        documentationNodes: import('vue').ComputedRef<{
+            id: string;
+            name: string;
+            indent: number;
+            count: number;
+            type: string;
+        }[]>;
+        toggleCollapse: (id: string) => void;
+        collapsed: import('vue').Ref<Record<string, boolean>, Record<string, boolean>>;
+        isActiveNode: (id: string) => boolean;
+    }, {}, {}, {
+        handleClick(id: string): void;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        activeDocumentationKey: {
+            type: StringConstructor;
+            default: string;
+            optional: boolean;
+        };
+    }>> & Readonly<{}>, {
+        activeDocumentationKey: string;
+    }, {}, {
+        SidebarList: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            title: {
+                type: StringConstructor;
+                required: true;
+            };
+        }>, {
+            title: string;
+            isMobile: boolean | undefined;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            title: {
+                type: StringConstructor;
+                required: true;
+            };
+        }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        SidebarItem: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            itemId: {
+                type: StringConstructor;
+                required: true;
+            };
+            name: {
+                type: StringConstructor;
+                required: true;
+            };
+            indent: {
+                type: NumberConstructor;
+                default: number;
+            };
+            isSelected: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            isCollapsible: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            isCollapsed: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            icon: {
+                type: StringConstructor;
+                default: string;
+            };
+            extraInfo: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: string;
+            };
+            itemType: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {}, {}, {}, {
+            handleClick(): void;
+            handleToggle(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("click" | "toggle")[], "click" | "toggle", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            itemId: {
+                type: StringConstructor;
+                required: true;
+            };
+            name: {
+                type: StringConstructor;
+                required: true;
+            };
+            indent: {
+                type: NumberConstructor;
+                default: number;
+            };
+            isSelected: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            isCollapsible: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            isCollapsed: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            icon: {
+                type: StringConstructor;
+                default: string;
+            };
+            extraInfo: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: string;
+            };
+            itemType: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{
+            onClick?: ((...args: any[]) => any) | undefined;
+            onToggle?: ((...args: any[]) => any) | undefined;
+        }>, {
+            icon: string;
+            indent: number;
+            isSelected: boolean;
+            isCollapsible: boolean;
+            isCollapsed: boolean;
+            extraInfo: string | number;
+            itemType: string;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    ModelSidebar: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        activeModelKey: StringConstructor;
+        testTag: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>, {
+        creatorVisible: import('vue').Ref<boolean, boolean>;
+        flatList: import('vue').ComputedRef<{
+            id: string;
+            name: string;
+            indent: number;
+            count: number;
+            type: string;
+            concept: any;
+        }[]>;
+        collapsed: import('vue').Ref<Record<string, boolean>, Record<string, boolean>>;
+        saveModels: Function;
+        fetchParseResults: (model: string) => Promise<void>;
+        trilogyIcon: string;
+        navigationStore: import('../../stores/useScreenNavigation').NavigationStore;
+        handleClick: (id: string) => void;
+        handleToggle: (id: string) => void;
+        modelStore: import('pinia').Store<"models", {
+            models: Record<string, import('../../models').ModelConfig>;
+        }, {
+            modelList: (state: {
+                models: Record<string, import('../../models').ModelConfig>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                models: Record<string, import('../../models').ModelConfig>;
+            }>) => import('../../models').ModelConfig[];
+            unsavedModels: (state: {
+                models: Record<string, import('../../models').ModelConfig>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                models: Record<string, import('../../models').ModelConfig>;
+            }>) => number;
+        }, {
+            newModelConfig(name: string, force?: boolean): import('../../models').ModelConfig;
+            addModelConfig(model: import('../../models').ModelConfig): void;
+            removeModelConfig(name: string): void;
+            updateModelName(name: string, newName: string): void;
+            addEditorAsModelSource(model: string, editor: import('../../editors').Editor): void;
+            addModelConfigSource(name: string, contents: import('../../models').ModelSource): void;
+            removeModelConfigSource(name: string, contents: string): void;
+            setModelConfigParseResults(name: string, results: import('../../models').ModelParseResults): void;
+            setModelParseError(name: string, error: string): void;
+        }>;
+        contextMenuItems: (item: any) => import('../ContextMenu.vue').ContextMenuItem[];
+        handleContextMenuItemClick: (item: any, menuItem: import('../ContextMenu.vue').ContextMenuItem) => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        activeModelKey: StringConstructor;
+        testTag: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>> & Readonly<{}>, {
+        testTag: string;
+    }, {}, {
+        SidebarList: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            title: {
+                type: StringConstructor;
+                required: true;
+            };
+        }>, {
+            title: string;
+            isMobile: boolean | undefined;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            title: {
+                type: StringConstructor;
+                required: true;
+            };
+        }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        SidebarItem: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            itemId: {
+                type: StringConstructor;
+                required: true;
+            };
+            name: {
+                type: StringConstructor;
+                required: true;
+            };
+            indent: {
+                type: NumberConstructor;
+                default: number;
+            };
+            isSelected: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            isCollapsible: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            isCollapsed: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            icon: {
+                type: StringConstructor;
+                default: string;
+            };
+            extraInfo: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: string;
+            };
+            itemType: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {}, {}, {}, {
+            handleClick(): void;
+            handleToggle(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("click" | "toggle")[], "click" | "toggle", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            itemId: {
+                type: StringConstructor;
+                required: true;
+            };
+            name: {
+                type: StringConstructor;
+                required: true;
+            };
+            indent: {
+                type: NumberConstructor;
+                default: number;
+            };
+            isSelected: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            isCollapsible: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            isCollapsed: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            icon: {
+                type: StringConstructor;
+                default: string;
+            };
+            extraInfo: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: string;
+            };
+            itemType: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{
+            onClick?: ((...args: any[]) => any) | undefined;
+            onToggle?: ((...args: any[]) => any) | undefined;
+        }>, {
+            icon: string;
+            indent: number;
+            isSelected: boolean;
+            isCollapsible: boolean;
+            isCollapsed: boolean;
+            extraInfo: string | number;
+            itemType: string;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        ModelCreator: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            formDefaults: {
+                type: ObjectConstructor;
+                required: false;
+                default: () => {};
+            };
+            visible: {
+                type: BooleanConstructor;
+                required: true;
+            };
+            testTag: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+        }>, {
+            modelDetails: import('vue').Ref<{
+                name: any;
+                importAddress: any;
+                importToken: any;
+                connection: any;
+                options: {
+                    mdToken: string;
+                    projectId: string;
+                    username: string;
+                    password: string;
+                    account: string;
+                    sshPrivateKey: string;
+                };
+            }, {
+                name: any;
+                importAddress: any;
+                importToken: any;
+                connection: any;
+                options: {
+                    mdToken: string;
+                    projectId: string;
+                    username: string;
+                    password: string;
+                    account: string;
+                    sshPrivateKey: string;
+                };
+            } | {
+                name: any;
+                importAddress: any;
+                importToken: any;
+                connection: any;
+                options: {
+                    mdToken: string;
+                    projectId: string;
+                    username: string;
+                    password: string;
+                    account: string;
+                    sshPrivateKey: string;
+                };
+            }>;
+            connections: Record<string, import('../../connections').Connection>;
+            createModel: () => void;
+            performSubmit: () => Promise<void>;
+            validateForm: () => void;
+            isFormValid: import('vue').Ref<boolean, boolean>;
+            text: string;
+            isPopupControl: boolean;
+        }, {}, {}, {
+            close(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            formDefaults: {
+                type: ObjectConstructor;
+                required: false;
+                default: () => {};
+            };
+            visible: {
+                type: BooleanConstructor;
+                required: true;
+            };
+            testTag: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            testTag: string;
+            formDefaults: Record<string, any>;
+        }, {}, {
+            Tooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                position: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {}, {
+                visible: boolean;
+                hoverTimeout: ReturnType<typeof setTimeout> | null;
+            }, {
+                positionClass(): string;
+            }, {
+                showTooltip(): void;
+                hideTooltip(): void;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                position: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                position: string;
+                inline: boolean;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            LoadingButton: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                action: {
+                    type: FunctionConstructor;
+                    required: true;
+                };
+                useDefaultStyle: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                keyCombination: {
+                    type: {
+                        (arrayLength: number): string[];
+                        (...items: string[]): string[];
+                        new (arrayLength: number): string[];
+                        new (...items: string[]): string[];
+                        isArray(arg: any): arg is any[];
+                        readonly prototype: any[];
+                        from<T>(arrayLike: ArrayLike<T>): T[];
+                        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        of<T>(...items: T[]): T[];
+                        readonly [Symbol.species]: ArrayConstructor;
+                    };
+                    default: null;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                testId: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>, {
+                errorMessage: import('vue').Ref<string | null, string | null>;
+                isLoading: import('vue').Ref<boolean, boolean>;
+                status: import('vue').Ref<"success" | "error" | null, "success" | "error" | null>;
+                handleClick: () => Promise<void>;
+                handleKeydown: (event: KeyboardEvent) => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                action: {
+                    type: FunctionConstructor;
+                    required: true;
+                };
+                useDefaultStyle: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                keyCombination: {
+                    type: {
+                        (arrayLength: number): string[];
+                        (...items: string[]): string[];
+                        new (arrayLength: number): string[];
+                        new (...items: string[]): string[];
+                        isArray(arg: any): arg is any[];
+                        readonly prototype: any[];
+                        from<T>(arrayLike: ArrayLike<T>): T[];
+                        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        of<T>(...items: T[]): T[];
+                        readonly [Symbol.species]: ArrayConstructor;
+                    };
+                    default: null;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                testId: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>> & Readonly<{}>, {
+                disabled: boolean;
+                useDefaultStyle: boolean;
+                keyCombination: string[];
+                testId: string;
+            }, {}, {
+                Tooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                    content: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    position: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    inline: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>, {}, {
+                    visible: boolean;
+                    hoverTimeout: ReturnType<typeof setTimeout> | null;
+                }, {
+                    positionClass(): string;
+                }, {
+                    showTooltip(): void;
+                    hideTooltip(): void;
+                }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                    content: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    position: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    inline: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & Readonly<{}>, {
+                    position: string;
+                    inline: boolean;
+                }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        LoadingButton: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            action: {
+                type: FunctionConstructor;
+                required: true;
+            };
+            useDefaultStyle: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            keyCombination: {
+                type: {
+                    (arrayLength: number): string[];
+                    (...items: string[]): string[];
+                    new (arrayLength: number): string[];
+                    new (...items: string[]): string[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                default: null;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            testId: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {
+            errorMessage: import('vue').Ref<string | null, string | null>;
+            isLoading: import('vue').Ref<boolean, boolean>;
+            status: import('vue').Ref<"success" | "error" | null, "success" | "error" | null>;
+            handleClick: () => Promise<void>;
+            handleKeydown: (event: KeyboardEvent) => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            action: {
+                type: FunctionConstructor;
+                required: true;
+            };
+            useDefaultStyle: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            keyCombination: {
+                type: {
+                    (arrayLength: number): string[];
+                    (...items: string[]): string[];
+                    new (arrayLength: number): string[];
+                    new (...items: string[]): string[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                default: null;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            testId: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            disabled: boolean;
+            useDefaultStyle: boolean;
+            keyCombination: string[];
+            testId: string;
+        }, {}, {
+            Tooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                position: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {}, {
+                visible: boolean;
+                hoverTimeout: ReturnType<typeof setTimeout> | null;
+            }, {
+                positionClass(): string;
+            }, {
+                showTooltip(): void;
+                hideTooltip(): void;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                position: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                position: string;
+                inline: boolean;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        Tooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            content: {
+                type: StringConstructor;
+                required: true;
+            };
+            position: {
+                type: StringConstructor;
+                default: string;
+            };
+            inline: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {}, {
+            visible: boolean;
+            hoverTimeout: ReturnType<typeof setTimeout> | null;
+        }, {
+            positionClass(): string;
+        }, {
+            showTooltip(): void;
+            hideTooltip(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            content: {
+                type: StringConstructor;
+                required: true;
+            };
+            position: {
+                type: StringConstructor;
+                default: string;
+            };
+            inline: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, {
+            position: string;
+            inline: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        SidebarOverflowMenu: import('vue').DefineComponent<import('./SidebarOverflowMenu.vue').SidebarOverflowMenuProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            select: (item: import('../ContextMenu.vue').ContextMenuItem) => any;
+        }, string, import('vue').PublicProps, Readonly<import('./SidebarOverflowMenu.vue').SidebarOverflowMenuProps> & Readonly<{
+            onSelect?: ((item: import('../ContextMenu.vue').ContextMenuItem) => any) | undefined;
+        }>, {
+            tooltip: string;
+            menuWidth: number;
+            buttonClass: string;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    JobsList: import('vue').DefineComponent<{
+        activeJobsKey?: string;
+    }, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        "jobs-key-selected": (key: string) => any;
+    }, string, import('vue').PublicProps, Readonly<{
+        activeJobsKey?: string;
+    }> & Readonly<{
+        "onJobs-key-selected"?: ((key: string) => any) | undefined;
+    }>, {
+        activeJobsKey: string;
+    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+    LLMConnectionList: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        activeLLMKey: {
+            type: StringConstructor;
+            default: string;
+            optional: boolean;
+        };
+        testTag: {
+            type: StringConstructor;
+            default: string;
+            optional: boolean;
+        };
+    }>, {
+        llmConnectionStore: import('pinia').Store<"llmConnections", {
+            connections: Record<string, import('../../llm').LLMProvider>;
+            activeConnection: string;
+        }, {
+            connectionList: (state: {
+                connections: Record<string, import('../../llm').LLMProvider>;
+                activeConnection: string;
+            } & import('pinia').PiniaCustomStateProperties<{
+                connections: Record<string, import('../../llm').LLMProvider>;
+                activeConnection: string;
+            }>) => import('../../llm').LLMProvider[];
+            unsavedConnections: (state: {
+                connections: Record<string, import('../../llm').LLMProvider>;
+                activeConnection: string;
+            } & import('pinia').PiniaCustomStateProperties<{
+                connections: Record<string, import('../../llm').LLMProvider>;
+                activeConnection: string;
+            }>) => number;
+            getConnection: (state: {
+                connections: Record<string, import('../../llm').LLMProvider>;
+                activeConnection: string;
+            } & import('pinia').PiniaCustomStateProperties<{
+                connections: Record<string, import('../../llm').LLMProvider>;
+                activeConnection: string;
+            }>) => (name: string) => import('../../llm').LLMProvider;
+            getAllConnections: (state: {
+                connections: Record<string, import('../../llm').LLMProvider>;
+                activeConnection: string;
+            } & import('pinia').PiniaCustomStateProperties<{
+                connections: Record<string, import('../../llm').LLMProvider>;
+                activeConnection: string;
+            }>) => import('../../llm').LLMProvider[];
+            getConnectionStatus: (state: {
+                connections: Record<string, import('../../llm').LLMProvider>;
+                activeConnection: string;
+            } & import('pinia').PiniaCustomStateProperties<{
+                connections: Record<string, import('../../llm').LLMProvider>;
+                activeConnection: string;
+            }>) => (name: string) => "running" | "failed" | "disabled" | "connected";
+            hasActiveDefaultConnection: (state: {
+                connections: Record<string, import('../../llm').LLMProvider>;
+                activeConnection: string;
+            } & import('pinia').PiniaCustomStateProperties<{
+                connections: Record<string, import('../../llm').LLMProvider>;
+                activeConnection: string;
+            }>) => boolean;
+        }, {
+            addConnection(connection: import('../../llm').LLMProvider, checkForDefault?: boolean): import('../../llm').LLMProvider;
+            resetConnection(name: string): Promise<void>;
+            connectionStateToStatus(connection: import('../../llm').LLMProvider | null): "running" | "failed" | "disabled" | "connected";
+            newConnection(name: string, type: string, options: Record<string, any>): Promise<import('../../llm').LLMProvider>;
+            fetchModelsForProvider(type: string, apiKey: string): Promise<string[]>;
+            generateValidatedCompletion(base: string, validator?: Function | null, maxAttempts?: number, modelOverride?: string | null, messageHistory?: import('../../llm').LLMMessage[] | null, addUserMessage?: boolean): Promise<import('../../stores/llmStore').ValidatedResponse>;
+            generateDashboardCompletion(inputString: string, validator?: Function | null, concepts?: import('../../llm').ModelConceptInput[], maxAttempts?: number): Promise<string | null>;
+            generateQueryCompletion(inputString: string, concepts: import('../../llm').ModelConceptInput[], validator?: Function | null, maxAttempts?: number, modelOverride?: string | null): Promise<import('../../stores/llmStore').ValidatedResponse>;
+            generateSQLQueryCompletion(inputString: string): Promise<import('../../stores/llmStore').ValidatedResponse>;
+            generateFilterQuery(inputString: string, concepts: import('../../llm').ModelConceptInput[], validator?: Function | null, maxAttempts?: number): Promise<string | null>;
+            generateChatName(connectionName: string, messages: import('../../llm').LLMMessage[]): Promise<string>;
+            generateCompletion(name: string, options: import('../../llm').LLMRequestOptions, history?: import('../../llm').LLMMessage[] | null): Promise<import('../../llm').LLMResponse>;
+        }>;
+        chatStore: import('pinia').Store<"chats", {
+            chats: Record<string, import('../../chats').Chat>;
+            activeChatId: string;
+            chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+        }, {
+            chatList: (state: {
+                chats: Record<string, import('../../chats').Chat>;
+                activeChatId: string;
+                chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                chats: Record<string, import('../../chats').Chat>;
+                activeChatId: string;
+                chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+            }>) => import('../../chats').Chat[];
+            unsavedChats: (state: {
+                chats: Record<string, import('../../chats').Chat>;
+                activeChatId: string;
+                chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                chats: Record<string, import('../../chats').Chat>;
+                activeChatId: string;
+                chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+            }>) => number;
+            activeChat: (state: {
+                chats: Record<string, import('../../chats').Chat>;
+                activeChatId: string;
+                chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                chats: Record<string, import('../../chats').Chat>;
+                activeChatId: string;
+                chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+            }>) => import('../../chats').Chat | null;
+            getConnectionChats: (state: {
+                chats: Record<string, import('../../chats').Chat>;
+                activeChatId: string;
+                chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                chats: Record<string, import('../../chats').Chat>;
+                activeChatId: string;
+                chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+            }>) => (llmConnectionName: string) => import('../../chats').Chat[];
+            getChatById: (state: {
+                chats: Record<string, import('../../chats').Chat>;
+                activeChatId: string;
+                chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                chats: Record<string, import('../../chats').Chat>;
+                activeChatId: string;
+                chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+            }>) => (chatId: string) => import('../../chats').Chat | null;
+            getChatExecution: (state: {
+                chats: Record<string, import('../../chats').Chat>;
+                activeChatId: string;
+                chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                chats: Record<string, import('../../chats').Chat>;
+                activeChatId: string;
+                chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+            }>) => (chatId: string) => import('../../stores/chatStore').ChatExecution | null;
+            isChatExecuting: (state: {
+                chats: Record<string, import('../../chats').Chat>;
+                activeChatId: string;
+                chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                chats: Record<string, import('../../chats').Chat>;
+                activeChatId: string;
+                chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+            }>) => (chatId: string) => boolean;
+            getChatActiveToolName: (state: {
+                chats: Record<string, import('../../chats').Chat>;
+                activeChatId: string;
+                chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                chats: Record<string, import('../../chats').Chat>;
+                activeChatId: string;
+                chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+            }>) => (chatId: string) => string;
+            getChatRateLimitBackoff: (state: {
+                chats: Record<string, import('../../chats').Chat>;
+                activeChatId: string;
+                chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                chats: Record<string, import('../../chats').Chat>;
+                activeChatId: string;
+                chatExecutions: Record<string, import('../../stores/chatStore').ChatExecution>;
+            }>) => (chatId: string) => import('../../stores/chatStore').RateLimitBackoff | null;
+        }, {
+            newChat(llmConnectionName: string, dataConnectionName?: string, name?: string): import('../../chats').Chat;
+            addChat(chat: import('../../chats').Chat): void;
+            removeChat(id: string): void;
+            setActiveChat(id: string): void;
+            clearActiveChat(): void;
+            updateChatName(chatId: string, name: string): void;
+            updateChatDataConnection(chatId: string, connectionName: string): void;
+            addMessageToChat(chatId: string, message: import('../llm').ChatMessage): void;
+            addArtifactToChat(chatId: string, artifact: import('../llm').ChatArtifactType): number;
+            setActiveArtifact(chatId: string, index: number): void;
+            setImports(chatId: string, imports: import('../../chats/chat').ChatImport[]): void;
+            addImportToChat(chatId: string, imp: import('../../chats/chat').ChatImport): boolean;
+            removeImportFromChat(chatId: string, importId: string): boolean;
+            clearChatMessages(chatId: string): void;
+            loadChats(serializedChats: Record<string, any>): void;
+            serializeChats(): Record<string, any>;
+            markAllSaved(): void;
+            purgeDeleted(): void;
+            startExecution(chatId: string): void;
+            stopExecution(chatId: string): void;
+            setRateLimitBackoff(chatId: string, attempt: number, delayMs: number): void;
+            clearRateLimitBackoff(chatId: string): void;
+            setActiveToolName(chatId: string, toolName: string): void;
+            completeExecution(chatId: string, error?: string): void;
+            clearExecution(chatId: string): void;
+            executeMessage(chatId: string, message: string, deps: import('../../stores/chatStore').ChatExecutionDependencies, options?: {
+                onSymbolsRefresh?: () => Promise<import('../../stores/resolver').CompletionItem[]>;
+            }): Promise<{
+                response?: string;
+                artifacts?: import('../llm').ChatArtifactType[];
+            } | void>;
+            buildSystemPrompt(chatId: string, deps: import('../../stores/chatStore').ChatExecutionDependencies): string;
+        }>;
+        contentList: import('vue').ComputedRef<{
+            id: string;
+            name: string;
+            indent: number;
+            count: number;
+            type: "model" | "fast-model" | "connection" | "settings-group" | "toggle-save-credential" | "refresh-connection" | "error" | "api-key" | "loading" | "open-chat" | "open-validation" | "new-chat" | "chat-item" | "chats-header";
+            connection: any | undefined;
+            chat?: import('../../chats').Chat;
+            chatId?: string;
+        }[]>;
+        toggleCollapse: (id: string, connectionName: string, type: string, extraData?: any) => Promise<void>;
+        collapsed: import('vue').Ref<Record<string, boolean>, Record<string, boolean>>;
+        saveConnections: Function;
+        updateApiKey: (connection: import('../../llm').LLMProvider, apiKey: string) => Promise<void>;
+        updateModel: (connection: import('../../llm').LLMProvider, model: string) => void;
+        updateFastModel: (connection: import('../../llm').LLMProvider, fastModel: string | null) => void;
+        refreshId: (id: string, connectionName: string, type: string) => Promise<void>;
+        creatorVisible: import('vue').Ref<boolean, boolean>;
+        isItemSelected: (item: any) => boolean;
+        screenNavigation: import('../../stores/useScreenNavigation').NavigationStore;
+    }, {}, {
+        connections(): import('../../llm').LLMProvider[];
+    }, {
+        resetConnection(connection: import('../../llm').LLMProvider): Promise<void>;
+        setActiveConnection(connectionName: string): void;
+        deleteConnection(id: string, connectionName: string): void;
+        deleteChat(chatId: string, _connectionName: string): void;
+        toggleSaveCredential(connection: import('../../llm').LLMProvider): void;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("open-chat" | "llm-open-view" | "create-new-chat")[], "open-chat" | "llm-open-view" | "create-new-chat", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        activeLLMKey: {
+            type: StringConstructor;
+            default: string;
+            optional: boolean;
+        };
+        testTag: {
+            type: StringConstructor;
+            default: string;
+            optional: boolean;
+        };
+    }>> & Readonly<{
+        "onOpen-chat"?: ((...args: any[]) => any) | undefined;
+        "onLlm-open-view"?: ((...args: any[]) => any) | undefined;
+        "onCreate-new-chat"?: ((...args: any[]) => any) | undefined;
+    }>, {
+        testTag: string;
+        activeLLMKey: string;
+    }, {}, {
+        SidebarList: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            title: {
+                type: StringConstructor;
+                required: true;
+            };
+        }>, {
+            title: string;
+            isMobile: boolean | undefined;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            title: {
+                type: StringConstructor;
+                required: true;
+            };
+        }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        LLMConnectionListItem: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            item: {
+                type: import('vue').PropType<import('./LLMConnectionListItem.vue').ListItem>;
+                required: true;
+            };
+            isCollapsed: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            isSelected: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {
+            apiKeyInput: import('vue').Ref<string, string>;
+            selectedModel: import('vue').Ref<string, string>;
+            selectedFastModel: import('vue').Ref<string, string>;
+            isExpandable: import('vue').ComputedRef<boolean>;
+            getItemName: () => string;
+            handleItemClick: () => void;
+            handleRefreshConnectionClick: (event: Event) => void;
+            getProviderType: (connection: import('../../llm').LLMProvider) => string;
+            isConnected: (connection: import('../../llm').LLMProvider) => boolean;
+            setAsActive: (id: string) => void;
+            updateApiKey: (connection: import('../../llm').LLMProvider, apiKey: string) => void;
+            updateModel: (connection: import('../../llm').LLMProvider, model: string) => void;
+            updateFastModel: (connection: import('../../llm').LLMProvider, fastModel: string | null) => void;
+            handleApiKeyInput: () => void;
+            handleModelChange: () => void;
+            handleFastModelChange: () => void;
+            toggleSaveCredential: (connection: import('../../llm').LLMProvider) => void;
+            deleteConnection: (id: string) => void;
+            deleteChat: (chatId: string | undefined) => void;
+            contextMenuItems: import('vue').ComputedRef<import('../ContextMenu.vue').ContextMenuItem[]>;
+            handleContextMenuItemClick: (item: import('../ContextMenu.vue').ContextMenuItem) => void;
+            toggleCollapse: (id: string) => void;
+            showApiKey: import('vue').Ref<boolean, boolean>;
+            toggleApiKeyVisibility: () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("toggle" | "deleteConnection" | "refresh" | "toggleSaveCredential" | "setActive" | "updateApiKey" | "updateModel" | "updateFastModel" | "deleteChat")[], "toggle" | "deleteConnection" | "refresh" | "toggleSaveCredential" | "setActive" | "updateApiKey" | "updateModel" | "updateFastModel" | "deleteChat", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            item: {
+                type: import('vue').PropType<import('./LLMConnectionListItem.vue').ListItem>;
+                required: true;
+            };
+            isCollapsed: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            isSelected: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            onToggle?: ((...args: any[]) => any) | undefined;
+            onRefresh?: ((...args: any[]) => any) | undefined;
+            onDeleteConnection?: ((...args: any[]) => any) | undefined;
+            onToggleSaveCredential?: ((...args: any[]) => any) | undefined;
+            onSetActive?: ((...args: any[]) => any) | undefined;
+            onUpdateApiKey?: ((...args: any[]) => any) | undefined;
+            onUpdateModel?: ((...args: any[]) => any) | undefined;
+            onUpdateFastModel?: ((...args: any[]) => any) | undefined;
+            onDeleteChat?: ((...args: any[]) => any) | undefined;
+        }>, {
+            isSelected: boolean;
+            isCollapsed: boolean;
+        }, {}, {
+            SidebarItem: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                itemId: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                name: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                indent: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                isSelected: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                isCollapsible: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                isCollapsed: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                icon: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                extraInfo: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: string;
+                };
+                itemType: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>, {}, {}, {}, {
+                handleClick(): void;
+                handleToggle(): void;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("click" | "toggle")[], "click" | "toggle", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                itemId: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                name: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                indent: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                isSelected: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                isCollapsible: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                isCollapsed: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                icon: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                extraInfo: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: string;
+                };
+                itemType: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>> & Readonly<{
+                onClick?: ((...args: any[]) => any) | undefined;
+                onToggle?: ((...args: any[]) => any) | undefined;
+            }>, {
+                icon: string;
+                indent: number;
+                isSelected: boolean;
+                isCollapsible: boolean;
+                isCollapsed: boolean;
+                extraInfo: string | number;
+                itemType: string;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            LLMProviderIcon: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                providerType: {
+                    type: StringConstructor;
+                    required: true;
+                };
+            }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                providerType: {
+                    type: StringConstructor;
+                    required: true;
+                };
+            }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            ConnectionStatusIcon: import('vue').DefineComponent<import('./ConnectionStatusIcon.vue').StatusIconProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('./ConnectionStatusIcon.vue').StatusIconProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+            Tooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                position: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {}, {
+                visible: boolean;
+                hoverTimeout: ReturnType<typeof setTimeout> | null;
+            }, {
+                positionClass(): string;
+            }, {
+                showTooltip(): void;
+                hideTooltip(): void;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                position: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                position: string;
+                inline: boolean;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            SidebarOverflowMenu: import('vue').DefineComponent<import('./SidebarOverflowMenu.vue').SidebarOverflowMenuProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                select: (item: import('../ContextMenu.vue').ContextMenuItem) => any;
+            }, string, import('vue').PublicProps, Readonly<import('./SidebarOverflowMenu.vue').SidebarOverflowMenuProps> & Readonly<{
+                onSelect?: ((item: import('../ContextMenu.vue').ContextMenuItem) => any) | undefined;
+            }>, {
+                tooltip: string;
+                menuWidth: number;
+                buttonClass: string;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        LLMConnectionCreator: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            visible: {
+                type: BooleanConstructor;
+                required: true;
+            };
+            testTag: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+        }>, {
+            connectionDetails: import('vue').Ref<{
+                name: string;
+                type: string;
+                options: {
+                    apiKey: string;
+                    model: string;
+                    saveCredential: boolean;
+                };
+            }, {
+                name: string;
+                type: string;
+                options: {
+                    apiKey: string;
+                    model: string;
+                    saveCredential: boolean;
+                };
+            } | {
+                name: string;
+                type: string;
+                options: {
+                    apiKey: string;
+                    model: string;
+                    saveCredential: boolean;
+                };
+            }>;
+            connections: Record<string, import('../../llm').LLMProvider>;
+            createConnection: () => void;
+            handleSubmitConnection: () => Promise<string>;
+            submitConnectionCreation: () => Promise<void>;
+            updateDefaultModel: (providerType: string) => void;
+        }, {}, {}, {
+            close(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            visible: {
+                type: BooleanConstructor;
+                required: true;
+            };
+            testTag: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            testTag: string;
+        }, {}, {
+            LoadingButton: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                action: {
+                    type: FunctionConstructor;
+                    required: true;
+                };
+                useDefaultStyle: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                keyCombination: {
+                    type: {
+                        (arrayLength: number): string[];
+                        (...items: string[]): string[];
+                        new (arrayLength: number): string[];
+                        new (...items: string[]): string[];
+                        isArray(arg: any): arg is any[];
+                        readonly prototype: any[];
+                        from<T>(arrayLike: ArrayLike<T>): T[];
+                        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        of<T>(...items: T[]): T[];
+                        readonly [Symbol.species]: ArrayConstructor;
+                    };
+                    default: null;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                testId: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>, {
+                errorMessage: import('vue').Ref<string | null, string | null>;
+                isLoading: import('vue').Ref<boolean, boolean>;
+                status: import('vue').Ref<"success" | "error" | null, "success" | "error" | null>;
+                handleClick: () => Promise<void>;
+                handleKeydown: (event: KeyboardEvent) => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                action: {
+                    type: FunctionConstructor;
+                    required: true;
+                };
+                useDefaultStyle: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                keyCombination: {
+                    type: {
+                        (arrayLength: number): string[];
+                        (...items: string[]): string[];
+                        new (arrayLength: number): string[];
+                        new (...items: string[]): string[];
+                        isArray(arg: any): arg is any[];
+                        readonly prototype: any[];
+                        from<T>(arrayLike: ArrayLike<T>): T[];
+                        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        of<T>(...items: T[]): T[];
+                        readonly [Symbol.species]: ArrayConstructor;
+                    };
+                    default: null;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                testId: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>> & Readonly<{}>, {
+                disabled: boolean;
+                useDefaultStyle: boolean;
+                keyCombination: string[];
+                testId: string;
+            }, {}, {
+                Tooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                    content: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    position: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    inline: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>, {}, {
+                    visible: boolean;
+                    hoverTimeout: ReturnType<typeof setTimeout> | null;
+                }, {
+                    positionClass(): string;
+                }, {
+                    showTooltip(): void;
+                    hideTooltip(): void;
+                }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                    content: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    position: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    inline: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & Readonly<{}>, {
+                    position: string;
+                    inline: boolean;
+                }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    DashboardList: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        activeDashboardKey: StringConstructor;
+        testTag: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>, {
+        connectionStore: import('pinia').Store<"connections", {
+            connections: Record<string, import('../../connections').Connection>;
+        }, {
+            connectionList: (state: {
+                connections: Record<string, import('../../connections').Connection>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                connections: Record<string, import('../../connections').Connection>;
+            }>) => import('../../connections').Connection[];
+            unsavedConnections: (state: {
+                connections: Record<string, import('../../connections').Connection>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                connections: Record<string, import('../../connections').Connection>;
+            }>) => number;
+        }, {
+            addConnection(connection: import('../../connections').Connection): import('../../connections').Connection;
+            connectConnection(name: string): Promise<any>;
+            resetConnection(name: string): Promise<any>;
+            deleteConnection(name: string): void;
+            connectionStateToStatus(connection: import('../../connections').Connection | null): "running" | "failed" | "disabled" | "connected";
+            getConnectionSources(name: string): import('../../stores').ContentInput[];
+            newConnection(name: string, type: string, options: Record<string, any>): import('../../connections').Connection;
+        }>;
+        dashboardStore: import('pinia').Store<"dashboards", {
+            dashboards: Record<string, import('../../dashboards').DashboardModel>;
+            activeDashboardId: string;
+            queryExecutors: Record<string, import('../../dashboards/dashboardQueryExecutor').DashboardQueryExecutor>;
+        }, {
+            dashboardList: (state: {
+                dashboards: Record<string, import('../../dashboards').DashboardModel>;
+                activeDashboardId: string;
+                queryExecutors: Record<string, import('../../dashboards/dashboardQueryExecutor').DashboardQueryExecutor>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                dashboards: Record<string, import('../../dashboards').DashboardModel>;
+                activeDashboardId: string;
+                queryExecutors: Record<string, import('../../dashboards/dashboardQueryExecutor').DashboardQueryExecutor>;
+            }>) => import('../../dashboards').DashboardModel[];
+            activeDashboard: (state: {
+                dashboards: Record<string, import('../../dashboards').DashboardModel>;
+                activeDashboardId: string;
+                queryExecutors: Record<string, import('../../dashboards/dashboardQueryExecutor').DashboardQueryExecutor>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                dashboards: Record<string, import('../../dashboards').DashboardModel>;
+                activeDashboardId: string;
+                queryExecutors: Record<string, import('../../dashboards/dashboardQueryExecutor').DashboardQueryExecutor>;
+            }>) => import('../../dashboards').DashboardModel | null;
+            getConnectionDashboards: (state: {
+                dashboards: Record<string, import('../../dashboards').DashboardModel>;
+                activeDashboardId: string;
+                queryExecutors: Record<string, import('../../dashboards/dashboardQueryExecutor').DashboardQueryExecutor>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                dashboards: Record<string, import('../../dashboards').DashboardModel>;
+                activeDashboardId: string;
+                queryExecutors: Record<string, import('../../dashboards/dashboardQueryExecutor').DashboardQueryExecutor>;
+            }>) => (connection: string) => import('../../dashboards').DashboardModel[];
+            unsavedDashboards: (state: {
+                dashboards: Record<string, import('../../dashboards').DashboardModel>;
+                activeDashboardId: string;
+                queryExecutors: Record<string, import('../../dashboards/dashboardQueryExecutor').DashboardQueryExecutor>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                dashboards: Record<string, import('../../dashboards').DashboardModel>;
+                activeDashboardId: string;
+                queryExecutors: Record<string, import('../../dashboards/dashboardQueryExecutor').DashboardQueryExecutor>;
+            }>) => number;
+            activeQueryExecutor: (state: {
+                dashboards: Record<string, import('../../dashboards').DashboardModel>;
+                activeDashboardId: string;
+                queryExecutors: Record<string, import('../../dashboards/dashboardQueryExecutor').DashboardQueryExecutor>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                dashboards: Record<string, import('../../dashboards').DashboardModel>;
+                activeDashboardId: string;
+                queryExecutors: Record<string, import('../../dashboards/dashboardQueryExecutor').DashboardQueryExecutor>;
+            }>) => import('../../dashboards/dashboardQueryExecutor').DashboardQueryExecutor | null;
+            hasQueryExecutor: (state: {
+                dashboards: Record<string, import('../../dashboards').DashboardModel>;
+                activeDashboardId: string;
+                queryExecutors: Record<string, import('../../dashboards/dashboardQueryExecutor').DashboardQueryExecutor>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                dashboards: Record<string, import('../../dashboards').DashboardModel>;
+                activeDashboardId: string;
+                queryExecutors: Record<string, import('../../dashboards/dashboardQueryExecutor').DashboardQueryExecutor>;
+            }>) => (dashboardId: string) => true;
+        }, {
+            getOrCreateQueryExecutor(dashboardId: string, dependencies: import('../../dashboards/dashboardQueryExecutor').QueryExecutorDependencies): import('../../dashboards/dashboardQueryExecutor').DashboardQueryExecutor;
+            getQueryExecutor(dashboardId: string): import('../../dashboards/dashboardQueryExecutor').DashboardQueryExecutor | null;
+            removeQueryExecutor(dashboardId: string): boolean;
+            clearAllQueryExecutors(): void;
+            getQueryExecutorStatuses(): Record<string, any>;
+            getDashboardByName(name: string): import('../../dashboards').DashboardModel | null;
+            newDashboard(name: string, connection: string): import('../../dashboards').DashboardModel;
+            cloneDashboard(id: string): import('../../dashboards').DashboardModel;
+            addDashboard(dashboard: import('../../dashboards').DashboardModel): void;
+            loadDashboards(serializedDashboards: Record<string, any>): void;
+            removeAllFilters(dashboardId: string): string[];
+            getConnectionDashboardsSync(connection: string): import('../../dashboards').DashboardModel[];
+            setActiveDashboard(id: string): void;
+            setDashboardState(id: string, state: "editing" | "published" | "locked"): void;
+            updateDashboardName(id: string, newName: string): void;
+            updateDashboardFilter(id: string, filter: string): string[];
+            updateDashboardImports(id: string, imports: import('../../dashboards/base').DashboardImport[]): void;
+            removeDashboard(id: string): void;
+            setState(dashboardId: string, state: import('../../dashboards/base').DashboardState): void;
+            addItemToDashboard(dashboardId: string, type: import('../../dashboards/base').CellType, x?: number, y?: number, w?: number, h?: number | null, content?: string | null, name?: string | null): string;
+            updateDashboardTitle(dashboardId: string, newTitle: string): void;
+            updateItemContent(dashboardId: string, itemId: string, content: string): void;
+            updateItemCrossFilterEligibility(dashboardId: string, itemId: string, allowCrossFilter: boolean): void;
+            updateItemResults(dashboardId: string, itemId: string, results: import('../../editors/results').Results): void;
+            updateItemLoading(dashboardId: string, itemId: string, loading: boolean): void;
+            updateItemError(dashboardId: string, itemId: string, error: string | null): void;
+            updateItemDrilldown(dashboardId: string, itemId: string, drilldown: string | null): void;
+            updateItemDrilldownChartConfig(dashboardId: string, itemId: string, drilldownChartConfig: import('../../editors/results').ChartConfig | null): void;
+            updateItemType(dashboardId: string, itemId: string, type: import('../../dashboards/base').DashboardTypes["CellType"]): void;
+            updateItemCrossFilters(dashboardId: string, itemId: string, conceptMap: Record<string, string>, chartMap: Record<string, string>, operation: "add" | "append" | "remove"): string[];
+            removeItemCrossFilter(dashboardId: string, itemId: string, source: string): string;
+            removeItemCrossFilterSource(dashboardId: string, itemId: string): string[];
+            updateItemName(dashboardId: string, itemId: string, name: string): void;
+            updateItemChartConfig(dashboardId: string, itemId: string, config: any): void;
+            updateMultipleItemProperties(dashboardId: string, itemId: string, updates: import('../../dashboards/base').ItemPropertyUpdates): void;
+            updateDashboardConnection(dashboardId: string, connection: string): void;
+            updateDashboardDescription(dashboardId: string, description: string): void;
+            updateDashboardLayout(dashboardId: string, newLayout: import('../../dashboards/base').LayoutItem[]): void;
+            updateItemDimensions(dashboardId: string, itemId: string, width: number, height: number): void;
+            updateItemLayoutDimensions(dashboardId: string, itemId: string, x?: number | null, y?: number | null, w?: number | null, h?: number | null): void;
+            removeItemFromDashboard(dashboardId: string, itemId: string): void;
+            copyItemInDashboard(dashboardId: string, itemId: string): string;
+            clearDashboardItems(dashboardId: string): void;
+            serializeDashboards(): Record<string, any>;
+            warmDashboardQueries(dashboardId: string, queryExecutionService: import('../../stores').QueryExecutionService, editorStore: import('../../stores/editorStore').EditorStoreType): Promise<void>;
+            populateCompletion(dashboardId: string, queryExecutionService: import('../../stores').QueryExecutionService, editorStore: import('../../stores/editorStore').EditorStoreType): Promise<import('../../stores/resolver').CompletionItem[]>;
+            populateAIConcepts(dashboardId: string, queryExecutionService: import('../../stores').QueryExecutionService, editorStore: import('../../stores/editorStore').EditorStoreType): Promise<import('../../llm').ModelConceptInput[]>;
+            generatePromptSpec(prompt: string, llmStore: import('../../main').LLMConnectionStoreType, queryExecutionService: import('../../stores').QueryExecutionService, editorStore: import('../../stores/editorStore').EditorStoreType): Promise<import('../../dashboards/prompts').PromptDashboard>;
+            populateFromPromptSpec(dashboardId: string, promptLayout: import('../../dashboards/prompts').PromptDashboard, llmStore: import('../../main').LLMConnectionStoreType, queryExecutionService: import('../../stores').QueryExecutionService, editorStore: import('../../stores/editorStore').EditorStoreType): Promise<void>;
+        }>;
+        contentList: import('vue').ComputedRef<any[]>;
+        toggleCollapse: (key: string) => void;
+        collapsed: import('vue').Ref<Record<string, boolean>, Record<string, boolean>>;
+        creatorVisible: import('vue').Ref<boolean, boolean>;
+        importPopupVisible: import('vue').Ref<boolean, boolean>;
+        saveDashboards: Function;
+        showDeleteConfirmationState: import('vue').Ref<boolean, boolean>;
+        showDeleteConfirmation: (item: import('../../dashboards').DashboardModel) => void;
+        cancelDelete: () => void;
+        confirmDelete: () => Promise<void>;
+    }, {}, {}, {
+        dashboardCreated(id: string): void;
+        clickAction(item: any): void;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        activeDashboardKey: StringConstructor;
+        testTag: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>> & Readonly<{}>, {
+        testTag: string;
+    }, {}, {
+        DashboardCreatorInline: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            visible: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            testTag: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {
+            dashboardName: import('vue').Ref<string, string>;
+            selectedConnection: import('vue').Ref<string, string>;
+            dashboardPrompt: import('vue').Ref<string, string>;
+            showPromptField: import('vue').ComputedRef<boolean>;
+            connections: import('vue').ComputedRef<import('../../connections').Connection[]>;
+            availableImports: import('vue').Ref<import('../../dashboards/base').DashboardImport[], import('../../dashboards/base').DashboardImport[]>;
+            selectedImport: import('vue').Ref<string, string>;
+            createDashboard: () => Promise<void>;
+            cancel: () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            visible: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            testTag: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            visible: boolean;
+            testTag: string;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        DashboardImportPopup: import('vue').DefineComponent<import('../dashboard/DashboardImportPopup.vue').DashboardImportPopupProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            close: () => any;
+        }, string, import('vue').PublicProps, Readonly<import('../dashboard/DashboardImportPopup.vue').DashboardImportPopupProps> & Readonly<{
+            onClose?: (() => any) | undefined;
+        }>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+        DashboardListItem: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            item: {
+                type: ObjectConstructor;
+                required: true;
+            };
+            isActive: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            isCollapsed: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {
+            isMobile: boolean;
+            dashboardStore: import('pinia').Store<"dashboards", {
+                dashboards: Record<string, import('../../dashboards').DashboardModel>;
+                activeDashboardId: string;
+                queryExecutors: Record<string, import('../../dashboards/dashboardQueryExecutor').DashboardQueryExecutor>;
+            }, {
+                dashboardList: (state: {
+                    dashboards: Record<string, import('../../dashboards').DashboardModel>;
+                    activeDashboardId: string;
+                    queryExecutors: Record<string, import('../../dashboards/dashboardQueryExecutor').DashboardQueryExecutor>;
+                } & import('pinia').PiniaCustomStateProperties<{
+                    dashboards: Record<string, import('../../dashboards').DashboardModel>;
+                    activeDashboardId: string;
+                    queryExecutors: Record<string, import('../../dashboards/dashboardQueryExecutor').DashboardQueryExecutor>;
+                }>) => import('../../dashboards').DashboardModel[];
+                activeDashboard: (state: {
+                    dashboards: Record<string, import('../../dashboards').DashboardModel>;
+                    activeDashboardId: string;
+                    queryExecutors: Record<string, import('../../dashboards/dashboardQueryExecutor').DashboardQueryExecutor>;
+                } & import('pinia').PiniaCustomStateProperties<{
+                    dashboards: Record<string, import('../../dashboards').DashboardModel>;
+                    activeDashboardId: string;
+                    queryExecutors: Record<string, import('../../dashboards/dashboardQueryExecutor').DashboardQueryExecutor>;
+                }>) => import('../../dashboards').DashboardModel | null;
+                getConnectionDashboards: (state: {
+                    dashboards: Record<string, import('../../dashboards').DashboardModel>;
+                    activeDashboardId: string;
+                    queryExecutors: Record<string, import('../../dashboards/dashboardQueryExecutor').DashboardQueryExecutor>;
+                } & import('pinia').PiniaCustomStateProperties<{
+                    dashboards: Record<string, import('../../dashboards').DashboardModel>;
+                    activeDashboardId: string;
+                    queryExecutors: Record<string, import('../../dashboards/dashboardQueryExecutor').DashboardQueryExecutor>;
+                }>) => (connection: string) => import('../../dashboards').DashboardModel[];
+                unsavedDashboards: (state: {
+                    dashboards: Record<string, import('../../dashboards').DashboardModel>;
+                    activeDashboardId: string;
+                    queryExecutors: Record<string, import('../../dashboards/dashboardQueryExecutor').DashboardQueryExecutor>;
+                } & import('pinia').PiniaCustomStateProperties<{
+                    dashboards: Record<string, import('../../dashboards').DashboardModel>;
+                    activeDashboardId: string;
+                    queryExecutors: Record<string, import('../../dashboards/dashboardQueryExecutor').DashboardQueryExecutor>;
+                }>) => number;
+                activeQueryExecutor: (state: {
+                    dashboards: Record<string, import('../../dashboards').DashboardModel>;
+                    activeDashboardId: string;
+                    queryExecutors: Record<string, import('../../dashboards/dashboardQueryExecutor').DashboardQueryExecutor>;
+                } & import('pinia').PiniaCustomStateProperties<{
+                    dashboards: Record<string, import('../../dashboards').DashboardModel>;
+                    activeDashboardId: string;
+                    queryExecutors: Record<string, import('../../dashboards/dashboardQueryExecutor').DashboardQueryExecutor>;
+                }>) => import('../../dashboards/dashboardQueryExecutor').DashboardQueryExecutor | null;
+                hasQueryExecutor: (state: {
+                    dashboards: Record<string, import('../../dashboards').DashboardModel>;
+                    activeDashboardId: string;
+                    queryExecutors: Record<string, import('../../dashboards/dashboardQueryExecutor').DashboardQueryExecutor>;
+                } & import('pinia').PiniaCustomStateProperties<{
+                    dashboards: Record<string, import('../../dashboards').DashboardModel>;
+                    activeDashboardId: string;
+                    queryExecutors: Record<string, import('../../dashboards/dashboardQueryExecutor').DashboardQueryExecutor>;
+                }>) => (dashboardId: string) => true;
+            }, {
+                getOrCreateQueryExecutor(dashboardId: string, dependencies: import('../../dashboards/dashboardQueryExecutor').QueryExecutorDependencies): import('../../dashboards/dashboardQueryExecutor').DashboardQueryExecutor;
+                getQueryExecutor(dashboardId: string): import('../../dashboards/dashboardQueryExecutor').DashboardQueryExecutor | null;
+                removeQueryExecutor(dashboardId: string): boolean;
+                clearAllQueryExecutors(): void;
+                getQueryExecutorStatuses(): Record<string, any>;
+                getDashboardByName(name: string): import('../../dashboards').DashboardModel | null;
+                newDashboard(name: string, connection: string): import('../../dashboards').DashboardModel;
+                cloneDashboard(id: string): import('../../dashboards').DashboardModel;
+                addDashboard(dashboard: import('../../dashboards').DashboardModel): void;
+                loadDashboards(serializedDashboards: Record<string, any>): void;
+                removeAllFilters(dashboardId: string): string[];
+                getConnectionDashboardsSync(connection: string): import('../../dashboards').DashboardModel[];
+                setActiveDashboard(id: string): void;
+                setDashboardState(id: string, state: "editing" | "published" | "locked"): void;
+                updateDashboardName(id: string, newName: string): void;
+                updateDashboardFilter(id: string, filter: string): string[];
+                updateDashboardImports(id: string, imports: import('../../dashboards/base').DashboardImport[]): void;
+                removeDashboard(id: string): void;
+                setState(dashboardId: string, state: import('../../dashboards/base').DashboardState): void;
+                addItemToDashboard(dashboardId: string, type: import('../../dashboards/base').CellType, x?: number, y?: number, w?: number, h?: number | null, content?: string | null, name?: string | null): string;
+                updateDashboardTitle(dashboardId: string, newTitle: string): void;
+                updateItemContent(dashboardId: string, itemId: string, content: string): void;
+                updateItemCrossFilterEligibility(dashboardId: string, itemId: string, allowCrossFilter: boolean): void;
+                updateItemResults(dashboardId: string, itemId: string, results: import('../../editors/results').Results): void;
+                updateItemLoading(dashboardId: string, itemId: string, loading: boolean): void;
+                updateItemError(dashboardId: string, itemId: string, error: string | null): void;
+                updateItemDrilldown(dashboardId: string, itemId: string, drilldown: string | null): void;
+                updateItemDrilldownChartConfig(dashboardId: string, itemId: string, drilldownChartConfig: import('../../editors/results').ChartConfig | null): void;
+                updateItemType(dashboardId: string, itemId: string, type: import('../../dashboards/base').DashboardTypes["CellType"]): void;
+                updateItemCrossFilters(dashboardId: string, itemId: string, conceptMap: Record<string, string>, chartMap: Record<string, string>, operation: "add" | "append" | "remove"): string[];
+                removeItemCrossFilter(dashboardId: string, itemId: string, source: string): string;
+                removeItemCrossFilterSource(dashboardId: string, itemId: string): string[];
+                updateItemName(dashboardId: string, itemId: string, name: string): void;
+                updateItemChartConfig(dashboardId: string, itemId: string, config: any): void;
+                updateMultipleItemProperties(dashboardId: string, itemId: string, updates: import('../../dashboards/base').ItemPropertyUpdates): void;
+                updateDashboardConnection(dashboardId: string, connection: string): void;
+                updateDashboardDescription(dashboardId: string, description: string): void;
+                updateDashboardLayout(dashboardId: string, newLayout: import('../../dashboards/base').LayoutItem[]): void;
+                updateItemDimensions(dashboardId: string, itemId: string, width: number, height: number): void;
+                updateItemLayoutDimensions(dashboardId: string, itemId: string, x?: number | null, y?: number | null, w?: number | null, h?: number | null): void;
+                removeItemFromDashboard(dashboardId: string, itemId: string): void;
+                copyItemInDashboard(dashboardId: string, itemId: string): string;
+                clearDashboardItems(dashboardId: string): void;
+                serializeDashboards(): Record<string, any>;
+                warmDashboardQueries(dashboardId: string, queryExecutionService: import('../../stores').QueryExecutionService, editorStore: import('../../stores/editorStore').EditorStoreType): Promise<void>;
+                populateCompletion(dashboardId: string, queryExecutionService: import('../../stores').QueryExecutionService, editorStore: import('../../stores/editorStore').EditorStoreType): Promise<import('../../stores/resolver').CompletionItem[]>;
+                populateAIConcepts(dashboardId: string, queryExecutionService: import('../../stores').QueryExecutionService, editorStore: import('../../stores/editorStore').EditorStoreType): Promise<import('../../llm').ModelConceptInput[]>;
+                generatePromptSpec(prompt: string, llmStore: import('../../main').LLMConnectionStoreType, queryExecutionService: import('../../stores').QueryExecutionService, editorStore: import('../../stores/editorStore').EditorStoreType): Promise<import('../../dashboards/prompts').PromptDashboard>;
+                populateFromPromptSpec(dashboardId: string, promptLayout: import('../../dashboards/prompts').PromptDashboard, llmStore: import('../../main').LLMConnectionStoreType, queryExecutionService: import('../../stores').QueryExecutionService, editorStore: import('../../stores/editorStore').EditorStoreType): Promise<void>;
+            }>;
+            connectionInfo: import('vue').ComputedRef<import('../../connections').Connection | null>;
+            connectionStatus: import('vue').ComputedRef<"running" | "disabled" | "connected">;
+            contextMenuItems: import('vue').ComputedRef<import('../ContextMenu.vue').ContextMenuItem[]>;
+        }, {}, {}, {
+            handleClick(): void;
+            handleToggle(): void;
+            handleDelete(): void;
+            handleClone(): void;
+            handleContextMenuItemClick(item: import('../ContextMenu.vue').ContextMenuItem): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("delete" | "click" | "toggle" | "clone")[], "delete" | "click" | "toggle" | "clone", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            item: {
+                type: ObjectConstructor;
+                required: true;
+            };
+            isActive: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            isCollapsed: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            onClick?: ((...args: any[]) => any) | undefined;
+            onToggle?: ((...args: any[]) => any) | undefined;
+            onDelete?: ((...args: any[]) => any) | undefined;
+            onClone?: ((...args: any[]) => any) | undefined;
+        }>, {
+            isCollapsed: boolean;
+            isActive: boolean;
+        }, {}, {
+            SidebarItem: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                itemId: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                name: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                indent: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                isSelected: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                isCollapsible: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                isCollapsed: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                icon: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                extraInfo: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: string;
+                };
+                itemType: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>, {}, {}, {}, {
+                handleClick(): void;
+                handleToggle(): void;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("click" | "toggle")[], "click" | "toggle", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                itemId: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                name: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                indent: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                isSelected: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                isCollapsible: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                isCollapsed: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                icon: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                extraInfo: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: string;
+                };
+                itemType: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>> & Readonly<{
+                onClick?: ((...args: any[]) => any) | undefined;
+                onToggle?: ((...args: any[]) => any) | undefined;
+            }>, {
+                icon: string;
+                indent: number;
+                isSelected: boolean;
+                isCollapsible: boolean;
+                isCollapsed: boolean;
+                extraInfo: string | number;
+                itemType: string;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            Tooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                position: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {}, {
+                visible: boolean;
+                hoverTimeout: ReturnType<typeof setTimeout> | null;
+            }, {
+                positionClass(): string;
+            }, {
+                showTooltip(): void;
+                hideTooltip(): void;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                position: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                position: string;
+                inline: boolean;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            StatusIcon: import('vue').DefineComponent<import('../StatusIcon.vue').StatusIconProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('../StatusIcon.vue').StatusIconProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+            SidebarOverflowMenu: import('vue').DefineComponent<import('./SidebarOverflowMenu.vue').SidebarOverflowMenuProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                select: (item: import('../ContextMenu.vue').ContextMenuItem) => any;
+            }, string, import('vue').PublicProps, Readonly<import('./SidebarOverflowMenu.vue').SidebarOverflowMenuProps> & Readonly<{
+                onSelect?: ((item: import('../ContextMenu.vue').ContextMenuItem) => any) | undefined;
+            }>, {
+                tooltip: string;
+                menuWidth: number;
+                buttonClass: string;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        SidebarList: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            title: {
+                type: StringConstructor;
+                required: true;
+            };
+        }>, {
+            title: string;
+            isMobile: boolean | undefined;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            title: {
+                type: StringConstructor;
+                required: true;
+            };
+        }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        LoadingButton: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            action: {
+                type: FunctionConstructor;
+                required: true;
+            };
+            useDefaultStyle: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            keyCombination: {
+                type: {
+                    (arrayLength: number): string[];
+                    (...items: string[]): string[];
+                    new (arrayLength: number): string[];
+                    new (...items: string[]): string[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                default: null;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            testId: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {
+            errorMessage: import('vue').Ref<string | null, string | null>;
+            isLoading: import('vue').Ref<boolean, boolean>;
+            status: import('vue').Ref<"success" | "error" | null, "success" | "error" | null>;
+            handleClick: () => Promise<void>;
+            handleKeydown: (event: KeyboardEvent) => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            action: {
+                type: FunctionConstructor;
+                required: true;
+            };
+            useDefaultStyle: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            keyCombination: {
+                type: {
+                    (arrayLength: number): string[];
+                    (...items: string[]): string[];
+                    new (arrayLength: number): string[];
+                    new (...items: string[]): string[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                default: null;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            testId: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            disabled: boolean;
+            useDefaultStyle: boolean;
+            keyCombination: string[];
+            testId: string;
+        }, {}, {
+            Tooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                position: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {}, {
+                visible: boolean;
+                hoverTimeout: ReturnType<typeof setTimeout> | null;
+            }, {
+                positionClass(): string;
+            }, {
+                showTooltip(): void;
+                hideTooltip(): void;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                position: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                position: string;
+                inline: boolean;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        ConfirmDialog: import('vue').DefineComponent<import('../ConfirmDialog.vue').ConfirmDialogProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            close: () => any;
+            confirm: () => any;
+        }, string, import('vue').PublicProps, Readonly<import('../ConfirmDialog.vue').ConfirmDialogProps> & Readonly<{
+            onClose?: (() => any) | undefined;
+            onConfirm?: (() => any) | undefined;
+        }>, {
+            confirmLabel: string;
+            cancelLabel: string;
+            confirmTestId: string;
+            cancelTestId: string;
+            confirmDisabled: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    CommunityModelList: import('vue').DefineComponent<{}, {
+        communityStore: import('pinia').Store<"communityApi", import('../../stores/communityApiStore').CommunityApiState, {
+            allFiles: (state: {
+                stores: ({
+                    type: "github";
+                    owner: string;
+                    repo: string;
+                    branch: string;
+                    name: string;
+                    id: string;
+                } | {
+                    type: "generic";
+                    baseUrl: string;
+                    token?: string | undefined;
+                    name: string;
+                    id: string;
+                })[];
+                filesByStore: Record<string, import('../../remotes/models').ModelFile[]>;
+                errors: Record<string, string>;
+                storeStatus: Record<string, import('../../stores/communityApiStore').StoreStatus>;
+                loading: boolean;
+                showAddStoreModal: boolean;
+                addingStore: boolean;
+                newStore: {
+                    type: "github" | "generic";
+                    name: string;
+                    baseUrl: string;
+                    owner: string;
+                    repo: string;
+                    branch: string;
+                };
+            } & import('pinia').PiniaCustomStateProperties<import('../../stores/communityApiStore').CommunityApiState>) => import('../../remotes/models').ModelFile[];
+            availableEngines: (state: {
+                stores: ({
+                    type: "github";
+                    owner: string;
+                    repo: string;
+                    branch: string;
+                    name: string;
+                    id: string;
+                } | {
+                    type: "generic";
+                    baseUrl: string;
+                    token?: string | undefined;
+                    name: string;
+                    id: string;
+                })[];
+                filesByStore: Record<string, import('../../remotes/models').ModelFile[]>;
+                errors: Record<string, string>;
+                storeStatus: Record<string, import('../../stores/communityApiStore').StoreStatus>;
+                loading: boolean;
+                showAddStoreModal: boolean;
+                addingStore: boolean;
+                newStore: {
+                    type: "github" | "generic";
+                    name: string;
+                    baseUrl: string;
+                    owner: string;
+                    repo: string;
+                    branch: string;
+                };
+            } & import('pinia').PiniaCustomStateProperties<import('../../stores/communityApiStore').CommunityApiState>) => string[];
+            hasErrors: (state: {
+                stores: ({
+                    type: "github";
+                    owner: string;
+                    repo: string;
+                    branch: string;
+                    name: string;
+                    id: string;
+                } | {
+                    type: "generic";
+                    baseUrl: string;
+                    token?: string | undefined;
+                    name: string;
+                    id: string;
+                })[];
+                filesByStore: Record<string, import('../../remotes/models').ModelFile[]>;
+                errors: Record<string, string>;
+                storeStatus: Record<string, import('../../stores/communityApiStore').StoreStatus>;
+                loading: boolean;
+                showAddStoreModal: boolean;
+                addingStore: boolean;
+                newStore: {
+                    type: "github" | "generic";
+                    name: string;
+                    baseUrl: string;
+                    owner: string;
+                    repo: string;
+                    branch: string;
+                };
+            } & import('pinia').PiniaCustomStateProperties<import('../../stores/communityApiStore').CommunityApiState>) => boolean;
+            errorList: (state: {
+                stores: ({
+                    type: "github";
+                    owner: string;
+                    repo: string;
+                    branch: string;
+                    name: string;
+                    id: string;
+                } | {
+                    type: "generic";
+                    baseUrl: string;
+                    token?: string | undefined;
+                    name: string;
+                    id: string;
+                })[];
+                filesByStore: Record<string, import('../../remotes/models').ModelFile[]>;
+                errors: Record<string, string>;
+                storeStatus: Record<string, import('../../stores/communityApiStore').StoreStatus>;
+                loading: boolean;
+                showAddStoreModal: boolean;
+                addingStore: boolean;
+                newStore: {
+                    type: "github" | "generic";
+                    name: string;
+                    baseUrl: string;
+                    owner: string;
+                    repo: string;
+                    branch: string;
+                };
+            } & import('pinia').PiniaCustomStateProperties<import('../../stores/communityApiStore').CommunityApiState>) => Array<{
+                root: string;
+                name: string;
+                error: string;
+            }>;
+        }, {
+            loadStoresFromStorage(): void;
+            saveStoresToStorage(): void;
+            fetchAllFiles(): Promise<void>;
+            refreshData(): Promise<void>;
+            fetchStoreFiles(storeId: string): Promise<void>;
+            filteredFiles(searchQuery: string, selectedEngine: string, importStatus: "all" | "imported" | "not-imported", modelStore: import('../../stores/modelStore').ModelConfigStoreType, remote?: string | null): import('../../remotes/models').ModelFile[];
+            getFilesByStore(storeId: string): import('../../remotes/models').ModelFile[];
+            initialize(): Promise<void>;
+            addStore(store: import('../../remotes/models').AnyModelStore): Promise<boolean>;
+            removeStore(storeId: string): void;
+            updateStoreToken(storeId: string, token: string): void;
+            openAddStoreModal(): void;
+            closeAddStoreModal(): void;
+            handleAddStore(): Promise<void>;
+            clearErrors(): void;
+            clearStoreError(storeId: string): void;
+            getStoreStatus(storeId: string): import('../../stores/communityApiStore').StoreStatus;
+        }>;
+        navigationStore: import('../../stores/useScreenNavigation').NavigationStore;
+        handleAddStoreSubmit: (store: any) => Promise<void>;
+        showDeleteStoreConfirmation: (item: import('../../remotes/models').AnyModelStore) => void;
+        cancelDeleteStore: () => void;
+        confirmDeleteStore: () => Promise<void>;
+        showDeleteConfirmationState: import('vue').Ref<boolean, boolean>;
+        handleModelSelected: (model: import('../../remotes/models').ModelFile, key: string, modelRoot: import('../../remotes/models').ModelRoot) => void;
+        handleItemClick: (_: string, key: string, __: import('../../remotes/models').ModelRoot) => void;
+        handleItemToggle: (_: string, key: string, __: import('../../remotes/models').ModelRoot) => void;
+        collapsed: import('vue').Ref<Record<string, boolean>, Record<string, boolean>>;
+        displayTree: import('vue').ComputedRef<import('../../remotes/displayHelpers').TreeNode[]>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {
+        SidebarList: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            title: {
+                type: StringConstructor;
+                required: true;
+            };
+        }>, {
+            title: string;
+            isMobile: boolean | undefined;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            title: {
+                type: StringConstructor;
+                required: true;
+            };
+        }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        CommunityModelListItem: import('vue').DefineComponent<import('./CommunityModelListItem.vue').CommunityModelListItemProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            "item-click": (type: string, key: string, modelRoot: any) => any;
+            "item-toggle": (type: string, key: string, modelRoot: any) => any;
+            "delete-store": (store: import('../../remotes/models').AnyModelStore) => any;
+            "model-selected": (model: any, key: string, modelRoot: any) => any;
+            "model-details": (model: any) => any;
+        }, string, import('vue').PublicProps, Readonly<import('./CommunityModelListItem.vue').CommunityModelListItemProps> & Readonly<{
+            "onItem-click"?: ((type: string, key: string, modelRoot: any) => any) | undefined;
+            "onItem-toggle"?: ((type: string, key: string, modelRoot: any) => any) | undefined;
+            "onDelete-store"?: ((store: import('../../remotes/models').AnyModelStore) => any) | undefined;
+            "onModel-selected"?: ((model: any, key: string, modelRoot: any) => any) | undefined;
+            "onModel-details"?: ((model: any) => any) | undefined;
+        }>, {
+            isMobile: boolean;
+            isCollapsed: boolean;
+            activeModel: string;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+        AddStoreModal: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            show: {
+                type: BooleanConstructor;
+                required: true;
+            };
+            loading: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {
+            storeType: import('vue').Ref<"generic" | "github", "generic" | "github">;
+            storeName: import('vue').Ref<string, string>;
+            baseUrl: import('vue').Ref<string, string>;
+            owner: import('vue').Ref<string, string>;
+            repo: import('vue').Ref<string, string>;
+            branch: import('vue').Ref<string, string>;
+            error: import('vue').Ref<string | null, string | null>;
+            handleSubmit: () => Promise<void>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("add" | "close")[], "add" | "close", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            show: {
+                type: BooleanConstructor;
+                required: true;
+            };
+            loading: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            onClose?: ((...args: any[]) => any) | undefined;
+            onAdd?: ((...args: any[]) => any) | undefined;
+        }>, {
+            loading: boolean;
+        }, {}, {
+            ModalDialog: {
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('../ModalDialog.vue').ModalDialogProps> & Readonly<{
+                    onClose?: (() => any) | undefined;
+                }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    close: () => any;
+                }, import('vue').PublicProps, {
+                    title: string;
+                    testId: string;
+                    maxWidth: string;
+                    closeOnOverlay: boolean;
+                }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('../ModalDialog.vue').ModalDialogProps> & Readonly<{
+                    onClose?: (() => any) | undefined;
+                }>, {}, {}, {}, {}, {
+                    title: string;
+                    testId: string;
+                    maxWidth: string;
+                    closeOnOverlay: boolean;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('../ModalDialog.vue').ModalDialogProps> & Readonly<{
+                onClose?: (() => any) | undefined;
+            }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                close: () => any;
+            }, string, {
+                title: string;
+                testId: string;
+                maxWidth: string;
+                closeOnOverlay: boolean;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    header?(_: {}): any;
+                    default?(_: {}): any;
+                    footer?(_: {}): any;
+                };
+            });
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        ConfirmDialog: import('vue').DefineComponent<import('../ConfirmDialog.vue').ConfirmDialogProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            close: () => any;
+            confirm: () => any;
+        }, string, import('vue').PublicProps, Readonly<import('../ConfirmDialog.vue').ConfirmDialogProps> & Readonly<{
+            onClose?: (() => any) | undefined;
+            onConfirm?: (() => any) | undefined;
+        }>, {
+            confirmLabel: string;
+            cancelLabel: string;
+            confirmTestId: string;
+            cancelTestId: string;
+            confirmDisabled: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=Sidebar.vue.d.ts.map