@trilogy-data/trilogy-studio-components 0.1.0

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

@@ -0,0 +1,175 @@
+import { PropType } from 'vue';
+import { Results } from '../../editors/results';
+import { DashboardQueryExecutor } from '../../dashboards/dashboardQueryExecutor';
+import { GridItemDataResponse } from '../../dashboards/base';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    dashboardId: {
+        type: StringConstructor;
+        required: true;
+    };
+    itemId: {
+        type: StringConstructor;
+        required: true;
+    };
+    getItemData: {
+        type: PropType<(itemId: string, dashboardId: string) => GridItemDataResponse>;
+        required: true;
+        default: () => {
+            type: string;
+            content: {
+                markdown: string;
+                query: string;
+            };
+        };
+    };
+    setItemData: {
+        type: PropType<(itemId: string, dashboardId: string, content: any) => null>;
+        required: true;
+        default: () => {
+            type: string;
+            content: {
+                markdown: string;
+                query: string;
+            };
+        };
+    };
+    editMode: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    getDashboardQueryExecutor: {
+        type: PropType<(dashboardId: string) => DashboardQueryExecutor>;
+        required: true;
+    };
+}>, {
+    chartContainer: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    results: import('vue').ComputedRef<Results | null>;
+    ready: import('vue').Ref<boolean, boolean>;
+    loading: import('vue').ComputedRef<boolean>;
+    error: import('vue').ComputedRef<string | null>;
+    query: import('vue').ComputedRef<string>;
+    markdown: import('vue').ComputedRef<string>;
+    onRefresh: import('vue').ComputedRef<((itemId: string) => void) | null>;
+    handleLocalRefresh: () => void;
+    startTime: import('vue').ComputedRef<number | null>;
+    controlsVisible: import('vue').Ref<boolean, boolean>;
+    onChartMouseEnter: () => void;
+    onChartMouseLeave: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    dashboardId: {
+        type: StringConstructor;
+        required: true;
+    };
+    itemId: {
+        type: StringConstructor;
+        required: true;
+    };
+    getItemData: {
+        type: PropType<(itemId: string, dashboardId: string) => GridItemDataResponse>;
+        required: true;
+        default: () => {
+            type: string;
+            content: {
+                markdown: string;
+                query: string;
+            };
+        };
+    };
+    setItemData: {
+        type: PropType<(itemId: string, dashboardId: string, content: any) => null>;
+        required: true;
+        default: () => {
+            type: string;
+            content: {
+                markdown: string;
+                query: string;
+            };
+        };
+    };
+    editMode: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    getDashboardQueryExecutor: {
+        type: PropType<(dashboardId: string) => DashboardQueryExecutor>;
+        required: true;
+    };
+}>> & Readonly<{}>, {
+    getItemData: (itemId: string, dashboardId: string) => GridItemDataResponse;
+    setItemData: (itemId: string, dashboardId: string, content: any) => null;
+}, {}, {
+    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>;
+    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>;
+    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;
+        loading: boolean;
+        markdown: string;
+    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=DashboardMarkdown.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DashboardMarkdown.vue.d.ts","sourceRoot":"","sources":["../../../components/dashboard/DashboardMarkdown.vue"],"names":[],"mappings":"AAiCA;AAyUA,OAAO,EAAqD,KAAK,QAAQ,EAAE,MAAM,KAAK,CAAA;AAEtF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAA;AACpD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAA;AAIrF,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,uBAAuB,CAAA;;;;;;;;;;;cAoBzC,QAAQ,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,oBAAoB,CAAC;;;;;;;;;;;cAKvE,QAAQ,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,KAAK,IAAI,CAAC;;;;;;;;;;;;;;;cASrE,QAAQ,CAAC,CAAC,WAAW,EAAE,MAAM,KAAK,sBAAsB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;cAdzD,QAAQ,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,oBAAoB,CAAC;;;;;;;;;;;cAKvE,QAAQ,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,KAAK,IAAI,CAAC;;;;;;;;;;;;;;;cASrE,QAAQ,CAAC,CAAC,WAAW,EAAE,MAAM,KAAK,sBAAsB,CAAC;;;;0BAdvC,MAAM,eAAe,MAAM,KAAK,oBAAoB;0BAKpD,MAAM,eAAe,MAAM,WAAW,GAAG,KAAK,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAtB5F,wBAyLC"}

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

@@ -0,0 +1,325 @@
+import { Import, ContentInput } from '../../stores/resolver';
+import { MarkdownData } from '../../dashboards/base';
+export interface DashboardMarkdownEditorProps {
+    content: MarkdownData;
+    connectionName: string;
+    imports: Import[];
+    rootContent: ContentInput[];
+    initialWidth?: number;
+    initialHeight?: number;
+}
+declare const _default: import('vue').DefineComponent<DashboardMarkdownEditorProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    cancel: (...args: any[]) => void;
+    save: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<DashboardMarkdownEditorProps> & 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=DashboardMarkdownEditor.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DashboardMarkdownEditor.vue.d.ts","sourceRoot":"","sources":["../../../components/dashboard/DashboardMarkdownEditor.vue"],"names":[],"mappings":"AAgbA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,uBAAuB,CAAA;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAMzD,MAAM,WAAW,4BAA4B;IAC3C,OAAO,EAAE,YAAY,CAAA;IACrB,cAAc,EAAE,MAAM,CAAA;IACtB,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,WAAW,EAAE,YAAY,EAAE,CAAA;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAnBD,CAtXkC;6BAsXlC,CArX0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAqX1B,CAtXkC;6BAsXlC,CArX0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAutB1B,wBASG"}

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

@@ -0,0 +1,8 @@
+type __VLS_Props = {
+    name: string;
+    connectionId?: string;
+    viewMode?: boolean;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;
+//# sourceMappingURL=DashboardMobile.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DashboardMobile.vue.d.ts","sourceRoot":"","sources":["../../../components/dashboard/DashboardMobile.vue"],"names":[],"mappings":"AAmfA,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAC;;AA4oBF,wBAMG"}

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

@@ -0,0 +1,14 @@
+import { Dashboard } from '../../dashboards/base';
+type __VLS_Props = {
+    dashboard: Dashboard | null;
+    isOpen: boolean;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    popupContent: HTMLDivElement;
+}, any>;
+export default _default;
+//# sourceMappingURL=DashboardSharePopup.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DashboardSharePopup.vue.d.ts","sourceRoot":"","sources":["../../../components/dashboard/DashboardSharePopup.vue"],"names":[],"mappings":"AAqQA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,uBAAuB,CAAA;AACtD,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,SAAS,GAAG,IAAI,CAAA;IAC3B,MAAM,EAAE,OAAO,CAAA;CAChB,CAAC;;;;;;;;AAmNF,wBAQG"}