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

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

@@ -0,0 +1,156 @@
+/**
+ * Polls the process status and fetches a result item when the process is successful.
+ *
+ * @param {Object} params - Parameters for polling the process status.
+ * @param {string} params.processUrl - The URL of the process JSON report.
+ * @param {import("vue").Ref<boolean>} params.isPolling - checks wether the polling should continue
+ * @param {number} [params.pollInterval=5000] - The interval (in milliseconds) between polling attempts.
+ * @param {number} [params.maxRetries=60] - The maximum number of polling attempts.
+ * @returns {Promise<JSON>} The fetched results JSON.
+ * @throws {Error} If the process does not complete successfully within the maximum retries.
+ */
+export function pollProcessStatus({ processUrl, isPolling, pollInterval, maxRetries, }: {
+    processUrl: string;
+    isPolling: import("vue").Ref<boolean>;
+    pollInterval?: number | undefined;
+    maxRetries?: number | undefined;
+}): Promise<JSON>;
+/**
+ * Auto execute the process when the jsonform has the execute option
+ *
+ * @param {import("vue").Ref<boolean>} autoExec
+ * @param {import("vue").Ref<import("@eox/jsonform").EOxJSONForm | null>} jsonformEl
+ * @param {import("vue").Ref<Record<string,any> | null>} jsonformSchema
+ * @param {() => Promise<void>} startProcess
+ **/
+export function useAutoExec(autoExec: import("vue").Ref<boolean>, jsonformEl: import("vue").Ref<import("@eox/jsonform").EOxJSONForm | null>, jsonformSchema: import("vue").Ref<Record<string, any> | null>, startProcess: () => Promise<void>): void;
+/**
+ * @param {Record<string,any> |null} [jsonformSchema]
+ **/
+export function getBboxProperty(jsonformSchema?: Record<string, any> | null): string;
+/**
+ * Extracts the keys of type "geojson" from the jsonform schema
+ * @param {Record<string,any> |null} [jsonformSchema]
+ **/
+export function getGeoJsonProperties(jsonformSchema?: Record<string, any> | null): string[];
+/**
+ * Converts jsonform geojson values to stringified geometries
+ * @param {Record<string,any> |null} [jsonformSchema]
+ * @param {Record<string,any>} jsonformValue
+ **/
+export function extractGeometries(jsonformValue: Record<string, any>, jsonformSchema?: Record<string, any> | null): void;
+/**
+ * Injects CSS to remove the borders of the jsonform from inside the shadowRoot
+ * @param {import("@eox/jsonform").EOxJSONForm | null} jsonFormEl
+ **/
+export function injectJsonformCSS(jsonFormEl: import("@eox/jsonform").EOxJSONForm | null): void;
+/**
+ * @param {import("stac-ts").StacLink[] | undefined} links
+ * @param {Record<string,any>|undefined} jsonformValue
+ * @param {number[]} origBbox
+ */
+export function processImage(links: import("stac-ts").StacLink[] | undefined, jsonformValue: Record<string, any> | undefined, origBbox: number[]): {
+    type: string;
+    properties: {
+        id: unknown;
+        title: string;
+    };
+    source: {
+        type: string;
+        imageExtent: number[];
+        url: string;
+    };
+}[] | undefined;
+/**
+ * @param {import("stac-ts").StacLink[] | undefined} links
+ * @param {Record<string,any> | undefined} jsonformValue
+ * @param {string} layerId
+ */
+export function processVector(links: import("stac-ts").StacLink[] | undefined, jsonformValue: Record<string, any> | undefined, layerId: string): Promise<Record<string, any>[] | undefined>;
+/**
+ * @param {import("stac-ts").StacLink[] | undefined} links
+ * @param {Record<string,any> | undefined} jsonformValue
+ * @param {import("vue").Ref<boolean>} isPolling
+ * @param {string} layerId
+ */
+export function processGeoTiff(links: import("stac-ts").StacLink[] | undefined, jsonformValue: Record<string, any> | undefined, layerId: string, isPolling: import("vue").Ref<boolean>): Promise<{
+    style?: Record<string, any> | undefined;
+    type: string;
+    source: {
+        type: string;
+        normalize: boolean;
+        sources: {
+            url: string;
+        }[];
+    };
+    properties: {
+        layerConfig?: Record<string, any> | undefined;
+        id: string;
+        title: string;
+    };
+} | undefined>;
+/**
+ * @param {import("stac-ts").StacLink[] | undefined} links
+ * @param {Record<string,any> | undefined} jsonformValue
+ * @param {string} specUrl
+ * @returns {Promise<[import("vega").Spec|null,Record<string,any>|null]>}
+ **/
+export function getChartValues(links: import("stac-ts").StacLink[] | undefined, jsonformValue: Record<string, any> | undefined, specUrl: string): Promise<[import("vega").Spec | null, Record<string, any> | null]>;
+/**
+ * @param {Object} params
+ * @param {import("vue").Ref<boolean>} params.loading
+ * @param {import("vue").Ref<import("stac-ts").StacCollection | null>} params.selectedStac
+ * @param {import("vue").Ref<import("@eox/jsonform").EOxJSONForm | null>} params.jsonformEl
+ * @param {import("vue").Ref<Record<string,any>|null>} params.jsonformSchema
+ * @param {import("vue").Ref<import("@eox/chart").EOxChart["spec"]>} params.chartSpec
+ * @param {import("vue").Ref<Record<string, any> | null>} params.chartData
+ * @param {import("vue").Ref<boolean>} params.isPolling
+ */
+export function handleProcesses({ loading, selectedStac, jsonformEl, jsonformSchema, chartSpec, chartData, isPolling, }: {
+    loading: import("vue").Ref<boolean>;
+    selectedStac: import("vue").Ref<import("stac-ts").StacCollection | null>;
+    jsonformEl: import("vue").Ref<import("@eox/jsonform").EOxJSONForm | null>;
+    jsonformSchema: import("vue").Ref<Record<string, any> | null>;
+    chartSpec: import("vue").Ref<import("@eox/chart").EOxChart["spec"]>;
+    chartData: import("vue").Ref<Record<string, any> | null>;
+    isPolling: import("vue").Ref<boolean>;
+}): Promise<void>;
+/**
+ * Reset the process state
+ * @param {Object} params
+ * @param {import("vue").Ref<boolean>} params.loading
+ * @param {import("vue").Ref<boolean>} params.isProcessed
+ * @param {import("vue").Ref<import("@eox/chart").EOxChart["spec"]>} params.chartSpec
+ * @param {import("vue").Ref<boolean>} params.isPolling
+ * @param {import("vue").Ref<Record<string,any>|null>} params.jsonformSchema
+ */
+export function resetProcess({ loading, isProcessed, chartSpec, jsonformSchema, isPolling, }: {
+    loading: import("vue").Ref<boolean>;
+    isProcessed: import("vue").Ref<boolean>;
+    chartSpec: import("vue").Ref<import("@eox/chart").EOxChart["spec"]>;
+    isPolling: import("vue").Ref<boolean>;
+    jsonformSchema: import("vue").Ref<Record<string, any> | null>;
+}): void;
+/**
+ * Description placeholder
+ *
+ * @export
+ * @async
+ * @param {Object} params
+ * @param {import("vue").Ref<import("stac-ts").StacCollection>} params.selectedStac
+ * @param {import("vue").Ref<import("@eox/jsonform").EOxJSONForm | null>} params.jsonformEl
+ * @param {import("vue").Ref<Record<string,any> | null>} params.jsonformSchema
+ * @param {import("vue").Ref<import("@eox/chart").EOxChart["spec"]>} params.chartSpec
+ * @param {import("vue").Ref<boolean>} params.isProcessed
+ * @param {import("vue").Ref<boolean>} params.loading
+ * @param {import("vue").Ref<boolean>} params.isPolling
+ */
+export function initProcess({ selectedStac, jsonformEl, jsonformSchema, chartSpec, isProcessed, loading, isPolling, }: {
+    selectedStac: import("vue").Ref<import("stac-ts").StacCollection>;
+    jsonformEl: import("vue").Ref<import("@eox/jsonform").EOxJSONForm | null>;
+    jsonformSchema: import("vue").Ref<Record<string, any> | null>;
+    chartSpec: import("vue").Ref<import("@eox/chart").EOxChart["spec"]>;
+    isProcessed: import("vue").Ref<boolean>;
+    loading: import("vue").Ref<boolean>;
+    isPolling: import("vue").Ref<boolean>;
+}): Promise<void>;

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

