@carbonbox/domain 0.48.1 → 0.49.0

package/build/carbonbox/carbon-footprint-configurations/shared/domain/enums/CarbonFootprintConfigurationActivationRequirement.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CarbonFootprintConfigurationActivationRequirement = void 0;
+/**
+ * Requirements a carbon footprint configuration (corporate, event or
+ * product) must meet to move from `DRAFT` to `ACTIVE`.
+ *
+ * Each member identifies ONE rule evaluated by
+ * `CarbonFootprintConfigurationActivationPolicy`. The members are listed in
+ * the order the policy evaluates them; a given footprint type only
+ * evaluates the members that apply to it (e.g. `FACILITY_*` is corporate
+ * only, `ANALYSIS_UNIT_*` is event only).
+ *
+ * The detail needed to describe an unmet requirement (index, received value,
+ * dates...) travels in `CarbonFootprintConfigurationRequirementContext`.
+ */
+var CarbonFootprintConfigurationActivationRequirement;
+(function (CarbonFootprintConfigurationActivationRequirement) {
+    // ─── Gates (all footprint types) ──────────────────────────────────────────
+    CarbonFootprintConfigurationActivationRequirement["CARBON_CLIENT_NOT_ENTITLED"] = "CARBON_CLIENT_NOT_ENTITLED";
+    CarbonFootprintConfigurationActivationRequirement["CONFIGURATION_MUST_BE_DRAFT"] = "CONFIGURATION_MUST_BE_DRAFT";
+    // ─── Segment configurations (corporate, product) ─────────────────────────
+    CarbonFootprintConfigurationActivationRequirement["SEGMENT_CONFIGURATION_REQUIRED"] = "SEGMENT_CONFIGURATION_REQUIRED";
+    CarbonFootprintConfigurationActivationRequirement["SEGMENT_CONFIGURATION_SEGMENT_ID_REQUIRED"] = "SEGMENT_CONFIGURATION_SEGMENT_ID_REQUIRED";
+    CarbonFootprintConfigurationActivationRequirement["SEGMENT_CONFIGURATION_EMISSION_SOURCE_REQUIRED"] = "SEGMENT_CONFIGURATION_EMISSION_SOURCE_REQUIRED";
+    // ─── Event edition lifecycle stage configurations (event) ────────────────
+    CarbonFootprintConfigurationActivationRequirement["LIFECYCLE_STAGE_CONFIGURATION_REQUIRED"] = "LIFECYCLE_STAGE_CONFIGURATION_REQUIRED";
+    CarbonFootprintConfigurationActivationRequirement["LIFECYCLE_STAGE_CONFIGURATION_STAGE_ID_REQUIRED"] = "LIFECYCLE_STAGE_CONFIGURATION_STAGE_ID_REQUIRED";
+    CarbonFootprintConfigurationActivationRequirement["LIFECYCLE_STAGE_CONFIGURATION_EMISSION_SOURCE_REQUIRED"] = "LIFECYCLE_STAGE_CONFIGURATION_EMISSION_SOURCE_REQUIRED";
+    // ─── Event edition and analysis unit (event) ─────────────────────────────
+    CarbonFootprintConfigurationActivationRequirement["EVENT_EDITION_REFERENCE_INCOMPLETE"] = "EVENT_EDITION_REFERENCE_INCOMPLETE";
+    CarbonFootprintConfigurationActivationRequirement["ANALYSIS_UNIT_REQUIRED"] = "ANALYSIS_UNIT_REQUIRED";
+    CarbonFootprintConfigurationActivationRequirement["ANALYSIS_UNIT_BENCHMARK_VALUE_INVALID"] = "ANALYSIS_UNIT_BENCHMARK_VALUE_INVALID";
+    CarbonFootprintConfigurationActivationRequirement["ANALYSIS_UNIT_MEASUREMENT_UNIT_INVALID"] = "ANALYSIS_UNIT_MEASUREMENT_UNIT_INVALID";
+    // ─── Product, system boundary and functional unit (product) ──────────────
+    CarbonFootprintConfigurationActivationRequirement["PRODUCT_REFERENCE_INCOMPLETE"] = "PRODUCT_REFERENCE_INCOMPLETE";
+    CarbonFootprintConfigurationActivationRequirement["SYSTEM_BOUNDARY_REFERENCE_INCOMPLETE"] = "SYSTEM_BOUNDARY_REFERENCE_INCOMPLETE";
+    CarbonFootprintConfigurationActivationRequirement["FUNCTIONAL_UNIT_REQUIRED"] = "FUNCTIONAL_UNIT_REQUIRED";
+    CarbonFootprintConfigurationActivationRequirement["FUNCTIONAL_UNIT_BENCHMARK_VALUE_INVALID"] = "FUNCTIONAL_UNIT_BENCHMARK_VALUE_INVALID";
+    CarbonFootprintConfigurationActivationRequirement["FUNCTIONAL_UNIT_MEASUREMENT_UNIT_REQUIRED"] = "FUNCTIONAL_UNIT_MEASUREMENT_UNIT_REQUIRED";
+    // ─── Execution period (corporate) ────────────────────────────────────────
+    CarbonFootprintConfigurationActivationRequirement["EXECUTION_PERIOD_START_DATE_REQUIRED"] = "EXECUTION_PERIOD_START_DATE_REQUIRED";
+    CarbonFootprintConfigurationActivationRequirement["EXECUTION_PERIOD_START_DATE_INVALID_FORMAT"] = "EXECUTION_PERIOD_START_DATE_INVALID_FORMAT";
+    CarbonFootprintConfigurationActivationRequirement["EXECUTION_PERIOD_START_DATE_TOO_OLD"] = "EXECUTION_PERIOD_START_DATE_TOO_OLD";
+    CarbonFootprintConfigurationActivationRequirement["EXECUTION_PERIOD_END_DATE_INVALID_FORMAT"] = "EXECUTION_PERIOD_END_DATE_INVALID_FORMAT";
+    CarbonFootprintConfigurationActivationRequirement["EXECUTION_PERIOD_START_DATE_NOT_BEFORE_END_DATE"] = "EXECUTION_PERIOD_START_DATE_NOT_BEFORE_END_DATE";
+    // ─── Intensity indicators (all footprint types) ──────────────────────────
+    CarbonFootprintConfigurationActivationRequirement["INTENSITY_INDICATOR_CONFIGURATIONS_INVALID"] = "INTENSITY_INDICATOR_CONFIGURATIONS_INVALID";
+    CarbonFootprintConfigurationActivationRequirement["INTENSITY_INDICATOR_ASSIGNMENT_REQUIRED"] = "INTENSITY_INDICATOR_ASSIGNMENT_REQUIRED";
+    CarbonFootprintConfigurationActivationRequirement["INTENSITY_INDICATOR_TARGET_VALUE_NOT_POSITIVE"] = "INTENSITY_INDICATOR_TARGET_VALUE_NOT_POSITIVE";
+    CarbonFootprintConfigurationActivationRequirement["INTENSITY_INDICATOR_BENCHMARK_VALUE_NOT_POSITIVE"] = "INTENSITY_INDICATOR_BENCHMARK_VALUE_NOT_POSITIVE";
+    // ─── Facilities (corporate) ──────────────────────────────────────────────
+    CarbonFootprintConfigurationActivationRequirement["FACILITY_REQUIRED"] = "FACILITY_REQUIRED";
+    CarbonFootprintConfigurationActivationRequirement["FACILITY_REFERENCE_INCOMPLETE"] = "FACILITY_REFERENCE_INCOMPLETE";
+    CarbonFootprintConfigurationActivationRequirement["FACILITY_NOT_FOUND"] = "FACILITY_NOT_FOUND";
+    // ─── Reporting standard (all footprint types) ────────────────────────────
+    CarbonFootprintConfigurationActivationRequirement["CARBON_FOOTPRINT_OBJECTIVE_TOO_SHORT"] = "CARBON_FOOTPRINT_OBJECTIVE_TOO_SHORT";
+    // ─── Ownership references (all footprint types) ──────────────────────────
+    CarbonFootprintConfigurationActivationRequirement["OWNED_BY_CARBON_CLIENT_REFERENCE_INCOMPLETE"] = "OWNED_BY_CARBON_CLIENT_REFERENCE_INCOMPLETE";
+    CarbonFootprintConfigurationActivationRequirement["CREATED_BY_STAKEHOLDER_REFERENCE_INCOMPLETE"] = "CREATED_BY_STAKEHOLDER_REFERENCE_INCOMPLETE";
+})(CarbonFootprintConfigurationActivationRequirement || (exports.CarbonFootprintConfigurationActivationRequirement = CarbonFootprintConfigurationActivationRequirement = {}));

