@cccsaurora/howler-ui 2.14.0-dev.257 → 2.14.0-dev.263

package/components/app/providers/FieldProvider.d.ts

@@ -0,0 +1,9 @@
+import { SearchField } from '@cccsaurora/howler-ui/api/search/fields';
+import { FC, PropsWithChildren } from 'react';
+interface FieldProviderType {
+    hitFields: SearchField[];
+    getHitFields: () => Promise<SearchField[]>;
+}
+export declare const FieldContext: import('react').Context<FieldProviderType>;
+declare const FieldProvider: FC<PropsWithChildren>;
+export default FieldProvider;

package/components/app/providers/FieldProvider.js

@@ -0,0 +1,22 @@
+import { jsx } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react@18.3.1/node_modules/react/jsx-runtime.js";
+import { a as api } from "../../../index-BPPnUdfP.js";
+import useMyApi from "../../hooks/useMyApi.js";
+import { createContext, useState, useCallback } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react@18.3.1/node_modules/react/index.js";
+const FieldContext = createContext(null);
+const FieldProvider = ({ children }) => {
+  const { dispatchApi } = useMyApi();
+  const [hitFields, setHitFields] = useState([]);
+  const getHitFields = useCallback(async () => {
+    if (hitFields.length) {
+      return hitFields;
+    }
+    const fields = await dispatchApi(api.search.fields.hit.get());
+    setHitFields(fields);
+    return fields;
+  }, [dispatchApi, hitFields]);
+  return /* @__PURE__ */ jsx(FieldContext.Provider, { value: { hitFields, getHitFields }, children });
+};
+export {
+  FieldContext,
+  FieldProvider as default
+};

package/components/app/providers/HitProvider.d.ts

@@ -0,0 +1,22 @@
+import { Hit } from '@cccsaurora/howler-ui/models/entities/generated/Hit';
+import { WithMetadata } from '@cccsaurora/howler-ui/models/WithMetadata';
+import { FC, PropsWithChildren } from 'react';
+interface HitProviderType {
+    hits: {
+        [index: string]: Hit;
+    };
+    selectedHits: Hit[];
+    addHitToSelection: (id: string) => void;
+    removeHitFromSelection: (id: string) => void;
+    clearSelectedHits: (except?: string) => void;
+    loadHits: (hits: Hit[]) => void;
+    updateHit: (newHit: Hit) => void;
+    getHit: (id: string, force?: boolean) => Promise<WithMetadata<Hit>>;
+}
+export declare const HitContext: import('use-context-selector').Context<HitProviderType>;
+/**
+ * Central repository for storing individual hit data across the application. Allows efficient retrieval of hits across componenents.
+ */
+declare const HitProvider: FC<PropsWithChildren>;
+export declare const useHitContextSelector: <Selected>(selector: (value: HitProviderType) => Selected) => Selected;
+export default HitProvider;

package/components/app/providers/HitProvider.js

