@carbonbox/domain 0.28.2 → 0.29.1

package/build/carbonbox/purchase-management-system/purchase-contracts/domain/exceptions/InvalidContractStatusError.js

@@ -1,19 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidContractStatusError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidContractStatusError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+/**
+ * Exception thrown when an invalid contract status is provided
+ * This error occurs when the contract status doesn't match allowed values
+ *
+ * Error code: CBX-PMS-002
+ * @since 1.0.0
+ */
+class InvalidContractStatusError extends CodedRootError_1.CodedRootError {
     constructor(contractStatus, validStatuses) {
+        const errorCode = ErrorCode_1.ErrorCode.INVALID_CONTRACT_STATUS;
         const validStatusesText = validStatuses.join(', ');
-        const message = `Invalid contract status '${contractStatus}'. Valid contract statuses are: ${validStatusesText}`;
-        super(message);
+        const technicalMessage = `Invalid contract status '${contractStatus}'. Valid contract statuses are: ${validStatusesText}`;
+        const context = {
+            providedStatus: contractStatus,
+            validStatuses,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid contract statuses: ${validStatusesText}`,
+            'Common statuses include: DRAFT, ACTIVE, SUSPENDED, TERMINATED, EXPIRED',
+            'Check the contract lifecycle for valid status transitions',
+            'Contact contract administration for status change requests',
+        ];
+        super(errorCode, technicalMessage, context, suggestions);
         this.name = 'InvalidContractStatusError';
     }
     static create(contractStatus, validStatuses) {
         return new InvalidContractStatusError(contractStatus, validStatuses);
     }
-    logError() {
-        return `${this.name}: ${this.message}`;
-    }
 }
 exports.InvalidContractStatusError = InvalidContractStatusError;

package/build/carbonbox/purchase-management-system/purchase-contracts/domain/exceptions/InvalidPaymentTermsError.js

@@ -1,19 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidPaymentTermsError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidPaymentTermsError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+/**
+ * Exception thrown when invalid payment terms are provided for a contract
+ * This error occurs when the payment terms don't match allowed values
+ *
+ * Error code: CBX-PMS-003
+ * @since 1.0.0
+ */
+class InvalidPaymentTermsError extends CodedRootError_1.CodedRootError {
     constructor(paymentTerms, validTerms) {
+        const errorCode = ErrorCode_1.ErrorCode.INVALID_PAYMENT_TERMS;
         const validTermsText = validTerms.join(', ');
-        const message = `Invalid payment terms '${paymentTerms}'. Valid payment terms are: ${validTermsText}`;
-        super(message);
+        const technicalMessage = `Invalid payment terms '${paymentTerms}'. Valid payment terms are: ${validTermsText}`;
+        const context = {
+            providedTerms: paymentTerms,
+            validTerms,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid payment terms: ${validTermsText}`,
+            'Common payment terms include: NET30, NET60, NET90, IMMEDIATE',
+            'Check contract requirements for specific payment terms',
+            'Contact the finance team for special payment term requests',
+        ];
+        super(errorCode, technicalMessage, context, suggestions);
         this.name = 'InvalidPaymentTermsError';
     }
     static create(paymentTerms, validTerms) {
         return new InvalidPaymentTermsError(paymentTerms, validTerms);
     }
-    logError() {
-        return `${this.name}: ${this.message}`;
-    }
 }
 exports.InvalidPaymentTermsError = InvalidPaymentTermsError;

