@eodash/eodash 5.0.0-rc.1 → 5.0.0-rc.1.5

package/dist/types/core/client/eodashSTAC/createLayers.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @param {string} collectionId
+ * @param {string} title
+ * @param {Record<string,import("stac-ts").StacAsset>} assets
+ * @param {import("stac-ts").StacItem } item
+ * @param {import("ol/layer/WebGLTile").Style} [style]
+ * @param {Record<string, unknown>} [layerConfig]
+ * @param {Record<string, unknown>} [layerDatetime]
+ * @param {object | null} [extraProperties]
+ **/
+export function createLayersFromAssets(collectionId: string, title: string, assets: Record<string, import("stac-ts").StacAsset>, item: import("stac-ts").StacItem, style?: import("ol/layer/WebGLTile").Style, layerConfig?: Record<string, unknown>, layerDatetime?: Record<string, unknown>, extraProperties?: object | null): Promise<({
+    style?: import("ol/layer/WebGLTile").Style | undefined;
+    type: string;
+    source: {
+        type: string;
+        url: string;
+        format: string;
+    };
+    properties: {
+        layerConfig?: {
+            style: import("ol/layer/WebGLTile").Style | undefined;
+        } | undefined;
+        id: string;
+        title: string;
+        layerDatetime: Record<string, unknown> | undefined;
+    };
+} | {
+    type: string;
+    source: {
+        type: string;
+        normalize: boolean;
+        interpolate: boolean;
+        sources: {
+            url: string;
+        }[];
+    };
+    properties: {
+        id: string;
+        title: string;
+        layerConfig: Record<string, unknown> | undefined;
+        layerDatetime: Record<string, unknown> | undefined;
+    };
+    style: import("ol/layer/WebGLTile").Style | undefined;
+})[]>;
+export function createLayersFromLinks(collectionId: string, title: string, item: import("stac-ts").StacItem, layerDatetime?: Record<string, any>, extraProperties?: object | null): Promise<Record<string, any>[]>;

package/dist/types/core/client/eodashSTAC/helpers.d.ts

