@trilogy-data/trilogy-studio-components 0.1.0

package/dist/views/ModelView.vue.d.ts

@@ -0,0 +1,2170 @@
+import { ModelSource, ModelConfig } from '../models';
+import { default as TrilogyResolver } from '../stores/resolver';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    activeModelKey: {
+        type: StringConstructor;
+        required: true;
+    };
+}>, {
+    modelStore: import('pinia').Store<"models", {
+        models: Record<string, ModelConfig>;
+    }, {
+        modelList: (state: {
+            models: Record<string, ModelConfig>;
+        } & import('pinia').PiniaCustomStateProperties<{
+            models: Record<string, ModelConfig>;
+        }>) => ModelConfig[];
+        unsavedModels: (state: {
+            models: Record<string, ModelConfig>;
+        } & import('pinia').PiniaCustomStateProperties<{
+            models: Record<string, ModelConfig>;
+        }>) => number;
+    }, {
+        newModelConfig(name: string, force?: boolean): ModelConfig;
+        addModelConfig(model: ModelConfig): void;
+        removeModelConfig(name: string): void;
+        updateModelName(name: string, newName: string): void;
+        addEditorAsModelSource(model: string, editor: import('../editors').Editor): void;
+        addModelConfigSource(name: string, contents: ModelSource): void;
+        removeModelConfigSource(name: string, contents: string): void;
+        setModelConfigParseResults(name: string, results: import('../models').ModelParseResults): void;
+        setModelParseError(name: string, error: string): void;
+    }>;
+    editorStore: import('pinia').Store<"editors", {
+        editors: Record<string, import('../editors').Editor>;
+        activeEditorName: string;
+        activeEditorId: string;
+    }, {
+        editorList: (state: {
+            editors: Record<string, import('../editors').Editor>;
+            activeEditorName: string;
+            activeEditorId: string;
+        } & import('pinia').PiniaCustomStateProperties<{
+            editors: Record<string, import('../editors').Editor>;
+            activeEditorName: string;
+            activeEditorId: string;
+        }>) => import('../editors').Editor[];
+        unsavedEditors: (state: {
+            editors: Record<string, import('../editors').Editor>;
+            activeEditorName: string;
+            activeEditorId: string;
+        } & import('pinia').PiniaCustomStateProperties<{
+            editors: Record<string, import('../editors').Editor>;
+            activeEditorName: string;
+            activeEditorId: string;
+        }>) => number;
+    }, {
+        newEditor(name: string, type: "trilogy" | "sql" | "preql", connection: string, contents: string | undefined): 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[];
+    }>;
+    isExpanded: import('vue').Ref<Record<string, boolean>, Record<string, boolean>>;
+    toggleConcepts: (index: string) => void;
+    newSourceVisible: import('vue').Ref<Record<string, boolean>, Record<string, boolean>>;
+    submitSourceAddition: (model: string) => void;
+    sourceDetails: import('vue').Ref<{
+        name: string;
+        alias: string;
+    }, {
+        name: string;
+        alias: string;
+    } | {
+        name: string;
+        alias: string;
+    }>;
+    trilogyResolver: TrilogyResolver;
+    fetchParseResults: (model: string) => void;
+    isEditorExpanded: import('vue').Ref<Record<string, boolean>, Record<string, boolean>>;
+}, {}, {
+    modelConfigs(): Record<string, ModelConfig>;
+    editorList(): string[];
+    selectedType(): string;
+    selectedPath(): string[];
+    selectedModel(): string;
+    selectedSource(): string;
+    selectedSourceFull(): ModelSource | undefined;
+    selectedConceptNamespace(): string;
+    selectedConceptName(): string;
+    selectedConceptFull(): import('../models').Concept | undefined;
+}, {
+    saveEditorsCall(): void;
+    clearSources(model: string): void;
+    remove(model: string): void;
+    onEditorClick(source: {
+        alias: string;
+        editor: string;
+    }): void;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    activeModelKey: {
+        type: StringConstructor;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {
+    ModelConcept: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        concept: {
+            type: typeof import('../models').Concept;
+            required: true;
+        };
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        concept: {
+            type: typeof import('../models').Concept;
+            required: true;
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+    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>;
+    ErrorMessage: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        type: {
+            type: () => "error" | "information";
+            default: string;
+            validator: (value: string) => boolean;
+        };
+    }>, {}, {}, {
+        messageClass(): string;
+        iconEmoji(): string;
+    }, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        type: {
+            type: () => "error" | "information";
+            default: string;
+            validator: (value: string) => boolean;
+        };
+    }>> & Readonly<{}>, {
+        type: "error" | "information";
+    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    Editor: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        context: {
+            type: import('vue').PropType<string>;
+            required: true;
+        };
+        editorId: {
+            type: import('vue').PropType<string>;
+            required: true;
+        };
+        containerHeight: {
+            type: import('vue').PropType<number>;
+            required: false;
+        };
+    }>, {
+        isMobile: 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;
+        }>;
+        modelStore: import('pinia').Store<"models", {
+            models: Record<string, ModelConfig>;
+        }, {
+            modelList: (state: {
+                models: Record<string, ModelConfig>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                models: Record<string, ModelConfig>;
+            }>) => ModelConfig[];
+            unsavedModels: (state: {
+                models: Record<string, ModelConfig>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                models: Record<string, ModelConfig>;
+            }>) => number;
+        }, {
+            newModelConfig(name: string, force?: boolean): ModelConfig;
+            addModelConfig(model: ModelConfig): void;
+            removeModelConfig(name: string): void;
+            updateModelName(name: string, newName: string): void;
+            addEditorAsModelSource(model: string, editor: import('../editors').Editor): void;
+            addModelConfigSource(name: string, contents: ModelSource): void;
+            removeModelConfigSource(name: string, contents: string): void;
+            setModelConfigParseResults(name: string, results: import('../models').ModelParseResults): void;
+            setModelParseError(name: string, error: string): void;
+        }>;
+        llmStore: 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>): 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>;
+            shouldAutoContinue(connectionName: string, lastAssistantMessage: string): Promise<boolean>;
+        }> | undefined;
+        editorStore: import('pinia').Store<"editors", {
+            editors: Record<string, import('../editors').Editor>;
+            activeEditorName: string;
+            activeEditorId: string;
+        }, {
+            editorList: (state: {
+                editors: Record<string, import('../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+            } & import('pinia').PiniaCustomStateProperties<{
+                editors: Record<string, import('../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+            }>) => import('../editors').Editor[];
+            unsavedEditors: (state: {
+                editors: Record<string, import('../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+            } & import('pinia').PiniaCustomStateProperties<{
+                editors: Record<string, import('../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+            }>) => number;
+        }, {
+            newEditor(name: string, type: "trilogy" | "sql" | "preql", connection: string, contents: string | undefined): 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[];
+        }>;
+        trilogyResolver: TrilogyResolver;
+        EditorTag: typeof import('../editors').EditorTag;
+        userSettingsStore: import('pinia').Store<"userSettings", {
+            settings: import('../stores/userSettingsStore').UserSettings;
+            defaults: import('../stores/userSettingsStore').UserSettings;
+            isLoading: boolean;
+            hasChanges: boolean;
+            hasLoaded: boolean;
+        }, {
+            getSettings: (state: {
+                settings: {
+                    [x: string]: string | number | boolean | string[] | null | undefined;
+                    theme: "dark" | "light" | "";
+                    trilogyResolver: string;
+                    telemetryEnabled: boolean | null;
+                    tipsRead: string[];
+                    skipAllTips: boolean;
+                };
+                defaults: {
+                    [x: string]: string | number | boolean | string[] | null | undefined;
+                    theme: "dark" | "light" | "";
+                    trilogyResolver: string;
+                    telemetryEnabled: boolean | null;
+                    tipsRead: string[];
+                    skipAllTips: boolean;
+                };
+                isLoading: boolean;
+                hasChanges: boolean;
+                hasLoaded: boolean;
+            } & import('pinia').PiniaCustomStateProperties<{
+                settings: import('../stores/userSettingsStore').UserSettings;
+                defaults: import('../stores/userSettingsStore').UserSettings;
+                isLoading: boolean;
+                hasChanges: boolean;
+                hasLoaded: boolean;
+            }>) => {
+                [x: string]: string | number | boolean | string[] | null | undefined;
+                theme: "dark" | "light" | "";
+                trilogyResolver: string;
+                telemetryEnabled: boolean | null;
+                tipsRead: string[];
+                skipAllTips: boolean;
+            };
+            getDefaults: (state: {
+                settings: {
+                    [x: string]: string | number | boolean | string[] | null | undefined;
+                    theme: "dark" | "light" | "";
+                    trilogyResolver: string;
+                    telemetryEnabled: boolean | null;
+                    tipsRead: string[];
+                    skipAllTips: boolean;
+                };
+                defaults: {
+                    [x: string]: string | number | boolean | string[] | null | undefined;
+                    theme: "dark" | "light" | "";
+                    trilogyResolver: string;
+                    telemetryEnabled: boolean | null;
+                    tipsRead: string[];
+                    skipAllTips: boolean;
+                };
+                isLoading: boolean;
+                hasChanges: boolean;
+                hasLoaded: boolean;
+            } & import('pinia').PiniaCustomStateProperties<{
+                settings: import('../stores/userSettingsStore').UserSettings;
+                defaults: import('../stores/userSettingsStore').UserSettings;
+                isLoading: boolean;
+                hasChanges: boolean;
+                hasLoaded: boolean;
+            }>) => {
+                [x: string]: string | number | boolean | string[] | null | undefined;
+                theme: "dark" | "light" | "";
+                trilogyResolver: string;
+                telemetryEnabled: boolean | null;
+                tipsRead: string[];
+                skipAllTips: boolean;
+            };
+            hasUnsavedChanges: (state: {
+                settings: {
+                    [x: string]: string | number | boolean | string[] | null | undefined;
+                    theme: "dark" | "light" | "";
+                    trilogyResolver: string;
+                    telemetryEnabled: boolean | null;
+                    tipsRead: string[];
+                    skipAllTips: boolean;
+                };
+                defaults: {
+                    [x: string]: string | number | boolean | string[] | null | undefined;
+                    theme: "dark" | "light" | "";
+                    trilogyResolver: string;
+                    telemetryEnabled: boolean | null;
+                    tipsRead: string[];
+                    skipAllTips: boolean;
+                };
+                isLoading: boolean;
+                hasChanges: boolean;
+                hasLoaded: boolean;
+            } & import('pinia').PiniaCustomStateProperties<{
+                settings: import('../stores/userSettingsStore').UserSettings;
+                defaults: import('../stores/userSettingsStore').UserSettings;
+                isLoading: boolean;
+                hasChanges: boolean;
+                hasLoaded: boolean;
+            }>) => boolean;
+        }, {
+            updateSetting<K extends keyof import('../stores/userSettingsStore').UserSettings>(key: K, value: import('../stores/userSettingsStore').UserSettings[K]): void;
+            getUnreadTips(tips: import('../data/tips').ModalItem[]): import('../data/tips').ModalItem[];
+            clearDismissedTips(): void;
+            markTipRead(tipId: string): void;
+            clearReadTips(): void;
+            toggleTheme(): void;
+            setHasChanges(value: boolean): void;
+            updateSettings(newSettings: Partial<import('../stores/userSettingsStore').UserSettings>): void;
+            resetToDefaults(): void;
+            saveSettings(): Promise<boolean>;
+            loadSettings(): void;
+        }>;
+        setActiveEditor: Function;
+        queryExecutionService: import('../stores').QueryExecutionService;
+        analyticsStore: import('pinia').Store<"analytics", import('../stores/analyticsStore').AnalyticsState, {}, {
+            log(path: string, title?: string, isEvent?: boolean): void;
+            setEnabled(enabled: boolean): void;
+            setSendTelemetry(send: boolean): void;
+            init({ enabled, sendTelemetry, }: {
+                enabled?: boolean;
+                sendTelemetry?: boolean;
+            }): void;
+        }>;
+        navigationStore: import('../stores/useScreenNavigation').NavigationStore | undefined;
+    }, {
+        last_passed_query_text: string | null;
+        prompt: string;
+        generatingPrompt: boolean;
+        info: string;
+    }, {
+        connectionHasModel(): boolean;
+        editorData(): import('../editors').Editor;
+        error(): string | null;
+        loading(): boolean;
+        result(): import('../editors/results').Results;
+        passedQuery(): boolean;
+        generateOverlayVisible(): boolean;
+    }, {
+        goToDefinition(e: import('../components/editor/events').GoToDefinitionEvent): void;
+        setContent(newContent: string): void;
+        updateEditorName(newName: string): void;
+        toggleTag(tag: import('../editors').EditorTag): void;
+        handleContentsChange(content: string): void;
+        insertSymbol(symbol: import('../stores/resolver').CompletionItem): void;
+        handlePositionChange(scrollPosition: {
+            line: number;
+            column: number;
+        }): void;
+        validateQuery(log?: boolean, sources?: import('../stores').ContentInput[] | null): Promise<import('../stores/resolver').Import[] | null>;
+        cancelQuery(): Promise<void>;
+        formatQuery(): Promise<void>;
+        buildQueryArgs(text: string): Promise<import('../components/editor/Editor.vue').QueryPartial>;
+        drilldownQuery(remove: string, add: string[], filter: string): Promise<void>;
+        runQuery(): Promise<any>;
+        handleLLMTrigger(): Promise<void>;
+        generateLLMQuerySQL(): Promise<void>;
+        generateLLMQuery(): Promise<void>;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("save-editors" | "save-models" | "query-started" | "query-finished")[], "save-editors" | "save-models" | "query-started" | "query-finished", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        context: {
+            type: import('vue').PropType<string>;
+            required: true;
+        };
+        editorId: {
+            type: import('vue').PropType<string>;
+            required: true;
+        };
+        containerHeight: {
+            type: import('vue').PropType<number>;
+            required: false;
+        };
+    }>> & Readonly<{
+        "onSave-editors"?: ((...args: any[]) => any) | undefined;
+        "onSave-models"?: ((...args: any[]) => any) | undefined;
+        "onQuery-started"?: ((...args: any[]) => any) | undefined;
+        "onQuery-finished"?: ((...args: any[]) => any) | undefined;
+    }>, {}, {}, {
+        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>;
+        ErrorMessage: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            type: {
+                type: () => "error" | "information";
+                default: string;
+                validator: (value: string) => boolean;
+            };
+        }>, {}, {}, {
+            messageClass(): string;
+            iconEmoji(): string;
+        }, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            type: {
+                type: () => "error" | "information";
+                default: string;
+                validator: (value: string) => boolean;
+            };
+        }>> & Readonly<{}>, {
+            type: "error" | "information";
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        SymbolsPane: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            symbols: {
+                type: import('vue').PropType<import('../stores/resolver').CompletionItem[]>;
+                required: true;
+            };
+            editorHeight: {
+                type: NumberConstructor;
+                required: false;
+                default: null;
+            };
+        }>, {
+            searchQuery: import('vue').Ref<string, string>;
+            filteredSymbols: import('vue').Ref<{
+                label: string;
+                description: string;
+                type: string;
+                datatype: string;
+                insertText: string;
+                trilogyType?: ("concept" | "function" | "type") | undefined;
+                trilogySubType?: ("property" | "key" | "metric") | undefined;
+                calculation?: string | undefined;
+                keys?: string[] | undefined;
+            }[], import('../stores/resolver').CompletionItem[] | {
+                label: string;
+                description: string;
+                type: string;
+                datatype: string;
+                insertText: string;
+                trilogyType?: ("concept" | "function" | "type") | undefined;
+                trilogySubType?: ("property" | "key" | "metric") | undefined;
+                calculation?: string | undefined;
+                keys?: string[] | undefined;
+            }[]>;
+            symbolSearchInput: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+            filters: import('vue').Ref<{
+                keys: boolean;
+                properties: boolean;
+                metrics: boolean;
+            }, {
+                keys: boolean;
+                properties: boolean;
+                metrics: boolean;
+            } | {
+                keys: boolean;
+                properties: boolean;
+                metrics: boolean;
+            }>;
+            isFiltering: import('vue').ComputedRef<boolean>;
+            tooltip: {
+                visible: boolean;
+                x: number;
+                y: number;
+                symbol: {
+                    label: string;
+                    description: string;
+                    type: string;
+                    datatype: string;
+                    insertText: string;
+                    trilogyType?: ("concept" | "function" | "type") | undefined;
+                    trilogySubType?: ("property" | "key" | "metric") | undefined;
+                    calculation?: string | undefined;
+                    keys?: string[] | undefined;
+                };
+            };
+            clearFilters: () => void;
+            filterSymbols: () => void;
+            getIconType: (symbol: import('../stores/resolver').CompletionItem) => string;
+            getIconMdiClass: (symbol: import('../stores/resolver').CompletionItem) => string;
+            getSymbolChar: (symbol: import('../stores/resolver').CompletionItem) => string;
+            getIconClass: (symbol: import('../stores/resolver').CompletionItem) => string;
+            getIconTooltip: (symbol: import('../stores/resolver').CompletionItem) => string;
+            showTooltip: (event: MouseEvent, symbol: import('../stores/resolver').CompletionItem) => Promise<void>;
+            hideTooltip: () => void;
+            updateTooltipPosition: (event: MouseEvent) => void;
+            focusSearch: () => void;
+            editorHeightCalc: import('vue').ComputedRef<string>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("select-symbol" | "focus-search")[], "select-symbol" | "focus-search", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            symbols: {
+                type: import('vue').PropType<import('../stores/resolver').CompletionItem[]>;
+                required: true;
+            };
+            editorHeight: {
+                type: NumberConstructor;
+                required: false;
+                default: null;
+            };
+        }>> & Readonly<{
+            "onSelect-symbol"?: ((...args: any[]) => any) | undefined;
+            "onFocus-search"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            editorHeight: number;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        EditorHeader: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            name: {
+                type: StringConstructor;
+                required: true;
+            };
+            editorType: {
+                type: StringConstructor;
+                required: true;
+            };
+            tags: {
+                type: ArrayConstructor;
+                required: true;
+            };
+            loading: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            connectionHasModel: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {}, {
+            isEditing: boolean;
+            editableName: string;
+            EditorTag: typeof import('../editors').EditorTag;
+        }, {}, {
+            startEditing(): void;
+            finishEditing(): void;
+            cancelEditing(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("validate" | "cancel" | "name-update" | "save" | "run" | "toggle-tag" | "generate")[], "validate" | "cancel" | "name-update" | "save" | "run" | "toggle-tag" | "generate", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            name: {
+                type: StringConstructor;
+                required: true;
+            };
+            editorType: {
+                type: StringConstructor;
+                required: true;
+            };
+            tags: {
+                type: ArrayConstructor;
+                required: true;
+            };
+            loading: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            connectionHasModel: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            onValidate?: ((...args: any[]) => any) | undefined;
+            onSave?: ((...args: any[]) => any) | undefined;
+            onCancel?: ((...args: any[]) => any) | undefined;
+            "onName-update"?: ((...args: any[]) => any) | undefined;
+            onRun?: ((...args: any[]) => any) | undefined;
+            "onToggle-tag"?: ((...args: any[]) => any) | undefined;
+            onGenerate?: ((...args: any[]) => any) | undefined;
+        }>, {
+            loading: boolean;
+            connectionHasModel: boolean;
+        }, {}, {
+            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>;
+        CodeEditor: import('vue').DefineComponent<{
+            editorId: string;
+            context: string;
+            contents: string;
+            editorType: string;
+            theme: string;
+            scrollPosition?: ({
+                line: number;
+                column: number;
+            } | null) | undefined;
+            editorHeight?: number | undefined;
+        }, {
+            editorElement: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+            getEditorText: (fallback: string) => string;
+            getEditorRange: () => import('monaco-editor').IRange | null;
+            setValue: (value: string) => void;
+            executeEdits: (source: string, edits: import("monaco-editor").editor.IIdentifiedSingleEditOperation[]) => void;
+            getEditorInstance: () => import("monaco-editor").editor.IStandaloneCodeEditor | undefined;
+            setModelMarkers: (markers: import("monaco-editor").editor.IMarkerData[]) => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("save" | "contents-change" | "run-query" | "validate-query" | "format-query" | "scroll-change" | "generate-llm-query" | "go-to-definition-requested")[], "save" | "contents-change" | "run-query" | "validate-query" | "format-query" | "scroll-change" | "generate-llm-query" | "go-to-definition-requested", import('vue').PublicProps, Readonly<{
+            editorId: string;
+            context: string;
+            contents: string;
+            editorType: string;
+            theme: string;
+            scrollPosition?: ({
+                line: number;
+                column: number;
+            } | null) | undefined;
+            editorHeight?: number | undefined;
+        }> & Readonly<{
+            onSave?: ((...args: any[]) => any) | undefined;
+            "onContents-change"?: ((...args: any[]) => any) | undefined;
+            "onRun-query"?: ((...args: any[]) => any) | undefined;
+            "onValidate-query"?: ((...args: any[]) => any) | undefined;
+            "onFormat-query"?: ((...args: any[]) => any) | undefined;
+            "onScroll-change"?: ((...args: any[]) => any) | undefined;
+            "onGenerate-llm-query"?: ((...args: any[]) => any) | undefined;
+            "onGo-to-definition-requested"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            theme: string;
+            scrollPosition: {
+                line: number;
+                column: number;
+            } | null;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    ModelCard: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        config: {
+            type: () => ModelConfig;
+            required: true;
+        };
+    }>, {
+        modelStore: import('pinia').Store<"models", {
+            models: Record<string, ModelConfig>;
+        }, {
+            modelList: (state: {
+                models: Record<string, ModelConfig>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                models: Record<string, ModelConfig>;
+            }>) => ModelConfig[];
+            unsavedModels: (state: {
+                models: Record<string, ModelConfig>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                models: Record<string, ModelConfig>;
+            }>) => number;
+        }, {
+            newModelConfig(name: string, force?: boolean): ModelConfig;
+            addModelConfig(model: ModelConfig): void;
+            removeModelConfig(name: string): void;
+            updateModelName(name: string, newName: string): void;
+            addEditorAsModelSource(model: string, editor: import('../editors').Editor): void;
+            addModelConfigSource(name: string, contents: ModelSource): void;
+            removeModelConfigSource(name: string, contents: string): void;
+            setModelConfigParseResults(name: string, results: import('../models').ModelParseResults): void;
+            setModelParseError(name: string, error: string): void;
+        }>;
+        editorStore: import('pinia').Store<"editors", {
+            editors: Record<string, import('../editors').Editor>;
+            activeEditorName: string;
+            activeEditorId: string;
+        }, {
+            editorList: (state: {
+                editors: Record<string, import('../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+            } & import('pinia').PiniaCustomStateProperties<{
+                editors: Record<string, import('../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+            }>) => import('../editors').Editor[];
+            unsavedEditors: (state: {
+                editors: Record<string, import('../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+            } & import('pinia').PiniaCustomStateProperties<{
+                editors: Record<string, import('../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+            }>) => number;
+        }, {
+            newEditor(name: string, type: "trilogy" | "sql" | "preql", connection: string, contents: string | undefined): 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[];
+        }>;
+        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;
+        }>;
+        navigationStore: import('../stores/useScreenNavigation').NavigationStore;
+        isExpanded: import('vue').Ref<Record<string, boolean>, Record<string, boolean>>;
+        toggleConcepts: (index: string) => void;
+        isDatasourceExpanded: import('vue').Ref<Record<string, boolean>, Record<string, boolean>>;
+        newSourceVisible: import('vue').Ref<Record<string, boolean>, Record<string, boolean>>;
+        submitSourceAddition: (model: string) => void;
+        toggleDatasources: (index: string) => void;
+        sourceDetails: import('vue').Ref<{
+            name: string;
+            alias: string;
+        }, {
+            name: string;
+            alias: string;
+        } | {
+            name: string;
+            alias: string;
+        }>;
+        trilogyResolver: TrilogyResolver;
+        fetchParseResults: (model: string) => Promise<void>;
+        index: import('vue').ComputedRef<string>;
+        toggleNewSource: (index: string) => void;
+        isEditing: import('vue').Ref<boolean, boolean>;
+        startEditing: () => void;
+        editableName: import('vue').Ref<string, string>;
+        finishEditing: () => void;
+        cancelEditing: () => void;
+        nameInput: import('vue').Ref<HTMLDivElement | null, HTMLDivElement | null>;
+        isDescriptionExpanded: import('vue').Ref<boolean, boolean>;
+        toggleDescription: () => void;
+        shouldTruncateDescription: import('vue').ComputedRef<boolean>;
+        openEditor: (editorAddress: string) => void;
+    }, {}, {
+        modelConfigs(): Record<string, ModelConfig>;
+        editorList(): string[];
+    }, {
+        clearSources(model: string): void;
+        removeSource(model: string, sourceIndex: number): void;
+        remove(model: string): void;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        config: {
+            type: () => ModelConfig;
+            required: true;
+        };
+    }>> & Readonly<{}>, {}, {}, {
+        ModelConcept: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            concept: {
+                type: typeof import('../models').Concept;
+                required: true;
+            };
+        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            concept: {
+                type: typeof import('../models').Concept;
+                required: true;
+            };
+        }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+        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>;
+        ErrorMessage: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            type: {
+                type: () => "error" | "information";
+                default: string;
+                validator: (value: string) => boolean;
+            };
+        }>, {}, {}, {
+            messageClass(): string;
+            iconEmoji(): string;
+        }, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            type: {
+                type: () => "error" | "information";
+                default: string;
+                validator: (value: string) => boolean;
+            };
+        }>> & Readonly<{}>, {
+            type: "error" | "information";
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        Editor: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            context: {
+                type: import('vue').PropType<string>;
+                required: true;
+            };
+            editorId: {
+                type: import('vue').PropType<string>;
+                required: true;
+            };
+            containerHeight: {
+                type: import('vue').PropType<number>;
+                required: false;
+            };
+        }>, {
+            isMobile: 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;
+            }>;
+            modelStore: import('pinia').Store<"models", {
+                models: Record<string, ModelConfig>;
+            }, {
+                modelList: (state: {
+                    models: Record<string, ModelConfig>;
+                } & import('pinia').PiniaCustomStateProperties<{
+                    models: Record<string, ModelConfig>;
+                }>) => ModelConfig[];
+                unsavedModels: (state: {
+                    models: Record<string, ModelConfig>;
+                } & import('pinia').PiniaCustomStateProperties<{
+                    models: Record<string, ModelConfig>;
+                }>) => number;
+            }, {
+                newModelConfig(name: string, force?: boolean): ModelConfig;
+                addModelConfig(model: ModelConfig): void;
+                removeModelConfig(name: string): void;
+                updateModelName(name: string, newName: string): void;
+                addEditorAsModelSource(model: string, editor: import('../editors').Editor): void;
+                addModelConfigSource(name: string, contents: ModelSource): void;
+                removeModelConfigSource(name: string, contents: string): void;
+                setModelConfigParseResults(name: string, results: import('../models').ModelParseResults): void;
+                setModelParseError(name: string, error: string): void;
+            }>;
+            llmStore: 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>): 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>;
+                shouldAutoContinue(connectionName: string, lastAssistantMessage: string): Promise<boolean>;
+            }> | undefined;
+            editorStore: import('pinia').Store<"editors", {
+                editors: Record<string, import('../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+            }, {
+                editorList: (state: {
+                    editors: Record<string, import('../editors').Editor>;
+                    activeEditorName: string;
+                    activeEditorId: string;
+                } & import('pinia').PiniaCustomStateProperties<{
+                    editors: Record<string, import('../editors').Editor>;
+                    activeEditorName: string;
+                    activeEditorId: string;
+                }>) => import('../editors').Editor[];
+                unsavedEditors: (state: {
+                    editors: Record<string, import('../editors').Editor>;
+                    activeEditorName: string;
+                    activeEditorId: string;
+                } & import('pinia').PiniaCustomStateProperties<{
+                    editors: Record<string, import('../editors').Editor>;
+                    activeEditorName: string;
+                    activeEditorId: string;
+                }>) => number;
+            }, {
+                newEditor(name: string, type: "trilogy" | "sql" | "preql", connection: string, contents: string | undefined): 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[];
+            }>;
+            trilogyResolver: TrilogyResolver;
+            EditorTag: typeof import('../editors').EditorTag;
+            userSettingsStore: import('pinia').Store<"userSettings", {
+                settings: import('../stores/userSettingsStore').UserSettings;
+                defaults: import('../stores/userSettingsStore').UserSettings;
+                isLoading: boolean;
+                hasChanges: boolean;
+                hasLoaded: boolean;
+            }, {
+                getSettings: (state: {
+                    settings: {
+                        [x: string]: string | number | boolean | string[] | null | undefined;
+                        theme: "dark" | "light" | "";
+                        trilogyResolver: string;
+                        telemetryEnabled: boolean | null;
+                        tipsRead: string[];
+                        skipAllTips: boolean;
+                    };
+                    defaults: {
+                        [x: string]: string | number | boolean | string[] | null | undefined;
+                        theme: "dark" | "light" | "";
+                        trilogyResolver: string;
+                        telemetryEnabled: boolean | null;
+                        tipsRead: string[];
+                        skipAllTips: boolean;
+                    };
+                    isLoading: boolean;
+                    hasChanges: boolean;
+                    hasLoaded: boolean;
+                } & import('pinia').PiniaCustomStateProperties<{
+                    settings: import('../stores/userSettingsStore').UserSettings;
+                    defaults: import('../stores/userSettingsStore').UserSettings;
+                    isLoading: boolean;
+                    hasChanges: boolean;
+                    hasLoaded: boolean;
+                }>) => {
+                    [x: string]: string | number | boolean | string[] | null | undefined;
+                    theme: "dark" | "light" | "";
+                    trilogyResolver: string;
+                    telemetryEnabled: boolean | null;
+                    tipsRead: string[];
+                    skipAllTips: boolean;
+                };
+                getDefaults: (state: {
+                    settings: {
+                        [x: string]: string | number | boolean | string[] | null | undefined;
+                        theme: "dark" | "light" | "";
+                        trilogyResolver: string;
+                        telemetryEnabled: boolean | null;
+                        tipsRead: string[];
+                        skipAllTips: boolean;
+                    };
+                    defaults: {
+                        [x: string]: string | number | boolean | string[] | null | undefined;
+                        theme: "dark" | "light" | "";
+                        trilogyResolver: string;
+                        telemetryEnabled: boolean | null;
+                        tipsRead: string[];
+                        skipAllTips: boolean;
+                    };
+                    isLoading: boolean;
+                    hasChanges: boolean;
+                    hasLoaded: boolean;
+                } & import('pinia').PiniaCustomStateProperties<{
+                    settings: import('../stores/userSettingsStore').UserSettings;
+                    defaults: import('../stores/userSettingsStore').UserSettings;
+                    isLoading: boolean;
+                    hasChanges: boolean;
+                    hasLoaded: boolean;
+                }>) => {
+                    [x: string]: string | number | boolean | string[] | null | undefined;
+                    theme: "dark" | "light" | "";
+                    trilogyResolver: string;
+                    telemetryEnabled: boolean | null;
+                    tipsRead: string[];
+                    skipAllTips: boolean;
+                };
+                hasUnsavedChanges: (state: {
+                    settings: {
+                        [x: string]: string | number | boolean | string[] | null | undefined;
+                        theme: "dark" | "light" | "";
+                        trilogyResolver: string;
+                        telemetryEnabled: boolean | null;
+                        tipsRead: string[];
+                        skipAllTips: boolean;
+                    };
+                    defaults: {
+                        [x: string]: string | number | boolean | string[] | null | undefined;
+                        theme: "dark" | "light" | "";
+                        trilogyResolver: string;
+                        telemetryEnabled: boolean | null;
+                        tipsRead: string[];
+                        skipAllTips: boolean;
+                    };
+                    isLoading: boolean;
+                    hasChanges: boolean;
+                    hasLoaded: boolean;
+                } & import('pinia').PiniaCustomStateProperties<{
+                    settings: import('../stores/userSettingsStore').UserSettings;
+                    defaults: import('../stores/userSettingsStore').UserSettings;
+                    isLoading: boolean;
+                    hasChanges: boolean;
+                    hasLoaded: boolean;
+                }>) => boolean;
+            }, {
+                updateSetting<K extends keyof import('../stores/userSettingsStore').UserSettings>(key: K, value: import('../stores/userSettingsStore').UserSettings[K]): void;
+                getUnreadTips(tips: import('../data/tips').ModalItem[]): import('../data/tips').ModalItem[];
+                clearDismissedTips(): void;
+                markTipRead(tipId: string): void;
+                clearReadTips(): void;
+                toggleTheme(): void;
+                setHasChanges(value: boolean): void;
+                updateSettings(newSettings: Partial<import('../stores/userSettingsStore').UserSettings>): void;
+                resetToDefaults(): void;
+                saveSettings(): Promise<boolean>;
+                loadSettings(): void;
+            }>;
+            setActiveEditor: Function;
+            queryExecutionService: import('../stores').QueryExecutionService;
+            analyticsStore: import('pinia').Store<"analytics", import('../stores/analyticsStore').AnalyticsState, {}, {
+                log(path: string, title?: string, isEvent?: boolean): void;
+                setEnabled(enabled: boolean): void;
+                setSendTelemetry(send: boolean): void;
+                init({ enabled, sendTelemetry, }: {
+                    enabled?: boolean;
+                    sendTelemetry?: boolean;
+                }): void;
+            }>;
+            navigationStore: import('../stores/useScreenNavigation').NavigationStore | undefined;
+        }, {
+            last_passed_query_text: string | null;
+            prompt: string;
+            generatingPrompt: boolean;
+            info: string;
+        }, {
+            connectionHasModel(): boolean;
+            editorData(): import('../editors').Editor;
+            error(): string | null;
+            loading(): boolean;
+            result(): import('../editors/results').Results;
+            passedQuery(): boolean;
+            generateOverlayVisible(): boolean;
+        }, {
+            goToDefinition(e: import('../components/editor/events').GoToDefinitionEvent): void;
+            setContent(newContent: string): void;
+            updateEditorName(newName: string): void;
+            toggleTag(tag: import('../editors').EditorTag): void;
+            handleContentsChange(content: string): void;
+            insertSymbol(symbol: import('../stores/resolver').CompletionItem): void;
+            handlePositionChange(scrollPosition: {
+                line: number;
+                column: number;
+            }): void;
+            validateQuery(log?: boolean, sources?: import('../stores').ContentInput[] | null): Promise<import('../stores/resolver').Import[] | null>;
+            cancelQuery(): Promise<void>;
+            formatQuery(): Promise<void>;
+            buildQueryArgs(text: string): Promise<import('../components/editor/Editor.vue').QueryPartial>;
+            drilldownQuery(remove: string, add: string[], filter: string): Promise<void>;
+            runQuery(): Promise<any>;
+            handleLLMTrigger(): Promise<void>;
+            generateLLMQuerySQL(): Promise<void>;
+            generateLLMQuery(): Promise<void>;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("save-editors" | "save-models" | "query-started" | "query-finished")[], "save-editors" | "save-models" | "query-started" | "query-finished", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            context: {
+                type: import('vue').PropType<string>;
+                required: true;
+            };
+            editorId: {
+                type: import('vue').PropType<string>;
+                required: true;
+            };
+            containerHeight: {
+                type: import('vue').PropType<number>;
+                required: false;
+            };
+        }>> & Readonly<{
+            "onSave-editors"?: ((...args: any[]) => any) | undefined;
+            "onSave-models"?: ((...args: any[]) => any) | undefined;
+            "onQuery-started"?: ((...args: any[]) => any) | undefined;
+            "onQuery-finished"?: ((...args: any[]) => any) | undefined;
+        }>, {}, {}, {
+            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>;
+            ErrorMessage: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                type: {
+                    type: () => "error" | "information";
+                    default: string;
+                    validator: (value: string) => boolean;
+                };
+            }>, {}, {}, {
+                messageClass(): string;
+                iconEmoji(): string;
+            }, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                type: {
+                    type: () => "error" | "information";
+                    default: string;
+                    validator: (value: string) => boolean;
+                };
+            }>> & Readonly<{}>, {
+                type: "error" | "information";
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            SymbolsPane: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                symbols: {
+                    type: import('vue').PropType<import('../stores/resolver').CompletionItem[]>;
+                    required: true;
+                };
+                editorHeight: {
+                    type: NumberConstructor;
+                    required: false;
+                    default: null;
+                };
+            }>, {
+                searchQuery: import('vue').Ref<string, string>;
+                filteredSymbols: import('vue').Ref<{
+                    label: string;
+                    description: string;
+                    type: string;
+                    datatype: string;
+                    insertText: string;
+                    trilogyType?: ("concept" | "function" | "type") | undefined;
+                    trilogySubType?: ("property" | "key" | "metric") | undefined;
+                    calculation?: string | undefined;
+                    keys?: string[] | undefined;
+                }[], import('../stores/resolver').CompletionItem[] | {
+                    label: string;
+                    description: string;
+                    type: string;
+                    datatype: string;
+                    insertText: string;
+                    trilogyType?: ("concept" | "function" | "type") | undefined;
+                    trilogySubType?: ("property" | "key" | "metric") | undefined;
+                    calculation?: string | undefined;
+                    keys?: string[] | undefined;
+                }[]>;
+                symbolSearchInput: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+                filters: import('vue').Ref<{
+                    keys: boolean;
+                    properties: boolean;
+                    metrics: boolean;
+                }, {
+                    keys: boolean;
+                    properties: boolean;
+                    metrics: boolean;
+                } | {
+                    keys: boolean;
+                    properties: boolean;
+                    metrics: boolean;
+                }>;
+                isFiltering: import('vue').ComputedRef<boolean>;
+                tooltip: {
+                    visible: boolean;
+                    x: number;
+                    y: number;
+                    symbol: {
+                        label: string;
+                        description: string;
+                        type: string;
+                        datatype: string;
+                        insertText: string;
+                        trilogyType?: ("concept" | "function" | "type") | undefined;
+                        trilogySubType?: ("property" | "key" | "metric") | undefined;
+                        calculation?: string | undefined;
+                        keys?: string[] | undefined;
+                    };
+                };
+                clearFilters: () => void;
+                filterSymbols: () => void;
+                getIconType: (symbol: import('../stores/resolver').CompletionItem) => string;
+                getIconMdiClass: (symbol: import('../stores/resolver').CompletionItem) => string;
+                getSymbolChar: (symbol: import('../stores/resolver').CompletionItem) => string;
+                getIconClass: (symbol: import('../stores/resolver').CompletionItem) => string;
+                getIconTooltip: (symbol: import('../stores/resolver').CompletionItem) => string;
+                showTooltip: (event: MouseEvent, symbol: import('../stores/resolver').CompletionItem) => Promise<void>;
+                hideTooltip: () => void;
+                updateTooltipPosition: (event: MouseEvent) => void;
+                focusSearch: () => void;
+                editorHeightCalc: import('vue').ComputedRef<string>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("select-symbol" | "focus-search")[], "select-symbol" | "focus-search", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                symbols: {
+                    type: import('vue').PropType<import('../stores/resolver').CompletionItem[]>;
+                    required: true;
+                };
+                editorHeight: {
+                    type: NumberConstructor;
+                    required: false;
+                    default: null;
+                };
+            }>> & Readonly<{
+                "onSelect-symbol"?: ((...args: any[]) => any) | undefined;
+                "onFocus-search"?: ((...args: any[]) => any) | undefined;
+            }>, {
+                editorHeight: number;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            EditorHeader: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                name: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                editorType: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                tags: {
+                    type: ArrayConstructor;
+                    required: true;
+                };
+                loading: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                connectionHasModel: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {}, {
+                isEditing: boolean;
+                editableName: string;
+                EditorTag: typeof import('../editors').EditorTag;
+            }, {}, {
+                startEditing(): void;
+                finishEditing(): void;
+                cancelEditing(): void;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("validate" | "cancel" | "name-update" | "save" | "run" | "toggle-tag" | "generate")[], "validate" | "cancel" | "name-update" | "save" | "run" | "toggle-tag" | "generate", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                name: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                editorType: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                tags: {
+                    type: ArrayConstructor;
+                    required: true;
+                };
+                loading: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                connectionHasModel: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{
+                onValidate?: ((...args: any[]) => any) | undefined;
+                onSave?: ((...args: any[]) => any) | undefined;
+                onCancel?: ((...args: any[]) => any) | undefined;
+                "onName-update"?: ((...args: any[]) => any) | undefined;
+                onRun?: ((...args: any[]) => any) | undefined;
+                "onToggle-tag"?: ((...args: any[]) => any) | undefined;
+                onGenerate?: ((...args: any[]) => any) | undefined;
+            }>, {
+                loading: boolean;
+                connectionHasModel: boolean;
+            }, {}, {
+                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>;
+            CodeEditor: import('vue').DefineComponent<{
+                editorId: string;
+                context: string;
+                contents: string;
+                editorType: string;
+                theme: string;
+                scrollPosition?: ({
+                    line: number;
+                    column: number;
+                } | null) | undefined;
+                editorHeight?: number | undefined;
+            }, {
+                editorElement: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+                getEditorText: (fallback: string) => string;
+                getEditorRange: () => import('monaco-editor').IRange | null;
+                setValue: (value: string) => void;
+                executeEdits: (source: string, edits: import("monaco-editor").editor.IIdentifiedSingleEditOperation[]) => void;
+                getEditorInstance: () => import("monaco-editor").editor.IStandaloneCodeEditor | undefined;
+                setModelMarkers: (markers: import("monaco-editor").editor.IMarkerData[]) => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("save" | "contents-change" | "run-query" | "validate-query" | "format-query" | "scroll-change" | "generate-llm-query" | "go-to-definition-requested")[], "save" | "contents-change" | "run-query" | "validate-query" | "format-query" | "scroll-change" | "generate-llm-query" | "go-to-definition-requested", import('vue').PublicProps, Readonly<{
+                editorId: string;
+                context: string;
+                contents: string;
+                editorType: string;
+                theme: string;
+                scrollPosition?: ({
+                    line: number;
+                    column: number;
+                } | null) | undefined;
+                editorHeight?: number | undefined;
+            }> & Readonly<{
+                onSave?: ((...args: any[]) => any) | undefined;
+                "onContents-change"?: ((...args: any[]) => any) | undefined;
+                "onRun-query"?: ((...args: any[]) => any) | undefined;
+                "onValidate-query"?: ((...args: any[]) => any) | undefined;
+                "onFormat-query"?: ((...args: any[]) => any) | undefined;
+                "onScroll-change"?: ((...args: any[]) => any) | undefined;
+                "onGenerate-llm-query"?: ((...args: any[]) => any) | undefined;
+                "onGo-to-definition-requested"?: ((...args: any[]) => any) | undefined;
+            }>, {
+                theme: string;
+                scrollPosition: {
+                    line: number;
+                    column: number;
+                } | null;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        ConceptTable: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            concepts: {
+                type: () => import('../models').Concept[];
+                required: true;
+            };
+        }>, {
+            tableRef: import('vue').Ref<HTMLDivElement | null, HTMLDivElement | null>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            concepts: {
+                type: () => import('../models').Concept[];
+                required: true;
+            };
+        }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        DatasourceTable: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            datasources: {
+                type: () => import('../models').Datasource[];
+                required: true;
+            };
+        }>, {
+            tableRef: import('vue').Ref<HTMLDivElement | null, HTMLDivElement | null>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            datasources: {
+                type: () => import('../models').Datasource[];
+                required: true;
+            };
+        }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=ModelView.vue.d.ts.map