@@ -0,0 +1,103 @@
+import { jsx } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react@18.3.1/node_modules/react/jsx-runtime.js";
+import { a as api } from "../../../index-BPPnUdfP.js";
+import useMyApi from "../../hooks/useMyApi.js";
+import { uniq } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/lodash.js";
+import { useContext, useRef, useState, useMemo, useEffect, useCallback } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react@18.3.1/node_modules/react/index.js";
+import { createContext, useContextSelector } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/use-context-selector@2.0.0_react@18.3.1_scheduler@0.23.2/node_modules/use-context-selector/dist/index.js";
+import { SocketContext } from "./SocketProvider.js";
+const HitContext = createContext(null);
+const HitProvider = ({ children }) => {
+  const { dispatchApi } = useMyApi();
+  const { addListener, removeListener } = useContext(SocketContext);
+  const hitRequests = useRef({});
+  const [hits, setHits] = useState({});
+  const [selectedHitIds, setSelectedHitIds] = useState([]);
+  const handler = useMemo(
+    () => (data) => {
+      if (data.hit) {
+        console.debug("Received websocket update for hit", data.hit.howler.id);
+        hitRequests.current[data.hit.howler.id] = Promise.resolve(data.hit);
+        setHits((_hits) => ({
+          ..._hits,
+          [data.hit.howler.id]: {
+            ..._hits[data.hit.howler.id],
+            ...data.hit
+          }
+        }));
+      }
+    },
+    []
+  );
+  useEffect(() => {
+    addListener("hit_provider", handler);
+    return () => removeListener("hit_provider");
+  }, [addListener, handler, removeListener]);
+  const getHit = useCallback(
+    async (id, force = false) => {
+      if (!hitRequests.current[id] || force) {
+        hitRequests.current[id] = dispatchApi(api.hit.get(id, ["template", "dossiers", "analytic", "overview"]));
+        const newHit = await hitRequests.current[id];
+        setHits((_hits) => ({ ..._hits, [id]: newHit }));
+      }
+      return hitRequests.current[id];
+    },
+    [dispatchApi]
+  );
+  const updateHit = useCallback((newHit) => {
+    hitRequests.current[newHit.howler.id] = Promise.resolve(newHit);
+    setHits((_hits) => ({ ..._hits, [newHit.howler.id]: newHit }));
+  }, []);
+  const loadHits = useCallback((newHits) => {
+    const mappedHits = newHits.map((hit) => [hit.howler.id, hit]);
+    mappedHits.forEach(([id, hit]) => {
+      hitRequests.current[id] = Promise.resolve(hit);
+    });
+    setHits((_hits) => ({ ..._hits, ...Object.fromEntries(mappedHits) }));
+  }, []);
+  const addHitToSelection = useCallback((id) => {
+    setSelectedHitIds((_selected) => uniq([..._selected, id]));
+  }, []);
+  const removeHitFromSelection = useCallback((id) => {
+    setSelectedHitIds((_selected) => _selected.filter((_id) => _id !== id));
+  }, []);
+  const clearSelectedHits = useCallback((except) => {
+    setSelectedHitIds(!!except ? [except] : []);
+  }, []);
+  const selectedHits = useMemo(() => selectedHitIds.map((id) => hits[id]).filter((hit) => !!hit), [hits, selectedHitIds]);
+  useEffect(() => {
+    selectedHitIds.forEach((id) => {
+      if (!hitRequests.current[id]) {
+        getHit(id);
+      }
+    });
+  }, [getHit, selectedHitIds]);
+  useEffect(() => {
+    Object.entries(hits).forEach(([id, hit]) => {
+      hitRequests.current[id] = Promise.resolve(hit);
+    });
+  }, [hits]);
+  return /* @__PURE__ */ jsx(
+    HitContext.Provider,
+    {
+      value: {
+        hits,
+        getHit,
+        updateHit,
+        selectedHits,
+        addHitToSelection,
+        removeHitFromSelection,
+        clearSelectedHits,
+        loadHits
+      },
+      children
+    }
+  );
+};
+const useHitContextSelector = (selector) => {
+  return useContextSelector(HitContext, selector);
+};
+export {
+  HitContext,
+  HitProvider as default,
+  useHitContextSelector
+};

package/components/app/providers/HitSearchProvider.d.ts

@@ -0,0 +1,27 @@
+import { HowlerSearchResponse } from '@cccsaurora/howler-ui/api/search';
+import { HitLayout } from '@cccsaurora/howler-ui/components/elements/hit/HitLayout';
+import { Hit } from '@cccsaurora/howler-ui/models/entities/generated/Hit';
+import { WithMetadata } from '@cccsaurora/howler-ui/models/WithMetadata';
+import { Dispatch, FC, PropsWithChildren, SetStateAction } from 'react';
+export interface QueryEntry {
+    [query: string]: string;
+}
+interface HitSearchProviderType {
+    layout: HitLayout;
+    displayType: 'list' | 'grid';
+    searching: boolean;
+    error: string | null;
+    response: HowlerSearchResponse<WithMetadata<Hit>> | null;
+    viewId: string | null;
+    bundleId: string | null;
+    queryHistory: QueryEntry;
+    fzfSearch: boolean;
+    setDisplayType: (type: 'list' | 'grid') => void;
+    setQueryHistory: Dispatch<SetStateAction<QueryEntry>>;
+    setFzfSearch: Dispatch<SetStateAction<boolean>>;
+    search: (query: string, appendResults?: boolean) => void;
+}
+export declare const HitSearchContext: import('use-context-selector').Context<HitSearchProviderType>;
+declare const HitSearchProvider: FC<PropsWithChildren>;
+export declare const useHitSearchContextSelector: <Selected>(selector: (value: HitSearchProviderType) => Selected) => Selected;
+export default HitSearchProvider;