@@ -0,0 +1,80 @@
+/** @param {import("stac-ts").StacLink[]} [links] */
+export function generateFeatures(links?: import("stac-ts").StacLink[]): {
+    type: string;
+    crs: {
+        type: string;
+        properties: {
+            name: string;
+        };
+    };
+    features: import("geojson").Feature<import("geojson").Geometry, import("geojson").GeoJsonProperties>[];
+};
+/**
+ * Sperates and extracts layerConfig (jsonform schema & legend) from a style json
+ *
+ *  @param { import("ol/layer/WebGLTile").Style & { jsonform?: Record<string,any> } & { legend?: Record<string,any> } } [style] */
+export function extractLayerConfig(style?: import("ol/layer/WebGLTile").Style & {
+    jsonform?: Record<string, any>;
+} & {
+    legend?: Record<string, any>;
+}): {
+    layerConfig: Record<string, unknown> | undefined;
+    style: (import("ol/layer/WebGLTile").Style & {
+        jsonform?: Record<string, any>;
+    } & {
+        legend?: Record<string, any>;
+    }) | undefined;
+};
+/**
+ * Function to extract collection urls from an indicator
+ * @param {import("stac-ts").StacCatalog
+ *   | import("stac-ts").StacCollection
+ *   | import("stac-ts").StacItem
+ *   | null
+ * } stacObject
+ * @param {string} basepath
+ */
+export function extractCollectionUrls(stacObject: import("stac-ts").StacCatalog | import("stac-ts").StacCollection | import("stac-ts").StacItem | null, basepath: string): string[];
+/**
+ * Assigns projection code to the layer ID
+ * @param {import("stac-ts").StacItem} item
+ * @param {import("stac-ts").StacLink | import("stac-ts").StacAsset} linkOrAsset
+ * @param {string} id - {@link createLayerID} & {@link extractRoles}
+ * @param {{ properties:{id:string}  & Record<string, any> }& Record<string,any>} layer
+ * @returns
+ */
+export function assignProjID(item: import("stac-ts").StacItem, linkOrAsset: import("stac-ts").StacLink | import("stac-ts").StacAsset, id: string, layer: {
+    properties: {
+        id: string;
+    } & Record<string, any>;
+} & Record<string, any>): string;
+export function extractRoles(properties: Record<string, any>, linkOrAsset: import("stac-ts").StacLink | import("stac-ts").StacAsset): void;
+export function fetchStyle(item: import("stac-ts").StacItem, itemUrl: string): Promise<{
+    variables?: {
+        [x: string]: string | number;
+    } | undefined;
+    color?: import("ol/expr/expression.js").ExpressionValue | undefined;
+    brightness?: import("ol/expr/expression.js").ExpressionValue | undefined;
+    contrast?: import("ol/expr/expression.js").ExpressionValue | undefined;
+    exposure?: import("ol/expr/expression.js").ExpressionValue | undefined;
+    saturation?: import("ol/expr/expression.js").ExpressionValue | undefined;
+    gamma?: import("ol/expr/expression.js").ExpressionValue | undefined;
+    jsonform?: Record<string, any>;
+} | undefined>;
+export function getProjectionCode(projection?: string | number | {
+    name: string;
+    def: string;
+}): string;
+export function extractLayerDatetime(links?: import("stac-ts").StacLink[], currentStep?: string | null): {
+    controlValues: string[];
+    currentStep: string;
+    slider: boolean;
+    play: boolean;
+    displayFormat: string;
+} | undefined;
+export function findLayer(layers: Record<string, any>[], layer: string): Record<string, any> | undefined;
+export function replaceLayer(currentLayers: Record<string, any>[], oldLayer: string, newLayers: Record<string, any>[]): Record<string, any>[] | undefined;
+export function getColFromLayer(indicators: import("../eodashSTAC/EodashCollection.js").EodashCollection[], layer: import("ol/layer").Layer): Promise<import("../eodashSTAC/EodashCollection.js").EodashCollection | undefined>;
+export function createLayerID(collectionId: string, itemId: string, link: import("stac-ts").StacLink, projectionCode: string): string;
+export function createAssetID(collectionId: string, itemId: string, index: number): string;
+export function removeUnneededProperties(layers: Record<string, any>[]): Record<string, any>[];

package/dist/types/core/client/eodashSTAC/triggers.d.ts

@@ -0,0 +1 @@
+export function setMapProjFromCol(STAcCollection?: import("stac-ts").StacCollection): Promise<void>;

package/dist/types/core/client/main.d.ts

@@ -0,0 +1,2 @@
+export { createEodash } from "./composables/DefineEodash";
+export { default as store } from "./store";

package/dist/types/core/client/plugins/axios.d.ts

@@ -0,0 +1,2 @@
+export const axios: import("axios-cache-interceptor").AxiosCacheInstance;
+export default axios;

package/dist/types/core/client/plugins/index.d.ts

@@ -0,0 +1,3 @@
+/** @param {import("vue").App} app */
+export function registerPlugins(app: import("vue").App): void;
+export const pinia: import("pinia").Pinia;

package/dist/types/core/client/plugins/vuetify.d.ts

