@carbonbox/domain 0.51.0 → 0.53.0

package/build/carbonbox/carbon-footprint-audits/audit-findings/domain/value-objects/AuditFindingResponseMessage.js

@@ -0,0 +1,40 @@
+"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 _AuditFindingResponseMessage_instances, _a, _AuditFindingResponseMessage_guardAgainstInvalidLength;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuditFindingResponseMessage = void 0;
+const String_1 = require("../../../../shared/domain/value-objects/String");
+const InvalidPropertyValueError_1 = require("../../../../shared/domain/exceptions/InvalidPropertyValueError");
+class AuditFindingResponseMessage extends String_1.String {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, _a.PROPERTY_NAME);
+        _AuditFindingResponseMessage_instances.add(this);
+        if (skipDomainValidation === false) {
+            __classPrivateFieldGet(this, _AuditFindingResponseMessage_instances, "m", _AuditFindingResponseMessage_guardAgainstInvalidLength).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);
+    }
+    toPrimitives() {
+        return this.value.trim();
+    }
+}
+exports.AuditFindingResponseMessage = AuditFindingResponseMessage;
+_a = AuditFindingResponseMessage, _AuditFindingResponseMessage_instances = new WeakSet(), _AuditFindingResponseMessage_guardAgainstInvalidLength = function _AuditFindingResponseMessage_guardAgainstInvalidLength(value) {
+    if (value.trim().length > _a.MAX_LENGTH) {
+        throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(_a.PROPERTY_NAME, `at most ${_a.MAX_LENGTH} characters`, `${value.trim().length} characters`);
+    }
+};
+AuditFindingResponseMessage.PROPERTY_NAME = 'message';
+AuditFindingResponseMessage.MAX_LENGTH = 5000;

package/build/carbonbox/carbon-footprint-audits/audit-findings/domain/value-objects/AuditFindingResponses.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuditFindingResponses = void 0;
+const ObjectValueObject_1 = require("../../../../shared/domain/value-objects/ObjectValueObject");
+const InvalidPropertyTypeError_1 = require("../../../../shared/domain/exceptions/InvalidPropertyTypeError");
+const AuditFindingRespondedByStakeholder_1 = require("./AuditFindingRespondedByStakeholder");
+const AuditFindingResponseMessage_1 = require("./AuditFindingResponseMessage");
+const AuditFindingRespondedAt_1 = require("./AuditFindingRespondedAt");
+/**
+ * Thread of answers of an audit finding, oldest first (D11). Each answer is validated with its own
+ * value objects: who answered (carbon client side only), the message and the moment.
+ */
+class AuditFindingResponses extends ObjectValueObject_1.ObjectValueObject {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, AuditFindingResponses.PROPERTY_NAME, 'AuditFindingResponsePrimitives[]', { allowNull: false, allowUndefined: false });
+        if (skipDomainValidation === false) {
+            AuditFindingResponses.guardAgainstInvalidResponses(value);
+        }
+    }
+    static create(value) {
+        return new AuditFindingResponses(value, false);
+    }
+    static fromPrimitives(primitives) {
+        const value = primitives.map((response) => ({
+            respondedByStakeholder: response.respondedByStakeholder,
+            message: response.message,
+            respondedAt: response.respondedAt,
+        }));
+        return new AuditFindingResponses(value, true);
+    }
+    static empty() {
+        return new AuditFindingResponses([], false);
+    }
+    static guardAgainstInvalidResponses(value) {
+        if (Array.isArray(value) === false) {
+            throw InvalidPropertyTypeError_1.InvalidPropertyTypeError.create(AuditFindingResponses.PROPERTY_NAME, 'array', typeof value);
+        }
+        value.forEach((response) => {
+            AuditFindingRespondedByStakeholder_1.AuditFindingRespondedByStakeholder.create(response.respondedByStakeholder);
+            AuditFindingResponseMessage_1.AuditFindingResponseMessage.create(response.message);
+            AuditFindingRespondedAt_1.AuditFindingRespondedAt.create(response.respondedAt);
+        });
+    }
+    hasResponses() {
+        return this.value.length > 0;
+    }
+    count() {
+        return this.value.length;
+    }
+    toPrimitives() {
+        return this.value.map((response) => ({
+            respondedByStakeholder: {
+                id: response.respondedByStakeholder.id,
+                displayName: response.respondedByStakeholder.displayName,
+                roleType: response.respondedByStakeholder.roleType,
+                taxIdentification: response.respondedByStakeholder.taxIdentification,
+            },
+            message: response.message,
+            respondedAt: response.respondedAt,
+        }));
+    }
+}
+exports.AuditFindingResponses = AuditFindingResponses;
+AuditFindingResponses.PROPERTY_NAME = 'responses';

