@eodash/eodash 5.0.0 → 5.1.0

package/dist/types/widgets/EodashProcess/methods/async.d.ts

@@ -2,44 +2,44 @@
  * Polls the process status and fetches a result item when the process is successful.
  *
  * @param {Object} params - Parameters for polling the process status.
+ * @param {import("vue").Ref<import("../types").AsyncJob[]>} params.jobs - The list of jobs to update.
  * @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.
+ * @param {boolean} [params.enableCompare=false] - Whether to enable comparison mode, affecting the indicator used.
+ * @returns {Promise<import("../types").EOxHubProcessResults>} The fetched results JSON.
  * @throws {Error} If the process does not complete successfully within the maximum retries.
  */
-export function pollProcessStatus({ processUrl, isPolling, pollInterval, maxRetries, }: {
+export function pollProcessStatus({ jobs, processUrl, isPolling, pollInterval, maxRetries, enableCompare, }: {
+    jobs: import("vue").Ref<import("../types").AsyncJob[]>;
     processUrl: string;
     isPolling: import("vue").Ref<boolean>;
     pollInterval?: number | undefined;
     maxRetries?: number | undefined;
-}): Promise<JSON>;
+    enableCompare?: boolean | undefined;
+}): Promise<import("../types").EOxHubProcessResults>;
 /**
  *
- * @param {*} jobs
- * @param {*} indicator
+ * @param {import("vue").Ref<import("../types").AsyncJob[]>} jobs
+ * @param {string} indicator
  */
-export function updateJobsStatus(jobs: any, indicator: any): Promise<void>;
+export function updateJobsStatus(jobs: import("vue").Ref<import("../types").AsyncJob[]>, indicator: string): Promise<void>;
 /**
  * load a geotiff to the map from an existing process
  *
  * @param {Object} params
  * @param {import("stac-ts").StacCollection | null} params.selectedStac
- * @param {any[]} params.results
  * @param {string} params.jobId
+ * @param {import("../types").EOxHubProcessResults} params.results
+ * @param {import("@eox/map").EOxMap | null} params.mapElement
  */