@@ -0,0 +1,82 @@
+export default vuetify;
+declare const vuetify: {
+    install: (app: import("vue").App) => void;
+    defaults: import("vue").Ref<import("vuetify").DefaultsInstance>;
+    display: import("vuetify").DisplayInstance;
+    theme: import("vuetify").ThemeInstance & {
+        install: (app: import("vue").App) => void;
+    };
+    icons: {
+        defaultSet: string;
+        aliases: Partial<import("vuetify").IconAliases>;
+        sets: Record<string, import("vuetify").IconSet>;
+    };
+    locale: {
+        isRtl: import("vue").Ref<boolean>;
+        rtl: import("vue").Ref<Record<string, boolean>>;
+        rtlClasses: import("vue").Ref<string>;
+        name: string;
+        messages: import("vue").Ref<import("vuetify").LocaleMessages>;
+        current: import("vue").Ref<string>;
+        fallback: import("vue").Ref<string>;
+        t: (key: string, ...params: unknown[]) => string;
+        n: (value: number) => string;
+        provide: (props: import("vuetify").LocaleOptions) => import("vuetify").LocaleInstance;
+    };
+    date: {
+        options: {
+            adapter: (new (options: {
+                locale: any;
+                formats?: any;
+            }) => import("vuetify").DateInstance) | import("vuetify").DateInstance;
+            formats?: Record<string, any>;
+            locale: Record<string, any>;
+        };
+        instance: {
+            locale?: any;
+            date: (value?: any) => unknown;
+            format: (date: unknown, formatString: string) => string;
+            toJsDate: (value: unknown) => Date;
+            parseISO: (date: string) => unknown;
+            toISO: (date: unknown) => string;
+            startOfDay: (date: unknown) => unknown;
+            endOfDay: (date: unknown) => unknown;
+            startOfWeek: (date: unknown, firstDayOfWeek?: number | string) => unknown;
+            endOfWeek: (date: unknown) => unknown;
+            startOfMonth: (date: unknown) => unknown;
+            endOfMonth: (date: unknown) => unknown;
+            startOfYear: (date: unknown) => unknown;
+            endOfYear: (date: unknown) => unknown;
+            isAfter: (date: unknown, comparing: unknown) => boolean;
+            isAfterDay: (value: unknown, comparing: unknown) => boolean;
+            isSameDay: (date: unknown, comparing: unknown) => boolean;
+            isSameMonth: (date: unknown, comparing: unknown) => boolean;
+            isSameYear: (value: unknown, comparing: unknown) => boolean;
+            isBefore: (date: unknown, comparing: unknown) => boolean;
+            isEqual: (date: unknown, comparing: unknown) => boolean;
+            isValid: (date: any) => boolean;
+            isWithinRange: (date: unknown, range: [unknown, unknown]) => boolean;
+            addMinutes: (date: unknown, amount: number) => unknown;
+            addHours: (date: unknown, amount: number) => unknown;
+            addDays: (date: unknown, amount: number) => unknown;
+            addWeeks: (date: unknown, amount: number) => unknown;
+            addMonths: (date: unknown, amount: number) => unknown;
+            getYear: (date: unknown) => number;
+            setYear: (date: unknown, year: number) => unknown;
+            getDiff: (date: unknown, comparing: unknown, unit?: string) => number;
+            getWeekArray: (date: unknown, firstDayOfWeek?: number | string) => unknown[][];
+            getWeekdays: (firstDayOfWeek?: number | string) => string[];
+            getMonth: (date: unknown) => number;
+            setMonth: (date: unknown, month: number) => unknown;
+            getDate: (date: unknown) => number;
+            setDate: (date: unknown, day: number) => unknown;
+            getNextMonth: (date: unknown) => unknown;
+            getPreviousMonth: (date: unknown) => unknown;
+            getHours: (date: unknown) => number;
+            setHours: (date: unknown, hours: number) => unknown;
+            getMinutes: (date: unknown) => number;
+            setMinutes: (date: unknown, minutes: number) => unknown;
+        };
+    };
+    goTo: import("vuetify").GoToInstance;
+};

package/dist/types/core/client/render.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/core/client/store/actions.d.ts

@@ -0,0 +1,12 @@
+export function getLayers(): Record<string, any>[];
+export function getCompareLayers(): Record<string, any>[];
+export function registerProjection(projection?: string | number | {
+    name: string;
+    def: string;
+    extent?: number[];
+}): Promise<void>;
+export function changeMapProjection(projection?: string | number | {
+    name: string;
+    def: string;
+}): Promise<void>;
+export function setActiveTemplate(template: string): void;

package/dist/types/core/client/store/index.d.ts

@@ -0,0 +1,11 @@
+declare namespace _default {
+    export namespace stac {
+        export { useSTAcStore };
+    }
+    export { actions };
+    export { states };
+}
+export default _default;
+import { useSTAcStore } from "./stac";
+import * as actions from "./actions";
+import * as states from "./states";

package/dist/types/core/client/store/stac.d.ts

