@trilogy-data/trilogy-studio-components 0.1.0

package/dist/components/model/ModelCard.vue.d.ts

@@ -0,0 +1,1113 @@
+import { ModelConfig, ModelSource } from '../../models';
+import { default as FetchResolver } from '../../stores/resolver';
+import { NavigationStore } from '../../stores/useScreenNavigation';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    config: {
+        type: () => ModelConfig;
+        required: true;
+    };
+}>, {
+    modelStore: import('pinia').Store<"models", {
+        models: Record<string, ModelConfig>;
+    }, {
+        modelList: (state: {
+            models: Record<string, ModelConfig>;
+        } & import('pinia').PiniaCustomStateProperties<{
+            models: Record<string, ModelConfig>;
+        }>) => ModelConfig[];
+        unsavedModels: (state: {
+            models: Record<string, ModelConfig>;
+        } & import('pinia').PiniaCustomStateProperties<{
+            models: Record<string, ModelConfig>;
+        }>) => number;
+    }, {
+        newModelConfig(name: string, force?: boolean): ModelConfig;
+        addModelConfig(model: ModelConfig): void;
+        removeModelConfig(name: string): void;
+        updateModelName(name: string, newName: string): void;
+        addEditorAsModelSource(model: string, editor: import('../../editors').Editor): void;
+        addModelConfigSource(name: string, contents: ModelSource): void;
+        removeModelConfigSource(name: string, contents: string): void;
+        setModelConfigParseResults(name: string, results: import('../../models').ModelParseResults): void;
+        setModelParseError(name: string, error: string): void;
+    }>;
+    editorStore: import('pinia').Store<"editors", {
+        editors: Record<string, import('../../editors').Editor>;
+        activeEditorName: string;
+        activeEditorId: string;
+    }, {
+        editorList: (state: {
+            editors: Record<string, import('../../editors').Editor>;
+            activeEditorName: string;
+            activeEditorId: string;
+        } & import('pinia').PiniaCustomStateProperties<{
+            editors: Record<string, import('../../editors').Editor>;
+            activeEditorName: string;
+            activeEditorId: string;
+        }>) => import('../../editors').Editor[];
+        unsavedEditors: (state: {
+            editors: Record<string, import('../../editors').Editor>;
+            activeEditorName: string;
+            activeEditorId: string;
+        } & import('pinia').PiniaCustomStateProperties<{
+            editors: Record<string, import('../../editors').Editor>;
+            activeEditorName: string;
+            activeEditorId: string;
+        }>) => number;
+    }, {
+        newEditor(name: string, type: "trilogy" | "sql" | "preql", connection: string, contents: string | undefined): import('../../editors').Editor;
+        addEditor(editor: import('../../editors').Editor): void;
+        getEditorByName(name: string): import('../../editors').Editor | undefined;
+        getConnectionEditors(connection: string, tags?: import('../../editors').EditorTag[]): import('../../editors').Editor[];
+        updateEditorName(id: string, newName: string): void;
+        removeEditor(id: string): false | undefined;
+        setEditorScrollPosition(id: string, scrollPosition: {
+            line: number;
+            column: number;
+        }): void;
+        setEditorContents(id: string, contents: string): void;
+        setEditorResults(id: string, results: import('../../editors/results').Results): void;
+        getCurrentEditorAutocomplete(word: string): import('../../stores/resolver').CompletionItem[];
+    }>;
+    connectionStore: import('pinia').Store<"connections", {
+        connections: Record<string, import('../../connections').Connection>;
+    }, {
+        connectionList: (state: {
+            connections: Record<string, import('../../connections').Connection>;
+        } & import('pinia').PiniaCustomStateProperties<{
+            connections: Record<string, import('../../connections').Connection>;
+        }>) => import('../../connections').Connection[];
+        unsavedConnections: (state: {
+            connections: Record<string, import('../../connections').Connection>;
+        } & import('pinia').PiniaCustomStateProperties<{
+            connections: Record<string, import('../../connections').Connection>;
+        }>) => number;
+    }, {
+        addConnection(connection: import('../../connections').Connection): import('../../connections').Connection;
+        connectConnection(name: string): Promise<any>;
+        resetConnection(name: string): Promise<any>;
+        deleteConnection(name: string): void;
+        connectionStateToStatus(connection: import('../../connections').Connection | null): "running" | "failed" | "disabled" | "connected";
+        getConnectionSources(name: string): import('../../stores').ContentInput[];
+        newConnection(name: string, type: string, options: Record<string, any>): import('../../connections').Connection;
+    }>;
+    navigationStore: NavigationStore;
+    isExpanded: import('vue').Ref<Record<string, boolean>, Record<string, boolean>>;
+    toggleConcepts: (index: string) => void;
+    isDatasourceExpanded: import('vue').Ref<Record<string, boolean>, Record<string, boolean>>;
+    newSourceVisible: import('vue').Ref<Record<string, boolean>, Record<string, boolean>>;
+    submitSourceAddition: (model: string) => void;
+    toggleDatasources: (index: string) => void;
+    sourceDetails: import('vue').Ref<{
+        name: string;
+        alias: string;
+    }, {
+        name: string;
+        alias: string;
+    } | {
+        name: string;
+        alias: string;
+    }>;
+    trilogyResolver: FetchResolver;
+    fetchParseResults: (model: string) => Promise<void>;
+    index: import('vue').ComputedRef<string>;
+    toggleNewSource: (index: string) => void;
+    isEditing: import('vue').Ref<boolean, boolean>;
+    startEditing: () => void;
+    editableName: import('vue').Ref<string, string>;
+    finishEditing: () => void;
+    cancelEditing: () => void;
+    nameInput: import('vue').Ref<HTMLDivElement | null, HTMLDivElement | null>;
+    isDescriptionExpanded: import('vue').Ref<boolean, boolean>;
+    toggleDescription: () => void;
+    shouldTruncateDescription: import('vue').ComputedRef<boolean>;
+    openEditor: (editorAddress: string) => void;
+}, {}, {
+    modelConfigs(): Record<string, ModelConfig>;
+    editorList(): string[];
+}, {
+    clearSources(model: string): void;
+    removeSource(model: string, sourceIndex: number): void;
+    remove(model: string): void;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    config: {
+        type: () => ModelConfig;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {
+    ModelConcept: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        concept: {
+            type: typeof import('../../models').Concept;
+            required: true;
+        };
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        concept: {
+            type: typeof import('../../models').Concept;
+            required: true;
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+    LoadingButton: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        action: {
+            type: FunctionConstructor;
+            required: true;
+        };
+        useDefaultStyle: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        keyCombination: {
+            type: {
+                (arrayLength: number): string[];
+                (...items: string[]): string[];
+                new (arrayLength: number): string[];
+                new (...items: string[]): string[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                readonly [Symbol.species]: ArrayConstructor;
+            };
+            default: null;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        testId: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>, {
+        errorMessage: import('vue').Ref<string | null, string | null>;
+        isLoading: import('vue').Ref<boolean, boolean>;
+        status: import('vue').Ref<"success" | "error" | null, "success" | "error" | null>;
+        handleClick: () => Promise<void>;
+        handleKeydown: (event: KeyboardEvent) => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        action: {
+            type: FunctionConstructor;
+            required: true;
+        };
+        useDefaultStyle: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        keyCombination: {
+            type: {
+                (arrayLength: number): string[];
+                (...items: string[]): string[];
+                new (arrayLength: number): string[];
+                new (...items: string[]): string[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                readonly [Symbol.species]: ArrayConstructor;
+            };
+            default: null;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        testId: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>> & Readonly<{}>, {
+        disabled: boolean;
+        useDefaultStyle: boolean;
+        keyCombination: string[];
+        testId: string;
+    }, {}, {
+        Tooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            content: {
+                type: StringConstructor;
+                required: true;
+            };
+            position: {
+                type: StringConstructor;
+                default: string;
+            };
+            inline: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {}, {
+            visible: boolean;
+            hoverTimeout: ReturnType<typeof setTimeout> | null;
+        }, {
+            positionClass(): string;
+        }, {
+            showTooltip(): void;
+            hideTooltip(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            content: {
+                type: StringConstructor;
+                required: true;
+            };
+            position: {
+                type: StringConstructor;
+                default: string;
+            };
+            inline: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, {
+            position: string;
+            inline: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    ErrorMessage: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        type: {
+            type: () => "error" | "information";
+            default: string;
+            validator: (value: string) => boolean;
+        };
+    }>, {}, {}, {
+        messageClass(): string;
+        iconEmoji(): string;
+    }, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        type: {
+            type: () => "error" | "information";
+            default: string;
+            validator: (value: string) => boolean;
+        };
+    }>> & Readonly<{}>, {
+        type: "error" | "information";
+    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    Editor: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        context: {
+            type: import('vue').PropType<string>;
+            required: true;
+        };
+        editorId: {
+            type: import('vue').PropType<string>;
+            required: true;
+        };
+        containerHeight: {
+            type: import('vue').PropType<number>;
+            required: false;
+        };
+    }>, {
+        isMobile: boolean;
+        connectionStore: import('pinia').Store<"connections", {
+            connections: Record<string, import('../../connections').Connection>;
+        }, {
+            connectionList: (state: {
+                connections: Record<string, import('../../connections').Connection>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                connections: Record<string, import('../../connections').Connection>;
+            }>) => import('../../connections').Connection[];
+            unsavedConnections: (state: {
+                connections: Record<string, import('../../connections').Connection>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                connections: Record<string, import('../../connections').Connection>;
+            }>) => number;
+        }, {
+            addConnection(connection: import('../../connections').Connection): import('../../connections').Connection;
+            connectConnection(name: string): Promise<any>;
+            resetConnection(name: string): Promise<any>;
+            deleteConnection(name: string): void;
+            connectionStateToStatus(connection: import('../../connections').Connection | null): "running" | "failed" | "disabled" | "connected";
+            getConnectionSources(name: string): import('../../stores').ContentInput[];
+            newConnection(name: string, type: string, options: Record<string, any>): import('../../connections').Connection;
+        }>;
+        modelStore: import('pinia').Store<"models", {
+            models: Record<string, ModelConfig>;
+        }, {
+            modelList: (state: {
+                models: Record<string, ModelConfig>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                models: Record<string, ModelConfig>;
+            }>) => ModelConfig[];
+            unsavedModels: (state: {
+                models: Record<string, ModelConfig>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                models: Record<string, ModelConfig>;
+            }>) => number;
+        }, {
+            newModelConfig(name: string, force?: boolean): ModelConfig;
+            addModelConfig(model: ModelConfig): void;
+            removeModelConfig(name: string): void;
+            updateModelName(name: string, newName: string): void;
+            addEditorAsModelSource(model: string, editor: import('../../editors').Editor): void;
+            addModelConfigSource(name: string, contents: ModelSource): void;
+            removeModelConfigSource(name: string, contents: string): void;
+            setModelConfigParseResults(name: string, results: import('../../models').ModelParseResults): void;
+            setModelParseError(name: string, error: string): void;
+        }>;
+        llmStore: import('pinia').Store<"llmConnections", {
+            connections: Record<string, import('../../llm').LLMProvider>;
+            activeConnection: string;
+        }, {
+            connectionList: (state: {
+                connections: Record<string, import('../../llm').LLMProvider>;
+                activeConnection: string;
+            } & import('pinia').PiniaCustomStateProperties<{
+                connections: Record<string, import('../../llm').LLMProvider>;
+                activeConnection: string;
+            }>) => import('../../llm').LLMProvider[];
+            unsavedConnections: (state: {
+                connections: Record<string, import('../../llm').LLMProvider>;
+                activeConnection: string;
+            } & import('pinia').PiniaCustomStateProperties<{
+                connections: Record<string, import('../../llm').LLMProvider>;
+                activeConnection: string;
+            }>) => number;
+            getConnection: (state: {
+                connections: Record<string, import('../../llm').LLMProvider>;
+                activeConnection: string;
+            } & import('pinia').PiniaCustomStateProperties<{
+                connections: Record<string, import('../../llm').LLMProvider>;
+                activeConnection: string;
+            }>) => (name: string) => import('../../llm').LLMProvider;
+            getAllConnections: (state: {
+                connections: Record<string, import('../../llm').LLMProvider>;
+                activeConnection: string;
+            } & import('pinia').PiniaCustomStateProperties<{
+                connections: Record<string, import('../../llm').LLMProvider>;
+                activeConnection: string;
+            }>) => import('../../llm').LLMProvider[];
+            getConnectionStatus: (state: {
+                connections: Record<string, import('../../llm').LLMProvider>;
+                activeConnection: string;
+            } & import('pinia').PiniaCustomStateProperties<{
+                connections: Record<string, import('../../llm').LLMProvider>;
+                activeConnection: string;
+            }>) => (name: string) => "running" | "failed" | "disabled" | "connected";
+            hasActiveDefaultConnection: (state: {
+                connections: Record<string, import('../../llm').LLMProvider>;
+                activeConnection: string;
+            } & import('pinia').PiniaCustomStateProperties<{
+                connections: Record<string, import('../../llm').LLMProvider>;
+                activeConnection: string;
+            }>) => boolean;
+        }, {
+            addConnection(connection: import('../../llm').LLMProvider, checkForDefault?: boolean): import('../../llm').LLMProvider;
+            resetConnection(name: string): Promise<void>;
+            connectionStateToStatus(connection: import('../../llm').LLMProvider | null): "running" | "failed" | "disabled" | "connected";
+            newConnection(name: string, type: string, options: Record<string, any>): import('../../llm').LLMProvider;
+            fetchModelsForProvider(type: string, apiKey: string): Promise<string[]>;
+            generateValidatedCompletion(base: string, validator?: Function | null, maxAttempts?: number, modelOverride?: string | null, messageHistory?: import('../../llm').LLMMessage[] | null, addUserMessage?: boolean): Promise<import('../../stores/llmStore').ValidatedResponse>;
+            generateDashboardCompletion(inputString: string, validator?: Function | null, concepts?: import('../../llm').ModelConceptInput[], maxAttempts?: number): Promise<string | null>;
+            generateQueryCompletion(inputString: string, concepts: import('../../llm').ModelConceptInput[], validator?: Function | null, maxAttempts?: number, modelOverride?: string | null): Promise<import('../../stores/llmStore').ValidatedResponse>;
+            generateSQLQueryCompletion(inputString: string): Promise<import('../../stores/llmStore').ValidatedResponse>;
+            generateFilterQuery(inputString: string, concepts: import('../../llm').ModelConceptInput[], validator?: Function | null, maxAttempts?: number): Promise<string | null>;
+            generateChatName(connectionName: string, messages: import('../../llm').LLMMessage[]): Promise<string>;
+            generateCompletion(name: string, options: import('../../llm').LLMRequestOptions, history?: import('../../llm').LLMMessage[] | null): Promise<import('../../llm').LLMResponse>;
+            shouldAutoContinue(connectionName: string, lastAssistantMessage: string): Promise<boolean>;
+        }> | undefined;
+        editorStore: import('pinia').Store<"editors", {
+            editors: Record<string, import('../../editors').Editor>;
+            activeEditorName: string;
+            activeEditorId: string;
+        }, {
+            editorList: (state: {
+                editors: Record<string, import('../../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+            } & import('pinia').PiniaCustomStateProperties<{
+                editors: Record<string, import('../../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+            }>) => import('../../editors').Editor[];
+            unsavedEditors: (state: {
+                editors: Record<string, import('../../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+            } & import('pinia').PiniaCustomStateProperties<{
+                editors: Record<string, import('../../editors').Editor>;
+                activeEditorName: string;
+                activeEditorId: string;
+            }>) => number;
+        }, {
+            newEditor(name: string, type: "trilogy" | "sql" | "preql", connection: string, contents: string | undefined): import('../../editors').Editor;
+            addEditor(editor: import('../../editors').Editor): void;
+            getEditorByName(name: string): import('../../editors').Editor | undefined;
+            getConnectionEditors(connection: string, tags?: import('../../editors').EditorTag[]): import('../../editors').Editor[];
+            updateEditorName(id: string, newName: string): void;
+            removeEditor(id: string): false | undefined;
+            setEditorScrollPosition(id: string, scrollPosition: {
+                line: number;
+                column: number;
+            }): void;
+            setEditorContents(id: string, contents: string): void;
+            setEditorResults(id: string, results: import('../../editors/results').Results): void;
+            getCurrentEditorAutocomplete(word: string): import('../../stores/resolver').CompletionItem[];
+        }>;
+        trilogyResolver: FetchResolver;
+        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: 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>;
+    ConceptTable: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        concepts: {
+            type: () => import('../../models').Concept[];
+            required: true;
+        };
+    }>, {
+        tableRef: import('vue').Ref<HTMLDivElement | null, HTMLDivElement | null>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        concepts: {
+            type: () => import('../../models').Concept[];
+            required: true;
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    DatasourceTable: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        datasources: {
+            type: () => import('../../models').Datasource[];
+            required: true;
+        };
+    }>, {
+        tableRef: import('vue').Ref<HTMLDivElement | null, HTMLDivElement | null>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        datasources: {
+            type: () => import('../../models').Datasource[];
+            required: true;
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=ModelCard.vue.d.ts.map