@carbonbox/domain 0.51.0 → 0.53.0

package/build/carbonbox/carbon-footprint-audits/verification-statements/domain/value-objects/VerificationStatementVerifierOrganizationName.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerificationStatementVerifierOrganizationName = void 0;
+const String_1 = require("../../../../shared/domain/value-objects/String");
+const InvalidPropertyValueError_1 = require("../../../../shared/domain/exceptions/InvalidPropertyValueError");
+/**
+ * Name of the verification body the auditor issued the statement for, copied from the auditor
+ * profile when issuing (never re-read). Required, up to 255 characters.
+ */
+class VerificationStatementVerifierOrganizationName extends String_1.String {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, VerificationStatementVerifierOrganizationName.PROPERTY_NAME);
+    }
+    static create(value) {
+        String_1.String.guardAgainstEmptyValue(value, VerificationStatementVerifierOrganizationName.PROPERTY_NAME);
+        String_1.String.guardAgainstInvalidType(value, VerificationStatementVerifierOrganizationName.PROPERTY_NAME);
+        VerificationStatementVerifierOrganizationName.guardAgainstExcessiveLength(value);
+        return new VerificationStatementVerifierOrganizationName(value.trim(), false);
+    }
+    static guardAgainstExcessiveLength(value) {
+        if (value.trim().length > VerificationStatementVerifierOrganizationName.MAX_LENGTH) {
+            throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(VerificationStatementVerifierOrganizationName.PROPERTY_NAME, `at most ${VerificationStatementVerifierOrganizationName.MAX_LENGTH} characters`, `${value.trim().length} characters`);
+        }
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new VerificationStatementVerifierOrganizationName(value, true);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.VerificationStatementVerifierOrganizationName = VerificationStatementVerifierOrganizationName;
+VerificationStatementVerifierOrganizationName.PROPERTY_NAME = 'verifierOrganizationName';
+VerificationStatementVerifierOrganizationName.MAX_LENGTH = 255;

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

@@ -10,7 +10,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 _EmissionFactor_code, _EmissionFactor_name, _EmissionFactor_description, _EmissionFactor_greenhouseGasValues, _EmissionFactor_informationSource, _EmissionFactor_ipccCode, _EmissionFactor_ipccSubcategory, _EmissionFactor_methodologicalTier;
+var _EmissionFactor_code, _EmissionFactor_name, _EmissionFactor_description, _EmissionFactor_greenhouseGasValues, _EmissionFactor_informationSource, _EmissionFactor_ipccCode, _EmissionFactor_ipccSubcategory, _EmissionFactor_methodologicalTier, _EmissionFactor_biogenicContent;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EmissionFactor = void 0;
 const AggregateRoot_1 = require("../../../../shared/domain/entities/AggregateRoot");
@@ -23,6 +23,9 @@ const EmissionFactorIpccCode_1 = require("../value-objects/EmissionFactorIpccCod
 const EmissionFactorIpccSubcategory_1 = require("../value-objects/EmissionFactorIpccSubcategory");
 const EmissionFactorMethodologicalTier_1 = require("../value-objects/EmissionFactorMethodologicalTier");
 const EmissionFactorName_1 = require("../value-objects/EmissionFactorName");
+const EmissionFactorBiogenicContent_1 = require("../value-objects/EmissionFactorBiogenicContent");
+const InconsistentEmissionFactorBiogenicContentError_1 = require("../exceptions/InconsistentEmissionFactorBiogenicContentError");
+const StandardGreenhouseGasSpecies_1 = require("../../../../shared/domain/enums/StandardGreenhouseGasSpecies");
 class EmissionFactor extends AggregateRoot_1.AggregateRoot {
     constructor(props, skipDomainValidation) {
         const id = skipDomainValidation
@@ -37,6 +40,7 @@ class EmissionFactor extends AggregateRoot_1.AggregateRoot {
         _EmissionFactor_ipccCode.set(this, void 0);
         _EmissionFactor_ipccSubcategory.set(this, void 0);
         _EmissionFactor_methodologicalTier.set(this, void 0);
+        _EmissionFactor_biogenicContent.set(this, void 0);
         if (skipDomainValidation === false) {
             // Initialize with domain validation
             __classPrivateFieldSet(this, _EmissionFactor_code, EmissionFactorCode_1.EmissionFactorCode.create(props.code), "f");
@@ -47,6 +51,8 @@ class EmissionFactor extends AggregateRoot_1.AggregateRoot {
             __classPrivateFieldSet(this, _EmissionFactor_ipccCode, EmissionFactorIpccCode_1.EmissionFactorIpccCode.create(props.ipccCode), "f");
             __classPrivateFieldSet(this, _EmissionFactor_ipccSubcategory, EmissionFactorIpccSubcategory_1.EmissionFactorIpccSubcategory.create(props.ipccSubcategory), "f");
             __classPrivateFieldSet(this, _EmissionFactor_methodologicalTier, EmissionFactorMethodologicalTier_1.EmissionFactorMethodologicalTier.create(props.methodologicalTier), "f");
+            __classPrivateFieldSet(this, _EmissionFactor_biogenicContent, EmissionFactorBiogenicContent_1.EmissionFactorBiogenicContent.create(props.biogenicContent), "f");
+            EmissionFactor.guardAgainstInconsistentBiogenicContent(__classPrivateFieldGet(this, _EmissionFactor_biogenicContent, "f"), __classPrivateFieldGet(this, _EmissionFactor_greenhouseGasValues, "f"));
         }
         else {
             // Initialize from primitives (no domain validation)
@@ -58,6 +64,7 @@ class EmissionFactor extends AggregateRoot_1.AggregateRoot {
             __classPrivateFieldSet(this, _EmissionFactor_ipccCode, EmissionFactorIpccCode_1.EmissionFactorIpccCode.fromPrimitives(props.ipccCode), "f");
             __classPrivateFieldSet(this, _EmissionFactor_ipccSubcategory, EmissionFactorIpccSubcategory_1.EmissionFactorIpccSubcategory.fromPrimitives(props.ipccSubcategory), "f");
             __classPrivateFieldSet(this, _EmissionFactor_methodologicalTier, EmissionFactorMethodologicalTier_1.EmissionFactorMethodologicalTier.fromPrimitives(props.methodologicalTier), "f");
+            __classPrivateFieldSet(this, _EmissionFactor_biogenicContent, EmissionFactorBiogenicContent_1.EmissionFactorBiogenicContent.fromPrimitives(props.biogenicContent), "f");
         }
     }
     static create(props) {
@@ -74,6 +81,7 @@ class EmissionFactor extends AggregateRoot_1.AggregateRoot {
             ipccCode: primitives.ipccCode,
             ipccSubcategory: primitives.ipccSubcategory,
             methodologicalTier: primitives.methodologicalTier,
+            biogenicContent: primitives.biogenicContent,
         };
         return new EmissionFactor(props, true);
     }
@@ -88,6 +96,7 @@ class EmissionFactor extends AggregateRoot_1.AggregateRoot {
             ipccCode: __classPrivateFieldGet(this, _EmissionFactor_ipccCode, "f").toPrimitives(),
             ipccSubcategory: __classPrivateFieldGet(this, _EmissionFactor_ipccSubcategory, "f").toPrimitives(),
             methodologicalTier: __classPrivateFieldGet(this, _EmissionFactor_methodologicalTier, "f").toEnum(),
+            biogenicContent: __classPrivateFieldGet(this, _EmissionFactor_biogenicContent, "f").toEnum(),
         };
     }
     get code() {
@@ -114,6 +123,39 @@ class EmissionFactor extends AggregateRoot_1.AggregateRoot {
     get methodologicalTier() {
         return __classPrivateFieldGet(this, _EmissionFactor_methodologicalTier, "f");
     }
+    get biogenicContent() {
+        return __classPrivateFieldGet(this, _EmissionFactor_biogenicContent, "f");
+    }
+    /**
+     * Coherencia entre el contenido biogénico declarado y las especies del factor
+     * (GHG Protocol cap. 9 / ISO 14064-1 §9.3.1): evita, p.ej., una leña cargada con `CO2` fósil
+     * (se sumaría al inventario) o una mezcla con biocombustible sin su `CO2-BIOGENIC`.
+     *   - NONE: no declara `CO2-BIOGENIC` ni `CH4-NON-FOSSIL`.
+     *   - FULL: no declara `CO2` ni `CH4-FOSSIL`, y declara `CO2-BIOGENIC` o `CH4-NON-FOSSIL`.
+     *   - PARTIAL: declara `CO2` y `CO2-BIOGENIC`.
+     * N2O y las especies de texto libre se aceptan con cualquier contenido.
+     */
+    static guardAgainstInconsistentBiogenicContent(biogenicContent, greenhouseGasValues) {
+        const declaredSpecies = greenhouseGasValues.toPrimitives().map((value) => value.greenhouseGasSpecies);
+        const declares = (species) => declaredSpecies.includes(species);
+        const forbiddenSpecies = [];
+        const missingSpecies = [];
+        if (biogenicContent.isNone()) {
+            forbiddenSpecies.push(...[StandardGreenhouseGasSpecies_1.StandardGreenhouseGasSpecies.CO2_BIOGENIC, StandardGreenhouseGasSpecies_1.StandardGreenhouseGasSpecies.CH4_NON_FOSSIL].filter(declares));
+        }
+        if (biogenicContent.isFull()) {
+            forbiddenSpecies.push(...[StandardGreenhouseGasSpecies_1.StandardGreenhouseGasSpecies.CO2, StandardGreenhouseGasSpecies_1.StandardGreenhouseGasSpecies.CH4_FOSSIL].filter(declares));
+            if (!declares(StandardGreenhouseGasSpecies_1.StandardGreenhouseGasSpecies.CO2_BIOGENIC) && !declares(StandardGreenhouseGasSpecies_1.StandardGreenhouseGasSpecies.CH4_NON_FOSSIL)) {
+                missingSpecies.push(`${StandardGreenhouseGasSpecies_1.StandardGreenhouseGasSpecies.CO2_BIOGENIC} or ${StandardGreenhouseGasSpecies_1.StandardGreenhouseGasSpecies.CH4_NON_FOSSIL}`);
+            }
+        }
+        if (biogenicContent.isPartial()) {
+            missingSpecies.push(...[StandardGreenhouseGasSpecies_1.StandardGreenhouseGasSpecies.CO2, StandardGreenhouseGasSpecies_1.StandardGreenhouseGasSpecies.CO2_BIOGENIC].filter((species) => !declares(species)));
+        }
+        if (forbiddenSpecies.length > 0 || missingSpecies.length > 0) {
+            throw InconsistentEmissionFactorBiogenicContentError_1.InconsistentEmissionFactorBiogenicContentError.create(biogenicContent.toEnum(), declaredSpecies, forbiddenSpecies, missingSpecies);
+        }
+    }
 }
 exports.EmissionFactor = EmissionFactor;
-_EmissionFactor_code = new WeakMap(), _EmissionFactor_name = new WeakMap(), _EmissionFactor_description = new WeakMap(), _EmissionFactor_greenhouseGasValues = new WeakMap(), _EmissionFactor_informationSource = new WeakMap(), _EmissionFactor_ipccCode = new WeakMap(), _EmissionFactor_ipccSubcategory = new WeakMap(), _EmissionFactor_methodologicalTier = new WeakMap();
+_EmissionFactor_code = new WeakMap(), _EmissionFactor_name = new WeakMap(), _EmissionFactor_description = new WeakMap(), _EmissionFactor_greenhouseGasValues = new WeakMap(), _EmissionFactor_informationSource = new WeakMap(), _EmissionFactor_ipccCode = new WeakMap(), _EmissionFactor_ipccSubcategory = new WeakMap(), _EmissionFactor_methodologicalTier = new WeakMap(), _EmissionFactor_biogenicContent = new WeakMap();

package/build/carbonbox/emission-calculation-formulas/emission-factors/domain/enums/BiogenicContent.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BiogenicContent = void 0;
+/**
+ * Biogenic carbon content of an emission factor
+ * Declares the carbon origin of the activity so the greenhouse gas species of the factor can be
+ * checked for coherence (GHG Protocol Corporate Standard cap. 9; ISO 14064-1:2018 §9.3.1)
+ */
+var BiogenicContent;
+(function (BiogenicContent) {
+    /**
+     * No biogenic carbon - fossil fuels, grid electricity, refrigerants, industrial processes.
+     * Must not declare `CO2-BIOGENIC` nor `CH4-NON-FOSSIL`
+     */
+    BiogenicContent["NONE"] = "NONE";
+    /**
+     * Fully biogenic carbon - biomass, organic waste, wastewater.
+     * Must not declare `CO2` nor `CH4-FOSSIL`, and must declare `CO2-BIOGENIC` or `CH4-NON-FOSSIL`
+     */
+    BiogenicContent["FULL"] = "FULL";
+    /**
+     * Fossil and biogenic carbon - fuels blended with biofuels.
+     * Must declare both `CO2` and `CO2-BIOGENIC`
+     */
+    BiogenicContent["PARTIAL"] = "PARTIAL";
+})(BiogenicContent || (exports.BiogenicContent = BiogenicContent = {}));

package/build/carbonbox/emission-calculation-formulas/emission-factors/domain/exceptions/InconsistentEmissionFactorBiogenicContentError.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InconsistentEmissionFactorBiogenicContentError = void 0;
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InconsistentEmissionFactorBiogenicContentError extends CodedRootError_1.CodedRootError {
+    constructor(biogenicContent, declaredSpecies, forbiddenSpecies, missingSpecies) {
+        const problems = [];
+        if (forbiddenSpecies.length > 0) {
+            problems.push(`must not declare [${forbiddenSpecies.join(', ')}]`);
+        }
+        if (missingSpecies.length > 0) {
+            problems.push(`must declare [${missingSpecies.join(', ')}]`);
+        }
+        const technicalMessage = `Emission factor with biogenic content '${biogenicContent}' ${problems.join(' and ')} `
+            + `(declared species: [${declaredSpecies.join(', ')}]).`;
+        const context = {
+            biogenicContent,
+            declaredSpecies,
+            forbiddenSpecies,
+            missingSpecies,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'NONE (fossil fuels, grid electricity, refrigerants): use CO2 and CH4-FOSSIL, never CO2-BIOGENIC nor CH4-NON-FOSSIL',
+            'FULL (biomass, organic waste, wastewater): use CO2-BIOGENIC and/or CH4-NON-FOSSIL, never CO2 nor CH4-FOSSIL',
+            'PARTIAL (fuels blended with biofuels): split the carbon dioxide into CO2 (fossil share) and CO2-BIOGENIC (biofuel share)',
+            'N2O and non-standard species are allowed with any biogenic content',
+        ];
+        super(ErrorCode_1.ErrorCode.INCONSISTENT_EMISSION_FACTOR_BIOGENIC_CONTENT, technicalMessage, context, suggestions);
+        this.name = 'InconsistentEmissionFactorBiogenicContentError';
+    }
+    static create(biogenicContent, declaredSpecies, forbiddenSpecies, missingSpecies) {
+        return new InconsistentEmissionFactorBiogenicContentError(biogenicContent, declaredSpecies, forbiddenSpecies, missingSpecies);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.InconsistentEmissionFactorBiogenicContentError = InconsistentEmissionFactorBiogenicContentError;

package/build/carbonbox/emission-calculation-formulas/emission-factors/domain/exceptions/InvalidBiogenicContentError.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidBiogenicContentError = void 0;
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidBiogenicContentError extends CodedRootError_1.CodedRootError {
+    constructor(receivedValue, validValues) {
+        const validValuesList = validValues.join(', ');
+        const technicalMessage = `Invalid biogenic content value '${receivedValue}': must be one of ${validValuesList}.`;
+        const context = {
+            receivedValue,
+            validValues,
+            validValuesList,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid biogenic content values: ${validValuesList}`,
+            'Use NONE for fossil fuels, grid electricity, refrigerants and industrial processes',
+            'Use FULL for biomass, organic waste and wastewater',
+            'Use PARTIAL for fuels blended with biofuels',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_BIOGENIC_CONTENT, technicalMessage, context, suggestions);
+        this.name = 'InvalidBiogenicContentError';
+    }
+    static create(receivedValue, validValues) {
+        return new InvalidBiogenicContentError(receivedValue, validValues);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.InvalidBiogenicContentError = InvalidBiogenicContentError;

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmissionFactorBiogenicContent = void 0;
+const String_1 = require("../../../../shared/domain/value-objects/String");
+const BiogenicContent_1 = require("../enums/BiogenicContent");
+const InvalidBiogenicContentError_1 = require("../exceptions/InvalidBiogenicContentError");
+class EmissionFactorBiogenicContent extends String_1.String {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, EmissionFactorBiogenicContent.PROPERTY_NAME);
+        if (skipDomainValidation === false) {
+            EmissionFactorBiogenicContent.validateBiogenicContent(value);
+        }
+    }
+    static create(value) {
+        String_1.String.guardAgainstEmptyValue(value, EmissionFactorBiogenicContent.PROPERTY_NAME);
+        String_1.String.guardAgainstInvalidType(value, EmissionFactorBiogenicContent.PROPERTY_NAME);
+        return new EmissionFactorBiogenicContent(value, false);
+    }
+    static fromPrimitives(primitive) {
+        return new EmissionFactorBiogenicContent(primitive, true);
+    }
+    /**
+     * Valida que el valor sea un contenido biogénico soportado.
+     */
+    static validateBiogenicContent(value) {
+        if (!EmissionFactorBiogenicContent.VALID_BIOGENIC_CONTENTS.includes(value)) {
+            throw InvalidBiogenicContentError_1.InvalidBiogenicContentError.create(value, EmissionFactorBiogenicContent.VALID_BIOGENIC_CONTENTS);
+        }
+    }
+    /**
+     * Obtiene los contenidos biogénicos válidos.
+     */
+    static getValidBiogenicContents() {
+        return Object.freeze([...EmissionFactorBiogenicContent.VALID_BIOGENIC_CONTENTS]);
+    }
+    /**
+     * Verifica si un valor es un contenido biogénico válido.
+     */
+    static isValidBiogenicContent(value) {
+        return EmissionFactorBiogenicContent.VALID_BIOGENIC_CONTENTS.includes(value);
+    }
+    isNone() {
+        return this.value === BiogenicContent_1.BiogenicContent.NONE;
+    }
+    isFull() {
+        return this.value === BiogenicContent_1.BiogenicContent.FULL;
+    }
+    isPartial() {
+        return this.value === BiogenicContent_1.BiogenicContent.PARTIAL;
+    }
+    toPrimitives() {
+        return this.value;
+    }
+    toEnum() {
+        return this.value;
+    }
+}
+exports.EmissionFactorBiogenicContent = EmissionFactorBiogenicContent;
+EmissionFactorBiogenicContent.PROPERTY_NAME = 'biogenicContent';
+EmissionFactorBiogenicContent.VALID_BIOGENIC_CONTENTS = Object.values(BiogenicContent_1.BiogenicContent);

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

@@ -50,6 +50,8 @@ class EmissionFactorGreenhouseGasValues extends ValueObject_1.ValueObject {
         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);
+        // CO2 / CH4 / N2O solo aceptan sus especies estándar (p.ej. nada de `CH4` a secas).
+        GreenhouseGasSpecies_1.GreenhouseGasSpecies.guardAgainstCategoryMismatch(value.greenhouseGasCategory, value.greenhouseGasSpecies, `${propertyName}.greenhouseGasSpecies`);
         EmissionFactorGreenhouseGasValues.guardAgainstInvalidCountryValues(value.countryValues, `${propertyName}.countryValues`);
         EmissionFactorGreenhouseGasValues.guardAgainstInvalidUnit(value.unit, `${propertyName}.unit`);
         EmissionFactorGreenhouseGasValues.guardAgainstInvalidDataSource(value.dataSource, `${propertyName}.dataSource`);

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

@@ -46,6 +46,8 @@ class GlobalWarmingPotentialGreenhouseGasPotentials extends ValueObject_1.ValueO
         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);
+        // CO2 / CH4 / N2O solo aceptan sus especies estándar (p.ej. nada de `CH4` a secas).
+        GreenhouseGasSpecies_1.GreenhouseGasSpecies.guardAgainstCategoryMismatch(value.greenhouseGasCategory, value.greenhouseGasSpecies, `${propertyName}.greenhouseGasSpecies`);
         GlobalWarmingPotentialGreenhouseGasPotentials.guardAgainstInvalidPotentialValue(value.potentialValue, `${propertyName}.potentialValue`);
     }
     static guardAgainstInvalidCategory(category, propertyName) {

package/build/carbonbox/reporting/shared/domain/exceptions/InvalidReportAssuranceError.js

@@ -12,8 +12,9 @@ class InvalidReportAssuranceError extends CodedRootError_1.CodedRootError {
         };
         const suggestions = [
             'level must be a value of AssuranceLevel (NONE, LIMITED, REASONABLE)',
-            'With level NONE, verificationType and verifierName must be null',
+            'With level NONE, verificationType, verifierName and verificationStatementId must be null',
             'With level LIMITED or REASONABLE, verificationType must be a value of VerificationType and verifierName a non-empty name',
+            'verificationStatementId only backs a THIRD_PARTY verification',
             'Review the assurance declaration of the report instance',
         ];
         super(ErrorCode_1.ErrorCode.INVALID_REPORT_ASSURANCE, technicalMessage, context, suggestions);

package/build/carbonbox/reporting/shared/domain/value-objects/ReportAssurance.js

@@ -5,10 +5,12 @@ const ValueObject_1 = require("../../../../shared/domain/value-objects/ValueObje
 const AssuranceLevel_1 = require("../enums/AssuranceLevel");
 const VerificationType_1 = require("../enums/VerificationType");
 const InvalidReportAssuranceError_1 = require("../exceptions/InvalidReportAssuranceError");
+const VerificationStatementId_1 = require("../../../../carbon-footprint-audits/verification-statements/domain/value-objects/VerificationStatementId");
 /**
  * Assurance declaration of a report instance (GAP 6, ISO 14064-1 §9.3.1 / ISO 14064-3).
  * Invariants: with level NONE nothing else is declared; with LIMITED or REASONABLE the
- * verification type and the verifier name are mandatory.
+ * verification type and the verifier name are mandatory; a verification statement of the platform
+ * (AUD-D11) only backs a THIRD_PARTY verification.
  */
 class ReportAssurance extends ValueObject_1.ValueObject {
     constructor(value, skipDomainValidation) {
@@ -24,7 +26,12 @@ class ReportAssurance extends ValueObject_1.ValueObject {
         return new ReportAssurance(primitives, true);
     }
     static notVerified() {
-        return new ReportAssurance({ level: AssuranceLevel_1.AssuranceLevel.NONE, verificationType: null, verifierName: null }, false);
+        return new ReportAssurance({
+            level: AssuranceLevel_1.AssuranceLevel.NONE,
+            verificationType: null,
+            verifierName: null,
+            verificationStatementId: null,
+        }, false);
     }
     validateReportAssurance(value) {
         if (!Object.values(AssuranceLevel_1.AssuranceLevel).includes(value.level)) {
@@ -37,6 +44,9 @@ class ReportAssurance extends ValueObject_1.ValueObject {
             if (value.verifierName !== null) {
                 throw InvalidReportAssuranceError_1.InvalidReportAssuranceError.create('verifierName must be null when the inventory is not verified (level NONE)');
             }
+            if (value.verificationStatementId !== null) {
+                throw InvalidReportAssuranceError_1.InvalidReportAssuranceError.create('verificationStatementId must be null when the inventory is not verified (level NONE)');
+            }
             return;
         }
         if (value.verificationType === null || !Object.values(VerificationType_1.VerificationType).includes(value.verificationType)) {
@@ -48,6 +58,12 @@ class ReportAssurance extends ValueObject_1.ValueObject {
         if (value.verifierName.trim().length > ReportAssurance.VERIFIER_NAME_MAX_LENGTH) {
             throw InvalidReportAssuranceError_1.InvalidReportAssuranceError.create(`verifierName cannot exceed ${ReportAssurance.VERIFIER_NAME_MAX_LENGTH} characters`);
         }
+        if (value.verificationStatementId !== null) {
+            if (value.verificationType !== VerificationType_1.VerificationType.THIRD_PARTY) {
+                throw InvalidReportAssuranceError_1.InvalidReportAssuranceError.create('verificationStatementId can only back a THIRD_PARTY verification');
+            }
+            VerificationStatementId_1.VerificationStatementId.create(value.verificationStatementId);
+        }
     }
     getLevel() {
         return this.value.level;
@@ -64,11 +80,21 @@ class ReportAssurance extends ValueObject_1.ValueObject {
     isIndependentlyVerified() {
         return this.value.verificationType === VerificationType_1.VerificationType.THIRD_PARTY;
     }
+    getVerificationStatementId() {
+        return this.value.verificationStatementId;
+    }
+    /**
+     * Whether the assurance is backed by a verification statement issued in the platform (AUD-D11).
+     */
+    isBackedByVerificationStatement() {
+        return this.value.verificationStatementId !== null;
+    }
     toPrimitives() {
         return {
             level: this.value.level,
             verificationType: this.value.verificationType,
             verifierName: this.value.verifierName === null ? null : this.value.verifierName.trim(),
+            verificationStatementId: this.value.verificationStatementId,
         };
     }
 }

package/build/carbonbox/shared/domain/authorization/enums/Permission.js

@@ -37,6 +37,10 @@ var Permission;
     Permission["STAKEHOLDERS_ACTIVATE_CARBON_CLIENT_ACCOUNT"] = "STAKEHOLDERS_ACTIVATE_CARBON_CLIENT_ACCOUNT";
     Permission["STAKEHOLDERS_DEACTIVATE_CARBON_CLIENT_ACCOUNT"] = "STAKEHOLDERS_DEACTIVATE_CARBON_CLIENT_ACCOUNT";
     Permission["STAKEHOLDERS_VIEW_CARBON_CLIENT_LIST"] = "STAKEHOLDERS_VIEW_CARBON_CLIENT_LIST";
+    Permission["STAKEHOLDERS_VIEW_CARBON_AUDITOR_PROFILE"] = "STAKEHOLDERS_VIEW_CARBON_AUDITOR_PROFILE";
+    Permission["STAKEHOLDERS_VIEW_CARBON_AUDITOR_LIST"] = "STAKEHOLDERS_VIEW_CARBON_AUDITOR_LIST";
+    Permission["STAKEHOLDERS_ACTIVATE_CARBON_AUDITOR_ACCOUNT"] = "STAKEHOLDERS_ACTIVATE_CARBON_AUDITOR_ACCOUNT";
+    Permission["STAKEHOLDERS_DEACTIVATE_CARBON_AUDITOR_ACCOUNT"] = "STAKEHOLDERS_DEACTIVATE_CARBON_AUDITOR_ACCOUNT";
     Permission["USER_PROFILE_VIEW_OWN_PROFILE"] = "USER_PROFILE_VIEW_OWN_PROFILE";
     Permission["USER_PROFILE_UPDATE_OWN_PROFILE"] = "USER_PROFILE_UPDATE_OWN_PROFILE";
     Permission["USER_PROFILE_CHANGE_OWN_PASSWORD"] = "USER_PROFILE_CHANGE_OWN_PASSWORD";
@@ -278,4 +282,24 @@ var Permission;
     Permission["REPORTING_MANAGE_REPORT_PREPARATION_QUESTIONNAIRE_CUSTOM_QUESTIONS"] = "REPORTING_MANAGE_REPORT_PREPARATION_QUESTIONNAIRE_CUSTOM_QUESTIONS";
     Permission["REPORTING_VIEW_REPORT_PREPARATION_QUESTIONNAIRE"] = "REPORTING_VIEW_REPORT_PREPARATION_QUESTIONNAIRE";
     Permission["REPORTING_VIEW_REPORT_PREPARATION_QUESTIONNAIRE_LIST"] = "REPORTING_VIEW_REPORT_PREPARATION_QUESTIONNAIRE_LIST";
+    // Carbon Footprint Audits (AUD-D07)
+    Permission["CARBON_FOOTPRINT_AUDITS_ASSIGN_AUDITOR"] = "CARBON_FOOTPRINT_AUDITS_ASSIGN_AUDITOR";
+    Permission["CARBON_FOOTPRINT_AUDITS_REPLACE_AUDITOR"] = "CARBON_FOOTPRINT_AUDITS_REPLACE_AUDITOR";
+    Permission["CARBON_FOOTPRINT_AUDITS_REVOKE_AUDIT_ENGAGEMENT"] = "CARBON_FOOTPRINT_AUDITS_REVOKE_AUDIT_ENGAGEMENT";
+    Permission["CARBON_FOOTPRINT_AUDITS_RESEND_AUDITOR_INVITATION"] = "CARBON_FOOTPRINT_AUDITS_RESEND_AUDITOR_INVITATION";
+    Permission["CARBON_FOOTPRINT_AUDITS_UPDATE_AUDITED_CARBON_FOOTPRINTS"] = "CARBON_FOOTPRINT_AUDITS_UPDATE_AUDITED_CARBON_FOOTPRINTS";
+    Permission["CARBON_FOOTPRINT_AUDITS_VIEW_AUDIT_ENGAGEMENT"] = "CARBON_FOOTPRINT_AUDITS_VIEW_AUDIT_ENGAGEMENT";
+    Permission["CARBON_FOOTPRINT_AUDITS_VIEW_AUDIT_ENGAGEMENT_LIST"] = "CARBON_FOOTPRINT_AUDITS_VIEW_AUDIT_ENGAGEMENT_LIST";
+    Permission["CARBON_FOOTPRINT_AUDITS_ACCEPT_AUDIT_ENGAGEMENT"] = "CARBON_FOOTPRINT_AUDITS_ACCEPT_AUDIT_ENGAGEMENT";
+    Permission["CARBON_FOOTPRINT_AUDITS_DECLINE_AUDIT_ENGAGEMENT"] = "CARBON_FOOTPRINT_AUDITS_DECLINE_AUDIT_ENGAGEMENT";
+    Permission["CARBON_FOOTPRINT_AUDITS_CREATE_AUDIT_FINDING"] = "CARBON_FOOTPRINT_AUDITS_CREATE_AUDIT_FINDING";
+    Permission["CARBON_FOOTPRINT_AUDITS_UPDATE_AUDIT_FINDING"] = "CARBON_FOOTPRINT_AUDITS_UPDATE_AUDIT_FINDING";
+    Permission["CARBON_FOOTPRINT_AUDITS_CLOSE_AUDIT_FINDING"] = "CARBON_FOOTPRINT_AUDITS_CLOSE_AUDIT_FINDING";
+    Permission["CARBON_FOOTPRINT_AUDITS_REOPEN_AUDIT_FINDING"] = "CARBON_FOOTPRINT_AUDITS_REOPEN_AUDIT_FINDING";
+    Permission["CARBON_FOOTPRINT_AUDITS_RESPOND_TO_AUDIT_FINDING"] = "CARBON_FOOTPRINT_AUDITS_RESPOND_TO_AUDIT_FINDING";
+    Permission["CARBON_FOOTPRINT_AUDITS_VIEW_AUDIT_FINDING"] = "CARBON_FOOTPRINT_AUDITS_VIEW_AUDIT_FINDING";
+    Permission["CARBON_FOOTPRINT_AUDITS_VIEW_AUDIT_FINDING_LIST"] = "CARBON_FOOTPRINT_AUDITS_VIEW_AUDIT_FINDING_LIST";
+    Permission["CARBON_FOOTPRINT_AUDITS_ISSUE_VERIFICATION_STATEMENT"] = "CARBON_FOOTPRINT_AUDITS_ISSUE_VERIFICATION_STATEMENT";
+    Permission["CARBON_FOOTPRINT_AUDITS_VIEW_VERIFICATION_STATEMENT"] = "CARBON_FOOTPRINT_AUDITS_VIEW_VERIFICATION_STATEMENT";
+    Permission["CARBON_FOOTPRINT_AUDITS_VIEW_VERIFICATION_STATEMENT_LIST"] = "CARBON_FOOTPRINT_AUDITS_VIEW_VERIFICATION_STATEMENT_LIST";
 })(Permission || (exports.Permission = Permission = {}));

package/build/carbonbox/shared/domain/enums/ErrorCode.js

@@ -15,6 +15,7 @@ exports.ErrorCode = void 0;
  * - EMC: Emission Calculations
  * - ECR: Emission Calculation Results
  * - RPT: Reporting
+ * - AUD: Carbon Footprint Audits
  * - SHR: Shared/Common
  *
  * Total Codes: 182
@@ -136,7 +137,7 @@ var ErrorCode;
     ErrorCode["INVALID_FORMULA"] = "CBX-EMC-003";
     ErrorCode["JOB_NOT_FOUND"] = "CBX-EMC-004";
     ErrorCode["JOB_ALREADY_RUNNING"] = "CBX-EMC-005";
-    // Emission Calculation Formulas Errors (CBX-EMC-006 to CBX-EMC-013)
+    // Emission Calculation Formulas Errors (CBX-EMC-006 to CBX-EMC-015)
     ErrorCode["INVALID_CALCULATION_VARIABLE_ACTIVITY_DATA_CONDITIONS_FOR_STRATEGY"] = "CBX-EMC-006";
     ErrorCode["INVALID_CALCULATION_VARIABLE_RESOLUTION_STRATEGY"] = "CBX-EMC-007";
     ErrorCode["DUPLICATE_GREENHOUSE_GAS"] = "CBX-EMC-008";
@@ -145,6 +146,8 @@ var ErrorCode;
     ErrorCode["UNAUTHORIZED_FORMULA_CREATION_ROLE"] = "CBX-EMC-011";
     ErrorCode["INVALID_IPCC_CODE"] = "CBX-EMC-012";
     ErrorCode["INVALID_METHODOLOGICAL_TIER"] = "CBX-EMC-013";
+    ErrorCode["INVALID_BIOGENIC_CONTENT"] = "CBX-EMC-014";
+    ErrorCode["INCONSISTENT_EMISSION_FACTOR_BIOGENIC_CONTENT"] = "CBX-EMC-015";
     // Emission Calculation Results Errors (CBX-ECR-XXX)
     ErrorCode["UNKNOWN_GREENHOUSE_GAS_CATEGORY"] = "CBX-ECR-001";
     // Reporting Errors (CBX-RPT-XXX)
@@ -177,6 +180,24 @@ var ErrorCode;
     ErrorCode["INVALID_REPORT_BLOCK_DATA_BINDING"] = "CBX-RPT-027";
     ErrorCode["INVALID_REPORT_ASSURANCE"] = "CBX-RPT-028";
     ErrorCode["REPORT_CONTENT_GENERATION_JOB_INVALID_STATUS_TRANSITION"] = "CBX-RPT-029";
+    // Carbon Footprint Audits Errors (CBX-AUD-XXX) — AUD-D08
+    // Audit engagements (CBX-AUD-001 to CBX-AUD-005)
+    ErrorCode["INVALID_AUDIT_ENGAGEMENT_STATUS"] = "CBX-AUD-001";
+    ErrorCode["AUDIT_ENGAGEMENT_INVALID_STATUS_TRANSITION"] = "CBX-AUD-002";
+    ErrorCode["AUDIT_ENGAGEMENT_NOT_ACTIVE"] = "CBX-AUD-003";
+    ErrorCode["AUDIT_ENGAGEMENT_NOT_ASSIGNED_TO_CARBON_AUDITOR"] = "CBX-AUD-004";
+    ErrorCode["INVALID_AUDITED_CARBON_FOOTPRINT_CONFIGURATIONS"] = "CBX-AUD-005";
+    // Audit findings (CBX-AUD-006 to CBX-AUD-010)
+    ErrorCode["INVALID_AUDIT_FINDING_TYPE"] = "CBX-AUD-006";
+    ErrorCode["INVALID_AUDIT_FINDING_STATUS"] = "CBX-AUD-007";
+    ErrorCode["INVALID_AUDIT_FINDING_SUBJECT"] = "CBX-AUD-008";
+    ErrorCode["AUDIT_FINDING_INVALID_STATUS_TRANSITION"] = "CBX-AUD-009";
+    ErrorCode["INVALID_AUDIT_FINDING_RESPONDER"] = "CBX-AUD-010";
+    // Verification statements (CBX-AUD-011 to CBX-AUD-014)
+    ErrorCode["INVALID_VERIFICATION_OPINION"] = "CBX-AUD-011";
+    ErrorCode["INVALID_VERIFICATION_STANDARD"] = "CBX-AUD-012";
+    ErrorCode["INVALID_VERIFICATION_ASSURANCE_LEVEL"] = "CBX-AUD-013";
+    ErrorCode["VERIFICATION_STATEMENT_BLOCKED_BY_UNRESOLVED_FINDINGS"] = "CBX-AUD-014";
     // Shared/Common Errors (CBX-SHR-XXX)
     ErrorCode["INVALID_EMAIL"] = "CBX-SHR-001";
     ErrorCode["INVALID_DATE_FORMAT"] = "CBX-SHR-002";
@@ -262,4 +283,6 @@ var ErrorCode;
     ErrorCode["INVALID_FULL_INTERNATIONAL_NUMBER"] = "CBX-SHR-075";
     // Tenant Isolation Errors (CBX-SHR-076) — AIS-D02/AIS-D03
     ErrorCode["INVALID_CROSS_TENANT_REFERENCE"] = "CBX-SHR-076";
+    // Verification body accreditation (CBX-SHR-077) — AUD-D02/AUD-D06
+    ErrorCode["INVALID_ACCREDITATION"] = "CBX-SHR-077";
 })(ErrorCode || (exports.ErrorCode = ErrorCode = {}));

package/build/carbonbox/shared/domain/enums/SemanticUuidPrefix.js

@@ -68,6 +68,7 @@ var SemanticUuidPrefix;
     SemanticUuidPrefix["USR_STH_COORDINATOR"] = "USR-STH-CRD";
     SemanticUuidPrefix["USR_STH_HOST"] = "USR-STH-CHO";
     SemanticUuidPrefix["USR_STH_MANAGER"] = "USR-STH-MGR";
+    SemanticUuidPrefix["USR_STH_AUDITOR"] = "USR-STH-AUD";
     // Users - Invitations (AIS-D04)
     SemanticUuidPrefix["USR_INVITATION"] = "USR-INV";
     // Purchase Management System
@@ -88,6 +89,10 @@ var SemanticUuidPrefix;
     SemanticUuidPrefix["RPT_PREPARATION_QUESTIONNAIRE"] = "RPT-PRE";
     SemanticUuidPrefix["RPT_PREPARATION_QUESTION"] = "RPT-PRE-QST";
     SemanticUuidPrefix["RPT_CONTENT_GENERATION_JOB"] = "RPT-CGJ";
+    // Carbon Footprint Audits (AUD-D05, AUD-D06)
+    SemanticUuidPrefix["CFA_AUDIT_ENGAGEMENT"] = "CFA-ENG";
+    SemanticUuidPrefix["CFA_AUDIT_FINDING"] = "CFA-FND";
+    SemanticUuidPrefix["CFA_VERIFICATION_STATEMENT"] = "CFA-VST";
     // Future expansion examples (when system grows):
     // ADC_SUB_FIELDS = 'ADC-SUB-FLD', // Activity Data Collection -> Submissions -> Fields
     // USR_STH_CHO_MGT = 'USR-STH-CHO-MGT', // Users -> Stakeholders -> Carbon Host -> Management

package/build/carbonbox/shared/domain/enums/StakeholderRole.js

@@ -7,4 +7,6 @@ var StakeholderRole;
     StakeholderRole["CARBON_MANAGER"] = "CARBON_MANAGER";
     StakeholderRole["CARBON_COORDINATOR"] = "CARBON_COORDINATOR";
     StakeholderRole["CARBON_CLIENT"] = "CARBON_CLIENT";
+    // AUD-D01: external verifier of 1..N carbon clients; outside the supervision chain
+    StakeholderRole["CARBON_AUDITOR"] = "CARBON_AUDITOR";
 })(StakeholderRole || (exports.StakeholderRole = StakeholderRole = {}));

package/build/carbonbox/shared/domain/enums/StandardGreenhouseGasSpecies.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StandardGreenhouseGasSpecies = void 0;
+/**
+ * Standard greenhouse gas species: the codes the system knows and gives meaning to.
+ * Any other species (refrigerants, blends, SF6, NF3...) is still accepted as free text
+ * by `GreenhouseGasSpecies`, but only under a category that has no standard species
+ * (HFC, PFC, SF6, NF3, HCFC, OTHER).
+ *
+ * Biogenic accounting (GHG Protocol Corporate Standard cap. 9; ISO 14064-1:2018 §9.3.1):
+ * only `CO2-BIOGENIC` stays outside the inventory total; `CH4-NON-FOSSIL` counts with its
+ * own potential (IPCC AR6: 27.0 vs 29.8 for fossil methane).
+ */
+var StandardGreenhouseGasSpecies;
+(function (StandardGreenhouseGasSpecies) {
+    /**
+     * Fossil carbon dioxide
+     */
+    StandardGreenhouseGasSpecies["CO2"] = "CO2";
+    /**
+     * Carbon dioxide from biomass / biofuel combustion: informational item outside the total
+     */
+    StandardGreenhouseGasSpecies["CO2_BIOGENIC"] = "CO2-BIOGENIC";
+    /**
+     * Methane of fossil origin
+     */
+    StandardGreenhouseGasSpecies["CH4_FOSSIL"] = "CH4-FOSSIL";
+    /**
+     * Methane of non-fossil origin (biomass, waste, wastewater): counts towards the total
+     */
+    StandardGreenhouseGasSpecies["CH4_NON_FOSSIL"] = "CH4-NON-FOSSIL";
+    /**
+     * Nitrous oxide
+     */
+    StandardGreenhouseGasSpecies["N2O"] = "N2O";
+})(StandardGreenhouseGasSpecies || (exports.StandardGreenhouseGasSpecies = StandardGreenhouseGasSpecies = {}));

package/build/carbonbox/shared/domain/exceptions/InvalidAccreditationError.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidAccreditationError = void 0;
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+/**
+ * The accreditation of a verification body is incomplete or too long (AUD-D02, AUD-D06).
+ */
+class InvalidAccreditationError extends CodedRootError_1.CodedRootError {
+    constructor(propertyName, reason) {
+        const technicalMessage = `Invalid accreditation '${propertyName}': ${reason}`;
+        const context = {
+            propertyName,
+            reason,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Send both the accreditation body and the accreditation number, or null when the verifier is not accredited',
+            'The accreditation body and number cannot be empty nor exceed 255 characters',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_ACCREDITATION, technicalMessage, context, suggestions);
+        this.name = 'InvalidAccreditationError';
+    }
+    static create(propertyName, reason) {
+        return new InvalidAccreditationError(propertyName, reason);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.InvalidAccreditationError = InvalidAccreditationError;