@imtf/dms-core 1.0.0-beta.1

package/core/providers/Search/selectors.d.ts

@@ -0,0 +1,541 @@
+import { TreeViewState } from "../../../core/containers/TreeView/types";
+import { SupportedItem } from "../App/types";
+import { SearchState } from "./reducer";
+export declare const loadingSelector: ((state: any) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: SearchState) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: SearchState) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: any) => SearchState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").lruMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const errorSelector: ((state: any) => any) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: SearchState) => any;
+    memoizedResultFunc: ((resultFuncArgs_0: SearchState) => any) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => any;
+    dependencies: [(state: any) => SearchState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").lruMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const resultsSelector: ((state: any) => {
+    contextName: string | undefined;
+    count: number | null;
+    head: import("../../../core/containers/TreeView/types").TreeViewField[];
+    mask: import("../Definitions/types").SearchMask | null;
+    rows: import("../../../core/containers/TreeView/types").TableRow[];
+    hasUnknowCount: boolean;
+    timestamp: number | undefined;
+    capabilities: import("./types").SearchResultCapabilities;
+}) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: SearchState) => {
+        contextName: string | undefined;
+        count: number | null;
+        head: import("../../../core/containers/TreeView/types").TreeViewField[];
+        mask: import("../Definitions/types").SearchMask | null;
+        rows: import("../../../core/containers/TreeView/types").TableRow[];
+        hasUnknowCount: boolean;
+        timestamp: number | undefined;
+        capabilities: import("./types").SearchResultCapabilities;
+    };
+    memoizedResultFunc: ((resultFuncArgs_0: SearchState) => {
+        contextName: string | undefined;
+        count: number | null;
+        head: import("../../../core/containers/TreeView/types").TreeViewField[];
+        mask: import("../Definitions/types").SearchMask | null;
+        rows: import("../../../core/containers/TreeView/types").TableRow[];
+        hasUnknowCount: boolean;
+        timestamp: number | undefined;
+        capabilities: import("./types").SearchResultCapabilities;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        contextName: string | undefined;
+        count: number | null;
+        head: import("../../../core/containers/TreeView/types").TreeViewField[];
+        mask: import("../Definitions/types").SearchMask | null;
+        rows: import("../../../core/containers/TreeView/types").TableRow[];
+        hasUnknowCount: boolean;
+        timestamp: number | undefined;
+        capabilities: import("./types").SearchResultCapabilities;
+    };
+    dependencies: [(state: any) => SearchState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").lruMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const searchTriggeredSelector: ((state: any) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: SearchState) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: SearchState) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: any) => SearchState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").lruMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const createSearchResultsSelector: (identifier: string) => {
+    resultsWithMoreButtonSelector: ((state: any) => {
+        contextName: string | undefined;
+        count: number | null;
+        head: import("../../../core/containers/TreeView/types").TreeViewField[];
+        mask: import("../Definitions/types").SearchMask | null;
+        rows: import("../../../core/containers/TreeView/types").TableRow[];
+        hasUnknowCount: boolean;
+        timestamp: number | undefined;
+        capabilities: import("./types").SearchResultCapabilities;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: TreeViewState | undefined, resultFuncArgs_1: {
+            contextName: string | undefined;
+            count: number | null;
+            head: import("../../../core/containers/TreeView/types").TreeViewField[];
+            mask: import("../Definitions/types").SearchMask | null;
+            rows: import("../../../core/containers/TreeView/types").TableRow[];
+            hasUnknowCount: boolean;
+            timestamp: number | undefined;
+            capabilities: import("./types").SearchResultCapabilities;
+        }) => {
+            contextName: string | undefined;
+            count: number | null;
+            head: import("../../../core/containers/TreeView/types").TreeViewField[];
+            mask: import("../Definitions/types").SearchMask | null;
+            rows: import("../../../core/containers/TreeView/types").TableRow[];
+            hasUnknowCount: boolean;
+            timestamp: number | undefined;
+            capabilities: import("./types").SearchResultCapabilities;
+        };
+        memoizedResultFunc: ((resultFuncArgs_0: TreeViewState | undefined, resultFuncArgs_1: {
+            contextName: string | undefined;
+            count: number | null;
+            head: import("../../../core/containers/TreeView/types").TreeViewField[];
+            mask: import("../Definitions/types").SearchMask | null;
+            rows: import("../../../core/containers/TreeView/types").TableRow[];
+            hasUnknowCount: boolean;
+            timestamp: number | undefined;
+            capabilities: import("./types").SearchResultCapabilities;
+        }) => {
+            contextName: string | undefined;
+            count: number | null;
+            head: import("../../../core/containers/TreeView/types").TreeViewField[];
+            mask: import("../Definitions/types").SearchMask | null;
+            rows: import("../../../core/containers/TreeView/types").TableRow[];
+            hasUnknowCount: boolean;
+            timestamp: number | undefined;
+            capabilities: import("./types").SearchResultCapabilities;
+        }) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => {
+            contextName: string | undefined;
+            count: number | null;
+            head: import("../../../core/containers/TreeView/types").TreeViewField[];
+            mask: import("../Definitions/types").SearchMask | null;
+            rows: import("../../../core/containers/TreeView/types").TableRow[];
+            hasUnknowCount: boolean;
+            timestamp: number | undefined;
+            capabilities: import("./types").SearchResultCapabilities;
+        };
+        dependencies: [(state: any) => TreeViewState | undefined, ((state: any) => {
+            contextName: string | undefined;
+            count: number | null;
+            head: import("../../../core/containers/TreeView/types").TreeViewField[];
+            mask: import("../Definitions/types").SearchMask | null;
+            rows: import("../../../core/containers/TreeView/types").TableRow[];
+            hasUnknowCount: boolean;
+            timestamp: number | undefined;
+            capabilities: import("./types").SearchResultCapabilities;
+        }) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: SearchState) => {
+                contextName: string | undefined;
+                count: number | null;
+                head: import("../../../core/containers/TreeView/types").TreeViewField[];
+                mask: import("../Definitions/types").SearchMask | null;
+                rows: import("../../../core/containers/TreeView/types").TableRow[];
+                hasUnknowCount: boolean;
+                timestamp: number | undefined;
+                capabilities: import("./types").SearchResultCapabilities;
+            };
+            memoizedResultFunc: ((resultFuncArgs_0: SearchState) => {
+                contextName: string | undefined;
+                count: number | null;
+                head: import("../../../core/containers/TreeView/types").TreeViewField[];
+                mask: import("../Definitions/types").SearchMask | null;
+                rows: import("../../../core/containers/TreeView/types").TableRow[];
+                hasUnknowCount: boolean;
+                timestamp: number | undefined;
+                capabilities: import("./types").SearchResultCapabilities;
+            }) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => {
+                contextName: string | undefined;
+                count: number | null;
+                head: import("../../../core/containers/TreeView/types").TreeViewField[];
+                mask: import("../Definitions/types").SearchMask | null;
+                rows: import("../../../core/containers/TreeView/types").TableRow[];
+                hasUnknowCount: boolean;
+                timestamp: number | undefined;
+                capabilities: import("./types").SearchResultCapabilities;
+            };
+            dependencies: [(state: any) => SearchState];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            memoize: typeof import("reselect").lruMemoize;
+            argsMemoize: typeof import("reselect").weakMapMemoize;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import("reselect").lruMemoize;
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+    };
+};
+export declare const resultsSearchMaskSelector: ((state: any) => import("../Definitions/types").SearchMask | null) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        contextName: string | undefined;
+        count: number | null;
+        head: import("../../../core/containers/TreeView/types").TreeViewField[];
+        mask: import("../Definitions/types").SearchMask | null;
+        rows: import("../../../core/containers/TreeView/types").TableRow[];
+        hasUnknowCount: boolean;
+        timestamp: number | undefined;
+        capabilities: import("./types").SearchResultCapabilities;
+    }) => import("../Definitions/types").SearchMask | null;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        contextName: string | undefined;
+        count: number | null;
+        head: import("../../../core/containers/TreeView/types").TreeViewField[];
+        mask: import("../Definitions/types").SearchMask | null;
+        rows: import("../../../core/containers/TreeView/types").TableRow[];
+        hasUnknowCount: boolean;
+        timestamp: number | undefined;
+        capabilities: import("./types").SearchResultCapabilities;
+    }) => import("../Definitions/types").SearchMask | null) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("../Definitions/types").SearchMask | null;
+    dependencies: [((state: any) => {
+        contextName: string | undefined;
+        count: number | null;
+        head: import("../../../core/containers/TreeView/types").TreeViewField[];
+        mask: import("../Definitions/types").SearchMask | null;
+        rows: import("../../../core/containers/TreeView/types").TableRow[];
+        hasUnknowCount: boolean;
+        timestamp: number | undefined;
+        capabilities: import("./types").SearchResultCapabilities;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: SearchState) => {
+            contextName: string | undefined;
+            count: number | null;
+            head: import("../../../core/containers/TreeView/types").TreeViewField[];
+            mask: import("../Definitions/types").SearchMask | null;
+            rows: import("../../../core/containers/TreeView/types").TableRow[];
+            hasUnknowCount: boolean;
+            timestamp: number | undefined;
+            capabilities: import("./types").SearchResultCapabilities;
+        };
+        memoizedResultFunc: ((resultFuncArgs_0: SearchState) => {
+            contextName: string | undefined;
+            count: number | null;
+            head: import("../../../core/containers/TreeView/types").TreeViewField[];
+            mask: import("../Definitions/types").SearchMask | null;
+            rows: import("../../../core/containers/TreeView/types").TableRow[];
+            hasUnknowCount: boolean;
+            timestamp: number | undefined;
+            capabilities: import("./types").SearchResultCapabilities;
+        }) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => {
+            contextName: string | undefined;
+            count: number | null;
+            head: import("../../../core/containers/TreeView/types").TreeViewField[];
+            mask: import("../Definitions/types").SearchMask | null;
+            rows: import("../../../core/containers/TreeView/types").TableRow[];
+            hasUnknowCount: boolean;
+            timestamp: number | undefined;
+            capabilities: import("./types").SearchResultCapabilities;
+        };
+        dependencies: [(state: any) => SearchState];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import("reselect").lruMemoize;
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").lruMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const resultsSearchHasUnknowCountSelector: ((state: any) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        contextName: string | undefined;
+        count: number | null;
+        head: import("../../../core/containers/TreeView/types").TreeViewField[];
+        mask: import("../Definitions/types").SearchMask | null;
+        rows: import("../../../core/containers/TreeView/types").TableRow[];
+        hasUnknowCount: boolean;
+        timestamp: number | undefined;
+        capabilities: import("./types").SearchResultCapabilities;
+    }) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        contextName: string | undefined;
+        count: number | null;
+        head: import("../../../core/containers/TreeView/types").TreeViewField[];
+        mask: import("../Definitions/types").SearchMask | null;
+        rows: import("../../../core/containers/TreeView/types").TableRow[];
+        hasUnknowCount: boolean;
+        timestamp: number | undefined;
+        capabilities: import("./types").SearchResultCapabilities;
+    }) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [((state: any) => {
+        contextName: string | undefined;
+        count: number | null;
+        head: import("../../../core/containers/TreeView/types").TreeViewField[];
+        mask: import("../Definitions/types").SearchMask | null;
+        rows: import("../../../core/containers/TreeView/types").TableRow[];
+        hasUnknowCount: boolean;
+        timestamp: number | undefined;
+        capabilities: import("./types").SearchResultCapabilities;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: SearchState) => {
+            contextName: string | undefined;
+            count: number | null;
+            head: import("../../../core/containers/TreeView/types").TreeViewField[];
+            mask: import("../Definitions/types").SearchMask | null;
+            rows: import("../../../core/containers/TreeView/types").TableRow[];
+            hasUnknowCount: boolean;
+            timestamp: number | undefined;
+            capabilities: import("./types").SearchResultCapabilities;
+        };
+        memoizedResultFunc: ((resultFuncArgs_0: SearchState) => {
+            contextName: string | undefined;
+            count: number | null;
+            head: import("../../../core/containers/TreeView/types").TreeViewField[];
+            mask: import("../Definitions/types").SearchMask | null;
+            rows: import("../../../core/containers/TreeView/types").TableRow[];
+            hasUnknowCount: boolean;
+            timestamp: number | undefined;
+            capabilities: import("./types").SearchResultCapabilities;
+        }) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => {
+            contextName: string | undefined;
+            count: number | null;
+            head: import("../../../core/containers/TreeView/types").TreeViewField[];
+            mask: import("../Definitions/types").SearchMask | null;
+            rows: import("../../../core/containers/TreeView/types").TableRow[];
+            hasUnknowCount: boolean;
+            timestamp: number | undefined;
+            capabilities: import("./types").SearchResultCapabilities;
+        };
+        dependencies: [(state: any) => SearchState];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import("reselect").lruMemoize;
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").lruMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const createSelectedItemsSelector: (identifier: string) => ((state: any) => SupportedItem[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: TreeViewState | undefined, resultFuncArgs_1: {
+        contextName: string | undefined;
+        count: number | null;
+        head: import("../../../core/containers/TreeView/types").TreeViewField[];
+        mask: import("../Definitions/types").SearchMask | null;
+        rows: import("../../../core/containers/TreeView/types").TableRow[];
+        hasUnknowCount: boolean;
+        timestamp: number | undefined;
+        capabilities: import("./types").SearchResultCapabilities;
+    }) => SupportedItem[];
+    memoizedResultFunc: ((resultFuncArgs_0: TreeViewState | undefined, resultFuncArgs_1: {
+        contextName: string | undefined;
+        count: number | null;
+        head: import("../../../core/containers/TreeView/types").TreeViewField[];
+        mask: import("../Definitions/types").SearchMask | null;
+        rows: import("../../../core/containers/TreeView/types").TableRow[];
+        hasUnknowCount: boolean;
+        timestamp: number | undefined;
+        capabilities: import("./types").SearchResultCapabilities;
+    }) => SupportedItem[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => SupportedItem[];
+    dependencies: [(state: any) => TreeViewState | undefined, ((state: any) => {
+        contextName: string | undefined;
+        count: number | null;
+        head: import("../../../core/containers/TreeView/types").TreeViewField[];
+        mask: import("../Definitions/types").SearchMask | null;
+        rows: import("../../../core/containers/TreeView/types").TableRow[];
+        hasUnknowCount: boolean;
+        timestamp: number | undefined;
+        capabilities: import("./types").SearchResultCapabilities;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: SearchState) => {
+            contextName: string | undefined;
+            count: number | null;
+            head: import("../../../core/containers/TreeView/types").TreeViewField[];
+            mask: import("../Definitions/types").SearchMask | null;
+            rows: import("../../../core/containers/TreeView/types").TableRow[];
+            hasUnknowCount: boolean;
+            timestamp: number | undefined;
+            capabilities: import("./types").SearchResultCapabilities;
+        };
+        memoizedResultFunc: ((resultFuncArgs_0: SearchState) => {
+            contextName: string | undefined;
+            count: number | null;
+            head: import("../../../core/containers/TreeView/types").TreeViewField[];
+            mask: import("../Definitions/types").SearchMask | null;
+            rows: import("../../../core/containers/TreeView/types").TableRow[];
+            hasUnknowCount: boolean;
+            timestamp: number | undefined;
+            capabilities: import("./types").SearchResultCapabilities;
+        }) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => {
+            contextName: string | undefined;
+            count: number | null;
+            head: import("../../../core/containers/TreeView/types").TreeViewField[];
+            mask: import("../Definitions/types").SearchMask | null;
+            rows: import("../../../core/containers/TreeView/types").TableRow[];
+            hasUnknowCount: boolean;
+            timestamp: number | undefined;
+            capabilities: import("./types").SearchResultCapabilities;
+        };
+        dependencies: [(state: any) => SearchState];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import("reselect").lruMemoize;
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").lruMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};

package/core/providers/Search/service.d.ts

@@ -0,0 +1,9 @@
+import { RawSearchResults, SearchResult } from "./types";
+export declare const paths: Readonly<{
+    readonly search: (params?: {} | undefined) => string;
+    readonly exportCSV: (params?: {} | undefined) => string;
+    readonly rawSearch: (params?: {} | undefined) => string;
+}>;
+export declare function search(query: Record<string, unknown>, params?: Record<string, unknown>): Promise<SearchResult>;
+export declare function exportResults(query: Record<string, unknown>, params: Record<string, unknown>): Promise<import("axios").AxiosResponse<any, any>>;
+export declare function rawSearch<HitItem>(query: Record<string, unknown>, params?: Record<string, unknown>): Promise<RawSearchResults<HitItem>>;

package/core/providers/Search/types.d.ts

@@ -0,0 +1,100 @@
+import type { Row } from "../../../core/components/TreeView/types";
+import type { TableRow, TreeViewField } from "../../../core/containers/TreeView/types";
+import { SearchMask } from "../Definitions/types";
+import { InodeRefList, InodeType, ProcessState } from "../Inodes/types";
+export type ValueField = {
+    kind: "dms-indexation.search.ValueField";
+    name: string;
+    value: string | number | boolean;
+};
+export type RawSearchResults<HitItem> = {
+    kind: "dms-indexation.search.SearchResponse";
+    facet: {
+        kind: "dms-indexation.search.Facet";
+        facetFields: unknown[];
+        facetIntervals: unknown[];
+    };
+    header: {
+        kind: "dms-indexation.search.Header";
+        count: number;
+        queryTime: number;
+    };
+    hits: Array<{
+        kind: "dms-indexation.search.Hit";
+        item: HitItem;
+        status: "valid" | string;
+        valueFields: ValueField[];
+    }>;
+};
+export type Field = {
+    name: string;
+    hidden?: boolean;
+};
+export type SearchResultCapabilities = {
+    canDownloadSearchResult: boolean;
+};
+export type SearchResult = {
+    kind: "dms-core.ui.Search";
+    count: number;
+    searchMaskResource: SearchMask;
+    tableResource: {
+        kind: "dms-core.ui.Table";
+        rows: TableRow[];
+        head: TreeViewField[];
+    };
+    capabilities: SearchResultCapabilities;
+};
+export type Option = {
+    value: string;
+    label: string;
+    count: number;
+};
+export type Component = {
+    kind: string;
+    name: string;
+    label: string;
+    disabled: boolean;
+    required: boolean;
+    hidden: boolean;
+    width: number;
+    tooltipText: string;
+    multiple: boolean;
+    show_undefined: boolean;
+    options: Option[];
+    customOption: boolean;
+    key?: string;
+    valueFormat?: string;
+    components?: Component[];
+    datasourceName?: string;
+};
+export type QueryParams = {
+    searchContextName: string;
+    searchParams?: URLSearchParams;
+    queryResource?: Record<string, any>;
+    limit: number;
+    offset: number;
+    rootOid?: string;
+    highlight?: SearchMask["defaultHighlight"];
+};
+export type SearchResultRowCell = {
+    kind: "dms-core.ui.ItemTableCell" | "dms-core.ui.StringTableCell";
+    value: string;
+} | {
+    kind: "dms-core.ui.LongTableCell" | "dms-core.ui.DoubleTableCell";
+    value: number;
+} | {
+    kind: "dms-core.ui.TypeTableCell";
+    value: InodeType;
+} | {
+    kind: "dms-core.ui.PathTableCell";
+    value: InodeRefList;
+} | {
+    kind: "dms-core.ui.ProcessStateTableCell";
+    value: ProcessState;
+};
+export type SearchResultRow = {
+    cells: SearchResultRowCell[];
+    highlights: string[];
+    kind: "dms-core.ui.TableRow";
+    status: "valid" | string;
+} & Row;

package/core/providers/Search/utils/common.d.ts

@@ -0,0 +1,7 @@
+import { Field } from "../types";
+export declare const getOrderingClause: (queryParams?: URLSearchParams) => {
+    kind: string;
+    field: string;
+    direction: string;
+}[] | undefined;
+export declare function orderAndFilterCells(originalFields: Field[], fields: Field[], cells: Field[]): Field[];