package/build/carbonbox/carbon-footprint-configurations/shared/domain/enums/CarbonFootprintConfigurationCompletionRequirement.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CarbonFootprintConfigurationCompletionRequirement = void 0;
+/**
+ * Requirements a carbon footprint configuration (corporate, event or
+ * product) must meet to move from `ACTIVE` to `COMPLETED`.
+ *
+ * Each member identifies ONE rule evaluated by
+ * `CarbonFootprintConfigurationCompletionPolicy`, listed in evaluation
+ * order. The `EXECUTION_PERIOD_*` members are corporate only: event and
+ * product footprints have no reporting window at footprint level.
+ *
+ * The detail needed to describe an unmet requirement travels in
+ * `CarbonFootprintConfigurationRequirementContext`.
+ */
+var CarbonFootprintConfigurationCompletionRequirement;
+(function (CarbonFootprintConfigurationCompletionRequirement) {
+    // ─── Gates (all footprint types) ──────────────────────────────────────────
+    CarbonFootprintConfigurationCompletionRequirement["CARBON_CLIENT_NOT_ENTITLED"] = "CARBON_CLIENT_NOT_ENTITLED";
+    CarbonFootprintConfigurationCompletionRequirement["CONFIGURATION_MUST_BE_ACTIVE"] = "CONFIGURATION_MUST_BE_ACTIVE";
+    // ─── Execution period (corporate) ────────────────────────────────────────
+    CarbonFootprintConfigurationCompletionRequirement["EXECUTION_PERIOD_END_DATE_REQUIRED"] = "EXECUTION_PERIOD_END_DATE_REQUIRED";
+    CarbonFootprintConfigurationCompletionRequirement["EXECUTION_PERIOD_END_DATE_INVALID_FORMAT"] = "EXECUTION_PERIOD_END_DATE_INVALID_FORMAT";
+    CarbonFootprintConfigurationCompletionRequirement["EXECUTION_PERIOD_NOT_ENDED"] = "EXECUTION_PERIOD_NOT_ENDED";
+    // ─── Calculation and data coverage (all footprint types) ─────────────────
+    CarbonFootprintConfigurationCompletionRequirement["ACTIVE_CALCULATION_PROCESSES_PRESENT"] = "ACTIVE_CALCULATION_PROCESSES_PRESENT";
+    CarbonFootprintConfigurationCompletionRequirement["SCOPE_1_OR_SCOPE_2_SUBMISSION_REQUIRED"] = "SCOPE_1_OR_SCOPE_2_SUBMISSION_REQUIRED";
+})(CarbonFootprintConfigurationCompletionRequirement || (exports.CarbonFootprintConfigurationCompletionRequirement = CarbonFootprintConfigurationCompletionRequirement = {}));

package/build/carbonbox/carbon-footprint-configurations/shared/domain/policies/CarbonFootprintConfigurationActivationPolicy.js

