@carbonbox/domain 0.29.2 → 0.30.1

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

@@ -1,19 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidContractTypeError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidContractTypeError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidContractTypeError extends CodedRootError_1.CodedRootError {
     constructor(contractType, validTypes) {
         const validTypesText = validTypes.join(', ');
-        const message = `Invalid contract type '${contractType}'. Valid contract types are: ${validTypesText}`;
-        super(message);
+        const technicalMessage = `Invalid contract type '${contractType}'. Valid contract types are: ${validTypesText}`;
+        const context = {
+            contractType,
+            validTypes,
+            providedType: contractType,
+            allowedTypes: validTypesText,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid contract types: ${validTypesText}`,
+            'Verify the contract type configuration matches the system requirements',
+            'Check if the contract type enum has been updated recently',
+            'Contact support if you believe this contract type should be valid',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_CONTRACT_TYPE, technicalMessage, context, suggestions);
         this.name = 'InvalidContractTypeError';
     }
     static create(contractType, validTypes) {
         return new InvalidContractTypeError(contractType, validTypes);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidContractTypeError = InvalidContractTypeError;

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

@@ -1,18 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidContractValueFactorError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidContractValueFactorError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidContractValueFactorError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue) {
-        const message = `Factor cannot be negative for contract values: ${receivedValue}`;
-        super(message);
+        const technicalMessage = `Factor cannot be negative for contract values: ${receivedValue}`;
+        const context = {
+            receivedValue,
+            providedFactor: receivedValue,
+            minimumAllowedValue: 0,
+            isNegative: receivedValue < 0,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Ensure the contract value factor is a non-negative number (0 or greater)',
+            `The provided factor (${receivedValue}) is invalid. Use a positive value or zero`,
+            'Verify that the calculation producing this factor is correct',
+            'Check if there are any data validation issues in the contract value calculation',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_CONTRACT_VALUE_FACTOR, technicalMessage, context, suggestions);
         this.name = 'InvalidContractValueFactorError';
     }
     static create(receivedValue) {
         return new InvalidContractValueFactorError(receivedValue);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidContractValueFactorError = InvalidContractValueFactorError;

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

@@ -1,19 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidPaymentScheduleError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidPaymentScheduleError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidPaymentScheduleError extends CodedRootError_1.CodedRootError {
     constructor(paymentSchedule, validSchedules) {
         const validSchedulesText = validSchedules.join(', ');
-        const message = `Invalid payment schedule '${paymentSchedule}'. Valid payment schedules are: ${validSchedulesText}`;
-        super(message);
+        const technicalMessage = `Invalid payment schedule '${paymentSchedule}'. Valid payment schedules are: ${validSchedulesText}`;
+        const context = {
+            paymentSchedule,
+            validSchedules,
+            providedSchedule: paymentSchedule,
+            allowedSchedules: validSchedulesText,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid payment schedules: ${validSchedulesText}`,
+            'Verify the payment schedule configuration matches the contract requirements',
+            'Check if the payment schedule enum has been updated recently',
+            'Ensure the payment schedule is compatible with the contract type',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_PAYMENT_SCHEDULE, technicalMessage, context, suggestions);
         this.name = 'InvalidPaymentScheduleError';
     }
     static create(paymentSchedule, validSchedules) {
         return new InvalidPaymentScheduleError(paymentSchedule, validSchedules);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidPaymentScheduleError = InvalidPaymentScheduleError;

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

@@ -1,18 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidTaxRateError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidTaxRateError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidTaxRateError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue) {
-        const message = `Tax rate must be between 0 and 1: ${receivedValue}`;
-        super(message);
+        const technicalMessage = `Tax rate must be between 0 and 1: ${receivedValue}`;
+        const context = {
+            receivedValue,
+            providedRate: receivedValue,
+            minimumAllowedValue: 0,
+            maximumAllowedValue: 1,
+            isOutOfRange: receivedValue < 0 || receivedValue > 1,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Ensure the tax rate is a decimal value between 0 and 1 (e.g., 0.19 for 19%)',
+            `The provided tax rate (${receivedValue}) is out of range. Use a value from 0.0 to 1.0`,
+            'Verify that you are using decimal notation, not percentage (use 0.15 instead of 15)',
+            'Check if the tax rate calculation or data source is correct',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_TAX_RATE, technicalMessage, context, suggestions);
         this.name = 'InvalidTaxRateError';
     }
     static create(receivedValue) {
         return new InvalidTaxRateError(receivedValue);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidTaxRateError = InvalidTaxRateError;

package/build/carbonbox/purchase-management-system/purchase-orders/domain/exceptions/InvalidDiscountAmountFactorError.js

@@ -1,18 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidDiscountAmountFactorError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidDiscountAmountFactorError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidDiscountAmountFactorError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue) {
-        const message = `Factor cannot be negative for discount amount multiplication: ${receivedValue}`;
-        super(message);
+        const technicalMessage = `Factor cannot be negative for discount amount multiplication: ${receivedValue}`;
+        const context = {
+            receivedValue,
+            providedFactor: receivedValue,
+            minimumAllowedValue: 0,
+            isNegative: receivedValue < 0,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Ensure the discount amount factor is a non-negative number (0 or greater)',
+            `The provided factor (${receivedValue}) is invalid. Use a positive value or zero`,
+            'Verify that the calculation producing this factor is correct',
+            'Check if there are any data validation issues in the discount calculation',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_DISCOUNT_AMOUNT_FACTOR, technicalMessage, context, suggestions);
         this.name = 'InvalidDiscountAmountFactorError';
     }
     static create(receivedValue) {
         return new InvalidDiscountAmountFactorError(receivedValue);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidDiscountAmountFactorError = InvalidDiscountAmountFactorError;

package/build/carbonbox/purchase-management-system/purchase-orders/domain/exceptions/InvalidFixedDiscountAmountError.js

@@ -1,18 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidFixedDiscountAmountError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidFixedDiscountAmountError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidFixedDiscountAmountError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue) {
-        const message = `Fixed discount amount cannot be negative: ${receivedValue}`;
-        super(message);
+        const technicalMessage = `Fixed discount amount cannot be negative: ${receivedValue}`;
+        const context = {
+            receivedValue,
+            providedAmount: receivedValue,
+            minimumAllowedValue: 0,
+            isNegative: receivedValue < 0,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Ensure the fixed discount amount is a non-negative number (0 or greater)',
+            `The provided discount amount (${receivedValue}) is invalid. Use a positive value or zero`,
+            'Verify that the discount amount configuration is correct',
+            'Check if the discount was calculated or entered correctly',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_FIXED_DISCOUNT_AMOUNT, technicalMessage, context, suggestions);
         this.name = 'InvalidFixedDiscountAmountError';
     }
     static create(receivedValue) {
         return new InvalidFixedDiscountAmountError(receivedValue);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidFixedDiscountAmountError = InvalidFixedDiscountAmountError;

package/build/carbonbox/purchase-management-system/purchase-orders/domain/exceptions/InvalidMaximumSubtotalError.js

@@ -1,18 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidMaximumSubtotalError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidMaximumSubtotalError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidMaximumSubtotalError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue) {
-        const message = `Maximum subtotal cannot be negative: ${receivedValue}`;
-        super(message);
+        const technicalMessage = `Maximum subtotal cannot be negative: ${receivedValue}`;
+        const context = {
+            receivedValue,
+            providedMaximum: receivedValue,
+            minimumAllowedValue: 0,
+            isNegative: receivedValue < 0,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Ensure the maximum subtotal is a non-negative number (0 or greater)',
+            `The provided maximum subtotal (${receivedValue}) is invalid. Use a positive value or zero`,
+            'Verify that the maximum subtotal configuration is correct',
+            'Check if the subtotal limit was calculated or entered correctly',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_MAXIMUM_SUBTOTAL, technicalMessage, context, suggestions);
         this.name = 'InvalidMaximumSubtotalError';
     }
     static create(receivedValue) {
         return new InvalidMaximumSubtotalError(receivedValue);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidMaximumSubtotalError = InvalidMaximumSubtotalError;

package/build/carbonbox/purchase-management-system/purchase-orders/domain/exceptions/InvalidPaymentMethodError.js

@@ -1,19 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidPaymentMethodError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidPaymentMethodError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidPaymentMethodError extends CodedRootError_1.CodedRootError {
     constructor(paymentMethod, validMethods) {
         const validMethodsText = validMethods.join(', ');
-        const message = `Invalid payment method '${paymentMethod}'. Valid payment methods are: ${validMethodsText}`;
-        super(message);
+        const technicalMessage = `Invalid payment method '${paymentMethod}'. Valid payment methods are: ${validMethodsText}`;
+        const context = {
+            paymentMethod,
+            validMethods,
+            providedMethod: paymentMethod,
+            allowedMethods: validMethodsText,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid payment methods: ${validMethodsText}`,
+            'Verify the payment method configuration matches the order requirements',
+            'Check if the payment method enum has been updated recently',
+            'Ensure the payment method is supported by the system',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_PAYMENT_METHOD, technicalMessage, context, suggestions);
         this.name = 'InvalidPaymentMethodError';
     }
     static create(paymentMethod, validMethods) {
         return new InvalidPaymentMethodError(paymentMethod, validMethods);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidPaymentMethodError = InvalidPaymentMethodError;

package/build/carbonbox/purchase-management-system/purchase-orders/domain/exceptions/InvalidPaymentStatusError.js

@@ -1,19 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidPaymentStatusError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidPaymentStatusError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidPaymentStatusError extends CodedRootError_1.CodedRootError {
     constructor(paymentStatus, validStatuses) {
         const validStatusesText = validStatuses.join(', ');
-        const message = `Invalid payment status '${paymentStatus}'. Valid payment statuses are: ${validStatusesText}`;
-        super(message);
+        const technicalMessage = `Invalid payment status '${paymentStatus}'. Valid payment statuses are: ${validStatusesText}`;
+        const context = {
+            paymentStatus,
+            validStatuses,
+            providedStatus: paymentStatus,
+            allowedStatuses: validStatusesText,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid payment statuses: ${validStatusesText}`,
+            'Verify the payment status transition is allowed for this order',
+            'Check if the payment status enum has been updated recently',
+            'Ensure the payment workflow is correctly configured',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_PAYMENT_STATUS, technicalMessage, context, suggestions);
         this.name = 'InvalidPaymentStatusError';
     }
     static create(paymentStatus, validStatuses) {
         return new InvalidPaymentStatusError(paymentStatus, validStatuses);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidPaymentStatusError = InvalidPaymentStatusError;

package/build/carbonbox/purchase-management-system/purchase-orders/domain/exceptions/InvalidPercentageRangeError.js

@@ -1,18 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidPercentageRangeError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidPercentageRangeError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidPercentageRangeError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue) {
-        const message = `Percentage must be between 0 and 100: ${receivedValue}`;
-        super(message);
+        const technicalMessage = `Percentage must be between 0 and 100: ${receivedValue}`;
+        const context = {
+            receivedValue,
+            providedPercentage: receivedValue,
+            minimumAllowedValue: 0,
+            maximumAllowedValue: 100,
+            isOutOfRange: receivedValue < 0 || receivedValue > 100,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Ensure the percentage is a value between 0 and 100 (inclusive)',
+            `The provided percentage (${receivedValue}) is out of range. Use a value from 0 to 100`,
+            'Verify that you are using percentage notation, not decimal (use 15 instead of 0.15)',
+            'Check if the percentage calculation or data source is correct',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_PERCENTAGE_RANGE, technicalMessage, context, suggestions);
         this.name = 'InvalidPercentageRangeError';
     }
     static create(receivedValue) {
         return new InvalidPercentageRangeError(receivedValue);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidPercentageRangeError = InvalidPercentageRangeError;

package/build/carbonbox/purchase-management-system/purchase-orders/domain/exceptions/InvalidPurchaseOrderStatusError.js

@@ -1,19 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidPurchaseOrderStatusError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidPurchaseOrderStatusError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidPurchaseOrderStatusError extends CodedRootError_1.CodedRootError {
     constructor(orderStatus, validStatuses) {
         const validStatusesText = validStatuses.join(', ');
-        const message = `Invalid purchase order status '${orderStatus}'. Valid purchase order statuses are: ${validStatusesText}`;
-        super(message);
+        const technicalMessage = `Invalid purchase order status '${orderStatus}'. Valid purchase order statuses are: ${validStatusesText}`;
+        const context = {
+            orderStatus,
+            validStatuses,
+            providedStatus: orderStatus,
+            allowedStatuses: validStatusesText,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid purchase order statuses: ${validStatusesText}`,
+            'Verify the order status transition is allowed in the current workflow',
+            'Check if the purchase order status enum has been updated recently',
+            'Ensure the order status workflow is correctly configured',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_PURCHASE_ORDER_STATUS, technicalMessage, context, suggestions);
         this.name = 'InvalidPurchaseOrderStatusError';
     }
     static create(orderStatus, validStatuses) {
         return new InvalidPurchaseOrderStatusError(orderStatus, validStatuses);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidPurchaseOrderStatusError = InvalidPurchaseOrderStatusError;

package/build/carbonbox/purchase-management-system/purchase-orders/domain/exceptions/InvalidSubtotalAmountError.js

@@ -1,18 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidSubtotalAmountError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidSubtotalAmountError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidSubtotalAmountError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue) {
-        const message = `Subtotal amount cannot be negative: ${receivedValue}`;
-        super(message);
+        const technicalMessage = `Subtotal amount cannot be negative: ${receivedValue}`;
+        const context = {
+            receivedValue,
+            providedAmount: receivedValue,
+            minimumAllowedValue: 0,
+            isNegative: receivedValue < 0,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Ensure the subtotal amount is a non-negative number (0 or greater)',
+            `The provided subtotal amount (${receivedValue}) is invalid. Use a positive value or zero`,
+            'Verify that the subtotal calculation is correct',
+            'Check if there are any data validation issues in the order items',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_SUBTOTAL_AMOUNT, technicalMessage, context, suggestions);
         this.name = 'InvalidSubtotalAmountError';
     }
     static create(receivedValue) {
         return new InvalidSubtotalAmountError(receivedValue);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidSubtotalAmountError = InvalidSubtotalAmountError;

package/build/carbonbox/purchase-management-system/purchase-orders/domain/exceptions/InvalidSubtotalAmountFactorError.js

@@ -1,18 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidSubtotalAmountFactorError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidSubtotalAmountFactorError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidSubtotalAmountFactorError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue) {
-        const message = `Factor cannot be negative for subtotal amount multiplication: ${receivedValue}`;
-        super(message);
+        const technicalMessage = `Factor cannot be negative for subtotal amount multiplication: ${receivedValue}`;
+        const context = {
+            receivedValue,
+            constraint: 'must be greater than or equal to 0',
+            operation: 'subtotal amount multiplication',
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Verify that the factor is a positive number or zero',
+            'Check if there is a calculation error producing a negative factor',
+            'Ensure the factor calculation logic is correctly implemented',
+            'Review the source values used to calculate the factor',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_SUBTOTAL_AMOUNT_FACTOR, technicalMessage, context, suggestions);
         this.name = 'InvalidSubtotalAmountFactorError';
     }
     static create(receivedValue) {
         return new InvalidSubtotalAmountFactorError(receivedValue);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidSubtotalAmountFactorError = InvalidSubtotalAmountFactorError;

package/build/carbonbox/purchase-management-system/purchase-orders/domain/exceptions/InvalidTaxAmountFactorError.js

@@ -1,18 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidTaxAmountFactorError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidTaxAmountFactorError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidTaxAmountFactorError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue) {
-        const message = `Factor cannot be negative for tax amount multiplication: ${receivedValue}`;
-        super(message);
+        const technicalMessage = `Factor cannot be negative for tax amount multiplication: ${receivedValue}`;
+        const context = {
+            receivedValue,
+            constraint: 'must be greater than or equal to 0',
+            operation: 'tax amount multiplication',
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Verify that the factor is a positive number or zero',
+            'Check if there is a calculation error producing a negative factor',
+            'Ensure the tax calculation logic is correctly implemented',
+            'Review the source values used to calculate the tax factor',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_TAX_AMOUNT_FACTOR, technicalMessage, context, suggestions);
         this.name = 'InvalidTaxAmountFactorError';
     }
     static create(receivedValue) {
         return new InvalidTaxAmountFactorError(receivedValue);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidTaxAmountFactorError = InvalidTaxAmountFactorError;

package/build/carbonbox/purchase-management-system/purchase-orders/domain/exceptions/InvalidTotalAmountFactorError.js

@@ -1,18 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidTotalAmountFactorError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidTotalAmountFactorError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidTotalAmountFactorError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue) {
-        const message = `Factor cannot be negative for total amount multiplication: ${receivedValue}`;
-        super(message);
+        const technicalMessage = `Factor cannot be negative for total amount multiplication: ${receivedValue}`;
+        const context = {
+            receivedValue,
+            constraint: 'must be greater than or equal to 0',
+            operation: 'total amount multiplication',
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Verify that the factor is a positive number or zero',
+            'Check if there is a calculation error producing a negative factor',
+            'Ensure the total amount calculation logic is correctly implemented',
+            'Review the source values used to calculate the total factor',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_TOTAL_AMOUNT_FACTOR, technicalMessage, context, suggestions);
         this.name = 'InvalidTotalAmountFactorError';
     }
     static create(receivedValue) {
         return new InvalidTotalAmountFactorError(receivedValue);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidTotalAmountFactorError = InvalidTotalAmountFactorError;

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

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