node-opcua-aggregates 2.76.2 → 2.78.0

package/source/aggregates.ts

@@ -1,19 +1,23 @@
 /**
  * @module node-opcua-aggregates
  */
-import { AggregateFunction } from "node-opcua-constants";
-import { makeNodeId } from "node-opcua-nodeid";
+import { AggregateFunction, ObjectIds, ObjectTypeIds, ReferenceTypeIds } from "node-opcua-constants";
+import { coerceNodeId, makeNodeId, NodeId, NodeIdLike, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
 import * as utils from "node-opcua-utils";
 import { DataType } from "node-opcua-variant";
 import {
     AddressSpace,
     BaseNode,
+    IAddressSpace,
+    UAHistoricalDataConfiguration,
     UAHistoryServerCapabilities,
     UAObject,
     UAServerCapabilities,
     UAVariable
 } from "node-opcua-address-space";
 import { AddressSpacePrivate } from "node-opcua-address-space/src/address_space_private";
+import { BrowseDirection, coerceQualifiedName, NodeClass, NodeClassMask } from "node-opcua-data-model";
+import { assert } from "node-opcua-assert";
 
 import { AggregateConfigurationOptionsEx } from "./interval";
 import { readProcessedDetails } from "./read_processed_details";
@@ -121,53 +125,11 @@ function setHistoricalServerCapabilities(historyServerCapabilities: any, default
     // xx setBoolean("InsertAnnotationsCapability");
 }
 
-export type AggregateFunctionName =
-    | "AnnotationCount"
-    | "Average"
-    | "Count"
-    | "Delta"
-    | "DeltaBounds"
-    | "DurationBad"
-    | "DurationGood"
-    | "DurationInStateNonZero"
-    | "DurationInStateZero"
-    | "EndBound"
-    | "Interpolative"
-    | "Maximum"
-    | "Maximum2"
-    | "MaximumActualTime"
-    | "MaximumActualTime2"
-    | "Minimum"
-    | "Minimum2"
-    | "MinimumActualTime"
-    | "MinimumActualTime2"
-    | "NumberOfTransitions"
-    | "PercentBad"
-    | "PercentGood"
-    | "Range"
-    | "Range2"
-    | "StandardDeviationPopulation"
-    | "StandardDeviationSample"
-    | "Start"
-    | "StartBound"
-    | "TimeAverage"
-    | "TimeAverage2"
-    | "Total"
-    | "Total2"
-    | "VariancePopulation"
-    | "VarianceSample"
-    | "WorstQuality"
-    | "WorstQuality2";
-
 interface UAHistoryServerCapabilitiesWithH extends UAServerCapabilities {
     historyServerCapabilities: UAHistoryServerCapabilities;
 }
-function addAggregateFunctionSupport(addressSpace: AddressSpace, functionName: number): void {
-    /* istanbul ignore next */
-    if (!functionName) {
-        throw new Error("Invalid function name");
-    }
 
+export function addAggregateFunctionSupport(addressSpace: AddressSpace, aggregateFunctionNodeId: NodeIdLike): void {
     const serverCapabilities = addressSpace.rootFolder.objects.server.serverCapabilities as UAHistoryServerCapabilitiesWithH;
 
     /* istanbul ignore next */
@@ -179,12 +141,19 @@ function addAggregateFunctionSupport(addressSpace: AddressSpace, functionName: n
 
     const aggregateFunctionsInHist = serverCapabilities.historyServerCapabilities.aggregateFunctions;
 
-    const functionNodeId = makeNodeId(functionName);
-    const functionNode = addressSpace.getNamespace(0).findNode(functionNodeId);
+    const functionNode = addressSpace.findNode(aggregateFunctionNodeId);
 
     /* istanbul ignore next */
     if (!functionNode) {
-        throw new Error("Cannot find node " + functionName + " in addressSpace");
+        throw new Error("Cannot find node " + aggregateFunctionNodeId.toString() + " in addressSpace");
+    }
+    /* istanbul ignore next */
+    if (functionNode.nodeClass !== NodeClass.Object) {
+        throw new Error("Expecting an object Node");
+    }
+    /* istanbul ignore next */
+    if (!sameNodeId((functionNode as UAObject).typeDefinition, coerceNodeId(ObjectTypeIds.AggregateFunctionType))) {
+        throw new Error("Expecting an object with TypeDefinition AggregateFunctionType");
     }
 
     aggregateFunctions.addReference({
@@ -197,7 +166,23 @@ function addAggregateFunctionSupport(addressSpace: AddressSpace, functionName: n
     });
 }
 
-export function addAggregateSupport(addressSpace: AddressSpace): void {
+export function addAggregateStandardFunctionSupport(addressSpace: AddressSpace, functionName: AggregateFunction): void {
+    /* istanbul ignore next */
+    if (!functionName) {
+        throw new Error("Invalid function name");
+    }
+    const functionNodeId = makeNodeId(functionName);
+    addAggregateFunctionSupport(addressSpace, functionNodeId);
+}
+
+export function addAggregateSupport(addressSpace: AddressSpace, aggregatedFunctions?: AggregateFunction[]): void {
+    aggregatedFunctions = aggregatedFunctions || [
+        AggregateFunction.Interpolative,
+        AggregateFunction.Minimum,
+        AggregateFunction.Maximum,
+        AggregateFunction.Average
+    ];
+
     const aggregateConfigurationType = addressSpace.getNamespace(0).findObjectType("AggregateConfigurationType");
 
     /* istanbul ignore next */
@@ -232,37 +217,108 @@ export function addAggregateSupport(addressSpace: AddressSpace): void {
 
     setHistoricalServerCapabilities(historyServerCapabilities, historicalCapabilitiesDefaultProperties);
 
-    addAggregateFunctionSupport(addressSpace, AggregateFunction.Interpolative);
-    addAggregateFunctionSupport(addressSpace, AggregateFunction.Minimum);
-    addAggregateFunctionSupport(addressSpace, AggregateFunction.Maximum);
-    addAggregateFunctionSupport(addressSpace, AggregateFunction.Average);
-
+    for (const f of aggregatedFunctions) {
+        addAggregateStandardFunctionSupport(addressSpace, f);
+    }
     const addressSpaceInternal = addressSpace as unknown as AddressSpacePrivate;
     addressSpaceInternal._readProcessedDetails = readProcessedDetails;
 }
 
-export function installAggregateConfigurationOptions(node: UAVariable, options: AggregateConfigurationOptionsEx): void {
-    const nodePriv = node as any;
+interface BaseNodeWithHistoricalDataConfiguration extends UAVariable {
+    $historicalDataConfiguration: UAHistoricalDataConfiguration;
+}
+
+export function getAggregateFunctions(addressSpace: IAddressSpace): NodeId[] {
+    const aggregateFunctionTypeNodeId = resolveNodeId(ObjectTypeIds.AggregateFunctionType);
+    const aggregateFunctions = addressSpace.findNode(ObjectIds.Server_ServerCapabilities_AggregateFunctions) as UAObject;
+    if (!aggregateFunctions) {
+        return [];
+    }
+    const referenceDescripitions = aggregateFunctions.browseNode({
+        referenceTypeId: ReferenceTypeIds.HierarchicalReferences,
+        resultMask: 63,
+        nodeClassMask: NodeClassMask.Object,
+        browseDirection: BrowseDirection.Forward,
+        includeSubtypes: true
+    });
+    const aggregateFunctionsNodeIds = referenceDescripitions
+        .filter((a) => sameNodeId(a.typeDefinition, aggregateFunctionTypeNodeId))
+        .map((a) => a.nodeId);
+    return aggregateFunctionsNodeIds;
+}
+
+/**
+ * Install aggregateConfiguration on an historizing variable
+ * 
+ * @param node the variable on which to add the aggregateConfiguration.
+ * @param options the default AggregateConfigurationOptions.
+ * @param aggregateFunctions the aggregatedFunctions, if not specified the aggregatedFunction of ServerCapabilities.AggregatedFunction will be used.
+
+ */
+export function installAggregateConfigurationOptions(
+    node: UAVariable,
+    options: AggregateConfigurationOptionsEx,
+    aggregateFunctions?: NodeIdLike[]
+): void {
+    const nodePriv = node as BaseNodeWithHistoricalDataConfiguration;
+
+    // istanbul ignore next
+    if (!nodePriv.historizing) {
+        throw new Error(
+            "variable.historizing is not set\n make sure addressSpace.installHistoricalDataNode(variable) has been called"
+        );
+    }
+
     const aggregateConfiguration = nodePriv.$historicalDataConfiguration.aggregateConfiguration;
-    aggregateConfiguration.percentDataBad.setValueFromSource({ dataType: "Byte", value: options.percentDataBad });
-    aggregateConfiguration.percentDataGood.setValueFromSource({ dataType: "Byte", value: options.percentDataGood });
+
+    const f = (a: number | boolean | undefined, defaultValue: number | boolean): number | boolean =>
+        a === undefined ? defaultValue : a;
+
+    aggregateConfiguration.percentDataBad.setValueFromSource({ dataType: "Byte", value: f(options.percentDataBad, 100) });
+    aggregateConfiguration.percentDataGood.setValueFromSource({ dataType: "Byte", value: f(options.percentDataGood, 100) });
     aggregateConfiguration.treatUncertainAsBad.setValueFromSource({
         dataType: "Boolean",
-        value: options.treatUncertainAsBad
+        value: f(options.treatUncertainAsBad, false)
     });
     aggregateConfiguration.useSlopedExtrapolation.setValueFromSource({
         dataType: "Boolean",
-        value: options.useSlopedExtrapolation
+        value: f(options.useSlopedExtrapolation, false)
     });
 
     nodePriv.$historicalDataConfiguration.stepped.setValueFromSource({
         dataType: "Boolean",
-        value: options.stepped
+        value: f(options.stepped, false)
     });
+    // https://reference.opcfoundation.org/v104/Core/docs/Part13/4.4/
+    // Exposing Supported Functions and Capabilities
+    if (!aggregateFunctions) {
+        aggregateFunctions = getAggregateFunctions(node.addressSpace);
+    }
+
+    let uaAggregateFunctions = nodePriv.$historicalDataConfiguration.aggregateFunctions;
+    if (!uaAggregateFunctions) {
+        const namespace = nodePriv.namespace;
+        uaAggregateFunctions = namespace.addObject({
+            browseName: coerceQualifiedName({ name: "AggregateFunctions", namespaceIndex: 0 }),
+            componentOf: nodePriv.$historicalDataConfiguration
+        });
+        uaAggregateFunctions = nodePriv.$historicalDataConfiguration.aggregateFunctions;
+    }
+    // verify that all aggregateFunctions are of type AggregateFunctionType
+    // ... to do
+
+    const referenceType = resolveNodeId(ReferenceTypeIds.Organizes);
+    for (const nodeId of aggregateFunctions) {
+        uaAggregateFunctions!.addReference({
+            nodeId,
+            referenceType,
+            isForward: true
+        });
+    }
 }
 
 export function getAggregateConfiguration(node: BaseNode): AggregateConfigurationOptionsEx {
-    const nodePriv = node as any;
+    const nodePriv = node as BaseNodeWithHistoricalDataConfiguration;
 
     /* istanbul ignore next */
     if (!nodePriv.$historicalDataConfiguration) {

package/source/calculate_bad_good.ts

@@ -0,0 +1,148 @@
+import { extraStatusCodeBits, StatusCode, StatusCodes } from "node-opcua-status-code";
+
+import { Interval, AggregateConfigurationOptions, isUncertain, isBad, isGoodish2, isGoodish } from "./interval";
+
+// function isBadWithUncertain(statusCode: StatusCode, treatUncertainAsBad?: boolean): boolean {
+//     if (isGoodish(statusCode)) return false;
+
+//     if (isUncertain(statusCode)) {
+//         return treatUncertainAsBad || false;
+//     }
+//     return true;
+// }
+
+const a = (s: StatusCode | undefined, options: AggregateConfigurationOptions) =>
+    !s || s === StatusCodes.BadNoData
+        ? StatusCodes.BadNoData
+        : isBad(s) || (options.treatUncertainAsBad && isUncertain(s))
+        ? StatusCodes.Bad
+        : StatusCodes.Good;
+
+function findLowBound(
+    interval: Interval,
+    options: AggregateConfigurationOptions
+): { previousStatus: StatusCode; previousTime: number; indexStart: number } {
+    const indexStart: number = interval.index;
+
+    const initialValue = interval.dataValues[indexStart];
+    if (initialValue.sourceTimestamp!.getTime() === interval.startTime.getTime()) {
+        return { previousStatus: initialValue.statusCode, previousTime: interval.startTime.getTime(), indexStart: indexStart + 1 };
+    }
+    const previousStatus =
+        indexStart === 0 || !interval.dataValues[indexStart - 1]
+            ? StatusCodes.BadNoData
+            : a(interval.dataValues[indexStart - 1].statusCode, options);
+    const previousTime = interval.startTime.getTime();
+    return { previousStatus, previousTime, indexStart };
+}
+
+// eslint-disable-next-line max-statements, complexity
+export function calculateBadAndGood(
+    interval: Interval,
+    options: AggregateConfigurationOptions
+): {
+    durationGood: number;
+    durationBad: number;
+    durationUnknown: number;
+    percentBad: number;
+    percentGood: number;
+    statusCode: StatusCode;
+} {
+    if (interval.count === 0) {
+        return {
+            durationGood: 0,
+            durationBad: 0,
+            durationUnknown: 0,
+            percentBad: 0,
+            percentGood: 0,
+            statusCode: StatusCodes.BadNoData
+        };
+    }
+    let durationGood = 0;
+    let durationBad = 0;
+    let durationUnknown = 0;
+
+    let partialFlag = interval.isPartial ? extraStatusCodeBits.HistorianPartial : 0;
+
+    let { previousStatus, previousTime, indexStart } = findLowBound(interval, options);
+
+    if (previousStatus === StatusCodes.BadNoData) {
+        partialFlag = extraStatusCodeBits.HistorianPartial;
+        previousStatus = StatusCodes.Bad;
+    }
+
+    let nbGood = 0;
+    let nbBad = 0;
+    let nbUncertain = 0;
+    indexStart += 0;
+    for (let i = indexStart; i < interval.index + interval.count; i++) {
+        const dataValue = interval.dataValues[i];
+        if (isGoodish(dataValue.statusCode)) {
+            nbGood++;
+        }
+        if (isUncertain(dataValue.statusCode)) {
+            nbUncertain++;
+        }
+        if (isBad(dataValue.statusCode)) {
+            nbBad++;
+        }
+        const currentStatus = a(dataValue.statusCode, options);
+        if (currentStatus === StatusCodes.BadNoData) {
+            partialFlag = extraStatusCodeBits.HistorianPartial;
+        }
+        const currentTime = dataValue.sourceTimestamp!.getTime();
+
+        // console.log(" ", dataValue.sourceTimestamp?.toISOString(), dataValue.statusCode.toString(), dataValue.value.value);
+
+        if (currentStatus === previousStatus) continue;
+        if (previousStatus === StatusCodes.Good) {
+            // if (isBadWithUncertain(currentStatus, options.treatUncertainAsBad)) {
+            //     durationBad += currentTime - previousTime;
+            // } else {
+            durationGood += currentTime - previousTime;
+            // }
+        } else if (previousStatus === StatusCodes.BadNoData) {
+            durationUnknown += currentTime - previousTime;
+        } else {
+            durationBad += currentTime - previousTime;
+        }
+        previousStatus = currentStatus;
+        previousTime = currentTime;
+    }
+
+    // final step
+    const currentTime = interval.getEffectiveEndTime();
+    if (previousStatus === StatusCodes.Good) {
+        durationGood += currentTime - previousTime;
+    } else if (previousStatus === StatusCodes.BadNoData) {
+        durationUnknown += currentTime - previousTime;
+    } else {
+        durationBad += currentTime - previousTime;
+    }
+
+    if (nbGood === 0) {
+        if (nbBad > 0) {
+            // we need at lest a Good Status in the intervale to be good & no bad !
+            durationGood = -1;
+        } else {
+            durationGood = 0;
+        }
+    }
+    const effectiveProcessingInterval = currentTime - interval.startTime.getTime();
+
+    const percentGood = (durationGood / effectiveProcessingInterval) * 100;
+    const percentBad = (durationBad / effectiveProcessingInterval) * 100;
+
+    let percentDataGood = options.percentDataGood === undefined ? 100 : options.percentDataGood;
+    const percentDataBad = options.percentDataBad === undefined ? 100 : options.percentDataBad;
+
+    if (percentBad >= percentDataBad || (nbGood === 0 && nbUncertain === 0)) {
+        durationGood = 0; // BAD
+        percentDataGood = -1;
+        // const statusCode = StatusCodes.Bad;
+        //return { durationGood, durationBad, durationUnknown, percentBad, percentGood, statusCode };
+    }
+    const statusCode = StatusCode.makeStatusCode(StatusCodes.Good, extraStatusCodeBits.HistorianCalculated | partialFlag);
+
+    return { durationGood, durationBad, durationUnknown, percentBad, percentGood, statusCode };
+}

package/source/common.ts

@@ -5,21 +5,14 @@ import { SessionContext, UAVariable, ContinuationPointManager, ContinuationPoint
 import { NodeClass } from "node-opcua-data-model";
 import { DataValue } from "node-opcua-data-value";
 import { HistoryData, HistoryReadResult, ReadRawModifiedDetails } from "node-opcua-service-history";
-import { StatusCode } from "node-opcua-status-code";
+import { StatusCode, StatusCodes } from "node-opcua-status-code";
 import { coerceNodeId } from "node-opcua-nodeid";
 
 import { getAggregateConfiguration } from "./aggregates";
-import { getInterval, Interval, AggregateConfigurationOptionsEx } from "./interval";
+import { getInterval, Interval, AggregateConfigurationOptionsEx, isBad, isGood, isUncertain } from "./interval";
 
 /**
  * @internal
- * @param node
- * @param processingInterval
- * @param startDate
- * @param endDate
- * @param dataValues
- * @param lambda
- * @param callback
  */
 function processAggregateData(
     node: UAVariable,
@@ -52,6 +45,7 @@ function processAggregateData(
             throw Error("invalid DataValue");
         }
         results.push(dataValue);
+        // console.log(" => ", dataValue.sourceTimestamp.toISOString(), dataValue.statusCode.toString(), dataValue.value.value);
     }
 
     setImmediate(() => {

package/source/count.ts

@@ -0,0 +1,98 @@
+import { UAVariable } from "node-opcua-address-space";
+import { DataValue } from "node-opcua-data-value";
+import { extraStatusCodeBits, StatusCode, StatusCodes } from "node-opcua-status-code";
+import { DataType } from "node-opcua-variant";
+
+import { getAggregateData } from "./common";
+import { Interval, AggregateConfigurationOptions, isBad, isUncertain, isGoodish } from "./interval";
+
+/**
+ * The Count Aggregate retrieves a count of all the raw values within an interval.
+ *  If one or more raw values are non-Good, they are not included in the count, and the Aggregate
+ *  StatusCode is determined using the StatusCode Calculation for non-time based Aggregates.
+ * If no Good data exists for an interval, the count is zero.
+ */
+function calculateCountValue(interval: Interval, options: AggregateConfigurationOptions): DataValue {
+    const indexStart = interval.index;
+    let statusCode: StatusCode = StatusCodes.Good;
+    let isPartial = interval.isPartial;
+
+    let nbBad = 0;
+    let nbGood = 0;
+    let nbUncertain = 0;
+    let badDuration = 0;
+    let uncertainDuration = 0;
+    let goodDuration = 0;
+    for (let i = indexStart; i < indexStart + interval.count; i++) {
+        const dataValue = interval.dataValues[i];
+        if (dataValue.statusCode === StatusCodes.BadNoData) {
+            isPartial = true;
+            continue;
+        }
+        const regionDuration = interval.regionDuration(i);
+        if (isBad(dataValue.statusCode)) {
+            nbBad++;
+            badDuration += regionDuration;
+        } else if (isUncertain(dataValue.statusCode)) {
+            nbUncertain++;
+            uncertainDuration += regionDuration;
+        } else if (isGoodish(dataValue.statusCode)) {
+            nbGood++;
+            goodDuration += regionDuration;
+        }
+    }
+
+    const partialFlag = isPartial ? extraStatusCodeBits.HistorianPartial : 0;
+
+    // console.log(" ", goodDuration, uncertainDuration, badDuration);
+
+    if (nbBad > 0) {
+        const duration = interval.duration();
+        if(options.treatUncertainAsBad) {
+            badDuration += uncertainDuration;
+        }
+        const actualPercentDataBad = (badDuration / duration) * 100.0;
+        const percentDataBad = options.percentDataBad === undefined ? 100 : options.percentDataBad;
+        if (actualPercentDataBad >= percentDataBad) {
+            return new DataValue({
+                sourceTimestamp: interval.startTime,
+                statusCode: StatusCodes.Bad
+            });
+        }
+    }
+    if (nbUncertain > 0 || nbBad > 0) {
+        statusCode = StatusCode.makeStatusCode(
+            StatusCodes.UncertainDataSubNormal,
+            extraStatusCodeBits.HistorianCalculated | partialFlag
+        );
+    } else {
+        statusCode = StatusCode.makeStatusCode(StatusCodes.Good, extraStatusCodeBits.HistorianCalculated | partialFlag);
+    }
+
+    if (nbUncertain === 0 && nbGood === 0) {
+        statusCode = StatusCodes.BadNoData;
+        return new DataValue({
+            sourceTimestamp: interval.startTime,
+            statusCode: statusCode as StatusCode
+        });
+    }
+
+    return new DataValue({
+        sourceTimestamp: interval.startTime,
+        statusCode: statusCode as StatusCode,
+        value: {
+            dataType: DataType.UInt32,
+            value: nbGood
+        }
+    });
+}
+
+export function getCountData(
+    node: UAVariable,
+    processingInterval: number,
+    startDate: Date,
+    endDate: Date,
+    callback: (err: Error | null, dataValues?: DataValue[]) => void
+): void {
+    getAggregateData(node, processingInterval, startDate, endDate, calculateCountValue, callback);
+}

package/source/duration_bad.ts

@@ -0,0 +1,37 @@
+import { UAVariable } from "node-opcua-address-space";
+import { DataValue } from "node-opcua-data-value";
+import { DataType } from "node-opcua-variant";
+import { StatusCodes } from "node-opcua-status-code";
+
+import { getAggregateData } from "./common";
+import { Interval, AggregateConfigurationOptions, isGoodish } from "./interval";
+import { calculateBadAndGood } from "./calculate_bad_good";
+
+function calculateDurationBad(interval: Interval, options: AggregateConfigurationOptions): DataValue {
+    const { durationBad, durationUnknown, statusCode } = calculateBadAndGood(interval, options);
+    if (durationUnknown > 0 && durationBad === 0) {
+        return new DataValue({
+            sourceTimestamp: interval.startTime,
+            statusCode: StatusCodes.Bad
+        });
+    }
+    const value = durationBad;
+    if (isGoodish(statusCode)) {
+        return new DataValue({
+            sourceTimestamp: interval.startTime,
+            statusCode,
+            value: { dataType: DataType.Double, value }
+        });
+    }
+    return new DataValue({ sourceTimestamp: interval.startTime, statusCode, value: { dataType: DataType.Null } });
+}
+/**Retrieve the percentage of data (0 to 100) in the interval which has Bad StatusCode. */
+export function getDurationBadData(
+    node: UAVariable,
+    processingInterval: number,
+    startDate: Date,
+    endDate: Date,
+    callback: (err: Error | null, dataValues?: DataValue[]) => void
+): void {
+    getAggregateData(node, processingInterval, startDate, endDate, calculateDurationBad, callback);
+}

package/source/duration_good.ts

@@ -0,0 +1,37 @@
+import { UAVariable } from "node-opcua-address-space";
+import { DataValue } from "node-opcua-data-value";
+import { DataType } from "node-opcua-variant";
+import { StatusCodes } from "node-opcua-status-code";
+
+import { getAggregateData } from "./common";
+import { Interval, AggregateConfigurationOptions, isGoodish } from "./interval";
+import { calculateBadAndGood } from "./calculate_bad_good";
+
+function calculateDurationGood(interval: Interval, options: AggregateConfigurationOptions): DataValue {
+    const { durationGood, durationUnknown, statusCode } = calculateBadAndGood(interval, options);
+    if (durationUnknown>0  && durationGood ===0) {
+        return new DataValue({
+            sourceTimestamp: interval.startTime,
+            statusCode: StatusCodes.Bad
+        });
+    }
+    const value = durationGood;
+    if (isGoodish(statusCode)) {
+        return new DataValue({
+            sourceTimestamp: interval.startTime,
+            statusCode,
+            value: { dataType: DataType.Double, value }
+        });
+    }
+    return new DataValue({ sourceTimestamp: interval.startTime, statusCode, value: { dataType: DataType.Null } });
+}
+/**Retrieve the percentage of data (0 to 100) in the interval which has Bad StatusCode. */
+export function getDurationGoodData(
+    node: UAVariable,
+    processingInterval: number,
+    startDate: Date,
+    endDate: Date,
+    callback: (err: Error | null, dataValues?: DataValue[]) => void
+): void {
+    getAggregateData(node, processingInterval, startDate, endDate, calculateDurationGood, callback);
+}

package/source/index.ts

@@ -1,7 +1,13 @@
 /**
  * @module node-opca-aggregates
  */
-export { addAggregateSupport, installAggregateConfigurationOptions, getAggregateConfiguration } from "./aggregates";
+export {
+    addAggregateSupport,
+    installAggregateConfigurationOptions,
+    getAggregateConfiguration,
+    addAggregateStandardFunctionSupport,
+    addAggregateFunctionSupport
+} from "./aggregates";
 export * from "./interpolate";
 export * from "./minmax";
 export * from "./interval";