@jupytergis/base 0.11.1 → 0.12.1

package/lib/stacBrowser/hooks/useStacFilterExtension.js

@@ -0,0 +1,262 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { endOfToday, startOfToday } from 'date-fns';
+import { useCallback, useEffect, useState } from 'react';
+import useIsFirstRender from "../../shared/hooks/useIsFirstRender";
+import { useStacResultsContext } from "../context/StacResultsContext";
+import { useStacSearch } from "./useStacSearch";
+import { GlobalStateDbManager } from "../../store";
+import { fetchWithProxies } from "../../tools";
+const STAC_FILTER_EXTENSION_STATE_KEY = 'jupytergis:stac-filter-extension-state';
+/**
+ * Hook for searching STAC catalogs that support the Filter Extension (CQL2-JSON).
+ * Fetches collections and queryables, and builds filter queries using the STAC Filter Extension.
+ */
+export function useStacFilterExtension({ model, baseUrl, limit = 12, }) {
+    const isFirstRender = useIsFirstRender();
+    const { registerBuildQuery, executeQuery } = useStacResultsContext();
+    // Get temporal/spatial filters from useStacSearch
+    const { startTime, endTime, setStartTime, setEndTime, currentBBox, useWorldBBox, setUseWorldBBox, } = useStacSearch({
+        model,
+    });
+    const [queryableFields, setQueryableFields] = useState();
+    const [collections, setCollections] = useState([]);
+    const [selectedCollection, setSelectedCollection] = useState('');
+    const [selectedQueryables, setSelectedQueryables] = useState({});
+    const [filterOperator, setFilterOperator] = useState('and');
+    const stateDb = GlobalStateDbManager.getInstance().getStateDb();
+    // On mount, load saved filter state from StateDB (if present)
+    useEffect(() => {
+        async function loadFilterExtensionStateFromDb() {
+            const savedFilterState = (await (stateDb === null || stateDb === void 0 ? void 0 : stateDb.fetch(STAC_FILTER_EXTENSION_STATE_KEY)));
+            if (savedFilterState) {
+                if (savedFilterState.selectedCollection) {
+                    setSelectedCollection(savedFilterState.selectedCollection);
+                }
+                if (savedFilterState.queryableFilters) {
+                    // Convert null back to undefined for inputValue
+                    const restoredFilters = {};
+                    Object.entries(savedFilterState.queryableFilters).forEach(([key, filter]) => {
+                        restoredFilters[key] = {
+                            operator: filter.operator,
+                            inputValue: filter.inputValue === null ? undefined : filter.inputValue,
+                        };
+                    });
+                    setSelectedQueryables(restoredFilters);
+                }
+                if (savedFilterState.filterOperator) {
+                    setFilterOperator(savedFilterState.filterOperator);
+                }
+            }
+        }
+        loadFilterExtensionStateFromDb();
+    }, [stateDb]);
+    // Save filter state to StateDB on change
+    useEffect(() => {
+        async function saveFilterExtensionStateToDb() {
+            // Clean queryableFilters to ensure JSON serialization works
+            const cleanedQueryableFilters = {};
+            Object.entries(selectedQueryables).forEach(([key, filter]) => {
+                var _a;
+                cleanedQueryableFilters[key] = {
+                    operator: filter.operator,
+                    inputValue: (_a = filter.inputValue) !== null && _a !== void 0 ? _a : null,
+                };
+            });
+            await (stateDb === null || stateDb === void 0 ? void 0 : stateDb.save(STAC_FILTER_EXTENSION_STATE_KEY, {
+                selectedCollection: selectedCollection || undefined,
+                queryableFilters: Object.keys(cleanedQueryableFilters).length > 0
+                    ? cleanedQueryableFilters
+                    : undefined,
+                filterOperator,
+            }));
+        }
+        saveFilterExtensionStateToDb();
+    }, [selectedCollection, selectedQueryables, filterOperator, stateDb]);
+    // Reset all state when URL changes
+    useEffect(() => {
+        setQueryableFields(undefined);
+        setCollections([]);
+        setSelectedCollection('');
+        setSelectedQueryables({});
+        setFilterOperator('and');
+    }, [baseUrl]);
+    // for collections
+    useEffect(() => {
+        if (!model) {
+            return;
+        }
+        const fetchCollections = async () => {
+            if (!baseUrl) {
+                return;
+            }
+            const collectionsUrl = baseUrl.endsWith('/')
+                ? `${baseUrl}collections`
+                : `${baseUrl}/collections`;
+            const data = await fetchWithProxies(collectionsUrl, model, async (response) => await response.json(), undefined);
+            const collections = data.collections
+                .map((collection) => {
+                var _a;
+                return ({
+                    title: (_a = collection.title) !== null && _a !== void 0 ? _a : collection.id,
+                    id: collection.id,
+                });
+            })
+                .sort((a, b) => {
+                var _a, _b, _c, _d;
+                const titleA = (_b = (_a = a.title) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== null && _b !== void 0 ? _b : '';
+                const titleB = (_d = (_c = b.title) === null || _c === void 0 ? void 0 : _c.toLowerCase()) !== null && _d !== void 0 ? _d : '';
+                return titleA.localeCompare(titleB);
+            });
+            setCollections(collections);
+            // Set first collection as default if one isn't loaded
+            if (collections.length > 0 && !(selectedCollection === '')) {
+                setSelectedCollection(collections[0].id);
+            }
+        };
+        fetchCollections();
+    }, [model, baseUrl]);
+    // for queryables
+    // ! TODO - support multiple collection selections
+    useEffect(() => {
+        if (!model) {
+            return;
+        }
+        const fetchQueryables = async () => {
+            if (!baseUrl) {
+                return;
+            }
+            const queryablesUrl = baseUrl.endsWith('/')
+                ? `${baseUrl}queryables`
+                : `${baseUrl}/queryables`;
+            const data = await fetchWithProxies(queryablesUrl, model, async (response) => await response.json(), undefined);
+            setQueryableFields(Object.entries(data.properties));
+        };
+        fetchQueryables();
+    }, [model, baseUrl]);
+    const updateSelectedQueryables = useCallback((qKey, filter) => {
+        setSelectedQueryables(prev => {
+            // If filter is null, remove the key entirely
+            if (filter === null) {
+                const _a = prev, _b = qKey, _ = _a[_b], rest = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
+                return rest;
+            }
+            // If inputValue is undefined but filter exists, keep it (user might be entering value)
+            // Only remove if explicitly set to null
+            return Object.assign(Object.assign({}, prev), { [qKey]: filter });
+        });
+    }, []);
+    const buildQuery = useCallback(() => {
+        const st = startTime
+            ? startTime.toISOString()
+            : startOfToday().toISOString();
+        const et = endTime ? endTime.toISOString() : endOfToday().toISOString();
+        // Build filter object from selectedQueryables
+        const filterConditions = Object.entries(selectedQueryables)
+            .filter(([, filter]) => filter.inputValue !== undefined)
+            .map(([property, filter]) => {
+            var _a, _b;
+            // Check if this property is a datetime type
+            const queryableField = queryableFields === null || queryableFields === void 0 ? void 0 : queryableFields.find(([key]) => key === property);
+            const isDateTime = queryableField &&
+                ((_a = queryableField[1]) === null || _a === void 0 ? void 0 : _a.type) === 'string' &&
+                ((_b = queryableField[1]) === null || _b === void 0 ? void 0 : _b.format) === 'date-time';
+            // For datetime values, wrap in timestamp object; otherwise use value directly
+            const value = isDateTime
+                ? { timestamp: filter.inputValue }
+                : filter.inputValue;
+            const condition = {
+                op: filter.operator,
+                args: [{ property }, value],
+            };
+            return condition;
+        });
+        const body = {
+            bbox: currentBBox,
+            collections: [selectedCollection],
+            datetime: `${st}/${et}`,
+            limit,
+            'filter-lang': 'cql2-json',
+        };
+        // Only add filter if there are any conditions
+        if (filterConditions.length > 0) {
+            body.filter = {
+                op: filterOperator,
+                args: filterConditions,
+            };
+        }
+        return body;
+    }, [
+        startTime,
+        endTime,
+        currentBBox,
+        selectedCollection,
+        limit,
+        selectedQueryables,
+        filterOperator,
+        queryableFields,
+    ]);
+    // Register buildQuery with context
+    useEffect(() => {
+        registerBuildQuery(() => buildQuery());
+    }, [registerBuildQuery, buildQuery, baseUrl]);
+    const handleSubmit = useCallback(async () => {
+        if (!model) {
+            return;
+        }
+        // Build query body and execute query
+        const queryBody = buildQuery();
+        const searchUrl = baseUrl.endsWith('/')
+            ? `${baseUrl}search`
+            : `${baseUrl}/search`;
+        await executeQuery(queryBody, searchUrl);
+    }, [model, executeQuery, buildQuery, baseUrl]);
+    // Handle search when filters change
+    useEffect(() => {
+        if (model && !isFirstRender && selectedCollection !== '') {
+            const queryBody = buildQuery();
+            const searchUrl = baseUrl.endsWith('/')
+                ? `${baseUrl}search`
+                : `${baseUrl}/search`;
+            executeQuery(queryBody, searchUrl);
+        }
+    }, [
+        model,
+        isFirstRender,
+        selectedCollection,
+        selectedQueryables,
+        filterOperator,
+        startTime,
+        endTime,
+        currentBBox,
+        buildQuery,
+        executeQuery,
+        baseUrl,
+    ]);
+    return {
+        queryableFields,
+        collections,
+        selectedCollection,
+        setSelectedCollection,
+        handleSubmit,
+        startTime,
+        endTime,
+        setStartTime,
+        setEndTime,
+        useWorldBBox,
+        setUseWorldBBox,
+        selectedQueryables,
+        updateSelectedQueryables,
+        filterOperator,
+        setFilterOperator,
+    };
+}

package/lib/stacBrowser/hooks/useStacSearch.d.ts

@@ -1,30 +1,19 @@
 import { IJupyterGISModel } from '@jupytergis/schema';
-import { IStacItem, StacFilterState, StacFilterSetters } from "../types/types";
 interface IUseStacSearchProps {
     model: IJupyterGISModel | undefined;
 }
 interface IUseStacSearchReturn {
-    filterState: StacFilterState;
-    filterSetters: StacFilterSetters;
-    results: IStacItem[];
     startTime: Date | undefined;
     setStartTime: (date: Date | undefined) => void;
     endTime: Date | undefined;
     setEndTime: (date: Date | undefined) => void;
-    totalPages: number;
-    currentPage: number;
-    totalResults: number;
-    handlePaginationClick: (page: number) => Promise<void>;
-    handleResultClick: (id: string) => Promise<void>;
-    formatResult: (item: IStacItem) => string;
-    isLoading: boolean;
+    currentBBox: [number, number, number, number];
+    setCurrentBBox: (bbox: [number, number, number, number]) => void;
     useWorldBBox: boolean;
     setUseWorldBBox: (val: boolean) => void;
 }
 /**
- * Custom hook for managing STAC search functionality
- * @param props - Configuration object containing datasets, platforms, products, and model
- * @returns Object containing state and handlers for STAC search
+ * Base hook for managing STAC search - handles temporal/spatial filters
  */
-declare function useStacSearch({ model }: IUseStacSearchProps): IUseStacSearchReturn;
-export default useStacSearch;
+export declare function useStacSearch({ model, }: IUseStacSearchProps): IUseStacSearchReturn;
+export {};

package/lib/stacBrowser/hooks/useStacSearch.js

@@ -1,79 +1,47 @@
-var _a;
-import { UUID } from '@lumino/coreutils';
-import { startOfYesterday } from 'date-fns';
 import { useEffect, useState } from 'react';
-import useIsFirstRender from "../../shared/hooks/useIsFirstRender";
-import { products } from "../constants";
 import { GlobalStateDbManager } from "../../store";
-import { fetchWithProxies } from "../../tools";
-const API_URL = 'https://geodes-portal.cnes.fr/api/stac/search';
-const XSRF_TOKEN = (_a = document.cookie.match(/_xsrf=([^;]+)/)) === null || _a === void 0 ? void 0 : _a[1];
-const STAC_FILTERS_KEY = 'jupytergis:stac-filters';
+const STAC_SEARCH_STATE_KEY = 'jupytergis:stac-search-state';
 /**
- * Custom hook for managing STAC search functionality
- * @param props - Configuration object containing datasets, platforms, products, and model
- * @returns Object containing state and handlers for STAC search
+ * Base hook for managing STAC search - handles temporal/spatial filters
  */
-function useStacSearch({ model }) {
-    const isFirstRender = useIsFirstRender();
-    const stateDb = GlobalStateDbManager.getInstance().getStateDb();
-    const [results, setResults] = useState([]);
-    const [isLoading, setIsLoading] = useState(false);
-    const [totalPages, setTotalPages] = useState(1);
-    const [currentPage, setCurrentPage] = useState(1);
-    const [totalResults, setTotalResults] = useState(0);
+export function useStacSearch({ model, }) {
     const [startTime, setStartTime] = useState(undefined);
     const [endTime, setEndTime] = useState(undefined);
     const [currentBBox, setCurrentBBox] = useState([-180, -90, 180, 90]);
     const [useWorldBBox, setUseWorldBBox] = useState(false);
-    const [filterState, setFilterState] = useState({
-        collections: new Set(),
-        datasets: new Set(),
-        platforms: new Set(),
-        products: new Set(),
-    });
-    const filterSetters = {
-        collections: val => setFilterState(s => (Object.assign(Object.assign({}, s), { collections: new Set(val) }))),
-        datasets: val => setFilterState(s => (Object.assign(Object.assign({}, s), { datasets: new Set(val) }))),
-        platforms: val => setFilterState(s => (Object.assign(Object.assign({}, s), { platforms: new Set(val) }))),
-        products: val => setFilterState(s => (Object.assign(Object.assign({}, s), { products: new Set(val) }))),
-    };
-    // On mount, fetch filterState and times from StateDB (if present)
+    const stateDb = GlobalStateDbManager.getInstance().getStateDb();
+    // Load saved state from StateDB on mount
     useEffect(() => {
-        async function loadStacStateFromDb() {
-            var _a, _b, _c, _d;
-            const savedFilterState = (await (stateDb === null || stateDb === void 0 ? void 0 : stateDb.fetch(STAC_FILTERS_KEY)));
-            setFilterState({
-                collections: new Set((_a = savedFilterState === null || savedFilterState === void 0 ? void 0 : savedFilterState.collections) !== null && _a !== void 0 ? _a : []),
-                datasets: new Set((_b = savedFilterState === null || savedFilterState === void 0 ? void 0 : savedFilterState.datasets) !== null && _b !== void 0 ? _b : []),
-                platforms: new Set((_c = savedFilterState === null || savedFilterState === void 0 ? void 0 : savedFilterState.platforms) !== null && _c !== void 0 ? _c : []),
-                products: new Set((_d = savedFilterState === null || savedFilterState === void 0 ? void 0 : savedFilterState.products) !== null && _d !== void 0 ? _d : []),
-            });
+        async function loadStacSearchStateFromDb() {
+            const savedState = (await (stateDb === null || stateDb === void 0 ? void 0 : stateDb.fetch(STAC_SEARCH_STATE_KEY)));
+            if (savedState) {
+                if (savedState.startTime) {
+                    setStartTime(new Date(savedState.startTime));
+                }
+                if (savedState.endTime) {
+                    setEndTime(new Date(savedState.endTime));
+                }
+                if (savedState.useWorldBBox !== undefined) {
+                    setUseWorldBBox(savedState.useWorldBBox);
+                }
+            }
         }
-        loadStacStateFromDb();
+        loadStacSearchStateFromDb();
     }, [stateDb]);
-    // Save filterState to StateDB on change
+    // Save state to StateDB on change
     useEffect(() => {
-        async function saveStacFilterStateToDb() {
-            await (stateDb === null || stateDb === void 0 ? void 0 : stateDb.save(STAC_FILTERS_KEY, {
-                collections: Array.from(filterState.collections),
-                datasets: Array.from(filterState.datasets),
-                platforms: Array.from(filterState.platforms),
-                products: Array.from(filterState.products),
+        async function saveStacSearchStateToDb() {
+            await (stateDb === null || stateDb === void 0 ? void 0 : stateDb.save(STAC_SEARCH_STATE_KEY, {
+                startTime: startTime === null || startTime === void 0 ? void 0 : startTime.toISOString(),
+                endTime: endTime === null || endTime === void 0 ? void 0 : endTime.toISOString(),
+                useWorldBBox,
             }));
         }
-        saveStacFilterStateToDb();
-    }, [filterState, stateDb]);
-    // Handle search when filters change
-    useEffect(() => {
-        if (model && !isFirstRender && filterState.datasets.size > 0) {
-            setCurrentPage(1);
-            fetchResults(1);
-        }
-    }, [filterState, startTime, endTime, currentBBox]);
+        saveStacSearchStateToDb();
+    }, [startTime, endTime, useWorldBBox, stateDb]);
     // Listen for model updates to get current bounding box
     useEffect(() => {
-        const listenToModel = (sender, bBoxIn4326) => {
+        const listenToModel = (_sender, bBoxIn4326) => {
             if (useWorldBBox) {
                 setCurrentBBox([-180, -90, 180, 90]);
             }
@@ -86,136 +54,14 @@ function useStacSearch({ model }) {
             model === null || model === void 0 ? void 0 : model.updateBboxSignal.disconnect(listenToModel);
         };
     }, [model, useWorldBBox]);
-    const fetchResults = async (page = 1) => {
-        const processingLevel = new Set();
-        const productType = new Set();
-        filterState.products.forEach(productCode => {
-            products
-                .filter(product => product.productCode === productCode)
-                .forEach(product => {
-                if (product.processingLevel) {
-                    processingLevel.add(product.processingLevel);
-                }
-                if (product.productType) {
-                    product.productType.forEach(type => productType.add(type));
-                }
-            });
-        });
-        const body = {
-            bbox: currentBBox,
-            limit: 12,
-            page,
-            query: Object.assign(Object.assign(Object.assign(Object.assign({ latest: { eq: true }, dataset: { in: Array.from(filterState.datasets) }, end_datetime: {
-                    gte: startTime
-                        ? startTime.toISOString()
-                        : startOfYesterday().toISOString(),
-                } }, (endTime && {
-                start_datetime: { lte: endTime.toISOString() },
-            })), (filterState.platforms.size > 0 && {
-                platform: { in: Array.from(filterState.platforms) },
-            })), (processingLevel.size > 0 && {
-                'processing:level': { in: Array.from(processingLevel) },
-            })), (productType.size > 0 && {
-                'product:type': { in: Array.from(productType) },
-            })),
-            sortBy: [{ direction: 'desc', field: 'start_datetime' }],
-        };
-        try {
-            setIsLoading(true);
-            const options = {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'X-XSRFToken': XSRF_TOKEN,
-                    credentials: 'include',
-                },
-                body: JSON.stringify(body),
-            };
-            if (!model) {
-                return;
-            }
-            const data = (await fetchWithProxies(API_URL, model, async (response) => await response.json(), 
-            //@ts-expect-error Jupyter requires X-XSRFToken header
-            options, 'internal'));
-            if (!data) {
-                console.debug('STAC search failed -- no results found');
-                setResults([]);
-                setTotalPages(1);
-                setTotalResults(0);
-                return;
-            }
-            setResults(data.features);
-            const pages = data.context.matched / data.context.limit;
-            setTotalPages(Math.ceil(pages));
-            setTotalResults(data.context.matched);
-        }
-        catch (error) {
-            console.error('STAC search failed -- error fetching data:', error);
-            setResults([]);
-            setTotalPages(1);
-            setTotalResults(0);
-        }
-        finally {
-            setIsLoading(false);
-        }
-    };
-    /**
-     * Handles clicking on a result item
-     * @param id - ID of the clicked result
-     */
-    const handleResultClick = async (id) => {
-        var _a;
-        if (!results) {
-            return;
-        }
-        const layerId = UUID.uuid4();
-        const stacData = results.find(item => item.id === id);
-        if (!stacData) {
-            console.error('Result not found:', id);
-            return;
-        }
-        const layerModel = {
-            type: 'StacLayer',
-            parameters: { data: stacData },
-            visible: true,
-            name: (_a = stacData.properties.title) !== null && _a !== void 0 ? _a : stacData.id,
-        };
-        model && model.addLayer(layerId, layerModel);
-    };
-    /**
-     * Handles pagination clicks
-     * @param page - Page number to navigate to
-     */
-    const handlePaginationClick = async (page) => {
-        setCurrentPage(page);
-        model && fetchResults(page);
-    };
-    /**
-     * Formats a result item for display
-     * @param item - STAC item to format
-     * @returns Formatted string representation of the item
-     */
-    const formatResult = (item) => {
-        var _a;
-        return (_a = item.properties.title) !== null && _a !== void 0 ? _a : item.id;
-    };
     return {
-        filterState,
-        filterSetters,
-        results,
         startTime,
         setStartTime,
         endTime,
         setEndTime,
-        totalPages,
-        currentPage,
-        totalResults,
-        handlePaginationClick,
-        handleResultClick,
-        formatResult,
-        isLoading,
+        currentBBox,
+        setCurrentBBox,
         useWorldBBox,
         setUseWorldBBox,
     };
 }
-export default useStacSearch;

package/lib/stacBrowser/types/types.d.ts

@@ -1,3 +1,7 @@
+export interface IStacCollectionsReturn {
+    collections: IStacCollection[];
+    links: IStacLink[];
+}
 export interface IStacCollection {
     type: 'Collection';
     stac_version: string;
@@ -22,13 +26,13 @@ export interface IStacRange {
     maximum: number | string;
 }
 export interface IStacExtent {
-    spatial: IStacSpacialExtent;
+    spatial: IStacSpatialExtent;
     temporal: IStacTemporalExtent;
 }
 export interface IStacTemporalExtent {
     interval: Array<[string | null, string | null]>;
 }
-export interface IStacSpacialExtent {
+export interface IStacSpatialExtent {
     bbox: number[][];
 }
 export interface IStacProvider {
@@ -43,6 +47,14 @@ export interface IStacLink {
     type?: string;
     title?: string;
 }
+/**
+ * Extended STAC link with optional method and body for pagination.
+ * Used for pagination links that may include HTTP method and request body.
+ */
+export interface IStacPaginationLink extends IStacLink {
+    method?: string;
+    body?: IStacQueryBodyUnion;
+}
 export interface IStacAsset {
     href: string;
     title?: string;
@@ -91,7 +103,72 @@ export interface IStacSearchResult {
     stac_version: string;
     type: 'FeatureCollection';
 }
-export interface IStacQueryBody {
+/**
+ * Comparison operators for STAC filter conditions.
+ */
+export type Operator = '=' | '!=' | '<' | '<=' | '>' | '>=';
+/**
+ * CQL2-JSON filter condition structure for STAC Filter Extension queries.
+ * For datetime values, the second argument is wrapped in a timestamp object.
+ */
+export interface IStacFilterCondition {
+    op: Operator;
+    args: [{
+        property: string;
+    }, string | number | {
+        timestamp: string;
+    }];
+}
+export type FilterOperator = 'and' | 'or';
+/**
+ * CQL2-JSON filter structure for STAC Filter Extension queries.
+ */
+export interface IStacCql2Filter {
+    op: FilterOperator;
+    args: IStacFilterCondition[];
+}
+export interface IQueryableFilter {
+    operator: Operator;
+    inputValue: string | number | undefined;
+}
+export type UpdateSelectedQueryables = (qKey: string, filter: IQueryableFilter | null) => void;
+/**
+ * JSON Schema structure for STAC queryables.
+ * Based on the STAC Filter Extension queryables endpoint response.
+ * Different endpoints may have varying structures, so most fields are optional
+ * and we allow additional properties to accommodate variations.
+ */
+export interface IStacQueryableSchema {
+    type?: 'string' | 'number' | 'integer';
+    title?: string;
+    description?: string;
+    format?: string;
+    enum?: (string | number)[];
+    pattern?: string;
+    minLength?: number;
+    maximum?: number;
+    minimum?: number;
+    $ref?: string;
+    [key: string]: unknown;
+}
+/**
+ * Type for queryables array: array of [propertyName, schema] tuples.
+ */
+export type IStacQueryables = [string, IStacQueryableSchema][];
+/**
+ * Query body for STAC catalogs that support the Filter Extension (CQL2-JSON).
+ * Used for generic STAC searches with filter extension support.
+ */
+export interface IStacFilterExtensionQueryBody {
+    bbox: [number, number, number, number];
+    collections: string[];
+    datetime: string;
+    limit: number;
+    'filter-lang': 'cql2-json';
+    filter?: IStacCql2Filter;
+    token?: string;
+}
+export interface IStacGeodesQueryBody {
     bbox: [number, number, number, number];
     limit?: number;
     page?: number;
@@ -116,9 +193,15 @@ export interface IStacQueryBody {
         }
     ];
 }
+/**
+ * Union type for all STAC query body formats.
+ * Used in contexts that need to accept multiple query formats.
+ */
+export type IStacQueryBodyUnion = IStacGeodesQueryBody | IStacFilterExtensionQueryBody;
 export type StacFilterKey = 'collections' | 'datasets' | 'platforms' | 'products';
 export type StacFilterState = Record<StacFilterKey, Set<string>>;
 export type StacFilterStateStateDb = {
     [K in keyof StacFilterState]: string[];
 };
 export type StacFilterSetters = Record<StacFilterKey, (val: Set<string>) => void>;
+export type SetResultsFunction = (results: IStacItem[], totalResults: string, totalPages: number) => void;