@carbonbox/domain 0.29.2 → 0.30.0

package/build/carbonbox/purchase-management-system/service-catalog/domain/exceptions/InvalidReportTypeError.js

@@ -1,19 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidReportTypeError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidReportTypeError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidReportTypeError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue, validTypes) {
         const validTypesList = validTypes.join(', ');
-        const message = `Invalid report type value '${receivedValue}': must be one of ${validTypesList}.`;
-        super(message);
+        const technicalMessage = `Invalid report type value '${receivedValue}': must be one of ${validTypesList}.`;
+        const context = {
+            receivedValue,
+            validTypes,
+            providedType: receivedValue,
+            allowedTypes: validTypesList,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid report types: ${validTypesList}`,
+            'Verify the report type configuration matches the service requirements',
+            'Check if the ReportType enum has been updated recently',
+            'Ensure the report type is compatible with the selected service',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_REPORT_TYPE, technicalMessage, context, suggestions);
         this.name = 'InvalidReportTypeError';
     }
     static create(receivedValue, validTypes) {
         return new InvalidReportTypeError(receivedValue, validTypes);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidReportTypeError = InvalidReportTypeError;

package/build/carbonbox/purchase-management-system/service-catalog/domain/exceptions/InvalidServiceCatalogCategoryError.js

@@ -1,19 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidServiceCatalogCategoryError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidServiceCatalogCategoryError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidServiceCatalogCategoryError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue, validCategories) {
         const validCategoriesList = validCategories.join(', ');
-        const message = `Invalid service category value '${receivedValue}': must be one of ${validCategoriesList}.`;
-        super(message);
+        const technicalMessage = `Invalid service category value '${receivedValue}': must be one of ${validCategoriesList}.`;
+        const context = {
+            receivedValue,
+            validCategories,
+            providedCategory: receivedValue,
+            allowedCategories: validCategoriesList,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid service categories: ${validCategoriesList}`,
+            'Verify the service category configuration matches the catalog requirements',
+            'Check if the ServiceCatalogCategory enum has been updated recently',
+            'Ensure the category is appropriate for the type of service being created',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_SERVICE_CATALOG_CATEGORY, technicalMessage, context, suggestions);
         this.name = 'InvalidServiceCatalogCategoryError';
     }
     static create(receivedValue, validCategories) {
         return new InvalidServiceCatalogCategoryError(receivedValue, validCategories);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidServiceCatalogCategoryError = InvalidServiceCatalogCategoryError;

package/build/carbonbox/purchase-management-system/service-catalog/domain/exceptions/InvalidServiceCatalogStatusError.js

@@ -1,19 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidServiceCatalogStatusError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidServiceCatalogStatusError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidServiceCatalogStatusError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue, validStatuses) {
         const validStatusesList = validStatuses.join(', ');
-        const message = `Invalid service status value '${receivedValue}': must be one of ${validStatusesList}.`;
-        super(message);
+        const technicalMessage = `Invalid service status value '${receivedValue}': must be one of ${validStatusesList}.`;
+        const context = {
+            receivedValue,
+            validStatuses,
+            providedStatus: receivedValue,
+            allowedStatuses: validStatusesList,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid service statuses: ${validStatusesList}`,
+            'Verify the service status transition is allowed in the catalog workflow',
+            'Check if the ServiceCatalogStatus enum has been updated recently',
+            'Ensure the status change is compatible with the service lifecycle',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_SERVICE_CATALOG_STATUS, technicalMessage, context, suggestions);
         this.name = 'InvalidServiceCatalogStatusError';
     }
     static create(receivedValue, validStatuses) {
         return new InvalidServiceCatalogStatusError(receivedValue, validStatuses);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidServiceCatalogStatusError = InvalidServiceCatalogStatusError;

package/build/carbonbox/purchase-management-system/service-catalog/domain/exceptions/InvalidServiceCatalogTypeError.js

@@ -1,19 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidServiceCatalogTypeError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidServiceCatalogTypeError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidServiceCatalogTypeError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue, validTypes) {
         const validTypesList = validTypes.join(', ');
-        const message = `Invalid service type value '${receivedValue}': must be one of ${validTypesList}.`;
-        super(message);
+        const technicalMessage = `Invalid service type value '${receivedValue}': must be one of ${validTypesList}.`;
+        const context = {
+            receivedValue,
+            validTypes,
+            providedType: receivedValue,
+            allowedTypes: validTypesList,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid service types: ${validTypesList}`,
+            'Verify the service type configuration matches the catalog requirements',
+            'Check if the ServiceCatalogType enum has been updated recently',
+            'Ensure the service type is appropriate for the category selected',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_SERVICE_CATALOG_TYPE, technicalMessage, context, suggestions);
         this.name = 'InvalidServiceCatalogTypeError';
     }
     static create(receivedValue, validTypes) {
         return new InvalidServiceCatalogTypeError(receivedValue, validTypes);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidServiceCatalogTypeError = InvalidServiceCatalogTypeError;

package/build/carbonbox/purchase-management-system/service-catalog/domain/exceptions/InvalidUserRoleError.js

@@ -1,19 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidUserRoleError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidUserRoleError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidUserRoleError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue, validRoles) {
         const validRolesList = validRoles.join(', ');
-        const message = `Invalid user role value '${receivedValue}': must be one of ${validRolesList}.`;
-        super(message);
+        const technicalMessage = `Invalid user role value '${receivedValue}': must be one of ${validRolesList}.`;
+        const context = {
+            receivedValue,
+            validRoles,
+            validRolesList,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid user roles: ${validRolesList}`,
+            'Verify that the user role value is correctly spelled',
+            'Check if the user has the necessary permissions for this role',
+            'Review the UserRole enum for all available options',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_USER_ROLE, technicalMessage, context, suggestions);
         this.name = 'InvalidUserRoleError';
     }
     static create(receivedValue, validRoles) {
         return new InvalidUserRoleError(receivedValue, validRoles);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidUserRoleError = InvalidUserRoleError;

package/build/carbonbox/purchase-management-system/service-pricing/domain/exceptions/InvalidDiscountPercentageError.js

@@ -1,18 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidDiscountPercentageError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidDiscountPercentageError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidDiscountPercentageError extends CodedRootError_1.CodedRootError {
     constructor(receivedPercentage) {
-        const message = `Invalid discount percentage '${receivedPercentage}': must be between 0 and 100.`;
-        super(message);
+        const technicalMessage = `Invalid discount percentage '${receivedPercentage}': must be between 0 and 100.`;
+        const context = {
+            receivedPercentage,
+            validRange: { min: 0, max: 100 },
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Verify that the discount percentage is a positive number',
+            'Ensure the discount percentage does not exceed 100',
+            'Check if the discount value is being calculated correctly',
+            'Consider using a fixed discount amount instead if the percentage is too high',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_DISCOUNT_PERCENTAGE, technicalMessage, context, suggestions);
         this.name = 'InvalidDiscountPercentageError';
     }
     static create(receivedPercentage) {
         return new InvalidDiscountPercentageError(receivedPercentage);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidDiscountPercentageError = InvalidDiscountPercentageError;

package/build/carbonbox/purchase-management-system/service-pricing/domain/exceptions/InvalidMarkupPercentageError.js

@@ -1,18 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidMarkupPercentageError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidMarkupPercentageError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidMarkupPercentageError extends CodedRootError_1.CodedRootError {
     constructor(receivedPercentage) {
-        const message = `Invalid markup percentage '${receivedPercentage}': cannot be negative.`;
-        super(message);
+        const technicalMessage = `Invalid markup percentage '${receivedPercentage}': cannot be negative.`;
+        const context = {
+            receivedPercentage,
+            constraint: 'must be greater than or equal to 0',
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Verify that the markup percentage is a positive number or zero',
+            'Check if there is a calculation error producing a negative value',
+            'Ensure the markup formula is correctly implemented',
+            'Review the source data for the markup percentage value',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_MARKUP_PERCENTAGE, technicalMessage, context, suggestions);
         this.name = 'InvalidMarkupPercentageError';
     }
     static create(receivedPercentage) {
         return new InvalidMarkupPercentageError(receivedPercentage);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidMarkupPercentageError = InvalidMarkupPercentageError;

package/build/carbonbox/purchase-management-system/service-pricing/domain/exceptions/InvalidPricePerUnitError.js

@@ -1,18 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidPricePerUnitError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidPricePerUnitError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidPricePerUnitError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue, context) {
-        const message = `Invalid price per unit value '${receivedValue}' for ${context}: cannot be negative.`;
-        super(message);
+        const technicalMessage = `Invalid price per unit value '${receivedValue}' for ${context}: cannot be negative.`;
+        const errorContext = {
+            receivedValue,
+            context,
+            constraint: 'must be greater than or equal to 0',
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Verify that the price per unit is a positive number or zero',
+            'Check if there is a calculation error producing a negative price',
+            'Ensure the pricing formula is correctly configured',
+            'Review the source data for the price per unit value',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_PRICE_PER_UNIT, technicalMessage, errorContext, suggestions);
         this.name = 'InvalidPricePerUnitError';
     }
     static create(receivedValue, context = 'price per unit') {
         return new InvalidPricePerUnitError(receivedValue, context);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidPricePerUnitError = InvalidPricePerUnitError;

package/build/carbonbox/purchase-management-system/service-pricing/domain/exceptions/InvalidPricingModelError.js

@@ -1,19 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidPricingModelError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidPricingModelError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidPricingModelError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue, validPricingModels) {
         const validPricingModelsList = validPricingModels.join(', ');
-        const message = `Invalid pricing model value '${receivedValue}': must be one of ${validPricingModelsList}.`;
-        super(message);
+        const technicalMessage = `Invalid pricing model value '${receivedValue}': must be one of ${validPricingModelsList}.`;
+        const context = {
+            receivedValue,
+            validPricingModels,
+            validPricingModelsList,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid pricing models: ${validPricingModelsList}`,
+            'Verify that the pricing model value is correctly spelled',
+            'Check if the pricing model is supported in your configuration',
+            'Review the PricingModel enum for all available options',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_PRICING_MODEL, technicalMessage, context, suggestions);
         this.name = 'InvalidPricingModelError';
     }
     static create(receivedValue, validPricingModels) {
         return new InvalidPricingModelError(receivedValue, validPricingModels);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidPricingModelError = InvalidPricingModelError;

package/build/carbonbox/purchase-management-system/service-pricing/domain/exceptions/InvalidPricingStatusError.js

@@ -1,19 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidPricingStatusError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidPricingStatusError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidPricingStatusError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue, validPricingStatuses) {
         const validPricingStatusesList = validPricingStatuses.join(', ');
-        const message = `Invalid pricing status value '${receivedValue}': must be one of ${validPricingStatusesList}.`;
-        super(message);
+        const technicalMessage = `Invalid pricing status value '${receivedValue}': must be one of ${validPricingStatusesList}.`;
+        const context = {
+            receivedValue,
+            validPricingStatuses,
+            validPricingStatusesList,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid pricing statuses: ${validPricingStatusesList}`,
+            'Verify that the pricing status value is correctly spelled',
+            'Check if the pricing status transition is allowed',
+            'Review the PricingStatus enum for all available options',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_PRICING_STATUS, technicalMessage, context, suggestions);
         this.name = 'InvalidPricingStatusError';
     }
     static create(receivedValue, validPricingStatuses) {
         return new InvalidPricingStatusError(receivedValue, validPricingStatuses);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidPricingStatusError = InvalidPricingStatusError;

package/build/carbonbox/purchase-management-system/service-pricing/domain/exceptions/InvalidTaxPercentageError.js

@@ -1,18 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidTaxPercentageError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidTaxPercentageError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidTaxPercentageError extends CodedRootError_1.CodedRootError {
     constructor(receivedPercentage) {
-        const message = `Invalid tax percentage '${receivedPercentage}': cannot be negative.`;
-        super(message);
+        const technicalMessage = `Invalid tax percentage '${receivedPercentage}': cannot be negative.`;
+        const context = {
+            receivedPercentage,
+            constraint: 'must be greater than or equal to 0',
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Verify that the tax percentage is a positive number or zero',
+            'Check if there is a calculation error producing a negative tax value',
+            'Ensure the tax rate is correctly configured for the region',
+            'Review the source data for the tax percentage value',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_TAX_PERCENTAGE, technicalMessage, context, suggestions);
         this.name = 'InvalidTaxPercentageError';
     }
     static create(receivedPercentage) {
         return new InvalidTaxPercentageError(receivedPercentage);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidTaxPercentageError = InvalidTaxPercentageError;

package/build/carbonbox/purchase-management-system/service-pricing/domain/exceptions/InvalidUnitsError.js

@@ -1,18 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidUnitsError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidUnitsError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidUnitsError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue, context) {
-        const message = `Invalid units value '${receivedValue}' for ${context}: cannot be negative.`;
-        super(message);
+        const technicalMessage = `Invalid units value '${receivedValue}' for ${context}: cannot be negative.`;
+        const errorContext = {
+            receivedValue,
+            context,
+            constraint: 'must be greater than or equal to 0',
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Verify that the units value is a positive number or zero',
+            'Check if there is a calculation error producing a negative units value',
+            'Ensure the units are correctly calculated from the source data',
+            'Review the measurement unit configuration for correctness',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_UNITS, technicalMessage, errorContext, suggestions);
         this.name = 'InvalidUnitsError';
     }
     static create(receivedValue, context = 'units') {
         return new InvalidUnitsError(receivedValue, context);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidUnitsError = InvalidUnitsError;

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

@@ -1,18 +1,30 @@
 "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 {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class EmptyReportSectionBlocksError extends CodedRootError_1.CodedRootError {
     constructor(sectionId) {
-        const message = `Report section '${sectionId}' must have at least one block.`;
-        super(message);
+        const technicalMessage = `Report section '${sectionId}' contains no content blocks. All report sections must have at least one content block to be considered valid.`;
+        const context = {
+            sectionId,
+            minimumBlocksRequired: 1,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Add at least one content block to the report section before saving',
+            `Verify that the section '${sectionId}' has been properly configured with content blocks`,
+            'Check the report template definition to ensure all sections have block configurations',
+            'Review the report section creation logic to validate that blocks are properly assigned',
+        ];
+        super(ErrorCode_1.ErrorCode.EMPTY_REPORT_SECTION_BLOCKS, technicalMessage, context, suggestions);
         this.name = 'EmptyReportSectionBlocksError';
     }
     static create(sectionId) {
         return new EmptyReportSectionBlocksError(sectionId);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.EmptyReportSectionBlocksError = EmptyReportSectionBlocksError;

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

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

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

@@ -1,18 +1,31 @@
 "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 {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidReportSectionIdError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue) {
-        const message = `Invalid report section ID '${receivedValue}': cannot be empty.`;
-        super(message);
+        const technicalMessage = `Invalid report section ID: '${receivedValue}'. Report section IDs cannot be empty and must contain a valid identifier string.`;
+        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 ID',
+            'Verify that the section ID is properly generated during report section creation',
+            'Check the report template configuration to ensure section IDs are correctly assigned',
+            'Review the section ID assignment logic in the report construction process',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_REPORT_SECTION_ID, technicalMessage, context, suggestions);
         this.name = 'InvalidReportSectionIdError';
     }
     static create(receivedValue) {
         return new InvalidReportSectionIdError(receivedValue);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidReportSectionIdError = InvalidReportSectionIdError;

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

@@ -1,18 +1,31 @@
 "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 {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidReportSectionOrderError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue) {
-        const message = `Invalid report section order '${receivedValue}': must be non-negative.`;
-        super(message);
+        const technicalMessage = `Invalid report section order value: ${receivedValue}. Section order must be a non-negative integer (0 or greater) to define proper section sequencing.`;
+        const context = {
+            receivedValue,
+            minimumAllowedValue: 0,
+            isNegative: receivedValue < 0,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Provide a non-negative integer value for the report section order (0, 1, 2, ...)',
+            `Change the section order from ${receivedValue} to a valid non-negative number`,
+            'Review the report section ordering logic to ensure proper sequence assignment',
+            'Check that the section order calculation does not produce negative values',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_REPORT_SECTION_ORDER, technicalMessage, context, suggestions);
         this.name = 'InvalidReportSectionOrderError';
     }
     static create(receivedValue) {
         return new InvalidReportSectionOrderError(receivedValue);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidReportSectionOrderError = InvalidReportSectionOrderError;