@carbonbox/domain 0.52.0 → 0.54.0

package/build/carbonbox/carbon-footprint-audits/verification-statements/domain/exceptions/InvalidVerificationOpinionError.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidVerificationOpinionError = void 0;
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+/**
+ * The opinion of a verification statement is not a value of VerificationOpinion (AUD-D06).
+ */
+class InvalidVerificationOpinionError extends CodedRootError_1.CodedRootError {
+    constructor(invalidValue, validValues, propertyName) {
+        const technicalMessage = `Verification statement ${propertyName} constraint violation: '${invalidValue}' is not a valid verification opinion.`;
+        const context = {
+            propertyName,
+            receivedValue: invalidValue,
+            validValues,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid verification opinions: ${validValues.join(', ')}`,
+            'UNMODIFIED and QUALIFIED state the inventory is fairly stated (with qualifications for QUALIFIED); ADVERSE and DISCLAIMER do not',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_VERIFICATION_OPINION, technicalMessage, context, suggestions);
+        this.name = 'InvalidVerificationOpinionError';
+    }
+    static create(invalidValue, validValues, propertyName = 'opinion') {
+        return new InvalidVerificationOpinionError(invalidValue, validValues, propertyName);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.InvalidVerificationOpinionError = InvalidVerificationOpinionError;

package/build/carbonbox/carbon-footprint-audits/verification-statements/domain/exceptions/InvalidVerificationStandardError.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidVerificationStandardError = void 0;
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+/**
+ * The verification standard of a verification statement is not a value of VerificationStandard (AUD-D06).
+ */
+class InvalidVerificationStandardError extends CodedRootError_1.CodedRootError {
+    constructor(invalidValue, validValues, propertyName) {
+        const technicalMessage = `Verification statement ${propertyName} constraint violation: '${invalidValue}' is not a valid verification standard.`;
+        const context = {
+            propertyName,
+            receivedValue: invalidValue,
+            validValues,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid verification standards: ${validValues.join(', ')}`,
+            'Use OTHER and name the standard in the conclusion when it is not listed',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_VERIFICATION_STANDARD, technicalMessage, context, suggestions);
+        this.name = 'InvalidVerificationStandardError';
+    }
+    static create(invalidValue, validValues, propertyName = 'verificationStandard') {
+        return new InvalidVerificationStandardError(invalidValue, validValues, propertyName);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.InvalidVerificationStandardError = InvalidVerificationStandardError;

package/build/carbonbox/carbon-footprint-audits/verification-statements/domain/exceptions/VerificationStatementBlockedByUnresolvedFindingsError.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerificationStatementBlockedByUnresolvedFindingsError = void 0;
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+/**
+ * The verification statement cannot be issued while clarification or corrective action requests
+ * of the verified footprint are not closed (D12, scenario E19). The context lists the blocking
+ * findings so the auditor can open each one.
+ */
+class VerificationStatementBlockedByUnresolvedFindingsError extends CodedRootError_1.CodedRootError {
+    constructor(blockingAuditFindingIds) {
+        const technicalMessage = `The verification statement cannot be issued: ${blockingAuditFindingIds.length} clarification or corrective action request(s) are not closed.`;
+        const context = {
+            blockingAuditFindingIds: Array.from(blockingAuditFindingIds),
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Close every clarification and corrective action request of the footprint before issuing the statement',
+            'Forward action requests do not block the statement',
+        ];
+        super(ErrorCode_1.ErrorCode.VERIFICATION_STATEMENT_BLOCKED_BY_UNRESOLVED_FINDINGS, technicalMessage, context, suggestions);
+        this.name = 'VerificationStatementBlockedByUnresolvedFindingsError';
+    }
+    static create(blockingAuditFindingIds) {
+        return new VerificationStatementBlockedByUnresolvedFindingsError(blockingAuditFindingIds);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.VerificationStatementBlockedByUnresolvedFindingsError = VerificationStatementBlockedByUnresolvedFindingsError;

package/build/carbonbox/carbon-footprint-audits/verification-statements/domain/policies/VerificationStatementIssuancePolicy.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerificationStatementIssuancePolicy = void 0;
+const VerificationStatementBlockedByUnresolvedFindingsError_1 = require("../exceptions/VerificationStatementBlockedByUnresolvedFindingsError");
+/**
+ * Pure domain policy: whether a verification statement can be issued given the findings of the
+ * verified carbon footprint (D12). Clarification (CL) and corrective action (CAR) requests must be
+ * closed; forward action requests (FAR) never block.
+ *
+ * The caller passes every finding of the verified footprint, including those raised by previous
+ * auditors (the findings belong to the carbon client, D6).
+ */
+class VerificationStatementIssuancePolicy {
+    constructor() {
+        // Static-only — not instantiable.
+    }
+    /** The ids of the findings that keep the statement from being issued. */
+    static findBlockingAuditFindingIds(auditFindings) {
+        return auditFindings
+            .filter((auditFinding) => auditFinding.blocksVerificationStatement())
+            .map((auditFinding) => auditFinding.id.toPrimitives());
+    }
+    static canBeIssued(auditFindings) {
+        return VerificationStatementIssuancePolicy.findBlockingAuditFindingIds(auditFindings).length === 0;
+    }
+    /** Throws `VerificationStatementBlockedByUnresolvedFindingsError` listing the blocking findings. */
+    static assertCanBeIssued(auditFindings) {
+        const blockingAuditFindingIds = VerificationStatementIssuancePolicy.findBlockingAuditFindingIds(auditFindings);
+        if (blockingAuditFindingIds.length > 0) {
+            throw VerificationStatementBlockedByUnresolvedFindingsError_1.VerificationStatementBlockedByUnresolvedFindingsError.create(blockingAuditFindingIds);
+        }
+    }
+}
+exports.VerificationStatementIssuancePolicy = VerificationStatementIssuancePolicy;

package/build/carbonbox/carbon-footprint-audits/verification-statements/domain/repository/IVerificationStatementRepository.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/carbonbox/carbon-footprint-audits/verification-statements/domain/types/VerificationStatementIssueProps.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/carbonbox/carbon-footprint-audits/verification-statements/domain/types/VerificationStatementPrimitives.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/carbonbox/carbon-footprint-audits/verification-statements/domain/types/VerificationStatementProps.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerificationStatementAccreditation = void 0;
+const NullableAccreditation_1 = require("../../../../shared/domain/value-objects/NullableAccreditation");
+/**
+ * Accreditation the auditor held when issuing the statement, or null when not accredited. Copied
+ * from the auditor profile when issuing: later profile changes never alter an issued statement.
+ */
+class VerificationStatementAccreditation extends NullableAccreditation_1.NullableAccreditation {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, VerificationStatementAccreditation.PROPERTY_NAME);
+    }
+    static create(value) {
+        return new VerificationStatementAccreditation(value, false);
+    }
+    static fromPrimitives(primitives) {
+        const value = primitives === null
+            ? null
+            : { accreditationBody: primitives.accreditationBody, accreditationNumber: primitives.accreditationNumber };
+        return new VerificationStatementAccreditation(value, true);
+    }
+}
+exports.VerificationStatementAccreditation = VerificationStatementAccreditation;
+VerificationStatementAccreditation.PROPERTY_NAME = 'accreditation';

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

@@ -0,0 +1,57 @@
+"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 _VerificationStatementAssuranceLevel_instances, _a, _VerificationStatementAssuranceLevel_guardAgainstInvalidAssuranceLevel;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerificationStatementAssuranceLevel = void 0;
+const String_1 = require("../../../../shared/domain/value-objects/String");
+const AssuranceLevel_1 = require("../../../../reporting/shared/domain/enums/AssuranceLevel");
+const InvalidVerificationAssuranceLevelError_1 = require("../exceptions/InvalidVerificationAssuranceLevelError");
+/**
+ * Level of assurance the verification statement provides. Reuses the reporting AssuranceLevel,
+ * without NONE: a statement always provides limited or reasonable assurance.
+ */
+class VerificationStatementAssuranceLevel extends String_1.String {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, _a.PROPERTY_NAME);
+        _VerificationStatementAssuranceLevel_instances.add(this);
+        if (skipDomainValidation === false) {
+            __classPrivateFieldGet(this, _VerificationStatementAssuranceLevel_instances, "m", _VerificationStatementAssuranceLevel_guardAgainstInvalidAssuranceLevel).call(this, value);
+        }
+    }
+    static create(value) {
+        String_1.String.guardAgainstEmptyValue(value, _a.PROPERTY_NAME);
+        String_1.String.guardAgainstInvalidType(value, _a.PROPERTY_NAME);
+        return new _a(value, false);
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new _a(value, true);
+    }
+    isReasonable() {
+        return this.value === AssuranceLevel_1.AssuranceLevel.REASONABLE;
+    }
+    isLimited() {
+        return this.value === AssuranceLevel_1.AssuranceLevel.LIMITED;
+    }
+    toEnum() {
+        return this.value;
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.VerificationStatementAssuranceLevel = VerificationStatementAssuranceLevel;
+_a = VerificationStatementAssuranceLevel, _VerificationStatementAssuranceLevel_instances = new WeakSet(), _VerificationStatementAssuranceLevel_guardAgainstInvalidAssuranceLevel = function _VerificationStatementAssuranceLevel_guardAgainstInvalidAssuranceLevel(value) {
+    if (_a.VALID_ASSURANCE_LEVELS.includes(value) === false) {
+        throw InvalidVerificationAssuranceLevelError_1.InvalidVerificationAssuranceLevelError.create(value, _a.VALID_ASSURANCE_LEVELS, _a.PROPERTY_NAME);
+    }
+};
+VerificationStatementAssuranceLevel.PROPERTY_NAME = 'assuranceLevel';
+VerificationStatementAssuranceLevel.VALID_ASSURANCE_LEVELS = [
+    AssuranceLevel_1.AssuranceLevel.LIMITED,
+    AssuranceLevel_1.AssuranceLevel.REASONABLE,
+];

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerificationStatementAuditEngagementId = void 0;
+const AggregateId_1 = require("../../../../shared/domain/value-objects/AggregateId");
+const SemanticUuidPrefix_1 = require("../../../../shared/domain/enums/SemanticUuidPrefix");
+const InvalidAggregatePrefixError_1 = require("../../../../shared/domain/exceptions/InvalidAggregatePrefixError");
+/**
+ * Id of the audit engagement under which the verification statement was issued (`CFA-ENG_<id>`).
+ */
+class VerificationStatementAuditEngagementId extends AggregateId_1.AggregateId {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, VerificationStatementAuditEngagementId.PROPERTY_NAME);
+    }
+    static create(value) {
+        AggregateId_1.AggregateId.guardAgainstEmptyValue(value, VerificationStatementAuditEngagementId.PROPERTY_NAME);
+        AggregateId_1.AggregateId.guardAgainstInvalidType(value, VerificationStatementAuditEngagementId.PROPERTY_NAME);
+        AggregateId_1.AggregateId.guardAgainstInvalidId(value, VerificationStatementAuditEngagementId.PROPERTY_NAME);
+        // Validate that the prefix is valid for AuditEngagement
+        VerificationStatementAuditEngagementId.guardAgainstInvalidPrefix(value);
+        return new VerificationStatementAuditEngagementId(value, false);
+    }
+    /**
+     * Validates that the id has the AuditEngagement prefix.
+     * The id format was already validated, so the prefix can be extracted safely.
+     */
+    static guardAgainstInvalidPrefix(value) {
+        const prefix = new VerificationStatementAuditEngagementId(value, true).extractPrefix();
+        if (VerificationStatementAuditEngagementId.VALID_PREFIXES.includes(prefix) === false) {
+            throw InvalidAggregatePrefixError_1.InvalidAggregatePrefixError.create(value, 'AuditEngagement', prefix, VerificationStatementAuditEngagementId.VALID_PREFIXES, VerificationStatementAuditEngagementId.PROPERTY_NAME);
+        }
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new VerificationStatementAuditEngagementId(value, true);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.VerificationStatementAuditEngagementId = VerificationStatementAuditEngagementId;
+VerificationStatementAuditEngagementId.PROPERTY_NAME = 'auditEngagementId';
+VerificationStatementAuditEngagementId.VALID_PREFIXES = [
+    SemanticUuidPrefix_1.SemanticUuidPrefix.CFA_AUDIT_ENGAGEMENT,
+];

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerificationStatementConclusion = void 0;
+const String_1 = require("../../../../shared/domain/value-objects/String");
+const InvalidPropertyValueError_1 = require("../../../../shared/domain/exceptions/InvalidPropertyValueError");
+/**
+ * Written conclusion of the verification statement (scope, criteria, procedures, opinion and
+ * qualifications). Required, up to 10000 characters.
+ */
+class VerificationStatementConclusion extends String_1.String {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, VerificationStatementConclusion.PROPERTY_NAME);
+    }
+    static create(value) {
+        String_1.String.guardAgainstEmptyValue(value, VerificationStatementConclusion.PROPERTY_NAME);
+        String_1.String.guardAgainstInvalidType(value, VerificationStatementConclusion.PROPERTY_NAME);
+        VerificationStatementConclusion.guardAgainstExcessiveLength(value);
+        return new VerificationStatementConclusion(value.trim(), false);
+    }
+    static guardAgainstExcessiveLength(value) {
+        if (value.trim().length > VerificationStatementConclusion.MAX_LENGTH) {
+            throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(VerificationStatementConclusion.PROPERTY_NAME, `at most ${VerificationStatementConclusion.MAX_LENGTH} characters`, `${value.trim().length} characters`);
+        }
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new VerificationStatementConclusion(value, true);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.VerificationStatementConclusion = VerificationStatementConclusion;
+VerificationStatementConclusion.PROPERTY_NAME = 'conclusion';
+VerificationStatementConclusion.MAX_LENGTH = 10000;

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerificationStatementId = void 0;
+const AggregateId_1 = require("../../../../shared/domain/value-objects/AggregateId");
+const SemanticUuidPrefix_1 = require("../../../../shared/domain/enums/SemanticUuidPrefix");
+const InvalidAggregatePrefixError_1 = require("../../../../shared/domain/exceptions/InvalidAggregatePrefixError");
+/**
+ * Identity of a VerificationStatement aggregate (`CFA-VST_<id>`).
+ */
+class VerificationStatementId extends AggregateId_1.AggregateId {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, VerificationStatementId.PROPERTY_NAME);
+    }
+    static create(value) {
+        AggregateId_1.AggregateId.guardAgainstEmptyValue(value, VerificationStatementId.PROPERTY_NAME);
+        AggregateId_1.AggregateId.guardAgainstInvalidType(value, VerificationStatementId.PROPERTY_NAME);
+        AggregateId_1.AggregateId.guardAgainstInvalidId(value, VerificationStatementId.PROPERTY_NAME);
+        // Validate that the prefix is valid for VerificationStatement
+        VerificationStatementId.guardAgainstInvalidPrefix(value);
+        return new VerificationStatementId(value, false);
+    }
+    /**
+     * Validates that the id has the VerificationStatement prefix.
+     * The id format was already validated, so the prefix can be extracted safely.
+     */
+    static guardAgainstInvalidPrefix(value) {
+        const prefix = new VerificationStatementId(value, true).extractPrefix();
+        if (VerificationStatementId.VALID_PREFIXES.includes(prefix) === false) {
+            throw InvalidAggregatePrefixError_1.InvalidAggregatePrefixError.create(value, 'VerificationStatement', prefix, VerificationStatementId.VALID_PREFIXES, VerificationStatementId.PROPERTY_NAME);
+        }
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new VerificationStatementId(value, true);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.VerificationStatementId = VerificationStatementId;
+VerificationStatementId.PROPERTY_NAME = 'id';
+VerificationStatementId.VALID_PREFIXES = [
+    SemanticUuidPrefix_1.SemanticUuidPrefix.CFA_VERIFICATION_STATEMENT,
+];

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerificationStatementIssuedAt = void 0;
+const DateTimeString_1 = require("../../../../shared/domain/value-objects/DateTimeString");
+/**
+ * Moment the verification statement was issued (`DD/MM/YYYY HH:mm:ss`). The domain does not read
+ * the clock: the caller passes the current moment.
+ */
+class VerificationStatementIssuedAt extends DateTimeString_1.DateTimeString {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, VerificationStatementIssuedAt.PROPERTY_NAME);
+    }
+    static create(value) {
+        DateTimeString_1.DateTimeString.guardAgainstEmptyValue(value, VerificationStatementIssuedAt.PROPERTY_NAME);
+        DateTimeString_1.DateTimeString.guardAgainstInvalidType(value, VerificationStatementIssuedAt.PROPERTY_NAME);
+        DateTimeString_1.DateTimeString.guardAgainstInvalidDateTimeFormat(value);
+        return new VerificationStatementIssuedAt(value, false);
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new VerificationStatementIssuedAt(value, true);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.VerificationStatementIssuedAt = VerificationStatementIssuedAt;
+VerificationStatementIssuedAt.PROPERTY_NAME = 'issuedAt';

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerificationStatementIssuedByCarbonAuditorId = void 0;
+const UserId_1 = require("../../../../shared/domain/value-objects/UserId");
+const SemanticUuidPrefix_1 = require("../../../../shared/domain/enums/SemanticUuidPrefix");
+const InvalidUserPrefixError_1 = require("../../../../shared/domain/exceptions/InvalidUserPrefixError");
+/**
+ * Id of the carbon auditor who issued the verification statement (`USR-STH-AUD_<id>`).
+ */
+class VerificationStatementIssuedByCarbonAuditorId extends UserId_1.UserId {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation);
+    }
+    static create(value) {
+        UserId_1.UserId.guardAgainstEmptyValue(value, VerificationStatementIssuedByCarbonAuditorId.ISSUED_BY_PROPERTY_NAME);
+        UserId_1.UserId.guardAgainstInvalidType(value, VerificationStatementIssuedByCarbonAuditorId.ISSUED_BY_PROPERTY_NAME);
+        UserId_1.UserId.guardAgainstInvalidId(value, VerificationStatementIssuedByCarbonAuditorId.ISSUED_BY_PROPERTY_NAME);
+        // Validate that the prefix belongs to a carbon auditor
+        VerificationStatementIssuedByCarbonAuditorId.guardAgainstInvalidCarbonAuditorPrefix(value);
+        return new VerificationStatementIssuedByCarbonAuditorId(value, false);
+    }
+    /**
+     * Validates that the id has the carbon auditor prefix.
+     * The id format was already validated, so the prefix can be extracted safely.
+     */
+    static guardAgainstInvalidCarbonAuditorPrefix(value) {
+        const prefix = new VerificationStatementIssuedByCarbonAuditorId(value, true).extractPrefix();
+        if (VerificationStatementIssuedByCarbonAuditorId.VALID_PREFIXES.includes(prefix) === false) {
+            throw InvalidUserPrefixError_1.InvalidUserPrefixError.create(value, prefix, VerificationStatementIssuedByCarbonAuditorId.VALID_PREFIXES);
+        }
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new VerificationStatementIssuedByCarbonAuditorId(value, true);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.VerificationStatementIssuedByCarbonAuditorId = VerificationStatementIssuedByCarbonAuditorId;
+VerificationStatementIssuedByCarbonAuditorId.ISSUED_BY_PROPERTY_NAME = 'issuedByCarbonAuditorId';
+VerificationStatementIssuedByCarbonAuditorId.VALID_PREFIXES = [
+    SemanticUuidPrefix_1.SemanticUuidPrefix.USR_STH_AUDITOR,
+];

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerificationStatementMaterialityThresholdPercentage = void 0;
+const Numeric_1 = require("../../../../shared/domain/value-objects/Numeric");
+/**
+ * Materiality threshold the auditor applied, as a percentage of the verified total (usually 5 %
+ * for reasonable assurance and 5–10 % for limited). Greater than 0 and up to 100.
+ */
+class VerificationStatementMaterialityThresholdPercentage extends Numeric_1.Numeric {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, VerificationStatementMaterialityThresholdPercentage.PROPERTY_NAME, {
+            allowDecimals: true,
+            allowNegative: false,
+            minValue: 0,
+            maxValue: 100,
+            allowZero: false,
+            maxDecimalPlaces: Number.POSITIVE_INFINITY, // No limit on decimal places
+        });
+    }
+    static create(value) {
+        return new VerificationStatementMaterialityThresholdPercentage(value, false);
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new VerificationStatementMaterialityThresholdPercentage(value, true);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.VerificationStatementMaterialityThresholdPercentage = VerificationStatementMaterialityThresholdPercentage;
+VerificationStatementMaterialityThresholdPercentage.PROPERTY_NAME = 'materialityThresholdPercentage';

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

@@ -0,0 +1,50 @@
+"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 _VerificationStatementOpinion_instances, _a, _VerificationStatementOpinion_guardAgainstInvalidOpinion;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerificationStatementOpinion = void 0;
+const String_1 = require("../../../../shared/domain/value-objects/String");
+const VerificationOpinion_1 = require("../enums/VerificationOpinion");
+const InvalidVerificationOpinionError_1 = require("../exceptions/InvalidVerificationOpinionError");
+/**
+ * Opinion the auditor expresses on the verified GHG statement.
+ */
+class VerificationStatementOpinion extends String_1.String {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, _a.PROPERTY_NAME);
+        _VerificationStatementOpinion_instances.add(this);
+        if (skipDomainValidation === false) {
+            __classPrivateFieldGet(this, _VerificationStatementOpinion_instances, "m", _VerificationStatementOpinion_guardAgainstInvalidOpinion).call(this, value);
+        }
+    }
+    static create(value) {
+        String_1.String.guardAgainstEmptyValue(value, _a.PROPERTY_NAME);
+        String_1.String.guardAgainstInvalidType(value, _a.PROPERTY_NAME);
+        return new _a(value, false);
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new _a(value, true);
+    }
+    isUnmodified() {
+        return this.value === VerificationOpinion_1.VerificationOpinion.UNMODIFIED;
+    }
+    toEnum() {
+        return this.value;
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.VerificationStatementOpinion = VerificationStatementOpinion;
+_a = VerificationStatementOpinion, _VerificationStatementOpinion_instances = new WeakSet(), _VerificationStatementOpinion_guardAgainstInvalidOpinion = function _VerificationStatementOpinion_guardAgainstInvalidOpinion(value) {
+    if (_a.VALID_OPINIONS.includes(value) === false) {
+        throw InvalidVerificationOpinionError_1.InvalidVerificationOpinionError.create(value, _a.VALID_OPINIONS, _a.PROPERTY_NAME);
+    }
+};
+VerificationStatementOpinion.PROPERTY_NAME = 'opinion';
+VerificationStatementOpinion.VALID_OPINIONS = Object.values(VerificationOpinion_1.VerificationOpinion);

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

@@ -0,0 +1,47 @@
+"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 _VerificationStatementVerificationStandard_instances, _a, _VerificationStatementVerificationStandard_guardAgainstInvalidStandard;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerificationStatementVerificationStandard = void 0;
+const String_1 = require("../../../../shared/domain/value-objects/String");
+const VerificationStandard_1 = require("../enums/VerificationStandard");
+const InvalidVerificationStandardError_1 = require("../exceptions/InvalidVerificationStandardError");
+/**
+ * Standard the verification was performed against.
+ */
+class VerificationStatementVerificationStandard extends String_1.String {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, _a.PROPERTY_NAME);
+        _VerificationStatementVerificationStandard_instances.add(this);
+        if (skipDomainValidation === false) {
+            __classPrivateFieldGet(this, _VerificationStatementVerificationStandard_instances, "m", _VerificationStatementVerificationStandard_guardAgainstInvalidStandard).call(this, value);
+        }
+    }
+    static create(value) {
+        String_1.String.guardAgainstEmptyValue(value, _a.PROPERTY_NAME);
+        String_1.String.guardAgainstInvalidType(value, _a.PROPERTY_NAME);
+        return new _a(value, false);
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new _a(value, true);
+    }
+    toEnum() {
+        return this.value;
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.VerificationStatementVerificationStandard = VerificationStatementVerificationStandard;
+_a = VerificationStatementVerificationStandard, _VerificationStatementVerificationStandard_instances = new WeakSet(), _VerificationStatementVerificationStandard_guardAgainstInvalidStandard = function _VerificationStatementVerificationStandard_guardAgainstInvalidStandard(value) {
+    if (_a.VALID_STANDARDS.includes(value) === false) {
+        throw InvalidVerificationStandardError_1.InvalidVerificationStandardError.create(value, _a.VALID_STANDARDS, _a.PROPERTY_NAME);
+    }
+};
+VerificationStatementVerificationStandard.PROPERTY_NAME = 'verificationStandard';
+VerificationStatementVerificationStandard.VALID_STANDARDS = Object.values(VerificationStandard_1.VerificationStandard);

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerificationStatementVerifiedCalculationProcessId = void 0;
+const AggregateId_1 = require("../../../../shared/domain/value-objects/AggregateId");
+const SemanticUuidPrefix_1 = require("../../../../shared/domain/enums/SemanticUuidPrefix");
+const InvalidAggregatePrefixError_1 = require("../../../../shared/domain/exceptions/InvalidAggregatePrefixError");
+/**
+ * Id of the calculation process the statement verified (`ECP-PRC_<id>`): the verified snapshot
+ * (decision D12). Later changes of the carbon client produce other processes and never alter it.
+ */
+class VerificationStatementVerifiedCalculationProcessId extends AggregateId_1.AggregateId {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, VerificationStatementVerifiedCalculationProcessId.PROPERTY_NAME);
+    }
+    static create(value) {
+        AggregateId_1.AggregateId.guardAgainstEmptyValue(value, VerificationStatementVerifiedCalculationProcessId.PROPERTY_NAME);
+        AggregateId_1.AggregateId.guardAgainstInvalidType(value, VerificationStatementVerifiedCalculationProcessId.PROPERTY_NAME);
+        AggregateId_1.AggregateId.guardAgainstInvalidId(value, VerificationStatementVerifiedCalculationProcessId.PROPERTY_NAME);
+        // Validate that the prefix is valid for CalculationProcess
+        VerificationStatementVerifiedCalculationProcessId.guardAgainstInvalidPrefix(value);
+        return new VerificationStatementVerifiedCalculationProcessId(value, false);
+    }
+    /**
+     * Validates that the id has the CalculationProcess prefix.
+     * The id format was already validated, so the prefix can be extracted safely.
+     */
+    static guardAgainstInvalidPrefix(value) {
+        const prefix = new VerificationStatementVerifiedCalculationProcessId(value, true).extractPrefix();
+        if (VerificationStatementVerifiedCalculationProcessId.VALID_PREFIXES.includes(prefix) === false) {
+            throw InvalidAggregatePrefixError_1.InvalidAggregatePrefixError.create(value, 'CalculationProcess', prefix, VerificationStatementVerifiedCalculationProcessId.VALID_PREFIXES, VerificationStatementVerifiedCalculationProcessId.PROPERTY_NAME);
+        }
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new VerificationStatementVerifiedCalculationProcessId(value, true);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.VerificationStatementVerifiedCalculationProcessId = VerificationStatementVerifiedCalculationProcessId;
+VerificationStatementVerifiedCalculationProcessId.PROPERTY_NAME = 'verifiedCalculationProcessId';
+VerificationStatementVerifiedCalculationProcessId.VALID_PREFIXES = [
+    SemanticUuidPrefix_1.SemanticUuidPrefix.ECP_PROCESSES,
+];

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerificationStatementVerifiedCarbonFootprintConfiguration = void 0;
+const CarbonFootprintConfigurationReference_1 = require("../../../../shared/domain/value-objects/CarbonFootprintConfigurationReference");
+/**
+ * The carbon footprint configuration the statement verified (id and footprint type).
+ */
+class VerificationStatementVerifiedCarbonFootprintConfiguration extends CarbonFootprintConfigurationReference_1.CarbonFootprintConfigurationReference {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, VerificationStatementVerifiedCarbonFootprintConfiguration.PROPERTY_NAME);
+    }
+    static create(value) {
+        return new VerificationStatementVerifiedCarbonFootprintConfiguration(value, false);
+    }
+    static fromPrimitives(primitives) {
+        const value = {
+            id: primitives.id,
+            footprintType: primitives.footprintType,
+        };
+        return new VerificationStatementVerifiedCarbonFootprintConfiguration(value, true);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.VerificationStatementVerifiedCarbonFootprintConfiguration = VerificationStatementVerifiedCarbonFootprintConfiguration;
+VerificationStatementVerifiedCarbonFootprintConfiguration.PROPERTY_NAME = 'verifiedCarbonFootprintConfiguration';