@trilogy-data/trilogy-studio-components 0.1.10 → 0.1.11

package/dist/components/llm/ArtifactsPane.vue.d.ts

@@ -0,0 +1,885 @@
+import { PropType } from 'vue';
+import { ChatArtifact } from '../../chats/chat';
+import { Results, ChartConfig } from '../../editors/results';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    artifacts: {
+        type: PropType<ChatArtifact[]>;
+        required: true;
+    };
+    activeArtifactIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, {
+    visibleArtifacts: import('vue').ComputedRef<{
+        artifact: ChatArtifact;
+        originalIndex: number;
+    }[]>;
+    hiddenArtifacts: import('vue').ComputedRef<{
+        artifact: ChatArtifact;
+        originalIndex: number;
+    }[]>;
+    showHidden: import('vue').Ref<boolean, boolean>;
+    getArtifactResults: (artifact: ChatArtifact) => Results | null;
+    getMarkdownResults: (artifact: ChatArtifact) => Results | null;
+    getArtifactIcon: (artifact: ChatArtifact) => string;
+    getArtifactLabel: (artifact: ChatArtifact, index: number) => string;
+    getArtifactMeta: (artifact: ChatArtifact) => string;
+    isArtifactCollapsed: (artifact: ChatArtifact, index: number) => boolean;
+    toggleArtifactCollapsed: (artifact: ChatArtifact, index: number) => void;
+    getArtifactCardStyle: (artifact: ChatArtifact) => Record<string, string>;
+    getArtifactContainerHeight: (artifact: ChatArtifact) => number;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("chart-config-change" | "publish-artifacts" | "update:activeArtifactIndex" | "unhide-artifact")[], "chart-config-change" | "publish-artifacts" | "update:activeArtifactIndex" | "unhide-artifact", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    artifacts: {
+        type: PropType<ChatArtifact[]>;
+        required: true;
+    };
+    activeArtifactIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{
+    "onChart-config-change"?: ((...args: any[]) => any) | undefined;
+    "onPublish-artifacts"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:activeArtifactIndex"?: ((...args: any[]) => any) | undefined;
+    "onUnhide-artifact"?: ((...args: any[]) => any) | undefined;
+}>, {
+    activeArtifactIndex: number;
+}, {}, {
+    ResultsComponent: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        type: {
+            type: StringConstructor;
+            required: true;
+        };
+        results: {
+            type: typeof Results;
+            required: true;
+        };
+        chartConfig: {
+            type: PropType<ChartConfig | null>;
+            required: false;
+        };
+        error: {
+            type: StringConstructor;
+            required: false;
+        };
+        connection: {
+            type: StringConstructor;
+            required: false;
+        };
+        symbols: {
+            type: PropType<import('../../stores/resolver').CompletionItem[]>;
+            required: false;
+        };
+        containerHeight: NumberConstructor;
+        generatedSql: StringConstructor;
+        trilogySource: StringConstructor;
+        defaultTab: {
+            type: StringConstructor;
+            required: false;
+            default: null;
+        };
+        showChatButton: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>, {
+        codeBlock: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+        connectionStore: import('pinia').Store<"connections", {
+            connections: Record<string, import('../../connections').Connection>;
+        }, {
+            connectionList: (state: {
+                connections: Record<string, import('../../connections').Connection>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                connections: Record<string, import('../../connections').Connection>;
+            }>) => import('../../connections').Connection[];
+            unsavedConnections: (state: {
+                connections: Record<string, import('../../connections').Connection>;
+            } & import('pinia').PiniaCustomStateProperties<{
+                connections: Record<string, import('../../connections').Connection>;
+            }>) => number;
+        }, {
+            addConnection(connection: import('../../connections').Connection): import('../../connections').Connection;
+            connectConnection(name: string): Promise<any>;
+            resetConnection(name: string): Promise<any>;
+            deleteConnection(name: string): void;
+            connectionStateToStatus(connection: import('../../connections').Connection | null): "running" | "failed" | "disabled" | "connected";
+            getConnectionSources(name: string): import('../../stores').ContentInput[];
+            newConnection(name: string, type: string, options: Record<string, any>): import('../../connections').Connection;
+        }>;
+    }, {
+        activeTab: string;
+        activeDrilldown: import('../editor/Results.vue').Drilldown | null;
+        TABS_HEIGHT: number;
+    }, {
+        tabContentHeight(): number;
+        eligibleTabs(): string[];
+        displayTab(): string;
+    }, {
+        switchToVisualizeTab(): void;
+        setTab(tab: string): void;
+        handleReconnect(): Promise<void>;
+        onChartChange(config: any): void;
+        activateDrilldown(e: import('../../events/display').DrillDownTriggerEvent): void;
+        submitDrilldown(selected: string[]): void;
+        handleLocalRefresh(): void;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("drilldown-click" | "refresh-click" | "config-change" | "open-chat")[], "drilldown-click" | "refresh-click" | "config-change" | "open-chat", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        type: {
+            type: StringConstructor;
+            required: true;
+        };
+        results: {
+            type: typeof Results;
+            required: true;
+        };
+        chartConfig: {
+            type: PropType<ChartConfig | null>;
+            required: false;
+        };
+        error: {
+            type: StringConstructor;
+            required: false;
+        };
+        connection: {
+            type: StringConstructor;
+            required: false;
+        };
+        symbols: {
+            type: PropType<import('../../stores/resolver').CompletionItem[]>;
+            required: false;
+        };
+        containerHeight: NumberConstructor;
+        generatedSql: StringConstructor;
+        trilogySource: StringConstructor;
+        defaultTab: {
+            type: StringConstructor;
+            required: false;
+            default: null;
+        };
+        showChatButton: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{
+        "onDrilldown-click"?: ((...args: any[]) => any) | undefined;
+        "onRefresh-click"?: ((...args: any[]) => any) | undefined;
+        "onConfig-change"?: ((...args: any[]) => any) | undefined;
+        "onOpen-chat"?: ((...args: any[]) => any) | undefined;
+    }>, {
+        defaultTab: string;
+        showChatButton: boolean;
+    }, {}, {
+        DataTable: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            headers: {
+                type: {
+                    new (entries?: readonly (readonly [String, import('../../editors/results').ResultColumn])[] | null | undefined): Map<String, import('../../editors/results').ResultColumn>;
+                    new (iterable?: Iterable<readonly [String, import('../../editors/results').ResultColumn]> | null | undefined): Map<String, import('../../editors/results').ResultColumn>;
+                    readonly prototype: Map<any, any>;
+                    readonly [Symbol.species]: MapConstructor;
+                };
+                required: true;
+            };
+            results: {
+                type: PropType<readonly import('../../editors/results').Row[]>;
+                required: true;
+            };
+            containerHeight: NumberConstructor;
+            cellClick: {
+                type: FunctionConstructor;
+                default: () => void;
+            };
+            backgroundClick: {
+                type: FunctionConstructor;
+                default: () => void;
+            };
+            prettyPrint: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            fitParent: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {
+            settingsStore: import('pinia').Store<"userSettings", {
+                settings: import('../../stores/userSettingsStore').UserSettings;
+                defaults: import('../../stores/userSettingsStore').UserSettings;
+                isLoading: boolean;
+                hasChanges: boolean;
+                hasLoaded: boolean;
+            }, {
+                getSettings: (state: {
+                    settings: {
+                        [x: string]: string | number | boolean | string[] | null | undefined;
+                        theme: "dark" | "light" | "";
+                        trilogyResolver: string;
+                        telemetryEnabled: boolean | null;
+                        tipsRead: string[];
+                        skipAllTips: boolean;
+                    };
+                    defaults: {
+                        [x: string]: string | number | boolean | string[] | null | undefined;
+                        theme: "dark" | "light" | "";
+                        trilogyResolver: string;
+                        telemetryEnabled: boolean | null;
+                        tipsRead: string[];
+                        skipAllTips: boolean;
+                    };
+                    isLoading: boolean;
+                    hasChanges: boolean;
+                    hasLoaded: boolean;
+                } & import('pinia').PiniaCustomStateProperties<{
+                    settings: import('../../stores/userSettingsStore').UserSettings;
+                    defaults: import('../../stores/userSettingsStore').UserSettings;
+                    isLoading: boolean;
+                    hasChanges: boolean;
+                    hasLoaded: boolean;
+                }>) => {
+                    [x: string]: string | number | boolean | string[] | null | undefined;
+                    theme: "dark" | "light" | "";
+                    trilogyResolver: string;
+                    telemetryEnabled: boolean | null;
+                    tipsRead: string[];
+                    skipAllTips: boolean;
+                };
+                getDefaults: (state: {
+                    settings: {
+                        [x: string]: string | number | boolean | string[] | null | undefined;
+                        theme: "dark" | "light" | "";
+                        trilogyResolver: string;
+                        telemetryEnabled: boolean | null;
+                        tipsRead: string[];
+                        skipAllTips: boolean;
+                    };
+                    defaults: {
+                        [x: string]: string | number | boolean | string[] | null | undefined;
+                        theme: "dark" | "light" | "";
+                        trilogyResolver: string;
+                        telemetryEnabled: boolean | null;
+                        tipsRead: string[];
+                        skipAllTips: boolean;
+                    };
+                    isLoading: boolean;
+                    hasChanges: boolean;
+                    hasLoaded: boolean;
+                } & import('pinia').PiniaCustomStateProperties<{
+                    settings: import('../../stores/userSettingsStore').UserSettings;
+                    defaults: import('../../stores/userSettingsStore').UserSettings;
+                    isLoading: boolean;
+                    hasChanges: boolean;
+                    hasLoaded: boolean;
+                }>) => {
+                    [x: string]: string | number | boolean | string[] | null | undefined;
+                    theme: "dark" | "light" | "";
+                    trilogyResolver: string;
+                    telemetryEnabled: boolean | null;
+                    tipsRead: string[];
+                    skipAllTips: boolean;
+                };
+                hasUnsavedChanges: (state: {
+                    settings: {
+                        [x: string]: string | number | boolean | string[] | null | undefined;
+                        theme: "dark" | "light" | "";
+                        trilogyResolver: string;
+                        telemetryEnabled: boolean | null;
+                        tipsRead: string[];
+                        skipAllTips: boolean;
+                    };
+                    defaults: {
+                        [x: string]: string | number | boolean | string[] | null | undefined;
+                        theme: "dark" | "light" | "";
+                        trilogyResolver: string;
+                        telemetryEnabled: boolean | null;
+                        tipsRead: string[];
+                        skipAllTips: boolean;
+                    };
+                    isLoading: boolean;
+                    hasChanges: boolean;
+                    hasLoaded: boolean;
+                } & import('pinia').PiniaCustomStateProperties<{
+                    settings: import('../../stores/userSettingsStore').UserSettings;
+                    defaults: import('../../stores/userSettingsStore').UserSettings;
+                    isLoading: boolean;
+                    hasChanges: boolean;
+                    hasLoaded: boolean;
+                }>) => boolean;
+            }, {
+                updateSetting<K extends keyof import('../../stores/userSettingsStore').UserSettings>(key: K, value: import('../../stores/userSettingsStore').UserSettings[K]): void;
+                getUnreadTips(tips: import('../../data/tips').ModalItem[]): import('../../data/tips').ModalItem[];
+                clearDismissedTips(): void;
+                markTipRead(tipId: string): void;
+                clearReadTips(): void;
+                toggleTheme(): void;
+                setHasChanges(value: boolean): void;
+                updateSettings(newSettings: Partial<import('../../stores/userSettingsStore').UserSettings>): void;
+                resetToDefaults(): void;
+                saveSettings(): Promise<boolean>;
+                loadSettings(): void;
+            }>;
+            currentTheme: import('vue').ComputedRef<"" | "dark" | "light">;
+        }, {
+            tabulator: import('vue').ShallowRef<Tabulator> | null;
+            selectedCell: null;
+            controlsVisible: boolean;
+        }, {
+            tableData(): readonly Readonly<Record<string, any>>[];
+            tableColumns(): ColumnDefinition[];
+        }, {
+            copyToClipboard(): Promise<void>;
+            downloadData(): void;
+            showNotification(message: string, type: "success" | "error"): void;
+            create(): void;
+            updateTable(): void;
+            updateTableTheme(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            headers: {
+                type: {
+                    new (entries?: readonly (readonly [String, import('../../editors/results').ResultColumn])[] | null | undefined): Map<String, import('../../editors/results').ResultColumn>;
+                    new (iterable?: Iterable<readonly [String, import('../../editors/results').ResultColumn]> | null | undefined): Map<String, import('../../editors/results').ResultColumn>;
+                    readonly prototype: Map<any, any>;
+                    readonly [Symbol.species]: MapConstructor;
+                };
+                required: true;
+            };
+            results: {
+                type: PropType<readonly import('../../editors/results').Row[]>;
+                required: true;
+            };
+            containerHeight: NumberConstructor;
+            cellClick: {
+                type: FunctionConstructor;
+                default: () => void;
+            };
+            backgroundClick: {
+                type: FunctionConstructor;
+                default: () => void;
+            };
+            prettyPrint: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            fitParent: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, {
+            cellClick: Function;
+            backgroundClick: Function;
+            prettyPrint: boolean;
+            fitParent: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        VegaLiteChart: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            data: {
+                type: PropType<Readonly<import('../../editors/results').Row[]>>;
+                required: true;
+            };
+            columns: {
+                type: PropType<Map<string, import('../../editors/results').ResultColumn>>;
+                required: true;
+            };
+            initialConfig: {
+                type: PropType<ChartConfig | undefined | null>;
+                default: undefined;
+            };
+            showControls: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            containerHeight: NumberConstructor;
+            containerWidth: NumberConstructor;
+            onChartConfigChange: {
+                type: PropType<(config: 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').ChartRenderManager;
+            controlsManager: import('../chartControlsManager').ChartControlsManager;
+            renderChart: (force?: boolean) => Promise<void> | undefined;
+            filteredColumnsInternal: (type: "numeric" | "categorical" | "temporal" | "latitude" | "longitude" | "geographic" | "all") => import('../../editors/results').ResultColumn[];
+            updateConfig: (field: keyof 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').Row[]>>;
+                required: true;
+            };
+            columns: {
+                type: PropType<Map<string, import('../../editors/results').ResultColumn>>;
+                required: true;
+            };
+            initialConfig: {
+                type: PropType<ChartConfig | undefined | null>;
+                default: undefined;
+            };
+            showControls: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            containerHeight: NumberConstructor;
+            containerWidth: NumberConstructor;
+            onChartConfigChange: {
+                type: PropType<(config: ChartConfig) => void>;
+                default: () => void;
+            };
+            chartSelection: {
+                type: PropType<Object[]>;
+                default: () => void;
+            };
+            chartTitle: {
+                type: StringConstructor;
+                default: string;
+            };
+            drilldownActive: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, {
+            onChartConfigChange: (config: ChartConfig) => void;
+            initialConfig: ChartConfig | null | undefined;
+            showControls: boolean;
+            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<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').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<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').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').CompletionItem[]>;
+                required: true;
+            };
+        }>, {
+            searchQuery: import('vue').Ref<string, string>;
+            filteredDimensions: import('vue').Ref<{
+                label: string;
+                description: string;
+                type: string;
+                datatype: string;
+                insertText: string;
+                trilogyType?: ("concept" | "function" | "type") | undefined;
+                trilogySubType?: ("property" | "key" | "metric") | undefined;
+                calculation?: string | undefined;
+                keys?: string[] | undefined;
+            }[], import('../../stores/resolver').CompletionItem[] | {
+                label: string;
+                description: string;
+                type: string;
+                datatype: string;
+                insertText: string;
+                trilogyType?: ("concept" | "function" | "type") | undefined;
+                trilogySubType?: ("property" | "key" | "metric") | undefined;
+                calculation?: string | undefined;
+                keys?: string[] | undefined;
+            }[]>;
+            drilldownSearchInput: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+            dimensionsList: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+            tooltip: {
+                visible: boolean;
+                x: number;
+                y: number;
+                dimension: {
+                    label: string;
+                    description: string;
+                    type: string;
+                    datatype: string;
+                    insertText: string;
+                    trilogyType?: ("concept" | "function" | "type") | undefined;
+                    trilogySubType?: ("property" | "key" | "metric") | undefined;
+                    calculation?: string | undefined;
+                    keys?: string[] | undefined;
+                };
+            };
+            selected: import('vue').Ref<string[], string[]>;
+            highlightedIndex: import('vue').Ref<number, number>;
+            filterDimensions: () => void;
+            selectDimension: (dimension: import('../../stores/resolver').CompletionItem) => void;
+            removeDimension: (dimensionLabel: string) => void;
+            handleSubmit: () => void;
+            handleClose: () => void;
+            handleSearchKeydown: (event: KeyboardEvent) => void;
+            setHighlightedIndex: (index: number) => void;
+            getIconType: (dimension: import('../../stores/resolver').CompletionItem) => string;
+            getIconMdiClass: (dimension: import('../../stores/resolver').CompletionItem) => string;
+            getDimensionChar: (dimension: import('../../stores/resolver').CompletionItem) => string;
+            getIconClass: (dimension: import('../../stores/resolver').CompletionItem) => string;
+            getIconTooltip: (dimension: import('../../stores/resolver').CompletionItem) => string;
+            showTooltip: (event: MouseEvent, dimension: import('../../stores/resolver').CompletionItem) => Promise<void>;
+            hideTooltip: () => void;
+            updateTooltipPosition: (event: MouseEvent) => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("close" | "submit" | "select-dimension" | "remove-dimension")[], "close" | "submit" | "select-dimension" | "remove-dimension", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            drilldownRemove: {
+                type: StringConstructor;
+                required: true;
+            };
+            drilldownFilter: {
+                type: StringConstructor;
+                required: true;
+            };
+            symbols: {
+                type: PropType<import('../../stores/resolver').CompletionItem[]>;
+                required: true;
+            };
+        }>> & Readonly<{
+            onSubmit?: ((...args: any[]) => any) | undefined;
+            onClose?: ((...args: any[]) => any) | undefined;
+            "onSelect-dimension"?: ((...args: any[]) => any) | undefined;
+            "onRemove-dimension"?: ((...args: any[]) => any) | undefined;
+        }>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    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>;
+    MarkdownRenderer: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        markdown: {
+            type: StringConstructor;
+            required: true;
+            default: string;
+        };
+        results: {
+            type: PropType<Results | null>;
+            default: null;
+        };
+        loading: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>, {
+        renderedMarkdown: import('vue').ComputedRef<string>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        markdown: {
+            type: StringConstructor;
+            required: true;
+            default: string;
+        };
+        results: {
+            type: PropType<Results | null>;
+            default: null;
+        };
+        loading: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{}>, {
+        results: Results | null;
+        markdown: string;
+        loading: boolean;
+    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=ArtifactsPane.vue.d.ts.map