package/build/carbonbox/reporting/report-instances/domain/value-objects/ReportInstanceId.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReportInstanceId = 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");
+class ReportInstanceId extends AggregateId_1.AggregateId {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, ReportInstanceId.PROPERTY_NAME);
+    }
+    static create(value) {
+        AggregateId_1.AggregateId.guardAgainstEmptyValue(value, ReportInstanceId.PROPERTY_NAME);
+        AggregateId_1.AggregateId.guardAgainstInvalidType(value, ReportInstanceId.PROPERTY_NAME);
+        AggregateId_1.AggregateId.guardAgainstInvalidId(value, ReportInstanceId.PROPERTY_NAME);
+        // Validate that the prefix is valid for ReportInstance
+        ReportInstanceId.guardAgainstInvalidPrefix(value);
+        return new ReportInstanceId(value, false);
+    }
+    /**
+     * Validates that the UUID has a valid ReportInstance prefix
+     */
+    static guardAgainstInvalidPrefix(value) {
+        try {
+            const tempInstance = new ReportInstanceId(value, true);
+            const prefix = tempInstance.extractPrefix();
+            if (ReportInstanceId.VALID_PREFIXES.includes(prefix) === false) {
+                throw InvalidAggregatePrefixError_1.InvalidAggregatePrefixError.create(value, 'ReportInstance', prefix, ReportInstanceId.VALID_PREFIXES, ReportInstanceId.PROPERTY_NAME);
+            }
+        }
+        catch (error) {
+            if (error instanceof InvalidAggregatePrefixError_1.InvalidAggregatePrefixError) {
+                throw error;
+            }
+            if (error instanceof Error) {
+                throw InvalidAggregatePrefixError_1.InvalidAggregatePrefixError.create(value, 'ReportInstance', 'UNKNOWN', ReportInstanceId.VALID_PREFIXES, ReportInstanceId.PROPERTY_NAME);
+            }
+            throw error;
+        }
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new ReportInstanceId(value, true);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.ReportInstanceId = ReportInstanceId;
+ReportInstanceId.PROPERTY_NAME = 'id';
+ReportInstanceId.VALID_PREFIXES = [
+    SemanticUuidPrefix_1.SemanticUuidPrefix.RPT_INSTANCE,
+];

package/build/carbonbox/reporting/report-templates/domain/enums/ReportTemplateStatus.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReportTemplateStatus = void 0;
+/**
+ * Report template status enumeration
+ * Defines the lifecycle states of a report template
+ */
+var ReportTemplateStatus;
+(function (ReportTemplateStatus) {
+    /**
+     * Draft - Template is being edited
+     */
+    ReportTemplateStatus["DRAFT"] = "DRAFT";
+    /**
+     * Active - Template is available for use
+     */
+    ReportTemplateStatus["ACTIVE"] = "ACTIVE";
+    /**
+     * Deprecated - Template is no longer recommended but still accessible
+     */
+    ReportTemplateStatus["DEPRECATED"] = "DEPRECATED";
+    /**
+     * Archived - Template is soft deleted
+     */
+    ReportTemplateStatus["ARCHIVED"] = "ARCHIVED";
+})(ReportTemplateStatus || (exports.ReportTemplateStatus = ReportTemplateStatus = {}));

package/build/carbonbox/reporting/report-templates/domain/types/ReportTemplatePrimitives.js

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

package/build/carbonbox/reporting/report-templates/domain/types/ReportTemplateProps.js

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

package/build/carbonbox/reporting/report-templates/domain/value-objects/ReportTemplateId.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReportTemplateId = 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");
+class ReportTemplateId extends AggregateId_1.AggregateId {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, ReportTemplateId.PROPERTY_NAME);
+    }
+    static create(value) {
+        AggregateId_1.AggregateId.guardAgainstEmptyValue(value, ReportTemplateId.PROPERTY_NAME);
+        AggregateId_1.AggregateId.guardAgainstInvalidType(value, ReportTemplateId.PROPERTY_NAME);
+        AggregateId_1.AggregateId.guardAgainstInvalidId(value, ReportTemplateId.PROPERTY_NAME);
+        // Validate that the prefix is valid for ReportTemplate
+        ReportTemplateId.guardAgainstInvalidPrefix(value);
+        return new ReportTemplateId(value, false);
+    }
+    /**
+     * Validates that the UUID has a valid ReportTemplate prefix
+     */
+    static guardAgainstInvalidPrefix(value) {
+        try {
+            const tempInstance = new ReportTemplateId(value, true);
+            const prefix = tempInstance.extractPrefix();
+            if (ReportTemplateId.VALID_PREFIXES.includes(prefix) === false) {
+                throw InvalidAggregatePrefixError_1.InvalidAggregatePrefixError.create(value, 'ReportTemplate', prefix, ReportTemplateId.VALID_PREFIXES, ReportTemplateId.PROPERTY_NAME);
+            }
+        }
+        catch (error) {
+            if (error instanceof InvalidAggregatePrefixError_1.InvalidAggregatePrefixError) {
+                throw error;
+            }
+            if (error instanceof Error) {
+                throw InvalidAggregatePrefixError_1.InvalidAggregatePrefixError.create(value, 'ReportTemplate', 'UNKNOWN', ReportTemplateId.VALID_PREFIXES, ReportTemplateId.PROPERTY_NAME);
+            }
+            throw error;
+        }
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new ReportTemplateId(value, true);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.ReportTemplateId = ReportTemplateId;
+ReportTemplateId.PROPERTY_NAME = 'id';
+ReportTemplateId.VALID_PREFIXES = [
+    SemanticUuidPrefix_1.SemanticUuidPrefix.RPT_TEMPLATE,
+];

package/build/carbonbox/reporting/shared/domain/enums/BlockNature.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockNature = void 0;
+/**
+ * Block nature enumeration
+ * Defines how each block in a report template should be filled
+ */
+var BlockNature;
+(function (BlockNature) {
+    /**
+     * Fixed content - Static text defined at template level
+     * Can be parametrized by country or standard
+     */
+    BlockNature["FIXED"] = "FIXED";
+    /**
+     * Curated bank - Content selected from pre-approved options
+     * Host provides options, client selects or adapts
+     */
+    BlockNature["CURATED_BANK"] = "CURATED_BANK";
+    /**
+     * Client input - Direct input from the client
+     * Collected via questionnaire with validation limits
+     */
+    BlockNature["CLIENT_INPUT"] = "CLIENT_INPUT";
+    /**
+     * Data bound - Automatic binding to snapshot data
+     * References specific data points (aggregations, factors, etc.)
+     */
+    BlockNature["DATA_BOUND"] = "DATA_BOUND";
+})(BlockNature || (exports.BlockNature = BlockNature = {}));

package/build/carbonbox/reporting/shared/domain/enums/DataBindingSource.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataBindingSource = void 0;
+/**
+ * Data binding source enumeration
+ * Defines all possible data sources for DATA_BOUND blocks
+ * This is a closed catalog to ensure determinism
+ */
+var DataBindingSource;
+(function (DataBindingSource) {
+    // Client Profile
+    DataBindingSource["CLIENT_PROFILE_NAME"] = "client.profile.name";
+    DataBindingSource["CLIENT_PROFILE_LEGAL_NAME"] = "client.profile.legalBusinessName";
+    DataBindingSource["CLIENT_PROFILE_TAX_ID"] = "client.profile.taxId";
+    DataBindingSource["CLIENT_PROFILE_COUNTRY"] = "client.profile.country";
+    DataBindingSource["CLIENT_PROFILE_ADDRESS"] = "client.profile.address";
+    DataBindingSource["CLIENT_PROFILE_CITY"] = "client.profile.city";
+    DataBindingSource["CLIENT_PROFILE_POSTAL_CODE"] = "client.profile.postalCode";
+    DataBindingSource["CLIENT_PROFILE_WEBSITE"] = "client.profile.website";
+    DataBindingSource["CLIENT_PROFILE_INDUSTRY"] = "client.profile.industry";
+    // Period
+    DataBindingSource["PERIOD_START_DATE"] = "period.startDate";
+    DataBindingSource["PERIOD_END_DATE"] = "period.endDate";
+    DataBindingSource["PERIOD_DURATION_MONTHS"] = "period.durationMonths";
+    DataBindingSource["PERIOD_YEAR"] = "period.year";
+    // Aggregations - Total
+    DataBindingSource["AGGREGATION_TOTAL"] = "aggregation.total";
+    DataBindingSource["AGGREGATION_TOTAL_TCO2E"] = "aggregation.totalTCO2e";
+    // Aggregations - By Scope
+    DataBindingSource["AGGREGATION_SCOPE_1"] = "aggregation.scope1";
+    DataBindingSource["AGGREGATION_SCOPE_2"] = "aggregation.scope2";
+    DataBindingSource["AGGREGATION_SCOPE_3"] = "aggregation.scope3";
+    DataBindingSource["AGGREGATION_BY_SCOPE"] = "aggregation.byScope";
+    // Aggregations - By Category
+    DataBindingSource["AGGREGATION_BY_CATEGORY"] = "aggregation.byCategory";
+    DataBindingSource["AGGREGATION_CATEGORY_ENERGY"] = "aggregation.category.energy";
+    DataBindingSource["AGGREGATION_CATEGORY_TRANSPORT"] = "aggregation.category.transport";
+    DataBindingSource["AGGREGATION_CATEGORY_WASTE"] = "aggregation.category.waste";
+    // Aggregations - By Gas
+    DataBindingSource["AGGREGATION_BY_GAS"] = "aggregation.byGas";
+    DataBindingSource["AGGREGATION_GAS_CO2"] = "aggregation.gas.co2";
+    DataBindingSource["AGGREGATION_GAS_CH4"] = "aggregation.gas.ch4";
+    DataBindingSource["AGGREGATION_GAS_N2O"] = "aggregation.gas.n2o";
+    // Aggregations - By Segment
+    DataBindingSource["AGGREGATION_BY_SEGMENT"] = "aggregation.bySegment";
+    // Aggregations - Biogenic
+    DataBindingSource["AGGREGATION_BIOGENIC"] = "aggregation.biogenic";
+    DataBindingSource["AGGREGATION_BIOGENIC_CO2"] = "aggregation.biogenicCO2";
+    // Emission Factors
+    DataBindingSource["EMISSION_FACTOR_VALUE"] = "emissionFactor.value";
+    DataBindingSource["EMISSION_FACTOR_UNIT"] = "emissionFactor.unit";
+    DataBindingSource["EMISSION_FACTOR_INFORMATION_SOURCE"] = "emissionFactor.informationSource";
+    DataBindingSource["EMISSION_FACTOR_CODE"] = "emissionFactor.code";
+    DataBindingSource["EMISSION_FACTOR_NAME"] = "emissionFactor.name";
+    DataBindingSource["EMISSION_FACTOR_IPCC_CODE"] = "emissionFactor.ipccCode";
+    DataBindingSource["EMISSION_FACTOR_IPCC_SUBCATEGORY"] = "emissionFactor.ipccSubcategory";
+    DataBindingSource["EMISSION_FACTOR_METHODOLOGICAL_TIER"] = "emissionFactor.methodologicalTier";
+    // Global Warming Potential (GWP)
+    DataBindingSource["GWP_PROTOCOL_VERSION"] = "gwp.protocolVersion";
+    DataBindingSource["GWP_POTENTIAL"] = "gwp.potential";
+    DataBindingSource["GWP_INFORMATION_SOURCE"] = "gwp.informationSource";
+    DataBindingSource["GWP_AR_VERSION"] = "gwp.arVersion";
+    // Calculation Formulas
+    DataBindingSource["FORMULA_EXPRESSION"] = "formula.expression";
+    DataBindingSource["FORMULA_INFORMATION_SOURCE"] = "formula.informationSource";
+    DataBindingSource["FORMULA_METHODOLOGICAL_TIER"] = "formula.methodologicalTier";
+    DataBindingSource["FORMULA_EMISSION_SOURCE"] = "formula.emissionSource";
+    DataBindingSource["FORMULA_APPLICABLE_GASES"] = "formula.applicableGases";
+    // Charts and Visualizations
+    DataBindingSource["CHART_BY_SCOPE"] = "chart.byScope";
+    DataBindingSource["CHART_BY_SUBCATEGORY"] = "chart.bySubcategory";
+    DataBindingSource["CHART_BY_SEGMENT"] = "chart.bySegment";
+    DataBindingSource["CHART_BY_GAS"] = "chart.byGas";
+    DataBindingSource["CHART_TREND_ANALYSIS"] = "chart.trendAnalysis";
+    // Facilities/Locations
+    DataBindingSource["FACILITIES_COUNT"] = "facilities.count";
+    DataBindingSource["FACILITIES_LIST"] = "facilities.list";
+    DataBindingSource["FACILITIES_BY_COUNTRY"] = "facilities.byCountry";
+    // Organizational Boundaries
+    DataBindingSource["ORGANIZATIONAL_APPROACH"] = "organizational.approach";
+    DataBindingSource["ORGANIZATIONAL_EQUITY_SHARE"] = "organizational.equityShare";
+    DataBindingSource["ORGANIZATIONAL_CONTROL_TYPE"] = "organizational.controlType";
+    // Standards and Compliance
+    DataBindingSource["REPORTING_STANDARD"] = "standard.name";
+    DataBindingSource["STANDARD_VERSION"] = "standard.version";
+    DataBindingSource["STANDARD_REQUIREMENTS"] = "standard.requirements";
+    // Metadata
+    DataBindingSource["REPORT_GENERATION_DATE"] = "metadata.generationDate";
+    DataBindingSource["REPORT_VERSION"] = "metadata.version";
+    DataBindingSource["REPORT_TEMPLATE_VERSION"] = "metadata.templateVersion";
+})(DataBindingSource || (exports.DataBindingSource = DataBindingSource = {}));

package/build/carbonbox/reporting/shared/domain/enums/ReportStatus.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReportStatus = void 0;
+/**
+ * Report status enumeration
+ * Defines the lifecycle states of a report instance
+ */
+var ReportStatus;
+(function (ReportStatus) {
+    /**
+     * Draft - Initial state, content being prepared
+     */
+    ReportStatus["DRAFT"] = "DRAFT";
+    /**
+     * Generating - AI is generating content
+     */
+    ReportStatus["GENERATING"] = "GENERATING";
+    /**
+     * Pending internal approval - Awaiting internal review
+     */
+    ReportStatus["PENDING_INTERNAL"] = "PENDING_INTERNAL";
+    /**
+     * Pending client approval - Awaiting client review
+     */
+    ReportStatus["PENDING_CLIENT"] = "PENDING_CLIENT";
+    /**
+     * Approved - All approvals received
+     */
+    ReportStatus["APPROVED"] = "APPROVED";
+    /**
+     * Published - Report is finalized and available
+     */
+    ReportStatus["PUBLISHED"] = "PUBLISHED";
+    /**
+     * Rejected - Report was rejected and needs revision
+     */
+    ReportStatus["REJECTED"] = "REJECTED";
+    /**
+     * Archived - Report is archived (soft delete)
+     */
+    ReportStatus["ARCHIVED"] = "ARCHIVED";
+})(ReportStatus || (exports.ReportStatus = ReportStatus = {}));

package/build/carbonbox/reporting/shared/domain/enums/ReportType.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReportType = void 0;
+/**
+ * Report type enumeration
+ * Defines the different types of reports that can be generated
+ */
+var ReportType;
+(function (ReportType) {
+    /**
+     * Auditable report - Formal report for external audits
+     * Requires strict compliance and double approval
+     */
+    ReportType["AUDITABLE"] = "AUDITABLE";
+    /**
+     * Technical report - Detailed technical analysis
+     * Includes methodologies and calculation details
+     */
+    ReportType["TECHNICAL"] = "TECHNICAL";
+    /**
+     * Executive report - High-level summary for management
+     * Focus on key insights and recommendations
+     */
+    ReportType["EXECUTIVE"] = "EXECUTIVE";
+    /**
+     * Custom report - User-defined structure
+     * Flexible format based on client needs
+     */
+    ReportType["CUSTOM"] = "CUSTOM";
+})(ReportType || (exports.ReportType = ReportType = {}));

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmptyReportSectionBlocksError = void 0;
+const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
+class EmptyReportSectionBlocksError extends RootError_1.RootError {
+    constructor(sectionId) {
+        const message = `Report section '${sectionId}' must have at least one block.`;
+        super(message);
+        this.name = 'EmptyReportSectionBlocksError';
+    }
+    static create(sectionId) {
+        return new EmptyReportSectionBlocksError(sectionId);
+    }
+    logError() {
+        return `${this.name}: ${this.message}`;
+    }
+}
+exports.EmptyReportSectionBlocksError = EmptyReportSectionBlocksError;

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidReportInstanceIdError = void 0;
+const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
+class InvalidReportInstanceIdError extends RootError_1.RootError {
+    constructor(receivedValue) {
+        const message = `Invalid report instance ID '${receivedValue}': must start with 'RPT-INS-' and be 30 characters long.`;
+        super(message);
+        this.name = 'InvalidReportInstanceIdError';
+    }
+    static create(receivedValue) {
+        return new InvalidReportInstanceIdError(receivedValue);
+    }
+    logError() {
+        return `${this.name}: ${this.message}`;
+    }
+}
+exports.InvalidReportInstanceIdError = InvalidReportInstanceIdError;

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidReportSectionIdError = void 0;
+const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
+class InvalidReportSectionIdError extends RootError_1.RootError {
+    constructor(receivedValue) {
+        const message = `Invalid report section ID '${receivedValue}': cannot be empty.`;
+        super(message);
+        this.name = 'InvalidReportSectionIdError';
+    }
+    static create(receivedValue) {
+        return new InvalidReportSectionIdError(receivedValue);
+    }
+    logError() {
+        return `${this.name}: ${this.message}`;
+    }
+}
+exports.InvalidReportSectionIdError = InvalidReportSectionIdError;

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidReportSectionOrderError = void 0;
+const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
+class InvalidReportSectionOrderError extends RootError_1.RootError {
+    constructor(receivedValue) {
+        const message = `Invalid report section order '${receivedValue}': must be non-negative.`;
+        super(message);
+        this.name = 'InvalidReportSectionOrderError';
+    }
+    static create(receivedValue) {
+        return new InvalidReportSectionOrderError(receivedValue);
+    }
+    logError() {
+        return `${this.name}: ${this.message}`;
+    }
+}
+exports.InvalidReportSectionOrderError = InvalidReportSectionOrderError;

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidReportSectionTitleError = void 0;
+const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
+class InvalidReportSectionTitleError extends RootError_1.RootError {
+    constructor(receivedValue) {
+        const message = `Invalid report section title '${receivedValue}': cannot be empty.`;
+        super(message);
+        this.name = 'InvalidReportSectionTitleError';
+    }
+    static create(receivedValue) {
+        return new InvalidReportSectionTitleError(receivedValue);
+    }
+    logError() {
+        return `${this.name}: ${this.message}`;
+    }
+}
+exports.InvalidReportSectionTitleError = InvalidReportSectionTitleError;

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidReportTemplateIdError = void 0;
+const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
+class InvalidReportTemplateIdError extends RootError_1.RootError {
+    constructor(receivedValue) {
+        const message = `Invalid report template ID '${receivedValue}': must start with 'RPT-TPL-' and be 30 characters long.`;
+        super(message);
+        this.name = 'InvalidReportTemplateIdError';
+    }
+    static create(receivedValue) {
+        return new InvalidReportTemplateIdError(receivedValue);
+    }
+    logError() {
+        return `${this.name}: ${this.message}`;
+    }
+}
+exports.InvalidReportTemplateIdError = InvalidReportTemplateIdError;

package/build/carbonbox/reporting/shared/domain/types/ReportBlockPrimitives.js

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

package/build/carbonbox/reporting/shared/domain/types/ReportSectionPrimitives.js

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

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReportSection = void 0;
+const ValueObject_1 = require("../../../../shared/domain/value-objects/ValueObject");
+const InvalidReportSectionIdError_1 = require("../exceptions/InvalidReportSectionIdError");
+const InvalidReportSectionTitleError_1 = require("../exceptions/InvalidReportSectionTitleError");
+const InvalidReportSectionOrderError_1 = require("../exceptions/InvalidReportSectionOrderError");
+const EmptyReportSectionBlocksError_1 = require("../exceptions/EmptyReportSectionBlocksError");
+class ReportSection extends ValueObject_1.ValueObject {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, ReportSection.PROPERTY_NAME, ReportSection.EXPECTED_TYPE);
+        if (!skipDomainValidation) {
+            this.validateReportSection(value);
+        }
+    }
+    static create(value) {
+        return new ReportSection(value, false);
+    }
+    static fromPrimitives(primitives) {
+        return new ReportSection(primitives, true);
+    }
+    validateReportSection(value) {
+        if (!value.id || value.id.trim() === '') {
+            throw InvalidReportSectionIdError_1.InvalidReportSectionIdError.create(value.id);
+        }
+        if (!value.title || value.title.trim() === '') {
+            throw InvalidReportSectionTitleError_1.InvalidReportSectionTitleError.create(value.title);
+        }
+        if (value.order < 0) {
+            throw InvalidReportSectionOrderError_1.InvalidReportSectionOrderError.create(value.order);
+        }
+        if (!Array.isArray(value.blocks) || value.blocks.length === 0) {
+            throw EmptyReportSectionBlocksError_1.EmptyReportSectionBlocksError.create(value.id);
+        }
+    }
+    getId() {
+        return this.value.id;
+    }
+    getTitle() {
+        return this.value.title;
+    }
+    getOrder() {
+        return this.value.order;
+    }
+    getBlocks() {
+        return this.value.blocks;
+    }
+    isRequired() {
+        return this.value.isRequired;
+    }
+    isVisible() {
+        return this.value.isVisible;
+    }
+    toPrimitives() {
+        return {
+            id: this.value.id,
+            title: this.value.title,
+            order: this.value.order,
+            blocks: [...this.value.blocks],
+            isRequired: this.value.isRequired,
+            isVisible: this.value.isVisible,
+        };
+    }
+}
+exports.ReportSection = ReportSection;
+ReportSection.PROPERTY_NAME = 'reportSection';
+ReportSection.EXPECTED_TYPE = 'ReportSectionPrimitives';