package/components/app/providers/HitSearchProvider.js

@@ -0,0 +1,188 @@
+import { jsx } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react@18.3.1/node_modules/react/jsx-runtime.js";
+import { a as api } from "../../../index-BPPnUdfP.js";
+import { HitLayout } from "../../elements/hit/HitLayout.js";
+import useMyApi from "../../hooks/useMyApi.js";
+import useMyLocalStorage, { useMyLocalStorageItem } from "../../hooks/useMyLocalStorage.js";
+import i18nInstance from "../../../i18n.js";
+import isNull from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isNull.js";
+import isUndefined from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isUndefined.js";
+import { useState, useMemo, useCallback, useEffect } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react@18.3.1/node_modules/react/index.js";
+import { isMobile } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react-device-detect@2.2.3_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/react-device-detect/dist/lib.js";
+import { useParams, useLocation } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react-router-dom@6.30.1_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/react-router-dom/dist/index.js";
+import { createContext, useContextSelector } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/use-context-selector@2.0.0_react@18.3.1_scheduler@0.23.2/node_modules/use-context-selector/dist/index.js";
+import { StorageKey } from "../../../utils/constants.js";
+import { getStored } from "../../../utils/localStorage.js";
+import Throttler from "../../../utils/Throttler.js";
+import { convertDateToLucene, convertCustomDateRangeToLucene } from "../../../utils/utils.js";
+import { HitContext } from "./HitProvider.js";
+import { ParameterContext } from "./ParameterProvider.js";
+import { ViewContext } from "./ViewProvider.js";
+const HitSearchContext = createContext(null);
+const THROTTLER = new Throttler(500);
+const HitSearchProvider = ({ children }) => {
+  const { get } = useMyLocalStorage();
+  const routeParams = useParams();
+  const location = useLocation();
+  const { dispatchApi } = useMyApi();
+  const pageCount = useMyLocalStorageItem(StorageKey.PAGE_COUNT, 25)[0];
+  const getCurrentView = useContextSelector(ViewContext, (ctx) => ctx.getCurrentView);
+  const defaultView = useContextSelector(ViewContext, (ctx) => ctx.defaultView);
+  const query = useContextSelector(ParameterContext, (ctx) => ctx.query);
+  const setQuery = useContextSelector(ParameterContext, (ctx) => ctx.setQuery);
+  const offset = useContextSelector(ParameterContext, (ctx) => ctx.offset);
+  const setOffset = useContextSelector(ParameterContext, (ctx) => ctx.setOffset);
+  const trackTotalHits = useContextSelector(ParameterContext, (ctx) => ctx.trackTotalHits);
+  const sort = useContextSelector(ParameterContext, (ctx) => ctx.sort);
+  const span = useContextSelector(ParameterContext, (ctx) => ctx.span);
+  const filter = useContextSelector(ParameterContext, (ctx) => ctx.filter);
+  const startDate = useContextSelector(ParameterContext, (ctx) => ctx.startDate);
+  const endDate = useContextSelector(ParameterContext, (ctx) => ctx.endDate);
+  const loadHits = useContextSelector(HitContext, (ctx) => ctx.loadHits);
+  const [displayType, setDisplayType] = useState(getStored(StorageKey.DISPLAY_TYPE) ?? "list");
+  const [searching, setSearching] = useState(false);
+  const [error, setError] = useState(null);
+  const [response, setResponse] = useState();
+  const [queryHistory, setQueryHistory] = useState(
+    JSON.parse(get(StorageKey.QUERY_HISTORY)) || { "howler.id: *": (/* @__PURE__ */ new Date()).toISOString() }
+  );
+  const [fzfSearch, setFzfSearch] = useState(false);
+  const viewId = useMemo(
+    () => (location.pathname.startsWith("/views") ? routeParams.id : defaultView) ?? null,
+    [defaultView, location.pathname, routeParams.id]
+  );
+  const bundleId = useMemo(
+    () => location.pathname.startsWith("/bundles") ? routeParams.id : null,
+    [location.pathname, routeParams.id]
+  );
+  const layout = useMemo(
+    () => isMobile ? HitLayout.COMFY : get(StorageKey.HIT_LAYOUT) ?? HitLayout.NORMAL,
+    [get]
+  );
+  const search = useCallback(
+    async (_query, appendResults) => {
+      THROTTLER.debounce(async () => {
+        var _a;
+        if (_query === "woof!") {
+          i18nInstance.changeLanguage("woof");
+          return;
+        }
+        if (isNull(sort) || isNull(span)) {
+          return;
+        }
+        if (!isNull(_query) && !isUndefined(_query) && _query !== query) {
+          setQuery(_query);
+        }
+        setSearching(true);
+        setError(null);
+        const filters = [];
+        if (span && !span.endsWith("custom")) {
+          filters.push(`event.created:${convertDateToLucene(span)}`);
+        } else if (startDate && endDate) {
+          filters.push(`event.created:${convertCustomDateRangeToLucene(startDate, endDate)}`);
+        }
+        if (filter) {
+          filters.push(filter);
+        }
+        try {
+          const bundle = location.pathname.startsWith("/bundles") && routeParams.id;
+          let fullQuery = _query || "howler.id:*";
+          if (bundle) {
+            fullQuery = `(howler.bundles:${bundle}) AND (${fullQuery})`;
+          } else if (viewId) {
+            fullQuery = `(${((_a = await getCurrentView({ viewId })) == null ? void 0 : _a.query) || "howler.id:*"}) AND (${fullQuery})`;
+          }
+          const _response = await dispatchApi(
+            api.search.hit.post({
+              offset: appendResults ? response.rows : offset,
+              rows: pageCount,
+              query: fullQuery,
+              sort,
+              filters,
+              track_total_hits: trackTotalHits,
+              metadata: ["template", "overview", "analytic"]
+            }),
+            { showError: false, throwError: true }
+          );
+          if (_response.total < offset) {
+            setOffset(0);
+          }
+          loadHits(_response.items);
+          if (!appendResults) {
+            setResponse(_response);
+          } else {
+            setResponse((_existingResponse) => ({
+              ..._response,
+              offset: _existingResponse.offset,
+              rows: Math.min(_existingResponse.rows + _response.rows, _response.total),
+              items: [..._existingResponse.items, ..._response.items]
+            }));
+          }
+        } catch (e) {
+          setError(e.message);
+        } finally {
+          setSearching(false);
+        }
+      });
+    },
+    // We skip reloading when the response changes
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      sort,
+      span,
+      query,
+      startDate,
+      endDate,
+      filter,
+      setQuery,
+      location.pathname,
+      routeParams.id,
+      viewId,
+      dispatchApi,
+      offset,
+      pageCount,
+      trackTotalHits,
+      loadHits,
+      getCurrentView,
+      setOffset
+    ]
+  );
+  useEffect(() => {
+    if (span.endsWith("custom") && (!startDate || !endDate)) {
+      return;
+    }
+    if (viewId || bundleId || query && query !== "howler.id:*" || offset > 0) {
+      search(query);
+    } else {
+      setResponse(null);
+    }
+  }, [filter, offset, pageCount, sort, span, bundleId, location.pathname, startDate, endDate, viewId]);
+  return /* @__PURE__ */ jsx(
+    HitSearchContext.Provider,
+    {
+      value: {
+        layout,
+        displayType,
+        setDisplayType,
+        search,
+        searching,
+        error,
+        response,
+        viewId,
+        bundleId,
+        setQueryHistory,
+        queryHistory,
+        fzfSearch,
+        setFzfSearch
+      },
+      children
+    }
+  );
+};
+const useHitSearchContextSelector = (selector) => {
+  return useContextSelector(HitSearchContext, selector);
+};
+export {
+  HitSearchContext,
+  HitSearchProvider as default,
+  useHitSearchContextSelector
+};

