@hestia-earth/ui-components 0.0.1

package/node/node-logs-file/node-logs-file.component.d.ts

@@ -0,0 +1,31 @@
+import { OnInit } from '@angular/core';
+import { DomSanitizer, SafeResourceUrl } from '@angular/platform-browser';
+import { Observable } from 'rxjs';
+import { DataState } from '@hestia-earth/api';
+import { JSONLD, NodeType } from '@hestia-earth/schema';
+import { HeNodeService } from '../node.service';
+import { ILine, Level } from '../../common/logs-utils';
+import * as i0 from "@angular/core";
+export declare class NodeLogsFileComponent implements OnInit {
+    private domSanitizer;
+    private nodeService;
+    private allLogs;
+    node?: JSONLD<NodeType>;
+    dataState?: DataState;
+    showFilters: boolean;
+    Level: typeof Level;
+    modelFilter: string;
+    termFilter: string;
+    selectedLevel: Level;
+    loading: boolean;
+    nodeLog?: Observable<string>;
+    nodeLogLines: ILine[];
+    csvContent?: SafeResourceUrl;
+    fileToExt: (path: string, extension: string) => string;
+    constructor(domSanitizer: DomSanitizer, nodeService: HeNodeService);
+    ngOnInit(): void;
+    private updateCsvContent;
+    applyFilters(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeLogsFileComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NodeLogsFileComponent, "he-node-logs-file", never, { "node": "node"; "dataState": "dataState"; }, {}, never, never>;
+}

package/node/node-logs-models/node-logs-models.component.d.ts

@@ -0,0 +1,72 @@
+import { OnInit } from '@angular/core';
+import { Observable } from 'rxjs';
+import { Emission, ITermJSONLD, Product, Input as HestiaInput } from '@hestia-earth/schema';
+import { INodeTermLogs } from '../node.service';
+import { HeEngineService } from '../../engine/engine.service';
+import { HeSearchService } from '../../search/search.service';
+import * as i0 from "@angular/core";
+declare type subValueKeys = 'input' | 'property';
+interface IBlankNodeLogSubValue {
+    key: subValueKeys;
+    value: any;
+    configModels: string[];
+}
+interface IBlankNodeLog {
+    isOpen: boolean;
+    canOpen: boolean;
+    term: ITermJSONLD;
+    configModels: string[];
+    original: number;
+    recalculated: number;
+    isRecalculated: boolean;
+    hasData: boolean;
+    logs?: INodeTermLogs;
+    keys: string[];
+    subValues: IBlankNodeLogSubValue[];
+}
+export declare class NodeLogsModelsComponent implements OnInit {
+    private searchService;
+    private hestiaEngineService;
+    private config?;
+    private models;
+    private allTerms;
+    private allBlankNodes;
+    private nodeType?;
+    /**
+     * Restrict models by key.
+     */
+    private nodeKey?;
+    logsUrl?: string;
+    originalValues: (Emission | Product | HestiaInput)[];
+    private recalculatedValues;
+    private terms;
+    private logs?;
+    filteredType?: string;
+    isExternal: boolean;
+    loading: boolean;
+    blankNodes: IBlankNodeLog[];
+    methodModelsCount: number;
+    methodsById?: any;
+    onlyWithData: boolean;
+    term?: string;
+    suggestTerm: (text$: Observable<string>) => Observable<string[]>;
+    constructor(searchService: HeSearchService, hestiaEngineService: HeEngineService);
+    ngOnInit(): Promise<void>;
+    private fetchAllTerms;
+    private suggestByTerm;
+    trackByBlankNode(_index: number, node: IBlankNodeLog): string;
+    togglePopover(popover: any, context: any): any;
+    validSubValue(node: IBlankNodeLog, index: number, subValue?: IBlankNodeLogSubValue): boolean;
+    getMethodIdAt(node: IBlankNodeLog, index: number, subValue?: IBlankNodeLogSubValue): string;
+    methodName({ logs }: IBlankNodeLog, methodId: string): any;
+    hasLog({ logs }: IBlankNodeLog, methodId: string): boolean;
+    hasLogDetails({ logs }: IBlankNodeLog, methodId: string): number | {
+        [key: string]: any;
+    } | undefined;
+    logColor(node: IBlankNodeLog, methodId: string): "success" | "danger" | "dark";
+    requirementColor(value: any): "danger" | "white";
+    filterResults(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeLogsModelsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NodeLogsModelsComponent, "he-node-logs-models", never, { "nodeType": "nodeType"; "nodeKey": "nodeKey"; "logsUrl": "logsUrl"; "originalValues": "originalValues"; "recalculatedValues": "recalculatedValues"; "terms": "terms"; "logs": "logs"; "filteredType": "filteredType"; }, {}, never, never>;
+}
+export {};

package/node/node-missing-lookup-factors/node-missing-lookup-factors.component.d.ts

@@ -0,0 +1,14 @@
+import { OnInit } from '@angular/core';
+import { JSONLD, NodeType } from '@hestia-earth/schema';
+import { INodeMissingLookupLog, HeNodeService } from '../node.service';
+import * as i0 from "@angular/core";
+export declare class NodeMissingLookupFactorsComponent implements OnInit {
+    nodeService: HeNodeService;
+    node?: JSONLD<NodeType>;
+    loading: boolean;
+    logs: INodeMissingLookupLog[];
+    constructor(nodeService: HeNodeService);
+    ngOnInit(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeMissingLookupFactorsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NodeMissingLookupFactorsComponent, "he-node-missing-lookup-factors", never, { "node": "node"; }, {}, never, never>;
+}

package/node/node-value-details/node-value-details.component.d.ts

@@ -0,0 +1,17 @@
+import { OnInit } from '@angular/core';
+import { NodeType } from '@hestia-earth/schema';
+import { IGroupedNode } from '../../common/utils';
+import * as i0 from "@angular/core";
+export declare class NodeValueDetailsComponent<T> implements OnInit {
+    data?: IGroupedNode<T>;
+    nodeType?: NodeType;
+    dataKey?: string;
+    baseUrl: string;
+    keys: string[];
+    additionalKeys: string[];
+    tableKeys: string[];
+    get type(): any;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeValueDetailsComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NodeValueDetailsComponent<any>, "he-node-value-details", never, { "data": "data"; "nodeType": "nodeType"; "dataKey": "dataKey"; }, {}, never, never>;
+}

package/node/node.module.d.ts

@@ -0,0 +1,20 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./node-icon/node-icon.component";
+import * as i2 from "./node-link/node-link.component";
+import * as i3 from "./node-csv-export-confirm/node-csv-export-confirm.component";
+import * as i4 from "./node-csv-select-headers/node-csv-select-headers.component";
+import * as i5 from "./node-diffs/node-diffs.component";
+import * as i6 from "./node-logs-file/node-logs-file.component";
+import * as i7 from "./node-logs-models/node-logs-models.component";
+import * as i8 from "./node-missing-lookup-factors/node-missing-lookup-factors.component";
+import * as i9 from "./node-value-details/node-value-details.component";
+import * as i10 from "@angular/common";
+import * as i11 from "@angular/router";
+import * as i12 from "@angular/forms";
+import * as i13 from "@angular/cdk/drag-drop";
+import * as i14 from "../common/common.module";
+export declare class HeNodeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeNodeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HeNodeModule, [typeof i1.NodeIconComponent, typeof i2.NodeLinkComponent, typeof i3.NodeCsvExportConfirmComponent, typeof i4.NodeCsvSelectHeadersComponent, typeof i5.NodeDiffsComponent, typeof i6.NodeLogsFileComponent, typeof i7.NodeLogsModelsComponent, typeof i8.NodeMissingLookupFactorsComponent, typeof i9.NodeValueDetailsComponent], [typeof i10.CommonModule, typeof i11.RouterModule, typeof i12.FormsModule, typeof i13.DragDropModule, typeof i14.HeCommonModule], [typeof i1.NodeIconComponent, typeof i2.NodeLinkComponent, typeof i3.NodeCsvExportConfirmComponent, typeof i4.NodeCsvSelectHeadersComponent, typeof i5.NodeDiffsComponent, typeof i6.NodeLogsFileComponent, typeof i7.NodeLogsModelsComponent, typeof i8.NodeMissingLookupFactorsComponent, typeof i9.NodeValueDetailsComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HeNodeModule>;
+}

package/node/node.service.d.ts

@@ -0,0 +1,70 @@
+import { HttpClient } from '@angular/common/http';
+import { DataState } from '@hestia-earth/api';
+import { ICycleJSONLD, IImpactAssessmentJSONLD, ISiteJSONLD, NodeType, TermTermType } from '@hestia-earth/schema';
+import { HeCommonService } from '../common/common.service';
+import { HeAuthService } from '../auth/auth.service';
+import * as i0 from "@angular/core";
+export interface IJSONNode {
+    '@type'?: NodeType;
+    '@id'?: string;
+    type?: NodeType;
+    id?: string;
+    dataState?: DataState;
+}
+export interface IRelatedNode {
+    '@type': NodeType;
+    '@id': string;
+    [x: string]: string;
+}
+export interface IJSONData {
+    [NodeType.Cycle]?: ICycleJSONLD[];
+    [NodeType.Site]?: ISiteJSONLD[];
+    [NodeType.ImpactAssessment]?: IImpactAssessmentJSONLD[];
+}
+export interface INodeMissingLookupLog {
+    filename: string;
+    termId: string;
+    column: string;
+    model?: string;
+    term?: string;
+    key?: string;
+}
+export interface INodeTermLogs {
+    [modelKey: string]: {
+        isKey: boolean;
+        shouldRun?: boolean;
+        missingLookups?: INodeMissingLookupLog[];
+        requirements?: {
+            [key: string]: any;
+        };
+        logs?: {
+            [key: string]: any;
+        };
+        [key: string]: any;
+    };
+}
+export interface INodeLogs {
+    [term: string]: INodeTermLogs;
+}
+export declare class HeNodeService {
+    private http;
+    private authService;
+    private commonService;
+    constructor(http: HttpClient, authService: HeAuthService, commonService: HeCommonService);
+    get$<T>({ dataState, ...node }: IJSONNode): import("rxjs").Observable<T>;
+    get<T>(node: IJSONNode, defaultForState?: boolean): Promise<T>;
+    getLog({ dataState, ...node }: IJSONNode): import("rxjs").Observable<string>;
+    getMissingLookupsLog({ dataState, ...node }: IJSONNode): Promise<INodeMissingLookupLog[]>;
+    getModelsLog({ dataState, ...node }: IJSONNode): Promise<any>;
+    triggerPipeline({ dataState, ...node }: IJSONNode): Promise<Object>;
+    downloadRaw<T = any>(url: string, responseType?: any): Promise<T>;
+    nodeTypeUrl(type: any): string;
+    nodeUrl({ dataState, ...node }: IJSONNode): string;
+    nodeLogsUrl({ dataState, ...node }: IJSONNode): string;
+    lookupUrl(filename: string): string;
+    termTypeLookupUrl(termType: TermTermType): string;
+    downloadLookup(filename: string): Promise<string | null>;
+    lookupLink(termType: TermTermType): Promise<string | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeNodeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HeNodeService>;
+}

package/node/public-api.d.ts

@@ -0,0 +1,12 @@
+export * from './node-csv.service';
+export * from './node.module';
+export * from './node.service';
+export { NodeCsvExportConfirmComponent } from './node-csv-export-confirm/node-csv-export-confirm.component';
+export { NodeCsvSelectHeadersComponent } from './node-csv-select-headers/node-csv-select-headers.component';
+export { NodeDiffsComponent } from './node-diffs/node-diffs.component';
+export { NodeIconComponent } from './node-icon/node-icon.component';
+export { NodeLinkComponent } from './node-link/node-link.component';
+export { NodeLogsFileComponent } from './node-logs-file/node-logs-file.component';
+export { NodeLogsModelsComponent } from './node-logs-models/node-logs-models.component';
+export { NodeMissingLookupFactorsComponent } from './node-missing-lookup-factors/node-missing-lookup-factors.component';
+export { NodeValueDetailsComponent } from './node-value-details/node-value-details.component';

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@hestia-earth/ui-components",
+  "version": "0.0.1",
+  "description": "Hestia reusable components",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@gitlab.com/hestia-earth/hestia-ui-components.git"
+  },
+  "author": "Guillaume Royer <guillaume@hestia.earth>",
+  "license": "GPL-3.0-or-later",
+  "bugs": {
+    "url": "https://gitlab.com/hestia-earth/hestia-ui-components/issues"
+  },
+  "homepage": "https://gitlab.com/hestia-earth/hestia-ui-components#readme",
+  "peerDependencies": {
+    "@angular/cdk": "^12.2.0",
+    "@angular/common": "^12.2.0",
+    "@angular/core": "^12.2.0",
+    "@angular/google-maps": "^12.2.0",
+    "@fortawesome/angular-fontawesome": "^0.9.0",
+    "@fortawesome/fontawesome-svg-core": "~1.2.36",
+    "@fortawesome/free-regular-svg-icons": "^5.15.4",
+    "@fortawesome/free-solid-svg-icons": "^5.15.4",
+    "@google/markerclustererplus": "^5.1.3",
+    "@hestia-earth/api": "^0.9.29-0",
+    "@hestia-earth/bulma-tagsinput": "^1.0.5",
+    "@hestia-earth/schema": "^7.5.1",
+    "@hestia-earth/schema-convert": "^7.5.1",
+    "@hestia-earth/json-schema": "^7.5.1",
+    "@hestia-earth/ui-framework": "^1.11.0",
+    "@hestia-earth/utils": "^0.10.11",
+    "@ng-bootstrap/ng-bootstrap": "^8.0.4",
+    "chart.js": "^2.9.4",
+    "chartjs-plugin-datalabels": "^1.0.0",
+    "jsondiffpatch": "^0.4.1",
+    "lodash.get": "^4.4.2",
+    "lodash.omit": "^4.5.0",
+    "lodash.orderby": "^4.6.0",
+    "pluralize": "^8.0.0",
+    "random-material-color": "^1.0.5",
+    "ts-clipboard": "^1.0.17"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "main": "bundles/hestia-earth-ui-components.umd.js",
+  "module": "fesm2015/hestia-earth-ui-components.js",
+  "es2015": "fesm2015/hestia-earth-ui-components.js",
+  "esm2015": "esm2015/hestia-earth-ui-components.js",
+  "fesm2015": "fesm2015/hestia-earth-ui-components.js",
+  "typings": "hestia-earth-ui-components.d.ts",
+  "sideEffects": false
+}

package/public-api.d.ts

@@ -0,0 +1,15 @@
+export * from './auth/public-api';
+export * from './bibliographies/public-api';
+export * from './common/public-api';
+export * from './cycles/public-api';
+export * from './engine/public-api';
+export * from './files/public-api';
+export * from './fontawesome/public-api';
+export * from './impact-assessments/public-api';
+export * from './mendeley/public-api';
+export * from './node/public-api';
+export * from './schema/public-api';
+export * from './search/public-api';
+export * from './sites/public-api';
+export * from './terms/public-api';
+export * from './users/public-api';

package/schema/public-api.d.ts

@@ -0,0 +1 @@
+export * from './schema.service';

package/schema/schema.service.d.ts

@@ -0,0 +1,51 @@
+import { HttpClient } from '@angular/common/http';
+import { SchemaType, NodeType, sortConfig } from '@hestia-earth/schema';
+import { definitions, definition, IDefinitionObject } from '@hestia-earth/json-schema';
+import * as i0 from "@angular/core";
+export declare const linkTypeEnabled: (type: SchemaType | NodeType) => boolean;
+export declare const refToSchemaType: (ref?: string) => string;
+export declare const definitionToSchemaType: ({ title, $ref }: IDefinitionObject) => SchemaType;
+export declare const schemaRequiredProperties: (schemas: definitions, def: IDefinitionObject) => {
+    schemaType: SchemaType;
+    properties: {
+        key: string;
+        value: definition;
+    }[];
+};
+export declare const valueTypeToDefault: {
+    number: string;
+    integer: string;
+    boolean: boolean;
+    string: string;
+};
+export declare const nestingTypeEnabled: (schemaType: SchemaType) => boolean;
+export declare const nestingEnabled: (schemaType: SchemaType, key: string) => boolean;
+export declare const schemaTypeToDefaultValue: (schemas: definitions, prop: definition, nested?: boolean) => any;
+export declare const availableProperties: (schema: definition, schemaType: SchemaType, value: any, isTopLevel?: boolean, skipExistingNode?: boolean) => any;
+export declare const isSchemaIri: (schema?: IDefinitionObject | undefined) => boolean;
+export declare class HeSchemaService {
+    private http;
+    private schemasLoading;
+    private schemasLoaded;
+    private _schemas;
+    private sortConfigLoading;
+    private sortConfigLoaded;
+    private _sortConfig;
+    constructor(http: HttpClient);
+    private loadSchemas;
+    get schemas$(): import("rxjs").Observable<definitions>;
+    schemas(): Promise<definitions>;
+    private loadSortConfig;
+    get sortConfig$(): import("rxjs").Observable<sortConfig>;
+    sortConfig(): Promise<sortConfig>;
+    /**
+     * Parse and sort (if possible) headers from CSV content according to the schema order.
+     * This will load the sort configuration according to the current schema version.
+     *
+     * @param csvContent The content as a string
+     * @returns List of strings as Observable when parsing / sorting is done.
+     */
+    parseHeaders(csvContent: string): Promise<string[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeSchemaService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HeSchemaService>;
+}

package/search/public-api.d.ts

@@ -0,0 +1,3 @@
+export * from './search.model';
+export * from './search.module';
+export * from './search.service';

package/search/search.model.d.ts

@@ -0,0 +1,243 @@
+import { NodeType, TermTermType } from '@hestia-earth/schema';
+export declare type searchableType = NodeType.Cycle | NodeType.Source;
+export declare const searchableTypes: searchableType[];
+declare type multiMatchType = 'best_fields' | 'most_fields' | 'cross_fields' | 'phrase' | 'phrase_prefix' | 'bool_prefix';
+export interface ISearchFilters {
+    [key: string]: (string | number)[];
+}
+export declare const serializeSearchFilters: (filters: ISearchFilters) => string;
+export declare const deserializeSearchFilters: (filters: string) => ISearchFilters;
+export declare const matchType: (type: NodeType | string) => Readonly<{
+    match: {
+        '@type': string;
+    };
+}>;
+export declare const matchTermType: (termType: TermTermType | string) => Readonly<{
+    match: {
+        termType: string;
+    };
+}>;
+export declare const matchRegex: (key: string, value: string | RegExp) => Readonly<{
+    regexp: {
+        [x: string]: {
+            value: string;
+        };
+    };
+}>;
+export declare const matchQuery: (key: string, value: any, boost?: number | undefined) => Readonly<{
+    match: {
+        [x: string]: {
+            boost?: number | undefined;
+            query: any;
+        };
+    };
+}>;
+export declare const matchExactQuery: (key: string, value: any, boost?: number | undefined) => Readonly<{
+    match: {
+        [x: string]: {
+            boost?: number | undefined;
+            query: any;
+        };
+    };
+}>;
+export declare const matchNameNormalized: (query: string, boost?: number) => Readonly<{
+    match: {
+        nameNormalized: {
+            query: string;
+            boost: number;
+        };
+    };
+}>;
+export declare const numberGte: (key: string, value: number) => Readonly<{
+    range: {
+        [x: string]: {
+            gte: number;
+        };
+    };
+}>;
+export declare const multiMatchQuery: (query: string, fields: string[], type?: multiMatchType, boost?: number | undefined, analyzer?: "standard" | undefined) => Readonly<{
+    multi_match: {
+        analyzer?: "standard" | undefined;
+        boost?: number | undefined;
+        query: string;
+        fields: string[];
+        type: multiMatchType;
+    };
+}>;
+export declare const matchPhraseQuery: (query: string, boost?: number | undefined, ...fields: string[]) => Readonly<{
+    match: {
+        [x: string]: {
+            boost?: number | undefined;
+            query: any;
+        };
+    };
+}> | Readonly<{
+    multi_match: {
+        analyzer?: "standard" | undefined;
+        boost?: number | undefined;
+        query: string;
+        fields: string[];
+        type: multiMatchType;
+    };
+}>;
+export declare const matchPhrasePrefixQuery: (query: string, boost?: number, ...fields: string[]) => Readonly<{
+    multi_match: {
+        analyzer?: "standard" | undefined;
+        boost?: number | undefined;
+        query: string;
+        fields: string[];
+        type: multiMatchType;
+    };
+}> | Readonly<{
+    match_phrase_prefix: {
+        nameSearchAsYouType: {
+            query: string;
+            boost: number;
+        };
+    };
+}>;
+export declare const matchBoolPrefixQuery: (query: string, boost?: number, ...fields: string[]) => Readonly<{
+    multi_match: {
+        analyzer?: "standard" | undefined;
+        boost?: number | undefined;
+        query: string;
+        fields: string[];
+        type: multiMatchType;
+    };
+}> | Readonly<{
+    match_bool_prefix: {
+        name: {
+            query: string;
+            boost: number;
+        };
+    };
+}>;
+export declare const wildcardQuery: (query: string, boost?: number, ...fields: string[]) => Readonly<{
+    simple_query_string: {
+        query: string;
+        fields: string[];
+        analyze_wildcard: boolean;
+        boost: number;
+    };
+}>;
+export declare const matchGlobalRegion: {
+    regexp: {
+        '@id': string;
+    };
+};
+export declare const matchCountry: Readonly<{
+    bool: {
+        should: ({
+            match: {
+                gadmLevel: number;
+            };
+        } | {
+            regexp: {
+                '@id': string;
+            };
+        })[];
+        minimum_should_match: number;
+    };
+}>;
+export declare const countriesQuery: Readonly<{
+    bool: {
+        must: ({
+            match: {
+                gadmLevel: number;
+            };
+        } | Readonly<{
+            match: {
+                '@type': string;
+            };
+        }> | Readonly<{
+            match: {
+                termType: string;
+            };
+        }>)[];
+    };
+}>;
+export declare const allCountriesQuery: Readonly<{
+    bool: {
+        should: ({
+            match: {
+                gadmLevel: number;
+            };
+        } | {
+            regexp: {
+                '@id': string;
+            };
+        })[];
+        minimum_should_match: number;
+        must: (Readonly<{
+            match: {
+                '@type': string;
+            };
+        }> | Readonly<{
+            match: {
+                termType: string;
+            };
+        }>)[];
+    };
+}>;
+export declare const matchRegion: Readonly<{
+    range: {
+        [x: string]: {
+            gte: number;
+        };
+    };
+}>;
+export declare const regionsQuery: Readonly<{
+    bool: {
+        must: (Readonly<{
+            match: {
+                '@type': string;
+            };
+        }> | Readonly<{
+            match: {
+                termType: string;
+            };
+        }> | Readonly<{
+            range: {
+                [x: string]: {
+                    gte: number;
+                };
+            };
+        }>)[];
+    };
+}>;
+export declare const worldRegion: Readonly<{
+    '@id': string;
+    name: string;
+}>;
+export declare const cropsQuery: Readonly<{
+    bool: {
+        must: (Readonly<{
+            match: {
+                '@type': string;
+            };
+        }> | Readonly<{
+            match: {
+                termType: string;
+            };
+        }>)[];
+    };
+}>;
+export declare const matchAggregatedQuery: Readonly<{
+    match: {
+        [x: string]: {
+            boost?: number | undefined;
+            query: any;
+        };
+    };
+}>;
+export declare const matchNestedKey: (key: string, query: any) => any;
+/**
+ * List of fields to return in the search results.
+ */
+export declare const searchResultsFields: {
+    [type in searchableType]: string[];
+};
+export declare const searchQuery: (type: searchableType, query?: string | undefined, filters?: ISearchFilters | undefined, aggregated?: boolean | undefined) => {
+    bool: any;
+};
+export {};

package/search/search.module.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+export { HeSearchService } from './search.service';
+export declare class HeSearchModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeSearchModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HeSearchModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HeSearchModule>;
+}