@hestia-earth/ui-components 0.0.1

package/files/files-error.model.d.ts

@@ -0,0 +1,40 @@
+export declare type validationErrorLevel = 'error' | 'warning';
+export declare type validationErrorParam = 'missingProperty' | 'type' | 'term' | 'model' | 'product' | 'range' | 'allowedValues' | 'additionalProperty' | 'expected' | 'default' | 'current' | 'percentage' | 'keys' | 'threshold';
+export declare type validationErrorKeyword = 'required' | 'type' | 'if' | 'then';
+export interface IValidationError {
+    index?: number;
+    nodeIndex?: number;
+    level?: validationErrorLevel;
+    dataPath?: string;
+    schemaPath?: string;
+    keyword?: validationErrorKeyword;
+    message: string;
+    params?: {
+        [key in validationErrorParam]?: any;
+    };
+    mapError?: boolean;
+}
+export interface IValidationErrorWithIndex {
+    error: IValidationError[];
+    index: number;
+    changed?: boolean;
+}
+export declare const parseDataPath: (dataPath: string) => {
+    path: string;
+    label: string;
+}[];
+export declare const nodeLink: ({ "@type": type, "@id": id, name }: {
+    "@type": any;
+    "@id": any;
+    name: any;
+}) => string | null;
+export declare const code: (text: string | number | boolean) => string;
+export declare const missingNodeErrorMessage: ({ "@type": _t, type, name }: any) => string;
+export declare const formatCustomErrorMessage: (message?: string | undefined, error?: IValidationError | undefined, errorCount?: number) => string;
+export declare const formatError: (error?: IValidationError | undefined, errorCount?: number) => IValidationError | undefined;
+export declare const errorHasError: (error?: IValidationError | undefined) => boolean | undefined;
+export declare const errorHasWarning: (error?: IValidationError | undefined) => boolean | undefined;
+export declare const isMissingPropertyError: ({ params }: IValidationError) => boolean;
+export declare const isMissingOneOfError: ({ keyword, schemaPath }: IValidationError) => boolean;
+export declare const filterError: (error: IValidationError) => boolean;
+export declare const missingNodeErrors: (errors: IValidationError[]) => IValidationError[];

package/files/files-form/files-form.component.d.ts

