@trilogy-data/trilogy-studio-components 0.1.0

package/dist/components/dashboard/DashboardChartEditor.vue.d.ts

@@ -0,0 +1,325 @@
+import { Import, ContentInput } from '../../stores/resolver';
+export interface DashboardChartEditorProps {
+    content: string;
+    connectionName: string;
+    imports: Import[];
+    rootContent: ContentInput[];
+    showing: boolean;
+    initialWidth?: number;
+    initialHeight?: number;
+}
+declare const _default: import('vue').DefineComponent<DashboardChartEditorProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    cancel: (...args: any[]) => void;
+    save: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<DashboardChartEditorProps> & Readonly<{
+    onCancel?: ((...args: any[]) => any) | undefined;
+    onSave?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    editorElement: HTMLDivElement;
+    editor: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        onSave: {
+            type: import('vue').PropType<(() => void) | null>;
+            required: false;
+            default: null;
+        };
+        theme: {
+            type: StringConstructor;
+            default: string;
+        };
+        initContent: {
+            type: StringConstructor;
+            required: false;
+            default: string;
+        };
+        connectionName: {
+            type: StringConstructor;
+            required: true;
+        };
+        imports: {
+            type: import('vue').PropType<Import[]>;
+            required: false;
+            default: () => never[];
+        };
+        rootContent: {
+            type: import('vue').PropType<ContentInput[]>;
+            required: false;
+            default: () => never[];
+        };
+    }>> & Readonly<{
+        "onFormat-query"?: ((...args: any[]) => any) | undefined;
+        "onQuery-started"?: ((...args: any[]) => any) | undefined;
+    }>, {
+        queryExecutionService: import('../../stores').QueryExecutionService | undefined;
+        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): ContentInput[];
+            newConnection(name: string, type: string, options: Record<string, any>): import('../../connections').Connection;
+        }> | undefined;
+        isMobile: unknown;
+        llmConnectionStore: unknown;
+        analyticsStore: import('pinia').Store<"analytics", import('../../stores/analyticsStore').AnalyticsState, {}, {
+            log(path: string, title?: string, isEvent?: boolean): void;
+            setEnabled(enabled: boolean): void;
+            setSendTelemetry(send: boolean): void;
+            init({ enabled, sendTelemetry, }: {
+                enabled?: boolean;
+                sendTelemetry?: boolean;
+            }): void;
+        }> | undefined;
+    }, {
+        lastOperation: import('../SimpleEditor.vue').OperationState | null;
+        editor: import('../../editors').Editor;
+        activePanel: string;
+        isPanelVisible: boolean;
+    }, {}, {
+        togglePanel(panelName: string): void;
+        closePanel(): void;
+        getPanelTitle(): string;
+        createEditor(): void;
+        handleKeyboardShortcuts(event: KeyboardEvent): void;
+        focusSymbolSearch(): void;
+        insertSymbol(symbol: import('../../stores/resolver').CompletionItem): void;
+        validateQuery(showMarkers?: boolean): Promise<Import[]>;
+        formatQuery(): Promise<void>;
+        cancelQuery(): Promise<void>;
+        runQuery(): Promise<void>;
+        generateLLMQuery(): Promise<void>;
+        getContent(): string;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("format-query" | "query-started")[], import('vue').PublicProps, {
+        theme: string;
+        imports: Import[];
+        onSave: (() => void) | null;
+        initContent: string;
+        rootContent: ContentInput[];
+    }, true, {}, {}, {
+        SymbolsPane: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            symbols: {
+                type: import('vue').PropType<import('../../stores/resolver').CompletionItem[]>;
+                required: true;
+            };
+            editorHeight: {
+                type: NumberConstructor;
+                required: false;
+                default: null;
+            };
+        }>, {
+            searchQuery: import('vue').Ref<string, string>;
+            filteredSymbols: import('vue').Ref<{
+                label: string;
+                description: string;
+                type: string;
+                datatype: string;
+                insertText: string;
+                trilogyType?: ("concept" | "function" | "type") | undefined;
+                trilogySubType?: ("property" | "key" | "metric") | undefined;
+                calculation?: string | undefined;
+                keys?: string[] | undefined;
+            }[], import('../../stores/resolver').CompletionItem[] | {
+                label: string;
+                description: string;
+                type: string;
+                datatype: string;
+                insertText: string;
+                trilogyType?: ("concept" | "function" | "type") | undefined;
+                trilogySubType?: ("property" | "key" | "metric") | undefined;
+                calculation?: string | undefined;
+                keys?: string[] | undefined;
+            }[]>;
+            symbolSearchInput: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+            filters: import('vue').Ref<{
+                keys: boolean;
+                properties: boolean;
+                metrics: boolean;
+            }, {
+                keys: boolean;
+                properties: boolean;
+                metrics: boolean;
+            } | {
+                keys: boolean;
+                properties: boolean;
+                metrics: boolean;
+            }>;
+            isFiltering: import('vue').ComputedRef<boolean>;
+            tooltip: {
+                visible: boolean;
+                x: number;
+                y: number;
+                symbol: {
+                    label: string;
+                    description: string;
+                    type: string;
+                    datatype: string;
+                    insertText: string;
+                    trilogyType?: ("concept" | "function" | "type") | undefined;
+                    trilogySubType?: ("property" | "key" | "metric") | undefined;
+                    calculation?: string | undefined;
+                    keys?: string[] | undefined;
+                };
+            };
+            clearFilters: () => void;
+            filterSymbols: () => void;
+            getIconType: (symbol: import('../../stores/resolver').CompletionItem) => string;
+            getIconMdiClass: (symbol: import('../../stores/resolver').CompletionItem) => string;
+            getSymbolChar: (symbol: import('../../stores/resolver').CompletionItem) => string;
+            getIconClass: (symbol: import('../../stores/resolver').CompletionItem) => string;
+            getIconTooltip: (symbol: import('../../stores/resolver').CompletionItem) => string;
+            showTooltip: (event: MouseEvent, symbol: import('../../stores/resolver').CompletionItem) => Promise<void>;
+            hideTooltip: () => void;
+            updateTooltipPosition: (event: MouseEvent) => void;
+            focusSearch: () => void;
+            editorHeightCalc: import('vue').ComputedRef<string>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("select-symbol" | "focus-search")[], "select-symbol" | "focus-search", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            symbols: {
+                type: import('vue').PropType<import('../../stores/resolver').CompletionItem[]>;
+                required: true;
+            };
+            editorHeight: {
+                type: NumberConstructor;
+                required: false;
+                default: null;
+            };
+        }>> & Readonly<{
+            "onSelect-symbol"?: ((...args: any[]) => any) | undefined;
+            "onFocus-search"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            editorHeight: number;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        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>;
+    } & import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('vue').ExtractPropTypes<{
+        onSave: {
+            type: import('vue').PropType<(() => void) | null>;
+            required: false;
+            default: null;
+        };
+        theme: {
+            type: StringConstructor;
+            default: string;
+        };
+        initContent: {
+            type: StringConstructor;
+            required: false;
+            default: string;
+        };
+        connectionName: {
+            type: StringConstructor;
+            required: true;
+        };
+        imports: {
+            type: import('vue').PropType<Import[]>;
+            required: false;
+            default: () => never[];
+        };
+        rootContent: {
+            type: import('vue').PropType<ContentInput[]>;
+            required: false;
+            default: () => never[];
+        };
+    }>> & Readonly<{
+        "onFormat-query"?: ((...args: any[]) => any) | undefined;
+        "onQuery-started"?: ((...args: any[]) => any) | undefined;
+    }>, {
+        queryExecutionService: import('../../stores').QueryExecutionService | undefined;
+        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): ContentInput[];
+            newConnection(name: string, type: string, options: Record<string, any>): import('../../connections').Connection;
+        }> | undefined;
+        isMobile: unknown;
+        llmConnectionStore: unknown;
+        analyticsStore: import('pinia').Store<"analytics", import('../../stores/analyticsStore').AnalyticsState, {}, {
+            log(path: string, title?: string, isEvent?: boolean): void;
+            setEnabled(enabled: boolean): void;
+            setSendTelemetry(send: boolean): void;
+            init({ enabled, sendTelemetry, }: {
+                enabled?: boolean;
+                sendTelemetry?: boolean;
+            }): void;
+        }> | undefined;
+    }, {
+        lastOperation: import('../SimpleEditor.vue').OperationState | null;
+        editor: import('../../editors').Editor;
+        activePanel: string;
+        isPanelVisible: boolean;
+    }, {}, {
+        togglePanel(panelName: string): void;
+        closePanel(): void;
+        getPanelTitle(): string;
+        createEditor(): void;
+        handleKeyboardShortcuts(event: KeyboardEvent): void;
+        focusSymbolSearch(): void;
+        insertSymbol(symbol: import('../../stores/resolver').CompletionItem): void;
+        validateQuery(showMarkers?: boolean): Promise<Import[]>;
+        formatQuery(): Promise<void>;
+        cancelQuery(): Promise<void>;
+        runQuery(): Promise<void>;
+        generateLLMQuery(): Promise<void>;
+        getContent(): string;
+    }, {
+        theme: string;
+        imports: Import[];
+        onSave: (() => void) | null;
+        initContent: string;
+        rootContent: ContentInput[];
+    }> | null;
+}, HTMLDivElement>;
+export default _default;
+//# sourceMappingURL=DashboardChartEditor.vue.d.ts.map