@@ -0,0 +1,25 @@
+export const useSTAcStore: import("pinia").StoreDefinition<"stac", Pick<{
+    stac: import("vue").Ref<import("stac-ts").StacLink[] | null, import("stac-ts").StacLink[] | null>;
+    loadSTAC: (url?: import("../types").StacEndpoint) => Promise<void>;
+    loadSelectedSTAC: (relativePath?: string) => Promise<void>;
+    loadSelectedCompareSTAC: (relativePath?: string) => Promise<void>;
+    resetSelectedCompareSTAC: () => Promise<void>;
+    selectedStac: import("vue").Ref<import("stac-ts").StacCatalog | import("stac-ts").StacCollection | import("stac-ts").StacItem | null, import("stac-ts").StacCatalog | import("stac-ts").StacCollection | import("stac-ts").StacItem | null>;
+    selectedCompareStac: import("vue").Ref<import("stac-ts").StacCatalog | import("stac-ts").StacCollection | import("stac-ts").StacItem | null, import("stac-ts").StacCatalog | import("stac-ts").StacCollection | import("stac-ts").StacItem | null>;
+}, "stac" | "selectedStac" | "selectedCompareStac">, Pick<{
+    stac: import("vue").Ref<import("stac-ts").StacLink[] | null, import("stac-ts").StacLink[] | null>;
+    loadSTAC: (url?: import("../types").StacEndpoint) => Promise<void>;
+    loadSelectedSTAC: (relativePath?: string) => Promise<void>;
+    loadSelectedCompareSTAC: (relativePath?: string) => Promise<void>;
+    resetSelectedCompareSTAC: () => Promise<void>;
+    selectedStac: import("vue").Ref<import("stac-ts").StacCatalog | import("stac-ts").StacCollection | import("stac-ts").StacItem | null, import("stac-ts").StacCatalog | import("stac-ts").StacCollection | import("stac-ts").StacItem | null>;
+    selectedCompareStac: import("vue").Ref<import("stac-ts").StacCatalog | import("stac-ts").StacCollection | import("stac-ts").StacItem | null, import("stac-ts").StacCatalog | import("stac-ts").StacCollection | import("stac-ts").StacItem | null>;
+}, never>, Pick<{
+    stac: import("vue").Ref<import("stac-ts").StacLink[] | null, import("stac-ts").StacLink[] | null>;
+    loadSTAC: (url?: import("../types").StacEndpoint) => Promise<void>;
+    loadSelectedSTAC: (relativePath?: string) => Promise<void>;
+    loadSelectedCompareSTAC: (relativePath?: string) => Promise<void>;
+    resetSelectedCompareSTAC: () => Promise<void>;
+    selectedStac: import("vue").Ref<import("stac-ts").StacCatalog | import("stac-ts").StacCollection | import("stac-ts").StacItem | null, import("stac-ts").StacCatalog | import("stac-ts").StacCollection | import("stac-ts").StacItem | null>;
+    selectedCompareStac: import("vue").Ref<import("stac-ts").StacCatalog | import("stac-ts").StacCollection | import("stac-ts").StacItem | null, import("stac-ts").StacCatalog | import("stac-ts").StacCollection | import("stac-ts").StacItem | null>;
+}, "loadSTAC" | "loadSelectedSTAC" | "loadSelectedCompareSTAC" | "resetSelectedCompareSTAC">>;

package/dist/types/core/client/store/states.d.ts

@@ -0,0 +1,22 @@
+/** Currently selected STAC endpoint */
+export const currentUrl: import("vue").Ref<string, string>;
+/** Currently selected compare STAC endpoint */
+export const currentCompareUrl: import("vue").Ref<string, string>;
+/** Currently selected datetime */
+export const datetime: import("vue").Ref<string, string>;
+/** Currently selected indicator */
+export const indicator: import("vue").Ref<string, string>;
+/**
+ * Current map position
+ *
+ * @type {import("vue").Ref<(number | undefined)[]>}
+ */
+export const mapPosition: import("vue").Ref<(number | undefined)[]>;
+export const registeredProjections: string[];
+/** available projection to be rendered by `EodashMap` */
+export const availableMapProjection: import("vue").Ref<string, string>;
+/** @type {import("vue").Ref<HTMLElement & Record<string,any> | null>} */
+export const mapEl: import("vue").Ref<(HTMLElement & Record<string, any>) | null>;
+/** @type {import("vue").Ref<HTMLElement & Record<string,any> | null>} */
+export const mapCompareEl: import("vue").Ref<(HTMLElement & Record<string, any>) | null>;
+export const activeTemplate: import("vue").Ref<string, string>;