package/components/app/providers/LocalStorageProvider.d.ts

@@ -0,0 +1,13 @@
+import { FC, PropsWithChildren } from 'react';
+import { StorageKey } from '@cccsaurora/howler-ui/utils/constants';
+type ValuesType = {
+    [K in StorageKey]?: any;
+};
+export interface LocalStorageContextType {
+    set: <T>(key: string, value: T) => void;
+    values: ValuesType;
+    remove: (key: string) => void;
+}
+export declare const LocalStorageContext: import('react').Context<LocalStorageContextType>;
+declare const LocalStorageProvider: FC<PropsWithChildren>;
+export default LocalStorageProvider;

package/components/app/providers/LocalStorageProvider.js

@@ -0,0 +1,49 @@
+import { jsx } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react@18.3.1/node_modules/react/jsx-runtime.js";
+import useLocalStorage from "../../../commons/components/utils/hooks/useLocalStorage.js";
+import { createContext, useState, useEffect, useCallback } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react@18.3.1/node_modules/react/index.js";
+import { MY_LOCAL_STORAGE_PREFIX, StorageKey } from "../../../utils/constants.js";
+const LocalStorageContext = createContext(null);
+const LocalStorageProvider = ({ children }) => {
+  const { get: getStored, set: setStored, remove: removeStored } = useLocalStorage(MY_LOCAL_STORAGE_PREFIX);
+  const [values, setValues] = useState({});
+  useEffect(() => {
+    const newData = {};
+    for (const key in StorageKey) {
+      if (!values[StorageKey[key]]) {
+        newData[StorageKey[key]] = getStored(StorageKey[key]);
+      }
+    }
+    setValues((current) => {
+      return {
+        ...current,
+        ...newData
+      };
+    });
+  }, [getStored]);
+  const set = useCallback(
+    (key, value) => {
+      setStored(key, value);
+      setValues((current) => ({
+        ...current,
+        [key]: value
+      }));
+    },
+    [setStored]
+  );
+  const remove = useCallback(
+    (key) => {
+      removeStored(key);
+      setValues((current) => {
+        const copy = { ...current };
+        delete copy[key];
+        return copy;
+      });
+    },
+    [removeStored]
+  );
+  return /* @__PURE__ */ jsx(LocalStorageContext.Provider, { value: { values, set, remove }, children });
+};
+export {
+  LocalStorageContext,
+  LocalStorageProvider as default
+};

