@trilogy-data/trilogy-studio-components 0.1.0

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

@@ -0,0 +1,346 @@
+import { PropType } from 'vue';
+import { Results } from '../../editors/results';
+import { DashboardQueryExecutor } from '../../dashboards/dashboardQueryExecutor';
+import { GridItemDataResponse, DimensionClick } 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: string;
+        };
+    };
+    setItemData: {
+        type: PropType<(itemId: string, dashboardId: string, content: any) => null>;
+        required: true;
+        default: () => {
+            type: string;
+            content: 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>;
+    showLoading: import('vue').Ref<boolean, boolean>;
+    error: import('vue').ComputedRef<string | null>;
+    query: import('vue').ComputedRef<string>;
+    chartHeight: import('vue').ComputedRef<number>;
+    chartWidth: import('vue').ComputedRef<number>;
+    chartConfig: import('vue').ComputedRef<import('../../editors/results').ChartConfig | null>;
+    onRefresh: import('vue').ComputedRef<((itemId: string) => void) | null>;
+    handleLocalRefresh: () => void;
+    startTime: import('vue').ComputedRef<number | null>;
+    handleDimensionClick: (dimension: DimensionClick) => void;
+    handleBackgroundClick: () => void;
+    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: string;
+        };
+    };
+    setItemData: {
+        type: PropType<(itemId: string, dashboardId: string, content: any) => null>;
+        required: true;
+        default: () => {
+            type: string;
+            content: 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;
+}, {}, {
+    DashboardDataSelector: 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">;
+    }, {
+        selectedValue: any;
+        selectedLabel: string;
+        searchText: string;
+        showDropdown: boolean;
+        inputElement: HTMLElement | null;
+    }, {
+        headersArray(): import('../../editors/results').ResultColumn[];
+        firstColumn(): import('../../editors/results').ResultColumn | null;
+        secondColumn(): import('../../editors/results').ResultColumn | null;
+        displayColumn(): import('../../editors/results').ResultColumn | null;
+        valueColumn(): import('../../editors/results').ResultColumn | null;
+        selectOptions(): import('./DashboardDataSelector.vue').SelectOption[];
+        filteredOptions(): import('./DashboardDataSelector.vue').SelectOption[];
+        placeholderText(): string;
+        hasSelection(): boolean;
+        fieldLabel(): string;
+        dropdownStyle(): Record<string, string>;
+    }, {
+        formatValue(value: any, column: import('../../editors/results').ResultColumn): string;
+        highlightMatch(label: string): string;
+        selectOption(option: import('./DashboardDataSelector.vue').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, 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>;
+    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>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=DashboardFilter.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DashboardFilter.vue.d.ts","sourceRoot":"","sources":["../../../components/dashboard/DashboardFilter.vue"],"names":[],"mappings":"AA0CA;AAgZA,OAAO,EAQL,KAAK,QAAQ,EACd,MAAM,KAAK,CAAA;AAEZ,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAA;AACpD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAA;AAIrF,OAAO,EAAE,KAAK,oBAAoB,EAAE,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAA;;;;;;;;;;;cAoB9D,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;;;;;;;;;;;;;;;;;sCA2KpC,cAAc;;;;;;;;;;;;;;;cAzLnC,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,wBA6OC"}

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

@@ -0,0 +1,38 @@
+import { CompletionItem } from '../../stores/resolver';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    inputValue: {
+        type: StringConstructor;
+        required: true;
+    };
+    completionItems: {
+        type: () => CompletionItem[];
+        required: true;
+    };
+    inputElement: {
+        type: () => HTMLInputElement | HTMLTextAreaElement | null;
+        default: null;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "select-completion": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    inputValue: {
+        type: StringConstructor;
+        required: true;
+    };
+    completionItems: {
+        type: () => CompletionItem[];
+        required: true;
+    };
+    inputElement: {
+        type: () => HTMLInputElement | HTMLTextAreaElement | null;
+        default: null;
+    };
+}>> & Readonly<{
+    "onSelect-completion"?: ((...args: any[]) => any) | undefined;
+}>, {
+    inputElement: HTMLInputElement | HTMLTextAreaElement | null;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    dropdown: HTMLDivElement;
+}, any>;
+export default _default;
+//# sourceMappingURL=DashboardFilterAutocomplete.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DashboardFilterAutocomplete.vue.d.ts","sourceRoot":"","sources":["../../../components/dashboard/DashboardFilterAutocomplete.vue"],"names":[],"mappings":"AACA;AA2VA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;;;;;;;cA0VxC,MAAM,cAAc,EAAE;;;;cAIrB,MAAM,gBAAgB,GAAG,mBAAmB,GAAG,IAAI;;;;;;;;;;;cAJpD,MAAM,cAAc,EAAE;;;;cAIrB,MAAM,gBAAgB,GAAG,mBAAmB,GAAG,IAAI;;;;;;;;;;AAhBvE,wBAqBG"}

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

@@ -0,0 +1,31 @@
+import { GridItemDataResponse, LayoutItem, DimensionClick } from '../../dashboards/base';
+import { DashboardQueryExecutor } from '../../dashboards/dashboardQueryExecutor';
+import { CompletionItem } from '../../stores/resolver';
+type __VLS_Props = {
+    dashboardId: string;
+    item: LayoutItem;
+    editMode: boolean;
+    symbols: CompletionItem[];
+    getItemData: (itemId: string, dashboardId: string) => GridItemDataResponse;
+    getDashboardQueryExecutor: (dashboardId: string) => DashboardQueryExecutor;
+    setItemData: (itemId: string, dashboardId: string, data: any) => void;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "background-click": (itemId: string) => any;
+    "dimension-click": (args_0: DimensionClick) => any;
+    "edit-content": (item: LayoutItem) => any;
+    "update-dimensions": (itemId: string) => any;
+    "remove-filter": (itemId: string, filterSource: string) => any;
+    "remove-item": (itemId: string) => any;
+    "copy-item": (itemId: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onBackground-click"?: ((itemId: string) => any) | undefined;
+    "onDimension-click"?: ((args_0: DimensionClick) => any) | undefined;
+    "onEdit-content"?: ((item: LayoutItem) => any) | undefined;
+    "onUpdate-dimensions"?: ((itemId: string) => any) | undefined;
+    "onRemove-filter"?: ((itemId: string, filterSource: string) => any) | undefined;
+    "onRemove-item"?: ((itemId: string) => any) | undefined;
+    "onCopy-item"?: ((itemId: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;
+//# sourceMappingURL=DashboardGridItem.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DashboardGridItem.vue.d.ts","sourceRoot":"","sources":["../../../components/dashboard/DashboardGridItem.vue"],"names":[],"mappings":"AAkvBA,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,UAAU,EAEf,KAAK,cAAc,EACpB,MAAM,uBAAuB,CAAA;AAC9B,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAA;AACrF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAG3D,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,UAAU,CAAA;IAChB,QAAQ,EAAE,OAAO,CAAA;IACjB,OAAO,EAAE,cAAc,EAAE,CAAA;IACzB,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,oBAAoB,CAAA;IAC1E,yBAAyB,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,sBAAsB,CAAA;IAC1E,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,KAAK,IAAI,CAAA;CACtE,CAAC;;;;;;;;;;;;;;;;;;AA6iBF,wBAQG"}

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

@@ -0,0 +1,71 @@
+import { CompletionItem } from '../../stores/resolver';
+import { Dashboard } from '../../dashboards/base';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    dashboard: {
+        type: () => Dashboard;
+        required: true;
+    };
+    editsLocked: BooleanConstructor;
+    selectedConnection: {
+        type: StringConstructor;
+        required: true;
+    };
+    filterError: StringConstructor;
+    globalCompletion: {
+        type: () => CompletionItem[];
+        default: () => never[];
+    };
+    validateFilter: {
+        type: FunctionConstructor;
+        default: () => boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    refresh: (...args: any[]) => void;
+    "filter-change": (...args: any[]) => void;
+    "clear-filter": (...args: any[]) => void;
+    "connection-change": (...args: any[]) => void;
+    "import-change": (...args: any[]) => void;
+    "add-item": (...args: any[]) => void;
+    "clear-items": (...args: any[]) => void;
+    "mode-change": (...args: any[]) => void;
+    "title-update": (...args: any[]) => void;
+    "export-image": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    dashboard: {
+        type: () => Dashboard;
+        required: true;
+    };
+    editsLocked: BooleanConstructor;
+    selectedConnection: {
+        type: StringConstructor;
+        required: true;
+    };
+    filterError: StringConstructor;
+    globalCompletion: {
+        type: () => CompletionItem[];
+        default: () => never[];
+    };
+    validateFilter: {
+        type: FunctionConstructor;
+        default: () => boolean;
+    };
+}>> & Readonly<{
+    onRefresh?: ((...args: any[]) => any) | undefined;
+    "onFilter-change"?: ((...args: any[]) => any) | undefined;
+    "onClear-filter"?: ((...args: any[]) => any) | undefined;
+    "onConnection-change"?: ((...args: any[]) => any) | undefined;
+    "onImport-change"?: ((...args: any[]) => any) | undefined;
+    "onAdd-item"?: ((...args: any[]) => any) | undefined;
+    "onClear-items"?: ((...args: any[]) => any) | undefined;
+    "onMode-change"?: ((...args: any[]) => any) | undefined;
+    "onTitle-update"?: ((...args: any[]) => any) | undefined;
+    "onExport-image"?: ((...args: any[]) => any) | undefined;
+}>, {
+    globalCompletion: CompletionItem[];
+    validateFilter: Function;
+    editsLocked: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    titleInput: HTMLInputElement;
+}, HTMLDivElement>;
+export default _default;
+//# sourceMappingURL=DashboardHeader.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DashboardHeader.vue.d.ts","sourceRoot":"","sources":["../../../components/dashboard/DashboardHeader.vue"],"names":[],"mappings":"AA8rBA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAE3D,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,uBAAuB,CAAA;;;cAggBlC,MAAM,SAAS;;;;;;;;;;cAUhB,MAAM,cAAc,EAAE;;;;;;;;;;;;;;;;;;;;cAVrB,MAAM,SAAS;;;;;;;;;;cAUhB,MAAM,cAAc,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;AAlBzC,wBA4BG"}

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

@@ -0,0 +1,50 @@
+import { CompletionItem } from '../../stores/resolver';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    filterValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    filterError: StringConstructor;
+    isLoading: BooleanConstructor;
+    globalCompletion: {
+        type: () => CompletionItem[];
+        default: () => never[];
+    };
+    validateFilter: {
+        type: FunctionConstructor;
+        default: () => boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "filter-change": (...args: any[]) => void;
+    "filter-apply": (...args: any[]) => void;
+    "clear-filter": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    filterValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    filterError: StringConstructor;
+    isLoading: BooleanConstructor;
+    globalCompletion: {
+        type: () => CompletionItem[];
+        default: () => never[];
+    };
+    validateFilter: {
+        type: FunctionConstructor;
+        default: () => boolean;
+    };
+}>> & Readonly<{
+    "onFilter-change"?: ((...args: any[]) => any) | undefined;
+    "onFilter-apply"?: ((...args: any[]) => any) | undefined;
+    "onClear-filter"?: ((...args: any[]) => any) | undefined;
+}>, {
+    isLoading: boolean;
+    filterValue: string;
+    globalCompletion: CompletionItem[];
+    validateFilter: Function;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    filterInputRef: HTMLInputElement;
+    filterTextareaRef: HTMLTextAreaElement;
+}, HTMLDivElement>;
+export default _default;
+//# sourceMappingURL=DashboardHeaderFilterInput.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DashboardHeaderFilterInput.vue.d.ts","sourceRoot":"","sources":["../../../components/dashboard/DashboardHeaderFilterInput.vue"],"names":[],"mappings":"AA+yBA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAA;;;;;;;;;cAmnBxC,MAAM,cAAc,EAAE;;;;;;;;;;;;;;;;;;;cAAtB,MAAM,cAAc,EAAE;;;;;;;;;;;;;;;;;;;;AAdzC,wBAwBG"}

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

@@ -0,0 +1,12 @@
+type __VLS_Props = {
+    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=DashboardImportPopup.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DashboardImportPopup.vue.d.ts","sourceRoot":"","sources":["../../../components/dashboard/DashboardImportPopup.vue"],"names":[],"mappings":"AA6pBA,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,OAAO,CAAA;CAChB,CAAC;;;;;;;;AA+fF,wBAQG"}

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

@@ -0,0 +1,14 @@
+import { DashboardImport } from '../../dashboards/base';
+export interface ImportSelectorProps {
+    availableImports: DashboardImport[];
+    activeImports: DashboardImport[];
+}
+declare const _default: import('vue').DefineComponent<ImportSelectorProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:imports": (imports: DashboardImport[]) => any;
+    explore: (args_0: DashboardImport) => any;
+}, string, import('vue').PublicProps, Readonly<ImportSelectorProps> & Readonly<{
+    "onUpdate:imports"?: ((imports: DashboardImport[]) => any) | undefined;
+    onExplore?: ((args_0: DashboardImport) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;
+//# sourceMappingURL=DashboardImportSelector.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DashboardImportSelector.vue.d.ts","sourceRoot":"","sources":["../../../components/dashboard/DashboardImportSelector.vue"],"names":[],"mappings":"AACA;AAifA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAE5D,MAAM,WAAW,mBAAmB;IAClC,gBAAgB,EAAE,eAAe,EAAE,CAAA;IACnC,aAAa,EAAE,eAAe,EAAE,CAAA;CACjC;;;;;;;;AAiWD,wBAQG"}