@carbonbox/domain 0.29.1 → 0.30.0

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;

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

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

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmptyValueError = void 0;
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class EmptyValueError extends CodedRootError_1.CodedRootError {
+    constructor(propertyName, expectedType) {
+        const technicalMessage = `Value constraint violation: '${propertyName}' cannot be empty. Expected type: ${expectedType}.`;
+        const context = {
+            propertyName,
+            expectedType,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Provide a non-empty value for '${propertyName}'`,
+            `Ensure the field contains valid ${expectedType} data`,
+            'Remove any whitespace-only values',
+            'Check for empty strings, arrays, or objects',
+        ];
+        super(ErrorCode_1.ErrorCode.EMPTY_VALUE, technicalMessage, context, suggestions);
+        this.name = 'EmptyValueError';
+    }
+    static create(propertyName, expectedType) {
+        return new EmptyValueError(propertyName, expectedType);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.EmptyValueError = EmptyValueError;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalServiceError = void 0;
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class ExternalServiceError extends CodedRootError_1.CodedRootError {
+    constructor(serviceName, reason) {
+        const technicalMessage = reason
+            ? `External service '${serviceName}' is unavailable: ${reason}`
+            : `External service '${serviceName}' is unavailable`;
+        const context = {
+            serviceName,
+            reason,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Retry the operation after a few moments',
+            'Check the status of the external service',
+            'Verify network connectivity to the service',
+            'Review service configuration and endpoints',
+            'Contact support if the service remains unavailable',
+        ];
+        super(ErrorCode_1.ErrorCode.EXTERNAL_SERVICE, technicalMessage, context, suggestions);
+        this.name = 'ExternalServiceError';
+    }
+    static create(serviceName, reason) {
+        return new ExternalServiceError(serviceName, reason);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.ExternalServiceError = ExternalServiceError;

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormNotFoundError = void 0;
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class FormNotFoundError extends CodedRootError_1.CodedRootError {
+    constructor(formId) {
+        const technicalMessage = `Data collection form with ID '${formId}' was not found`;
+        const context = {
+            formId,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Verify the form ID is correct',
+            'Check if the form has been deleted or archived',
+            'Ensure you have permission to access this form',
+            'Contact your administrator if the form should exist',
+        ];
+        super(ErrorCode_1.ErrorCode.FORM_NOT_FOUND, technicalMessage, context, suggestions);
+        this.name = 'FormNotFoundError';
+    }
+    static create(formId) {
+        return new FormNotFoundError(formId);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.FormNotFoundError = FormNotFoundError;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InsufficientPermissionsError = void 0;
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InsufficientPermissionsError extends CodedRootError_1.CodedRootError {
+    constructor(operation, requiredPermissions) {
+        const technicalMessage = requiredPermissions && requiredPermissions.length > 0
+            ? `Insufficient permissions to perform operation '${operation}'. Required permissions: ${requiredPermissions.join(', ')}.`
+            : `Insufficient permissions to perform operation '${operation}'.`;
+        const context = {
+            operation,
+            requiredPermissions: requiredPermissions ? Array.from(requiredPermissions) : undefined,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Contact your administrator to request the necessary permissions',
+            'Verify you have the correct role assigned for this operation',
+            'Check if your account has been restricted or deactivated',
+            'Ensure you are logged in with the correct user account',
+            'Review your organization\'s permission policies',
+        ];
+        super(ErrorCode_1.ErrorCode.INSUFFICIENT_PERMISSIONS, technicalMessage, context, suggestions);
+        this.name = 'InsufficientPermissionsError';
+    }
+    static create(operation, requiredPermissions) {
+        return new InsufficientPermissionsError(operation, requiredPermissions);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.InsufficientPermissionsError = InsufficientPermissionsError;

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

@@ -1,18 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidAggregateIdError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidAggregateIdError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidAggregateIdError extends CodedRootError_1.CodedRootError {
     constructor(id, propertyName) {
-        const message = `The id "${id}" violates the domain policy - The propertyName's ${propertyName}`;
-        super(message);
+        const technicalMessage = `The id "${id}" violates the domain policy for property: ${propertyName}`;
+        const context = {
+            id,
+            propertyName,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Ensure the aggregate ID follows the correct format for '${propertyName}'`,
+            'Verify the ID contains only valid characters',
+            'Check if the ID length meets the requirements',
+            'Validate the ID prefix matches the expected pattern',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_AGGREGATE_ID, technicalMessage, context, suggestions);
         this.name = 'InvalidAggregateIdError';
     }
     static create(id, propertyName) {
         return new InvalidAggregateIdError(id, propertyName);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidAggregateIdError = InvalidAggregateIdError;

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

@@ -1,19 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidAggregateIdFormatError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidAggregateIdFormatError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidAggregateIdFormatError extends CodedRootError_1.CodedRootError {
     constructor(aggregateId, propertyName) {
-        const message = `The aggregate ID "${aggregateId}" violates the domain policy - ${InvalidAggregateIdFormatError.INVALID_AGGREGATE_ID_ERROR_MESSAGE}. Property: ${propertyName}`;
-        super(message);
+        const technicalMessage = `The aggregate ID "${aggregateId}" has an invalid format for property '${propertyName}'. Expected format: PREFIX_UUID (e.g., PMS-SC_550e8400-e29b-41d4-a716-446655440000 or USR-STH-CHO_550e8400-e29b-41d4-a716-446655440000)`;
+        const context = {
+            aggregateId,
+            propertyName,
+            expectedFormat: 'PREFIX_UUID',
+            examples: ['PMS-SC_550e8400-e29b-41d4-a716-446655440000', 'USR-STH-CHO_550e8400-e29b-41d4-a716-446655440000'],
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Ensure the aggregate ID follows the format: PREFIX_UUID',
+            'Verify the prefix matches the bounded context abbreviation',
+            'Check that the UUID part is a valid UUIDv4',
+            'Examples: PMS-SC_<uuid>, USR-STH-CHO_<uuid>',
+            'Validate the underscore separator between prefix and UUID',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_AGGREGATE_ID_FORMAT, technicalMessage, context, suggestions);
         this.name = 'InvalidAggregateIdFormatError';
     }
     static create(aggregateId, propertyName) {
         return new InvalidAggregateIdFormatError(aggregateId, propertyName);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidAggregateIdFormatError = InvalidAggregateIdFormatError;
-InvalidAggregateIdFormatError.INVALID_AGGREGATE_ID_ERROR_MESSAGE = 'Invalid aggregate ID format. Expected: PREFIX_UUID (e.g., PMS-SC_550e8400-e29b-41d4-a716-446655440000 or USR-STH-CHO_550e8400-e29b-41d4-a716-446655440000)';

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

@@ -1,15 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidAggregatePrefixError = void 0;
-const RootError_1 = require("./RootError");
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
 /**
  * Generic error for invalid aggregate ID prefix validation
  * Use this for any aggregate ID that needs prefix validation
  */
-class InvalidAggregatePrefixError extends RootError_1.RootError {
+class InvalidAggregatePrefixError extends CodedRootError_1.CodedRootError {
     constructor(aggregateId, entityType, currentPrefix, validPrefixes, propertyName) {
-        const message = `The ${entityType} ID "${aggregateId}" has invalid prefix "${currentPrefix}". Expected one of: [${validPrefixes.join(', ')}]. ${InvalidAggregatePrefixError.INVALID_PREFIX_ERROR_MESSAGE}. Property: ${propertyName}`;
-        super(message);
+        const technicalMessage = `The ${entityType} ID "${aggregateId}" has invalid prefix "${currentPrefix}" for property '${propertyName}'. Expected one of: [${validPrefixes.join(', ')}]`;
+        const context = {
+            aggregateId,
+            entityType,
+            currentPrefix,
+            validPrefixes,
+            propertyName,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid prefixes: ${validPrefixes.join(', ')}`,
+            `Ensure the aggregate ID for '${entityType}' starts with a correct prefix`,
+            'Verify the entity type matches the expected prefix',
+            'Check the bounded context mapping for valid prefixes',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_AGGREGATE_PREFIX, technicalMessage, context, suggestions);
         this.name = 'InvalidAggregatePrefixError';
     }
     /**
@@ -24,8 +39,7 @@ class InvalidAggregatePrefixError extends RootError_1.RootError {
         return new InvalidAggregatePrefixError(aggregateId, entityType, currentPrefix, validPrefixes, propertyName);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidAggregatePrefixError = InvalidAggregatePrefixError;
-InvalidAggregatePrefixError.INVALID_PREFIX_ERROR_MESSAGE = 'Invalid prefix for aggregate ID';

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

@@ -1,19 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidAssignerRoleError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidAssignerRoleError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidAssignerRoleError extends CodedRootError_1.CodedRootError {
     constructor(invalidRole, allowedRoles, contextMessage) {
         const baseMessage = `Invalid assigner role: '${invalidRole}'. Allowed assigner roles: ${allowedRoles.join(', ')}.`;
-        const fullMessage = contextMessage ? `${contextMessage}. ${baseMessage}` : baseMessage;
-        super(fullMessage);
+        const technicalMessage = contextMessage ? `${contextMessage}. ${baseMessage}` : baseMessage;
+        const context = {
+            invalidRole,
+            allowedRoles,
+            contextMessage,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the allowed assigner roles: ${allowedRoles.join(', ')}`,
+            'Verify the stakeholder has the required role to assign others',
+            'Check the role hierarchy and assignment permissions',
+            'Common assigner roles: Manager, Coordinator',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_ASSIGNER_ROLE, technicalMessage, context, suggestions);
         this.name = 'InvalidAssignerRoleError';
     }
     static create(invalidRole, allowedRoles, contextMessage) {
         return new InvalidAssignerRoleError(invalidRole, allowedRoles, contextMessage);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidAssignerRoleError = InvalidAssignerRoleError;

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

@@ -1,18 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidBusinessScaleError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidBusinessScaleError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidBusinessScaleError extends CodedRootError_1.CodedRootError {
     constructor(value, validScales) {
-        const message = `Invalid business scale: '${value}'. Valid scales are: ${validScales.join(', ')}.`;
-        super(message);
+        const technicalMessage = `Invalid business scale: '${value}'. Valid scales are: ${validScales.join(', ')}.`;
+        const context = {
+            value,
+            validScales,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid business scales: ${validScales.join(', ')}`,
+            'Verify the business scale matches the company size classification',
+            'Common scales include: micro, small, medium, large',
+            'Check the business classification guidelines',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_BUSINESS_SCALE, technicalMessage, context, suggestions);
         this.name = 'InvalidBusinessScaleError';
     }
     static create(value, validScales) {
         return new InvalidBusinessScaleError(value, validScales);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidBusinessScaleError = InvalidBusinessScaleError;

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

@@ -1,18 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidCodeError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidCodeError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidCodeError extends CodedRootError_1.CodedRootError {
     constructor(code, propertyName) {
-        const message = `The code "${code}" violates the domain policy - The propertyName's ${propertyName}`;
-        super(message);
+        const technicalMessage = `The code "${code}" violates the validation policy for property '${propertyName}'. Expected a valid code that meets the business requirements.`;
+        const context = {
+            code,
+            propertyName,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Verify the code follows the expected format pattern',
+            'Check that the code contains only allowed characters',
+            'Ensure the code length is within valid bounds',
+            'Review business rules for valid code structures',
+            'Codes should typically be alphanumeric without special characters',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_CODE, technicalMessage, context, suggestions);
         this.name = 'InvalidCodeError';
     }
     static create(code, propertyName) {
         return new InvalidCodeError(code, propertyName);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidCodeError = InvalidCodeError;

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

@@ -1,21 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidCodeListError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidCodeListError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidCodeListError extends CodedRootError_1.CodedRootError {
     constructor(propertyName, expectedType, receivedType, invalidElements) {
         const invalidElementsText = invalidElements.length > 0
             ? ` Invalid elements: ${invalidElements.join(', ')}`
             : '';
-        const message = `Invalid value for property '${propertyName}': expected ${expectedType}, but received ${receivedType}.${invalidElementsText}`;
-        super(message);
+        const technicalMessage = `Invalid value for property '${propertyName}': expected ${expectedType}, but received ${receivedType}.${invalidElementsText}`;
+        const context = {
+            propertyName,
+            expectedType,
+            receivedType,
+            invalidElements,
+            invalidElementsCount: invalidElements.length,
+            hasInvalidElements: invalidElements.length > 0,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Ensure all codes in '${propertyName}' match the expected format: ${expectedType}`,
+            'Validate code format before creating the value object',
+            'Check that all codes follow the naming conventions defined in the domain',
+            'Review the source data to ensure codes are properly formatted and valid',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_CODE_LIST, technicalMessage, context, suggestions);
         this.name = 'InvalidCodeListError';
     }
     static create(propertyName, expectedType, receivedType, invalidElements = []) {
         return new InvalidCodeListError(propertyName, expectedType, receivedType, invalidElements);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidCodeListError = InvalidCodeListError;

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

@@ -1,18 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidColombianNITCheckDigitError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidColombianNITCheckDigitError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidColombianNITCheckDigitError extends CodedRootError_1.CodedRootError {
     constructor(nitNumber, providedCheckDigit, expectedCheckDigit) {
-        const message = `Invalid check digit for Colombian NIT '${nitNumber}': provided '${providedCheckDigit}', expected '${expectedCheckDigit}'.`;
-        super(message);
+        const technicalMessage = `Invalid check digit for Colombian NIT '${nitNumber}': provided '${providedCheckDigit}', expected '${expectedCheckDigit}'.`;
+        const context = {
+            nitNumber,
+            providedCheckDigit,
+            expectedCheckDigit,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Correct the check digit to '${expectedCheckDigit}'`,
+            'Verify the NIT number is correct before calculating the check digit',
+            'Use the Colombian DIAN algorithm to calculate the correct check digit',
+            'Check for typos in the NIT number or check digit',
+            'Consult the official DIAN documentation for NIT validation',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_COLOMBIAN_NIT_CHECK_DIGIT, technicalMessage, context, suggestions);
         this.name = 'InvalidColombianNITCheckDigitError';
     }
     static create(nitNumber, providedCheckDigit, expectedCheckDigit) {
         return new InvalidColombianNITCheckDigitError(nitNumber, providedCheckDigit, expectedCheckDigit);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidColombianNITCheckDigitError = InvalidColombianNITCheckDigitError;

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

@@ -1,18 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidColombianNITFormatError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidColombianNITFormatError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidColombianNITFormatError extends CodedRootError_1.CodedRootError {
     constructor(value) {
-        const message = `Invalid Colombian NIT format: '${value}'. Expected format: ########-# (8-10 digits followed by check digit).`;
-        super(message);
+        const technicalMessage = `Invalid Colombian NIT format: '${value}'. Expected format: ########-# (8-10 digits followed by check digit).`;
+        const context = {
+            value,
+            expectedFormat: '########-#',
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Ensure the NIT follows the Colombian format: 8-10 digits followed by a hyphen and check digit',
+            'Example: 900123456-7',
+            'Remove any spaces, dots, or other separators except the final hyphen',
+            'Verify the NIT has the correct number of digits before the check digit',
+            'The check digit must be separated by a hyphen',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_COLOMBIAN_NIT_FORMAT, technicalMessage, context, suggestions);
         this.name = 'InvalidColombianNITFormatError';
     }
     static create(value) {
         return new InvalidColombianNITFormatError(value);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidColombianNITFormatError = InvalidColombianNITFormatError;

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

@@ -1,18 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidColombianNITNumberError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidColombianNITNumberError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidColombianNITNumberError extends CodedRootError_1.CodedRootError {
     constructor(nitNumber) {
-        const message = `Invalid Colombian NIT number: '${nitNumber}'. Must be 8 to 10 digits.`;
-        super(message);
+        const technicalMessage = `Invalid Colombian NIT number: '${nitNumber}'. Must be 8 to 10 digits.`;
+        const context = {
+            nitNumber,
+            minDigits: 8,
+            maxDigits: 10,
+            actualLength: nitNumber ? nitNumber.replace(/\D/g, '').length : 0,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Ensure the NIT contains between 8 and 10 numeric digits',
+            'Remove any letters, spaces, or special characters except the final hyphen and check digit',
+            'Verify the NIT number is complete and not truncated',
+            'Check for missing leading zeros if applicable',
+            'Examples: 900123456-7 (9 digits + check digit), 12345678-9 (8 digits + check digit)',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_COLOMBIAN_NIT_NUMBER, technicalMessage, context, suggestions);
         this.name = 'InvalidColombianNITNumberError';
     }
     static create(nitNumber) {
         return new InvalidColombianNITNumberError(nitNumber);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidColombianNITNumberError = InvalidColombianNITNumberError;

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

@@ -1,17 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidCoordinatesError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidCoordinatesError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidCoordinatesError extends CodedRootError_1.CodedRootError {
     constructor(message) {
-        super(message);
+        const technicalMessage = message;
+        const context = {
+            message,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Ensure latitude is between -90 and 90 degrees',
+            'Ensure longitude is between -180 and 180 degrees',
+            'Verify coordinates follow the decimal degrees format (e.g., 40.7128, -74.0060)',
+            'Check for invalid characters or incorrect decimal separators',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_COORDINATES, technicalMessage, context, suggestions);
         this.name = 'InvalidCoordinatesError';
     }
     static create(message) {
         return new InvalidCoordinatesError(message);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidCoordinatesError = InvalidCoordinatesError;