-export function loadPreviousProcess({ selectedStac, results, jobId }: {
+export function loadPreviousProcess({ selectedStac, results, jobId, mapElement, }: {
     selectedStac: import("stac-ts").StacCollection | null;
-    results: any[];
     jobId: string;
+    results: import("../types").EOxHubProcessResults;
+    mapElement: import("@eox/map").EOxMap | null;
 }): Promise<void>;
-/**
- * The list of job result from the server
- * {job_start_datetime: string, job_end_datetime: string,status: string}
- *  @type {import("vue").Ref<any[]>}
- **/
-export const jobs: import("vue").Ref<any[]>;
-export function deleteJob(jobObject: any): Promise<void>;
-export function downloadPreviousResults(jobObject: any, selectedStac: any): Promise<void>;
-export function loadProcess(jobObject: any, selectedStac: any): Promise<void>;
+export function deleteJob(jobs: import("vue").Ref<import("../types").AsyncJob[]>, jobObject: import("../types").AsyncJob, indicator: string): Promise<void>;
+export function downloadPreviousResults(jobObject: import("../types").AsyncJob, selectedStac: import("stac-ts").StacCollection | null): Promise<void>;
+export function loadProcess(jobObject: import("../types").AsyncJob, selectedStac: import("stac-ts").StacCollection | null, mapElement: import("@eox/map").EOxMap | null): Promise<void>;

package/dist/types/widgets/EodashProcess/methods/composables.d.ts

@@ -7,8 +7,8 @@
  * @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;
-export function useInitProcess({ selectedStac, jsonformEl, jsonformSchema, chartSpec, isProcessed, processResults, loading, isPolling, }: {
-    selectedStac: import("vue").Ref<import("stac-ts").StacCollection>;
+export function useInitProcess({ selectedStac, jsonformEl, jsonformSchema, chartSpec, isProcessed, processResults, loading, isPolling, mapElement, }: {
+    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"] | null>;
@@ -16,4 +16,5 @@ export function useInitProcess({ selectedStac, jsonformEl, jsonformSchema, chart
     isProcessed: import("vue").Ref<boolean>;
     loading: import("vue").Ref<boolean>;
     isPolling: import("vue").Ref<boolean>;
+    mapElement: import("@eox/map").EOxMap | null;
 }): void;

package/dist/types/widgets/EodashProcess/methods/custom-endpoints/chart/index.d.ts

@@ -0,0 +1 @@
+export function handleChartCustomEndpoints(inputs: import("../../../../EodashProcess/types").CustomEnpointInput): Promise<any[] | null>;

package/dist/types/widgets/EodashProcess/methods/custom-endpoints/chart/sentinelhub-endpoint.d.ts

@@ -0,0 +1,6 @@
+/**
+ *
+ * @param {import("../../../../EodashProcess/types").CustomEnpointInput} inputs
+ * @returns
+ */
+export function handleSentinelHubProcess({ links, jsonformValue, jsonformSchema, selectedStac, enableCompare, }: import("../../../../EodashProcess/types").CustomEnpointInput): Promise<any[] | undefined>;

package/dist/types/widgets/EodashProcess/methods/custom-endpoints/chart/veda-endpoint.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @param {import("../../../../EodashProcess/types").CustomEnpointInput} inputs
+ */
+export function handleVedaEndpoint({ links, jsonformSchema, jsonformValue, selectedStac, enableCompare, }: import("../../../../EodashProcess/types").CustomEnpointInput): Promise<any[] | undefined>;

package/dist/types/widgets/EodashProcess/methods/custom-endpoints/layers/eoxhub-workspaces-endpoint.d.ts

@@ -0,0 +1,5 @@
+/**
+ *
+ * @param {import("../../../../EodashProcess/types").CustomEnpointInput} param0
+ */
+export function handleEOxHubEndpoint({ links, jsonformValue, isPolling, selectedStac, jobs, enableCompare, }: import("../../../../EodashProcess/types").CustomEnpointInput): Promise<(import("@eox/map/src/layers").EOxLayerType<"Vector", "Vector"> | import("@eox/map/src/layers").EOxLayerType<"Vector", "FlatGeoBuf"> | import("@eox/map/src/layers").EOxLayerType<"Vector", "Cluster"> | import("@eox/map/src/layers").EOxLayerType<"VectorTile", "VectorTile"> | import("@eox/map/src/layers").EOxLayerType<"WebGLTile", "GeoTIFF"> | import("@eox/map/src/layers").EOxLayerType<"Tile", "OSM"> | import("@eox/map/src/layers").EOxLayerType<"Tile", "WMTSCapabilities"> | import("@eox/map/src/layers").EOxLayerType<"Tile", "StadiaMaps"> | import("@eox/map/src/layers").EOxLayerType<"Tile", "WMTS"> | import("@eox/map/src/layers").EOxLayerType<"Tile", "XYZ"> | import("@eox/map/src/layers").EOxLayerType<"Tile", "TileJSON"> | import("@eox/map/src/layers").EOxLayerType<"Tile", "TileArcGISRest"> | import("@eox/map/src/layers").EOxLayerType<"Tile", "TileDebug"> | import("@eox/map/src/layers").EOxLayerType<"Tile", "TileImage"> | import("@eox/map/src/layers").EOxLayerType<"Tile", "TileWMS"> | import("@eox/map/src/layers").EOxLayerType<"Tile", "UrlTile"> | import("@eox/map/src/layers").EOxLayerType<"Tile", "BingMaps"> | import("@eox/map/src/layers").EOxLayerType<"Image", "Image"> | import("@eox/map/src/layers").EOxLayerType<"Image", "ImageCanvas"> | import("@eox/map/src/layers").EOxLayerType<"Image", "ImageStatic"> | import("@eox/map/src/layers").EOxLayerType<"Image", "ImageWMS"> | import("@eox/map/src/layers").EOxLayerType<"Image", "Raster"> | import("@eox/map/src/layers").EOxLayerType<"Image", "IIIF"> | import("@eox/map/src/layers").EOxLayerTypeGroup)[] | undefined>;

package/dist/types/widgets/EodashProcess/methods/custom-endpoints/layers/index.d.ts

@@ -0,0 +1 @@
+export const handleLayersCustomEndpoints: (input: import("../../../../EodashProcess/types").CustomEnpointInput) => Promise<import("@eox/map/.").EoxLayer[]>;

package/dist/types/widgets/EodashProcess/methods/handling.d.ts

@@ -4,7 +4,7 @@
  * @export
  * @async
  * @param {Object} params
- * @param {import("vue").Ref<import("stac-ts").StacCollection>} params.selectedStac
+ * @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"] | null>} params.chartSpec
@@ -12,9 +12,10 @@
  * @param {import("vue").Ref<boolean>} params.isProcessed
  * @param {import("vue").Ref<boolean>} params.loading
  * @param {import("vue").Ref<boolean>} params.isPolling
+ * @param {boolean} params.enableCompare
  */
-export function initProcess({ selectedStac, jsonformEl, jsonformSchema, chartSpec, isProcessed, processResults, loading, isPolling, }: {
-    selectedStac: import("vue").Ref<import("stac-ts").StacCollection>;
+export function initProcess({ selectedStac, jsonformEl, jsonformSchema, chartSpec, isProcessed, processResults, loading, isPolling, enableCompare, }: {
+    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"] | null>;
@@ -22,10 +23,11 @@ export function initProcess({ selectedStac, jsonformEl, jsonformSchema, chartSpe
     isProcessed: import("vue").Ref<boolean>;
     loading: import("vue").Ref<boolean>;
     isPolling: import("vue").Ref<boolean>;
+    enableCompare: boolean;
 }): Promise<void>;
 /**
  *
- * @param {Object} params
+ * @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
@@ -34,8 +36,10 @@ export function initProcess({ selectedStac, jsonformEl, jsonformSchema, chartSpe
  * @param {import("vue").Ref<Record<string, any> | null>} params.chartData
  * @param {import("vue").Ref<boolean>} params.isPolling
  * @param {import("vue").Ref<any[]>} params.processResults
+ * @param {import("@eox/map").EOxMap | null} params.mapElement
+ * @param {import("vue").Ref<import("../types").AsyncJob[]>} params.jobs
  */
-export function handleProcesses({ loading, selectedStac, jsonformEl, jsonformSchema, chartSpec, chartData, isPolling, processResults, }: {
+export function handleProcesses({ loading, selectedStac, jsonformEl, jsonformSchema, chartSpec, chartData, isPolling, processResults, mapElement, jobs, }: {
     loading: import("vue").Ref<boolean>;
     selectedStac: import("vue").Ref<import("stac-ts").StacCollection | null>;
     jsonformEl: import("vue").Ref<import("@eox/jsonform").EOxJSONForm | null>;
@@ -44,6 +48,8 @@ export function handleProcesses({ loading, selectedStac, jsonformEl, jsonformSch
     chartData: import("vue").Ref<Record<string, any> | null>;
     isPolling: import("vue").Ref<boolean>;
     processResults: import("vue").Ref<any[]>;
+    mapElement: import("@eox/map").EOxMap | null;
+    jobs: import("vue").Ref<import("../types").AsyncJob[]>;
 }): Promise<void>;
 /**
  * Reset the process state
@@ -76,3 +82,4 @@ export function onChartClick(evt: {
         item: import("vega").Item;
     };
 }): void;
+export function loadPOiIndicator(): void;

package/dist/types/widgets/EodashProcess/methods/outputs.d.ts

@@ -1,54 +1,85 @@
+/**
+ * @param {object} options
+ * @param {import("stac-ts").StacLink[] | undefined} options.links
+ * @param {Record<string,any> | undefined} options.jsonformValue
+ * @param {string} options.specUrl
+ * @param {(input:import("../../EodashProcess/types").CustomEnpointInput)=>Promise<Record<string,any>[] | undefined | null>} [options.customEndpointsHandler]
+ * @param {import("vue").Ref<boolean>} options.isPolling
+ * @param {import("stac-ts").StacCollection} options.selectedStac
+ * @param {Record<string,any>} options.jsonformSchema
+ * @param {import("vue").Ref<import("../types").AsyncJob[]>} options.jobs
+ * @param {boolean} [options.enableCompare=false] - Whether to enable compare mode
+ * @returns {Promise<[import("@eox/chart").EOxChart["spec"] | null,Record<string,any>|null]>}
+ **/
+export function processCharts({ links, jsonformValue, specUrl, customEndpointsHandler, jsonformSchema, selectedStac, isPolling, jobs, enableCompare, }: {
+    links: import("stac-ts").StacLink[] | undefined;
+    jsonformValue: Record<string, any> | undefined;
+    specUrl: string;
+    customEndpointsHandler?: ((input: import("../../EodashProcess/types").CustomEnpointInput) => Promise<Record<string, any>[] | undefined | null>) | undefined;
+    isPolling: import("vue").Ref<boolean>;
+    selectedStac: import("stac-ts").StacCollection;
+    jsonformSchema: Record<string, any>;
+    jobs: import("vue").Ref<import("../types").AsyncJob[]>;
+    enableCompare?: boolean | undefined;
+}): Promise<[import("@eox/chart").EOxChart["spec"] | null, Record<string, any> | null]>;
+/**
+ * @param {object} options
+ * @param {import("stac-ts").StacLink[] | undefined} options.links
+ * @param {Record<string,any> | undefined} options.jsonformValue
+ * @param {string} options.layerId
+ * @param {string} [options.projection]
+ */
+export function processGeoTiff({ links, jsonformValue, layerId, projection, }: {
+    links: import("stac-ts").StacLink[] | undefined;
+    jsonformValue: Record<string, any> | undefined;
+    layerId: string;
+    projection?: string | undefined;
+}): Promise<import("@eox/map/src/layers").EOxLayerType<"WebGLTile", "GeoTIFF">[] | undefined>;
 /**
  * @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;
+export function processImage(links: import("stac-ts").StacLink[] | undefined, jsonformValue: Record<string, any> | undefined, origBbox: number[]): import("@eox/map/src/layers").EOxLayerType<"Image", "ImageStatic">[] | 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>;
+export function processVector(links: import("stac-ts").StacLink[] | undefined, jsonformValue: Record<string, any> | undefined, layerId: string): Promise<import("@eox/map/src/layers").EOxLayerType<"Vector", any>[] | undefined>;
 /**
- * @param {import("stac-ts").StacLink[] | undefined} links
- * @param {Record<string,any> | undefined} jsonformValue
- * @param {string} specUrl
- * @returns {Promise<[import("@eox/chart").EOxChart["spec"] | null,Record<string,any>|null]>}
- **/
-export function getChartValues(links: import("stac-ts").StacLink[] | undefined, jsonformValue: Record<string, any> | undefined, specUrl: string): Promise<[import("@eox/chart").EOxChart["spec"] | null, Record<string, any> | null]>;
+ * Unified wrapper for processing map layer types (Vector, Image, GeoTiff)
+ * @param {object} options
+ * @param {import("stac-ts").StacLink[] | undefined} options.links
+ * @param {Record<string,any> | undefined} options.jsonformValue
+ * @param {string} options.layerId
+ * @param {string} [options.projection] - Required for GeoTiff layers
+ * @param {number[]} options.origBbox - Required for Image layers
+ * @param {import("vue").Ref<boolean>} options.isPolling
+ * @param {import("stac-ts").StacCollection} options.selectedStac
+ * @param {import("json-schema").JSONSchema7} options.jsonformSchema
+ * @param {import("vue").Ref<import("../types").AsyncJob[]>} options.jobs
+ * @param {(input:import("../types").CustomEnpointInput)=>Promise<import("@eox/map").EoxLayer[]>} options.customLayersHandler
+ * @param {boolean} [options.enableCompare=false] - Whether to enable compare mode
+ */
+export function processLayers({ links, jsonformValue, layerId, projection, origBbox, isPolling, selectedStac, jsonformSchema, jobs, customLayersHandler, enableCompare, }: {
+    links: import("stac-ts").StacLink[] | undefined;
+    jsonformValue: Record<string, any> | undefined;
+    layerId: string;
+    projection?: string | undefined;
+    origBbox: number[];
+    isPolling: import("vue").Ref<boolean>;
+    selectedStac: import("stac-ts").StacCollection;
+    jsonformSchema: import("json-schema").JSONSchema7;
+    jobs: import("vue").Ref<import("../types").AsyncJob[]>;
+    customLayersHandler: (input: import("../types").CustomEnpointInput) => Promise<import("@eox/map").EoxLayer[]>;
+    enableCompare?: boolean | undefined;
+}): Promise<import("@eox/map/src/layers").EoxLayer[]>;
 /**
- * @param {import("stac-ts").StacLink[] | undefined} links
- * @param {Record<string,any> | undefined} jsonformValue
- * @param {import("vue").Ref<boolean>} isPolling
- * @param {string} layerId
- * @param {string} projection
+ * This function loads a STAC collection as a processing output.
+ * Currently, it only supports POI STAC collections
+ *
+ * @param {import("stac-ts").StacLink[]} links
+ * @param {Record<string,any>} jsonformValue
  */
-export function processGeoTiff(links: import("stac-ts").StacLink[] | undefined, jsonformValue: Record<string, any> | undefined, layerId: string, isPolling: import("vue").Ref<boolean>, projection: string): Promise<{
-    style?: Record<string, any> | undefined;
-    type: string;
-    source: {
-        type: string;
-        normalize: boolean;
-        sources: {
-            url: string;
-        }[];
-    };
-    properties: {
-        layerControlToolsExpand: boolean;
-        layerConfig?: Record<string, any> | undefined;
-        id: string;
-        title: string;
-    };
-} | undefined>;
+export function processSTAC(links: import("stac-ts").StacLink[], jsonformValue: Record<string, any>, enableCompare?: boolean): Promise<void>;

package/dist/types/widgets/EodashProcess/methods/utils.d.ts

@@ -15,28 +15,48 @@ export function getGeoJsonProperties(jsonformSchema?: Record<string, any> | null
 export function extractGeometries(jsonformValue: Record<string, any>, jsonformSchema?: Record<string, any> | null): void;
 /**
  *
- * @param {*} link
- * @param {*} layerId
+ * @param {import("stac-ts").StacLink} link
+ * @param {string} layerId
  * @param {string[]} urls
- * @param {*} projection
- * @param {*} processId
+ * @param {import("openlayers").ProjectionLike} projection
+ * @param {string} processId
+ */
+export function createTiffLayerDefinition(link: import("stac-ts").StacLink, layerId: string, urls: string[], projection: import("openlayers").ProjectionLike, processId: string): Promise<import("@eox/map/src/layers").EOxLayerType<"WebGLTile", "GeoTIFF"> | undefined>;
+/**
+ * Generate time pairs from a temporal extent
+ * @param {import("stac-ts").TemporalExtent} stacExtent - [start, end]
+ * @param {import("stac-ts").TemporalExtent} [userExtent] -[start, end]
+ * @param {string} [distribution] - daily, weekly, monthly, or yearly
+ */
+export function generateTimePairs(stacExtent: import("stac-ts").TemporalExtent, userExtent?: import("stac-ts").TemporalExtent, distribution?: string): string[][];
+/**
+ * Filter links to separate those with and without endpoint property
+ * @param {import("stac-ts").StacLink[] | undefined} links
+ * @param {string} [relType] - Optional relationship type
+ * @param {string} [contentType] - Optional content type
+ * @returns {[import("stac-ts").StacLink[], import("stac-ts").StacLink[]]}
+ */
+export function separateEndpointLinks(links: import("stac-ts").StacLink[] | undefined, relType?: string, contentType?: string): [import("stac-ts").StacLink[], import("stac-ts").StacLink[]];
+/**
+ * Generates layer definitions for asynchronous process results.
+ * using AsyncProcessResults data structure.
+ * @param {import("../../EodashProcess/types").AsyncProcessResults} processResults
+ * @param {import("stac-ts").StacLink} endpointLink
+ * @param {import("stac-ts").StacCollection|null} selectedStac
+ * @param {string} [postfixId=""] - Optional layers id postfix
  * @returns
  */
-export function createLayerDefinition(link: any, layerId: any, urls: string[], projection: any, processId: any): Promise<{
-    style?: Record<string, any> | undefined;
-    type: string;
-    source: {
-        type: string;
-        normalize: boolean;
-        sources: {
-            url: string;
-        }[];
-    };
-    properties: {
-        layerControlToolsExpand: boolean;
-        layerConfig?: Record<string, any> | undefined;
-        id: string;
-        title: string;
-    };
-} | undefined>;
+export function creatAsyncProcessLayerDefinitions(processResults: import("../../EodashProcess/types").AsyncProcessResults, endpointLink: import("stac-ts").StacLink, selectedStac: import("stac-ts").StacCollection | null, postfixId?: string): Promise<import("@eox/map/src/layers").EoxLayer[]>;
+/**
+ *
+ * @param {import("../../EodashProcess/types").EOxHubProcessResults} resultItem
+ * @returns {import("../../EodashProcess/types").AsyncProcessResults}
+ */
+export function extractAsyncResults(resultItem: import("../../EodashProcess/types").EOxHubProcessResults): import("../../EodashProcess/types").AsyncProcessResults;
+/**
+ * Updates the jsonform schema to target the compare map
+ * @param {import("json-schema").JSONSchema7 | null | undefined} jsonformSchema
+ */
+export function updateJsonformSchemaTarget(jsonformSchema: import("json-schema").JSONSchema7 | null | undefined): import("json-schema").JSONSchema7 | null | undefined;
 export function download(fileName: string, content: string | Record<string, any>): void;
+export function applyProcessLayersToMap(mapElement: import("@eox/map").EOxMap | null, processLayers: import("@eox/map").EoxLayer[]): void;

package/dist/types/widgets/EodashProcess/states.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The list of job result from the server
+ * {job_start_datetime: string, job_end_datetime: string,status: string}
+ *  @type {import("vue").Ref<import("./types").AsyncJob[]>}
+ **/
+export const jobs: import("vue").Ref<import("./types").AsyncJob[]>;
+/**
+ * The list of jobs results from the server for the compare map
+ * @type {import("vue").Ref<import("./types").AsyncJob[]>}
+ */
+export const compareJobs: import("vue").Ref<import("./types").AsyncJob[]>;

package/dist/types/widgets/EodashProcess/types.d.ts

@@ -0,0 +1,41 @@
+import type { StacLink, StacCollection } from "stac-ts";
+import type { Ref } from "vue";
+export interface CustomEnpointInput {
+    links: StacLink[];
+    jsonformSchema: Record<string, any>;
+    jsonformValue: Record<string, any>;
+    selectedStac: StacCollection;
+    isPolling?: Ref<boolean>;
+    enableCompare?: boolean;
+    jobs: Ref<AsyncJob[]>;
+}
+export interface AsyncJob {
+    type: string;
+    processID: string;
+    jobID: string;
+    status: "successful" | "failed" | "running";
+    message: string;
+    /** percentage of completion */
+    progress: number | string;
+    /** stringified object of parameters  */
+    parameters: string;
+    /** ISO datetime string */
+    job_start_datetime: string;
+    /** ISO datetime string */
+    job_end_datetime: string;
+    /** typically contains links to differen types of the results */
+    links: StacLink[];
+}
+export type EOxHubProcessResults = {
+    urls: string[];
+} | {
+    [K in string as K extends "urls" ? never : K]: {
+        urls: string[];
+        mimetype: string;
+    };
+};
+export type AsyncProcessResults = {
+    type: string;
+    urls: string[];
+    id: string;
+}[];

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

@@ -1,21 +1,21 @@
 declare const _default: import("vue").DefineComponent<{}, {
-    body: string[];
-    styleOverride: string;
     allowHtml: boolean;
-    header: string[];
-    tags: string[];
-    subheader: string[];
     featured: string[];
     footer: string[];
+    header: string[];
+    body: string[];
+    styleOverride: string;
+    subheader: string[];
+    tags: string[];
     $props: {
-        readonly body?: string[] | undefined;
-        readonly styleOverride?: string | undefined;
-        readonly allowHtml?: boolean | undefined;
-        readonly header?: string[] | undefined;
-        readonly tags?: string[] | undefined;
-        readonly subheader?: string[] | undefined;
-        readonly featured?: string[] | undefined;
-        readonly footer?: string[] | undefined;
+        allowHtml?: boolean | undefined;
+        featured?: string[] | undefined;
+        footer?: string[] | undefined;
+        header?: string[] | undefined;
+        body?: string[] | undefined;
+        styleOverride?: string | undefined;
+        subheader?: string[] | undefined;
+        tags?: string[] | undefined;
     };
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, HTMLDivElement>;
+}, {}, {}, {}, 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/EodashTools.vue.d.ts

@@ -16,6 +16,7 @@ declare const _default: import("vue").DefineComponent<{}, {
         readonly enableHighlighting?: boolean | undefined;
         readonly expandMultipleFilters?: boolean | undefined;
         readonly expandMultipleResults?: boolean | undefined;
+        readonly styleOverride?: string | undefined;
         readonly filterProperties?: {
             keys: string[];
             title: string;
@@ -42,6 +43,7 @@ declare const _default: import("vue").DefineComponent<{}, {
             readonly enableHighlighting?: boolean | undefined;
             readonly expandMultipleFilters?: boolean | undefined;
             readonly expandMultipleResults?: boolean | undefined;
+            readonly styleOverride?: string | undefined;
             readonly filterProperties?: {
                 keys: string[];
                 title: string;
@@ -51,7 +53,5 @@ declare const _default: import("vue").DefineComponent<{}, {
             readonly aggregateResults?: string | undefined;
         }) | undefined;
     };
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {
-    rootEl: HTMLDivElement;
-}, HTMLDivElement>;
+}, {}, {}, {}, 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/ExportState.vue.d.ts

@@ -3,5 +3,5 @@ declare const _default: import("vue").DefineComponent<{}, {
     $props: {
         readonly getLayers?: Function | undefined;
     };
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, HTMLSpanElement>;
+}, {}, {}, {}, 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/PopUp.vue.d.ts

@@ -1,27 +1,22 @@
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;
-type __VLS_WithTemplateSlots<T, S> = T & (new () => {
+type __VLS_WithSlots<T, S> = T & (new () => {
     $slots: S;
 });
 declare const __VLS_component: import("vue").DefineComponent<{}, {
-    maxWidth: string;
-    maxHeight: string;
     width: string;
     height: string;
-    widget?: import("../core/client/types").Widget<"compiletime"> | undefined;
+    maxWidth: string;
+    maxHeight: string;
+    widget?: import("../core/client/types").Widget | undefined;
     $props: {
-        readonly maxWidth?: string | undefined;
-        readonly maxHeight?: string | undefined;
         readonly width?: string | undefined;
         readonly height?: string | undefined;
-        readonly widget?: import("../core/client/types").Widget<"compiletime"> | undefined;
-    };
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, HTMLSpanElement>;
-type __VLS_TemplateResult = {
-    attrs: Partial<{}>;
-    slots: {
-        default?(_: {}): any;
+        readonly maxWidth?: string | undefined;
+        readonly maxHeight?: string | undefined;
+        readonly widget?: import("../core/client/types").Widget | undefined;
     };
-    refs: {};
-    rootEl: HTMLSpanElement;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+type __VLS_Slots = {
+    default?: ((props: {}) => any) | undefined;
 };

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

@@ -1,10 +1,7 @@
 declare const _default: import("vue").DefineComponent<{}, {
-    widgets: Omit<import("../core/client/types").Widget<"compiletime">, "layout">[];
+    widgets: Omit<import("../core/client/types").Widget, "layout">[];
     $props: {
-        readonly widgets?: Omit<import("../core/client/types").Widget<"compiletime">, "layout">[] | undefined;
+        readonly widgets?: Omit<import("../core/client/types").Widget, "layout">[] | undefined;
     };
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {
-    detailsEls: HTMLDetailsElement[];
-    summaryEls: HTMLElement;
-}, any>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;