package/components/app/providers/ModalProvider.d.ts

@@ -0,0 +1,16 @@
+import { FC, PropsWithChildren, ReactNode } from 'react';
+export interface ModalOptions {
+    disableClose?: boolean;
+    maxWidth?: string;
+    maxHeight?: string;
+}
+interface ModalContextType {
+    showModal: (children: ReactNode, options?: ModalOptions) => () => void;
+    content?: ReactNode;
+    setContent: (children: ReactNode) => void;
+    options?: ModalOptions;
+    close: () => void;
+}
+export declare const ModalContext: import('react').Context<ModalContextType>;
+declare const ModalProvider: FC<PropsWithChildren>;
+export default ModalProvider;

package/components/app/providers/ModalProvider.js

@@ -0,0 +1,34 @@
+import { jsx } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react@18.3.1/node_modules/react/jsx-runtime.js";
+import { createContext, useState, useEffect, useCallback } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react@18.3.1/node_modules/react/index.js";
+const defaultOptions = {
+  disableClose: false
+};
+const ModalContext = createContext(null);
+const ModalProvider = ({ children }) => {
+  const [content, setContent] = useState(null);
+  const [options, setOptions] = useState(defaultOptions);
+  useEffect(() => {
+    if (!content) {
+      setOptions(defaultOptions);
+    }
+  }, [content]);
+  const showModal = useCallback(
+    (_children, newOptions) => {
+      setContent(_children);
+      if (options) {
+        setOptions({
+          ...options,
+          ...newOptions
+        });
+      }
+      return () => setContent(null);
+    },
+    [options]
+  );
+  const close = useCallback(() => setContent(null), []);
+  return /* @__PURE__ */ jsx(ModalContext.Provider, { value: { showModal, content, setContent, options, close }, children });
+};
+export {
+  ModalContext,
+  ModalProvider as default
+};

