@hestia-earth/ui-components 0.2.11 → 0.3.1

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

@@ -7,7 +7,6 @@ export declare class ImpactAssessmentsIndicatorsChartComponent implements AfterV
     private chartRef?;
     private chart;
     private impactAssessments;
-    private selected;
     private key;
     filterTermTypes?: TermTermType[];
     indicatorPerImpactAssessment: IGroupedNodes<Indicator>;
@@ -21,5 +20,5 @@ export declare class ImpactAssessmentsIndicatorsChartComponent implements AfterV
     private initChart;
     updateChart(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ImpactAssessmentsIndicatorsChartComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ImpactAssessmentsIndicatorsChartComponent, "he-impact-assessments-indicators-chart", never, { "impactAssessments": "impactAssessments"; "selected": "selected"; "key": "key"; "filterTermTypes": "filterTermTypes"; }, {}, never, 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

@@ -15,7 +15,6 @@ export declare class ImpactAssessmentsProductsComponent implements OnChanges {
     private dataStateValues;
     private cycles?;
     impactAssessments: IImpactAssessmentJSONLD[];
-    selected: string[];
     key: 'endpoints' | 'impacts' | 'emissionsResourceUse';
     dataState?: DataState;
     filterTermTypes?: TermTermType[];
@@ -45,7 +44,6 @@ export declare class ImpactAssessmentsProductsComponent implements OnChanges {
     impactName(impact: IImpactAssessmentJSONLD): any;
     cycleLabel({ '@id': id, name }: any): any;
     get enableBreakdown(): boolean;
-    isSelected(impact: IImpactAssessmentJSONLD): boolean;
     selectIndex({ target: { value } }: {
         target: {
             value: any;
@@ -53,6 +51,6 @@ export declare class ImpactAssessmentsProductsComponent implements OnChanges {
     }): void;
     showRecalculationLogs(): Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ImpactAssessmentsProductsComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ImpactAssessmentsProductsComponent, "he-impact-assessments-products", never, { "cycles": "cycles"; "impactAssessments": "impactAssessments"; "selected": "selected"; "key": "key"; "dataState": "dataState"; "filterTermTypes": "filterTermTypes"; "enableFilterMethodModel": "enableFilterMethodModel"; }, {}, never, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ImpactAssessmentsProductsComponent, "he-impact-assessments-products", never, { "cycles": "cycles"; "impactAssessments": "impactAssessments"; "key": "key"; "dataState": "dataState"; "filterTermTypes": "filterTermTypes"; "enableFilterMethodModel": "enableFilterMethodModel"; }, {}, never, never>;
 }
 export {};

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

@@ -1,25 +1,56 @@
 import { OnInit } from '@angular/core';
+import { DataState } from '@hestia-earth/api';
 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[];
     terms: ITermJSONLD[];
-    constructor(searchService: HeSearchService, nodeService: HeNodeService);
+    constructor(searchService: HeSearchService);
     ngOnInit(): Promise<void>;
-    private get node();
+    get node(): {
+        dataState: DataState;
+        version?: string;
+        versionDetails?: string;
+        organisation?: import("@hestia-earth/schema").Organisation;
+        cycle?: import("@hestia-earth/schema").Cycle;
+        endDate?: string;
+        startDate?: string;
+        site?: import("@hestia-earth/schema").Site;
+        country?: import("@hestia-earth/schema").Term;
+        region?: import("@hestia-earth/schema").Term;
+        product?: import("@hestia-earth/schema").Term;
+        functionalUnitQuantity?: number;
+        allocationMethod?: import("@hestia-earth/schema").ImpactAssessmentAllocationMethod;
+        source?: import("@hestia-earth/schema").Source;
+        emissionsResourceUse?: import("@hestia-earth/schema").Indicator[];
+        impacts?: import("@hestia-earth/schema").Indicator[];
+        endpoints?: import("@hestia-earth/schema").Indicator[];
+        organic?: boolean;
+        irrigated?: boolean;
+        autoGenerated?: boolean;
+        originalId?: string;
+        schemaVersion?: string;
+        added?: string[];
+        addedVersion?: string[];
+        updated?: string[];
+        updatedVersion?: string[];
+        aggregated?: boolean;
+        aggregatedVersion?: string;
+        dataPrivate?: boolean;
+        '@context': string | (string | import("@hestia-earth/schema").IContext)[];
+        '@type': NodeType.ImpactAssessment;
+        '@id': string;
+        name: string;
+    };
     get includeAllModels(): boolean;
     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/node/node-logs-models/node-logs-models.component.d.ts

@@ -1,86 +1,30 @@
 import { OnInit } from '@angular/core';
 import { Observable } from 'rxjs';
-import { Emission, ITermJSONLD, Product, Input as HestiaInput, Property, SchemaType } from '@hestia-earth/schema';
-import { INodeTermLogs, INodeTermLog } from '../node.service';
-import { HeEngineService, IModel } from '../../engine/engine.service';
+import { IBlankNodeLogSubValue, IBlankNodeLog, LogStatus, IConfigModel } from '../node-logs.model';
+import { HeNodeService } from '../node.service';
+import { HeEngineService } from '../../engine/engine.service';
 import { HeSearchService } from '../../search/search.service';
 import * as i0 from "@angular/core";
-declare type blankNode = Emission | Product | HestiaInput | Property;
-interface IConfigModel {
-    methodId: string;
-    model?: IModel;
-}
-interface IBlankNodeLogSubValue {
-    key: string;
-    originalValue: number | string | boolean;
-    recalculatedValue: number | string | boolean;
-    isRecalculated: boolean;
-    id?: any;
-    configModels?: IConfigModel[];
-}
-interface IBlankNodeLog {
-    isOpen: boolean;
-    canOpen: boolean;
-    term: ITermJSONLD;
-    termId: string;
-    type?: SchemaType;
-    configModels: (IConfigModel | IConfigModel[])[];
-    original: blankNode[];
-    originalValue: number;
-    originalValueByMethodId?: {
-        [methodId: string]: number;
-    };
-    recalculated: blankNode[];
-    recalculatedValue: number;
-    recalculatedValueByMethodId?: {
-        [methodId: string]: number;
-    };
-    isOriginal: boolean;
-    isRecalculated: boolean;
-    hasData: boolean;
-    isRequired: boolean;
-    logs?: INodeTermLogs;
-    keys: IBlankNodeLogSubValue[];
-    subValues: IBlankNodeLogSubValue[];
-    allParallel?: boolean;
-}
-declare enum LogStatus {
-    success = "successful",
-    error = "failed",
-    skipHierarchy = "not run (model higher up hierarchy run instead)",
-    dataProvided = "not run (user provided data retained)",
-    notRequired = "not relevant"
-}
 export declare class NodeLogsModelsComponent implements OnInit {
+    private nodeService;
     private searchService;
     private engineService;
-    private config?;
-    private models;
     private allTerms;
     private allBlankNodes;
-    private nodeType?;
+    private node?;
     /**
      * Restrict models by key.
      */
     private nodeKey?;
     private includeAllModels;
-    logsUrl?: string;
-    originalValues: blankNode[];
+    private originalValues;
     private recalculatedValues;
     private terms;
-    private logs?;
     private filterTermTypes?;
+    private logsKey?;
+    logsUrl?: string;
     baseUrl: string;
     isExternal: boolean;
-    hasLog: (log: INodeTermLog, withOrchestrator?: boolean) => boolean;
-    propertyValue: (value: string | number | (string | number)[], termId?: string) => number;
-    loading: boolean;
-    blankNodes: IBlankNodeLog[];
-    methodModelsCount: number;
-    rowsCount: number;
-    methodsById?: any;
-    onlyRequired: boolean;
-    showLegend: boolean;
     LogStatus: typeof LogStatus;
     logIcon: {
         successful: string | string[];
@@ -96,36 +40,28 @@ export declare class NodeLogsModelsComponent implements OnInit {
         "not run (user provided data retained)": string;
         "not relevant": string;
     };
+    propertyValue: (value: string | number | (string | number)[], termId?: string) => number;
+    getModelsAt: ({ configModels }: IBlankNodeLogSubValue | IBlankNodeLog, index: number) => IConfigModel | IConfigModel[];
+    requirementKeys: (requirements: {
+        [key: string]: any;
+    }) => string[];
+    requirementColor: (value: any) => "danger" | "white";
+    loading: boolean;
+    blankNodes: IBlankNodeLog[];
+    methodModelsCount: number;
+    rowsCount: number;
+    methodsById?: any;
+    onlyRequired: boolean;
+    showLegend: boolean;
     term?: string;
     suggestTerm: (text$: Observable<string>) => Observable<string[]>;
-    constructor(searchService: HeSearchService, engineService: HeEngineService);
+    constructor(nodeService: HeNodeService, searchService: HeSearchService, engineService: HeEngineService);
     ngOnInit(): Promise<void>;
-    private fetchAllTerms;
     private suggestByTerm;
     trackByBlankNode(_index: number, node: IBlankNodeLog): string;
-    keyValue(blankNodes: blankNode[], key: string): any;
-    openPopover(popover: any, { blankNode, methodId, subValue, logs }: {
-        blankNode: any;
-        methodId: any;
-        subValue: any;
-        logs: any;
-    }): any;
     get filteredType(): string;
     filterResults(): void;
-    /** Logs **/
-    private getSubvalueLogs;
-    getLogs(node: IBlankNodeLog, methodId: string, subValue?: IBlankNodeLogSubValue): any;
-    private isBackground;
-    private isUserProvided;
-    getModelsAt(node: IBlankNodeLog, index: number, subValue?: IBlankNodeLogSubValue): IConfigModel | IConfigModel[];
-    methodName(node: IBlankNodeLog, methodId: string, subValue?: IBlankNodeLogSubValue): any;
-    hasLogDetails(node: IBlankNodeLog, methodId: string, subValue?: IBlankNodeLogSubValue): any;
-    logStatus(node: IBlankNodeLog, methodId: string, subValue?: IBlankNodeLogSubValue): LogStatus;
-    requirementKeys(requirements: {
-        [key: string]: any;
-    }): string[];
-    requirementColor(value: any): "danger" | "white";
+    methodName({ methodId }: IConfigModel): any;
     static ɵfac: i0.ɵɵFactoryDeclaration<NodeLogsModelsComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NodeLogsModelsComponent, "he-node-logs-models", never, { "nodeType": "nodeType"; "nodeKey": "nodeKey"; "includeAllModels": "includeAllModels"; "logsUrl": "logsUrl"; "originalValues": "originalValues"; "recalculatedValues": "recalculatedValues"; "terms": "terms"; "logs": "logs"; "filterTermTypes": "filterTermTypes"; }, {}, never, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NodeLogsModelsComponent, "he-node-logs-models", never, { "node": "node"; "nodeKey": "nodeKey"; "includeAllModels": "includeAllModels"; "originalValues": "originalValues"; "recalculatedValues": "recalculatedValues"; "terms": "terms"; "filterTermTypes": "filterTermTypes"; "logsKey": "logsKey"; }, {}, never, never>;
 }
-export {};

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

@@ -0,0 +1,88 @@
+import { Emission, ITermJSONLD, Product, Input as HestiaInput, NodeType, TermTermType, Property, SchemaType } from '@hestia-earth/schema';
+import { IOrchestratorConfig, IModel } from '../engine/engine.service';
+export interface INodeMissingLookupLog {
+    filename: string;
+    termId: string;
+    column: string;
+    model?: string;
+    term?: string;
+    key?: string;
+}
+export interface INodeTermLog {
+    runRequired?: boolean;
+    shouldRun?: boolean;
+    shouldRunOrchestrator?: boolean;
+    missingLookups?: INodeMissingLookupLog[];
+    requirements?: {
+        [key: string]: any;
+    };
+    logs?: {
+        [key: string]: any;
+    };
+    [key: string]: any;
+    input?: string | string[];
+    property?: string | string[];
+}
+export interface INodeTermLogs {
+    [modelKey: string]: any | INodeTermLog;
+    models: string[];
+    isKey: boolean;
+}
+export interface INodeLogs {
+    [term: string]: INodeTermLogs;
+}
+export declare const groupLogsByModel: (data: string) => INodeLogs;
+export declare const computeTerms: (originalValues: blankNode[], recalculatedValues: blankNode[], terms?: ITermJSONLD[], filterTermTypes?: TermTermType[]) => Promise<any>;
+export declare type blankNode = Emission | Product | HestiaInput | Property;
+export declare enum LogStatus {
+    success = "successful",
+    error = "failed",
+    skipHierarchy = "not run (model higher up hierarchy run instead)",
+    dataProvided = "not run (user provided data retained)",
+    notRequired = "not relevant"
+}
+export interface IConfigModel {
+    methodId: string;
+    logs?: INodeTermLog;
+    hasLogs?: boolean;
+    status?: LogStatus;
+    model?: IModel;
+}
+export interface IBlankNodeLogSubValue {
+    key: string;
+    originalValue: number | string | boolean;
+    recalculatedValue: number | string | boolean;
+    isRecalculated: boolean;
+    isRequired?: boolean;
+    id?: any;
+    configModels?: IConfigModel[];
+    logs?: INodeTermLogs;
+}
+export interface IBlankNodeLog {
+    isOpen: boolean;
+    canOpen: boolean;
+    term: ITermJSONLD;
+    termId: string;
+    type?: SchemaType;
+    configModels: (IConfigModel | IConfigModel[])[];
+    original: blankNode[];
+    originalValue: number;
+    originalValueByMethodId?: {
+        [methodId: string]: number;
+    };
+    recalculated: blankNode[];
+    recalculatedValue: number;
+    recalculatedValueByMethodId?: {
+        [methodId: string]: number;
+    };
+    isOriginal: boolean;
+    isRecalculated: boolean;
+    hasData: boolean;
+    isRequired: boolean;
+    logs?: INodeTermLogs;
+    keys: IBlankNodeLogSubValue[];
+    subValues: IBlankNodeLogSubValue[];
+    allParallel?: boolean;
+}
+export declare const groupLogsByTerm: (nodeType: NodeType, logs: INodeLogs, models: IModel[], config: IOrchestratorConfig, allOriginalValues: blankNode[], allRecalculatedValues: blankNode[], nodeKey?: string) => (term: ITermJSONLD) => IBlankNodeLog;
+export declare const modelCount: (blankNodeLogs: IBlankNodeLog[]) => any;

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

@@ -1,6 +1,7 @@
 import { OnInit } from '@angular/core';
 import { JSONLD, NodeType } from '@hestia-earth/schema';
-import { INodeMissingLookupLog, HeNodeService } from '../node.service';
+import { INodeMissingLookupLog } from '../node-logs.model';
+import { HeNodeService } from '../node.service';
 import * as i0 from "@angular/core";
 export declare class NodeMissingLookupFactorsComponent implements OnInit {
     nodeService: HeNodeService;

package/node/node.service.d.ts

@@ -1,6 +1,7 @@
 import { HttpClient } from '@angular/common/http';
 import { DataState } from '@hestia-earth/api';
 import { ICycleJSONLD, IImpactAssessmentJSONLD, ISiteJSONLD, NodeType, TermTermType } from '@hestia-earth/schema';
+import { INodeMissingLookupLog } from './node-logs.model';
 import { HeCommonService } from '../common/common.service';
 import { HeAuthService } from '../auth/auth.service';
 import * as i0 from "@angular/core";
@@ -32,37 +33,6 @@ export interface IJSONData {
     [NodeType.Site]?: ISiteJSONLD[];
     [NodeType.ImpactAssessment]?: IImpactAssessmentJSONLD[];
 }
-export interface INodeMissingLookupLog {
-    filename: string;
-    termId: string;
-    column: string;
-    model?: string;
-    term?: string;
-    key?: string;
-}
-export interface INodeTermLog {
-    model: string;
-    isKey: boolean;
-    runRequired?: boolean;
-    shouldRun?: boolean;
-    shouldRunOrchestrator?: boolean;
-    missingLookups?: INodeMissingLookupLog[];
-    requirements?: {
-        [key: string]: any;
-    };
-    logs?: {
-        [key: string]: any;
-    };
-    [key: string]: any;
-    input?: string | string[];
-    property?: string | string[];
-}
-export interface INodeTermLogs {
-    [modelKey: string]: INodeTermLog;
-}
-export interface INodeLogs {
-    [term: string]: INodeTermLogs;
-}
 export declare class HeNodeService {
     protected http: HttpClient;
     protected authService: HeAuthService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hestia-earth/ui-components",
-  "version": "0.2.11",
+  "version": "0.3.1",
   "description": "Hestia reusable components",
   "repository": {
     "type": "git",
@@ -23,7 +23,7 @@
     "@fortawesome/free-solid-svg-icons": "^5.15.4",
     "@google/markerclustererplus": "^5.1.3",
     "@hestia-earth/api": ">=0.12.0",
-    "@hestia-earth/glossary": "^0.5.0",
+    "@hestia-earth/glossary": "^0.6.0",
     "@hestia-earth/json-schema": "^9.0.0",
     "@hestia-earth/schema": "^9.0.0",
     "@hestia-earth/schema-convert": "^9.0.0",

package/sites/sites-maps/sites-maps.component.d.ts

@@ -8,7 +8,6 @@ export declare class SitesMapsComponent<C extends JSONLD<T>, T extends NodeType>
     private map?;
     private loadPolygons;
     private sites;
-    private selected;
     private nodes;
     center: {
         lat: number;
@@ -21,7 +20,6 @@ export declare class SitesMapsComponent<C extends JSONLD<T>, T extends NodeType>
     constructor(nodeService: HeNodeService);
     ngOnInit(): void;
     ngAfterViewInit(): Promise<void>;
-    private isSelected;
     private loadData;
     private addMarkers;
     private addTermsPolygons;
@@ -33,5 +31,5 @@ export declare class SitesMapsComponent<C extends JSONLD<T>, T extends NodeType>
     private getSites;
     private termPolygons;
     static ɵfac: i0.ɵɵFactoryDeclaration<SitesMapsComponent<any, any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SitesMapsComponent<any, any>, "he-sites-maps", never, { "loadPolygons": "loadPolygons"; "sites": "sites"; "selected": "selected"; "nodes": "nodes"; "center": "center"; "zoom": "zoom"; "showNotice": "showNotice"; }, {}, never, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SitesMapsComponent<any, any>, "he-sites-maps", never, { "loadPolygons": "loadPolygons"; "sites": "sites"; "nodes": "nodes"; "center": "center"; "zoom": "zoom"; "showNotice": "showNotice"; }, {}, never, never>;
 }

package/sites/sites-measurements/sites-measurements.component.d.ts

@@ -10,7 +10,6 @@ declare enum View {
 export declare class SitesMeasurementsComponent implements OnChanges {
     originalValues: ISiteJSONLD[];
     sites: ISiteJSONLD[];
-    selected: string[];
     dataState?: DataState;
     showDownload: boolean;
     View: typeof View;
@@ -27,13 +26,12 @@ export declare class SitesMeasurementsComponent implements OnChanges {
     private update;
     togglePopover(popover: any, context: any): any;
     get showAreaTooBig(): boolean;
-    isSelected(site: ISiteJSONLD): boolean;
     selectIndex({ target: { value } }: {
         target: {
             value: any;
         };
     }): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<SitesMeasurementsComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SitesMeasurementsComponent, "he-sites-measurements", never, { "originalValues": "originalValues"; "sites": "sites"; "selected": "selected"; "dataState": "dataState"; }, {}, never, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SitesMeasurementsComponent, "he-sites-measurements", never, { "originalValues": "originalValues"; "sites": "sites"; "dataState": "dataState"; }, {}, never, never>;
 }
 export {};

package/sites/sites-measurements-logs/sites-measurements-logs.component.d.ts

@@ -1,24 +1,57 @@
 import { OnInit } from '@angular/core';
 import { ISiteJSONLD, ITermJSONLD, Measurement, NodeType, TermTermType } from '@hestia-earth/schema';
+import { DataState } from '@hestia-earth/api';
 import { HeSearchService } from '../../search/search.service';
-import { HeNodeService } from '../../node/node.service';
 import * as i0 from "@angular/core";
 export declare class SitesMeasurementsLogsComponent implements OnInit {
     private searchService;
-    private nodeService;
     site?: ISiteJSONLD;
     originalValues: Measurement[];
     recalculatedValues: Measurement[];
     loading: boolean;
     TermTermType: typeof TermTermType;
     NodeType: typeof NodeType;
-    logsUrl?: string;
-    logs: any;
     models: ITermJSONLD[];
     measurements: ITermJSONLD[];
-    constructor(searchService: HeSearchService, nodeService: HeNodeService);
+    constructor(searchService: HeSearchService);
     ngOnInit(): Promise<void>;
-    private get node();
+    get node(): {
+        dataState: DataState;
+        description?: string;
+        siteType?: import("@hestia-earth/schema").SiteSiteType;
+        organisation?: import("@hestia-earth/schema").Organisation;
+        tenure?: import("@hestia-earth/schema").SiteTenure;
+        defaultSource?: import("@hestia-earth/schema").Source;
+        numberOfSites?: number;
+        boundary?: any;
+        area?: number;
+        areaSd?: number;
+        latitude?: number;
+        longitude?: number;
+        country?: import("@hestia-earth/schema").Term;
+        region?: import("@hestia-earth/schema").Term;
+        ecoregion?: string;
+        awareWaterBasinId?: string;
+        glnNumber?: string;
+        startDate?: string;
+        endDate?: string;
+        measurements?: Measurement[];
+        infrastructure?: import("@hestia-earth/schema").Infrastructure[];
+        practices?: import("@hestia-earth/schema").Practice[];
+        originalId?: string;
+        schemaVersion?: string;
+        added?: string[];
+        addedVersion?: string[];
+        updated?: string[];
+        updatedVersion?: string[];
+        aggregated?: boolean;
+        aggregatedVersion?: string;
+        dataPrivate?: boolean;
+        '@context': string | (string | import("@hestia-earth/schema").IContext)[];
+        '@type': NodeType.Site;
+        '@id': string;
+        name: string;
+    };
     static ɵfac: i0.ɵɵFactoryDeclaration<SitesMeasurementsLogsComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<SitesMeasurementsLogsComponent, "he-sites-measurements-logs", never, { "site": "site"; "originalValues": "originalValues"; "recalculatedValues": "recalculatedValues"; }, {}, never, never>;
 }