@utiliread/primitives 1.0.0-145 → 1.0.0-147

package/dist/index.js

@@ -0,0 +1,2842 @@
+'use strict';
+
+var luxon = require('luxon');
+
+const units$c = ["decibel"];
+const sqUnits$5 = ["decibel2"];
+
+const acousticNoise = {
+    id: "acousticNoise",
+    measure: "noise",
+    aggregate: "instant",
+    units: units$c,
+};
+const minAcousticNoise = {
+    id: "minAcousticNoise",
+    measure: "noise",
+    aggregate: "min",
+    units: units$c,
+};
+const maxAcousticNoise = {
+    id: "maxAcousticNoise",
+    measure: "noise",
+    aggregate: "max",
+    units: units$c,
+};
+const avgAcousticNoise = {
+    id: "avgAcousticNoise",
+    measure: "noise",
+    aggregate: "avg",
+    units: units$c,
+};
+const sumAcousticNoise = {
+    id: "sumAcousticNoise",
+    measure: "noise",
+    aggregate: "sum",
+    units: units$c,
+};
+const cntAcousticNoise = {
+    id: "cntAcousticNoise",
+    measure: "noise",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+const ssqAcousticNoise = {
+    id: "ssqAcousticNoise",
+    measure: "noise",
+    aggregate: "ssq",
+    units: sqUnits$5,
+};
+
+const units$b = ["celcius", "kelvin", "fahrenheit"];
+const sqUnits$4 = [
+    "celcius2",
+    "kelvin2",
+    "fahrenheit2",
+];
+
+const ambientTemperature = {
+    id: "ambientTemperature",
+    measure: "temperature",
+    aggregate: "instant",
+    units: units$b,
+};
+const minAmbientTemperature = {
+    id: "minAmbientTemperature",
+    measure: "temperature",
+    aggregate: "min",
+    units: units$b,
+};
+const maxAmbientTemperature = {
+    id: "maxAmbientTemperature",
+    measure: "temperature",
+    aggregate: "max",
+    units: units$b,
+};
+const avgAmbientTemperature = {
+    id: "avgAmbientTemperature",
+    measure: "temperature",
+    aggregate: "avg",
+    units: units$b,
+};
+const sumAmbientTemperature = {
+    id: "sumAmbientTemperature",
+    measure: "temperature",
+    aggregate: "sum",
+    units: units$b,
+};
+const cntAmbientTemperature = {
+    id: "cntAmbientTemperature",
+    measure: "temperature",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+const ssqAmbientTemperature = {
+    id: "ssqAmbientTemperature",
+    measure: "temperature",
+    aggregate: "ssq",
+    units: sqUnits$4,
+};
+
+const units$a = ["unitless", "json"];
+
+const axiomaInfocode = {
+    id: "axiomaInfocode",
+    measure: "none",
+    aggregate: "instant",
+    units: units$a,
+};
+const axiomaInfocodeType1 = {
+    id: "axiomaInfocodeType1",
+    measure: "none",
+    aggregate: "instant",
+    units: units$a,
+};
+
+const consumer = {
+    id: "consumer",
+    measure: "none",
+    aggregate: "instant",
+    units: ["unitless"],
+    immediate: true,
+};
+
+const units$9 = [
+    "milliWattHour",
+    "wattHour",
+    "kiloWattHour",
+    "megaWattHour",
+    "gigaWattHour",
+    "calorie",
+    "kiloCalorie",
+    "megaCalorie",
+    "gigaCalorie",
+];
+
+const coolingEnergyVolumeInInlet = {
+    id: "coolingEnergyVolumeInInlet",
+    measure: "energy",
+    aggregate: "instant",
+    units: units$9,
+};
+const diffCoolingEnergyVolumeInInlet = {
+    id: "diffCoolingEnergyVolumeInInlet",
+    measure: "energy",
+    aggregate: "diff",
+    units: units$9,
+};
+const cntCoolingEnergyVolumeInInlet = {
+    id: "cntCoolingEnergyVolumeInInlet",
+    measure: "energy",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+
+const coolingEnergyVolumeInOutlet = {
+    id: "coolingEnergyVolumeInOutlet",
+    measure: "energy",
+    aggregate: "instant",
+    units: units$9,
+};
+const diffCoolingEnergyVolumeInOutlet = {
+    id: "diffCoolingEnergyVolumeInOutlet",
+    measure: "energy",
+    aggregate: "diff",
+    units: units$9,
+};
+const cntCoolingEnergyVolumeInOutlet = {
+    id: "cntCoolingEnergyVolumeInOutlet",
+    measure: "energy",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+
+const coolingEnergy = {
+    id: "coolingEnergy",
+    measure: "energy",
+    aggregate: "instant",
+    units: units$9,
+};
+const diffCoolingEnergy = {
+    id: "diffCoolingEnergy",
+    measure: "energy",
+    aggregate: "diff",
+    units: units$9,
+};
+const cntCoolingEnergy = {
+    id: "cntCoolingEnergy",
+    measure: "energy",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+
+const inletMinusOutletFlowTemperatureDifference = {
+    id: "inletMinusOutletFlowTemperatureDifference",
+    measure: "temperature",
+    aggregate: "instant",
+    units: units$b,
+};
+const minInletMinusOutletFlowTemperatureDifference = {
+    id: "minInletMinusOutletFlowTemperatureDifference",
+    measure: "temperature",
+    aggregate: "min",
+    units: units$b,
+};
+const maxInletMinusOutletFlowTemperatureDifference = {
+    id: "maxInletMinusOutletFlowTemperatureDifference",
+    measure: "temperature",
+    aggregate: "max",
+    units: units$b,
+};
+const avgInletMinusOutletFlowTemperatureDifference = {
+    id: "avgInletMinusOutletFlowTemperatureDifference",
+    measure: "temperature",
+    aggregate: "avg",
+    units: units$b,
+};
+const sumInletMinusOutletFlowTemperatureDifference = {
+    id: "sumInletMinusOutletFlowTemperatureDifference",
+    measure: "temperature",
+    aggregate: "sum",
+    units: units$b,
+};
+const cntInletMinusOutletFlowTemperatureDifference = {
+    id: "cntInletMinusOutletFlowTemperatureDifference",
+    measure: "temperature",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+const ssqInletMinusOutletFlowTemperatureDifference = {
+    id: "ssqInletMinusOutletFlowTemperatureDifference",
+    measure: "temperature",
+    aggregate: "ssq",
+    units: sqUnits$4,
+};
+const outletMinusInletFlowTemperatureDifference = {
+    id: "outletMinusInletFlowTemperatureDifference",
+    measure: "temperature",
+    aggregate: "instant",
+    units: units$b,
+};
+const minOutletMinusInletFlowTemperatureDifference = {
+    id: "minOutletMinusInletFlowTemperatureDifference",
+    measure: "temperature",
+    aggregate: "min",
+    units: units$b,
+};
+const maxOutletMinusInletFlowTemperatureDifference = {
+    id: "maxOutletMinusInletFlowTemperatureDifference",
+    measure: "temperature",
+    aggregate: "max",
+    units: units$b,
+};
+const avgOutletMinusInletFlowTemperatureDifference = {
+    id: "avgOutletMinusInletFlowTemperatureDifference",
+    measure: "temperature",
+    aggregate: "avg",
+    units: units$b,
+};
+const sumOutletMinusInletFlowTemperatureDifference = {
+    id: "sumOutletMinusInletFlowTemperatureDifference",
+    measure: "temperature",
+    aggregate: "sum",
+    units: units$b,
+};
+const cntOutletMinusInletFlowTemperatureDifference = {
+    id: "cntOutletMinusInletFlowTemperatureDifference",
+    measure: "temperature",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+const ssqOutletMinusInletFlowTemperatureDifference = {
+    id: "ssqOutletMinusInletFlowTemperatureDifference",
+    measure: "temperature",
+    aggregate: "ssq",
+    units: sqUnits$4,
+};
+
+const kamdraftDeviceAddresses = {
+    id: "kamdraftDeviceAddresses",
+    measure: "none",
+    aggregate: "instant",
+    units: ["json"],
+    immediate: true,
+};
+
+const msisdnDeviceAddresses = {
+    id: "msisdnDeviceAddresses",
+    measure: "none",
+    aggregate: "instant",
+    units: ["json"],
+    immediate: true,
+};
+
+const tchlrDeviceAddresses = {
+    id: "tchlrDeviceAddresses",
+    measure: "none",
+    aggregate: "instant",
+    units: ["json"],
+    immediate: true,
+};
+
+const wMBusDeviceAddresses = {
+    id: "wMBusDeviceAddresses",
+    measure: "none",
+    aggregate: "instant",
+    units: ["json"],
+    immediate: true,
+};
+
+const units$8 = [];
+
+const deviceDateTime = {
+    id: "deviceDateTime",
+    measure: "time",
+    aggregate: "instant",
+    units: units$8,
+};
+
+const deviceDate = {
+    id: "deviceDate",
+    measure: "time",
+    aggregate: "instant",
+    units: units$8,
+};
+
+const deviceNominalDiameter = {
+    id: "deviceNominalDiameter",
+    measure: "none",
+    aggregate: "instant",
+    units: ["unitless"],
+    immediate: true,
+};
+
+const devicePermanentVolumeFlow = {
+    id: "devicePermanentVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "instant",
+    units: ["cubicMetersPerHour"],
+    immediate: true,
+};
+
+const deviceRegisters = {
+    id: "deviceRegisters",
+    measure: "none",
+    aggregate: "instant",
+    units: ["json"],
+    immediate: true,
+};
+
+const legacyDeviceSamples = {
+    id: "legacyDeviceSamples",
+    measure: "none",
+    aggregate: "instant",
+    units: ["json"],
+    immediate: true,
+};
+const deviceSamplesOnLastMount = {
+    id: "deviceSamplesOnLastMount",
+    measure: "none",
+    aggregate: "instant",
+    units: ["json"],
+    immediate: true,
+};
+const deviceSamplesOnLastUnmount = {
+    id: "deviceSamplesOnLastUnmount",
+    measure: "none",
+    aggregate: "instant",
+    units: ["json"],
+    immediate: true,
+};
+
+const deviceSoftwareVersion = {
+    id: "deviceSoftwareVersion",
+    measure: "none",
+    aggregate: "instant",
+    units: ["unitless"],
+};
+
+const deviceTime = {
+    id: "deviceTime",
+    measure: "time",
+    aggregate: "instant",
+    units: units$8,
+};
+
+const device = {
+    id: "device",
+    measure: "none",
+    aggregate: "instant",
+    units: ["json"],
+    immediate: true,
+};
+
+const diehlInfocode = {
+    id: "diehlInfocode",
+    measure: "none",
+    aggregate: "instant",
+    units: units$a,
+};
+const diehlInfocodeType1 = {
+    id: "diehlInfocodeType1",
+    measure: "none",
+    aggregate: "instant",
+    units: units$a,
+};
+const diehlInfocodeType2 = {
+    id: "diehlInfocodeType2",
+    measure: "none",
+    aggregate: "instant",
+    units: units$a,
+};
+const diehlInfocodeType3 = {
+    id: "diehlInfocodeType3",
+    measure: "none",
+    aggregate: "instant",
+    units: units$a,
+};
+const diehlInfocodeType4 = {
+    id: "diehlInfocodeType4",
+    measure: "none",
+    aggregate: "instant",
+    units: units$a,
+};
+const diehlInfocodeType5 = {
+    id: "diehlInfocodeType5",
+    measure: "none",
+    aggregate: "instant",
+    units: units$a,
+};
+
+const electricalEnergy = {
+    id: "electricalEnergy",
+    measure: "energy",
+    aggregate: "instant",
+    units: units$9,
+};
+const diffElectricalEnergy = {
+    id: "diffElectricalEnergy",
+    measure: "energy",
+    aggregate: "diff",
+    units: units$9,
+};
+const cntElectricalEnergy = {
+    id: "cntElectricalEnergy",
+    measure: "energy",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+
+const kamstrupE8Inlet = {
+    id: "kamstrupE8Inlet",
+    measure: "energy",
+    aggregate: "instant",
+    units: ["cubicMeterCelcius", ...units$9],
+};
+const diffKamstrupE8Inlet = {
+    id: "diffKamstrupE8Inlet",
+    measure: "energy",
+    aggregate: "diff",
+    units: ["cubicMeterCelcius", ...units$9],
+};
+const cntKamstrupE8Inlet = {
+    id: "cntKamstrupE8Inlet",
+    measure: "energy",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+
+const kamstrupE9Outlet = {
+    id: "kamstrupE9Outlet",
+    measure: "energy",
+    aggregate: "instant",
+    units: ["cubicMeterCelcius", ...units$9],
+};
+const diffKamstrupE9Outlet = {
+    id: "diffKamstrupE9Outlet",
+    measure: "energy",
+    aggregate: "diff",
+    units: ["cubicMeterCelcius", ...units$9],
+};
+const cntKamstrupE9Outlet = {
+    id: "cntKamstrupE9Outlet",
+    measure: "energy",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+
+const units$7 = [
+    "second",
+    "minute",
+    "hour",
+    "day",
+    "week",
+    "month",
+    "year",
+];
+
+const errorOperatingTime = {
+    id: "errorOperatingTime",
+    measure: "duration",
+    aggregate: "instant",
+    units: units$7,
+};
+const diffErrorOperatingTime = {
+    id: "diffErrorOperatingTime",
+    measure: "duration",
+    aggregate: "diff",
+    units: units$7,
+};
+const cntErrorOperatingTime = {
+    id: "cntErrorOperatingTime",
+    measure: "duration",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+
+const auxFlowTemperature = {
+    id: "auxFlowTemperature",
+    measure: "temperature",
+    aggregate: "instant",
+    units: units$b,
+};
+const minAuxFlowTemperature = {
+    id: "minAuxFlowTemperature",
+    measure: "temperature",
+    aggregate: "min",
+    units: units$b,
+};
+const maxAuxFlowTemperature = {
+    id: "maxAuxFlowTemperature",
+    measure: "temperature",
+    aggregate: "max",
+    units: units$b,
+};
+const avgAuxFlowTemperature = {
+    id: "avgAuxFlowTemperature",
+    measure: "temperature",
+    aggregate: "avg",
+    units: units$b,
+};
+const sumAuxFlowTemperature = {
+    id: "sumAuxFlowTemperature",
+    measure: "temperature",
+    aggregate: "sum",
+    units: units$b,
+};
+const cntAuxFlowTemperature = {
+    id: "cntAuxFlowTemperature",
+    measure: "temperature",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+const ssqAuxFlowTemperature = {
+    id: "ssqAuxFlowTemperature",
+    measure: "temperature",
+    aggregate: "ssq",
+    units: sqUnits$4,
+};
+
+const inletFlowTemperature = {
+    id: "inletFlowTemperature",
+    measure: "temperature",
+    aggregate: "instant",
+    units: units$b,
+};
+const minInletFlowTemperature = {
+    id: "minInletFlowTemperature",
+    measure: "temperature",
+    aggregate: "min",
+    units: units$b,
+};
+const maxInletFlowTemperature = {
+    id: "maxInletFlowTemperature",
+    measure: "temperature",
+    aggregate: "max",
+    units: units$b,
+};
+const avgInletFlowTemperature = {
+    id: "avgInletFlowTemperature",
+    measure: "temperature",
+    aggregate: "avg",
+    units: units$b,
+};
+const sumInletFlowTemperature = {
+    id: "sumInletFlowTemperature",
+    measure: "temperature",
+    aggregate: "sum",
+    units: units$b,
+};
+const cntInletFlowTemperature = {
+    id: "cntInletFlowTemperature",
+    measure: "temperature",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+const ssqInletFlowTemperature = {
+    id: "ssqInletFlowTemperature",
+    measure: "temperature",
+    aggregate: "ssq",
+    units: sqUnits$4,
+};
+
+const outletFlowTemperature = {
+    id: "outletFlowTemperature",
+    measure: "temperature",
+    aggregate: "instant",
+    units: units$b,
+};
+const minOutletFlowTemperature = {
+    id: "minOutletFlowTemperature",
+    measure: "temperature",
+    aggregate: "min",
+    units: units$b,
+};
+const maxOutletFlowTemperature = {
+    id: "maxOutletFlowTemperature",
+    measure: "temperature",
+    aggregate: "max",
+    units: units$b,
+};
+const avgOutletFlowTemperature = {
+    id: "avgOutletFlowTemperature",
+    measure: "temperature",
+    aggregate: "avg",
+    units: units$b,
+};
+const sumOutletFlowTemperature = {
+    id: "sumOutletFlowTemperature",
+    measure: "temperature",
+    aggregate: "sum",
+    units: units$b,
+};
+const cntOutletFlowTemperature = {
+    id: "cntOutletFlowTemperature",
+    measure: "temperature",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+const ssqOutletFlowTemperature = {
+    id: "ssqOutletFlowTemperature",
+    measure: "temperature",
+    aggregate: "ssq",
+    units: sqUnits$4,
+};
+
+const flowTemperature = {
+    id: "flowTemperature",
+    measure: "temperature",
+    aggregate: "instant",
+    units: units$b,
+};
+const minFlowTemperature = {
+    id: "minFlowTemperature",
+    measure: "temperature",
+    aggregate: "min",
+    units: units$b,
+};
+const maxFlowTemperature = {
+    id: "maxFlowTemperature",
+    measure: "temperature",
+    aggregate: "max",
+    units: units$b,
+};
+const avgFlowTemperature = {
+    id: "avgFlowTemperature",
+    measure: "temperature",
+    aggregate: "avg",
+    units: units$b,
+};
+const sumFlowTemperature = {
+    id: "sumFlowTemperature",
+    measure: "temperature",
+    aggregate: "sum",
+    units: units$b,
+};
+const cntFlowTemperature = {
+    id: "cntFlowTemperature",
+    measure: "temperature",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+const ssqFlowTemperature = {
+    id: "ssqFlowTemperature",
+    measure: "temperature",
+    aggregate: "ssq",
+    units: sqUnits$4,
+};
+
+const heatEnergyVolumeInInlet = {
+    id: "heatEnergyVolumeInInlet",
+    measure: "energy",
+    aggregate: "instant",
+    units: units$9,
+};
+const diffHeatEnergyVolumeInInlet = {
+    id: "diffHeatEnergyVolumeInInlet",
+    measure: "energy",
+    aggregate: "diff",
+    units: units$9,
+};
+const cntHeatEnergyVolumeInInlet = {
+    id: "cntHeatEnergyVolumeInInlet",
+    measure: "energy",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+const heatEnergyTariff1VolumeInInlet = {
+    id: "heatEnergyTariff1VolumeInInlet",
+    measure: "energy",
+    aggregate: "instant",
+    units: units$9,
+};
+const diffHeatEnergyTariff1VolumeInInlet = {
+    id: "diffHeatEnergyTariff1VolumeInInlet",
+    measure: "energy",
+    aggregate: "diff",
+    units: units$9,
+};
+const cntHeatEnergyTariff1VolumeInInlet = {
+    id: "cntHeatEnergyTariff1VolumeInInlet",
+    measure: "energy",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+const heatEnergyTariff2VolumeInInlet = {
+    id: "heatEnergyTariff2VolumeInInlet",
+    measure: "energy",
+    aggregate: "instant",
+    units: units$9,
+};
+const diffHeatEnergyTariff2VolumeInInlet = {
+    id: "diffHeatEnergyTariff2VolumeInInlet",
+    measure: "energy",
+    aggregate: "diff",
+    units: units$9,
+};
+const cntHeatEnergyTariff2VolumeInInlet = {
+    id: "cntHeatEnergyTariff2VolumeInInlet",
+    measure: "energy",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+
+const heatEnergyVolumeInOutlet = {
+    id: "heatEnergyVolumeInOutlet",
+    measure: "energy",
+    aggregate: "instant",
+    units: units$9,
+};
+const diffHeatEnergyVolumeInOutlet = {
+    id: "diffHeatEnergyVolumeInOutlet",
+    measure: "energy",
+    aggregate: "diff",
+    units: units$9,
+};
+const cntHeatEnergyVolumeInOutlet = {
+    id: "cntHeatEnergyVolumeInOutlet",
+    measure: "energy",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+const heatEnergyTariff1VolumeInOutlet = {
+    id: "heatEnergyTariff1VolumeInOutlet",
+    measure: "energy",
+    aggregate: "instant",
+    units: units$9,
+};
+const diffHeatEnergyTariff1VolumeInOutlet = {
+    id: "diffHeatEnergyTariff1VolumeInOutlet",
+    measure: "energy",
+    aggregate: "diff",
+    units: units$9,
+};
+const cntHeatEnergyTariff1VolumeInOutlet = {
+    id: "cntHeatEnergyTariff1VolumeInOutlet",
+    measure: "energy",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+const heatEnergyTariff2VolumeInOutlet = {
+    id: "heatEnergyTariff2VolumeInOutlet",
+    measure: "energy",
+    aggregate: "instant",
+    units: units$9,
+};
+const diffHeatEnergyTariff2VolumeInOutlet = {
+    id: "diffHeatEnergyTariff2VolumeInOutlet",
+    measure: "energy",
+    aggregate: "diff",
+    units: units$9,
+};
+const cntHeatEnergyTariff2VolumeInOutlet = {
+    id: "cntHeatEnergyTariff2VolumeInOutlet",
+    measure: "energy",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+
+const heatEnergy = {
+    id: "heatEnergy",
+    measure: "energy",
+    aggregate: "instant",
+    units: units$9,
+};
+const diffHeatEnergy = {
+    id: "diffHeatEnergy",
+    measure: "energy",
+    aggregate: "diff",
+    units: units$9,
+};
+const cntHeatEnergy = {
+    id: "cntHeatEnergy",
+    measure: "energy",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+const heatEnergyTariff1 = {
+    id: "heatEnergyTariff1",
+    measure: "energy",
+    aggregate: "instant",
+    units: units$9,
+};
+const diffHeatEnergyTariff1 = {
+    id: "diffHeatEnergyTariff1",
+    measure: "energy",
+    aggregate: "diff",
+    units: units$9,
+};
+const cntHeatEnergyTariff1 = {
+    id: "cntHeatEnergyTariff1",
+    measure: "energy",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+const heatEnergyTariff2 = {
+    id: "heatEnergyTariff2",
+    measure: "energy",
+    aggregate: "instant",
+    units: units$9,
+};
+const diffHeatEnergyTariff2 = {
+    id: "diffHeatEnergyTariff2",
+    measure: "energy",
+    aggregate: "diff",
+    units: units$9,
+};
+const cntHeatEnergyTariff2 = {
+    id: "cntHeatEnergyTariff2",
+    measure: "energy",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+
+const infocode = {
+    id: "infocode",
+    measure: "none",
+    aggregate: "instant",
+    units: units$a,
+};
+
+const kamstrupModuleType = {
+    id: "kamstrupModuleType",
+    measure: "none",
+    aggregate: "instant",
+    units: ["unitless"],
+};
+
+const kamstrupMulticalInfocode = {
+    id: "kamstrupMulticalInfocode",
+    measure: "none",
+    aggregate: "instant",
+    units: units$a,
+};
+const kamstrupMulticalInfocodeType1 = {
+    id: "kamstrupMulticalInfocodeType1",
+    measure: "none",
+    aggregate: "instant",
+    units: units$a,
+};
+const kamstrupMulticalInfocodeType2 = {
+    id: "kamstrupMulticalInfocodeType2",
+    measure: "none",
+    aggregate: "instant",
+    units: units$a,
+};
+const kamstrupMulticalInfocodeType3 = {
+    id: "kamstrupMulticalInfocodeType3",
+    measure: "none",
+    aggregate: "instant",
+    units: units$a,
+};
+const kamstrupMulticalInfocodeType4 = {
+    id: "kamstrupMulticalInfocodeType4",
+    measure: "none",
+    aggregate: "instant",
+    units: units$a,
+};
+const kamstrupMulticalInfocodeType5 = {
+    id: "kamstrupMulticalInfocodeType5",
+    measure: "none",
+    aggregate: "instant",
+    units: units$a,
+};
+const kamstrupMulticalInfocodeType6 = {
+    id: "kamstrupMulticalInfocodeType6",
+    measure: "none",
+    aggregate: "instant",
+    units: units$a,
+};
+const kamstrupMulticalInfocodeType7 = {
+    id: "kamstrupMulticalInfocodeType7",
+    measure: "none",
+    aggregate: "instant",
+    units: units$a,
+};
+
+const landisGyrInfocode = {
+    id: "landisGyrInfocode",
+    measure: "none",
+    aggregate: "instant",
+    units: units$a,
+};
+const landisGyrInfocodeType1 = {
+    id: "landisGyrInfocodeType1",
+    measure: "none",
+    aggregate: "instant",
+    units: units$a,
+};
+const landisGyrInfocodeType2 = {
+    id: "landisGyrInfocodeType2",
+    measure: "none",
+    aggregate: "instant",
+    units: units$a,
+};
+
+const landisGyrMBusStatus = {
+    id: "landisGyrMBusStatus",
+    measure: "none",
+    aggregate: "instant",
+    units: units$a,
+};
+const landisGyrMBusStatusType1 = {
+    id: "landisGyrMBusStatusType1",
+    measure: "none",
+    aggregate: "instant",
+    units: units$a,
+};
+const landisGyrMBusStatusType2 = {
+    id: "landisGyrMBusStatusType2",
+    measure: "none",
+    aggregate: "instant",
+    units: units$a,
+};
+
+const units$6 = [
+    "gramsPerSecond",
+    "gramsPerMinute",
+    "gramsPerHour",
+    "kiloGramsPerSecond",
+    "kiloGramsPerMinute",
+    "kiloGramsPerHour",
+];
+const sqUnits$3 = [
+    "gramsPerSecond2",
+    "gramsPerMinute2",
+    "gramsPerHour2",
+    "kiloGramsPerSecond2",
+    "kiloGramsPerMinute2",
+    "kiloGramsPerHour2",
+];
+
+const inletMassFlow = {
+    id: "inletMassFlow",
+    measure: "massFlow",
+    aggregate: "instant",
+    units: units$6,
+};
+const minInletMassFlow = {
+    id: "minInletMassFlow",
+    measure: "massFlow",
+    aggregate: "min",
+    units: units$6,
+};
+const maxInletMassFlow = {
+    id: "maxInletMassFlow",
+    measure: "massFlow",
+    aggregate: "max",
+    units: units$6,
+};
+const avgInletMassFlow = {
+    id: "avgInletMassFlow",
+    measure: "massFlow",
+    aggregate: "avg",
+    units: units$6,
+};
+const sumInletMassFlow = {
+    id: "sumInletMassFlow",
+    measure: "massFlow",
+    aggregate: "sum",
+    units: units$6,
+};
+const cntInletMassFlow = {
+    id: "cntInletMassFlow",
+    measure: "massFlow",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+const ssqInletMassFlow = {
+    id: "ssqInletMassFlow",
+    measure: "massFlow",
+    aggregate: "ssq",
+    units: sqUnits$3,
+};
+
+const outletMassFlow = {
+    id: "outletMassFlow",
+    measure: "massFlow",
+    aggregate: "instant",
+    units: units$6,
+};
+const minOutletMassFlow = {
+    id: "minOutletMassFlow",
+    measure: "massFlow",
+    aggregate: "min",
+    units: units$6,
+};
+const maxOutletMassFlow = {
+    id: "maxOutletMassFlow",
+    measure: "massFlow",
+    aggregate: "max",
+    units: units$6,
+};
+const avgOutletMassFlow = {
+    id: "avgOutletMassFlow",
+    measure: "massFlow",
+    aggregate: "avg",
+    units: units$6,
+};
+const sumOutletMassFlow = {
+    id: "sumOutletMassFlow",
+    measure: "massFlow",
+    aggregate: "sum",
+    units: units$6,
+};
+const cntOutletMassFlow = {
+    id: "cntOutletMassFlow",
+    measure: "massFlow",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+const ssqOutletMassFlow = {
+    id: "ssqOutletMassFlow",
+    measure: "massFlow",
+    aggregate: "ssq",
+    units: sqUnits$3,
+};
+
+const massFlow = {
+    id: "massFlow",
+    measure: "massFlow",
+    aggregate: "instant",
+    units: units$6,
+};
+const minMassFlow = {
+    id: "minMassFlow",
+    measure: "massFlow",
+    aggregate: "min",
+    units: units$6,
+};
+const maxMassFlow = {
+    id: "maxMassFlow",
+    measure: "massFlow",
+    aggregate: "max",
+    units: units$6,
+};
+const avgMassFlow = {
+    id: "avgMassFlow",
+    measure: "massFlow",
+    aggregate: "avg",
+    units: units$6,
+};
+const sumMassFlow = {
+    id: "sumMassFlow",
+    measure: "massFlow",
+    aggregate: "sum",
+    units: units$6,
+};
+const cntMassFlow = {
+    id: "cntMassFlow",
+    measure: "massFlow",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+const ssqMassFlow = {
+    id: "ssqMassFlow",
+    measure: "massFlow",
+    aggregate: "ssq",
+    units: sqUnits$3,
+};
+
+const units$5 = [
+    "gram",
+    "kiloGram",
+    "tonne",
+    "ounce",
+    "pound",
+    "ton",
+];
+
+const inletMass = {
+    id: "inletMass",
+    measure: "mass",
+    aggregate: "instant",
+    units: units$5,
+};
+const diffInletMass = {
+    id: "diffInletMass",
+    measure: "mass",
+    aggregate: "diff",
+    units: units$5,
+};
+const cntInletMass = {
+    id: "cntInletMass",
+    measure: "mass",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+
+const outletMass = {
+    id: "outletMass",
+    measure: "mass",
+    aggregate: "instant",
+    units: units$5,
+};
+const diffOutletMass = {
+    id: "diffOutletMass",
+    measure: "mass",
+    aggregate: "diff",
+    units: units$5,
+};
+const cntOutletMass = {
+    id: "cntOutletMass",
+    measure: "mass",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+
+const mass = {
+    id: "mass",
+    measure: "mass",
+    aggregate: "instant",
+    units: units$5,
+};
+const diffMass = {
+    id: "diffMass",
+    measure: "mass",
+    aggregate: "diff",
+    units: units$5,
+};
+const cntMass = {
+    id: "cntMass",
+    measure: "mass",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+
+const mBusFormatStringSignature = {
+    id: "mBusFormatStringSignature",
+    measure: "none",
+    aggregate: "instant",
+    units: ["unitless"],
+};
+
+const none = {
+    id: "none",
+    measure: "none",
+    aggregate: "instant",
+    units: ["unitless"],
+};
+
+const operatingTime = {
+    id: "operatingTime",
+    measure: "duration",
+    aggregate: "instant",
+    units: units$7,
+};
+const diffOperatingTime = {
+    id: "diffOperatingTime",
+    measure: "duration",
+    aggregate: "diff",
+    units: units$7,
+};
+const cntOperatingTime = {
+    id: "cntOperatingTime",
+    measure: "duration",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+
+const place = {
+    id: "place",
+    measure: "none",
+    aggregate: "instant",
+    units: ["json"],
+    immediate: true,
+};
+const lastPlace = {
+    id: "lastPlace",
+    measure: "none",
+    aggregate: "instant",
+    units: ["json"],
+    immediate: true,
+};
+
+const units$4 = [
+    "milliWatt",
+    "watt",
+    "kiloWatt",
+    "megaWatt",
+    "gigaWatt",
+    "joulesPerSecond",
+    "joulesPerMinute",
+    "joulesPerHour",
+];
+const sqUnits$2 = [
+    "milliWatt2",
+    "watt2",
+    "kiloWatt2",
+    "megaWatt2",
+    "gigaWatt2",
+    "joulesPerSecond2",
+    "joulesPerMinute2",
+    "joulesPerHour2",
+];
+
+const inletPower = {
+    id: "inletPower",
+    measure: "power",
+    aggregate: "instant",
+    units: units$4,
+};
+const minInletPower = {
+    id: "minInletPower",
+    measure: "power",
+    aggregate: "min",
+    units: units$4,
+};
+const maxInletPower = {
+    id: "maxInletPower",
+    measure: "power",
+    aggregate: "max",
+    units: units$4,
+};
+const avgInletPower = {
+    id: "avgInletPower",
+    measure: "power",
+    aggregate: "avg",
+    units: units$4,
+};
+const sumInletPower = {
+    id: "sumInletPower",
+    measure: "power",
+    aggregate: "sum",
+    units: units$4,
+};
+const cntInletPower = {
+    id: "cntInletPower",
+    measure: "power",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+const ssqInletPower = {
+    id: "ssqInletPower",
+    measure: "power",
+    aggregate: "ssq",
+    units: sqUnits$2,
+};
+
+const outletPower = {
+    id: "outletPower",
+    measure: "power",
+    aggregate: "instant",
+    units: units$4,
+};
+const minOutletPower = {
+    id: "minOutletPower",
+    measure: "power",
+    aggregate: "min",
+    units: units$4,
+};
+const maxOutletPower = {
+    id: "maxOutletPower",
+    measure: "power",
+    aggregate: "max",
+    units: units$4,
+};
+const avgOutletPower = {
+    id: "avgOutletPower",
+    measure: "power",
+    aggregate: "avg",
+    units: units$4,
+};
+const sumOutletPower = {
+    id: "sumOutletPower",
+    measure: "power",
+    aggregate: "sum",
+    units: units$4,
+};
+const cntOutletPower = {
+    id: "cntOutletPower",
+    measure: "power",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+const ssqOutletPower = {
+    id: "ssqOutletPower",
+    measure: "power",
+    aggregate: "ssq",
+    units: sqUnits$2,
+};
+
+const power = {
+    id: "power",
+    measure: "power",
+    aggregate: "instant",
+    units: units$4,
+};
+const minPower = {
+    id: "minPower",
+    measure: "power",
+    aggregate: "min",
+    units: units$4,
+};
+const maxPower = {
+    id: "maxPower",
+    measure: "power",
+    aggregate: "max",
+    units: units$4,
+};
+const avgPower = {
+    id: "avgPower",
+    measure: "power",
+    aggregate: "avg",
+    units: units$4,
+};
+const sumPower = {
+    id: "sumPower",
+    measure: "power",
+    aggregate: "sum",
+    units: units$4,
+};
+const cntPower = {
+    id: "cntPower",
+    measure: "power",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+const ssqPower = {
+    id: "ssqPower",
+    measure: "power",
+    aggregate: "ssq",
+    units: sqUnits$2,
+};
+
+const units$3 = ["bar", "pascal", "kiloPascal"];
+const sqUnits$1 = [
+    "bar2",
+    "pascal2",
+    "kiloPascal2",
+];
+
+const inletPressure = {
+    id: "inletPressure",
+    measure: "pressure",
+    aggregate: "instant",
+    units: units$3,
+};
+const minInletPressure = {
+    id: "minInletPressure",
+    measure: "pressure",
+    aggregate: "min",
+    units: units$3,
+};
+const maxInletPressure = {
+    id: "maxInletPressure",
+    measure: "pressure",
+    aggregate: "max",
+    units: units$3,
+};
+const avgInletPressure = {
+    id: "avgInletPressure",
+    measure: "pressure",
+    aggregate: "avg",
+    units: units$3,
+};
+const sumInletPressure = {
+    id: "sumInletPressure",
+    measure: "pressure",
+    aggregate: "sum",
+    units: units$3,
+};
+const cntInletPressure = {
+    id: "cntInletPressure",
+    measure: "pressure",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+const ssqInletPressure = {
+    id: "ssqInletPressure",
+    measure: "pressure",
+    aggregate: "ssq",
+    units: sqUnits$1,
+};
+
+const outletPressure = {
+    id: "outletPressure",
+    measure: "pressure",
+    aggregate: "instant",
+    units: units$3,
+};
+const minOutletPressure = {
+    id: "minOutletPressure",
+    measure: "pressure",
+    aggregate: "min",
+    units: units$3,
+};
+const maxOutletPressure = {
+    id: "maxOutletPressure",
+    measure: "pressure",
+    aggregate: "max",
+    units: units$3,
+};
+const avgOutletPressure = {
+    id: "avgOutletPressure",
+    measure: "pressure",
+    aggregate: "avg",
+    units: units$3,
+};
+const sumOutletPressure = {
+    id: "sumOutletPressure",
+    measure: "pressure",
+    aggregate: "sum",
+    units: units$3,
+};
+const cntOutletPressure = {
+    id: "cntOutletPressure",
+    measure: "pressure",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+const ssqOutletPressure = {
+    id: "ssqOutletPressure",
+    measure: "pressure",
+    aggregate: "ssq",
+    units: sqUnits$1,
+};
+
+const pressure = {
+    id: "pressure",
+    measure: "pressure",
+    aggregate: "instant",
+    units: units$3,
+};
+const minPressure = {
+    id: "minPressure",
+    measure: "pressure",
+    aggregate: "min",
+    units: units$3,
+};
+const maxPressure = {
+    id: "maxPressure",
+    measure: "pressure",
+    aggregate: "max",
+    units: units$3,
+};
+const avgPressure = {
+    id: "avgPressure",
+    measure: "pressure",
+    aggregate: "avg",
+    units: units$3,
+};
+const sumPressure = {
+    id: "sumPressure",
+    measure: "pressure",
+    aggregate: "sum",
+    units: units$3,
+};
+const cntPressure = {
+    id: "cntPressure",
+    measure: "pressure",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+const ssqPressure = {
+    id: "ssqPressure",
+    measure: "pressure",
+    aggregate: "ssq",
+    units: sqUnits$1,
+};
+
+const radiatorTemperature = {
+    id: "radiatorTemperature",
+    measure: "temperature",
+    aggregate: "instant",
+    units: units$b,
+};
+const minRadiatorTemperature = {
+    id: "minRadiatorTemperature",
+    measure: "temperature",
+    aggregate: "min",
+    units: units$b,
+};
+const maxRadiatorTemperature = {
+    id: "maxRadiatorTemperature",
+    measure: "temperature",
+    aggregate: "max",
+    units: units$b,
+};
+const avgRadiatorTemperature = {
+    id: "avgRadiatorTemperature",
+    measure: "temperature",
+    aggregate: "avg",
+    units: units$b,
+};
+const sumRadiatorTemperature = {
+    id: "sumRadiatorTemperature",
+    measure: "temperature",
+    aggregate: "sum",
+    units: units$b,
+};
+const cntRadiatorTemperature = {
+    id: "cntRadiatorTemperature",
+    measure: "temperature",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+const ssqRadiatorTemperature = {
+    id: "ssqRadiatorTemperature",
+    measure: "temperature",
+    aggregate: "ssq",
+    units: sqUnits$4,
+};
+
+const units$2 = [
+    "varHour",
+    "kiloVarHour",
+    "megaVarHour",
+];
+
+const reactiveEnergy = {
+    id: "reactiveEnergy",
+    measure: "reactiveEnergy",
+    aggregate: "instant",
+    units: units$2,
+};
+const diffReactiveEnergy = {
+    id: "diffReactiveEnergy",
+    measure: "reactiveEnergy",
+    aggregate: "diff",
+    units: units$2,
+};
+const cntReactiveEnergy = {
+    id: "cntReactiveEnergy",
+    measure: "reactiveEnergy",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+
+const relativeHumidity = {
+    id: "relativeHumidity",
+    measure: "humidity",
+    aggregate: "instant",
+    units: ["percentage"],
+};
+
+const remainingBatteryTime = {
+    id: "remainingBatteryTime",
+    measure: "duration",
+    aggregate: "instant",
+    units: units$7,
+};
+const diffRemainingBatteryTime = {
+    id: "diffRemainingBatteryTime",
+    measure: "duration",
+    aggregate: "diff",
+    units: units$7,
+};
+const cntRemainingBatteryTime = {
+    id: "cntRemainingBatteryTime",
+    measure: "duration",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+
+const timeAtLastExactOverhearingArrived = {
+    id: "timeAtLastExactOverhearingArrived",
+    measure: "time",
+    aggregate: "instant",
+    units: units$8,
+    immediate: true,
+};
+const timeSinceLastExactOverhearingArrived = {
+    id: "timeSinceLastExactOverhearingArrived",
+    measure: "duration",
+    aggregate: "instant",
+    units: units$7,
+    immediate: true,
+};
+
+const timeAtLastInstallationMounted = {
+    id: "timeAtLastInstallationMounted",
+    measure: "time",
+    aggregate: "instant",
+    units: units$8,
+    immediate: true,
+};
+const timeSinceLastInstallationMounted = {
+    id: "timeSinceLastInstallationMounted",
+    measure: "duration",
+    aggregate: "instant",
+    units: units$7,
+    immediate: true,
+};
+
+const timeAtLastPossibleCandidateOverhearingArrived = {
+    id: "timeAtLastPossibleCandidateOverhearingArrived",
+    measure: "time",
+    aggregate: "instant",
+    units: units$8,
+    immediate: true,
+};
+const timeSinceLastPossibleCandidateOverhearingArrived = {
+    id: "timeSinceLastPossibleCandidateOverhearingArrived",
+    measure: "duration",
+    aggregate: "instant",
+    units: units$7,
+    immediate: true,
+};
+
+const timeAtLastSampled = {
+    id: "timeAtLastSampled",
+    measure: "time",
+    aggregate: "instant",
+    units: units$8,
+    immediate: true,
+};
+const timeSinceLastSampled = {
+    id: "timeSinceLastSampled",
+    measure: "duration",
+    aggregate: "instant",
+    units: units$7,
+    immediate: true,
+};
+
+const basetime = {
+    id: "basetime",
+    measure: "time",
+    aggregate: "instant",
+    units: units$8,
+    immediate: true,
+};
+const instantTime = {
+    id: "instantTime",
+    measure: "time",
+    aggregate: "instant",
+    units: units$8,
+};
+const periodStartTime = {
+    id: "periodStartTime",
+    measure: "time",
+    aggregate: "instant",
+    units: units$8,
+};
+const periodEndTime = {
+    id: "periodEndTime",
+    measure: "time",
+    aggregate: "instant",
+    units: units$8,
+};
+const instantOrPeriodStartTime = {
+    id: "instantOrPeriodStartTime",
+    measure: "time",
+    aggregate: "instant",
+    units: units$8,
+};
+const instantOrPeriodEndTime = {
+    id: "instantOrPeriodEndTime",
+    measure: "time",
+    aggregate: "instant",
+    units: units$8,
+};
+
+const units$1 = [
+    "litersPerSecond",
+    "litersPerMinute",
+    "litersPerHour",
+    "cubicMetersPerSecond",
+    "cubicMetersPerMinute",
+    "cubicMetersPerHour",
+    "gallonsPerSecond",
+    "gallonsPerMinute",
+    "gallonsPerHour",
+];
+const sqUnits = [
+    "litersPerSecond2",
+    "litersPerMinute2",
+    "litersPerHour2",
+    "cubicMetersPerSecond2",
+    "cubicMetersPerMinute2",
+    "cubicMetersPerHour2",
+    "gallonsPerSecond2",
+    "gallonsPerMinute2",
+    "gallonsPerHour2",
+];
+
+const inletVolumeFlow = {
+    id: "inletVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "instant",
+    units: units$1,
+};
+const minInletVolumeFlow = {
+    id: "minInletVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "min",
+    units: units$1,
+};
+const maxInletVolumeFlow = {
+    id: "maxInletVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "max",
+    units: units$1,
+};
+const avgInletVolumeFlow = {
+    id: "avgInletVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "avg",
+    units: units$1,
+};
+const sumInletVolumeFlow = {
+    id: "sumInletVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "sum",
+    units: units$1,
+};
+const cntInletVolumeFlow = {
+    id: "cntInletVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+const ssqInletVolumeFlow = {
+    id: "ssqInletVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "ssq",
+    units: sqUnits,
+};
+
+const outletVolumeFlow = {
+    id: "outletVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "instant",
+    units: units$1,
+};
+const minOutletVolumeFlow = {
+    id: "minOutletVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "min",
+    units: units$1,
+};
+const maxOutletVolumeFlow = {
+    id: "maxOutletVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "max",
+    units: units$1,
+};
+const avgOutletVolumeFlow = {
+    id: "avgOutletVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "avg",
+    units: units$1,
+};
+const sumOutletVolumeFlow = {
+    id: "sumOutletVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "sum",
+    units: units$1,
+};
+const cntOutletVolumeFlow = {
+    id: "cntOutletVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+const ssqOutletVolumeFlow = {
+    id: "ssqOutletVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "ssq",
+    units: sqUnits,
+};
+
+const volumeFlow = {
+    id: "volumeFlow",
+    measure: "volumeFlow",
+    aggregate: "instant",
+    units: units$1,
+};
+const minVolumeFlow = {
+    id: "minVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "min",
+    units: units$1,
+};
+const maxVolumeFlow = {
+    id: "maxVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "max",
+    units: units$1,
+};
+const avgVolumeFlow = {
+    id: "avgVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "avg",
+    units: units$1,
+};
+const sumVolumeFlow = {
+    id: "sumVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "sum",
+    units: units$1,
+};
+const cntVolumeFlow = {
+    id: "cntVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+const ssqVolumeFlow = {
+    id: "ssqVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "ssq",
+    units: sqUnits,
+};
+
+const units = ["liter", "cubicMeter", "gallon"];
+
+const inletVolume = {
+    id: "inletVolume",
+    measure: "volume",
+    aggregate: "instant",
+    units,
+};
+const diffInletVolume = {
+    id: "diffInletVolume",
+    measure: "volume",
+    aggregate: "diff",
+    units,
+};
+const cntInletVolume = {
+    id: "cntInletVolume",
+    measure: "volume",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+
+const outletVolume = {
+    id: "outletVolume",
+    measure: "volume",
+    aggregate: "instant",
+    units,
+};
+const diffOutletVolume = {
+    id: "diffOutletVolume",
+    measure: "volume",
+    aggregate: "diff",
+    units,
+};
+const cntOutletVolume = {
+    id: "cntOutletVolume",
+    measure: "volume",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+
+const pulseInputAVolume = {
+    id: "pulseInputAVolume",
+    measure: "volume",
+    aggregate: "instant",
+    units,
+};
+const diffPulseInputAVolume = {
+    id: "diffPulseInputAVolume",
+    measure: "volume",
+    aggregate: "diff",
+    units,
+};
+const cntPulseInputAVolume = {
+    id: "cntPulseInputAVolume",
+    measure: "volume",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+
+const pulseInputBVolume = {
+    id: "pulseInputBVolume",
+    measure: "volume",
+    aggregate: "instant",
+    units,
+};
+const diffPulseInputBVolume = {
+    id: "diffPulseInputBVolume",
+    measure: "volume",
+    aggregate: "diff",
+    units,
+};
+const cntPulseInputBVolume = {
+    id: "cntPulseInputBVolume",
+    measure: "volume",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+
+const volume = {
+    id: "volume",
+    measure: "volume",
+    aggregate: "instant",
+    units,
+};
+const diffVolume = {
+    id: "diffVolume",
+    measure: "volume",
+    aggregate: "diff",
+    units,
+};
+const cntVolume = {
+    id: "cntVolume",
+    measure: "volume",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+
+var Registers = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    acousticNoise: acousticNoise,
+    ambientTemperature: ambientTemperature,
+    auxFlowTemperature: auxFlowTemperature,
+    avgAcousticNoise: avgAcousticNoise,
+    avgAmbientTemperature: avgAmbientTemperature,
+    avgAuxFlowTemperature: avgAuxFlowTemperature,
+    avgFlowTemperature: avgFlowTemperature,
+    avgInletFlowTemperature: avgInletFlowTemperature,
+    avgInletMassFlow: avgInletMassFlow,
+    avgInletMinusOutletFlowTemperatureDifference: avgInletMinusOutletFlowTemperatureDifference,
+    avgInletPower: avgInletPower,
+    avgInletPressure: avgInletPressure,
+    avgInletVolumeFlow: avgInletVolumeFlow,
+    avgMassFlow: avgMassFlow,
+    avgOutletFlowTemperature: avgOutletFlowTemperature,
+    avgOutletMassFlow: avgOutletMassFlow,
+    avgOutletMinusInletFlowTemperatureDifference: avgOutletMinusInletFlowTemperatureDifference,
+    avgOutletPower: avgOutletPower,
+    avgOutletPressure: avgOutletPressure,
+    avgOutletVolumeFlow: avgOutletVolumeFlow,
+    avgPower: avgPower,
+    avgPressure: avgPressure,
+    avgRadiatorTemperature: avgRadiatorTemperature,
+    avgVolumeFlow: avgVolumeFlow,
+    axiomaInfocode: axiomaInfocode,
+    axiomaInfocodeType1: axiomaInfocodeType1,
+    basetime: basetime,
+    cntAcousticNoise: cntAcousticNoise,
+    cntAmbientTemperature: cntAmbientTemperature,
+    cntAuxFlowTemperature: cntAuxFlowTemperature,
+    cntCoolingEnergy: cntCoolingEnergy,
+    cntCoolingEnergyVolumeInInlet: cntCoolingEnergyVolumeInInlet,
+    cntCoolingEnergyVolumeInOutlet: cntCoolingEnergyVolumeInOutlet,
+    cntElectricalEnergy: cntElectricalEnergy,
+    cntErrorOperatingTime: cntErrorOperatingTime,
+    cntFlowTemperature: cntFlowTemperature,
+    cntHeatEnergy: cntHeatEnergy,
+    cntHeatEnergyTariff1: cntHeatEnergyTariff1,
+    cntHeatEnergyTariff1VolumeInInlet: cntHeatEnergyTariff1VolumeInInlet,
+    cntHeatEnergyTariff1VolumeInOutlet: cntHeatEnergyTariff1VolumeInOutlet,
+    cntHeatEnergyTariff2: cntHeatEnergyTariff2,
+    cntHeatEnergyTariff2VolumeInInlet: cntHeatEnergyTariff2VolumeInInlet,
+    cntHeatEnergyTariff2VolumeInOutlet: cntHeatEnergyTariff2VolumeInOutlet,
+    cntHeatEnergyVolumeInInlet: cntHeatEnergyVolumeInInlet,
+    cntHeatEnergyVolumeInOutlet: cntHeatEnergyVolumeInOutlet,
+    cntInletFlowTemperature: cntInletFlowTemperature,
+    cntInletMass: cntInletMass,
+    cntInletMassFlow: cntInletMassFlow,
+    cntInletMinusOutletFlowTemperatureDifference: cntInletMinusOutletFlowTemperatureDifference,
+    cntInletPower: cntInletPower,
+    cntInletPressure: cntInletPressure,
+    cntInletVolume: cntInletVolume,
+    cntInletVolumeFlow: cntInletVolumeFlow,
+    cntKamstrupE8Inlet: cntKamstrupE8Inlet,
+    cntKamstrupE9Outlet: cntKamstrupE9Outlet,
+    cntMass: cntMass,
+    cntMassFlow: cntMassFlow,
+    cntOperatingTime: cntOperatingTime,
+    cntOutletFlowTemperature: cntOutletFlowTemperature,
+    cntOutletMass: cntOutletMass,
+    cntOutletMassFlow: cntOutletMassFlow,
+    cntOutletMinusInletFlowTemperatureDifference: cntOutletMinusInletFlowTemperatureDifference,
+    cntOutletPower: cntOutletPower,
+    cntOutletPressure: cntOutletPressure,
+    cntOutletVolume: cntOutletVolume,
+    cntOutletVolumeFlow: cntOutletVolumeFlow,
+    cntPower: cntPower,
+    cntPressure: cntPressure,
+    cntPulseInputAVolume: cntPulseInputAVolume,
+    cntPulseInputBVolume: cntPulseInputBVolume,
+    cntRadiatorTemperature: cntRadiatorTemperature,
+    cntReactiveEnergy: cntReactiveEnergy,
+    cntRemainingBatteryTime: cntRemainingBatteryTime,
+    cntVolume: cntVolume,
+    cntVolumeFlow: cntVolumeFlow,
+    consumer: consumer,
+    coolingEnergy: coolingEnergy,
+    coolingEnergyVolumeInInlet: coolingEnergyVolumeInInlet,
+    coolingEnergyVolumeInOutlet: coolingEnergyVolumeInOutlet,
+    device: device,
+    deviceDate: deviceDate,
+    deviceDateTime: deviceDateTime,
+    deviceNominalDiameter: deviceNominalDiameter,
+    devicePermanentVolumeFlow: devicePermanentVolumeFlow,
+    deviceRegisters: deviceRegisters,
+    deviceSamplesOnLastMount: deviceSamplesOnLastMount,
+    deviceSamplesOnLastUnmount: deviceSamplesOnLastUnmount,
+    deviceSoftwareVersion: deviceSoftwareVersion,
+    deviceTime: deviceTime,
+    diehlInfocode: diehlInfocode,
+    diehlInfocodeType1: diehlInfocodeType1,
+    diehlInfocodeType2: diehlInfocodeType2,
+    diehlInfocodeType3: diehlInfocodeType3,
+    diehlInfocodeType4: diehlInfocodeType4,
+    diehlInfocodeType5: diehlInfocodeType5,
+    diffCoolingEnergy: diffCoolingEnergy,
+    diffCoolingEnergyVolumeInInlet: diffCoolingEnergyVolumeInInlet,
+    diffCoolingEnergyVolumeInOutlet: diffCoolingEnergyVolumeInOutlet,
+    diffElectricalEnergy: diffElectricalEnergy,
+    diffErrorOperatingTime: diffErrorOperatingTime,
+    diffHeatEnergy: diffHeatEnergy,
+    diffHeatEnergyTariff1: diffHeatEnergyTariff1,
+    diffHeatEnergyTariff1VolumeInInlet: diffHeatEnergyTariff1VolumeInInlet,
+    diffHeatEnergyTariff1VolumeInOutlet: diffHeatEnergyTariff1VolumeInOutlet,
+    diffHeatEnergyTariff2: diffHeatEnergyTariff2,
+    diffHeatEnergyTariff2VolumeInInlet: diffHeatEnergyTariff2VolumeInInlet,
+    diffHeatEnergyTariff2VolumeInOutlet: diffHeatEnergyTariff2VolumeInOutlet,
+    diffHeatEnergyVolumeInInlet: diffHeatEnergyVolumeInInlet,
+    diffHeatEnergyVolumeInOutlet: diffHeatEnergyVolumeInOutlet,
+    diffInletMass: diffInletMass,
+    diffInletVolume: diffInletVolume,
+    diffKamstrupE8Inlet: diffKamstrupE8Inlet,
+    diffKamstrupE9Outlet: diffKamstrupE9Outlet,
+    diffMass: diffMass,
+    diffOperatingTime: diffOperatingTime,
+    diffOutletMass: diffOutletMass,
+    diffOutletVolume: diffOutletVolume,
+    diffPulseInputAVolume: diffPulseInputAVolume,
+    diffPulseInputBVolume: diffPulseInputBVolume,
+    diffReactiveEnergy: diffReactiveEnergy,
+    diffRemainingBatteryTime: diffRemainingBatteryTime,
+    diffVolume: diffVolume,
+    electricalEnergy: electricalEnergy,
+    errorOperatingTime: errorOperatingTime,
+    flowTemperature: flowTemperature,
+    heatEnergy: heatEnergy,
+    heatEnergyTariff1: heatEnergyTariff1,
+    heatEnergyTariff1VolumeInInlet: heatEnergyTariff1VolumeInInlet,
+    heatEnergyTariff1VolumeInOutlet: heatEnergyTariff1VolumeInOutlet,
+    heatEnergyTariff2: heatEnergyTariff2,
+    heatEnergyTariff2VolumeInInlet: heatEnergyTariff2VolumeInInlet,
+    heatEnergyTariff2VolumeInOutlet: heatEnergyTariff2VolumeInOutlet,
+    heatEnergyVolumeInInlet: heatEnergyVolumeInInlet,
+    heatEnergyVolumeInOutlet: heatEnergyVolumeInOutlet,
+    infocode: infocode,
+    inletFlowTemperature: inletFlowTemperature,
+    inletMass: inletMass,
+    inletMassFlow: inletMassFlow,
+    inletMinusOutletFlowTemperatureDifference: inletMinusOutletFlowTemperatureDifference,
+    inletPower: inletPower,
+    inletPressure: inletPressure,
+    inletVolume: inletVolume,
+    inletVolumeFlow: inletVolumeFlow,
+    instantOrPeriodEndTime: instantOrPeriodEndTime,
+    instantOrPeriodStartTime: instantOrPeriodStartTime,
+    instantTime: instantTime,
+    kamdraftDeviceAddresses: kamdraftDeviceAddresses,
+    kamstrupE8Inlet: kamstrupE8Inlet,
+    kamstrupE9Outlet: kamstrupE9Outlet,
+    kamstrupModuleType: kamstrupModuleType,
+    kamstrupMulticalInfocode: kamstrupMulticalInfocode,
+    kamstrupMulticalInfocodeType1: kamstrupMulticalInfocodeType1,
+    kamstrupMulticalInfocodeType2: kamstrupMulticalInfocodeType2,
+    kamstrupMulticalInfocodeType3: kamstrupMulticalInfocodeType3,
+    kamstrupMulticalInfocodeType4: kamstrupMulticalInfocodeType4,
+    kamstrupMulticalInfocodeType5: kamstrupMulticalInfocodeType5,
+    kamstrupMulticalInfocodeType6: kamstrupMulticalInfocodeType6,
+    kamstrupMulticalInfocodeType7: kamstrupMulticalInfocodeType7,
+    landisGyrInfocode: landisGyrInfocode,
+    landisGyrInfocodeType1: landisGyrInfocodeType1,
+    landisGyrInfocodeType2: landisGyrInfocodeType2,
+    landisGyrMBusStatus: landisGyrMBusStatus,
+    landisGyrMBusStatusType1: landisGyrMBusStatusType1,
+    landisGyrMBusStatusType2: landisGyrMBusStatusType2,
+    lastPlace: lastPlace,
+    legacyDeviceSamples: legacyDeviceSamples,
+    mBusFormatStringSignature: mBusFormatStringSignature,
+    mass: mass,
+    massFlow: massFlow,
+    maxAcousticNoise: maxAcousticNoise,
+    maxAmbientTemperature: maxAmbientTemperature,
+    maxAuxFlowTemperature: maxAuxFlowTemperature,
+    maxFlowTemperature: maxFlowTemperature,
+    maxInletFlowTemperature: maxInletFlowTemperature,
+    maxInletMassFlow: maxInletMassFlow,
+    maxInletMinusOutletFlowTemperatureDifference: maxInletMinusOutletFlowTemperatureDifference,
+    maxInletPower: maxInletPower,
+    maxInletPressure: maxInletPressure,
+    maxInletVolumeFlow: maxInletVolumeFlow,
+    maxMassFlow: maxMassFlow,
+    maxOutletFlowTemperature: maxOutletFlowTemperature,
+    maxOutletMassFlow: maxOutletMassFlow,
+    maxOutletMinusInletFlowTemperatureDifference: maxOutletMinusInletFlowTemperatureDifference,
+    maxOutletPower: maxOutletPower,
+    maxOutletPressure: maxOutletPressure,
+    maxOutletVolumeFlow: maxOutletVolumeFlow,
+    maxPower: maxPower,
+    maxPressure: maxPressure,
+    maxRadiatorTemperature: maxRadiatorTemperature,
+    maxVolumeFlow: maxVolumeFlow,
+    minAcousticNoise: minAcousticNoise,
+    minAmbientTemperature: minAmbientTemperature,
+    minAuxFlowTemperature: minAuxFlowTemperature,
+    minFlowTemperature: minFlowTemperature,
+    minInletFlowTemperature: minInletFlowTemperature,
+    minInletMassFlow: minInletMassFlow,
+    minInletMinusOutletFlowTemperatureDifference: minInletMinusOutletFlowTemperatureDifference,
+    minInletPower: minInletPower,
+    minInletPressure: minInletPressure,
+    minInletVolumeFlow: minInletVolumeFlow,
+    minMassFlow: minMassFlow,
+    minOutletFlowTemperature: minOutletFlowTemperature,
+    minOutletMassFlow: minOutletMassFlow,
+    minOutletMinusInletFlowTemperatureDifference: minOutletMinusInletFlowTemperatureDifference,
+    minOutletPower: minOutletPower,
+    minOutletPressure: minOutletPressure,
+    minOutletVolumeFlow: minOutletVolumeFlow,
+    minPower: minPower,
+    minPressure: minPressure,
+    minRadiatorTemperature: minRadiatorTemperature,
+    minVolumeFlow: minVolumeFlow,
+    msisdnDeviceAddresses: msisdnDeviceAddresses,
+    none: none,
+    operatingTime: operatingTime,
+    outletFlowTemperature: outletFlowTemperature,
+    outletMass: outletMass,
+    outletMassFlow: outletMassFlow,
+    outletMinusInletFlowTemperatureDifference: outletMinusInletFlowTemperatureDifference,
+    outletPower: outletPower,
+    outletPressure: outletPressure,
+    outletVolume: outletVolume,
+    outletVolumeFlow: outletVolumeFlow,
+    periodEndTime: periodEndTime,
+    periodStartTime: periodStartTime,
+    place: place,
+    power: power,
+    pressure: pressure,
+    pulseInputAVolume: pulseInputAVolume,
+    pulseInputBVolume: pulseInputBVolume,
+    radiatorTemperature: radiatorTemperature,
+    reactiveEnergy: reactiveEnergy,
+    relativeHumidity: relativeHumidity,
+    remainingBatteryTime: remainingBatteryTime,
+    ssqAcousticNoise: ssqAcousticNoise,
+    ssqAmbientTemperature: ssqAmbientTemperature,
+    ssqAuxFlowTemperature: ssqAuxFlowTemperature,
+    ssqFlowTemperature: ssqFlowTemperature,
+    ssqInletFlowTemperature: ssqInletFlowTemperature,
+    ssqInletMassFlow: ssqInletMassFlow,
+    ssqInletMinusOutletFlowTemperatureDifference: ssqInletMinusOutletFlowTemperatureDifference,
+    ssqInletPower: ssqInletPower,
+    ssqInletPressure: ssqInletPressure,
+    ssqInletVolumeFlow: ssqInletVolumeFlow,
+    ssqMassFlow: ssqMassFlow,
+    ssqOutletFlowTemperature: ssqOutletFlowTemperature,
+    ssqOutletMassFlow: ssqOutletMassFlow,
+    ssqOutletMinusInletFlowTemperatureDifference: ssqOutletMinusInletFlowTemperatureDifference,
+    ssqOutletPower: ssqOutletPower,
+    ssqOutletPressure: ssqOutletPressure,
+    ssqOutletVolumeFlow: ssqOutletVolumeFlow,
+    ssqPower: ssqPower,
+    ssqPressure: ssqPressure,
+    ssqRadiatorTemperature: ssqRadiatorTemperature,
+    ssqVolumeFlow: ssqVolumeFlow,
+    sumAcousticNoise: sumAcousticNoise,
+    sumAmbientTemperature: sumAmbientTemperature,
+    sumAuxFlowTemperature: sumAuxFlowTemperature,
+    sumFlowTemperature: sumFlowTemperature,
+    sumInletFlowTemperature: sumInletFlowTemperature,
+    sumInletMassFlow: sumInletMassFlow,
+    sumInletMinusOutletFlowTemperatureDifference: sumInletMinusOutletFlowTemperatureDifference,
+    sumInletPower: sumInletPower,
+    sumInletPressure: sumInletPressure,
+    sumInletVolumeFlow: sumInletVolumeFlow,
+    sumMassFlow: sumMassFlow,
+    sumOutletFlowTemperature: sumOutletFlowTemperature,
+    sumOutletMassFlow: sumOutletMassFlow,
+    sumOutletMinusInletFlowTemperatureDifference: sumOutletMinusInletFlowTemperatureDifference,
+    sumOutletPower: sumOutletPower,
+    sumOutletPressure: sumOutletPressure,
+    sumOutletVolumeFlow: sumOutletVolumeFlow,
+    sumPower: sumPower,
+    sumPressure: sumPressure,
+    sumRadiatorTemperature: sumRadiatorTemperature,
+    sumVolumeFlow: sumVolumeFlow,
+    tchlrDeviceAddresses: tchlrDeviceAddresses,
+    timeAtLastExactOverhearingArrived: timeAtLastExactOverhearingArrived,
+    timeAtLastInstallationMounted: timeAtLastInstallationMounted,
+    timeAtLastPossibleCandidateOverhearingArrived: timeAtLastPossibleCandidateOverhearingArrived,
+    timeAtLastSampled: timeAtLastSampled,
+    timeSinceLastExactOverhearingArrived: timeSinceLastExactOverhearingArrived,
+    timeSinceLastInstallationMounted: timeSinceLastInstallationMounted,
+    timeSinceLastPossibleCandidateOverhearingArrived: timeSinceLastPossibleCandidateOverhearingArrived,
+    timeSinceLastSampled: timeSinceLastSampled,
+    volume: volume,
+    volumeFlow: volumeFlow,
+    wMBusDeviceAddresses: wMBusDeviceAddresses
+});
+
+exports.DayOfWeek = void 0;
+(function (DayOfWeek) {
+    DayOfWeek[DayOfWeek["Monday"] = 1] = "Monday";
+    DayOfWeek[DayOfWeek["Tuesday"] = 2] = "Tuesday";
+    DayOfWeek[DayOfWeek["Wednesday"] = 3] = "Wednesday";
+    DayOfWeek[DayOfWeek["Thursday"] = 4] = "Thursday";
+    DayOfWeek[DayOfWeek["Friday"] = 5] = "Friday";
+    DayOfWeek[DayOfWeek["Saturday"] = 6] = "Saturday";
+    DayOfWeek[DayOfWeek["Sunday"] = 7] = "Sunday";
+})(exports.DayOfWeek || (exports.DayOfWeek = {}));
+exports.Step = void 0;
+(function (Step) {
+    function startOf(dateTime, step, firstDayOfWeek) {
+        if (step === "week") {
+            const value = dateTime
+                .startOf("day")
+                .set({ weekday: firstDayOfWeek ?? exports.DayOfWeek.Monday });
+            return value > dateTime ? value.minus({ days: 7 }) : value;
+        }
+        else {
+            return dateTime.startOf(step);
+        }
+    }
+    Step.startOf = startOf;
+    function asDuration(step, amount = 1) {
+        switch (step) {
+            case "hour":
+                return luxon.Duration.fromObject({ hours: amount });
+            case "day":
+                return luxon.Duration.fromObject({ days: amount });
+            case "week":
+                return luxon.Duration.fromObject({ days: 7 * amount });
+            case "month":
+                return luxon.Duration.fromObject({ months: amount });
+            case "year":
+                return luxon.Duration.fromObject({ years: amount });
+        }
+    }
+    Step.asDuration = asDuration;
+})(exports.Step || (exports.Step = {}));
+
+const invariantDecimalSeparator = (0.1).toString()[1];
+const localeDecimalSeparator = (0.1).toLocaleString()[1];
+class Formatter {
+    toPrecision(value, precision, maxDecimals) {
+        const absValue = Math.abs(value);
+        const noOfIntegerDigits = Math.round(absValue).toString().length;
+        // Adjust precision to maxDecimals
+        if (maxDecimals !== undefined) {
+            precision = Math.min(precision, noOfIntegerDigits + maxDecimals);
+        }
+        if (value === 0) {
+            // (0).toPrecision(1) == "0"
+            // (0).toPrecision(2) == "0.0"
+            // (0).toPrecision(3) == "0.00"
+            // However, we want:
+            // Formatter.toPrecision(0, 0) == "0"
+            // Formatter.toPrecision(0, 1) == "0.0"
+            // Formatter.toPrecision(0, 2) == "0.00"
+            return value.toPrecision(precision + 1);
+        }
+        if (absValue < 1) {
+            return value.toPrecision(precision);
+        }
+        return precision >= noOfIntegerDigits
+            ? value.toFixed(precision - noOfIntegerDigits)
+            : value.toPrecision(precision);
+    }
+    toLocalePrecision(value, precision, maxDecimals) {
+        return this.toPrecision(value, precision, maxDecimals).replace(invariantDecimalSeparator, localeDecimalSeparator);
+    }
+    toFixed(value, precision, maxDecimals) {
+        const parts = this.getParts(value, precision, maxDecimals);
+        if (parts.noOfCoefficientDecimals < parts.exponent) {
+            const number = parts.invariantCoefficientString.replace(invariantDecimalSeparator, "");
+            const zeros = parts.exponent - parts.noOfCoefficientDecimals;
+            return `${number}${"0".repeat(zeros)}`;
+        }
+        else {
+            return parts.invariantPrecisionString;
+        }
+    }
+    toLocaleFixed(value, precision, maxDecimals) {
+        return this.toFixed(value, precision, maxDecimals).replace(invariantDecimalSeparator, localeDecimalSeparator);
+    }
+    getParts(value, precision, maxDecimals) {
+        const precisionString = this.toPrecision(value, precision, maxDecimals);
+        if (precisionString.indexOf("e") >= 0) {
+            const match = /(.*)e([\+-]\d+)$/.exec(precisionString);
+            const coefficientString = match[1];
+            const exponent = parseInt(match[2]);
+            const decimalSeparatorIndex = coefficientString.indexOf(invariantDecimalSeparator);
+            const noOfCoefficientDecimals = decimalSeparatorIndex >= 0
+                ? coefficientString.length - decimalSeparatorIndex - 1
+                : 0;
+            return {
+                invariantPrecisionString: precisionString,
+                invariantCoefficientString: coefficientString,
+                exponent,
+                noOfCoefficientDecimals,
+            };
+        }
+        else {
+            const decimalSeparatorIndex = precisionString.indexOf(invariantDecimalSeparator);
+            const noOfCoefficientDecimals = decimalSeparatorIndex >= 0
+                ? precisionString.length - decimalSeparatorIndex - 1
+                : 0;
+            return {
+                invariantPrecisionString: precisionString,
+                invariantCoefficientString: precisionString,
+                exponent: 0,
+                noOfCoefficientDecimals,
+            };
+        }
+    }
+}
+const NumberFormatter = new Formatter();
+
+function TimeOrRule(timeOrRule) {
+    return timeOrRule;
+}
+(function (TimeOrRule) {
+    function parse(input) {
+        const time = luxon.DateTime.fromISO(input, { setZone: true });
+        return time.isValid ? time : input;
+    }
+    TimeOrRule.parse = parse;
+    function isTime(input) {
+        return typeof input !== "string";
+    }
+    TimeOrRule.isTime = isTime;
+    function isRule(input) {
+        return typeof input === "string";
+    }
+    TimeOrRule.isRule = isRule;
+    function asDateTime(input) {
+        if (isRule(input)) {
+            return;
+        }
+        else if (luxon.DateTime.isDateTime(input)) {
+            return input;
+        }
+        else {
+            const dateTime = luxon.DateTime.fromJSDate(input);
+            if (!dateTime.isValid) {
+                throw new Error("Unable to convert from Date to DateTime");
+            }
+            return dateTime;
+        }
+    }
+    TimeOrRule.asDateTime = asDateTime;
+    function toJSON(input) {
+        return isRule(input) ? input : input.toJSON();
+    }
+    TimeOrRule.toJSON = toJSON;
+})(TimeOrRule || (TimeOrRule = {}));
+
+function BreakdownRule(...params) {
+    let init;
+    switch (params.length) {
+        case 1:
+            init = params[0];
+            break;
+        case 3:
+            init = {
+                origin: params[0],
+                count: params[1],
+                period: params[2],
+            };
+            break;
+        default:
+            throw new TypeError("Invalid breakdown rule format");
+    }
+    const periodName = Math.abs(init.count) == 1 ? init.period : init.period + "s";
+    return `${init.origin}/${init.count}${periodName}`;
+}
+(function (BreakdownRule) {
+    const regex = new RegExp("(.*)/([-+]?[0-9]+)(hour|day|week|month|year)s?");
+    function split(rule) {
+        const match = regex.exec(rule);
+        if (!match) {
+            throw new Error("Invalid breakdown rule format");
+        }
+        const origin = match[1];
+        const count = parseInt(match[2]);
+        let period = match[3];
+        if (period.endsWith("s")) {
+            period = period.substring(0, period.length - 1);
+        }
+        return {
+            origin: TimeOrRule.parse(origin),
+            count,
+            period: period,
+        };
+    }
+    BreakdownRule.split = split;
+})(BreakdownRule || (BreakdownRule = {}));
+
+function csv(values) {
+    return values.join(",");
+}
+
+exports.Medium = void 0;
+(function (Medium) {
+    function isMedium(input) {
+        if (input === "none" || input === "all") {
+            return true;
+        }
+        const ALL_MEDIUMS = [
+            "heat",
+            "water",
+            "cooling",
+            "electricity",
+            "infrastructure",
+        ];
+        return Array.isArray(input)
+            ? !input.some((x) => !ALL_MEDIUMS.includes(x))
+            : ALL_MEDIUMS.includes(input);
+    }
+    Medium.isMedium = isMedium;
+    function isMeter(medium) {
+        return (medium.includes("heat") ||
+            medium.includes("water") ||
+            medium.includes("cooling") ||
+            medium.includes("electricity"));
+    }
+    Medium.isMeter = isMeter;
+    function isFlowMeter(medium) {
+        return (medium.includes("heat") ||
+            medium.includes("water") ||
+            medium.includes("cooling"));
+    }
+    Medium.isFlowMeter = isFlowMeter;
+})(exports.Medium || (exports.Medium = {}));
+
+class PrecisionNumber {
+    get decimals() {
+        if (this.value > -1 && this.value < 1) {
+            return this.precision;
+        }
+        else {
+            return this.precision - getNumberOfIntegralDigits(this.value);
+        }
+    }
+    constructor(value, precision) {
+        this.value = value;
+        this.precision = precision ?? getPrecision(value);
+    }
+    static parse(input) {
+        let normalized = input
+            .trim()
+            .replace(",", ".")
+            .replace(localeDecimalSeparator, invariantDecimalSeparator);
+        if (normalized.endsWith(invariantDecimalSeparator)) {
+            normalized += "0";
+        }
+        const value = parseFloat(normalized);
+        const precision = value === 0
+            ? 1
+            : normalized
+                .replace(".", "")
+                .replace("+", "")
+                .replace("-", "")
+                .replace(/^0+/, "").length;
+        return new PrecisionNumber(value, precision);
+    }
+    abs() {
+        return new PrecisionNumber(Math.abs(this.value), this.precision);
+    }
+    plus(rhs) {
+        // The result should have the same number of decimal places as the minimum of the two inputs
+        const lhs = this;
+        const value = lhs.value + rhs.value;
+        const decimals = Math.min(lhs.decimals, rhs.decimals);
+        const precision = getPrecision(value, decimals);
+        return new PrecisionNumber(value, precision);
+    }
+    minus(rhs) {
+        // The result should have the same number of decimal places as the minimum of the two inputs
+        const lhs = this;
+        const value = lhs.value - rhs.value;
+        const decimals = Math.min(lhs.decimals, rhs.decimals);
+        const precision = getPrecision(value, decimals);
+        return new PrecisionNumber(value, precision);
+    }
+    valueOf() {
+        const scale = Math.pow(10, this.decimals);
+        const integer = Math.round(this.value * scale);
+        const value = integer / scale;
+        return value;
+    }
+    toString() {
+        return this.valueOf().toString();
+    }
+    toFixed() {
+        return NumberFormatter.toFixed(this.valueOf(), this.precision);
+    }
+    toPrecision() {
+        return NumberFormatter.toPrecision(this.valueOf(), this.precision);
+    }
+    toLocaleFixed() {
+        return NumberFormatter.toLocaleFixed(this.valueOf(), this.precision);
+    }
+    toLocalePrecision() {
+        return NumberFormatter.toLocalePrecision(this.valueOf(), this.precision);
+    }
+}
+function getPrecision(number, decimals) {
+    decimals ?? (decimals = number.toString().split(".", 2)[1]?.length ?? 0);
+    if (number == 0) {
+        return 1;
+    }
+    else if (number > -1 && number < 1) {
+        return decimals;
+    }
+    else {
+        return Math.max(getNumberOfIntegralDigits(number) + decimals, 1);
+    }
+}
+function getNumberOfIntegralDigits(number) {
+    const abs = Math.abs(number);
+    if (abs < 10)
+        return 1;
+    if (abs < 100)
+        return 2;
+    if (abs < 1000)
+        return 3;
+    if (abs < 10000)
+        return 4;
+    if (abs < 100000)
+        return 5;
+    if (abs < 1000000)
+        return 6;
+    if (abs < 10000000)
+        return 7;
+    if (abs < 100000000)
+        return 8;
+    if (abs < 1000000000)
+        return 9;
+    return Math.floor(Math.log10(abs) + 1);
+}
+
+function getRegisterId(register) {
+    return typeof register === "string" ? register : register.id;
+}
+
+const aggregatePrefixes = {
+    instant: "",
+    diff: "diff",
+    min: "min",
+    max: "max",
+    avg: "avg",
+    sum: "sum",
+    cnt: "cnt",
+    ssq: "ssq",
+};
+class Convention {
+    getAggregate(register) {
+        const registerId = getRegisterId(register);
+        // Brute force all prefixes - if none of them, then it must be instant.
+        for (const aggregateString of Object.keys(aggregatePrefixes)) {
+            const aggregate = aggregateString;
+            const prefix = aggregatePrefixes[aggregate];
+            if (prefix.length && isPrefix(registerId, prefix)) {
+                // Not instant - it was any of the others.
+                return aggregate;
+            }
+        }
+        return "instant";
+    }
+    toInstant(register) {
+        const registerId = getRegisterId(register);
+        for (const prefix of Object.values(aggregatePrefixes)) {
+            if (prefix.length && isPrefix(registerId, prefix)) {
+                const tail = registerId.substr(prefix.length);
+                return (tail[0].toLowerCase() + tail.substr(1));
+            }
+        }
+        return registerId;
+    }
+    toAggregate(register, aggregate) {
+        const instantRegisterId = this.toInstant(register);
+        if (aggregate === "instant") {
+            return instantRegisterId;
+        }
+        const prefix = aggregatePrefixes[aggregate];
+        return ((prefix +
+            instantRegisterId[0].toUpperCase() +
+            instantRegisterId.substr(1)));
+    }
+}
+function isPrefix(registerId, prefix) {
+    return (registerId.startsWith(prefix) && isUppercase(registerId[prefix.length]));
+}
+function isUppercase(input) {
+    return input.toUpperCase() === input;
+}
+const RegisterConvention = new Convention();
+
+class Library {
+    constructor() {
+        this.definitions = {};
+    }
+    add(...definitions) {
+        for (const definition of definitions) {
+            if (isDefinition(definition)) {
+                this.tryAdd(definition);
+            }
+            else {
+                for (const definitionInPack of Object.values(definition)) {
+                    this.tryAdd(definitionInPack);
+                }
+            }
+        }
+    }
+    tryAdd(definition) {
+        if (!this.definitions[definition.id]) {
+            this.definitions[definition.id] = definition;
+            return true;
+        }
+        return false;
+    }
+    has(id) {
+        return !!this.definitions[id];
+    }
+    tryGet(id) {
+        return this.definitions[id];
+    }
+    get(id) {
+        const definition = this.definitions[id];
+        if (!definition) {
+            throw new Error(`Defintion was not loaded for register ${id}`);
+        }
+        return definition;
+    }
+    all() {
+        return Object.values(this.definitions).map((x) => x);
+    }
+    reset() {
+        this.definitions = {};
+    }
+}
+function isDefinition(definitionOrPack) {
+    return !!(definitionOrPack.id &&
+        definitionOrPack.aggregate &&
+        definitionOrPack.units);
+}
+const RegisterLibrary = new Library();
+
+function Repository(repoOrTeam, name) {
+    const repo = name ? `${repoOrTeam}/${name}` : repoOrTeam;
+    if (!Repository.isRepository(repo)) {
+        throw new TypeError("Invalid repository format");
+    }
+    return repo;
+}
+(function (Repository) {
+    function isRepository(input) {
+        return /^[a-z][a-z0-9-]*\/[a-z][a-z0-9-]*$/.test(input);
+    }
+    Repository.isRepository = isRepository;
+    function split(repo) {
+        const parts = repo.split("/");
+        return {
+            team: parts[0],
+            name: parts[1],
+        };
+    }
+    Repository.split = split;
+})(Repository || (Repository = {}));
+
+/**
+ * Tracks client-side navigation state for cursor-based paging.
+ *
+ * The first page is represented by the empty-string cursor.
+ * `futureCursor` is the server-provided cursor for the page after the current
+ * one, while `cursors` keeps the visited cursor chain so the UI can move
+ * backward without recomputing anything.
+ */
+class CursorNavigationState {
+    /** One-based page number inferred from the visited cursor chain. */
+    get pageNumber() {
+        return this.cursors.indexOf(this.currentCursor) + 1;
+    }
+    /** Total number of pages computed from the total item count and page limit. */
+    get pageCount() {
+        return this.totalCount != null
+            ? Math.ceil(this.totalCount / this.limit)
+            : 0;
+    }
+    /** One-based index of the first item on the current page. */
+    get firstItemNumber() {
+        const index = this.cursors.indexOf(this.currentCursor);
+        const currentPageItemCount = this.pageItemCounts.get(this.currentCursor) ?? 0;
+        return index >= 0 && currentPageItemCount > 0
+            ? this.cursors
+                .slice(0, index)
+                .reduce((itemCount, cursor) => itemCount + (this.pageItemCounts.get(cursor) ?? 0), 0) + 1
+            : 0;
+    }
+    /** One-based index of the last item on the current page. */
+    get lastItemNumber() {
+        const currentPageItemCount = this.pageItemCounts.get(this.currentCursor) ?? 0;
+        return currentPageItemCount > 0
+            ? this.firstItemNumber + currentPageItemCount - 1
+            : 0;
+    }
+    /**
+     * Cursor for the next page, or the current page cursor if the current page is the last page.
+     */
+    get nextCursor() {
+        const currentIndex = this.cursors.indexOf(this.currentCursor);
+        return currentIndex >= 0 && currentIndex < this.cursors.length - 1
+            ? this.cursors[currentIndex + 1]
+            : (this.futureCursor ?? this.currentCursor);
+    }
+    /** Cursor for the previous page, or the first-page sentinel. */
+    get previousCursor() {
+        const currentIndex = this.cursors.indexOf(this.currentCursor);
+        const previousCursor = this.cursors[currentIndex - 1] ?? "";
+        return previousCursor;
+    }
+    /** Whether the current page is the first page. */
+    get currentIsFirst() {
+        return this.currentCursor === "";
+    }
+    /** Whether the current page is the last page. */
+    get currentIsLast() {
+        return (this.futureCursor === null &&
+            (this.cursors.length === 0 ||
+                this.cursors[this.cursors.length - 1] === this.currentCursor));
+    }
+    constructor(options) {
+        /** Cursor for the currently displayed page. */
+        this.currentCursor = "";
+        /**
+         * Cursor for the next page as reported by the server.
+         *
+         * `undefined` means the current page has not been loaded yet.
+         * `null` means that all pages are exhausted.
+         */
+        this.futureCursor = undefined;
+        /** Visited page cursor chain in navigation order. */
+        this.cursors = [];
+        this.pageItemCounts = new Map();
+        /** Total item count when the API provides it or when the last page is reached. */
+        this.totalCount = null;
+        this.limit = options?.limit ?? 20;
+    }
+    /**
+     * Applies a fetched page to the navigation state.
+     *
+     * `cursor` is the request cursor that produced `page`.
+     */
+    visitPage(cursor, page) {
+        // Determine if this page is the first in the navigation flow, and that it is the first time it it visited.
+        const isInitialFirstPage = this.cursors.length === 0 && cursor === "";
+        const isExpectedFuturePage = this.cursors.length > 0 && cursor === this.futureCursor;
+        this.currentCursor = cursor;
+        // Add the visited cursor to the chain only if it's the first or expected future page.
+        if (isInitialFirstPage || isExpectedFuturePage) {
+            this.cursors.push(cursor);
+        }
+        // Set or update the item count for the visited page.
+        if (this.cursors.includes(cursor)) {
+            this.pageItemCounts.set(cursor, page.items.length);
+        }
+        // Set or advance the future cursor if monotonically advancing.
+        // Note that `futureCursor` is advanced even when `cursors.length === 0`.
+        // This allows us to "start" with some intermediate cursor if the first page is not the initial page;
+        // in that case we still track the `futureCursor` so that we can navigate forward - backward in this case is however not possible.
+        if (this.futureCursor === undefined ||
+            isInitialFirstPage ||
+            cursor === this.futureCursor) {
+            this.futureCursor = page.nextCursor;
+        }
+        // Assign total count if provided
+        if (page.totalCount != null) {
+            this.totalCount = page.totalCount;
+        }
+        else if ((isInitialFirstPage || isExpectedFuturePage) &&
+            !page.hasMore) {
+            this.totalCount = this.cursors.reduce((itemCount, cursor) => itemCount + (this.pageItemCounts.get(cursor) ?? 0), 0);
+        }
+    }
+    toString() {
+        const hasItemNumbers = this.cursors.indexOf(this.currentCursor) >= 0;
+        const range = hasItemNumbers
+            ? `${this.firstItemNumber}-${this.lastItemNumber}`
+            : "...";
+        const total = this.totalCount ?? "?";
+        return `${range} / ${total}`;
+    }
+}
+
+const registers = Registers;
+
+exports.BreakdownRule = BreakdownRule;
+exports.CursorNavigationState = CursorNavigationState;
+exports.NumberFormatter = NumberFormatter;
+exports.PrecisionNumber = PrecisionNumber;
+exports.RegisterConvention = RegisterConvention;
+exports.RegisterLibrary = RegisterLibrary;
+exports.Repository = Repository;
+exports.TimeOrRule = TimeOrRule;
+exports.csv = csv;
+exports.invariantDecimalSeparator = invariantDecimalSeparator;
+exports.localeDecimalSeparator = localeDecimalSeparator;
+exports.registers = registers;
+//# sourceMappingURL=index.js.map