@carbonbox/domain 0.27.0 → 0.28.1

package/build/carbonbox/emission-calculation-formulas/domain/entity/EmissionCalculationFormula.js

@@ -134,7 +134,7 @@ class EmissionCalculationFormula extends AggregateRoot_1.AggregateRoot {
             expression: __classPrivateFieldGet(this, _EmissionCalculationFormula_expression, "f").toPrimitives(),
             resultUnit: __classPrivateFieldGet(this, _EmissionCalculationFormula_resultUnit, "f").toEnum(),
             status: __classPrivateFieldGet(this, _EmissionCalculationFormula_status, "f").toEnum(),
-            applicableGreenhouseGases: __classPrivateFieldGet(this, _EmissionCalculationFormula_applicableGreenhouseGases, "f").toEnums(),
+            applicableGreenhouseGases: __classPrivateFieldGet(this, _EmissionCalculationFormula_applicableGreenhouseGases, "f").toPrimitives(),
             emissionSource: __classPrivateFieldGet(this, _EmissionCalculationFormula_emissionSource, "f").toEnum(),
             variables: __classPrivateFieldGet(this, _EmissionCalculationFormula_variables, "f").toPrimitives(),
             activityVariableSymbol: __classPrivateFieldGet(this, _EmissionCalculationFormula_activityVariableSymbol, "f").toPrimitives(),

package/build/carbonbox/emission-calculation-formulas/domain/value-objects/EmissionCalculationFormulaApplicableGreenhouseGases.js

@@ -1,248 +1,63 @@
 "use strict";
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _a, _EmissionCalculationFormulaApplicableGreenhouseGases_guardAgainstInvalidGreenhouseGasTypes, _EmissionCalculationFormulaApplicableGreenhouseGases_guardAgainstDuplicateGreenhouseGases;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EmissionCalculationFormulaApplicableGreenhouseGases = void 0;
 const StringList_1 = require("../../../shared/domain/value-objects/StringList");
-const GreenhouseGas_1 = require("../../../shared/domain/enums/GreenhouseGas");
-const InvalidGreenhouseGasTypeError_1 = require("../exceptions/InvalidGreenhouseGasTypeError");
+const GreenhouseGasSpecies_1 = require("../../../shared/domain/value-objects/GreenhouseGasSpecies");
 const DuplicateGreenhouseGasError_1 = require("../exceptions/DuplicateGreenhouseGasError");
+/**
+ * Especies de gas a las que aplica una fórmula (códigos normalizados: `CO2`, `CH4-FOSSIL`, `R-410A`…).
+ * La categoría de cada especie NO se guarda aquí: se resuelve desde el dato de referencia
+ * (EmissionFactor / GlobalWarmingPotential), que es la fuente de verdad de la taxonomía.
+ * Vacío = la fórmula aplica a toda submission del emissionSource (semántica CAL-007 preservada).
+ */
 class EmissionCalculationFormulaApplicableGreenhouseGases extends StringList_1.StringList {
     constructor(value, skipDomainValidation) {
-        super(value, skipDomainValidation, _a.PROPERTY_NAME, { allowEmpty: false });
+        super(value, skipDomainValidation, EmissionCalculationFormulaApplicableGreenhouseGases.PROPERTY_NAME, { allowEmpty: false });
         if (skipDomainValidation === false) {
-            // Validaciones específicas de greenhouse gases después de las validaciones base de StringList
-            _a.guardAgainstInvalidGreenhouseGases(value);
+            EmissionCalculationFormulaApplicableGreenhouseGases.guardAgainstDuplicateSpecies(value);
         }
     }
-    /**
-     * Factory method para crear una instancia.
-     */
     static create(value) {
-        StringList_1.StringList.guardAgainstInvalidStringList(value, _a.PROPERTY_NAME);
-        return new _a(value, false);
+        StringList_1.StringList.guardAgainstInvalidStringList(value, EmissionCalculationFormulaApplicableGreenhouseGases.PROPERTY_NAME);
+        // Normaliza + valida cada especie por el VO compartido (trim + colapsar espacios + UPPERCASE).
+        const normalized = value.map((species) => GreenhouseGasSpecies_1.GreenhouseGasSpecies.create(species).toPrimitives());
+        return new EmissionCalculationFormulaApplicableGreenhouseGases(normalized, false);
     }
     static fromPrimitives(primitives) {
-        const value = primitives.map((primitive) => primitive);
-        return new _a(value, true);
-    }
-    /**
-     * Validaciones específicas para greenhouse gas types.
-     */
-    static guardAgainstInvalidGreenhouseGases(value) {
-        __classPrivateFieldGet(this, _a, "m", _EmissionCalculationFormulaApplicableGreenhouseGases_guardAgainstInvalidGreenhouseGasTypes).call(this, value);
-        __classPrivateFieldGet(this, _a, "m", _EmissionCalculationFormulaApplicableGreenhouseGases_guardAgainstDuplicateGreenhouseGases).call(this, value);
+        return new EmissionCalculationFormulaApplicableGreenhouseGases([...primitives], true);
+    }
+    static guardAgainstDuplicateSpecies(value) {
+        const counts = new Map();
+        value.forEach((species) => counts.set(species, (counts.get(species) || 0) + 1));
+        const duplicates = [...counts.entries()].filter(([, count]) => count > 1).map(([species]) => species);
+        if (duplicates.length > 0) {
+            throw DuplicateGreenhouseGasError_1.DuplicateGreenhouseGasError.create(EmissionCalculationFormulaApplicableGreenhouseGases.PROPERTY_NAME, duplicates);
+        }
     }
-    /**
-     * Convierte a representación primitiva.
-     */
     toPrimitives() {
         return [...this.value];
     }
-    /**
-     * Obtiene los greenhouse gas types como array de enums.
-     */
-    toEnums() {
-        return this.value;
-    }
-    /**
-     * Obtiene los greenhouse gas types como array de strings.
-     */
-    toGreenhouseGasTypeStrings() {
-        return [...this.value];
-    }
-    /**
-     * Verifica si contiene un greenhouse gas type específico.
-     */
-    contains(gasType) {
-        return this.value.includes(gasType);
-    }
-    /**
-     * Obtiene los greenhouse gases como array inmutable.
-     */
-    get greenhouseGases() {
+    get speciesCodes() {
         return Object.freeze([...this.value]);
     }
-    /**
-     * Número de greenhouse gases.
-     */
+    contains(species) {
+        return this.value.includes(GreenhouseGasSpecies_1.GreenhouseGasSpecies.normalize(species));
+    }
     get length() {
         return this.value.length;
     }
-    /**
-     * Verifica si la colección está vacía.
-     */
     isEmpty() {
         return this.value.length === 0;
     }
-    /**
-     * Verifica si la colección tiene valores.
-     */
     hasValues() {
         return !this.isEmpty();
     }
-    /**
-     * Verifica si incluye todos los greenhouse gas types especificados.
-     */
-    includesAllOf(gasTypes) {
-        return gasTypes.every((gasType) => this.contains(gasType));
-    }
-    /**
-     * Verifica si incluye alguno de los greenhouse gas types especificados.
-     */
-    includesAnyOf(gasTypes) {
-        return gasTypes.some((gasType) => this.contains(gasType));
-    }
-    /**
-     * Obtiene los greenhouse gas types comunes con otra colección.
-     */
-    getCommonGases(other) {
-        return this.value.filter((gas) => other.contains(gas));
-    }
-    /**
-     * Obtiene los greenhouse gas types únicos de esta colección comparado con otra.
-     */
-    getUniqueGases(other) {
-        return this.value.filter((gas) => !other.contains(gas));
-    }
-    /**
-     * Verifica si contiene CO2.
-     */
-    hasCO2() {
-        return this.contains(GreenhouseGas_1.GreenhouseGas.CO2);
-    }
-    /**
-     * Verifica si contiene CH4 (metano).
-     */
-    hasMethane() {
-        return this.contains(GreenhouseGas_1.GreenhouseGas.CH4);
+    includesAllOf(species) {
+        return species.every((current) => this.contains(current));
     }
-    /**
-     * Verifica si contiene N2O (óxido nitroso).
-     */
-    hasNitrousOxide() {
-        return this.contains(GreenhouseGas_1.GreenhouseGas.N2O);
-    }
-    /**
-     * Verifica si contiene gases fluorados (HFCs, PFCs, SF6, NF3).
-     */
-    hasFluorinatedGases() {
-        const fluorinatedGases = [
-            GreenhouseGas_1.GreenhouseGas.HFC134a,
-            GreenhouseGas_1.GreenhouseGas.SF6,
-            GreenhouseGas_1.GreenhouseGas.NF3,
-        ];
-        return fluorinatedGases.some((gas) => this.contains(gas));
-    }
-    /**
-     * Verifica si contiene solo los tres gases principales del Protocolo de Kyoto.
-     */
-    hasOnlyKyotoMainGases() {
-        const kyotoMainGases = [GreenhouseGas_1.GreenhouseGas.CO2, GreenhouseGas_1.GreenhouseGas.CH4, GreenhouseGas_1.GreenhouseGas.N2O];
-        return this.value.length === 3 && this.includesAllOf(kyotoMainGases);
-    }
-    /**
-     * Verifica si incluye todos los gases del Protocolo de Kyoto.
-     */
-    includesAllKyotoGases() {
-        const allKyotoGases = Object.values(GreenhouseGas_1.GreenhouseGas);
-        return this.includesAllOf(allKyotoGases);
-    }
-    /**
-     * Obtiene los gases por categoría de potencial de calentamiento.
-     */
-    getGasesByWarmingPotentialCategory() {
-        const lowPotential = [];
-        const mediumPotential = [];
-        const highPotential = [];
-        this.value.forEach((gas) => {
-            const gasType = gas;
-            switch (gasType) {
-                case GreenhouseGas_1.GreenhouseGas.CO2:
-                    lowPotential.push(gasType);
-                    break;
-                case GreenhouseGas_1.GreenhouseGas.CH4:
-                case GreenhouseGas_1.GreenhouseGas.N2O:
-                    mediumPotential.push(gasType);
-                    break;
-                default:
-                    highPotential.push(gasType);
-                    break;
-            }
-        });
-        return {
-            lowPotential,
-            mediumPotential,
-            highPotential,
-        };
-    }
-    /**
-     * Obtiene la complejidad de la colección basada en el número y tipo de gases.
-     */
-    getComplexity() {
-        const gasCount = this.length;
-        const hasFluorinatedGases = this.hasFluorinatedGases();
-        if (gasCount === 1)
-            return 'simple';
-        if (gasCount <= 3 && !hasFluorinatedGases)
-            return 'simple';
-        if (gasCount <= 5)
-            return 'medium';
-        return 'complex';
-    }
-    /**
-     * Obtiene estadísticas de la colección.
-     */
-    getStatistics() {
-        return {
-            totalGases: this.length,
-            hasCO2: this.hasCO2(),
-            hasMethane: this.hasMethane(),
-            hasNitrousOxide: this.hasNitrousOxide(),
-            hasFluorinatedGases: this.hasFluorinatedGases(),
-            includesAllKyotoGases: this.includesAllKyotoGases(),
-            complexity: this.getComplexity(),
-        };
-    }
-    /**
-     * Representación como string de los greenhouse gas types.
-     */
-    toString() {
-        return this.value.join(', ');
+    includesAnyOf(species) {
+        return species.some((current) => this.contains(current));
     }
 }
 exports.EmissionCalculationFormulaApplicableGreenhouseGases = EmissionCalculationFormulaApplicableGreenhouseGases;
-_a = EmissionCalculationFormulaApplicableGreenhouseGases, _EmissionCalculationFormulaApplicableGreenhouseGases_guardAgainstInvalidGreenhouseGasTypes = function _EmissionCalculationFormulaApplicableGreenhouseGases_guardAgainstInvalidGreenhouseGasTypes(value) {
-    const validGasTypes = Object.values(GreenhouseGas_1.GreenhouseGas);
-    const invalidGases = [];
-    value.forEach((gas, index) => {
-        if (!validGasTypes.includes(gas)) {
-            invalidGases.push(`[${index}]: ${gas}`);
-        }
-    });
-    if (invalidGases.length > 0) {
-        throw InvalidGreenhouseGasTypeError_1.InvalidGreenhouseGasTypeError.create(_a.PROPERTY_NAME, validGasTypes, invalidGases.join(', '));
-    }
-}, _EmissionCalculationFormulaApplicableGreenhouseGases_guardAgainstDuplicateGreenhouseGases = function _EmissionCalculationFormulaApplicableGreenhouseGases_guardAgainstDuplicateGreenhouseGases(value) {
-    const gasTypeCount = new Map();
-    const duplicates = [];
-    // Contar ocurrencias
-    value.forEach((gas) => {
-        const count = gasTypeCount.get(gas) || 0;
-        gasTypeCount.set(gas, count + 1);
-    });
-    // Encontrar duplicados
-    gasTypeCount.forEach((count, gas) => {
-        if (count > 1) {
-            duplicates.push(gas);
-        }
-    });
-    if (duplicates.length > 0) {
-        throw DuplicateGreenhouseGasError_1.DuplicateGreenhouseGasError.create(_a.PROPERTY_NAME, duplicates);
-    }
-};
 EmissionCalculationFormulaApplicableGreenhouseGases.PROPERTY_NAME = 'applicableGreenhouseGases';

package/build/carbonbox/emission-calculation-formulas/emission-factors/domain/value-objects/EmissionFactorGreenhouseGasValues.js

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EmissionFactorGreenhouseGasValues = void 0;
 const ValueObject_1 = require("../../../../shared/domain/value-objects/ValueObject");
-const GreenhouseGas_1 = require("../../../../shared/domain/enums/GreenhouseGas");
+const GreenhouseGasCategory_1 = require("../../../../shared/domain/enums/GreenhouseGasCategory");
+const GreenhouseGasSpecies_1 = require("../../../../shared/domain/value-objects/GreenhouseGasSpecies");
 const CountryCode_1 = require("../../../../shared/domain/enums/CountryCode");
 const String_1 = require("../../../../shared/domain/value-objects/String");
 const Numeric_1 = require("../../../../shared/domain/value-objects/Numeric");
@@ -19,7 +20,8 @@ class EmissionFactorGreenhouseGasValues extends ValueObject_1.ValueObject {
     }
     static fromPrimitives(primitives) {
         const value = primitives.map((primitive) => ({
-            greenhouseGas: primitive.greenhouseGas,
+            greenhouseGasCategory: primitive.greenhouseGasCategory,
+            greenhouseGasSpecies: primitive.greenhouseGasSpecies,
             countryValues: primitive.countryValues.map((countryValue) => countryValue),
             dataSource: primitive.dataSource,
             unit: primitive.unit,
@@ -45,14 +47,16 @@ class EmissionFactorGreenhouseGasValues extends ValueObject_1.ValueObject {
         if (!value || typeof value !== 'object') {
             throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(propertyName, 'object', typeof value);
         }
-        EmissionFactorGreenhouseGasValues.guardAgainstInvalidGreenhouseGas(value.greenhouseGas, `${propertyName}.greenhouseGas`);
+        EmissionFactorGreenhouseGasValues.guardAgainstInvalidCategory(value.greenhouseGasCategory, `${propertyName}.greenhouseGasCategory`);
+        // Normaliza + valida el código de especie (lanza si el formato es inválido).
+        GreenhouseGasSpecies_1.GreenhouseGasSpecies.create(value.greenhouseGasSpecies);
         EmissionFactorGreenhouseGasValues.guardAgainstInvalidCountryValues(value.countryValues, `${propertyName}.countryValues`);
         EmissionFactorGreenhouseGasValues.guardAgainstInvalidUnit(value.unit, `${propertyName}.unit`);
         EmissionFactorGreenhouseGasValues.guardAgainstInvalidDataSource(value.dataSource, `${propertyName}.dataSource`);
     }
-    static guardAgainstInvalidGreenhouseGas(greenhouseGas, propertyName) {
-        if (!Object.values(GreenhouseGas_1.GreenhouseGas).includes(greenhouseGas)) {
-            throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(propertyName, `valid GreenhouseGas enum value (${Object.values(GreenhouseGas_1.GreenhouseGas).join(', ')})`, `"${greenhouseGas}"`);
+    static guardAgainstInvalidCategory(category, propertyName) {
+        if (!Object.values(GreenhouseGasCategory_1.GreenhouseGasCategory).includes(category)) {
+            throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(propertyName, `valid GreenhouseGasCategory enum value (${Object.values(GreenhouseGasCategory_1.GreenhouseGasCategory).join(', ')})`, `"${category}"`);
         }
     }
     static guardAgainstInvalidCountryValues(countryValues, propertyName) {
@@ -133,10 +137,10 @@ class EmissionFactorGreenhouseGasValues extends ValueObject_1.ValueObject {
         String_1.String.guardAgainstEmptyValue(dataSource, propertyName);
     }
     static guardAgainstDuplicateGreenhouseGases(values, propertyName) {
-        const greenhouseGases = values.map((value) => value.greenhouseGas);
-        const uniqueGreenhouseGases = new Set(greenhouseGases);
-        if (greenhouseGases.length !== uniqueGreenhouseGases.size) {
-            throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(propertyName, 'unique greenhouse gases', 'duplicate greenhouse gas entries found');
+        const species = values.map((value) => GreenhouseGasSpecies_1.GreenhouseGasSpecies.normalize(value.greenhouseGasSpecies));
+        const uniqueSpecies = new Set(species);
+        if (species.length !== uniqueSpecies.size) {
+            throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(propertyName, 'unique greenhouse gas species', 'duplicate greenhouse gas species entries found');
         }
     }
     static guardAgainstDuplicateCountries(countryValues, propertyName) {
@@ -148,7 +152,8 @@ class EmissionFactorGreenhouseGasValues extends ValueObject_1.ValueObject {
     }
     static toPrimitivesArray(value) {
         return value.map((ghgFactorValue) => ({
-            greenhouseGas: ghgFactorValue.greenhouseGas,
+            greenhouseGasCategory: ghgFactorValue.greenhouseGasCategory,
+            greenhouseGasSpecies: GreenhouseGasSpecies_1.GreenhouseGasSpecies.normalize(ghgFactorValue.greenhouseGasSpecies),
             countryValues: ghgFactorValue.countryValues.map((countryValue) => ({
                 country: countryValue.country,
                 factorValue: countryValue.factorValue,

package/build/carbonbox/emission-calculation-formulas/global-warming-potentials/domain/value-objects/GlobalWarmingPotentialGreenhouseGasPotentials.js

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GlobalWarmingPotentialGreenhouseGasPotentials = void 0;
 const ValueObject_1 = require("../../../../shared/domain/value-objects/ValueObject");
-const GreenhouseGas_1 = require("../../../../shared/domain/enums/GreenhouseGas");
+const GreenhouseGasCategory_1 = require("../../../../shared/domain/enums/GreenhouseGasCategory");
+const GreenhouseGasSpecies_1 = require("../../../../shared/domain/value-objects/GreenhouseGasSpecies");
 const Numeric_1 = require("../../../../shared/domain/value-objects/Numeric");
 const InvalidPropertyValueError_1 = require("../../../../shared/domain/exceptions/InvalidPropertyValueError");
 class GlobalWarmingPotentialGreenhouseGasPotentials extends ValueObject_1.ValueObject {
@@ -17,7 +18,8 @@ class GlobalWarmingPotentialGreenhouseGasPotentials extends ValueObject_1.ValueO
     }
     static fromPrimitives(primitives) {
         const value = primitives.map(((primitive) => ({
-            greenhouseGas: primitive.greenhouseGas,
+            greenhouseGasCategory: primitive.greenhouseGasCategory,
+            greenhouseGasSpecies: primitive.greenhouseGasSpecies,
             potentialValue: primitive.potentialValue,
         })));
         return new GlobalWarmingPotentialGreenhouseGasPotentials(value, true);
@@ -35,18 +37,20 @@ class GlobalWarmingPotentialGreenhouseGasPotentials extends ValueObject_1.ValueO
         value.forEach((ghgPotentialValue, index) => {
             GlobalWarmingPotentialGreenhouseGasPotentials.guardAgainstInvalidGHGPotentialValue(ghgPotentialValue, `${propertyName}[${index}]`);
         });
-        GlobalWarmingPotentialGreenhouseGasPotentials.guardAgainstDuplicateGreenhouseGases(value, propertyName);
+        GlobalWarmingPotentialGreenhouseGasPotentials.guardAgainstDuplicateSpecies(value, propertyName);
     }
     static guardAgainstInvalidGHGPotentialValue(value, propertyName) {
         if (!value || typeof value !== 'object') {
             throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(propertyName, 'object', typeof value);
         }
-        GlobalWarmingPotentialGreenhouseGasPotentials.guardAgainstInvalidGreenhouseGas(value.greenhouseGas, `${propertyName}.greenhouseGas`);
+        GlobalWarmingPotentialGreenhouseGasPotentials.guardAgainstInvalidCategory(value.greenhouseGasCategory, `${propertyName}.greenhouseGasCategory`);
+        // Normaliza + valida el código de especie (lanza si el formato es inválido).
+        GreenhouseGasSpecies_1.GreenhouseGasSpecies.create(value.greenhouseGasSpecies);
         GlobalWarmingPotentialGreenhouseGasPotentials.guardAgainstInvalidPotentialValue(value.potentialValue, `${propertyName}.potentialValue`);
     }
-    static guardAgainstInvalidGreenhouseGas(greenhouseGas, propertyName) {
-        if (!Object.values(GreenhouseGas_1.GreenhouseGas).includes(greenhouseGas)) {
-            throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(propertyName, `valid GreenhouseGas enum value (${Object.values(GreenhouseGas_1.GreenhouseGas).join(', ')})`, `"${greenhouseGas}"`);
+    static guardAgainstInvalidCategory(category, propertyName) {
+        if (!Object.values(GreenhouseGasCategory_1.GreenhouseGasCategory).includes(category)) {
+            throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(propertyName, `valid GreenhouseGasCategory enum value (${Object.values(GreenhouseGasCategory_1.GreenhouseGasCategory).join(', ')})`, `"${category}"`);
         }
     }
     static guardAgainstInvalidPotentialValue(potentialValue, propertyName) {
@@ -58,16 +62,17 @@ class GlobalWarmingPotentialGreenhouseGasPotentials extends ValueObject_1.ValueO
             throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(propertyName, 'non-negative number', `${potentialValue}`);
         }
     }
-    static guardAgainstDuplicateGreenhouseGases(values, propertyName) {
-        const greenhouseGases = values.map((value) => value.greenhouseGas);
-        const uniqueGreenhouseGases = new Set(greenhouseGases);
-        if (greenhouseGases.length !== uniqueGreenhouseGases.size) {
-            throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(propertyName, 'unique greenhouse gases', 'duplicate greenhouse gas entries found');
+    static guardAgainstDuplicateSpecies(values, propertyName) {
+        const species = values.map((value) => GreenhouseGasSpecies_1.GreenhouseGasSpecies.normalize(value.greenhouseGasSpecies));
+        const uniqueSpecies = new Set(species);
+        if (species.length !== uniqueSpecies.size) {
+            throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(propertyName, 'unique greenhouse gas species', 'duplicate greenhouse gas species entries found');
         }
     }
     static toPrimitivesArray(value) {
         return value.map((ghgPotentialValue) => ({
-            greenhouseGas: ghgPotentialValue.greenhouseGas,
+            greenhouseGasCategory: ghgPotentialValue.greenhouseGasCategory,
+            greenhouseGasSpecies: GreenhouseGasSpecies_1.GreenhouseGasSpecies.normalize(ghgPotentialValue.greenhouseGasSpecies),
             potentialValue: ghgPotentialValue.potentialValue,
         }));
     }