package/build/carbonbox/carbon-footprint-audits/audit-findings/domain/value-objects/AuditFindingStatus.js

@@ -0,0 +1,53 @@
+"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 _AuditFindingStatus_instances, _AuditFindingStatus_guardAgainstInvalidAuditFindingStatus;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuditFindingStatus = void 0;
+const String_1 = require("../../../../shared/domain/value-objects/String");
+const AuditFindingStatus_1 = require("../enums/AuditFindingStatus");
+const InvalidAuditFindingStatusError_1 = require("../exceptions/InvalidAuditFindingStatusError");
+class AuditFindingStatus extends String_1.String {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, AuditFindingStatus.PROPERTY_NAME);
+        _AuditFindingStatus_instances.add(this);
+        if (skipDomainValidation === false) {
+            __classPrivateFieldGet(this, _AuditFindingStatus_instances, "m", _AuditFindingStatus_guardAgainstInvalidAuditFindingStatus).call(this, value);
+        }
+    }
+    static create(value) {
+        String_1.String.guardAgainstEmptyValue(value, AuditFindingStatus.PROPERTY_NAME);
+        String_1.String.guardAgainstInvalidType(value, AuditFindingStatus.PROPERTY_NAME);
+        return new AuditFindingStatus(value, false);
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new AuditFindingStatus(value, true);
+    }
+    isOpen() {
+        return this.value === AuditFindingStatus_1.AuditFindingStatus.OPEN;
+    }
+    isAnswered() {
+        return this.value === AuditFindingStatus_1.AuditFindingStatus.ANSWERED;
+    }
+    isClosed() {
+        return this.value === AuditFindingStatus_1.AuditFindingStatus.CLOSED;
+    }
+    toEnum() {
+        return this.value;
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.AuditFindingStatus = AuditFindingStatus;
+_AuditFindingStatus_instances = new WeakSet(), _AuditFindingStatus_guardAgainstInvalidAuditFindingStatus = function _AuditFindingStatus_guardAgainstInvalidAuditFindingStatus(value) {
+    const validStatuses = Object.values(AuditFindingStatus_1.AuditFindingStatus);
+    if (!validStatuses.includes(value)) {
+        throw InvalidAuditFindingStatusError_1.InvalidAuditFindingStatusError.create(value, validStatuses);
+    }
+};
+AuditFindingStatus.PROPERTY_NAME = 'status';

package/build/carbonbox/carbon-footprint-audits/audit-findings/domain/value-objects/AuditFindingSubject.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuditFindingSubject = void 0;
+const ObjectValueObject_1 = require("../../../../shared/domain/value-objects/ObjectValueObject");
+const AuditFindingSubjectType_1 = require("../enums/AuditFindingSubjectType");
+const InvalidAuditFindingSubjectError_1 = require("../exceptions/InvalidAuditFindingSubjectError");
+/**
+ * Resource an audit finding points to. `subjectId` is null only with GENERAL and required (the id
+ * of the resource) with every other subject type. The id is kept as sent: whether the resource
+ * exists and belongs to the audited footprint is checked by the application layer.
+ */
+class AuditFindingSubject extends ObjectValueObject_1.ObjectValueObject {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, AuditFindingSubject.PROPERTY_NAME, 'AuditFindingSubjectPrimitives', { allowNull: false, allowUndefined: false });
+        if (skipDomainValidation === false) {
+            AuditFindingSubject.guardAgainstInvalidSubject(value);
+        }
+    }
+    static create(value) {
+        return new AuditFindingSubject(value, false);
+    }
+    static fromPrimitives(primitives) {
+        const value = {
+            subjectType: primitives.subjectType,
+            subjectId: primitives.subjectId,
+        };
+        return new AuditFindingSubject(value, true);
+    }
+    static guardAgainstInvalidSubject(value) {
+        if (Object.values(AuditFindingSubjectType_1.AuditFindingSubjectType).includes(value.subjectType) === false) {
+            throw InvalidAuditFindingSubjectError_1.InvalidAuditFindingSubjectError.create(`subjectType '${String(value.subjectType)}' is not a value of AuditFindingSubjectType`);
+        }
+        if (value.subjectType === AuditFindingSubjectType_1.AuditFindingSubjectType.GENERAL) {
+            if (value.subjectId !== null) {
+                throw InvalidAuditFindingSubjectError_1.InvalidAuditFindingSubjectError.create('subjectId must be null when the subject type is GENERAL');
+            }
+            return;
+        }
+        if (typeof value.subjectId !== 'string' || value.subjectId.trim() === '') {
+            throw InvalidAuditFindingSubjectError_1.InvalidAuditFindingSubjectError.create(`subjectId is required with subject type ${value.subjectType}`);
+        }
+        if (value.subjectId.trim().length > AuditFindingSubject.SUBJECT_ID_MAX_LENGTH) {
+            throw InvalidAuditFindingSubjectError_1.InvalidAuditFindingSubjectError.create(`subjectId cannot exceed ${AuditFindingSubject.SUBJECT_ID_MAX_LENGTH} characters`);
+        }
+    }
+    get subjectType() {
+        return this.value.subjectType;
+    }
+    get subjectId() {
+        return this.value.subjectId === null ? null : this.value.subjectId.trim();
+    }
+    isGeneral() {
+        return this.value.subjectType === AuditFindingSubjectType_1.AuditFindingSubjectType.GENERAL;
+    }
+    toPrimitives() {
+        return {
+            subjectType: this.subjectType,
+            subjectId: this.subjectId,
+        };
+    }
+}
+exports.AuditFindingSubject = AuditFindingSubject;
+AuditFindingSubject.PROPERTY_NAME = 'subject';
+AuditFindingSubject.SUBJECT_ID_MAX_LENGTH = 255;