@@ -0,0 +1,94 @@
+/// <reference types="googlemaps" />
+import { OnInit, ElementRef } from '@angular/core';
+import { Observable } from 'rxjs';
+import { JSON as HestiaJson, SchemaType, NodeType, Bibliography, Source } from '@hestia-earth/schema';
+import { IErrorProperty, INodeProperty, suggestionType } from '../files-form.model';
+import { HeUsersService } from '../../users/users.service';
+import { HeSearchService } from '../../search/search.service';
+import * as i0 from "@angular/core";
+export declare class FilesFormComponent implements OnInit {
+    ref: ElementRef;
+    private searchService;
+    private usersService;
+    private schemas?;
+    private errors;
+    node?: HestiaJson<SchemaType>;
+    nodeMap: {
+        [type in NodeType]?: string[];
+    };
+    editable: boolean;
+    errorMode: boolean;
+    deepEditable: boolean;
+    errorsEditable: boolean;
+    private nodeChange;
+    private nodeErorrResolved;
+    private nodeErrorAdded;
+    NodeType: typeof NodeType;
+    SchemaType: typeof SchemaType;
+    isOpen: boolean;
+    mapVisible: boolean;
+    pluralize: any;
+    formatPropertyError: (errors: any, property: INodeProperty) => string;
+    mapDrawingProperty?: INodeProperty;
+    bibliographiesSearchProperty?: INodeProperty;
+    nodeProperty?: INodeProperty;
+    properties: INodeProperty[];
+    formatter: (value: any) => any;
+    suggestNewProperty: (fullKey: string) => (text$: Observable<string>) => Observable<{
+        name: string;
+        prop: any;
+    }[]>;
+    private suggestExistingNode;
+    private suggestNode;
+    private suggester;
+    propertySuggest: (fullKey: string, suggestType: suggestionType) => (text$: Observable<string>) => Observable<any[]>;
+    constructor(ref: ElementRef, searchService: HeSearchService, usersService: HeUsersService);
+    ngOnInit(): void;
+    trackByIndex(index: number, _value: any): number;
+    trackByProperty(_index: number, { id, fullKey }: INodeProperty): string;
+    hasAddons(property: INodeProperty): string | number | boolean | undefined;
+    isRequired({ value, isRequired }: INodeProperty): boolean | undefined;
+    enableAddError(property: INodeProperty): boolean;
+    addError(property: INodeProperty, { message, level }: IErrorProperty): void;
+    editError(property: INodeProperty): void;
+    resolveError(property: INodeProperty): void;
+    typeaheadFocus(e: Event): void;
+    addPropertyEnabled(property: INodeProperty): boolean;
+    private newProperties;
+    private replacePropertyData;
+    suggestionSelected({ '@id': _id, name, type, id, ...data }: {
+        [x: string]: any;
+        "@id": any;
+        name: any;
+        type: any;
+        id: any;
+    }, property: INodeProperty): void;
+    addArrayGroup(array: INodeProperty): void;
+    duplicateArrayGroup(array: INodeProperty, property: INodeProperty): void;
+    removeArrayGroup(array: INodeProperty, { key }: INodeProperty): void | null;
+    private moveArrayGroupToPosition;
+    moveArrayGroupUp(array: INodeProperty, { key }: INodeProperty): void;
+    moveArrayGroupDown(array: INodeProperty, { key }: INodeProperty): void;
+    propertyChanged(value: any, property: INodeProperty): void;
+    private addDefaultProperty;
+    addMissingProperty(property: INodeProperty): void | null;
+    addProperty(property: INodeProperty): void;
+    private updatePropertyCoordinates;
+    get showMap(): boolean;
+    mapDrawingModes({ key }: INodeProperty): google.maps.drawing.OverlayType[];
+    onMapDrawingClosed(newValue: any): void | (void | null)[];
+    bibliographiesSearchKey({ key, schemaType }: INodeProperty): string | null;
+    private updateBibliography;
+    private updateSource;
+    get bibliographiesSearchSources(): boolean;
+    onBibliographiesSearchClosed(value?: Partial<Source> | Partial<Bibliography>): void;
+    setUserActorId(property: INodeProperty): Promise<void>;
+    calculateCycleDurationEnabled(property: INodeProperty): boolean;
+    calculateCycleDuration(property: INodeProperty): void;
+    calculateCycleStartDateEnabled(property: INodeProperty): boolean;
+    calculateCycleStartDate(property: INodeProperty): void;
+    unitConverterEnabled(property: INodeProperty): boolean | undefined;
+    openUnitConverter(popover: any, property: INodeProperty): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilesFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilesFormComponent, "he-files-form", never, { "schemas": "schemas"; "errors": "errors"; "node": "node"; "nodeMap": "nodeMap"; "editable": "editable"; "errorMode": "errorMode"; "deepEditable": "deepEditable"; "errorsEditable": "errorsEditable"; }, { "nodeChange": "nodeChange"; "nodeErorrResolved": "nodeErorrResolved"; "nodeErrorAdded": "nodeErrorAdded"; }, never, never>;
+}

package/files/files-form.model.d.ts