package/dist/types/core/client/types.d.ts

@@ -0,0 +1,269 @@
+/** @group Eodash */
+export interface WebComponentProps<T extends ExecutionTime = "compiletime"> {
+    /**
+     * Imports web component file, either using a URL or an import function.
+     *
+     * @example
+     *   importing `eox-itemfilter` web component, after installing `@eox/itemfilter` it can be
+     *   referenced:
+     *   ```js
+     *   link: async() => import("@eox/itemfilter")
+     *   ```
+     *
+     *   ::: warning
+     *   import maps are not available in runtime config
+     *   :::
+     */
+    link: T extends "runtime" ? string : string | (() => Promise<unknown>);
+    /**
+     * Exported Constructor, needs to be provided if the web component is not
+     * registered in by the [link](#link) provided
+     */
+    constructorProp?: string;
+    tagName: `${string}-${string}`;
+    /** Object defining all the properties and attributes of the web component */
+    properties?: Record<string, unknown>;
+    /**
+     * Triggered when the web component is mounted in the DOM.
+     *
+     * @param el - Web component
+     * @param store - Return value of the core STAC pinia store in
+     *   `/core/client/store/stac.ts`
+     */
+    onMounted?: (el: Element | null, store: ReturnType<typeof import("./store/stac.js").useSTAcStore>) => Promise<void> | void;
+    /**
+     * Triggered when the web component is unmounted from the DOM.
+     *
+     * @param el - Web component
+     * @param store - Return value of the core STAC pinia store in
+     *   `/core/client/store/stac.ts`
+     */
+    onUnmounted?: (el: Element | null, store: ReturnType<typeof import("./store/stac.js").useSTAcStore>) => Promise<void> | void;
+}
+/** @ignore */
+export interface WidgetsContainerProps {
+    widgets: Omit<Widget, "layout">[];
+}
+/** Properties of EOxLayoutItem used for setting the position and size of panels */
+export interface Layout {
+    /** Horizontal start position. Integer between 1 and 12 */
+    x: number;
+    /** Vertical start position. Integer between 1 and 12 */
+    y: number;
+    /** Width. Integer between 1 and 12 */
+    w: number;
+    /** Height. Integer between 1 and 12 */
+    h: number;
+}
+/**
+ * Widget type: `web-component` API
+ *
+ * @group Eodash
+ */
+export interface WebComponentWidget<T extends ExecutionTime = "compiletime"> {
+    id: number | string | symbol;
+    title: string;
+    /** Widget position and size. */
+    layout: Layout;
+    widget: WebComponentProps<T>;
+    type: "web-component";
+}
+/**
+ * Widget type: `internal` API. Internal widgets are Vue components provided by
+ * eodash.
+ *
+ * @group Eodash
+ */
+export interface InternalComponentWidget {
+    id: number | string | symbol;
+    title: string;
+    /** Widget position and size. */
+    layout: Layout;
+    widget: {
+        /**
+         * Internal Vue Components inside the
+         * [widgets](https://github.com/eodash/eodash/tree/main/widgets) folder.
+         * Referenced using their name without the .vue extention
+         */
+        name: string;
+        /** Specified Vue component props */
+        properties?: Record<string, unknown>;
+    };
+    type: "internal";
+}
+/** Widget type: `iframe` API Renders an external HTML file as a widget. */
+/** @group Eodash */
+export interface IFrameWidget {
+    id: number | string | symbol;
+    title: string;
+    /** Widget position and size. */
+    layout: Layout;
+    widget: {
+        /** The URL of the page to embed */
+        src: string;
+    };
+    type: "iframe";
+}
+/** @group Eodash */
+export interface FunctionalWidget<T extends ExecutionTime = "compiletime"> {
+    /**
+     * Provides a functional definition of widgets, gets triggered whenever a STAC
+     * object is selected, and only renders the returned configuration if the `id`
+     * doesn't match the currently rendered `id`
+     *
+     * @param selectedSTAC - Currently selected STAC object
+     */
+    defineWidget: (selectedSTAC: import("stac-ts").StacCatalog | import("stac-ts").StacCollection | import("stac-ts").StacItem | null) => StaticWidget<T> | undefined | null;
+}
+/**
+ * There are 3 types of Widgets:
+ *
+ * @group Eodash
+ */
+export type StaticWidget<T extends ExecutionTime = "compiletime"> = WebComponentWidget<T> | InternalComponentWidget | IFrameWidget;
+/**
+ * Widgets can be defined in 2 forms:
+ *
+ * 1. {@link StaticWidget} : This is defined as an object once, and is considered
+ *    the default form.
+ * 2. {@link FunctionalWidget} : a special form which contains the
+ *    {@link FunctionalWidget.defineWidget `defineWidget`} function that runs
+ *    when {@link EodashStore.stac `loadSelectedSTAC`} function is triggered, and
+ *    returns a value of a Static Widget or null or undefined.
+ *
+ * @group Eodash
+ */
+export type Widget<T extends ExecutionTime = "compiletime"> = StaticWidget<T> | FunctionalWidget<T>;
+/** @group Eodash */
+export type BackgroundWidget<T extends ExecutionTime = "compiletime"> = Omit<WebComponentWidget<T>, "layout" | "title" | "slidable"> | Omit<InternalComponentWidget, "layout" | "title" | "slidable"> | Omit<IFrameWidget, "layout" | "title" | "slidable"> | Omit<FunctionalWidget<T>, "layout" | "slidable">;
+/**
+ * Dashboard rendered widgets specification. 3 types of widgets are supported:
+ * `"iframe"`, `"internal"`, and `"web-component"`. A specific object should be
+ * provided based on the type of the widget.
+ *
+ * @group Eodash
+ */
+export interface SingleTemplate<T extends ExecutionTime = "compiletime"> {
+    /** Gap between widgets */
+    gap?: number;
+    /** Loading widget */
+    loading?: BackgroundWidget<T>;
+    /**
+     * Widget rendered as the dashboard background. Has the same specifications of
+     * {@link Widget} without the `title` and `layout` properties
+     */
+    background?: BackgroundWidget<T>;
+    /** Array of widgets that will be rendered as dashboard panels. */
+    widgets: Widget<T>[];
+}
+export type MultiTemplates<T extends ExecutionTime = "compiletime"> = Record<string, SingleTemplate<T>>;
+/** @ignore */
+export type StacEndpoint = `${string}/catalog.json`;
+/** @group Eodash */
+type ExecutionTime = "runtime" | "compiletime";
+/**
+ * Eodash instance API
+ *
+ * @group Eodash
+ */
+export type Eodash<T extends ExecutionTime = "compiletime"> = {
+    /** Instance ID. */
+    id?: string;
+    /** Root STAC catalog endpoint */
+    stacEndpoint: StacEndpoint;
+    /** Brand specifications. */
+    brand: {
+        /** Removes the dashboard layout */
+        noLayout?: boolean;
+        /** Custom error message to alert the users if something crashes */
+        errorMessage?: string;
+        /** Fetches the specified font family from the specified `link` property. */
+        font?: {
+            /**
+             * Link to stylesheet that defines font-face. Could be either a relative
+             * or absolute URL.
+             */
+            link: string;
+            /** Font family name. */
+            family: string;
+        };
+        /** Title that will be shown in the app header */
+        name: string;
+        /** Brand logo */
+        logo?: string;
+        /**
+         * Dashboard theme as a custom [vuetifyJs
+         * theme](https://vuetifyjs.com/en/features/theme/).
+         */
+        theme?: import("vuetify/lib/index.mjs").ThemeDefinition;
+        /** Text applied to the footer. */
+        footerText?: string;
+    };
+} & ({
+    /** Template configuration */
+    template: SingleTemplate<T>;
+} | {
+    /** Multiple templates configuration */
+    templates: MultiTemplates<T>;
+});
+/** @group EodashStore */
+export interface EodashStore {
+    /** Stateful Reactive variables */
+    states: {
+        /** Currently selected STAC endpoint */
+        currentUrl: import("vue").Ref<string>;
+        /** Currently selected datetime */
+        datetime: import("vue").Ref<string>;
+        /** Currently selected indicator */
+        indicator: import("vue").Ref<string>;
+        registeredProjections: `EPSG${number}`[];
+        /** available projection to be rendered by the Map */
+        availableMapProjection: import("vue").Ref<string>;
+    };
+    actions: {
+        /**
+         * returns the layers of the `eox-map`
+         * @param [el] - `eox-map` element selector
+         */
+        getLayers: (el?: string) => object[];
+        /**
+         * Register EPSG projection in `eox-map` and adds it to  `availableMapProjection`
+         * */
+        registerProjection: (code?: number | string | {
+            name: string;
+            def: string;
+        }) => Promise<void>;
+        /** Change `eox-map` projection from an EPSG code or a registered projection code */
+        changeMapProjection: (code?: number | string | {
+            name: string;
+            def: string;
+        }) => Promise<void>;
+    };
+    /** Pinia store definition used to navigate the root STAC catalog. */
+    stac: {
+        useSTAcStore: typeof import("./store/stac.js").useSTAcStore;
+    };
+}
+/** @group WebComponent */
+type EodashConstructor = import("vue").VueElementConstructor<import("vue").ExtractPropTypes<{
+    config: string;
+}>>;
+/**
+ * Eodash Web Component constructor
+ *
+ * @group WebComponent
+ */
+export declare const Eodash: EodashConstructor;
+/**
+ * Registers `eo-dash` as Custom Element in the window
+ *
+ * @group WebComponent
+ */
+export declare function register(): void;
+/**
+ * Eodash store @see EodashStore
+ *
+ * @group WebComponent
+ */
+export declare const store: typeof import("./store").default;
+export * from "./main.js";

