@carbonbox/domain 0.29.2 → 0.30.0

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

@@ -1,18 +1,31 @@
 "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 {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidReportSectionTitleError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue) {
-        const message = `Invalid report section title '${receivedValue}': cannot be empty.`;
-        super(message);
+        const technicalMessage = `Invalid report section title: '${receivedValue}'. Report section titles cannot be empty and must contain meaningful text to identify the section.`;
+        const context = {
+            receivedValue,
+            receivedLength: receivedValue.length,
+            isEmpty: receivedValue.length === 0,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Provide a non-empty string value for the report section title',
+            'Ensure the section title contains descriptive text that identifies the section purpose',
+            'Check the report template configuration to verify section titles are properly defined',
+            'Review the section title assignment logic in the report construction process',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_REPORT_SECTION_TITLE, technicalMessage, context, suggestions);
         this.name = 'InvalidReportSectionTitleError';
     }
     static create(receivedValue) {
         return new InvalidReportSectionTitleError(receivedValue);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidReportSectionTitleError = InvalidReportSectionTitleError;

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

@@ -1,18 +1,32 @@
 "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 {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidReportTemplateIdError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue) {
-        const message = `Invalid report template ID '${receivedValue}': must start with 'RPT-TPL-' and be 30 characters long.`;
-        super(message);
+        const technicalMessage = `Invalid report template ID format: '${receivedValue}'. Report template IDs must start with 'RPT-TPL-' prefix and have exactly 30 characters total length.`;
+        const context = {
+            receivedValue,
+            receivedLength: receivedValue.length,
+            requiredPrefix: 'RPT-TPL-',
+            requiredLength: 30,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Ensure the report template ID starts with 'RPT-TPL-' prefix`,
+            'Verify that the report template ID has exactly 30 characters in total',
+            'Use the proper ID generation utility to create valid report template identifiers',
+            'Check the report template creation logic for ID format validation',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_REPORT_TEMPLATE_ID, technicalMessage, context, suggestions);
         this.name = 'InvalidReportTemplateIdError';
     }
     static create(receivedValue) {
         return new InvalidReportTemplateIdError(receivedValue);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidReportTemplateIdError = InvalidReportTemplateIdError;

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

@@ -10,10 +10,16 @@ exports.ErrorCode = void 0;
  * - PMS: Purchase Management System
  * - STK: Stakeholders
  * - CFC: Carbon Footprint Configurations
+ * - CRS: Company Resources
  * - ADC: Activity Data Collection
  * - EMC: Emission Calculations
+ * - ECR: Emission Calculation Results
+ * - RPT: Reporting
  * - SHR: Shared/Common
  *
+ * Total Codes: 173
+ * Total Exceptions Migrated: 171 (100%)
+ *
  * @since 1.0.0
  */
 var ErrorCode;
@@ -34,6 +40,40 @@ var ErrorCode;
     ErrorCode["DUPLICATE_ORDER"] = "CBX-PMS-005";
     ErrorCode["INVALID_CURRENCY"] = "CBX-PMS-006";
     ErrorCode["SERVICE_CATALOG_NOT_FOUND"] = "CBX-PMS-007";
+    // Purchase Contracts Errors (CBX-PMS-008 to CBX-PMS-011)
+    ErrorCode["INVALID_CONTRACT_TYPE"] = "CBX-PMS-008";
+    ErrorCode["INVALID_CONTRACT_VALUE_FACTOR"] = "CBX-PMS-009";
+    ErrorCode["INVALID_PAYMENT_SCHEDULE"] = "CBX-PMS-010";
+    ErrorCode["INVALID_TAX_RATE"] = "CBX-PMS-011";
+    // Purchase Orders Errors (CBX-PMS-012 to CBX-PMS-019)
+    ErrorCode["INVALID_DISCOUNT_AMOUNT_FACTOR"] = "CBX-PMS-012";
+    ErrorCode["INVALID_FIXED_DISCOUNT_AMOUNT"] = "CBX-PMS-013";
+    ErrorCode["INVALID_MAXIMUM_SUBTOTAL"] = "CBX-PMS-014";
+    ErrorCode["INVALID_PAYMENT_METHOD"] = "CBX-PMS-015";
+    ErrorCode["INVALID_PAYMENT_STATUS"] = "CBX-PMS-016";
+    ErrorCode["INVALID_PERCENTAGE_RANGE"] = "CBX-PMS-017";
+    ErrorCode["INVALID_PURCHASE_ORDER_STATUS"] = "CBX-PMS-018";
+    ErrorCode["INVALID_SUBTOTAL_AMOUNT"] = "CBX-PMS-019";
+    // Service Catalog Errors (CBX-PMS-020 to CBX-PMS-024)
+    ErrorCode["INVALID_EXPERT_DEDICATION_LEVEL"] = "CBX-PMS-020";
+    ErrorCode["INVALID_REPORT_TYPE"] = "CBX-PMS-021";
+    ErrorCode["INVALID_SERVICE_CATALOG_CATEGORY"] = "CBX-PMS-022";
+    ErrorCode["INVALID_SERVICE_CATALOG_STATUS"] = "CBX-PMS-023";
+    ErrorCode["INVALID_SERVICE_CATALOG_TYPE"] = "CBX-PMS-024";
+    // Service Pricing Errors (CBX-PMS-025 to CBX-PMS-031)
+    ErrorCode["INVALID_DISCOUNT_PERCENTAGE"] = "CBX-PMS-025";
+    ErrorCode["INVALID_MARKUP_PERCENTAGE"] = "CBX-PMS-026";
+    ErrorCode["INVALID_PRICE_PER_UNIT"] = "CBX-PMS-027";
+    ErrorCode["INVALID_PRICING_MODEL"] = "CBX-PMS-028";
+    ErrorCode["INVALID_PRICING_STATUS"] = "CBX-PMS-029";
+    ErrorCode["INVALID_TAX_PERCENTAGE"] = "CBX-PMS-030";
+    ErrorCode["INVALID_UNITS"] = "CBX-PMS-031";
+    // Service Catalog - User Role (CBX-PMS-032)
+    ErrorCode["INVALID_USER_ROLE"] = "CBX-PMS-032";
+    // Purchase Orders - Amount Factors (CBX-PMS-033 to CBX-PMS-035)
+    ErrorCode["INVALID_SUBTOTAL_AMOUNT_FACTOR"] = "CBX-PMS-033";
+    ErrorCode["INVALID_TAX_AMOUNT_FACTOR"] = "CBX-PMS-034";
+    ErrorCode["INVALID_TOTAL_AMOUNT_FACTOR"] = "CBX-PMS-035";
     // Stakeholder Errors (CBX-STK-XXX)
     ErrorCode["STAKEHOLDER_EXISTS"] = "CBX-STK-001";
     ErrorCode["INVALID_ROLE"] = "CBX-STK-002";
@@ -41,24 +81,65 @@ var ErrorCode;
     ErrorCode["INSUFFICIENT_PERMISSIONS"] = "CBX-STK-004";
     ErrorCode["INVALID_BUSINESS_STATUS"] = "CBX-STK-005";
     ErrorCode["MANAGER_REQUIRED"] = "CBX-STK-006";
+    ErrorCode["INVALID_CARBON_CLIENT_ACCOUNT_TYPE"] = "CBX-STK-007";
+    ErrorCode["INVALID_CARBON_COORDINATOR_AVAILABILITY_STATUS"] = "CBX-STK-008";
     // Carbon Footprint Configuration Errors (CBX-CFC-XXX)
     ErrorCode["CONFIGURATION_NOT_FOUND"] = "CBX-CFC-001";
     ErrorCode["INVALID_REPORTING_STANDARD"] = "CBX-CFC-002";
     ErrorCode["INVALID_COLLECTION_PERIOD"] = "CBX-CFC-003";
     ErrorCode["CONFIGURATION_LOCKED"] = "CBX-CFC-004";
     ErrorCode["DUPLICATE_CONFIGURATION"] = "CBX-CFC-005";
+    ErrorCode["INVALID_CARBON_FOOTPRINT_TYPE"] = "CBX-CFC-006";
+    ErrorCode["INVALID_CONFIGURATION_STATUS"] = "CBX-CFC-007";
+    // Company Resources Errors (CBX-CRS-XXX)
+    ErrorCode["INVALID_OPERATIONAL_SCOPE"] = "CBX-CRS-001";
     // Activity Data Collection Errors (CBX-ADC-XXX)
     ErrorCode["FORM_NOT_FOUND"] = "CBX-ADC-001";
     ErrorCode["INVALID_SUBMISSION"] = "CBX-ADC-002";
     ErrorCode["SUBMISSION_LOCKED"] = "CBX-ADC-003";
     ErrorCode["MISSING_REQUIRED_FIELDS"] = "CBX-ADC-004";
     ErrorCode["INVALID_FIELD_TYPE"] = "CBX-ADC-005";
+    // Activity Data Submissions Errors (CBX-ADC-006 to CBX-ADC-016)
+    ErrorCode["UNKNOWN_REPORTING_STANDARD"] = "CBX-ADC-006";
+    ErrorCode["UNKNOWN_FOOTPRINT_TYPE"] = "CBX-ADC-007";
+    ErrorCode["INVALID_UNCERTAINTY_SOURCE"] = "CBX-ADC-008";
+    ErrorCode["INVALID_SUB_SCOPE"] = "CBX-ADC-009";
+    ErrorCode["INVALID_SUBMISSION_STATUS"] = "CBX-ADC-010";
+    ErrorCode["INVALID_ADC_REPORTING_STANDARD"] = "CBX-ADC-011";
+    ErrorCode["INVALID_ADC_FOOTPRINT_TYPE"] = "CBX-ADC-012";
+    ErrorCode["INVALID_EMISSION_SCOPE_TYPE"] = "CBX-ADC-013";
+    ErrorCode["INVALID_EMISSION_SCOPE"] = "CBX-ADC-014";
+    ErrorCode["INVALID_SUBMISSION_STAKEHOLDER_ROLE"] = "CBX-ADC-015";
+    ErrorCode["INVALID_SUBMISSION_COUNTRY"] = "CBX-ADC-016";
+    // Conditional Logic Errors (CBX-ADC-017 to CBX-ADC-022)
+    ErrorCode["INVALID_CONDITIONAL_ACTION"] = "CBX-ADC-017";
+    ErrorCode["INVALID_TRIGGER_VALUE"] = "CBX-ADC-018";
+    ErrorCode["TRIGGER_VALUE_COMPARISON_ERROR"] = "CBX-ADC-019";
+    ErrorCode["TRIGGER_VALUE_CONVERSION_ERROR"] = "CBX-ADC-020";
+    ErrorCode["TRIGGER_VALUE_STRING_OPERATION_ERROR"] = "CBX-ADC-021";
+    ErrorCode["UNKNOWN_CONDITIONAL_ACTION_CATEGORY"] = "CBX-ADC-022";
     // Emission Calculation Errors (CBX-EMC-XXX)
     ErrorCode["CALCULATION_FAILED"] = "CBX-EMC-001";
     ErrorCode["MISSING_EMISSION_FACTOR"] = "CBX-EMC-002";
     ErrorCode["INVALID_FORMULA"] = "CBX-EMC-003";
     ErrorCode["JOB_NOT_FOUND"] = "CBX-EMC-004";
     ErrorCode["JOB_ALREADY_RUNNING"] = "CBX-EMC-005";
+    // Emission Calculation Formulas Errors (CBX-EMC-006 to CBX-EMC-011)
+    ErrorCode["INVALID_CALCULATION_VARIABLE_ACTIVITY_DATA_CONDITIONS_FOR_STRATEGY"] = "CBX-EMC-006";
+    ErrorCode["INVALID_CALCULATION_VARIABLE_RESOLUTION_STRATEGY"] = "CBX-EMC-007";
+    ErrorCode["DUPLICATE_GREENHOUSE_GAS"] = "CBX-EMC-008";
+    ErrorCode["INVALID_EMISSION_CALCULATION_FORMULA_ACTIVITY_VARIABLE_SYMBOL"] = "CBX-EMC-009";
+    ErrorCode["INVALID_GREENHOUSE_GAS_TYPE"] = "CBX-EMC-010";
+    ErrorCode["UNAUTHORIZED_FORMULA_CREATION_ROLE"] = "CBX-EMC-011";
+    // Emission Calculation Results Errors (CBX-ECR-XXX)
+    ErrorCode["UNKNOWN_GREENHOUSE_GAS_CATEGORY"] = "CBX-ECR-001";
+    // Reporting Errors (CBX-RPT-XXX)
+    ErrorCode["EMPTY_REPORT_SECTION_BLOCKS"] = "CBX-RPT-001";
+    ErrorCode["INVALID_REPORT_INSTANCE_ID"] = "CBX-RPT-002";
+    ErrorCode["INVALID_REPORT_SECTION_ID"] = "CBX-RPT-003";
+    ErrorCode["INVALID_REPORT_SECTION_ORDER"] = "CBX-RPT-004";
+    ErrorCode["INVALID_REPORT_SECTION_TITLE"] = "CBX-RPT-005";
+    ErrorCode["INVALID_REPORT_TEMPLATE_ID"] = "CBX-RPT-006";
     // Shared/Common Errors (CBX-SHR-XXX)
     ErrorCode["INVALID_EMAIL"] = "CBX-SHR-001";
     ErrorCode["INVALID_DATE_FORMAT"] = "CBX-SHR-002";
@@ -78,4 +159,68 @@ var ErrorCode;
     ErrorCode["MAXIMUM_VALUE_VIOLATION"] = "CBX-SHR-016";
     ErrorCode["INVALID_DATE_RANGE"] = "CBX-SHR-017";
     ErrorCode["PASSWORD_POLICY_VIOLATION"] = "CBX-SHR-018";
+    // Identity and Format Validation Errors (CBX-SHR-019 to CBX-SHR-033)
+    ErrorCode["INVALID_AGGREGATE_ID"] = "CBX-SHR-019";
+    ErrorCode["INVALID_AGGREGATE_ID_FORMAT"] = "CBX-SHR-020";
+    ErrorCode["INVALID_AGGREGATE_PREFIX"] = "CBX-SHR-021";
+    ErrorCode["INVALID_SEMANTIC_UUID_FORMAT"] = "CBX-SHR-022";
+    ErrorCode["INVALID_USER_ID_FORMAT"] = "CBX-SHR-023";
+    ErrorCode["INVALID_USER_PREFIX"] = "CBX-SHR-024";
+    ErrorCode["INVALID_UUID_FORMAT"] = "CBX-SHR-025";
+    ErrorCode["UNKNOWN_BOUNDED_CONTEXT_CODE"] = "CBX-SHR-026";
+    ErrorCode["INVALID_DOMAIN_CODE"] = "CBX-SHR-027";
+    ErrorCode["INVALID_CODE"] = "CBX-SHR-028";
+    ErrorCode["INVALID_VALUE_OBJECT_CONFIGURATION"] = "CBX-SHR-029";
+    ErrorCode["CREATE_METHOD_NOT_IMPLEMENTED"] = "CBX-SHR-030";
+    ErrorCode["METHOD_NOT_IMPLEMENTED"] = "CBX-SHR-031";
+    ErrorCode["INVALID_DOMAIN_EVENT_NAME"] = "CBX-SHR-032";
+    ErrorCode["INVALID_USER_PREFERRED_LOCALE"] = "CBX-SHR-033";
+    // Colombian Business Validation Errors (CBX-SHR-034 to CBX-SHR-036)
+    ErrorCode["INVALID_COLOMBIAN_NIT_FORMAT"] = "CBX-SHR-034";
+    ErrorCode["INVALID_COLOMBIAN_NIT_CHECK_DIGIT"] = "CBX-SHR-035";
+    ErrorCode["INVALID_COLOMBIAN_NIT_NUMBER"] = "CBX-SHR-036";
+    // Type and Enum Validation Errors (CBX-SHR-037 to CBX-SHR-046)
+    ErrorCode["INVALID_USER_TYPE"] = "CBX-SHR-037";
+    ErrorCode["INVALID_BUSINESS_SCALE"] = "CBX-SHR-038";
+    ErrorCode["INVALID_STAKEHOLDER_ROLE_TYPE"] = "CBX-SHR-039";
+    ErrorCode["INVALID_TAX_IDENTIFICATION_TYPE"] = "CBX-SHR-040";
+    ErrorCode["INVALID_COUNTRY_CODE"] = "CBX-SHR-041";
+    ErrorCode["INVALID_IDENTITY_DOCUMENT_TYPE"] = "CBX-SHR-042";
+    ErrorCode["INVALID_ASSIGNER_ROLE"] = "CBX-SHR-043";
+    ErrorCode["INVALID_MANAGED_STAKEHOLDER_ROLE"] = "CBX-SHR-044";
+    ErrorCode["INVALID_SUPERVISOR_ROLE"] = "CBX-SHR-045";
+    ErrorCode["UNSUPPORTED_STAKEHOLDER_ROLE"] = "CBX-SHR-046";
+    // Collection and Value Validation Errors (CBX-SHR-047 to CBX-SHR-056)
+    ErrorCode["EMPTY_ARRAY_NOT_ALLOWED"] = "CBX-SHR-047";
+    ErrorCode["INVALID_STRING_LIST"] = "CBX-SHR-048";
+    ErrorCode["INVALID_CODE_LIST"] = "CBX-SHR-049";
+    ErrorCode["INVALID_URL_LIST"] = "CBX-SHR-050";
+    ErrorCode["NEGATIVE_AMOUNT"] = "CBX-SHR-051";
+    ErrorCode["NOT_INTEGER"] = "CBX-SHR-052";
+    ErrorCode["MONEY_OVERFLOW"] = "CBX-SHR-053";
+    ErrorCode["DIVISION_BY_ZERO"] = "CBX-SHR-054";
+    ErrorCode["DATE_GREATER_THAN"] = "CBX-SHR-055";
+    ErrorCode["EMPTY_DISPLAY_NAME"] = "CBX-SHR-056";
+    // Technical Operation Errors (CBX-SHR-057 to CBX-SHR-066)
+    ErrorCode["FILTER_OPERATION_NOT_IMPLEMENTED"] = "CBX-SHR-057";
+    ErrorCode["SWAP_OPERATION_NOT_IMPLEMENTED"] = "CBX-SHR-058";
+    ErrorCode["INVALID_MEASUREMENT_UNIT_OPERATION"] = "CBX-SHR-059";
+    ErrorCode["EMPTY_SEGMENT_CODE"] = "CBX-SHR-060";
+    ErrorCode["EMPTY_SEGMENT_NAME"] = "CBX-SHR-061";
+    ErrorCode["EMPTY_TAX_IDENTIFICATION_NUMBER"] = "CBX-SHR-062";
+    ErrorCode["INVALID_TAX_IDENTIFICATION_NUMBER_FORMAT"] = "CBX-SHR-063";
+    ErrorCode["INVALID_TAX_IDENTIFICATION_NUMBER_LENGTH"] = "CBX-SHR-064";
+    ErrorCode["TAX_IDENTIFICATION_NUMBER_WITH_CONTROL_CHARACTERS"] = "CBX-SHR-065";
+    ErrorCode["INVALID_COUNTRY_SPECIFIC_TAX_IDENTIFICATION_NUMBER"] = "CBX-SHR-066";
+    // Either Pattern Errors (CBX-SHR-067 to CBX-SHR-068)
+    ErrorCode["CANNOT_ACCESS_LEFT_ON_RIGHT_VALUE"] = "CBX-SHR-067";
+    ErrorCode["CANNOT_ACCESS_RIGHT_ON_LEFT_VALUE"] = "CBX-SHR-068";
+    // User and Context Validation Errors (CBX-SHR-069 to CBX-SHR-075)
+    ErrorCode["UNSUPPORTED_USER_TYPE"] = "CBX-SHR-069";
+    ErrorCode["SECURITY_CONTEXT_RECONSTRUCTION_ERROR"] = "CBX-SHR-070";
+    ErrorCode["INVALID_USER_BUSINESS_STATUS"] = "CBX-SHR-071";
+    ErrorCode["INVALID_TIME_FORMAT"] = "CBX-SHR-072";
+    ErrorCode["INVALID_NATIONAL_NUMBER"] = "CBX-SHR-073";
+    ErrorCode["INVALID_MINUTES_DURATION"] = "CBX-SHR-074";
+    ErrorCode["INVALID_FULL_INTERNATIONAL_NUMBER"] = "CBX-SHR-075";
 })(ErrorCode || (exports.ErrorCode = ErrorCode = {}));

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalculationFailedError = void 0;
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class CalculationFailedError extends CodedRootError_1.CodedRootError {
+    constructor(calculationId, reason) {
+        const technicalMessage = `Emission calculation '${calculationId}' failed: ${reason}`;
+        const context = {
+            calculationId,
+            reason,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Review the calculation input data for errors',
+            'Check if all required emission factors are available',
+            'Verify the calculation formula is correctly configured',
+            'Contact support if the issue persists',
+            'Check system logs for detailed error information',
+        ];
+        super(ErrorCode_1.ErrorCode.CALCULATION_FAILED, technicalMessage, context, suggestions);
+        this.name = 'CalculationFailedError';
+    }
+    static create(calculationId, reason) {
+        return new CalculationFailedError(calculationId, reason);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.CalculationFailedError = CalculationFailedError;

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

@@ -1,18 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CreateMethodNotImplementedError = void 0;
-const RootError_1 = require("./RootError");
-class CreateMethodNotImplementedError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class CreateMethodNotImplementedError extends CodedRootError_1.CodedRootError {
     constructor(className) {
-        const message = `The 'create' method must be implemented in the class '${className}'.`;
-        super(message);
+        const technicalMessage = `The 'create' method must be implemented in the class '${className}'. This is a required factory method for domain entities and value objects.`;
+        const context = {
+            className,
+            missingMethod: 'create',
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Implement a static 'create' method in class '${className}'`,
+            'The create method should be the primary factory for instantiating this class',
+            'Signature: public static create(...params): ClassName',
+            'Use the create method instead of calling the constructor directly',
+            'Refer to domain-driven design patterns for factory method implementation',
+        ];
+        super(ErrorCode_1.ErrorCode.CREATE_METHOD_NOT_IMPLEMENTED, technicalMessage, context, suggestions);
         this.name = 'CreateMethodNotImplementedError';
     }
     static create(className) {
         return new CreateMethodNotImplementedError(className);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.CreateMethodNotImplementedError = CreateMethodNotImplementedError;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseConnectionError = void 0;
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class DatabaseConnectionError extends CodedRootError_1.CodedRootError {
+    constructor(database, reason) {
+        const technicalMessage = reason
+            ? `Failed to connect to database '${database}': ${reason}`
+            : `Failed to connect to database '${database}'`;
+        const context = {
+            database,
+            reason,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Verify database connection credentials',
+            'Check if the database server is running and accessible',
+            'Ensure network connectivity to the database',
+            'Review database connection pool settings',
+            'Contact your system administrator if the issue persists',
+        ];
+        super(ErrorCode_1.ErrorCode.DATABASE_CONNECTION, technicalMessage, context, suggestions);
+        this.name = 'DatabaseConnectionError';
+    }
+    static create(database, reason) {
+        return new DatabaseConnectionError(database, reason);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.DatabaseConnectionError = DatabaseConnectionError;

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

@@ -1,18 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DateGreaterThanError = void 0;
-const RootError_1 = require("./RootError");
-class DateGreaterThanError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class DateGreaterThanError extends CodedRootError_1.CodedRootError {
     constructor(date1, date2) {
-        const message = `Date constraint violation: '${date1.value}' is greater than '${date2.value}'.`;
-        super(message);
+        const technicalMessage = `Date constraint violation: '${date1.value}' is greater than '${date2.value}'.`;
+        const context = {
+            date1: date1.value,
+            date2: date2.value,
+            constraint: 'date_ordering',
+            violationType: 'date1_greater_than_date2',
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Ensure that the first date (${date1.value}) is not greater than the second date (${date2.value})`,
+            'Validate date ordering before creating value objects with date range constraints',
+            'Check if dates are being assigned in the correct order (start date vs end date)',
+            'Review business logic to ensure chronological ordering is maintained',
+        ];
+        super(ErrorCode_1.ErrorCode.DATE_GREATER_THAN, technicalMessage, context, suggestions);
         this.name = 'DateGreaterThanError';
     }
     static create(date1, date2) {
         return new DateGreaterThanError(date1, date2);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.DateGreaterThanError = DateGreaterThanError;

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

@@ -1,10 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DivisionByZeroError = void 0;
-const RootError_1 = require("./RootError");
-class DivisionByZeroError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class DivisionByZeroError extends CodedRootError_1.CodedRootError {
     constructor(operation, divisorValue) {
-        super(`Division by zero error: Cannot perform operation '${operation}' when divisor is ${divisorValue}.`);
+        const technicalMessage = `Division by zero error: Cannot perform operation '${operation}' when divisor is ${divisorValue}.`;
+        const context = {
+            operation,
+            divisorValue,
+            errorType: 'division_by_zero',
+            mathematicallyUndefined: true,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Ensure the divisor in operation '${operation}' is not zero before performing division`,
+            'Add validation to check for zero values before division operations',
+            'Review the logic that produces the divisor to prevent zero values',
+            'Consider using a default value or alternative calculation when the divisor is zero',
+        ];
+        super(ErrorCode_1.ErrorCode.DIVISION_BY_ZERO, technicalMessage, context, suggestions);
         this.operation = operation;
         this.divisorValue = divisorValue;
         this.name = 'DivisionByZeroError';
@@ -19,7 +34,7 @@ class DivisionByZeroError extends RootError_1.RootError {
         return this.divisorValue;
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.DivisionByZeroError = DivisionByZeroError;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuplicateOrderError = void 0;
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class DuplicateOrderError extends CodedRootError_1.CodedRootError {
+    constructor(orderId, existingOrderId) {
+        const technicalMessage = existingOrderId
+            ? `Order with ID '${orderId}' already exists. Existing order ID: ${existingOrderId}`
+            : `Order with ID '${orderId}' already exists in the system`;
+        const context = {
+            orderId,
+            existingOrderId,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Use a different order identifier',
+            'Check if this order was already submitted',
+            'Verify the order ID generation logic to avoid duplicates',
+            'Use the update endpoint if you need to modify an existing order',
+            'Contact support if you believe this is an error',
+        ];
+        super(ErrorCode_1.ErrorCode.DUPLICATE_ORDER, technicalMessage, context, suggestions);
+        this.name = 'DuplicateOrderError';
+    }
+    static create(orderId, existingOrderId) {
+        return new DuplicateOrderError(orderId, existingOrderId);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.DuplicateOrderError = DuplicateOrderError;

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

@@ -1,18 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EmptyArrayNotAllowedError = void 0;
-const RootError_1 = require("./RootError");
-class EmptyArrayNotAllowedError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class EmptyArrayNotAllowedError extends CodedRootError_1.CodedRootError {
     constructor(propertyName) {
-        const message = `Empty array not allowed for property '${propertyName}': at least one element is required.`;
-        super(message);
+        const technicalMessage = `Empty array not allowed for property '${propertyName}': at least one element is required.`;
+        const context = {
+            propertyName,
+            constraint: 'minimum_length',
+            minimumRequired: 1,
+            actualLength: 0,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Ensure that the property '${propertyName}' contains at least one element before creating the value object`,
+            'Validate input data before instantiation to prevent empty arrays',
+            'Check if the source data for this array property is being correctly populated',
+            'Consider adding a default value or making the array optional if business rules allow it',
+        ];
+        super(ErrorCode_1.ErrorCode.EMPTY_ARRAY_NOT_ALLOWED, technicalMessage, context, suggestions);
         this.name = 'EmptyArrayNotAllowedError';
     }
     static create(propertyName) {
         return new EmptyArrayNotAllowedError(propertyName);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.EmptyArrayNotAllowedError = EmptyArrayNotAllowedError;

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

@@ -1,18 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EmptyDisplayNameError = void 0;
-const RootError_1 = require("./RootError");
-class EmptyDisplayNameError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class EmptyDisplayNameError extends CodedRootError_1.CodedRootError {
     constructor(propertyName) {
-        const message = `The ${propertyName} cannot be empty or contain only whitespace.`;
-        super(message);
+        const technicalMessage = `The ${propertyName} cannot be empty or contain only whitespace.`;
+        const context = {
+            propertyName,
+            constraint: 'non_empty_display_name',
+            allowedPattern: 'non-whitespace characters required',
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Ensure that '${propertyName}' contains at least one non-whitespace character`,
+            'Trim whitespace and validate that the resulting string is not empty',
+            'Check input data to ensure display names are properly populated',
+            'Consider adding validation at the UI layer to prevent empty or whitespace-only values',
+        ];
+        super(ErrorCode_1.ErrorCode.EMPTY_DISPLAY_NAME, technicalMessage, context, suggestions);
         this.name = 'EmptyDisplayNameError';
     }
     static create(propertyName) {
         return new EmptyDisplayNameError(propertyName);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.EmptyDisplayNameError = EmptyDisplayNameError;

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

@@ -1,18 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EmptySegmentCodeError = void 0;
-const RootError_1 = require("./RootError");
-class EmptySegmentCodeError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class EmptySegmentCodeError extends CodedRootError_1.CodedRootError {
     constructor(propertyName) {
-        const message = `The ${propertyName} cannot be empty or contain only whitespace.`;
-        super(message);
+        const technicalMessage = `The ${propertyName} cannot be empty or contain only whitespace.`;
+        const context = {
+            propertyName,
+            constraint: 'non_empty_segment_code',
+            expectedPattern: 'non-whitespace characters required',
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Ensure that '${propertyName}' contains at least one non-whitespace character`,
+            'Validate segment codes before creating value objects to prevent empty values',
+            'Check that segment code input is properly populated from the data source',
+            'Consider implementing segment code format validation rules',
+        ];
+        super(ErrorCode_1.ErrorCode.EMPTY_SEGMENT_CODE, technicalMessage, context, suggestions);
         this.name = 'EmptySegmentCodeError';
     }
     static create(propertyName) {
         return new EmptySegmentCodeError(propertyName);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.EmptySegmentCodeError = EmptySegmentCodeError;

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

@@ -1,18 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EmptySegmentNameError = void 0;
-const RootError_1 = require("./RootError");
-class EmptySegmentNameError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class EmptySegmentNameError extends CodedRootError_1.CodedRootError {
     constructor(propertyName) {
-        const message = `The ${propertyName} cannot be empty or contain only whitespace.`;
-        super(message);
+        const technicalMessage = `The ${propertyName} cannot be empty or contain only whitespace.`;
+        const context = {
+            propertyName,
+            constraint: 'non_empty_segment_name',
+            expectedPattern: 'non-whitespace characters required',
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Ensure that '${propertyName}' contains at least one non-whitespace character`,
+            'Validate segment names before creating value objects to prevent empty values',
+            'Check that segment name input is properly populated from the data source',
+            'Consider implementing segment name format validation rules',
+        ];
+        super(ErrorCode_1.ErrorCode.EMPTY_SEGMENT_NAME, technicalMessage, context, suggestions);
         this.name = 'EmptySegmentNameError';
     }
     static create(propertyName) {
         return new EmptySegmentNameError(propertyName);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.EmptySegmentNameError = EmptySegmentNameError;