@trilogy-data/trilogy-studio-components 0.1.0

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

@@ -0,0 +1,755 @@
+import { Results, ChartConfig } from '../../editors/results';
+import { PropType } from 'vue';
+import { DrillDownTriggerEvent } from '../../events/display';
+export interface Drilldown {
+    remove: string;
+    filter: string;
+}
+declare const _default: 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<any>;
+        required: false;
+    };
+    containerHeight: NumberConstructor;
+    generatedSql: StringConstructor;
+    defaultTab: {
+        type: StringConstructor;
+        required: false;
+        default: null;
+    };
+}>, {
+    codeBlock: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    connectionStore: import('pinia').Store<"connections", {
+        connections: Record<string, import('../../connections').Connection>;
+    }, {
+        connectionList: (state: {
+            connections: Record<string, import('../../connections').Connection>;
+        } & import('pinia').PiniaCustomStateProperties<{
+            connections: Record<string, import('../../connections').Connection>;
+        }>) => import('../../connections').Connection[];
+        unsavedConnections: (state: {
+            connections: Record<string, import('../../connections').Connection>;
+        } & import('pinia').PiniaCustomStateProperties<{
+            connections: Record<string, import('../../connections').Connection>;
+        }>) => number;
+    }, {
+        addConnection(connection: import('../../connections').Connection): import('../../connections').Connection;
+        connectConnection(name: string): Promise<any>;
+        resetConnection(name: string): Promise<any>;
+        deleteConnection(name: string): void;
+        connectionStateToStatus(connection: import('../../connections').Connection | null): "running" | "failed" | "disabled" | "connected";
+        getConnectionSources(name: string): import('../../stores').ContentInput[];
+        newConnection(name: string, type: string, options: Record<string, any>): import('../../connections').Connection;
+    }>;
+}, {
+    activeTab: string;
+    activeDrilldown: Drilldown | null;
+    TABS_HEIGHT: number;
+}, {
+    tabContentHeight(): number;
+    eligibleTabs(): string[];
+    displayTab(): string;
+}, {
+    setTab(tab: string): void;
+    handleReconnect(): Promise<void>;
+    onChartChange(config: any): void;
+    activateDrilldown(e: 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 Results;
+        required: true;
+    };
+    chartConfig: {
+        type: PropType<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').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<import('tabulator-tables').Tabulator> | null;
+        selectedCell: null;
+        controlsVisible: boolean;
+    }, {
+        tableData(): readonly Readonly<Record<string, any>>[];
+        tableColumns(): import('tabulator-tables').ColumnDefinition[];
+    }, {
+        copyToClipboard(): Promise<void>;
+        downloadData(): void;
+        showNotification(message: string, type: "success" | "error"): void;
+        create(): void;
+        updateTable(): void;
+        updateTableTheme(): void;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        headers: {
+            type: {
+                new (entries?: readonly (readonly [String, import('../../editors/results').ResultColumn])[] | null | undefined): Map<String, import('../../editors/results').ResultColumn>;
+                new (iterable?: Iterable<readonly [String, import('../../editors/results').ResultColumn]> | null | undefined): Map<String, import('../../editors/results').ResultColumn>;
+                readonly prototype: Map<any, any>;
+                readonly [Symbol.species]: MapConstructor;
+            };
+            required: true;
+        };
+        results: {
+            type: 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<{}>, {
+        initialConfig: ChartConfig | null | undefined;
+        showControls: boolean;
+        onChartConfigChange: (config: 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<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>;
+export default _default;
+//# sourceMappingURL=Results.vue.d.ts.map