package/dist/components/dashboard/DashboardChartEditor.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DashboardChartEditor.vue.d.ts","sourceRoot":"","sources":["../../../components/dashboard/DashboardChartEditor.vue"],"names":[],"mappings":"AAoJA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,uBAAuB,CAAA;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAMzD,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,MAAM,CAAA;IACf,cAAc,EAAE,MAAM,CAAA;IACtB,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,WAAW,EAAE,YAAY,EAAE,CAAA;IAC3B,OAAO,EAAE,OAAO,CAAA;IAChB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAnBD,CAnFoB;6BAmFpB,CAnFkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAmFlD,CAnFoB;6BAmFpB,CAnFkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmPlD,wBASG"}

package/dist/components/dashboard/DashboardCreatorIcon.vue.d.ts

@@ -0,0 +1,52 @@
+declare const _default: import('vue').DefineComponent<{
+    connection: string;
+    title: string;
+}, {
+    createDashboard: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    connection: string;
+    title: string;
+}> & Readonly<{}>, {
+    title: 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>;
+export default _default;
+//# sourceMappingURL=DashboardCreatorIcon.vue.d.ts.map

package/dist/components/dashboard/DashboardCreatorIcon.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DashboardCreatorIcon.vue.d.ts","sourceRoot":"","sources":["../../../components/dashboard/DashboardCreatorIcon.vue"],"names":[],"mappings":"AAOA;;gBAqG6B,MAAM;WAAS,MAAM;;;;gBAArB,MAAM;WAAS,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAflD,wBA2CC"}

package/dist/components/dashboard/DashboardCreatorInline.vue.d.ts

@@ -0,0 +1,36 @@
+import { Ref } from 'vue';
+import { DashboardImport } from '../../dashboards/base';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    visible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    testTag: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {
+    dashboardName: Ref<string, string>;
+    selectedConnection: Ref<string, string>;
+    dashboardPrompt: Ref<string, string>;
+    showPromptField: import('vue').ComputedRef<boolean>;
+    connections: import('vue').ComputedRef<import('../../connections').Connection[]>;
+    availableImports: Ref<DashboardImport[], DashboardImport[]>;
+    selectedImport: Ref<string, string>;
+    createDashboard: () => Promise<void>;
+    cancel: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    visible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    testTag: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    visible: boolean;
+    testTag: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=DashboardCreatorInline.vue.d.ts.map

package/dist/components/dashboard/DashboardCreatorInline.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DashboardCreatorInline.vue.d.ts","sourceRoot":"","sources":["../../../components/dashboard/DashboardCreatorInline.vue"],"names":[],"mappings":"AA2EA;AAsTA,OAAO,EAAyB,KAAK,GAAG,EAAE,MAAM,KAAK,CAAA;AAMrD,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,uBAAuB,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE5D,wBAoJC"}

package/dist/components/dashboard/DashboardDataSelector.vue.d.ts

@@ -0,0 +1,221 @@
+import { ResultColumn, Row } from '../../editors/results';
+import { PropType } from 'vue';
+export interface SelectOption {
+    label: string;
+    value: any;
+}
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    headers: {
+        type: {
+            new (entries?: readonly (readonly [String, ResultColumn])[] | null | undefined): Map<String, ResultColumn>;
+            new (iterable?: Iterable<readonly [String, ResultColumn]> | null | undefined): Map<String, ResultColumn>;
+            readonly prototype: Map<any, any>;
+            readonly [Symbol.species]: MapConstructor;
+        };
+        required: true;
+    };
+    results: {
+        type: PropType<readonly 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">;
+}, {
+    selectedValue: any;
+    selectedLabel: string;
+    searchText: string;
+    showDropdown: boolean;
+    inputElement: HTMLElement | null;
+}, {
+    headersArray(): ResultColumn[];
+    firstColumn(): ResultColumn | null;
+    secondColumn(): ResultColumn | null;
+    displayColumn(): ResultColumn | null;
+    valueColumn(): ResultColumn | null;
+    selectOptions(): SelectOption[];
+    filteredOptions(): SelectOption[];
+    placeholderText(): string;
+    hasSelection(): boolean;
+    fieldLabel(): string;
+    dropdownStyle(): Record<string, string>;
+}, {
+    formatValue(value: any, column: ResultColumn): string;
+    highlightMatch(label: string): string;
+    selectOption(option: SelectOption): void;
+    selectAll(): void;
+    onSearchInput(): void;
+    handleFocus(): void;
+    updateInputElement(): void;
+    handleBlur(): void;
+    handleSelection(): void;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    headers: {
+        type: {
+            new (entries?: readonly (readonly [String, ResultColumn])[] | null | undefined): Map<String, ResultColumn>;
+            new (iterable?: Iterable<readonly [String, ResultColumn]> | null | undefined): Map<String, ResultColumn>;
+            readonly prototype: Map<any, any>;
+            readonly [Symbol.species]: MapConstructor;
+        };
+        required: true;
+    };
+    results: {
+        type: PropType<readonly 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>;
+export default _default;
+//# sourceMappingURL=DashboardDataSelector.vue.d.ts.map

package/dist/components/dashboard/DashboardDataSelector.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DashboardDataSelector.vue.d.ts","sourceRoot":"","sources":["../../../components/dashboard/DashboardDataSelector.vue"],"names":[],"mappings":"AAySA;AAskBA,OAAO,KAAK,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,uBAAuB,CAAA;AAE9D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAA;AAInC,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,GAAG,CAAA;CACX;;;;;;;;;;;;cAkBoB,QAAQ,CAAC,SAAS,GAAG,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAblB,GAAG;mBACH,MAAM;;;kBAGL,WAAW,GAAG,IAAI;;;mBA8C3B,YAAY,GAAG,IAAI;oBAGlB,YAAY,GAAG,IAAI;qBAGlB,YAAY,GAAG,IAAI;mBAGrB,YAAY,GAAG,IAAI;qBAIjB,YAAY,EAAE;uBA6BZ,YAAY,EAAE;uBAQd,MAAM;oBAWT,OAAO;kBAGT,MAAM;qBAGH,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;;uBA6BpB,GAAG,UAAU,YAAY,GAAG,MAAM;0BAiC/B,MAAM,GAAG,MAAM;yBAoBhB,YAAY;;;;;;;;;;;;;;;;;;cA1LhB,QAAQ,CAAC,SAAS,GAAG,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;AAhB7C,wBA6QC"}