@@ -0,0 +1,349 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CarbonFootprintConfigurationActivationPolicy = void 0;
+const ReportingStandard_1 = require("../../../../shared/domain/enums/ReportingStandard");
+const DateTimeFormattingDomainService_1 = require("../../../../shared/domain/services/implementations/DateTimeFormattingDomainService");
+const MeasurementUnitType_1 = require("../../../event-configurations/domain/enums/MeasurementUnitType");
+const CarbonFootprintConfigurationActivationRequirement_1 = require("../enums/CarbonFootprintConfigurationActivationRequirement");
+const ConfigurationStatus_1 = require("../enums/ConfigurationStatus");
+/**
+ * Pure domain policy that decides whether a carbon footprint configuration
+ * (corporate, event or product) can move from `DRAFT` to `ACTIVE`, and if
+ * not, which requirements it does not meet.
+ *
+ * Why this exists: the activation rules used to live only inside the
+ * `Activate*` command handlers, which throw on the FIRST broken rule. The
+ * web needs the complete list up front (readiness) and the command must keep
+ * rejecting exactly as before. Both now call this policy: the command throws
+ * from the first item, the readiness query returns the whole list.
+ *
+ * Every `evaluate*` method returns the unmet requirements in evaluation
+ * order (empty list = ready to activate). The order reproduces the command
+ * handlers, so `list[0]` is always the error the handler raised before this
+ * policy existed:
+ *  1. `CARBON_CLIENT_NOT_ENTITLED` (context: `configurationId`) — the
+ *     entitlement gate runs before the handler body, so it goes first.
+ *  2. `CONFIGURATION_MUST_BE_DRAFT` (`configurationId`, `currentStatus`).
+ *     When the status is not `DRAFT` nothing else is evaluated.
+ *  3. Footprint-type specific structure, in handler order:
+ *     - corporate / product: `SEGMENT_CONFIGURATION_REQUIRED`; then, per
+ *       item, `SEGMENT_CONFIGURATION_SEGMENT_ID_REQUIRED` and
+ *       `SEGMENT_CONFIGURATION_EMISSION_SOURCE_REQUIRED` (`index`,
+ *       `segmentConfigurationId`).
+ *     - event: `LIFECYCLE_STAGE_CONFIGURATION_REQUIRED`; then, per item,
+ *       `LIFECYCLE_STAGE_CONFIGURATION_STAGE_ID_REQUIRED` and
+ *       `LIFECYCLE_STAGE_CONFIGURATION_EMISSION_SOURCE_REQUIRED` (`index`,
+ *       `lifecycleStageConfigurationId`); `EVENT_EDITION_REFERENCE_INCOMPLETE`;
+ *       `ANALYSIS_UNIT_REQUIRED` (suppresses the next two),
+ *       `ANALYSIS_UNIT_BENCHMARK_VALUE_INVALID` (finite and >= 0),
+ *       `ANALYSIS_UNIT_MEASUREMENT_UNIT_INVALID` (`receivedValue`).
+ *     - product: `PRODUCT_REFERENCE_INCOMPLETE`,
+ *       `SYSTEM_BOUNDARY_REFERENCE_INCOMPLETE`, `FUNCTIONAL_UNIT_REQUIRED`
+ *       (suppresses the next two), `FUNCTIONAL_UNIT_BENCHMARK_VALUE_INVALID`
+ *       (finite and >= 0), `FUNCTIONAL_UNIT_MEASUREMENT_UNIT_REQUIRED`.
+ *     - corporate execution period: `EXECUTION_PERIOD_START_DATE_REQUIRED`
+ *       or `EXECUTION_PERIOD_START_DATE_INVALID_FORMAT` (`startDate`,
+ *       `parseErrorMessage`); `EXECUTION_PERIOD_START_DATE_TOO_OLD`
+ *       (`startDate`, `earliestAllowedStartDate`: at most one year before
+ *       `facts.evaluatedAt`); `EXECUTION_PERIOD_END_DATE_INVALID_FORMAT`
+ *       (`endDate`, `parseErrorMessage`; only when an end date is set);
+ *       `EXECUTION_PERIOD_START_DATE_NOT_BEFORE_END_DATE` (`startDate`,
+ *       `endDate`). A date that is missing or cannot be parsed suppresses
+ *       the requirements that compare it.
+ *  4. Intensity indicators (all types): `INTENSITY_INDICATOR_CONFIGURATIONS_INVALID`
+ *     (not an array; suppresses the per-item checks); then, per item,
+ *     `INTENSITY_INDICATOR_ASSIGNMENT_REQUIRED`,
+ *     `INTENSITY_INDICATOR_TARGET_VALUE_NOT_POSITIVE` and
+ *     `INTENSITY_INDICATOR_BENCHMARK_VALUE_NOT_POSITIVE` (`index`).
+ *  5. Facilities (corporate only): `FACILITY_REQUIRED`; then
+ *     `FACILITY_REFERENCE_INCOMPLETE` for every reference without `id` or
+ *     `commercialBranchName` (`index`, `facilityId`, `commercialBranchName`);
+ *     then `FACILITY_NOT_FOUND` for every COMPLETE reference whose id is not
+ *     in `facts.existingFacilityIds` (`index`, `facilityId`,
+ *     `commercialBranchName`). All incomplete references are listed before
+ *     any missing one because the handler validated completeness of the
+ *     whole list before looking any facility up.
+ *  6. `CARBON_FOOTPRINT_OBJECTIVE_TOO_SHORT` (all types; `reportingStandard`,
+ *     `minimumLength`) — only for `ISO_14064_1` and `HYBRID`.
+ *  7. `OWNED_BY_CARBON_CLIENT_REFERENCE_INCOMPLETE` and
+ *     `CREATED_BY_STAKEHOLDER_REFERENCE_INCOMPLETE` (all types; both
+ *     references need `id` and `displayName`).
+ *
+ * Dates: execution period dates are `DD/MM/YYYY` strings parsed with the
+ * domain `DateTimeFormattingDomainService` (pure, no I/O), exactly as the
+ * handlers did; "now" is never read from the clock but taken from
+ * `facts.evaluatedAt`, so the result only depends on the arguments.
+ *
+ * The policy is intentionally a pure function — it does not load data,
+ * throw, or mutate. Facts that need I/O (entitlement, existing facilities)
+ * are gathered by the caller and passed in.
+ */
+class CarbonFootprintConfigurationActivationPolicy {
+    constructor() {
+        // Static-only — not instantiable.
+    }
+    static evaluateCorporateConfiguration(primitives, facts) {
+        const gateRequirements = CarbonFootprintConfigurationActivationPolicy.evaluateGates(primitives, facts.isCarbonClientEntitledToFootprintType);
+        if (!CarbonFootprintConfigurationActivationPolicy.isDraft(primitives)) {
+            return gateRequirements;
+        }
+        return [
+            ...gateRequirements,
+            ...CarbonFootprintConfigurationActivationPolicy.evaluateSegmentConfigurations(primitives.segmentConfigurations),
+            ...CarbonFootprintConfigurationActivationPolicy.evaluateExecutionPeriod(primitives.executionPeriod, facts.evaluatedAt),
+            ...CarbonFootprintConfigurationActivationPolicy.evaluateIntensityIndicatorConfigurations(primitives.intensityIndicatorConfigurations),
+            ...CarbonFootprintConfigurationActivationPolicy.evaluateFacilities(primitives.facilities, facts.existingFacilityIds),
+            ...CarbonFootprintConfigurationActivationPolicy.evaluateCarbonFootprintObjective(primitives),
+            ...CarbonFootprintConfigurationActivationPolicy.evaluateOwnershipReferences(primitives),
+        ];
+    }
+    static evaluateEventConfiguration(primitives, facts) {
+        const gateRequirements = CarbonFootprintConfigurationActivationPolicy.evaluateGates(primitives, facts.isCarbonClientEntitledToFootprintType);
+        if (!CarbonFootprintConfigurationActivationPolicy.isDraft(primitives)) {
+            return gateRequirements;
+        }
+        return [
+            ...gateRequirements,
+            ...CarbonFootprintConfigurationActivationPolicy.evaluateLifecycleStageConfigurations(primitives.eventEditionLifecycleStageConfigurations),
+            ...CarbonFootprintConfigurationActivationPolicy.evaluateEventEdition(primitives),
+            ...CarbonFootprintConfigurationActivationPolicy.evaluateAnalysisUnit(primitives),
+            ...CarbonFootprintConfigurationActivationPolicy.evaluateIntensityIndicatorConfigurations(primitives.intensityIndicatorConfigurations),
+            ...CarbonFootprintConfigurationActivationPolicy.evaluateCarbonFootprintObjective(primitives),
+            ...CarbonFootprintConfigurationActivationPolicy.evaluateOwnershipReferences(primitives),
+        ];
+    }
+    static evaluateProductConfiguration(primitives, facts) {
+        const gateRequirements = CarbonFootprintConfigurationActivationPolicy.evaluateGates(primitives, facts.isCarbonClientEntitledToFootprintType);
+        if (!CarbonFootprintConfigurationActivationPolicy.isDraft(primitives)) {
+            return gateRequirements;
+        }
+        return [
+            ...gateRequirements,
+            ...CarbonFootprintConfigurationActivationPolicy.evaluateSegmentConfigurations(primitives.segmentConfigurations),
+            ...CarbonFootprintConfigurationActivationPolicy.evaluateProduct(primitives),
+            ...CarbonFootprintConfigurationActivationPolicy.evaluateSystemBoundary(primitives),
+            ...CarbonFootprintConfigurationActivationPolicy.evaluateFunctionalUnit(primitives),
+            ...CarbonFootprintConfigurationActivationPolicy.evaluateIntensityIndicatorConfigurations(primitives.intensityIndicatorConfigurations),
+            ...CarbonFootprintConfigurationActivationPolicy.evaluateCarbonFootprintObjective(primitives),
+            ...CarbonFootprintConfigurationActivationPolicy.evaluateOwnershipReferences(primitives),
+        ];
+    }
+    static isDraft(primitives) {
+        return primitives.status === ConfigurationStatus_1.ConfigurationStatus.DRAFT;
+    }
+    static evaluateGates(primitives, isCarbonClientEntitledToFootprintType) {
+        const requirements = [];
+        if (!isCarbonClientEntitledToFootprintType) {
+            requirements.push(CarbonFootprintConfigurationActivationPolicy.unmet(CarbonFootprintConfigurationActivationRequirement_1.CarbonFootprintConfigurationActivationRequirement.CARBON_CLIENT_NOT_ENTITLED, { configurationId: primitives.id }));
+        }
+        if (!CarbonFootprintConfigurationActivationPolicy.isDraft(primitives)) {
+            requirements.push(CarbonFootprintConfigurationActivationPolicy.unmet(CarbonFootprintConfigurationActivationRequirement_1.CarbonFootprintConfigurationActivationRequirement.CONFIGURATION_MUST_BE_DRAFT, { configurationId: primitives.id, currentStatus: primitives.status }));
+        }
+        return requirements;
+    }
+    static evaluateSegmentConfigurations(segmentConfigurations) {
+        if (!Array.isArray(segmentConfigurations) || segmentConfigurations.length === 0) {
+            return [CarbonFootprintConfigurationActivationPolicy.unmet(CarbonFootprintConfigurationActivationRequirement_1.CarbonFootprintConfigurationActivationRequirement.SEGMENT_CONFIGURATION_REQUIRED)];
+        }
+        const requirements = [];
+        segmentConfigurations.forEach((segmentConfiguration, index) => {
+            if (!segmentConfiguration?.segment?.id) {
+                requirements.push(CarbonFootprintConfigurationActivationPolicy.unmet(CarbonFootprintConfigurationActivationRequirement_1.CarbonFootprintConfigurationActivationRequirement.SEGMENT_CONFIGURATION_SEGMENT_ID_REQUIRED, { index, segmentConfigurationId: segmentConfiguration?.id }));
+            }
+            if (!Array.isArray(segmentConfiguration?.emissionSourceConfigurations) || segmentConfiguration.emissionSourceConfigurations.length === 0) {
+                requirements.push(CarbonFootprintConfigurationActivationPolicy.unmet(CarbonFootprintConfigurationActivationRequirement_1.CarbonFootprintConfigurationActivationRequirement.SEGMENT_CONFIGURATION_EMISSION_SOURCE_REQUIRED, { index, segmentConfigurationId: segmentConfiguration?.id }));
+            }
+        });
+        return requirements;
+    }
+    static evaluateLifecycleStageConfigurations(lifecycleStageConfigurations) {
+        if (!Array.isArray(lifecycleStageConfigurations) || lifecycleStageConfigurations.length === 0) {
+            return [CarbonFootprintConfigurationActivationPolicy.unmet(CarbonFootprintConfigurationActivationRequirement_1.CarbonFootprintConfigurationActivationRequirement.LIFECYCLE_STAGE_CONFIGURATION_REQUIRED)];
+        }
+        const requirements = [];
+        lifecycleStageConfigurations.forEach((lifecycleStageConfiguration, index) => {
+            if (!lifecycleStageConfiguration?.stage?.id) {
+                requirements.push(CarbonFootprintConfigurationActivationPolicy.unmet(CarbonFootprintConfigurationActivationRequirement_1.CarbonFootprintConfigurationActivationRequirement.LIFECYCLE_STAGE_CONFIGURATION_STAGE_ID_REQUIRED, { index, lifecycleStageConfigurationId: lifecycleStageConfiguration?.id }));
+            }
+            if (!Array.isArray(lifecycleStageConfiguration?.emissionSourceConfigurations) || lifecycleStageConfiguration.emissionSourceConfigurations.length === 0) {
+                requirements.push(CarbonFootprintConfigurationActivationPolicy.unmet(CarbonFootprintConfigurationActivationRequirement_1.CarbonFootprintConfigurationActivationRequirement.LIFECYCLE_STAGE_CONFIGURATION_EMISSION_SOURCE_REQUIRED, { index, lifecycleStageConfigurationId: lifecycleStageConfiguration?.id }));
+            }
+        });
+        return requirements;
+    }
+    static evaluateEventEdition(primitives) {
+        const { eventEdition } = primitives;
+        if (!eventEdition || !eventEdition.id || !eventEdition.code || !eventEdition.name) {
+            return [CarbonFootprintConfigurationActivationPolicy.unmet(CarbonFootprintConfigurationActivationRequirement_1.CarbonFootprintConfigurationActivationRequirement.EVENT_EDITION_REFERENCE_INCOMPLETE)];
+        }
+        return [];
+    }
+    static evaluateAnalysisUnit(primitives) {
+        const { analysisUnit } = primitives;
+        if (!analysisUnit) {
+            return [CarbonFootprintConfigurationActivationPolicy.unmet(CarbonFootprintConfigurationActivationRequirement_1.CarbonFootprintConfigurationActivationRequirement.ANALYSIS_UNIT_REQUIRED)];
+        }
+        const requirements = [];
+        if (CarbonFootprintConfigurationActivationPolicy.isNotNonNegativeFiniteNumber(analysisUnit.benchmarkValue)) {
+            requirements.push(CarbonFootprintConfigurationActivationPolicy.unmet(CarbonFootprintConfigurationActivationRequirement_1.CarbonFootprintConfigurationActivationRequirement.ANALYSIS_UNIT_BENCHMARK_VALUE_INVALID));
+        }
+        if (!Object.values(MeasurementUnitType_1.MeasurementUnitType).includes(analysisUnit.measurementUnit)) {
+            requirements.push(CarbonFootprintConfigurationActivationPolicy.unmet(CarbonFootprintConfigurationActivationRequirement_1.CarbonFootprintConfigurationActivationRequirement.ANALYSIS_UNIT_MEASUREMENT_UNIT_INVALID, { receivedValue: String(analysisUnit.measurementUnit) }));
+        }
+        return requirements;
+    }
+    static evaluateProduct(primitives) {
+        const { product } = primitives;
+        if (!product || !product.id || !product.code || !product.name) {
+            return [CarbonFootprintConfigurationActivationPolicy.unmet(CarbonFootprintConfigurationActivationRequirement_1.CarbonFootprintConfigurationActivationRequirement.PRODUCT_REFERENCE_INCOMPLETE)];
+        }
+        return [];
+    }
+    static evaluateSystemBoundary(primitives) {
+        const { systemBoundary } = primitives;
+        if (!systemBoundary || !systemBoundary.id || !systemBoundary.code || !systemBoundary.name || !systemBoundary.type) {
+            return [CarbonFootprintConfigurationActivationPolicy.unmet(CarbonFootprintConfigurationActivationRequirement_1.CarbonFootprintConfigurationActivationRequirement.SYSTEM_BOUNDARY_REFERENCE_INCOMPLETE)];
+        }
+        return [];
+    }
+    static evaluateFunctionalUnit(primitives) {
+        const { functionalUnit } = primitives;
+        if (!functionalUnit) {
+            return [CarbonFootprintConfigurationActivationPolicy.unmet(CarbonFootprintConfigurationActivationRequirement_1.CarbonFootprintConfigurationActivationRequirement.FUNCTIONAL_UNIT_REQUIRED)];
+        }
+        const requirements = [];
+        if (CarbonFootprintConfigurationActivationPolicy.isNotNonNegativeFiniteNumber(functionalUnit.benchmarkValue)) {
+            requirements.push(CarbonFootprintConfigurationActivationPolicy.unmet(CarbonFootprintConfigurationActivationRequirement_1.CarbonFootprintConfigurationActivationRequirement.FUNCTIONAL_UNIT_BENCHMARK_VALUE_INVALID));
+        }
+        if (typeof functionalUnit.measurementUnit !== 'string' || functionalUnit.measurementUnit.trim() === '') {
+            requirements.push(CarbonFootprintConfigurationActivationPolicy.unmet(CarbonFootprintConfigurationActivationRequirement_1.CarbonFootprintConfigurationActivationRequirement.FUNCTIONAL_UNIT_MEASUREMENT_UNIT_REQUIRED));
+        }
+        return requirements;
+    }
+    static evaluateExecutionPeriod(executionPeriod, evaluatedAt) {
+        const requirements = [];
+        const startDateValue = executionPeriod?.startDate || '';
+        const endDateValue = executionPeriod?.endDate || '';
+        const startDateResult = startDateValue === ''
+            ? null
+            : CarbonFootprintConfigurationActivationPolicy.DATE_TIME_FORMATTING.parseDateString(startDateValue);
+        const endDateResult = endDateValue === ''
+            ? null
+            : CarbonFootprintConfigurationActivationPolicy.DATE_TIME_FORMATTING.parseDateString(endDateValue);
+        if (startDateResult === null) {
+            requirements.push(CarbonFootprintConfigurationActivationPolicy.unmet(CarbonFootprintConfigurationActivationRequirement_1.CarbonFootprintConfigurationActivationRequirement.EXECUTION_PERIOD_START_DATE_REQUIRED));
+        }
+        else {
+            requirements.push(...startDateResult.fold((error) => [CarbonFootprintConfigurationActivationPolicy.unmet(CarbonFootprintConfigurationActivationRequirement_1.CarbonFootprintConfigurationActivationRequirement.EXECUTION_PERIOD_START_DATE_INVALID_FORMAT, { startDate: startDateValue, parseErrorMessage: error.message })], (startDate) => CarbonFootprintConfigurationActivationPolicy.evaluateStartDateAge(startDateValue, startDate, evaluatedAt)));
+        }
+        if (endDateResult !== null) {
+            requirements.push(...endDateResult.fold((error) => [CarbonFootprintConfigurationActivationPolicy.unmet(CarbonFootprintConfigurationActivationRequirement_1.CarbonFootprintConfigurationActivationRequirement.EXECUTION_PERIOD_END_DATE_INVALID_FORMAT, { endDate: endDateValue, parseErrorMessage: error.message })], () => []));
+        }
+        const startDate = startDateResult?.getRight();
+        const endDate = endDateResult?.getRight();
+        if (startDate !== undefined && endDate !== undefined && startDate >= endDate) {
+            requirements.push(CarbonFootprintConfigurationActivationPolicy.unmet(CarbonFootprintConfigurationActivationRequirement_1.CarbonFootprintConfigurationActivationRequirement.EXECUTION_PERIOD_START_DATE_NOT_BEFORE_END_DATE, { startDate: startDateValue, endDate: endDateValue }));
+        }
+        return requirements;
+    }
+    /**
+     * The start date may be at most `MAXIMUM_START_DATE_AGE_IN_YEARS` before
+     * the evaluation instant (same calendar arithmetic as the handler:
+     * `setFullYear(year - 1)` on a copy of "now").
+     */
+    static evaluateStartDateAge(startDateValue, startDate, evaluatedAt) {
+        const earliestAllowedStartDate = new Date(evaluatedAt.getTime());
+        earliestAllowedStartDate.setFullYear(earliestAllowedStartDate.getFullYear() - CarbonFootprintConfigurationActivationPolicy.MAXIMUM_START_DATE_AGE_IN_YEARS);
+        if (startDate < earliestAllowedStartDate) {
+            return [CarbonFootprintConfigurationActivationPolicy.unmet(CarbonFootprintConfigurationActivationRequirement_1.CarbonFootprintConfigurationActivationRequirement.EXECUTION_PERIOD_START_DATE_TOO_OLD, {
+                    startDate: startDateValue,
+                    earliestAllowedStartDate: CarbonFootprintConfigurationActivationPolicy.DATE_TIME_FORMATTING
+                        .formatDateToString(earliestAllowedStartDate)
+                        .getRight(),
+                })];
+        }
+        return [];
+    }
+    static evaluateIntensityIndicatorConfigurations(intensityIndicatorConfigurations) {
+        if (!Array.isArray(intensityIndicatorConfigurations)) {
+            return [CarbonFootprintConfigurationActivationPolicy.unmet(CarbonFootprintConfigurationActivationRequirement_1.CarbonFootprintConfigurationActivationRequirement.INTENSITY_INDICATOR_CONFIGURATIONS_INVALID)];
+        }
+        const requirements = [];
+        intensityIndicatorConfigurations.forEach((intensityIndicatorConfiguration, index) => {
+            if (!intensityIndicatorConfiguration?.assignedIntensityIndicator?.id) {
+                requirements.push(CarbonFootprintConfigurationActivationPolicy.unmet(CarbonFootprintConfigurationActivationRequirement_1.CarbonFootprintConfigurationActivationRequirement.INTENSITY_INDICATOR_ASSIGNMENT_REQUIRED, { index }));
+            }
+            if (CarbonFootprintConfigurationActivationPolicy.isNotPositiveNumber(intensityIndicatorConfiguration?.targetValue)) {
+                requirements.push(CarbonFootprintConfigurationActivationPolicy.unmet(CarbonFootprintConfigurationActivationRequirement_1.CarbonFootprintConfigurationActivationRequirement.INTENSITY_INDICATOR_TARGET_VALUE_NOT_POSITIVE, { index }));
+            }
+            if (CarbonFootprintConfigurationActivationPolicy.isNotPositiveNumber(intensityIndicatorConfiguration?.benchmarkValue)) {
+                requirements.push(CarbonFootprintConfigurationActivationPolicy.unmet(CarbonFootprintConfigurationActivationRequirement_1.CarbonFootprintConfigurationActivationRequirement.INTENSITY_INDICATOR_BENCHMARK_VALUE_NOT_POSITIVE, { index }));
+            }
+        });
+        return requirements;
+    }
+    static evaluateFacilities(facilities, existingFacilityIds) {
+        if (!Array.isArray(facilities) || facilities.length === 0) {
+            return [CarbonFootprintConfigurationActivationPolicy.unmet(CarbonFootprintConfigurationActivationRequirement_1.CarbonFootprintConfigurationActivationRequirement.FACILITY_REQUIRED)];
+        }
+        const incompleteReferenceRequirements = [];
+        const missingFacilityRequirements = [];
+        facilities.forEach((facility, index) => {
+            if (!facility?.id || !facility.commercialBranchName) {
+                incompleteReferenceRequirements.push(CarbonFootprintConfigurationActivationPolicy.unmet(CarbonFootprintConfigurationActivationRequirement_1.CarbonFootprintConfigurationActivationRequirement.FACILITY_REFERENCE_INCOMPLETE, { index, facilityId: facility?.id, commercialBranchName: facility?.commercialBranchName }));
+            }
+            else if (!existingFacilityIds.includes(facility.id)) {
+                missingFacilityRequirements.push(CarbonFootprintConfigurationActivationPolicy.unmet(CarbonFootprintConfigurationActivationRequirement_1.CarbonFootprintConfigurationActivationRequirement.FACILITY_NOT_FOUND, { index, facilityId: facility.id, commercialBranchName: facility.commercialBranchName }));
+            }
+        });
+        return [...incompleteReferenceRequirements, ...missingFacilityRequirements];
+    }
+    static evaluateCarbonFootprintObjective(primitives) {
+        const { reportingStandard, carbonFootprintObjective } = primitives;
+        const minimumLength = CarbonFootprintConfigurationActivationPolicy.MINIMUM_CARBON_FOOTPRINT_OBJECTIVE_LENGTH;
+        if (!CarbonFootprintConfigurationActivationPolicy.STANDARDS_REQUIRING_DETAILED_OBJECTIVE.includes(reportingStandard)) {
+            return [];
+        }
+        if (!carbonFootprintObjective || carbonFootprintObjective.length < minimumLength) {
+            return [CarbonFootprintConfigurationActivationPolicy.unmet(CarbonFootprintConfigurationActivationRequirement_1.CarbonFootprintConfigurationActivationRequirement.CARBON_FOOTPRINT_OBJECTIVE_TOO_SHORT, { reportingStandard, minimumLength })];
+        }
+        return [];
+    }
+    static evaluateOwnershipReferences(primitives) {
+        const { ownedByCarbonClient, createdByStakeholder } = primitives;
+        const requirements = [];
+        if (!ownedByCarbonClient || !ownedByCarbonClient.id || !ownedByCarbonClient.displayName) {
+            requirements.push(CarbonFootprintConfigurationActivationPolicy.unmet(CarbonFootprintConfigurationActivationRequirement_1.CarbonFootprintConfigurationActivationRequirement.OWNED_BY_CARBON_CLIENT_REFERENCE_INCOMPLETE));
+        }
+        if (!createdByStakeholder || !createdByStakeholder.id || !createdByStakeholder.displayName) {
+            requirements.push(CarbonFootprintConfigurationActivationPolicy.unmet(CarbonFootprintConfigurationActivationRequirement_1.CarbonFootprintConfigurationActivationRequirement.CREATED_BY_STAKEHOLDER_REFERENCE_INCOMPLETE));
+        }
+        return requirements;
+    }
+    /**
+     * Same predicate as the handlers' benchmark check: rejects non-numbers,
+     * `NaN`, `±Infinity` and negatives.
+     */
+    static isNotNonNegativeFiniteNumber(value) {
+        return typeof value !== 'number' || !Number.isFinite(value) || value < 0;
+    }
+    /**
+     * Same predicate as the handlers' intensity indicator check: rejects
+     * non-numbers and values `<= 0`. `NaN` is NOT rejected (`NaN <= 0` is
+     * false), exactly as before.
+     */
+    static isNotPositiveNumber(value) {
+        return typeof value !== 'number' || value <= 0;
+    }
+    static unmet(code, context = {}) {
+        return { code, context };
+    }
+}
+exports.CarbonFootprintConfigurationActivationPolicy = CarbonFootprintConfigurationActivationPolicy;
+CarbonFootprintConfigurationActivationPolicy.MINIMUM_CARBON_FOOTPRINT_OBJECTIVE_LENGTH = 10;
+CarbonFootprintConfigurationActivationPolicy.MAXIMUM_START_DATE_AGE_IN_YEARS = 1;
+CarbonFootprintConfigurationActivationPolicy.STANDARDS_REQUIRING_DETAILED_OBJECTIVE = [
+    ReportingStandard_1.ReportingStandard.ISO_14064_1,
+    ReportingStandard_1.ReportingStandard.HYBRID,
+];
+CarbonFootprintConfigurationActivationPolicy.DATE_TIME_FORMATTING = DateTimeFormattingDomainService_1.DateTimeFormattingDomainService.create();