@@ -0,0 +1,9 @@
+export function useAbsoluteUrl(rel?: string, base?: string): import("vue").Ref<string>;
+export function useCompareAbsoluteUrl(rel?: string, base?: string): import("vue").Ref<string>;
+export function useUpdateTheme(themeName: string, themeDefinition?: import("vuetify").ThemeDefinition): import("vuetify").ThemeInstance;
+export function useURLSearchParametersSync(): void;
+export function makePanelTransparent(root: import("vue").Ref<HTMLElement | null>): void;
+export function useGetTemplates(): string[];
+export function useOnLayersUpdate(listener: import("@vueuse/core").EventBusListener<"layers:updated" | "time:updated", {
+    layers: Record<string, any>[] | undefined;
+}>): void;

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

@@ -0,0 +1,8 @@
+/**
+ * Reactive Edoash Instance Object. provided globally in the app, and used as an
+ * intermediate object to make user defined instances config reactive.
+ *
+ * @type {import("./types").Eodash}
+ */
+export const eodash: import("./types").Eodash;
+export default eodash;

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

@@ -0,0 +1,108 @@
+export class EodashCollection {
+    /**
+     * Returns base layers and overlay layers of a STAC Collection
+     *
+     * @param {import("stac-ts").StacCollection} indicator */
+    static getIndicatorLayers(indicator: import("stac-ts").StacCollection): Promise<(Record<string, any> | {
+        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;
+    })[]>;
+    /**
+     * Returns GeoDB layer from a list of EodashCollections
+     *
+     * @param {EodashCollection[]} eodashCollections
+     *
+     **/
+    static getGeoDBLayer(eodashCollections: EodashCollection[]): {
+        type: string;
+        properties: {
+            id: string;
+            title: string;
+        };
+        source: {
+            type: string;
+            url: string;
+            format: string;
+        };
+        style: {
+            "circle-radius": number;
+            "circle-fill-color": string;
+            "circle-stroke-color": string;
+            "fill-color": string;
+            "stroke-color": string;
+        };
+        interactions: never[];
+    } | null;
+    /** @param {string} collectionUrl */
+    constructor(collectionUrl: string);
+    /**
+     * @type {import("stac-ts").StacLink
+     *   | import("stac-ts").StacItem
+     *   | undefined}
+     */
+    selectedItem: import("stac-ts").StacLink | import("stac-ts").StacItem | undefined;
+    get collectionStac(): import("stac-ts").StacCollection | undefined;
+    /**
+     * @async
+     * @param {import('stac-ts').StacLink | Date} [linkOrDate]
+     * @returns
+     */
+    createLayersJson: (linkOrDate?: import("stac-ts").StacLink | Date) => Promise<Record<string, any>[]>;
+    /**
+     * @param {import("stac-ts").StacItem} item
+     * @param {string} itemUrl
+     * @param {string} title
+     * @param {boolean} isGeoDB
+     * @param {string} [itemDatetime]
+     * @returns {Promise<Record<string,any>[]>} layers
+     * */
+    buildJsonArray(item: import("stac-ts").StacItem, itemUrl: string, title: string, isGeoDB: boolean, itemDatetime?: string): Promise<Record<string, any>[]>;
+    fetchCollection(): Promise<import("stac-ts").StacCollection>;
+    getItems(): import("stac-ts").StacLink[] | undefined;
+    getDates(): Date[] | undefined;
+    getExtent(): Promise<import("stac-ts").Extents | undefined>;
+    /**
+     * Get closest Item Link from a certain date,
+     * get the latest if no date provided
+     *  @param {Date} [date]
+     **/
+    getItem(date?: Date): import("stac-ts").StacLink | undefined;
+    /**
+     *
+     * @param {string} datetime
+     * @param {string} layer
+     * @param {string} map
+     */
+    updateLayerJson(datetime: string, layer: string, map: string): Promise<Record<string, any>[] | undefined>;
+    #private;
+}

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>;