@@ -0,0 +1,113 @@
+import 'moment/locale/en-gb';
+import { JSON as HestiaJson, SchemaType, NodeType } from '@hestia-earth/schema';
+import { definitions, definition } from '@hestia-earth/json-schema';
+import { IValidationError, validationErrorLevel } from './files-error.model';
+export declare const ARRAY_DELIMITER = ";";
+export declare type suggestionType = NodeType | 'select' | 'default';
+export declare const defaultSuggestionType: suggestionType;
+interface INodePropertySuggestion {
+    type?: suggestionType;
+    queries?: any[];
+    values?: string[];
+    parentLevel?: number;
+    isLinkNode?: boolean;
+    isUniqueKey?: string;
+}
+interface INewProperty {
+    name?: string;
+    prop?: definition;
+}
+export interface IErrorProperty {
+    level?: validationErrorLevel;
+    message?: string;
+}
+export interface INodeProperty {
+    /**
+     * Whether or not this property was added by the user
+     */
+    id: string;
+    isAdded?: boolean;
+    schemaType: SchemaType;
+    key: string;
+    fullKey: string;
+    value: any;
+    addPropertyEnabled: boolean;
+    suggestions?: INodePropertySuggestion;
+    schema?: definition;
+    error?: IValidationError;
+    hasError?: boolean;
+    hasWarning?: boolean;
+    editable?: boolean;
+    closedVisible?: boolean;
+    newProperty?: INewProperty;
+    newError?: IErrorProperty;
+    isRequired?: boolean;
+    isHidden?: boolean;
+    isArray?: boolean;
+    isExpandable?: boolean;
+    isOpen?: boolean;
+    properties: INodeProperty[];
+    placeholder?: string;
+    externalUrl?: {
+        url?: string;
+        title: string;
+        icon?: string;
+        urlParamValue?: boolean;
+    };
+    loading?: boolean;
+    changed?: boolean;
+}
+export declare const keyToDataPath: (key: string) => string;
+export declare const dataPathToKey: (dataPath: string, trimArray?: boolean) => string;
+export declare const parentKey: (key: string) => string;
+/**
+ * Sort properties having errors, type, id, ...properties (simple), and finally the groups
+ *
+ * @param a {INodeProperty}
+ * @param b {INodeProperty}
+ */
+export declare const sortProperties: (a: INodeProperty, b: INodeProperty) => number;
+export declare const formatPropertyError: (errors: any, property: INodeProperty) => string;
+export declare const hasError: (value: any) => any;
+export declare const hasWarning: (value: any) => any;
+export declare const formatLinkNodesSuggestions: (nodeMap: {
+    Actor?: string[] | undefined;
+    Cycle?: string[] | undefined;
+    ImpactAssessment?: string[] | undefined;
+    Organisation?: string[] | undefined;
+    Site?: string[] | undefined;
+    Source?: string[] | undefined;
+    Term?: string[] | undefined;
+}, type: NodeType) => {
+    type: NodeType;
+    id: string;
+    name: string;
+}[];
+export declare const formatSuggestion: ({ defaultProperties, ...node }: any) => any;
+export declare const nodeAvailableProperties: (node: HestiaJson<SchemaType>, { fullKey, schema, schemaType }: Partial<INodeProperty>) => any;
+export declare const isAddPropertyEnabled: (node: HestiaJson<SchemaType>, schemaType: SchemaType, schema: definition, fullKey?: string) => boolean;
+export declare const propertyId: () => any;
+/**
+ * Convert value to the final type in the schema.
+ *
+ * @param schema Definition of the value.
+ * @param value
+ * @returns Value in the correct format.
+ */
+export declare const parseNewValue: (schema: definition, value: any) => any;
+export declare const propertyError: (errors: IValidationError[]) => (dataPath: string, nonExpandableArray?: boolean) => IValidationError | undefined;
+export declare const singleProperty: (schemas: definitions, errors: IValidationError[], node: any, fullKey: string) => INodeProperty;
+export declare const recursiveProperties: (schemas: definitions, errors: IValidationError[], nodeSchema: definition, deepEditable: boolean, parent?: string) => (node: any) => INodeProperty[];
+export declare const updateProperties: ({ properties }: Partial<INodeProperty>, updater: (prop: INodeProperty) => INodeProperty) => any;
+export declare const typeToNewProperty: (schemas: definitions, schema: definition, nodeSchema: definition, node: any, fullKey: string) => INodeProperty;
+export declare const findProperty: (properties: INodeProperty[], fullKey: string) => any;
+export declare const parentProperty: (properties: INodeProperty[], property: INodeProperty) => INodeProperty;
+export declare const nestedProperty: ({ properties }: INodeProperty, nestedKey: string) => INodeProperty | undefined;
+export declare const siblingProperty: (properties: INodeProperty[], property: INodeProperty, siblingKey: string) => INodeProperty | undefined;
+export declare const groupChanged: (properties: INodeProperty[], key: string, value?: any) => void;
+export declare const refreshPropertyKeys: (property: INodeProperty) => any;
+export declare const calculateCycleDurationEnabled: (properties: INodeProperty[], property: INodeProperty) => boolean;
+export declare const calculateCycleDuration: (properties: INodeProperty[], property: INodeProperty) => number;
+export declare const calculateCycleStartDateEnabled: (properties: INodeProperty[], property: INodeProperty) => boolean;
+export declare const calculateCycleStartDate: (properties: INodeProperty[], property: INodeProperty) => string;
+export {};