package/build/carbonbox/carbon-footprint-configurations/shared/domain/policies/CarbonFootprintConfigurationCompletionPolicy.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CarbonFootprintConfigurationCompletionPolicy = void 0;
+const GHGScope_1 = require("../../../../shared/domain/enums/GHGScope");
+const ReportingStandard_1 = require("../../../../shared/domain/enums/ReportingStandard");
+const DateTimeFormattingDomainService_1 = require("../../../../shared/domain/services/implementations/DateTimeFormattingDomainService");
+const CarbonFootprintConfigurationCompletionRequirement_1 = require("../enums/CarbonFootprintConfigurationCompletionRequirement");
+const ConfigurationStatus_1 = require("../enums/ConfigurationStatus");
+/**
+ * Pure domain policy that decides whether a carbon footprint configuration
+ * (corporate, event or product) can move from `ACTIVE` to `COMPLETED`, and
+ * if not, which requirements it does not meet.
+ *
+ * Why this exists: the completion rules used to live only inside the
+ * `Complete*` command handlers, which throw on the FIRST broken rule. The
+ * command (throws from `list[0]`) and the readiness query (returns the whole
+ * list) now share this single source of truth.
+ *
+ * Every `evaluate*` method returns the unmet requirements in evaluation
+ * order (empty list = ready to complete), reproducing the handlers so that
+ * `list[0]` is always the error they raised before:
+ *  1. `CARBON_CLIENT_NOT_ENTITLED` (context: `configurationId`) — the
+ *     entitlement gate runs before the handler body, so it goes first.
+ *  2. `CONFIGURATION_MUST_BE_ACTIVE` (`configurationId`, `currentStatus`).
+ *     When the status is not `ACTIVE` nothing else is evaluated.
+ *  3. Corporate only — the execution period must have ended:
+ *     `EXECUTION_PERIOD_END_DATE_REQUIRED`;
+ *     `EXECUTION_PERIOD_END_DATE_INVALID_FORMAT` (`endDate`,
+ *     `parseErrorMessage`); `EXECUTION_PERIOD_NOT_ENDED` (`endDate`,
+ *     `evaluatedAt` as ISO-8601) when `facts.evaluatedAt` is before the end
+ *     date. A missing or unparseable end date suppresses the last one.
+ *     Event and product footprints have no reporting window at footprint
+ *     level, so they skip this step.
+ *  4. `ACTIVE_CALCULATION_PROCESSES_PRESENT` (`activeCalculationProcessCount`)
+ *     when calculation processes are still `SCHEDULED`, `QUEUED` or
+ *     `RUNNING`.
+ *  5. `SCOPE_1_OR_SCOPE_2_SUBMISSION_REQUIRED` (`reportingStandard`,
+ *     `emissionScopesFound`: distinct scopes in first-seen order, empty when
+ *     there are no submissions) — only for `GHG_PROTOCOL` and `HYBRID`, when
+ *     no activity data submission (any status) reports `SCOPE_1` or
+ *     `SCOPE_2`.
+ *
+ * Dates: the end date is a `DD/MM/YYYY` string parsed with the domain
+ * `DateTimeFormattingDomainService` (pure, no I/O), exactly as the handler
+ * did; "now" is taken from `facts.evaluatedAt`, never from the clock.
+ *
+ * The policy is intentionally a pure function — it does not load data,
+ * throw, or mutate. Facts that need I/O (entitlement, calculation processes,
+ * submissions) are gathered by the caller and passed in.
+ */
+class CarbonFootprintConfigurationCompletionPolicy {
+    constructor() {
+        // Static-only — not instantiable.
+    }
+    static evaluateCorporateConfiguration(primitives, facts) {
+        const gateRequirements = CarbonFootprintConfigurationCompletionPolicy.evaluateGates(primitives, facts);
+        if (!CarbonFootprintConfigurationCompletionPolicy.isActive(primitives)) {
+            return gateRequirements;
+        }
+        return [
+            ...gateRequirements,
+            ...CarbonFootprintConfigurationCompletionPolicy.evaluateExecutionPeriodEnded(primitives.executionPeriod, facts.evaluatedAt),
+            ...CarbonFootprintConfigurationCompletionPolicy.evaluateCalculationAndCoverage(primitives, facts),
+        ];
+    }
+    static evaluateEventConfiguration(primitives, facts) {
+        return CarbonFootprintConfigurationCompletionPolicy.evaluateConfigurationWithoutExecutionPeriod(primitives, facts);
+    }
+    static evaluateProductConfiguration(primitives, facts) {
+        return CarbonFootprintConfigurationCompletionPolicy.evaluateConfigurationWithoutExecutionPeriod(primitives, facts);
+    }
+    static evaluateConfigurationWithoutExecutionPeriod(primitives, facts) {
+        const gateRequirements = CarbonFootprintConfigurationCompletionPolicy.evaluateGates(primitives, facts);
+        if (!CarbonFootprintConfigurationCompletionPolicy.isActive(primitives)) {
+            return gateRequirements;
+        }
+        return [
+            ...gateRequirements,
+            ...CarbonFootprintConfigurationCompletionPolicy.evaluateCalculationAndCoverage(primitives, facts),
+        ];
+    }
+    static isActive(primitives) {
+        return primitives.status === ConfigurationStatus_1.ConfigurationStatus.ACTIVE;
+    }
+    static evaluateGates(primitives, facts) {
+        const requirements = [];
+        if (!facts.isCarbonClientEntitledToFootprintType) {
+            requirements.push(CarbonFootprintConfigurationCompletionPolicy.unmet(CarbonFootprintConfigurationCompletionRequirement_1.CarbonFootprintConfigurationCompletionRequirement.CARBON_CLIENT_NOT_ENTITLED, { configurationId: primitives.id }));
+        }
+        if (!CarbonFootprintConfigurationCompletionPolicy.isActive(primitives)) {
+            requirements.push(CarbonFootprintConfigurationCompletionPolicy.unmet(CarbonFootprintConfigurationCompletionRequirement_1.CarbonFootprintConfigurationCompletionRequirement.CONFIGURATION_MUST_BE_ACTIVE, { configurationId: primitives.id, currentStatus: primitives.status }));
+        }
+        return requirements;
+    }
+    static evaluateExecutionPeriodEnded(executionPeriod, evaluatedAt) {
+        const endDateValue = executionPeriod?.endDate || '';
+        if (endDateValue === '') {
+            return [CarbonFootprintConfigurationCompletionPolicy.unmet(CarbonFootprintConfigurationCompletionRequirement_1.CarbonFootprintConfigurationCompletionRequirement.EXECUTION_PERIOD_END_DATE_REQUIRED)];
+        }
+        return CarbonFootprintConfigurationCompletionPolicy.DATE_TIME_FORMATTING
+            .parseDateString(endDateValue)
+            .fold((error) => [CarbonFootprintConfigurationCompletionPolicy.unmet(CarbonFootprintConfigurationCompletionRequirement_1.CarbonFootprintConfigurationCompletionRequirement.EXECUTION_PERIOD_END_DATE_INVALID_FORMAT, { endDate: endDateValue, parseErrorMessage: error.message })], (endDate) => CarbonFootprintConfigurationCompletionPolicy.evaluateEndDateReached(endDateValue, endDate, evaluatedAt));
+    }
+    static evaluateEndDateReached(endDateValue, endDate, evaluatedAt) {
+        if (evaluatedAt < endDate) {
+            return [CarbonFootprintConfigurationCompletionPolicy.unmet(CarbonFootprintConfigurationCompletionRequirement_1.CarbonFootprintConfigurationCompletionRequirement.EXECUTION_PERIOD_NOT_ENDED, { endDate: endDateValue, evaluatedAt: evaluatedAt.toISOString() })];
+        }
+        return [];
+    }
+    static evaluateCalculationAndCoverage(primitives, facts) {
+        return [
+            ...CarbonFootprintConfigurationCompletionPolicy.evaluateActiveCalculationProcesses(facts.activeCalculationProcessCount),
+            ...CarbonFootprintConfigurationCompletionPolicy.evaluateScopeCoverage(primitives.reportingStandard, facts),
+        ];
+    }
+    static evaluateActiveCalculationProcesses(activeCalculationProcessCount) {
+        if (activeCalculationProcessCount > 0) {
+            return [CarbonFootprintConfigurationCompletionPolicy.unmet(CarbonFootprintConfigurationCompletionRequirement_1.CarbonFootprintConfigurationCompletionRequirement.ACTIVE_CALCULATION_PROCESSES_PRESENT, { activeCalculationProcessCount })];
+        }
+        return [];
+    }
+    /**
+     * GHG Protocol coverage rule: the reporting period must include at least
+     * one Scope 1 or Scope 2 emission; Scope 3 alone is not a valid GHG
+     * Protocol report. The scope is declared per activity data submission.
+     */
+    static evaluateScopeCoverage(reportingStandard, facts) {
+        if (!CarbonFootprintConfigurationCompletionPolicy.STANDARDS_REQUIRING_SCOPE_1_OR_SCOPE_2_COVERAGE.includes(reportingStandard)) {
+            return [];
+        }
+        const { emissionScopesOfSubmissions } = facts;
+        const hasScope1OrScope2Submission = emissionScopesOfSubmissions.some((emissionScope) => CarbonFootprintConfigurationCompletionPolicy.SCOPES_SATISFYING_COVERAGE.includes(emissionScope));
+        if (hasScope1OrScope2Submission) {
+            return [];
+        }
+        return [CarbonFootprintConfigurationCompletionPolicy.unmet(CarbonFootprintConfigurationCompletionRequirement_1.CarbonFootprintConfigurationCompletionRequirement.SCOPE_1_OR_SCOPE_2_SUBMISSION_REQUIRED, { reportingStandard, emissionScopesFound: Array.from(new Set(emissionScopesOfSubmissions)) })];
+    }
+    static unmet(code, context = {}) {
+        return { code, context };
+    }
+}
+exports.CarbonFootprintConfigurationCompletionPolicy = CarbonFootprintConfigurationCompletionPolicy;
+CarbonFootprintConfigurationCompletionPolicy.STANDARDS_REQUIRING_SCOPE_1_OR_SCOPE_2_COVERAGE = [
+    ReportingStandard_1.ReportingStandard.GHG_PROTOCOL,
+    ReportingStandard_1.ReportingStandard.HYBRID,
+];
+CarbonFootprintConfigurationCompletionPolicy.SCOPES_SATISFYING_COVERAGE = [
+    GHGScope_1.GHGScope.SCOPE_1,
+    GHGScope_1.GHGScope.SCOPE_2,
+];
+CarbonFootprintConfigurationCompletionPolicy.DATE_TIME_FORMATTING = DateTimeFormattingDomainService_1.DateTimeFormattingDomainService.create();

package/build/carbonbox/carbon-footprint-configurations/shared/domain/types/CarbonFootprintConfigurationActivationFacts.js

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

package/build/carbonbox/carbon-footprint-configurations/shared/domain/types/CarbonFootprintConfigurationCompletionFacts.js

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

package/build/carbonbox/carbon-footprint-configurations/shared/domain/types/CarbonFootprintConfigurationRequirementContext.js

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

package/build/carbonbox/carbon-footprint-configurations/shared/domain/types/CorporateCarbonFootprintConfigurationActivationFacts.js

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

package/build/carbonbox/carbon-footprint-configurations/shared/domain/types/UnmetCarbonFootprintConfigurationActivationRequirement.js

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

package/build/carbonbox/carbon-footprint-configurations/shared/domain/types/UnmetCarbonFootprintConfigurationCompletionRequirement.js

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