@trilogy-data/trilogy-studio-components 0.1.0

package/dist/components/editor/Editor.vue.d.ts

@@ -0,0 +1,816 @@
+import { PropType } from 'vue';
+import { NavigationStore } from '../../stores/useScreenNavigation.ts';
+import { Results } from '../../editors/results.ts';
+import { default as FetchResolver, ContentInput } from '../../stores/resolver.ts';
+import { Import, CompletionItem } from '../../stores/resolver';
+import { EditorTag } from '../../editors/index.ts';
+import { default as QueryExecutionService } from '../../stores/queryExecutionService.ts';
+import { GoToDefinitionEvent } from './events';
+export interface QueryPartial {
+    text: string;
+    queryType: string;
+    editorType: 'trilogy' | 'sql' | 'preql';
+    sources: ContentInput[];
+    imports: Import[];
+}
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    context: {
+        type: PropType<string>;
+        required: true;
+    };
+    editorId: {
+        type: PropType<string>;
+        required: true;
+    };
+    containerHeight: {
+        type: PropType<number>;
+        required: false;
+    };
+}>, {
+    isMobile: boolean;
+    connectionStore: import('pinia').Store<"connections", {
+        connections: Record<string, import('../../connections/base.ts').default>;
+    }, {
+        connectionList: (state: {
+            connections: Record<string, import('../../connections/base.ts').default>;
+        } & import('pinia').PiniaCustomStateProperties<{
+            connections: Record<string, import('../../connections/base.ts').default>;
+        }>) => import('../../connections/base.ts').default[];
+        unsavedConnections: (state: {
+            connections: Record<string, import('../../connections/base.ts').default>;
+        } & import('pinia').PiniaCustomStateProperties<{
+            connections: Record<string, import('../../connections/base.ts').default>;
+        }>) => number;
+    }, {
+        addConnection(connection: import('../../connections/base.ts').default): import('../../connections/base.ts').default;
+        connectConnection(name: string): Promise<any>;
+        resetConnection(name: string): Promise<any>;
+        deleteConnection(name: string): void;
+        connectionStateToStatus(connection: import('../../connections/base.ts').default | null): "running" | "failed" | "disabled" | "connected";
+        getConnectionSources(name: string): ContentInput[];
+        newConnection(name: string, type: string, options: Record<string, any>): import('../../connections/base.ts').default;
+    }>;
+    modelStore: import('pinia').Store<"models", {
+        models: Record<string, import('../../models/model.ts').ModelConfig>;
+    }, {
+        modelList: (state: {
+            models: Record<string, import('../../models/model.ts').ModelConfig>;
+        } & import('pinia').PiniaCustomStateProperties<{
+            models: Record<string, import('../../models/model.ts').ModelConfig>;
+        }>) => import('../../models/model.ts').ModelConfig[];
+        unsavedModels: (state: {
+            models: Record<string, import('../../models/model.ts').ModelConfig>;
+        } & import('pinia').PiniaCustomStateProperties<{
+            models: Record<string, import('../../models/model.ts').ModelConfig>;
+        }>) => number;
+    }, {
+        newModelConfig(name: string, force?: boolean): import('../../models/model.ts').ModelConfig;
+        addModelConfig(model: import('../../models/model.ts').ModelConfig): void;
+        removeModelConfig(name: string): void;
+        updateModelName(name: string, newName: string): void;
+        addEditorAsModelSource(model: string, editor: import('../../main.ts').EditorModel): void;
+        addModelConfigSource(name: string, contents: import('../../models/model.ts').ModelSource): void;
+        removeModelConfigSource(name: string, contents: string): void;
+        setModelConfigParseResults(name: string, results: import('../../models/model.ts').ModelParseResults): void;
+        setModelParseError(name: string, error: string): void;
+    }>;
+    llmStore: import('pinia').Store<"llmConnections", {
+        connections: Record<string, import('../../llm/base.ts').LLMProvider>;
+        activeConnection: string;
+    }, {
+        connectionList: (state: {
+            connections: Record<string, import('../../llm/base.ts').LLMProvider>;
+            activeConnection: string;
+        } & import('pinia').PiniaCustomStateProperties<{
+            connections: Record<string, import('../../llm/base.ts').LLMProvider>;
+            activeConnection: string;
+        }>) => import('../../llm/base.ts').LLMProvider[];
+        unsavedConnections: (state: {
+            connections: Record<string, import('../../llm/base.ts').LLMProvider>;
+            activeConnection: string;
+        } & import('pinia').PiniaCustomStateProperties<{
+            connections: Record<string, import('../../llm/base.ts').LLMProvider>;
+            activeConnection: string;
+        }>) => number;
+        getConnection: (state: {
+            connections: Record<string, import('../../llm/base.ts').LLMProvider>;
+            activeConnection: string;
+        } & import('pinia').PiniaCustomStateProperties<{
+            connections: Record<string, import('../../llm/base.ts').LLMProvider>;
+            activeConnection: string;
+        }>) => (name: string) => import('../../llm/base.ts').LLMProvider;
+        getAllConnections: (state: {
+            connections: Record<string, import('../../llm/base.ts').LLMProvider>;
+            activeConnection: string;
+        } & import('pinia').PiniaCustomStateProperties<{
+            connections: Record<string, import('../../llm/base.ts').LLMProvider>;
+            activeConnection: string;
+        }>) => import('../../llm/base.ts').LLMProvider[];
+        getConnectionStatus: (state: {
+            connections: Record<string, import('../../llm/base.ts').LLMProvider>;
+            activeConnection: string;
+        } & import('pinia').PiniaCustomStateProperties<{
+            connections: Record<string, import('../../llm/base.ts').LLMProvider>;
+            activeConnection: string;
+        }>) => (name: string) => "running" | "failed" | "disabled" | "connected";
+        hasActiveDefaultConnection: (state: {
+            connections: Record<string, import('../../llm/base.ts').LLMProvider>;
+            activeConnection: string;
+        } & import('pinia').PiniaCustomStateProperties<{
+            connections: Record<string, import('../../llm/base.ts').LLMProvider>;
+            activeConnection: string;
+        }>) => boolean;
+    }, {
+        addConnection(connection: import('../../llm/base.ts').LLMProvider, checkForDefault?: boolean): import('../../llm/base.ts').LLMProvider;
+        resetConnection(name: string): Promise<void>;
+        connectionStateToStatus(connection: import('../../llm/base.ts').LLMProvider | null): "running" | "failed" | "disabled" | "connected";
+        newConnection(name: string, type: string, options: Record<string, any>): import('../../llm/base.ts').LLMProvider;
+        fetchModelsForProvider(type: string, apiKey: string): Promise<string[]>;
+        generateValidatedCompletion(base: string, validator?: Function | null, maxAttempts?: number, modelOverride?: string | null, messageHistory?: import('../../llm/base.ts').LLMMessage[] | null, addUserMessage?: boolean): Promise<import('../../stores/llmStore.ts').ValidatedResponse>;
+        generateDashboardCompletion(inputString: string, validator?: Function | null, concepts?: import('../../llm/index.ts').ModelConceptInput[], maxAttempts?: number): Promise<string | null>;
+        generateQueryCompletion(inputString: string, concepts: import('../../llm/index.ts').ModelConceptInput[], validator?: Function | null, maxAttempts?: number, modelOverride?: string | null): Promise<import('../../stores/llmStore.ts').ValidatedResponse>;
+        generateSQLQueryCompletion(inputString: string): Promise<import('../../stores/llmStore.ts').ValidatedResponse>;
+        generateFilterQuery(inputString: string, concepts: import('../../llm/index.ts').ModelConceptInput[], validator?: Function | null, maxAttempts?: number): Promise<string | null>;
+        generateChatName(connectionName: string, messages: import('../../llm/base.ts').LLMMessage[]): Promise<string>;
+        generateCompletion(name: string, options: import('../../llm/base.ts').LLMRequestOptions, history?: import('../../llm/base.ts').LLMMessage[] | null): Promise<import('../../llm/base.ts').LLMResponse>;
+        shouldAutoContinue(connectionName: string, lastAssistantMessage: string): Promise<boolean>;
+    }> | undefined;
+    editorStore: import('pinia').Store<"editors", {
+        editors: Record<string, import('../../main.ts').EditorModel>;
+        activeEditorName: string;
+        activeEditorId: string;
+    }, {
+        editorList: (state: {
+            editors: Record<string, import('../../main.ts').EditorModel>;
+            activeEditorName: string;
+            activeEditorId: string;
+        } & import('pinia').PiniaCustomStateProperties<{
+            editors: Record<string, import('../../main.ts').EditorModel>;
+            activeEditorName: string;
+            activeEditorId: string;
+        }>) => import('../../main.ts').EditorModel[];
+        unsavedEditors: (state: {
+            editors: Record<string, import('../../main.ts').EditorModel>;
+            activeEditorName: string;
+            activeEditorId: string;
+        } & import('pinia').PiniaCustomStateProperties<{
+            editors: Record<string, import('../../main.ts').EditorModel>;
+            activeEditorName: string;
+            activeEditorId: string;
+        }>) => number;
+    }, {
+        newEditor(name: string, type: "trilogy" | "sql" | "preql", connection: string, contents: string | undefined): import('../../main.ts').EditorModel;
+        addEditor(editor: import('../../main.ts').EditorModel): void;
+        getEditorByName(name: string): import('../../main.ts').EditorModel | undefined;
+        getConnectionEditors(connection: string, tags?: EditorTag[]): import('../../main.ts').EditorModel[];
+        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: Results): void;
+        getCurrentEditorAutocomplete(word: string): CompletionItem[];
+    }>;
+    trilogyResolver: FetchResolver;
+    EditorTag: typeof EditorTag;
+    userSettingsStore: import('pinia').Store<"userSettings", {
+        settings: import('../../stores/userSettingsStore.ts').UserSettings;
+        defaults: import('../../stores/userSettingsStore.ts').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.ts').UserSettings;
+            defaults: import('../../stores/userSettingsStore.ts').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.ts').UserSettings;
+            defaults: import('../../stores/userSettingsStore.ts').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.ts').UserSettings;
+            defaults: import('../../stores/userSettingsStore.ts').UserSettings;
+            isLoading: boolean;
+            hasChanges: boolean;
+            hasLoaded: boolean;
+        }>) => boolean;
+    }, {
+        updateSetting<K extends keyof import('../../stores/userSettingsStore.ts').UserSettings>(key: K, value: import('../../stores/userSettingsStore.ts').UserSettings[K]): void;
+        getUnreadTips(tips: import('../../data/tips.ts').ModalItem[]): import('../../data/tips.ts').ModalItem[];
+        clearDismissedTips(): void;
+        markTipRead(tipId: string): void;
+        clearReadTips(): void;
+        toggleTheme(): void;
+        setHasChanges(value: boolean): void;
+        updateSettings(newSettings: Partial<import('../../stores/userSettingsStore.ts').UserSettings>): void;
+        resetToDefaults(): void;
+        saveSettings(): Promise<boolean>;
+        loadSettings(): void;
+    }>;
+    setActiveEditor: Function;
+    queryExecutionService: QueryExecutionService;
+    analyticsStore: import('pinia').Store<"analytics", import('../../stores/analyticsStore.ts').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('../../main.ts').EditorModel;
+    error(): string | null;
+    loading(): boolean;
+    result(): Results;
+    passedQuery(): boolean;
+    generateOverlayVisible(): boolean;
+}, {
+    goToDefinition(e: GoToDefinitionEvent): void;
+    setContent(newContent: string): void;
+    updateEditorName(newName: string): void;
+    toggleTag(tag: EditorTag): void;
+    handleContentsChange(content: string): void;
+    insertSymbol(symbol: CompletionItem): void;
+    handlePositionChange(scrollPosition: {
+        line: number;
+        column: number;
+    }): void;
+    validateQuery(log?: boolean, sources?: ContentInput[] | null): Promise<Import[] | null>;
+    cancelQuery(): Promise<void>;
+    formatQuery(): Promise<void>;
+    buildQueryArgs(text: string): Promise<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: PropType<string>;
+        required: true;
+    };
+    editorId: {
+        type: PropType<string>;
+        required: true;
+    };
+    containerHeight: {
+        type: 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: PropType<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;
+        }[], 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: CompletionItem) => string;
+        getIconMdiClass: (symbol: CompletionItem) => string;
+        getSymbolChar: (symbol: CompletionItem) => string;
+        getIconClass: (symbol: CompletionItem) => string;
+        getIconTooltip: (symbol: CompletionItem) => string;
+        showTooltip: (event: MouseEvent, symbol: 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: PropType<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 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>;
+export default _default;
+//# sourceMappingURL=Editor.vue.d.ts.map