package/build/carbonbox/carbon-footprint-audits/audit-findings/domain/value-objects/AuditFindingTitle.js

@@ -0,0 +1,40 @@
+"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 _AuditFindingTitle_instances, _a, _AuditFindingTitle_guardAgainstInvalidLength;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuditFindingTitle = void 0;
+const String_1 = require("../../../../shared/domain/value-objects/String");
+const InvalidPropertyValueError_1 = require("../../../../shared/domain/exceptions/InvalidPropertyValueError");
+class AuditFindingTitle extends String_1.String {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, _a.PROPERTY_NAME);
+        _AuditFindingTitle_instances.add(this);
+        if (skipDomainValidation === false) {
+            __classPrivateFieldGet(this, _AuditFindingTitle_instances, "m", _AuditFindingTitle_guardAgainstInvalidLength).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);
+    }
+    toPrimitives() {
+        return this.value.trim();
+    }
+}
+exports.AuditFindingTitle = AuditFindingTitle;
+_a = AuditFindingTitle, _AuditFindingTitle_instances = new WeakSet(), _AuditFindingTitle_guardAgainstInvalidLength = function _AuditFindingTitle_guardAgainstInvalidLength(value) {
+    if (value.trim().length > _a.MAX_LENGTH) {
+        throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(_a.PROPERTY_NAME, `at most ${_a.MAX_LENGTH} characters`, `${value.trim().length} characters`);
+    }
+};
+AuditFindingTitle.PROPERTY_NAME = 'title';
+AuditFindingTitle.MAX_LENGTH = 200;

package/build/carbonbox/carbon-footprint-audits/audit-findings/domain/value-objects/AuditFindingType.js

