@trilogy-data/trilogy-studio-components 0.1.0

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

@@ -0,0 +1,1095 @@
+import { PropType } from 'vue';
+import { EditorModel } from '../../main.ts';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    editorData: {
+        type: PropType<EditorModel>;
+        required: true;
+    };
+    containerHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, {
+    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): import('../../stores/resolver.ts').ContentInput[];
+        newConnection(name: string, type: string, options: Record<string, any>): import('../../connections/base.ts').default;
+    }>;
+}, {}, {}, {
+    llmQueryAccepted(): void;
+    handleDrilldown(data: any): void;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    editorData: {
+        type: PropType<EditorModel>;
+        required: true;
+    };
+    containerHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{}>, {
+    containerHeight: number;
+}, {}, {
+    LoadingView: import('vue').DefineComponent<{
+        cancel?: ((() => void) | null) | undefined;
+        text: string;
+        startTime: number | null;
+    }, {
+        containerRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+        containerHeight: import('vue').Ref<number, number>;
+        handleCancel: () => void;
+        trilogyIcon: string;
+        elapsedTime: import('vue').Ref<string, string>;
+        isCompact: import('vue').ComputedRef<boolean>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+        cancel?: ((() => void) | null) | undefined;
+        text: string;
+        startTime: number | null;
+    }> & Readonly<{}>, {
+        text: string;
+        startTime: number | null;
+    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    ErrorMessage: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        type: {
+            type: () => "error" | "information";
+            default: string;
+            validator: (value: string) => boolean;
+        };
+    }>, {}, {}, {
+        messageClass(): string;
+        iconEmoji(): string;
+    }, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        type: {
+            type: () => "error" | "information";
+            default: string;
+            validator: (value: string) => boolean;
+        };
+    }>> & Readonly<{}>, {
+        type: "error" | "information";
+    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    LoadingButton: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        action: {
+            type: FunctionConstructor;
+            required: true;
+        };
+        useDefaultStyle: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        keyCombination: {
+            type: {
+                (arrayLength: number): string[];
+                (...items: string[]): string[];
+                new (arrayLength: number): string[];
+                new (...items: string[]): string[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                readonly [Symbol.species]: ArrayConstructor;
+            };
+            default: null;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        testId: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>, {
+        errorMessage: import('vue').Ref<string | null, string | null>;
+        isLoading: import('vue').Ref<boolean, boolean>;
+        status: import('vue').Ref<"success" | "error" | null, "success" | "error" | null>;
+        handleClick: () => Promise<void>;
+        handleKeydown: (event: KeyboardEvent) => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        action: {
+            type: FunctionConstructor;
+            required: true;
+        };
+        useDefaultStyle: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        keyCombination: {
+            type: {
+                (arrayLength: number): string[];
+                (...items: string[]): string[];
+                new (arrayLength: number): string[];
+                new (...items: string[]): string[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                readonly [Symbol.species]: ArrayConstructor;
+            };
+            default: null;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        testId: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>> & Readonly<{}>, {
+        disabled: boolean;
+        useDefaultStyle: boolean;
+        keyCombination: string[];
+        testId: string;
+    }, {}, {
+        Tooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            content: {
+                type: StringConstructor;
+                required: true;
+            };
+            position: {
+                type: StringConstructor;
+                default: string;
+            };
+            inline: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {}, {
+            visible: boolean;
+            hoverTimeout: ReturnType<typeof setTimeout> | null;
+        }, {
+            positionClass(): string;
+        }, {
+            showTooltip(): void;
+            hideTooltip(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            content: {
+                type: StringConstructor;
+                required: true;
+            };
+            position: {
+                type: StringConstructor;
+                default: string;
+            };
+            inline: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, {
+            position: string;
+            inline: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    ResultsContainer: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        type: {
+            type: StringConstructor;
+            required: true;
+        };
+        results: {
+            type: typeof import('../../editors/results.ts').Results;
+            required: true;
+        };
+        chartConfig: {
+            type: PropType<import('../../editors/results.ts').ChartConfig | null>;
+            required: false;
+        };
+        error: {
+            type: StringConstructor;
+            required: false;
+        };
+        connection: {
+            type: StringConstructor;
+            required: false;
+        };
+        symbols: {
+            type: PropType<any>;
+            required: false;
+        };
+        containerHeight: NumberConstructor;
+        generatedSql: StringConstructor;
+        defaultTab: {
+            type: StringConstructor;
+            required: false;
+            default: null;
+        };
+    }>, {
+        codeBlock: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+        connectionStore: import('pinia').Store<"connections", {
+            connections: Record<string, import('../../connections/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): import('../../stores/resolver.ts').ContentInput[];
+            newConnection(name: string, type: string, options: Record<string, any>): import('../../connections/base.ts').default;
+        }>;
+    }, {
+        activeTab: string;
+        activeDrilldown: import('./Results.vue').Drilldown | null;
+        TABS_HEIGHT: number;
+    }, {
+        tabContentHeight(): number;
+        eligibleTabs(): string[];
+        displayTab(): string;
+    }, {
+        setTab(tab: string): void;
+        handleReconnect(): Promise<void>;
+        onChartChange(config: any): void;
+        activateDrilldown(e: import('../../events/display.ts').DrillDownTriggerEvent): void;
+        submitDrilldown(selected: string[]): void;
+        handleLocalRefresh(): void;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        type: {
+            type: StringConstructor;
+            required: true;
+        };
+        results: {
+            type: typeof import('../../editors/results.ts').Results;
+            required: true;
+        };
+        chartConfig: {
+            type: PropType<import('../../editors/results.ts').ChartConfig | null>;
+            required: false;
+        };
+        error: {
+            type: StringConstructor;
+            required: false;
+        };
+        connection: {
+            type: StringConstructor;
+            required: false;
+        };
+        symbols: {
+            type: PropType<any>;
+            required: false;
+        };
+        containerHeight: NumberConstructor;
+        generatedSql: StringConstructor;
+        defaultTab: {
+            type: StringConstructor;
+            required: false;
+            default: null;
+        };
+    }>> & Readonly<{}>, {
+        defaultTab: string;
+    }, {}, {
+        DataTable: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            headers: {
+                type: {
+                    new (entries?: readonly (readonly [String, import('../../editors/results.ts').ResultColumn])[] | null | undefined): Map<String, import('../../editors/results.ts').ResultColumn>;
+                    new (iterable?: Iterable<readonly [String, import('../../editors/results.ts').ResultColumn]> | null | undefined): Map<String, import('../../editors/results.ts').ResultColumn>;
+                    readonly prototype: Map<any, any>;
+                    readonly [Symbol.species]: MapConstructor;
+                };
+                required: true;
+            };
+            results: {
+                type: PropType<readonly import('../../editors/results.ts').Row[]>;
+                required: true;
+            };
+            containerHeight: NumberConstructor;
+            cellClick: {
+                type: FunctionConstructor;
+                default: () => void;
+            };
+            backgroundClick: {
+                type: FunctionConstructor;
+                default: () => void;
+            };
+            prettyPrint: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            fitParent: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {
+            settingsStore: import('pinia').Store<"userSettings", {
+                settings: import('../../stores/userSettingsStore.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;
+            }>;
+            currentTheme: import('vue').ComputedRef<"" | "dark" | "light">;
+        }, {
+            tabulator: import('vue').ShallowRef<import('tabulator-tables').Tabulator> | null;
+            selectedCell: null;
+            controlsVisible: boolean;
+        }, {
+            tableData(): readonly Readonly<Record<string, any>>[];
+            tableColumns(): import('tabulator-tables').ColumnDefinition[];
+        }, {
+            copyToClipboard(): Promise<void>;
+            downloadData(): void;
+            showNotification(message: string, type: "success" | "error"): void;
+            create(): void;
+            updateTable(): void;
+            updateTableTheme(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            headers: {
+                type: {
+                    new (entries?: readonly (readonly [String, import('../../editors/results.ts').ResultColumn])[] | null | undefined): Map<String, import('../../editors/results.ts').ResultColumn>;
+                    new (iterable?: Iterable<readonly [String, import('../../editors/results.ts').ResultColumn]> | null | undefined): Map<String, import('../../editors/results.ts').ResultColumn>;
+                    readonly prototype: Map<any, any>;
+                    readonly [Symbol.species]: MapConstructor;
+                };
+                required: true;
+            };
+            results: {
+                type: PropType<readonly import('../../editors/results.ts').Row[]>;
+                required: true;
+            };
+            containerHeight: NumberConstructor;
+            cellClick: {
+                type: FunctionConstructor;
+                default: () => void;
+            };
+            backgroundClick: {
+                type: FunctionConstructor;
+                default: () => void;
+            };
+            prettyPrint: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            fitParent: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, {
+            cellClick: Function;
+            backgroundClick: Function;
+            prettyPrint: boolean;
+            fitParent: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        VegaLiteChart: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            data: {
+                type: PropType<Readonly<import('../../editors/results.ts').Row[]>>;
+                required: true;
+            };
+            columns: {
+                type: PropType<Map<string, import('../../editors/results.ts').ResultColumn>>;
+                required: true;
+            };
+            initialConfig: {
+                type: PropType<import('../../editors/results.ts').ChartConfig | undefined | null>;
+                default: undefined;
+            };
+            showControls: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            containerHeight: NumberConstructor;
+            containerWidth: NumberConstructor;
+            onChartConfigChange: {
+                type: PropType<(config: import('../../editors/results.ts').ChartConfig) => void>;
+                default: () => void;
+            };
+            chartSelection: {
+                type: PropType<Object[]>;
+                default: () => void;
+            };
+            chartTitle: {
+                type: StringConstructor;
+                default: string;
+            };
+            drilldownActive: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {
+            vegaContainer1: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+            vegaContainer2: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+            chartContentArea: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+            renderManager: import('../chartRenderManager.ts').ChartRenderManager;
+            controlsManager: import('../chartControlsManager.ts').ChartControlsManager;
+            renderChart: (force?: boolean) => Promise<void> | undefined;
+            filteredColumnsInternal: (type: "numeric" | "categorical" | "temporal" | "latitude" | "longitude" | "geographic" | "all") => import('../../editors/results.ts').ResultColumn[];
+            updateConfig: (field: keyof import('../../editors/results.ts').ChartConfig, value: string | boolean | number) => void;
+            openInVegaEditor: () => void;
+            downloadChart: () => Promise<void>;
+            refreshChart: () => void;
+            charts: import('vue').ComputedRef<{
+                value: string;
+                label: string;
+                icon: string;
+            }[]>;
+            isShortContainer: import('vue').ComputedRef<boolean | 0 | undefined>;
+            revertDrilldown: () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            data: {
+                type: PropType<Readonly<import('../../editors/results.ts').Row[]>>;
+                required: true;
+            };
+            columns: {
+                type: PropType<Map<string, import('../../editors/results.ts').ResultColumn>>;
+                required: true;
+            };
+            initialConfig: {
+                type: PropType<import('../../editors/results.ts').ChartConfig | undefined | null>;
+                default: undefined;
+            };
+            showControls: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            containerHeight: NumberConstructor;
+            containerWidth: NumberConstructor;
+            onChartConfigChange: {
+                type: PropType<(config: import('../../editors/results.ts').ChartConfig) => void>;
+                default: () => void;
+            };
+            chartSelection: {
+                type: PropType<Object[]>;
+                default: () => void;
+            };
+            chartTitle: {
+                type: StringConstructor;
+                default: string;
+            };
+            drilldownActive: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, {
+            initialConfig: import('../../editors/results.ts').ChartConfig | null | undefined;
+            showControls: boolean;
+            onChartConfigChange: (config: import('../../editors/results.ts').ChartConfig) => void;
+            chartSelection: Object[];
+            chartTitle: string;
+            drilldownActive: boolean;
+        }, {}, {
+            Tooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                position: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {}, {
+                visible: boolean;
+                hoverTimeout: ReturnType<typeof setTimeout> | null;
+            }, {
+                positionClass(): string;
+            }, {
+                showTooltip(): void;
+                hideTooltip(): void;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                position: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                position: string;
+                inline: boolean;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            ChartControlPanel: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                config: {
+                    type: PropType<import('../../editors/results.ts').ChartConfig>;
+                    required: true;
+                };
+                charts: {
+                    type: PropType<Array<{
+                        value: string;
+                        label: string;
+                        icon: string;
+                    }>>;
+                    required: true;
+                };
+                filteredColumns: {
+                    type: PropType<(type: "numeric" | "categorical" | "temporal" | "latitude" | "longitude" | "geographic" | "all") => import('../../editors/results.ts').ResultColumn[]>;
+                    required: true;
+                };
+            }>, {
+                controlSections: import('vue').ComputedRef<import('../ChartControlPanel.vue').ChartControlSection[]>;
+                updateConfig: (field: string, value: any) => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("update-config" | "open-vega-editor")[], "update-config" | "open-vega-editor", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                config: {
+                    type: PropType<import('../../editors/results.ts').ChartConfig>;
+                    required: true;
+                };
+                charts: {
+                    type: PropType<Array<{
+                        value: string;
+                        label: string;
+                        icon: string;
+                    }>>;
+                    required: true;
+                };
+                filteredColumns: {
+                    type: PropType<(type: "numeric" | "categorical" | "temporal" | "latitude" | "longitude" | "geographic" | "all") => import('../../editors/results.ts').ResultColumn[]>;
+                    required: true;
+                };
+            }>> & Readonly<{
+                "onUpdate-config"?: ((...args: any[]) => any) | undefined;
+                "onOpen-vega-editor"?: ((...args: any[]) => any) | undefined;
+            }>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        ErrorMessage: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            type: {
+                type: () => "error" | "information";
+                default: string;
+                validator: (value: string) => boolean;
+            };
+        }>, {}, {}, {
+            messageClass(): string;
+            iconEmoji(): string;
+        }, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            type: {
+                type: () => "error" | "information";
+                default: string;
+                validator: (value: string) => boolean;
+            };
+        }>> & Readonly<{}>, {
+            type: "error" | "information";
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        LoadingButton: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            action: {
+                type: FunctionConstructor;
+                required: true;
+            };
+            useDefaultStyle: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            keyCombination: {
+                type: {
+                    (arrayLength: number): string[];
+                    (...items: string[]): string[];
+                    new (arrayLength: number): string[];
+                    new (...items: string[]): string[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                default: null;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            testId: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {
+            errorMessage: import('vue').Ref<string | null, string | null>;
+            isLoading: import('vue').Ref<boolean, boolean>;
+            status: import('vue').Ref<"success" | "error" | null, "success" | "error" | null>;
+            handleClick: () => Promise<void>;
+            handleKeydown: (event: KeyboardEvent) => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            action: {
+                type: FunctionConstructor;
+                required: true;
+            };
+            useDefaultStyle: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            keyCombination: {
+                type: {
+                    (arrayLength: number): string[];
+                    (...items: string[]): string[];
+                    new (arrayLength: number): string[];
+                    new (...items: string[]): string[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                default: null;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            testId: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            disabled: boolean;
+            useDefaultStyle: boolean;
+            keyCombination: string[];
+            testId: string;
+        }, {}, {
+            Tooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                position: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {}, {
+                visible: boolean;
+                hoverTimeout: ReturnType<typeof setTimeout> | null;
+            }, {
+                positionClass(): string;
+            }, {
+                showTooltip(): void;
+                hideTooltip(): void;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                position: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                position: string;
+                inline: boolean;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        CodeBlock: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            content: {
+                type: StringConstructor;
+                required: true;
+            };
+            language: {
+                type: PropType<"sql" | "trilogy">;
+                default: string;
+            };
+            copy: {
+                type: FunctionConstructor;
+                optional: boolean;
+            };
+        }>, {
+            codeBlock: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+            codeClass: import('vue').Ref<string, string>;
+            copyCode: () => Promise<void>;
+            copied: import('vue').Ref<boolean, boolean>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "on-copy"[], "on-copy", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            content: {
+                type: StringConstructor;
+                required: true;
+            };
+            language: {
+                type: PropType<"sql" | "trilogy">;
+                default: string;
+            };
+            copy: {
+                type: FunctionConstructor;
+                optional: boolean;
+            };
+        }>> & Readonly<{
+            "onOn-copy"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            language: "trilogy" | "sql";
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        DrilldownPane: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            drilldownRemove: {
+                type: StringConstructor;
+                required: true;
+            };
+            drilldownFilter: {
+                type: StringConstructor;
+                required: true;
+            };
+            symbols: {
+                type: PropType<import('../../stores/resolver.ts').CompletionItem[]>;
+                required: true;
+            };
+        }>, {
+            searchQuery: import('vue').Ref<string, string>;
+            filteredDimensions: import('vue').Ref<{
+                label: string;
+                description: string;
+                type: string;
+                datatype: string;
+                insertText: string;
+                trilogyType?: ("concept" | "function" | "type") | undefined;
+                trilogySubType?: ("property" | "key" | "metric") | undefined;
+                calculation?: string | undefined;
+                keys?: string[] | undefined;
+            }[], import('../../stores/resolver.ts').CompletionItem[] | {
+                label: string;
+                description: string;
+                type: string;
+                datatype: string;
+                insertText: string;
+                trilogyType?: ("concept" | "function" | "type") | undefined;
+                trilogySubType?: ("property" | "key" | "metric") | undefined;
+                calculation?: string | undefined;
+                keys?: string[] | undefined;
+            }[]>;
+            drilldownSearchInput: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+            dimensionsList: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+            tooltip: {
+                visible: boolean;
+                x: number;
+                y: number;
+                dimension: {
+                    label: string;
+                    description: string;
+                    type: string;
+                    datatype: string;
+                    insertText: string;
+                    trilogyType?: ("concept" | "function" | "type") | undefined;
+                    trilogySubType?: ("property" | "key" | "metric") | undefined;
+                    calculation?: string | undefined;
+                    keys?: string[] | undefined;
+                };
+            };
+            selected: import('vue').Ref<string[], string[]>;
+            highlightedIndex: import('vue').Ref<number, number>;
+            filterDimensions: () => void;
+            selectDimension: (dimension: import('../../stores/resolver.ts').CompletionItem) => void;
+            removeDimension: (dimensionLabel: string) => void;
+            handleSubmit: () => void;
+            handleClose: () => void;
+            handleSearchKeydown: (event: KeyboardEvent) => void;
+            setHighlightedIndex: (index: number) => void;
+            getIconType: (dimension: import('../../stores/resolver.ts').CompletionItem) => string;
+            getIconMdiClass: (dimension: import('../../stores/resolver.ts').CompletionItem) => string;
+            getDimensionChar: (dimension: import('../../stores/resolver.ts').CompletionItem) => string;
+            getIconClass: (dimension: import('../../stores/resolver.ts').CompletionItem) => string;
+            getIconTooltip: (dimension: import('../../stores/resolver.ts').CompletionItem) => string;
+            showTooltip: (event: MouseEvent, dimension: import('../../stores/resolver.ts').CompletionItem) => Promise<void>;
+            hideTooltip: () => void;
+            updateTooltipPosition: (event: MouseEvent) => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("close" | "submit" | "select-dimension" | "remove-dimension")[], "close" | "submit" | "select-dimension" | "remove-dimension", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            drilldownRemove: {
+                type: StringConstructor;
+                required: true;
+            };
+            drilldownFilter: {
+                type: StringConstructor;
+                required: true;
+            };
+            symbols: {
+                type: PropType<import('../../stores/resolver.ts').CompletionItem[]>;
+                required: true;
+            };
+        }>> & Readonly<{
+            onSubmit?: ((...args: any[]) => any) | undefined;
+            onClose?: ((...args: any[]) => any) | undefined;
+            "onSelect-dimension"?: ((...args: any[]) => any) | undefined;
+            "onRemove-dimension"?: ((...args: any[]) => any) | undefined;
+        }>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    HintComponent: import('vue').DefineComponent<{}, {}, {
+        staticShortcuts: {
+            name: string;
+            keys: string[];
+        }[];
+        sysType: string;
+    }, {
+        shortcuts(): Array<any>;
+        icon(): "⌘" | "Ctrl";
+    }, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    LLMChatRefinement: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        messages: {
+            type: PropType<import('../../llm/base.ts').LLMMessage[]>;
+            default: () => never[];
+        };
+        validateFn: {
+            type: FunctionConstructor;
+            default: () => boolean;
+        };
+        extractionFn: {
+            type: FunctionConstructor;
+            default: () => null;
+        };
+        mutationFn: {
+            type: FunctionConstructor;
+            default: () => null;
+        };
+        closeFn: {
+            type: FunctionConstructor;
+            default: () => void;
+        };
+        autoActivate: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        initialMessage: {
+            type: StringConstructor;
+            required: false;
+        };
+    }>, {
+        messages: import('vue').Ref<{
+            role: "user" | "assistant" | "system";
+            content: string;
+            modelInfo?: {
+                totalTokens: number;
+            } | undefined;
+            hidden?: boolean | undefined;
+        }[], import('../../llm/base.ts').LLMMessage[] | {
+            role: "user" | "assistant" | "system";
+            content: string;
+            modelInfo?: {
+                totalTokens: number;
+            } | undefined;
+            hidden?: boolean | undefined;
+        }[]>;
+        userInput: import('vue').Ref<string, string>;
+        isLoading: import('vue').Ref<boolean, boolean>;
+        messagesContainer: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+        inputTextarea: import('vue').Ref<HTMLTextAreaElement | null, HTMLTextAreaElement | null>;
+        getExtractedContent: (message: import('../../llm/base.ts').LLMMessage) => string | null;
+        containsExtractedContent: (message: import('../../llm/base.ts').LLMMessage) => boolean;
+        formatMessageWithPlaceholder: (message: import('../../llm/base.ts').LLMMessage) => string;
+        handleKeyDown: (event: KeyboardEvent) => void;
+        sendMessage: () => Promise<void>;
+        acceptResult: () => Promise<void>;
+        handleClose: () => Promise<void>;
+        activateChat: () => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        messages: {
+            type: PropType<import('../../llm/base.ts').LLMMessage[]>;
+            default: () => never[];
+        };
+        validateFn: {
+            type: FunctionConstructor;
+            default: () => boolean;
+        };
+        extractionFn: {
+            type: FunctionConstructor;
+            default: () => null;
+        };
+        mutationFn: {
+            type: FunctionConstructor;
+            default: () => null;
+        };
+        closeFn: {
+            type: FunctionConstructor;
+            default: () => void;
+        };
+        autoActivate: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        initialMessage: {
+            type: StringConstructor;
+            required: false;
+        };
+    }>> & Readonly<{}>, {
+        messages: import('../../llm/base.ts').LLMMessage[];
+        extractionFn: Function;
+        mutationFn: Function;
+        validateFn: Function;
+        closeFn: Function;
+        autoActivate: boolean;
+    }, {}, {
+        CodeBlock: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            content: {
+                type: StringConstructor;
+                required: true;
+            };
+            language: {
+                type: PropType<"sql" | "trilogy">;
+                default: string;
+            };
+            copy: {
+                type: FunctionConstructor;
+                optional: boolean;
+            };
+        }>, {
+            codeBlock: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+            codeClass: import('vue').Ref<string, string>;
+            copyCode: () => Promise<void>;
+            copied: import('vue').Ref<boolean, boolean>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "on-copy"[], "on-copy", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            content: {
+                type: StringConstructor;
+                required: true;
+            };
+            language: {
+                type: PropType<"sql" | "trilogy">;
+                default: string;
+            };
+            copy: {
+                type: FunctionConstructor;
+                optional: boolean;
+            };
+        }>> & Readonly<{
+            "onOn-copy"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            language: "trilogy" | "sql";
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=ResultComponent.vue.d.ts.map