package/components/app/providers/OverviewProvider.d.ts

@@ -0,0 +1,13 @@
+import { Hit } from '@cccsaurora/howler-ui/models/entities/generated/Hit';
+import { Overview } from '@cccsaurora/howler-ui/models/entities/generated/Overview';
+import { FC, PropsWithChildren } from 'react';
+interface OverviewContextType {
+    overviews: Overview[];
+    getOverviews: (force?: boolean) => Promise<Overview[]>;
+    getMatchingOverview: (h: Hit) => Overview;
+    refresh: () => void;
+    loaded: boolean;
+}
+export declare const OverviewContext: import('react').Context<OverviewContextType>;
+declare const OverviewProvider: FC<PropsWithChildren>;
+export default OverviewProvider;

package/components/app/providers/OverviewProvider.js

@@ -0,0 +1,68 @@
+import { jsx } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react@18.3.1/node_modules/react/jsx-runtime.js";
+import { a as api } from "../../../index-BPPnUdfP.js";
+import { createContext, useState, useCallback } from "/home/runner/work/howler/howler/ui/node_modules/.pnpm/react@18.3.1/node_modules/react/index.js";
+const OverviewContext = createContext(null);
+const OverviewProvider = ({ children }) => {
+  const [fetching, setFetching] = useState(false);
+  const [loaded, setLoaded] = useState(false);
+  const [overviews, setOverviews] = useState([]);
+  const getOverviews = useCallback(
+    async (force = false) => {
+      if (loaded && !force || fetching) {
+        return overviews;
+      } else {
+        try {
+          setFetching(true);
+          const result = await api.overview.get();
+          setOverviews(result);
+          setLoaded(true);
+          return result;
+        } finally {
+          setFetching(false);
+        }
+      }
+    },
+    [fetching, loaded, overviews]
+  );
+  const getMatchingOverview = useCallback(
+    (hit) => hit && overviews.filter(
+      (_overview) => {
+        var _a;
+        return (
+          // The analytic must match, and the detection must either a) not exist or b) match the hit
+          _overview.analytic === hit.howler.analytic && (!_overview.detection || _overview.detection.toLowerCase() === ((_a = hit.howler.detection) == null ? void 0 : _a.toLowerCase()))
+        );
+      }
+    ).sort((a, b) => {
+      if (a.detection && !b.detection) {
+        return -1;
+      } else if (!a.detection && b.detection) {
+        return 1;
+      } else {
+        return 0;
+      }
+    })[0],
+    [overviews]
+  );
+  const refresh = useCallback(() => {
+    setLoaded(false);
+    getOverviews();
+  }, []);
+  return /* @__PURE__ */ jsx(
+    OverviewContext.Provider,
+    {
+      value: {
+        overviews,
+        getOverviews,
+        getMatchingOverview,
+        refresh,
+        loaded
+      },
+      children
+    }
+  );
+};
+export {
+  OverviewContext,
+  OverviewProvider as default
+};

package/components/app/providers/ParameterProvider.d.ts

@@ -0,0 +1,26 @@
+import { FC, PropsWithChildren } from 'react';
+interface ParameterProviderType {
+    selected?: string;
+    query?: string;
+    offset: number;
+    trackTotalHits: boolean;
+    sort?: string;
+    span?: string;
+    filter?: string;
+    startDate?: string;
+    endDate?: string;
+    setSelected: (id: string) => void;
+    setQuery: (id: string) => void;
+    setOffset: (offset: string | number) => void;
+    setSort: (sort: string) => void;
+    setSpan: (span: string) => void;
+    setFilter: (filter: string) => void;
+    setCustomSpan: (startDate: string, endDate: string) => void;
+}
+export declare const ParameterContext: import('use-context-selector').Context<ParameterProviderType>;
+/**
+ * Context responsible for tracking updates to query operations in hit and view search.
+ */
+declare const ParameterProvider: FC<PropsWithChildren>;
+export declare const useParameterContextSelector: <Selected>(selector: (value: ParameterProviderType) => Selected) => Selected;
+export default ParameterProvider;