@@ -0,0 +1,60 @@
+"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 _AuditFindingType_instances, _AuditFindingType_guardAgainstInvalidAuditFindingType;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuditFindingType = void 0;
+const String_1 = require("../../../../shared/domain/value-objects/String");
+const AuditFindingType_1 = require("../enums/AuditFindingType");
+const InvalidAuditFindingTypeError_1 = require("../exceptions/InvalidAuditFindingTypeError");
+class AuditFindingType extends String_1.String {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, AuditFindingType.PROPERTY_NAME);
+        _AuditFindingType_instances.add(this);
+        if (skipDomainValidation === false) {
+            __classPrivateFieldGet(this, _AuditFindingType_instances, "m", _AuditFindingType_guardAgainstInvalidAuditFindingType).call(this, value);
+        }
+    }
+    static create(value) {
+        String_1.String.guardAgainstEmptyValue(value, AuditFindingType.PROPERTY_NAME);
+        String_1.String.guardAgainstInvalidType(value, AuditFindingType.PROPERTY_NAME);
+        return new AuditFindingType(value, false);
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new AuditFindingType(value, true);
+    }
+    isClarificationRequest() {
+        return this.value === AuditFindingType_1.AuditFindingType.CLARIFICATION_REQUEST;
+    }
+    isCorrectiveActionRequest() {
+        return this.value === AuditFindingType_1.AuditFindingType.CORRECTIVE_ACTION_REQUEST;
+    }
+    isForwardActionRequest() {
+        return this.value === AuditFindingType_1.AuditFindingType.FORWARD_ACTION_REQUEST;
+    }
+    /**
+     * Whether a finding of this type needs an answer from the carbon client side before it can be
+     * closed and blocks the verification statement while not closed (CL and CAR; D12).
+     */
+    requiresResolutionBeforeVerification() {
+        return this.isClarificationRequest() || this.isCorrectiveActionRequest();
+    }
+    toEnum() {
+        return this.value;
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.AuditFindingType = AuditFindingType;
+_AuditFindingType_instances = new WeakSet(), _AuditFindingType_guardAgainstInvalidAuditFindingType = function _AuditFindingType_guardAgainstInvalidAuditFindingType(value) {
+    const validTypes = Object.values(AuditFindingType_1.AuditFindingType);
+    if (!validTypes.includes(value)) {
+        throw InvalidAuditFindingTypeError_1.InvalidAuditFindingTypeError.create(value, validTypes);
+    }
+};
+AuditFindingType.PROPERTY_NAME = 'type';

package/build/carbonbox/carbon-footprint-audits/shared/domain/constants/AUDITOR_ACCESS_SERVICE_CODE.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AUDITOR_ACCESS_SERVICE_CODE = void 0;
+/**
+ * Code of the "Auditor user" service of the catalog (AUD-D09, decision D1).
+ *
+ * A carbon client sells access to an external auditor through a purchase contract that includes
+ * this service (`ADDITIONAL_SERVICE`, category `AUDIT_SUPPORT`). Assigning an auditor requires an
+ * ACTIVE contract of the carbon client with this service, and the engagement validity is copied
+ * from that contract.
+ */
+exports.AUDITOR_ACCESS_SERVICE_CODE = 'SVC_AUDITOR_ACCESS';

package/build/carbonbox/carbon-footprint-audits/verification-statements/domain/entity/IVerificationStatement.js

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

package/build/carbonbox/carbon-footprint-audits/verification-statements/domain/entity/VerificationStatement.js

@@ -0,0 +1,211 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+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 _VerificationStatement_auditEngagementId, _VerificationStatement_carbonClientId, _VerificationStatement_verifiedCarbonFootprintConfiguration, _VerificationStatement_verifiedCalculationProcessId, _VerificationStatement_assuranceLevel, _VerificationStatement_opinion, _VerificationStatement_verificationStandard, _VerificationStatement_materialityThresholdPercentage, _VerificationStatement_conclusion, _VerificationStatement_verifierOrganizationName, _VerificationStatement_accreditation, _VerificationStatement_issuedByCarbonAuditorId, _VerificationStatement_issuedAt;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerificationStatement = void 0;
+const AggregateRoot_1 = require("../../../../shared/domain/entities/AggregateRoot");
+const CarbonClientId_1 = require("../../../../stakeholders/carbon-clients/domain/value-objects/CarbonClientId");
+const VerificationStatementId_1 = require("../value-objects/VerificationStatementId");
+const VerificationStatementAuditEngagementId_1 = require("../value-objects/VerificationStatementAuditEngagementId");
+const VerificationStatementVerifiedCarbonFootprintConfiguration_1 = require("../value-objects/VerificationStatementVerifiedCarbonFootprintConfiguration");
+const VerificationStatementVerifiedCalculationProcessId_1 = require("../value-objects/VerificationStatementVerifiedCalculationProcessId");
+const VerificationStatementAssuranceLevel_1 = require("../value-objects/VerificationStatementAssuranceLevel");
+const VerificationStatementOpinion_1 = require("../value-objects/VerificationStatementOpinion");
+const VerificationStatementVerificationStandard_1 = require("../value-objects/VerificationStatementVerificationStandard");
+const VerificationStatementMaterialityThresholdPercentage_1 = require("../value-objects/VerificationStatementMaterialityThresholdPercentage");
+const VerificationStatementConclusion_1 = require("../value-objects/VerificationStatementConclusion");
+const VerificationStatementVerifierOrganizationName_1 = require("../value-objects/VerificationStatementVerifierOrganizationName");
+const VerificationStatementAccreditation_1 = require("../value-objects/VerificationStatementAccreditation");
+const VerificationStatementIssuedByCarbonAuditorId_1 = require("../value-objects/VerificationStatementIssuedByCarbonAuditorId");
+const VerificationStatementIssuedAt_1 = require("../value-objects/VerificationStatementIssuedAt");
+/**
+ * VerificationStatement aggregate (AUD-D06): the statement the carbon auditor issues at the end of
+ * an audit engagement (ISO 14064-3 §6.4 / ISAE 3410).
+ *
+ * It points to a concrete calculation process of the audited footprint (the verified snapshot,
+ * decision D12), so later changes of the carbon client never alter what was verified. The
+ * verifier organization name and accreditation are copied from the auditor profile when issuing.
+ *
+ * Immutable: there are no transitions after issuing. The domain does not read the clock: issuing
+ * receives the current moment (`DD/MM/YYYY HH:mm:ss`). The rule that a statement cannot be issued
+ * while clarification or corrective action requests are unresolved spans other aggregates and
+ * lives in a domain policy, not here.
+ */
+class VerificationStatement extends AggregateRoot_1.AggregateRoot {
+    constructor(props, skipDomainValidation) {
+        const id = skipDomainValidation
+            ? VerificationStatementId_1.VerificationStatementId.fromPrimitives(props.id).toPrimitives()
+            : VerificationStatementId_1.VerificationStatementId.create(props.id).toPrimitives();
+        super({ id }, skipDomainValidation);
+        _VerificationStatement_auditEngagementId.set(this, void 0);
+        _VerificationStatement_carbonClientId.set(this, void 0);
+        _VerificationStatement_verifiedCarbonFootprintConfiguration.set(this, void 0);
+        _VerificationStatement_verifiedCalculationProcessId.set(this, void 0);
+        _VerificationStatement_assuranceLevel.set(this, void 0);
+        _VerificationStatement_opinion.set(this, void 0);
+        _VerificationStatement_verificationStandard.set(this, void 0);
+        _VerificationStatement_materialityThresholdPercentage.set(this, void 0);
+        _VerificationStatement_conclusion.set(this, void 0);
+        _VerificationStatement_verifierOrganizationName.set(this, void 0);
+        _VerificationStatement_accreditation.set(this, void 0);
+        _VerificationStatement_issuedByCarbonAuditorId.set(this, void 0);
+        _VerificationStatement_issuedAt.set(this, void 0);
+        if (skipDomainValidation === false) {
+            // Initialize with domain validation
+            __classPrivateFieldSet(this, _VerificationStatement_auditEngagementId, VerificationStatementAuditEngagementId_1.VerificationStatementAuditEngagementId.create(props.auditEngagementId), "f");
+            __classPrivateFieldSet(this, _VerificationStatement_carbonClientId, CarbonClientId_1.CarbonClientId.create(props.carbonClientId), "f");
+            __classPrivateFieldSet(this, _VerificationStatement_verifiedCarbonFootprintConfiguration, VerificationStatementVerifiedCarbonFootprintConfiguration_1.VerificationStatementVerifiedCarbonFootprintConfiguration.create(props.verifiedCarbonFootprintConfiguration), "f");
+            __classPrivateFieldSet(this, _VerificationStatement_verifiedCalculationProcessId, VerificationStatementVerifiedCalculationProcessId_1.VerificationStatementVerifiedCalculationProcessId.create(props.verifiedCalculationProcessId), "f");
+            __classPrivateFieldSet(this, _VerificationStatement_assuranceLevel, VerificationStatementAssuranceLevel_1.VerificationStatementAssuranceLevel.create(props.assuranceLevel), "f");
+            __classPrivateFieldSet(this, _VerificationStatement_opinion, VerificationStatementOpinion_1.VerificationStatementOpinion.create(props.opinion), "f");
+            __classPrivateFieldSet(this, _VerificationStatement_verificationStandard, VerificationStatementVerificationStandard_1.VerificationStatementVerificationStandard.create(props.verificationStandard), "f");
+            __classPrivateFieldSet(this, _VerificationStatement_materialityThresholdPercentage, VerificationStatementMaterialityThresholdPercentage_1.VerificationStatementMaterialityThresholdPercentage.create(props.materialityThresholdPercentage), "f");
+            __classPrivateFieldSet(this, _VerificationStatement_conclusion, VerificationStatementConclusion_1.VerificationStatementConclusion.create(props.conclusion), "f");
+            __classPrivateFieldSet(this, _VerificationStatement_verifierOrganizationName, VerificationStatementVerifierOrganizationName_1.VerificationStatementVerifierOrganizationName.create(props.verifierOrganizationName), "f");
+            __classPrivateFieldSet(this, _VerificationStatement_accreditation, VerificationStatementAccreditation_1.VerificationStatementAccreditation.create(props.accreditation), "f");
+            __classPrivateFieldSet(this, _VerificationStatement_issuedByCarbonAuditorId, VerificationStatementIssuedByCarbonAuditorId_1.VerificationStatementIssuedByCarbonAuditorId.create(props.issuedByCarbonAuditorId), "f");
+            __classPrivateFieldSet(this, _VerificationStatement_issuedAt, VerificationStatementIssuedAt_1.VerificationStatementIssuedAt.create(props.issuedAt), "f");
+        }
+        else {
+            // Initialize from primitives (no domain validation)
+            __classPrivateFieldSet(this, _VerificationStatement_auditEngagementId, VerificationStatementAuditEngagementId_1.VerificationStatementAuditEngagementId.fromPrimitives(props.auditEngagementId), "f");
+            __classPrivateFieldSet(this, _VerificationStatement_carbonClientId, CarbonClientId_1.CarbonClientId.fromPrimitives(props.carbonClientId), "f");
+            __classPrivateFieldSet(this, _VerificationStatement_verifiedCarbonFootprintConfiguration, VerificationStatementVerifiedCarbonFootprintConfiguration_1.VerificationStatementVerifiedCarbonFootprintConfiguration.fromPrimitives(props.verifiedCarbonFootprintConfiguration), "f");
+            __classPrivateFieldSet(this, _VerificationStatement_verifiedCalculationProcessId, VerificationStatementVerifiedCalculationProcessId_1.VerificationStatementVerifiedCalculationProcessId.fromPrimitives(props.verifiedCalculationProcessId), "f");
+            __classPrivateFieldSet(this, _VerificationStatement_assuranceLevel, VerificationStatementAssuranceLevel_1.VerificationStatementAssuranceLevel.fromPrimitives(props.assuranceLevel), "f");
+            __classPrivateFieldSet(this, _VerificationStatement_opinion, VerificationStatementOpinion_1.VerificationStatementOpinion.fromPrimitives(props.opinion), "f");
+            __classPrivateFieldSet(this, _VerificationStatement_verificationStandard, VerificationStatementVerificationStandard_1.VerificationStatementVerificationStandard.fromPrimitives(props.verificationStandard), "f");
+            __classPrivateFieldSet(this, _VerificationStatement_materialityThresholdPercentage, VerificationStatementMaterialityThresholdPercentage_1.VerificationStatementMaterialityThresholdPercentage.fromPrimitives(props.materialityThresholdPercentage), "f");
+            __classPrivateFieldSet(this, _VerificationStatement_conclusion, VerificationStatementConclusion_1.VerificationStatementConclusion.fromPrimitives(props.conclusion), "f");
+            __classPrivateFieldSet(this, _VerificationStatement_verifierOrganizationName, VerificationStatementVerifierOrganizationName_1.VerificationStatementVerifierOrganizationName.fromPrimitives(props.verifierOrganizationName), "f");
+            __classPrivateFieldSet(this, _VerificationStatement_accreditation, VerificationStatementAccreditation_1.VerificationStatementAccreditation.fromPrimitives(props.accreditation), "f");
+            __classPrivateFieldSet(this, _VerificationStatement_issuedByCarbonAuditorId, VerificationStatementIssuedByCarbonAuditorId_1.VerificationStatementIssuedByCarbonAuditorId.fromPrimitives(props.issuedByCarbonAuditorId), "f");
+            __classPrivateFieldSet(this, _VerificationStatement_issuedAt, VerificationStatementIssuedAt_1.VerificationStatementIssuedAt.fromPrimitives(props.issuedAt), "f");
+        }
+    }
+    static create(props) {
+        return new VerificationStatement(props, false);
+    }
+    /**
+     * Issues a verification statement at `issuedAt` (the current moment, provided by the caller).
+     * Every field is validated; an issued statement never changes.
+     */
+    static issue(props) {
+        return new VerificationStatement({
+            id: props.id,
+            auditEngagementId: props.auditEngagementId,
+            carbonClientId: props.carbonClientId,
+            verifiedCarbonFootprintConfiguration: props.verifiedCarbonFootprintConfiguration,
+            verifiedCalculationProcessId: props.verifiedCalculationProcessId,
+            assuranceLevel: props.assuranceLevel,
+            opinion: props.opinion,
+            verificationStandard: props.verificationStandard,
+            materialityThresholdPercentage: props.materialityThresholdPercentage,
+            conclusion: props.conclusion,
+            verifierOrganizationName: props.verifierOrganizationName,
+            accreditation: props.accreditation,
+            issuedByCarbonAuditorId: props.issuedByCarbonAuditorId,
+            issuedAt: props.issuedAt,
+        }, false);
+    }
+    static fromPrimitives(primitives) {
+        const props = {
+            id: primitives.id,
+            auditEngagementId: primitives.auditEngagementId,
+            carbonClientId: primitives.carbonClientId,
+            verifiedCarbonFootprintConfiguration: primitives.verifiedCarbonFootprintConfiguration,
+            verifiedCalculationProcessId: primitives.verifiedCalculationProcessId,
+            assuranceLevel: primitives.assuranceLevel,
+            opinion: primitives.opinion,
+            verificationStandard: primitives.verificationStandard,
+            materialityThresholdPercentage: primitives.materialityThresholdPercentage,
+            conclusion: primitives.conclusion,
+            verifierOrganizationName: primitives.verifierOrganizationName,
+            accreditation: primitives.accreditation,
+            issuedByCarbonAuditorId: primitives.issuedByCarbonAuditorId,
+            issuedAt: primitives.issuedAt,
+        };
+        return new VerificationStatement(props, true);
+    }
+    get toPrimitives() {
+        return {
+            id: this.id.toPrimitives(),
+            auditEngagementId: __classPrivateFieldGet(this, _VerificationStatement_auditEngagementId, "f").toPrimitives(),
+            carbonClientId: __classPrivateFieldGet(this, _VerificationStatement_carbonClientId, "f").toPrimitives(),
+            verifiedCarbonFootprintConfiguration: __classPrivateFieldGet(this, _VerificationStatement_verifiedCarbonFootprintConfiguration, "f").toPrimitives(),
+            verifiedCalculationProcessId: __classPrivateFieldGet(this, _VerificationStatement_verifiedCalculationProcessId, "f").toPrimitives(),
+            assuranceLevel: __classPrivateFieldGet(this, _VerificationStatement_assuranceLevel, "f").toEnum(),
+            opinion: __classPrivateFieldGet(this, _VerificationStatement_opinion, "f").toEnum(),
+            verificationStandard: __classPrivateFieldGet(this, _VerificationStatement_verificationStandard, "f").toEnum(),
+            materialityThresholdPercentage: __classPrivateFieldGet(this, _VerificationStatement_materialityThresholdPercentage, "f").toPrimitives(),
+            conclusion: __classPrivateFieldGet(this, _VerificationStatement_conclusion, "f").toPrimitives(),
+            verifierOrganizationName: __classPrivateFieldGet(this, _VerificationStatement_verifierOrganizationName, "f").toPrimitives(),
+            accreditation: __classPrivateFieldGet(this, _VerificationStatement_accreditation, "f").toPrimitives(),
+            issuedByCarbonAuditorId: __classPrivateFieldGet(this, _VerificationStatement_issuedByCarbonAuditorId, "f").toPrimitives(),
+            issuedAt: __classPrivateFieldGet(this, _VerificationStatement_issuedAt, "f").toPrimitives(),
+        };
+    }
+    get auditEngagementId() {
+        return __classPrivateFieldGet(this, _VerificationStatement_auditEngagementId, "f");
+    }
+    get carbonClientId() {
+        return __classPrivateFieldGet(this, _VerificationStatement_carbonClientId, "f");
+    }
+    get verifiedCarbonFootprintConfiguration() {
+        return __classPrivateFieldGet(this, _VerificationStatement_verifiedCarbonFootprintConfiguration, "f");
+    }
+    get verifiedCalculationProcessId() {
+        return __classPrivateFieldGet(this, _VerificationStatement_verifiedCalculationProcessId, "f");
+    }
+    get assuranceLevel() {
+        return __classPrivateFieldGet(this, _VerificationStatement_assuranceLevel, "f");
+    }
+    get opinion() {
+        return __classPrivateFieldGet(this, _VerificationStatement_opinion, "f");
+    }
+    get verificationStandard() {
+        return __classPrivateFieldGet(this, _VerificationStatement_verificationStandard, "f");
+    }
+    get materialityThresholdPercentage() {
+        return __classPrivateFieldGet(this, _VerificationStatement_materialityThresholdPercentage, "f");
+    }
+    get conclusion() {
+        return __classPrivateFieldGet(this, _VerificationStatement_conclusion, "f");
+    }
+    get verifierOrganizationName() {
+        return __classPrivateFieldGet(this, _VerificationStatement_verifierOrganizationName, "f");
+    }
+    get accreditation() {
+        return __classPrivateFieldGet(this, _VerificationStatement_accreditation, "f");
+    }
+    get issuedByCarbonAuditorId() {
+        return __classPrivateFieldGet(this, _VerificationStatement_issuedByCarbonAuditorId, "f");
+    }
+    get issuedAt() {
+        return __classPrivateFieldGet(this, _VerificationStatement_issuedAt, "f");
+    }
+    /**
+     * Whether the auditor expressed an unmodified opinion (no qualifications).
+     */
+    isUnmodified() {
+        return __classPrivateFieldGet(this, _VerificationStatement_opinion, "f").isUnmodified();
+    }
+    /**
+     * Whether the statement provides reasonable assurance (otherwise it provides limited assurance).
+     */
+    providesReasonableAssurance() {
+        return __classPrivateFieldGet(this, _VerificationStatement_assuranceLevel, "f").isReasonable();
+    }
+}
+exports.VerificationStatement = VerificationStatement;
+_VerificationStatement_auditEngagementId = new WeakMap(), _VerificationStatement_carbonClientId = new WeakMap(), _VerificationStatement_verifiedCarbonFootprintConfiguration = new WeakMap(), _VerificationStatement_verifiedCalculationProcessId = new WeakMap(), _VerificationStatement_assuranceLevel = new WeakMap(), _VerificationStatement_opinion = new WeakMap(), _VerificationStatement_verificationStandard = new WeakMap(), _VerificationStatement_materialityThresholdPercentage = new WeakMap(), _VerificationStatement_conclusion = new WeakMap(), _VerificationStatement_verifierOrganizationName = new WeakMap(), _VerificationStatement_accreditation = new WeakMap(), _VerificationStatement_issuedByCarbonAuditorId = new WeakMap(), _VerificationStatement_issuedAt = new WeakMap();

package/build/carbonbox/carbon-footprint-audits/verification-statements/domain/enums/VerificationOpinion.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerificationOpinion = void 0;
+/**
+ * Verification opinion enumeration (AUD-D06, ISO 14064-3 §6.4 / ISAE 3410)
+ * Conclusion the auditor expresses on the verified GHG statement.
+ */
+var VerificationOpinion;
+(function (VerificationOpinion) {
+    /**
+     * Unmodified opinion: the GHG statement is fairly stated (no qualifications)
+     */
+    VerificationOpinion["UNMODIFIED"] = "UNMODIFIED";
+    /**
+     * Qualified opinion: fairly stated except for the matters described in the conclusion
+     */
+    VerificationOpinion["QUALIFIED"] = "QUALIFIED";
+    /**
+     * Adverse opinion: the GHG statement is materially misstated
+     */
+    VerificationOpinion["ADVERSE"] = "ADVERSE";
+    /**
+     * Disclaimer of opinion: the auditor could not obtain sufficient evidence to conclude
+     */
+    VerificationOpinion["DISCLAIMER"] = "DISCLAIMER";
+})(VerificationOpinion || (exports.VerificationOpinion = VerificationOpinion = {}));

package/build/carbonbox/carbon-footprint-audits/verification-statements/domain/enums/VerificationStandard.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerificationStandard = void 0;
+/**
+ * Verification standard enumeration (AUD-D06)
+ * Standard the verification was performed against.
+ */
+var VerificationStandard;
+(function (VerificationStandard) {
+    /**
+     * ISO 14064-3:2019 — specification for the verification and validation of GHG statements
+     */
+    VerificationStandard["ISO_14064_3_2019"] = "ISO_14064_3_2019";
+    /**
+     * ISAE 3410 (IAASB) — assurance engagements on greenhouse gas statements
+     */
+    VerificationStandard["ISAE_3410"] = "ISAE_3410";
+    /**
+     * Another standard, named in the conclusion of the statement
+     */
+    VerificationStandard["OTHER"] = "OTHER";
+})(VerificationStandard || (exports.VerificationStandard = VerificationStandard = {}));

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidVerificationAssuranceLevelError = void 0;
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+/**
+ * The assurance level of a verification statement is not LIMITED nor REASONABLE (AUD-D06).
+ * A statement always provides some assurance: NONE is only valid on a report that was not verified.
+ */
+class InvalidVerificationAssuranceLevelError extends CodedRootError_1.CodedRootError {
+    constructor(invalidValue, validValues, propertyName) {
+        const technicalMessage = `Verification statement ${propertyName} constraint violation: '${invalidValue}' is not a valid assurance level for a verification statement.`;
+        const context = {
+            propertyName,
+            receivedValue: invalidValue,
+            validValues,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid assurance levels: ${validValues.join(', ')}`,
+            'A verification statement cannot declare the NONE assurance level',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_VERIFICATION_ASSURANCE_LEVEL, technicalMessage, context, suggestions);
+        this.name = 'InvalidVerificationAssuranceLevelError';
+    }
+    static create(invalidValue, validValues, propertyName = 'assuranceLevel') {
+        return new InvalidVerificationAssuranceLevelError(invalidValue, validValues, propertyName);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.InvalidVerificationAssuranceLevelError = InvalidVerificationAssuranceLevelError;