@trilogy-data/trilogy-studio-components 0.1.0

package/dist/components/tutorial/TutorialPrompt.vue.d.ts

@@ -0,0 +1,2002 @@
+import { TutorialPrompt } from '../../data/tutorial/docTypes';
+export interface EditorComponent {
+    setContent(content: string): void;
+    runQuery(): void;
+}
+declare const _default: import('vue').DefineComponent<{
+    prompts: TutorialPrompt[];
+    context: string;
+    editorId: string;
+}, {
+    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[];
+    }>;
+    runQuery: () => void;
+    currentIndex: import('vue').Ref<number, number>;
+    currentPrompt: import('vue').ComputedRef<TutorialPrompt>;
+    hasUserAttempted: import('vue').Ref<boolean, boolean>;
+    isCurrentPromptValid: import('vue').Ref<boolean, boolean>;
+    nextPrompt: () => void;
+    prevPrompt: () => void;
+    validateResults: () => void;
+    saveEditorsCall: () => void;
+    setEditorContent: (content: string) => void;
+    editorRef: import('vue').Ref<{
+        setContent: (content: string) => void;
+        runQuery: () => void;
+    } | null, EditorComponent | {
+        setContent: (content: string) => void;
+        runQuery: () => void;
+    } | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    prompts: TutorialPrompt[];
+    context: string;
+    editorId: string;
+}> & Readonly<{}>, {
+    editorId: string;
+    context: string;
+}, {}, {
+    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, import('../../models').ModelConfig>;
+        }, {
+            modelList: (state: {
+                models: Record<string, import('../../models').ModelConfig>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                models: Record<string, import('../../models').ModelConfig>;
+            }>) => import('../../models').ModelConfig[];
+            unsavedModels: (state: {
+                models: Record<string, import('../../models').ModelConfig>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                models: Record<string, import('../../models').ModelConfig>;
+            }>) => number;
+        }, {
+            newModelConfig(name: string, force?: boolean): import('../../models').ModelConfig;
+            addModelConfig(model: import('../../models').ModelConfig): void;
+            removeModelConfig(name: string): void;
+            updateModelName(name: string, newName: string): void;
+            addEditorAsModelSource(model: string, editor: import('../../editors').Editor): void;
+            addModelConfigSource(name: string, contents: import('../../models').ModelSource): void;
+            removeModelConfigSource(name: string, contents: string): void;
+            setModelConfigParseResults(name: string, results: import('../../models').ModelParseResults): void;
+            setModelParseError(name: string, error: string): void;
+        }>;
+        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: import('../../stores').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('../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('../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>;
+    ResultComponent: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        editorData: {
+            type: import('vue').PropType<import('../../editors').Editor>;
+            required: true;
+        };
+        containerHeight: {
+            type: NumberConstructor;
+            default: number;
+        };
+    }>, {
+        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;
+        }>;
+    }, {}, {}, {
+        llmQueryAccepted(): void;
+        handleDrilldown(data: any): void;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        editorData: {
+            type: import('vue').PropType<import('../../editors').Editor>;
+            required: true;
+        };
+        containerHeight: {
+            type: NumberConstructor;
+            default: number;
+        };
+    }>> & Readonly<{}>, {
+        containerHeight: number;
+    }, {}, {
+        LoadingView: import('vue').DefineComponent<{
+            cancel?: ((() => void) | null) | undefined;
+            text: string;
+            startTime: number | null;
+        }, {
+            containerRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+            containerHeight: import('vue').Ref<number, number>;
+            handleCancel: () => void;
+            trilogyIcon: string;
+            elapsedTime: import('vue').Ref<string, string>;
+            isCompact: import('vue').ComputedRef<boolean>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+            cancel?: ((() => void) | null) | undefined;
+            text: string;
+            startTime: number | null;
+        }> & Readonly<{}>, {
+            text: string;
+            startTime: number | null;
+        }, {}, {}, {}, 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>;
+        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>;
+        ResultsContainer: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            type: {
+                type: StringConstructor;
+                required: true;
+            };
+            results: {
+                type: typeof import('../../editors/results').Results;
+                required: true;
+            };
+            chartConfig: {
+                type: import('vue').PropType<import('../../editors/results').ChartConfig | null>;
+                required: false;
+            };
+            error: {
+                type: StringConstructor;
+                required: false;
+            };
+            connection: {
+                type: StringConstructor;
+                required: false;
+            };
+            symbols: {
+                type: import('vue').PropType<any>;
+                required: false;
+            };
+            containerHeight: NumberConstructor;
+            generatedSql: StringConstructor;
+            defaultTab: {
+                type: StringConstructor;
+                required: false;
+                default: null;
+            };
+        }>, {
+            codeBlock: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+            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;
+            }>;
+        }, {
+            activeTab: string;
+            activeDrilldown: import('../editor/Results.vue').Drilldown | null;
+            TABS_HEIGHT: number;
+        }, {
+            tabContentHeight(): number;
+            eligibleTabs(): string[];
+            displayTab(): string;
+        }, {
+            setTab(tab: string): void;
+            handleReconnect(): Promise<void>;
+            onChartChange(config: any): void;
+            activateDrilldown(e: import('../../events/display').DrillDownTriggerEvent): void;
+            submitDrilldown(selected: string[]): void;
+            handleLocalRefresh(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            type: {
+                type: StringConstructor;
+                required: true;
+            };
+            results: {
+                type: typeof import('../../editors/results').Results;
+                required: true;
+            };
+            chartConfig: {
+                type: import('vue').PropType<import('../../editors/results').ChartConfig | null>;
+                required: false;
+            };
+            error: {
+                type: StringConstructor;
+                required: false;
+            };
+            connection: {
+                type: StringConstructor;
+                required: false;
+            };
+            symbols: {
+                type: import('vue').PropType<any>;
+                required: false;
+            };
+            containerHeight: NumberConstructor;
+            generatedSql: StringConstructor;
+            defaultTab: {
+                type: StringConstructor;
+                required: false;
+                default: null;
+            };
+        }>> & Readonly<{}>, {
+            defaultTab: string;
+        }, {}, {
+            DataTable: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                headers: {
+                    type: {
+                        new (entries?: readonly (readonly [String, import('../../editors/results').ResultColumn])[] | null | undefined): Map<String, import('../../editors/results').ResultColumn>;
+                        new (iterable?: Iterable<readonly [String, import('../../editors/results').ResultColumn]> | null | undefined): Map<String, import('../../editors/results').ResultColumn>;
+                        readonly prototype: Map<any, any>;
+                        readonly [Symbol.species]: MapConstructor;
+                    };
+                    required: true;
+                };
+                results: {
+                    type: import('vue').PropType<readonly import('../../editors/results').Row[]>;
+                    required: true;
+                };
+                containerHeight: NumberConstructor;
+                cellClick: {
+                    type: FunctionConstructor;
+                    default: () => void;
+                };
+                backgroundClick: {
+                    type: FunctionConstructor;
+                    default: () => void;
+                };
+                prettyPrint: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                fitParent: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {
+                settingsStore: 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;
+                }>;
+                currentTheme: import('vue').ComputedRef<"" | "dark" | "light">;
+            }, {
+                tabulator: import('vue').ShallowRef<import('tabulator-tables').Tabulator> | null;
+                selectedCell: null;
+                controlsVisible: boolean;
+            }, {
+                tableData(): readonly Readonly<Record<string, any>>[];
+                tableColumns(): import('tabulator-tables').ColumnDefinition[];
+            }, {
+                copyToClipboard(): Promise<void>;
+                downloadData(): void;
+                showNotification(message: string, type: "success" | "error"): void;
+                create(): void;
+                updateTable(): void;
+                updateTableTheme(): void;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                headers: {
+                    type: {
+                        new (entries?: readonly (readonly [String, import('../../editors/results').ResultColumn])[] | null | undefined): Map<String, import('../../editors/results').ResultColumn>;
+                        new (iterable?: Iterable<readonly [String, import('../../editors/results').ResultColumn]> | null | undefined): Map<String, import('../../editors/results').ResultColumn>;
+                        readonly prototype: Map<any, any>;
+                        readonly [Symbol.species]: MapConstructor;
+                    };
+                    required: true;
+                };
+                results: {
+                    type: import('vue').PropType<readonly import('../../editors/results').Row[]>;
+                    required: true;
+                };
+                containerHeight: NumberConstructor;
+                cellClick: {
+                    type: FunctionConstructor;
+                    default: () => void;
+                };
+                backgroundClick: {
+                    type: FunctionConstructor;
+                    default: () => void;
+                };
+                prettyPrint: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                fitParent: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                cellClick: Function;
+                backgroundClick: Function;
+                prettyPrint: boolean;
+                fitParent: boolean;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            VegaLiteChart: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                data: {
+                    type: import('vue').PropType<Readonly<import('../../editors/results').Row[]>>;
+                    required: true;
+                };
+                columns: {
+                    type: import('vue').PropType<Map<string, import('../../editors/results').ResultColumn>>;
+                    required: true;
+                };
+                initialConfig: {
+                    type: import('vue').PropType<import('../../editors/results').ChartConfig | undefined | null>;
+                    default: undefined;
+                };
+                showControls: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                containerHeight: NumberConstructor;
+                containerWidth: NumberConstructor;
+                onChartConfigChange: {
+                    type: import('vue').PropType<(config: import('../../editors/results').ChartConfig) => void>;
+                    default: () => void;
+                };
+                chartSelection: {
+                    type: import('vue').PropType<Object[]>;
+                    default: () => void;
+                };
+                chartTitle: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                drilldownActive: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {
+                vegaContainer1: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+                vegaContainer2: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+                chartContentArea: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+                renderManager: import('../chartRenderManager').ChartRenderManager;
+                controlsManager: import('../chartControlsManager').ChartControlsManager;
+                renderChart: (force?: boolean) => Promise<void> | undefined;
+                filteredColumnsInternal: (type: "numeric" | "categorical" | "temporal" | "latitude" | "longitude" | "geographic" | "all") => import('../../editors/results').ResultColumn[];
+                updateConfig: (field: keyof import('../../editors/results').ChartConfig, value: string | boolean | number) => void;
+                openInVegaEditor: () => void;
+                downloadChart: () => Promise<void>;
+                refreshChart: () => void;
+                charts: import('vue').ComputedRef<{
+                    value: string;
+                    label: string;
+                    icon: string;
+                }[]>;
+                isShortContainer: import('vue').ComputedRef<boolean | 0 | undefined>;
+                revertDrilldown: () => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                data: {
+                    type: import('vue').PropType<Readonly<import('../../editors/results').Row[]>>;
+                    required: true;
+                };
+                columns: {
+                    type: import('vue').PropType<Map<string, import('../../editors/results').ResultColumn>>;
+                    required: true;
+                };
+                initialConfig: {
+                    type: import('vue').PropType<import('../../editors/results').ChartConfig | undefined | null>;
+                    default: undefined;
+                };
+                showControls: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                containerHeight: NumberConstructor;
+                containerWidth: NumberConstructor;
+                onChartConfigChange: {
+                    type: import('vue').PropType<(config: import('../../editors/results').ChartConfig) => void>;
+                    default: () => void;
+                };
+                chartSelection: {
+                    type: import('vue').PropType<Object[]>;
+                    default: () => void;
+                };
+                chartTitle: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                drilldownActive: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                initialConfig: import('../../editors/results').ChartConfig | null | undefined;
+                showControls: boolean;
+                onChartConfigChange: (config: import('../../editors/results').ChartConfig) => void;
+                chartSelection: Object[];
+                chartTitle: string;
+                drilldownActive: boolean;
+            }, {}, {
+                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>;
+                ChartControlPanel: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                    config: {
+                        type: import('vue').PropType<import('../../editors/results').ChartConfig>;
+                        required: true;
+                    };
+                    charts: {
+                        type: import('vue').PropType<Array<{
+                            value: string;
+                            label: string;
+                            icon: string;
+                        }>>;
+                        required: true;
+                    };
+                    filteredColumns: {
+                        type: import('vue').PropType<(type: "numeric" | "categorical" | "temporal" | "latitude" | "longitude" | "geographic" | "all") => import('../../editors/results').ResultColumn[]>;
+                        required: true;
+                    };
+                }>, {
+                    controlSections: import('vue').ComputedRef<import('../ChartControlPanel.vue').ChartControlSection[]>;
+                    updateConfig: (field: string, value: any) => void;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("update-config" | "open-vega-editor")[], "update-config" | "open-vega-editor", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                    config: {
+                        type: import('vue').PropType<import('../../editors/results').ChartConfig>;
+                        required: true;
+                    };
+                    charts: {
+                        type: import('vue').PropType<Array<{
+                            value: string;
+                            label: string;
+                            icon: string;
+                        }>>;
+                        required: true;
+                    };
+                    filteredColumns: {
+                        type: import('vue').PropType<(type: "numeric" | "categorical" | "temporal" | "latitude" | "longitude" | "geographic" | "all") => import('../../editors/results').ResultColumn[]>;
+                        required: true;
+                    };
+                }>> & Readonly<{
+                    "onUpdate-config"?: ((...args: any[]) => any) | undefined;
+                    "onOpen-vega-editor"?: ((...args: any[]) => any) | undefined;
+                }>, {}, {}, {}, {}, 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>;
+            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>;
+            CodeBlock: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                language: {
+                    type: import('vue').PropType<"sql" | "trilogy">;
+                    default: string;
+                };
+                copy: {
+                    type: FunctionConstructor;
+                    optional: boolean;
+                };
+            }>, {
+                codeBlock: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+                codeClass: import('vue').Ref<string, string>;
+                copyCode: () => Promise<void>;
+                copied: import('vue').Ref<boolean, boolean>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "on-copy"[], "on-copy", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                language: {
+                    type: import('vue').PropType<"sql" | "trilogy">;
+                    default: string;
+                };
+                copy: {
+                    type: FunctionConstructor;
+                    optional: boolean;
+                };
+            }>> & Readonly<{
+                "onOn-copy"?: ((...args: any[]) => any) | undefined;
+            }>, {
+                language: "trilogy" | "sql";
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            DrilldownPane: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                drilldownRemove: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                drilldownFilter: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                symbols: {
+                    type: import('vue').PropType<import('../../stores/resolver').CompletionItem[]>;
+                    required: true;
+                };
+            }>, {
+                searchQuery: import('vue').Ref<string, string>;
+                filteredDimensions: 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;
+                }[]>;
+                drilldownSearchInput: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+                dimensionsList: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+                tooltip: {
+                    visible: boolean;
+                    x: number;
+                    y: number;
+                    dimension: {
+                        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;
+                    };
+                };
+                selected: import('vue').Ref<string[], string[]>;
+                highlightedIndex: import('vue').Ref<number, number>;
+                filterDimensions: () => void;
+                selectDimension: (dimension: import('../../stores/resolver').CompletionItem) => void;
+                removeDimension: (dimensionLabel: string) => void;
+                handleSubmit: () => void;
+                handleClose: () => void;
+                handleSearchKeydown: (event: KeyboardEvent) => void;
+                setHighlightedIndex: (index: number) => void;
+                getIconType: (dimension: import('../../stores/resolver').CompletionItem) => string;
+                getIconMdiClass: (dimension: import('../../stores/resolver').CompletionItem) => string;
+                getDimensionChar: (dimension: import('../../stores/resolver').CompletionItem) => string;
+                getIconClass: (dimension: import('../../stores/resolver').CompletionItem) => string;
+                getIconTooltip: (dimension: import('../../stores/resolver').CompletionItem) => string;
+                showTooltip: (event: MouseEvent, dimension: import('../../stores/resolver').CompletionItem) => Promise<void>;
+                hideTooltip: () => void;
+                updateTooltipPosition: (event: MouseEvent) => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("close" | "submit" | "select-dimension" | "remove-dimension")[], "close" | "submit" | "select-dimension" | "remove-dimension", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                drilldownRemove: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                drilldownFilter: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                symbols: {
+                    type: import('vue').PropType<import('../../stores/resolver').CompletionItem[]>;
+                    required: true;
+                };
+            }>> & Readonly<{
+                onSubmit?: ((...args: any[]) => any) | undefined;
+                onClose?: ((...args: any[]) => any) | undefined;
+                "onSelect-dimension"?: ((...args: any[]) => any) | undefined;
+                "onRemove-dimension"?: ((...args: any[]) => any) | undefined;
+            }>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        HintComponent: import('vue').DefineComponent<{}, {}, {
+            staticShortcuts: {
+                name: string;
+                keys: string[];
+            }[];
+            sysType: string;
+        }, {
+            shortcuts(): Array<any>;
+            icon(): "⌘" | "Ctrl";
+        }, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        LLMChatRefinement: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            messages: {
+                type: import('vue').PropType<import('../../llm').LLMMessage[]>;
+                default: () => never[];
+            };
+            validateFn: {
+                type: FunctionConstructor;
+                default: () => boolean;
+            };
+            extractionFn: {
+                type: FunctionConstructor;
+                default: () => null;
+            };
+            mutationFn: {
+                type: FunctionConstructor;
+                default: () => null;
+            };
+            closeFn: {
+                type: FunctionConstructor;
+                default: () => void;
+            };
+            autoActivate: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            initialMessage: {
+                type: StringConstructor;
+                required: false;
+            };
+        }>, {
+            messages: import('vue').Ref<{
+                role: "user" | "assistant" | "system";
+                content: string;
+                modelInfo?: {
+                    totalTokens: number;
+                } | undefined;
+                hidden?: boolean | undefined;
+            }[], import('../../llm').LLMMessage[] | {
+                role: "user" | "assistant" | "system";
+                content: string;
+                modelInfo?: {
+                    totalTokens: number;
+                } | undefined;
+                hidden?: boolean | undefined;
+            }[]>;
+            userInput: import('vue').Ref<string, string>;
+            isLoading: import('vue').Ref<boolean, boolean>;
+            messagesContainer: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+            inputTextarea: import('vue').Ref<HTMLTextAreaElement | null, HTMLTextAreaElement | null>;
+            getExtractedContent: (message: import('../../llm').LLMMessage) => string | null;
+            containsExtractedContent: (message: import('../../llm').LLMMessage) => boolean;
+            formatMessageWithPlaceholder: (message: import('../../llm').LLMMessage) => string;
+            handleKeyDown: (event: KeyboardEvent) => void;
+            sendMessage: () => Promise<void>;
+            acceptResult: () => Promise<void>;
+            handleClose: () => Promise<void>;
+            activateChat: () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            messages: {
+                type: import('vue').PropType<import('../../llm').LLMMessage[]>;
+                default: () => never[];
+            };
+            validateFn: {
+                type: FunctionConstructor;
+                default: () => boolean;
+            };
+            extractionFn: {
+                type: FunctionConstructor;
+                default: () => null;
+            };
+            mutationFn: {
+                type: FunctionConstructor;
+                default: () => null;
+            };
+            closeFn: {
+                type: FunctionConstructor;
+                default: () => void;
+            };
+            autoActivate: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            initialMessage: {
+                type: StringConstructor;
+                required: false;
+            };
+        }>> & Readonly<{}>, {
+            messages: import('../../llm').LLMMessage[];
+            extractionFn: Function;
+            mutationFn: Function;
+            validateFn: Function;
+            closeFn: Function;
+            autoActivate: boolean;
+        }, {}, {
+            CodeBlock: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                language: {
+                    type: import('vue').PropType<"sql" | "trilogy">;
+                    default: string;
+                };
+                copy: {
+                    type: FunctionConstructor;
+                    optional: boolean;
+                };
+            }>, {
+                codeBlock: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+                codeClass: import('vue').Ref<string, string>;
+                copyCode: () => Promise<void>;
+                copied: import('vue').Ref<boolean, boolean>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "on-copy"[], "on-copy", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                language: {
+                    type: import('vue').PropType<"sql" | "trilogy">;
+                    default: string;
+                };
+                copy: {
+                    type: FunctionConstructor;
+                    optional: boolean;
+                };
+            }>> & Readonly<{
+                "onOn-copy"?: ((...args: any[]) => any) | undefined;
+            }>, {
+                language: "trilogy" | "sql";
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    CodeBlock: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        content: {
+            type: StringConstructor;
+            required: true;
+        };
+        language: {
+            type: import('vue').PropType<"sql" | "trilogy">;
+            default: string;
+        };
+        copy: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+    }>, {
+        codeBlock: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+        codeClass: import('vue').Ref<string, string>;
+        copyCode: () => Promise<void>;
+        copied: import('vue').Ref<boolean, boolean>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "on-copy"[], "on-copy", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        content: {
+            type: StringConstructor;
+            required: true;
+        };
+        language: {
+            type: import('vue').PropType<"sql" | "trilogy">;
+            default: string;
+        };
+        copy: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+    }>> & Readonly<{
+        "onOn-copy"?: ((...args: any[]) => any) | undefined;
+    }>, {
+        language: "trilogy" | "sql";
+    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=TutorialPrompt.vue.d.ts.map