package/files/files.module.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./files-form/files-form.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+import * as i4 from "../common/common.module";
+import * as i5 from "../node/node.module";
+import * as i6 from "../bibliographies/bibliographies.module";
+import * as i7 from "../sites/sites.module";
+export declare class HeFilesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeFilesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HeFilesModule, [typeof i1.FilesFormComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i4.HeCommonModule, typeof i5.HeNodeModule, typeof i6.HeBibliographiesModule, typeof i7.HeSitesModule], [typeof i1.FilesFormComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HeFilesModule>;
+}

package/files/public-api.d.ts

@@ -0,0 +1,2 @@
+export * from './files.module';
+export { FilesFormComponent } from './files-form/files-form.component';

package/fontawesome/fontawesome.module.d.ts

@@ -0,0 +1,10 @@
+import { FaIconLibrary } from '@fortawesome/angular-fontawesome';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@fortawesome/angular-fontawesome";
+export declare class HeFontawesomeModule {
+    constructor(library: FaIconLibrary);
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeFontawesomeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HeFontawesomeModule, never, [typeof i1.CommonModule, typeof i2.FontAwesomeModule], [typeof i2.FontAwesomeModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HeFontawesomeModule>;
+}

package/fontawesome/public-api.d.ts

@@ -0,0 +1 @@
+export * from './fontawesome.module';

package/hestia-earth-ui-components.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@hestia-earth/ui-components" />
+export * from './public-api';

package/impact-assessments/impact-assessments-indicator-breakdown-chart/impact-assessments-indicator-breakdown-chart.component.d.ts

@@ -0,0 +1,28 @@
+import { OnInit } from '@angular/core';
+import { DomSanitizer, SafeResourceUrl } from '@angular/platform-browser';
+import { IImpactAssessmentJSONLD, Indicator, Term } from '@hestia-earth/schema';
+import { HeSearchService } from '../../search/search.service';
+import { HeNodeService } from '../../node/node.service';
+import * as i0 from "@angular/core";
+export declare class ImpactAssessmentsIndicatorBreakdownChartComponent implements OnInit {
+    private domSanitizer;
+    private searchService;
+    private nodeService;
+    private logs;
+    private emissions;
+    private chartRef?;
+    private chart;
+    impactAssessment?: IImpactAssessmentJSONLD;
+    indicators: Indicator[];
+    loading: boolean;
+    terms: Term[];
+    selectedTerm?: Term;
+    noData: boolean;
+    csvContent?: SafeResourceUrl;
+    constructor(domSanitizer: DomSanitizer, searchService: HeSearchService, nodeService: HeNodeService);
+    ngOnInit(): Promise<void>;
+    get id(): any;
+    updateChart(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImpactAssessmentsIndicatorBreakdownChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ImpactAssessmentsIndicatorBreakdownChartComponent, "he-impact-assessments-indicator-breakdown-chart", never, { "impactAssessment": "impactAssessment"; "indicators": "indicators"; }, {}, never, never>;
+}

package/impact-assessments/impact-assessments-indicators-chart/impact-assessments-indicators-chart.component.d.ts

@@ -0,0 +1,25 @@
+import { AfterViewInit, OnChanges, SimpleChanges } from '@angular/core';
+import { Indicator, Term, TermTermType } from '@hestia-earth/schema';
+import { IGroupedNodes } from '../../common/utils';
+import * as i0 from "@angular/core";
+export declare class ImpactAssessmentsIndicatorsChartComponent implements AfterViewInit, OnChanges {
+    private barChartRef?;
+    private barChart;
+    private pieChartRef?;
+    private pieChart;
+    private impactAssessments;
+    private key;
+    filterTermTypes?: TermTermType[];
+    indicatorPerImpactAssessment: IGroupedNodes<Indicator>;
+    terms: Term[];
+    selectedTerm?: Term;
+    ngAfterViewInit(): void | null;
+    ngOnChanges(changes: SimpleChanges): void | null;
+    private termAllowed;
+    private init;
+    private updateBarChart;
+    private updatePieChart;
+    updateCharts(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImpactAssessmentsIndicatorsChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ImpactAssessmentsIndicatorsChartComponent, "he-impact-assessments-indicators-chart", never, { "impactAssessments": "impactAssessments"; "key": "key"; "filterTermTypes": "filterTermTypes"; }, {}, never, never>;
+}

package/impact-assessments/impact-assessments-products/impact-assessments-products.component.d.ts

@@ -0,0 +1,77 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import { FormBuilder } from '@angular/forms';
+import { Observable } from 'rxjs';
+import { DataState } from '@hestia-earth/api';
+import { NodeType, IImpactAssessmentJSONLD, Indicator, TermTermType, Term } from '@hestia-earth/schema';
+import { HeNodeService } from '../../node/node.service';
+import { HeSearchService } from '../../search/search.service';
+import { ToastService } from '../../common/toast.service';
+import { IGroupedKeys } from '../../common/utils';
+import * as i0 from "@angular/core";
+declare enum View {
+    table = "table",
+    chart = "chart",
+    breakdown = "breakdown",
+    logs = "logs"
+}
+export declare class ImpactAssessmentsProductsComponent implements OnChanges {
+    private formBuilder;
+    private nodeService;
+    private searchService;
+    private toastService;
+    private dataStateValues;
+    private cycles?;
+    impactAssessments: IImpactAssessmentJSONLD[];
+    key: 'impacts' | 'emissionsResourceUse';
+    dataState?: DataState;
+    enableCompare: boolean;
+    filterTermTypes?: TermTermType[];
+    enableFilterMethodModel: boolean;
+    propertyValue: (value: string | number | (string | number)[], isAverage?: boolean) => number;
+    itemColor: (index: number) => any;
+    baseUrl: string;
+    showDownload: boolean;
+    View: typeof View;
+    selectedView: View;
+    methodModels: Term[];
+    selectedMethodModel?: Term;
+    indicators: IGroupedKeys<Indicator>[];
+    form: import("@angular/forms").FormGroup;
+    selectedImpactAssessments: IImpactAssessmentJSONLD[];
+    loading: boolean;
+    suggesting: boolean;
+    formatter: ({ "@id": id }: {
+        "@id": any;
+    }) => any;
+    suggestImpactAssessment: (text$: Observable<string>) => Observable<Omit<import("@hestia-earth/schema").JSONLD<NodeType.ImpactAssessment> & import("../../search/search.service").ISearchResultExtended, "_score">[]>;
+    constructor(formBuilder: FormBuilder, nodeService: HeNodeService, searchService: HeSearchService, toastService: ToastService);
+    ngOnChanges(changes: SimpleChanges): void | Promise<void>;
+    trackById(_index: number, item: IImpactAssessmentJSONLD): string;
+    get isOriginal(): boolean;
+    get originalValues(): IImpactAssessmentJSONLD[];
+    private termAllowed;
+    private update;
+    private updateMethodModels;
+    updateImpacts(): void;
+    private loadDataState;
+    private updateDataState;
+    togglePopover(popover: any, context: any): any;
+    impactName(impact: IImpactAssessmentJSONLD): any;
+    cycleLabel({ '@id': id, name }: any): any;
+    get enableBreakdown(): boolean;
+    showRecalculationLogs(): Promise<void>;
+    private selectAllImpacts;
+    private unselectAllImpacts;
+    toggleAllImpacts(): void;
+    private selectImpact;
+    private unselectImpact;
+    toggleImpact(impact: IImpactAssessmentJSONLD): void;
+    isSelected(impact: IImpactAssessmentJSONLD): boolean;
+    private suggest;
+    private loadImpact;
+    private fetchCycle;
+    addImpact(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImpactAssessmentsProductsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ImpactAssessmentsProductsComponent, "he-impact-assessments-products", never, { "cycles": "cycles"; "impactAssessments": "impactAssessments"; "key": "key"; "dataState": "dataState"; "enableCompare": "enableCompare"; "filterTermTypes": "filterTermTypes"; "enableFilterMethodModel": "enableFilterMethodModel"; }, {}, never, never>;
+}
+export {};

package/impact-assessments/impact-assessments-products-logs/impact-assessments-products-logs.component.d.ts

@@ -0,0 +1,25 @@
+import { OnInit } from '@angular/core';
+import { Emission, ITermJSONLD, NodeType, TermTermType } from '@hestia-earth/schema';
+import { HeSearchService } from '../../search/search.service';
+import { HeNodeService } from '../../node/node.service';
+import * as i0 from "@angular/core";
+export declare class ImpactAssessmentsProductsLogsComponent implements OnInit {
+    private searchService;
+    private nodeService;
+    private impactAssessment?;
+    key?: string;
+    filterTermTypes?: TermTermType[];
+    originalValues: Emission[];
+    recalculatedValues: Emission[];
+    loading: boolean;
+    logsUrl?: string;
+    NodeType: typeof NodeType;
+    logs: any;
+    models: ITermJSONLD[];
+    emissions: ITermJSONLD[];
+    constructor(searchService: HeSearchService, nodeService: HeNodeService);
+    ngOnInit(): Promise<void>;
+    private get node();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImpactAssessmentsProductsLogsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ImpactAssessmentsProductsLogsComponent, "he-impact-assessments-products-logs", never, { "impactAssessment": "impactAssessment"; "key": "key"; "filterTermTypes": "filterTermTypes"; "originalValues": "originalValues"; "recalculatedValues": "recalculatedValues"; }, {}, never, never>;
+}

package/impact-assessments/impact-assessments.model.d.ts

@@ -0,0 +1,6 @@
+import { NodeType, IImpactAssessmentJSONLD } from '@hestia-earth/schema';
+export interface IImpactAssessmentJSONLDExtended extends IImpactAssessmentJSONLD {
+    related: {
+        [type in NodeType]?: string[];
+    };
+}

package/impact-assessments/impact-assessments.module.d.ts

@@ -0,0 +1,15 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./impact-assessments-products/impact-assessments-products.component";
+import * as i2 from "./impact-assessments-indicators-chart/impact-assessments-indicators-chart.component";
+import * as i3 from "./impact-assessments-products-logs/impact-assessments-products-logs.component";
+import * as i4 from "./impact-assessments-indicator-breakdown-chart/impact-assessments-indicator-breakdown-chart.component";
+import * as i5 from "@angular/common";
+import * as i6 from "@angular/router";
+import * as i7 from "@angular/forms";
+import * as i8 from "../common/common.module";
+import * as i9 from "../node/node.module";
+export declare class HeImpactAssessmentsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeImpactAssessmentsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HeImpactAssessmentsModule, [typeof i1.ImpactAssessmentsProductsComponent, typeof i2.ImpactAssessmentsIndicatorsChartComponent, typeof i3.ImpactAssessmentsProductsLogsComponent, typeof i4.ImpactAssessmentsIndicatorBreakdownChartComponent], [typeof i5.CommonModule, typeof i6.RouterModule, typeof i7.FormsModule, typeof i7.ReactiveFormsModule, typeof i8.HeCommonModule, typeof i9.HeNodeModule], [typeof i1.ImpactAssessmentsProductsComponent, typeof i2.ImpactAssessmentsIndicatorsChartComponent, typeof i3.ImpactAssessmentsProductsLogsComponent, typeof i4.ImpactAssessmentsIndicatorBreakdownChartComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HeImpactAssessmentsModule>;
+}

package/impact-assessments/public-api.d.ts

@@ -0,0 +1,6 @@
+export * from './impact-assessments.model';
+export * from './impact-assessments.module';
+export { ImpactAssessmentsProductsComponent } from './impact-assessments-products/impact-assessments-products.component';
+export { ImpactAssessmentsIndicatorBreakdownChartComponent } from './impact-assessments-indicator-breakdown-chart/impact-assessments-indicator-breakdown-chart.component';
+export { ImpactAssessmentsIndicatorsChartComponent } from './impact-assessments-indicators-chart/impact-assessments-indicators-chart.component';
+export { ImpactAssessmentsProductsLogsComponent } from './impact-assessments-products-logs/impact-assessments-products-logs.component';

package/mendeley/mendeley.service.d.ts

@@ -0,0 +1,25 @@
+import { HttpClient } from '@angular/common/http';
+import { Bibliography } from '@hestia-earth/schema';
+import { HeCommonService } from '../common/common.service';
+import * as i0 from "@angular/core";
+interface IMendeleySearchParams {
+    title?: string;
+    limit?: number;
+    doi?: string;
+    scopus?: string;
+}
+export declare class MendeleySearchResult {
+    count: number;
+    results: Partial<Bibliography>[];
+}
+export declare class HeMendeleyService {
+    private http;
+    private commonService;
+    constructor(http: HttpClient, commonService: HeCommonService);
+    private get path();
+    find(params: IMendeleySearchParams): import("rxjs").Observable<MendeleySearchResult>;
+    get(id: string): Promise<Bibliography>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeMendeleyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HeMendeleyService>;
+}
+export {};

package/mendeley/public-api.d.ts

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

package/node/node-csv-export-confirm/node-csv-export-confirm.component.d.ts

@@ -0,0 +1,32 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import { DomSanitizer, SafeResourceUrl } from '@angular/platform-browser';
+import { SupportedExtensions } from '@hestia-earth/api';
+import { JSON as HestiaJson } from '@hestia-earth/schema';
+import * as i0 from "@angular/core";
+interface INodeIncluded {
+    node: HestiaJson<any>;
+    included: boolean;
+}
+export declare class NodeCsvExportConfirmComponent implements OnInit {
+    private domSanitizer;
+    private headers;
+    private nodes;
+    private filename;
+    headerKeys?: string[];
+    extension: SupportedExtensions;
+    isUpload: boolean;
+    closed: EventEmitter<boolean>;
+    csvData?: string;
+    csvContent?: SafeResourceUrl;
+    showIncludeNodes: boolean;
+    includedNodes: INodeIncluded[];
+    constructor(domSanitizer: DomSanitizer);
+    ngOnInit(): void;
+    get included(): INodeIncluded[];
+    headersUpdated(headers: string[]): void;
+    updateCsvContent(): void;
+    get downloadFilename(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeCsvExportConfirmComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NodeCsvExportConfirmComponent, "he-node-csv-export-confirm", never, { "nodes": "nodes"; "filename": "filename"; "headerKeys": "headerKeys"; "extension": "extension"; "isUpload": "isUpload"; }, { "closed": "closed"; }, never, never>;
+}
+export {};

package/node/node-csv-select-headers/node-csv-select-headers.component.d.ts

@@ -0,0 +1,42 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import { HeSchemaService } from '../../schema/schema.service';
+import * as i0 from "@angular/core";
+interface IHeader {
+    header: string;
+    selected: boolean;
+}
+interface IGroupedHeaders {
+    [group: string]: {
+        selected: boolean;
+        partialSelected: boolean;
+        open: boolean;
+        headers: IHeader[];
+    };
+}
+export declare class NodeCsvSelectHeadersComponent implements OnInit {
+    private schemaService;
+    private csv;
+    private keys?;
+    private includeDefaultCSV;
+    headersChanged: EventEmitter<string[]>;
+    headers: IGroupedHeaders;
+    allSelected: boolean;
+    showSelectTermFields: boolean;
+    termFields: string[];
+    termFieldSelected: any;
+    constructor(schemaService: HeSchemaService);
+    ngOnInit(): Promise<void>;
+    private isSelected;
+    dropHeader(event: CdkDragDrop<IHeader[]>, groupKey: string): void;
+    private updateAllSelected;
+    toggleAll(): void[];
+    updateGroup(groupKey: string): void;
+    updateGroupHeader(groupKey: string): void;
+    get selectedHeaders(): string[];
+    reresh(): void;
+    toggleTermField(field: string): void[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeCsvSelectHeadersComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NodeCsvSelectHeadersComponent, "he-node-csv-select-headers", never, { "csv": "csv"; "keys": "keys"; "includeDefaultCSV": "includeDefaultCSV"; }, { "headersChanged": "headersChanged"; }, never, never>;
+}
+export {};

package/node/node-csv.service.d.ts

@@ -0,0 +1,9 @@
+import { HeSchemaService } from '../schema/schema.service';
+import * as i0 from "@angular/core";
+export declare class HeNodeCsvService {
+    private schemaService;
+    constructor(schemaService: HeSchemaService);
+    csvToJson(content: string): Promise<any[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeNodeCsvService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HeNodeCsvService>;
+}

package/node/node-diffs/node-diffs.component.d.ts

@@ -0,0 +1,23 @@
+import { OnInit } from '@angular/core';
+import { NodeType, JSONLD } from '@hestia-earth/schema';
+import { DisplayType } from './node-diffs.model';
+import { HeNodeService } from '../node.service';
+import * as i0 from "@angular/core";
+export declare class NodeDiffsComponent implements OnInit {
+    private nodeService;
+    private data;
+    private id?;
+    private type?;
+    displayType: DisplayType;
+    private diffsLoaded;
+    DisplayType: typeof DisplayType;
+    loading: boolean;
+    left?: JSONLD<NodeType>;
+    right: any;
+    diffHtml?: string;
+    constructor(nodeService: HeNodeService);
+    ngOnInit(): Promise<void>;
+    private loadDiffs;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeDiffsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NodeDiffsComponent, "he-node-diffs", never, { "data": "data"; "id": "id"; "type": "type"; "displayType": "displayType"; }, { "diffsLoaded": "diffsLoaded"; }, never, never>;
+}

package/node/node-diffs/node-diffs.model.d.ts

@@ -0,0 +1,4 @@
+export declare enum DisplayType {
+    diffs = "diffs",
+    sideBySide = "side-by-side"
+}

package/node/node-icon/node-icon.component.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class NodeIconComponent {
+    private type?;
+    size: string;
+    get icon(): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeIconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NodeIconComponent, "he-node-icon", never, { "type": "type"; "size": "size"; }, {}, never, never>;
+}

package/node/node-link/node-link.component.d.ts

@@ -0,0 +1,11 @@
+import { JSONLD, NodeType } from '@hestia-earth/schema';
+import * as i0 from "@angular/core";
+export declare class NodeLinkComponent {
+    node?: JSONLD<NodeType>;
+    showExternalLink: boolean;
+    baseUrl: string;
+    get showLink(): boolean | undefined;
+    get target(): "_blank" | "_self";
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeLinkComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NodeLinkComponent, "he-node-link", never, { "node": "node"; "showExternalLink": "showExternalLink"; }, {}, never, ["*"]>;
+}