package/dist/types/core/client/utils/index.d.ts

@@ -0,0 +1,2 @@
+export function loadFont(family?: string, link?: string, isWebComponent?: boolean): Promise<string>;
+export function copyToClipBoard(text: string, showIcon: import("vue").Ref<boolean>): Promise<void>;

package/dist/types/core/client/utils/keys.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `eodash` injection key.
+ *
+ * @see {@link "@/plugins/index.js"}
+ */
+export const eodashKey: unique symbol;
+/** @type {import("@vueuse/core").EventBusKey<"layers:updated"|"time:updated">} */
+export const eoxLayersKey: import("@vueuse/core").EventBusKey<"layers:updated" | "time:updated">;

package/dist/types/core/client/utils/states.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Array of eodash STAC Collections extracted from the current selected indicator.
+ * Updated in {@link file://./../store/stac.js `loadSelectedSTAC`} widget
+ *
+ * @type {import('../eodashSTAC/EodashCollection').EodashCollection[]}
+ * @private
+ */
+export const eodashCollections: import("../eodashSTAC/EodashCollection").EodashCollection[];
+/**
+ * Array of eodash STAC Collections extracted from the current selected COMPARE indicator.
+ * Updated in {@link file://./../store/stac.js ` loadSelectedCompareSTAC`} widget
+ *
+ * @type {import('../eodashSTAC/EodashCollection').EodashCollection[]}
+ * @private
+ */
+export const eodashCompareCollections: import("../eodashSTAC/EodashCollection").EodashCollection[];
+/** whether the map postion was set in URL params on first load */
+export const posIsSetFromUrl: import("vue").Ref<boolean, boolean>;

package/dist/types/core/client/views/Dashboard.vue.d.ts

@@ -0,0 +1,9 @@
+declare const _default: import("vue").DefineComponent<{}, {
+    isWebComponent: boolean;
+    config?: string | undefined;
+    $props: {
+        readonly isWebComponent?: boolean | undefined;
+        readonly config?: string | undefined;
+    };
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/types/widgets/EodashDatePicker.vue.d.ts

@@ -0,0 +1,13 @@
+declare const _default: import("vue").DefineComponent<{}, {
+    hideArrows: boolean;
+    hideInputField: boolean;
+    hintText: string;
+    $props: {
+        readonly hideArrows?: boolean | undefined;
+        readonly hideInputField?: boolean | undefined;
+        readonly hintText?: string | undefined;
+    };
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {
+    rootRef: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;