@carbonbox/domain 0.29.1 → 0.30.0

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StakeholderExistsError = void 0;
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class StakeholderExistsError extends CodedRootError_1.CodedRootError {
+    constructor(email, stakeholderType) {
+        const technicalMessage = stakeholderType
+            ? `A ${stakeholderType} stakeholder already exists with email: ${email}`
+            : `A stakeholder already exists with this email: ${email}`;
+        const context = {
+            email,
+            stakeholderType,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Use a different email address',
+            'Check if the stakeholder was previously registered',
+            'Verify the email address for typos',
+            'Contact support if you need to reactivate a deactivated stakeholder',
+            'Use the update endpoint if you need to modify an existing stakeholder',
+        ];
+        super(ErrorCode_1.ErrorCode.STAKEHOLDER_EXISTS, technicalMessage, context, suggestions);
+        this.name = 'StakeholderExistsError';
+    }
+    static create(email, stakeholderType) {
+        return new StakeholderExistsError(email, stakeholderType);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.StakeholderExistsError = StakeholderExistsError;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubmissionLockedError = void 0;
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class SubmissionLockedError extends CodedRootError_1.CodedRootError {
+    constructor(submissionId, reason) {
+        const technicalMessage = reason
+            ? `Submission '${submissionId}' is locked and cannot be modified: ${reason}`
+            : `Submission '${submissionId}' is locked and cannot be modified`;
+        const context = {
+            submissionId,
+            reason,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Unlock the submission before making changes',
+            'Contact an administrator to unlock this submission',
+            'Check if the submission has been finalized or approved',
+            'Verify the lock status and who locked it',
+            'Create a new submission if modifications are not allowed',
+        ];
+        super(ErrorCode_1.ErrorCode.SUBMISSION_LOCKED, technicalMessage, context, suggestions);
+        this.name = 'SubmissionLockedError';
+    }
+    static create(submissionId, reason) {
+        return new SubmissionLockedError(submissionId, reason);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.SubmissionLockedError = SubmissionLockedError;

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

@@ -1,18 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaxIdentificationNumberWithControlCharactersError = void 0;
-const RootError_1 = require("./RootError");
-class TaxIdentificationNumberWithControlCharactersError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class TaxIdentificationNumberWithControlCharactersError extends CodedRootError_1.CodedRootError {
     constructor(propertyName) {
-        const message = `Tax identification number '${propertyName}' contains invalid control characters.`;
-        super(message);
+        const technicalMessage = `Tax identification number '${propertyName}' contains invalid control characters.`;
+        const context = {
+            propertyName,
+            constraint: 'no_control_characters',
+            errorType: 'invalid_characters',
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Remove control characters from the tax identification number '${propertyName}'`,
+            'Ensure the tax ID contains only alphanumeric characters and allowed special characters',
+            'Sanitize input to remove invisible or control characters before validation',
+            'Validate that the tax identification number contains only printable characters',
+        ];
+        super(ErrorCode_1.ErrorCode.TAX_IDENTIFICATION_NUMBER_WITH_CONTROL_CHARACTERS, technicalMessage, context, suggestions);
         this.name = 'TaxIdentificationNumberWithControlCharactersError';
     }
     static create(propertyName) {
         return new TaxIdentificationNumberWithControlCharactersError(propertyName);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.TaxIdentificationNumberWithControlCharactersError = TaxIdentificationNumberWithControlCharactersError;

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenInvalidError = void 0;
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class TokenInvalidError extends CodedRootError_1.CodedRootError {
+    constructor(reason) {
+        const technicalMessage = reason
+            ? `Authentication token is invalid: ${reason}`
+            : 'Authentication token is invalid or malformed';
+        const context = {
+            reason,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Verify the token format is correct (JWT format expected)',
+            'Check that the token has not been tampered with',
+            'Ensure the token signature is valid',
+            'Request a new authentication token by logging in again',
+            'Verify the token is not corrupted during transmission',
+        ];
+        super(ErrorCode_1.ErrorCode.TOKEN_INVALID, technicalMessage, context, suggestions);
+        this.name = 'TokenInvalidError';
+    }
+    static create(reason) {
+        return new TokenInvalidError(reason);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.TokenInvalidError = TokenInvalidError;

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

@@ -1,18 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UndefinedValueError = void 0;
-const RootError_1 = require("./RootError");
-class UndefinedValueError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class UndefinedValueError extends CodedRootError_1.CodedRootError {
     constructor(propertyName, expectedType) {
-        const message = `Value constraint violation: '${propertyName}' cannot be undefined. Expected type: ${expectedType}.`;
-        super(message);
+        const technicalMessage = `Value constraint violation: '${propertyName}' cannot be undefined. Expected type: ${expectedType}.`;
+        const context = {
+            propertyName,
+            expectedType,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Ensure '${propertyName}' is provided and not undefined`,
+            `Verify the property has a value of type ${expectedType}`,
+            'Check for missing required fields in the request',
+            'Review default values and initialization logic',
+        ];
+        super(ErrorCode_1.ErrorCode.UNDEFINED_VALUE, technicalMessage, context, suggestions);
         this.name = 'UndefinedValueError';
     }
     static create(propertyName, expectedType) {
         return new UndefinedValueError(propertyName, expectedType);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.UndefinedValueError = UndefinedValueError;

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

@@ -1,19 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnknownBoundedContextCodeError = void 0;
-const RootError_1 = require("./RootError");
-class UnknownBoundedContextCodeError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class UnknownBoundedContextCodeError extends CodedRootError_1.CodedRootError {
     constructor(contextCode, semanticUuid) {
-        const message = `The bounded context code "${contextCode}" is not recognized in semantic UUID "${semanticUuid}". ${UnknownBoundedContextCodeError.UNKNOWN_BOUNDED_CONTEXT_CODE_ERROR_MESSAGE}`;
-        super(message);
+        const technicalMessage = `The bounded context code "${contextCode}" is not recognized in semantic UUID "${semanticUuid}". Expected a valid bounded context identifier from the system.`;
+        const context = {
+            contextCode,
+            semanticUuid,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Verify the context code matches a registered bounded context',
+            'Valid context codes include: USR, CFG, ADC, EMC, RSC, etc.',
+            'Check the bounded context registry for available codes',
+            'Ensure the semantic UUID follows the format: CONTEXT-DOMAIN-UUID',
+            'Contact system administrator if you need a new bounded context registered',
+        ];
+        super(ErrorCode_1.ErrorCode.UNKNOWN_BOUNDED_CONTEXT_CODE, technicalMessage, context, suggestions);
         this.name = 'UnknownBoundedContextCodeError';
     }
     static create(contextCode, semanticUuid) {
         return new UnknownBoundedContextCodeError(contextCode, semanticUuid);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.UnknownBoundedContextCodeError = UnknownBoundedContextCodeError;
-UnknownBoundedContextCodeError.UNKNOWN_BOUNDED_CONTEXT_CODE_ERROR_MESSAGE = 'Unknown bounded context code in semantic UUID';

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

@@ -1,18 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnsupportedStakeholderRoleError = void 0;
-const RootError_1 = require("./RootError");
-class UnsupportedStakeholderRoleError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class UnsupportedStakeholderRoleError extends CodedRootError_1.CodedRootError {
     constructor(roleType) {
-        const message = `Unsupported stakeholder role: ${roleType}`;
-        super(message);
+        const technicalMessage = `Unsupported stakeholder role: ${roleType}`;
+        const context = {
+            roleType,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Verify the stakeholder role is valid and supported by the system',
+            'Check if the role has been deprecated or removed',
+            'Supported roles: Manager, Coordinator, Client, Host',
+            'Contact support if you believe this role should be supported',
+        ];
+        super(ErrorCode_1.ErrorCode.UNSUPPORTED_STAKEHOLDER_ROLE, technicalMessage, context, suggestions);
         this.name = 'UnsupportedStakeholderRoleError';
     }
     static create(roleType) {
         return new UnsupportedStakeholderRoleError(roleType);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.UnsupportedStakeholderRoleError = UnsupportedStakeholderRoleError;

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

@@ -1,18 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnsupportedUserTypeError = void 0;
-const RootError_1 = require("./RootError");
-class UnsupportedUserTypeError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class UnsupportedUserTypeError extends CodedRootError_1.CodedRootError {
     constructor(userType) {
-        const message = `Unsupported user type: ${userType}`;
-        super(message);
+        const technicalMessage = `Unsupported user type: ${userType}`;
+        const context = {
+            userType,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Verify the user type value is one of the supported types',
+            'Check if the user type enum has been updated but not all handlers',
+            'Ensure the user type is properly mapped in the system',
+            'Contact development team if this is a new user type that should be supported',
+        ];
+        super(ErrorCode_1.ErrorCode.UNSUPPORTED_USER_TYPE, technicalMessage, context, suggestions);
         this.name = 'UnsupportedUserTypeError';
     }
     static create(userType) {
         return new UnsupportedUserTypeError(userType);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.UnsupportedUserTypeError = UnsupportedUserTypeError;

package/build/carbonbox/shared/either/domain/exceptions/CannotAccessLeftOnRightValueError.js

@@ -1,17 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CannotAccessLeftOnRightValueError = void 0;
-const RootError_1 = require("../../../domain/exceptions/RootError");
-class CannotAccessLeftOnRightValueError extends RootError_1.RootError {
-    constructor(message) {
-        super(message);
+const CodedRootError_1 = require("../../../domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../domain/enums/ErrorCode");
+class CannotAccessLeftOnRightValueError extends CodedRootError_1.CodedRootError {
+    constructor(value) {
+        const technicalMessage = `Cannot access left value on Right${value ? ` (value: ${JSON.stringify(value)})` : ''}`;
+        const context = {
+            attemptedAccess: 'left',
+            actualType: 'Right',
+            value: value ?? null,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Verify that the Either is a Left before accessing the left value',
+            'Use isLeft() method to check the Either type before accessing',
+            'Use fold() or match() methods to handle both Left and Right cases safely',
+            'Consider using map() or flatMap() for functional transformations',
+        ];
+        super(ErrorCode_1.ErrorCode.CANNOT_ACCESS_LEFT_ON_RIGHT_VALUE, technicalMessage, context, suggestions);
         this.name = 'CannotAccessLeftOnRightValueError';
     }
     static create(value) {
-        return new CannotAccessLeftOnRightValueError(`Cannot access left value on Right${value ? `(${value})` : ''}`);
+        return new CannotAccessLeftOnRightValueError(value);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.CannotAccessLeftOnRightValueError = CannotAccessLeftOnRightValueError;

package/build/carbonbox/shared/either/domain/exceptions/CannotAccessRightOnLeftValueError.js

@@ -1,17 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CannotAccessRightOnLeftValueError = void 0;
-const RootError_1 = require("../../../domain/exceptions/RootError");
-class CannotAccessRightOnLeftValueError extends RootError_1.RootError {
-    constructor(message) {
-        super(message);
+const CodedRootError_1 = require("../../../domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../domain/enums/ErrorCode");
+class CannotAccessRightOnLeftValueError extends CodedRootError_1.CodedRootError {
+    constructor(value) {
+        const technicalMessage = `Cannot access right value on Left${value ? ` (value: ${JSON.stringify(value)})` : ''}`;
+        const context = {
+            attemptedAccess: 'right',
+            actualType: 'Left',
+            value: value ?? null,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Verify that the Either is a Right before accessing the right value',
+            'Use isRight() method to check the Either type before accessing',
+            'Use fold() or match() methods to handle both Left and Right cases safely',
+            'Consider using map() or flatMap() for functional transformations',
+        ];
+        super(ErrorCode_1.ErrorCode.CANNOT_ACCESS_RIGHT_ON_LEFT_VALUE, technicalMessage, context, suggestions);
         this.name = 'CannotAccessRightOnLeftValueError';
     }
     static create(value) {
-        return new CannotAccessRightOnLeftValueError(`Cannot access right value on Left${value ? `(${value})` : ''}`);
+        return new CannotAccessRightOnLeftValueError(value);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.CannotAccessRightOnLeftValueError = CannotAccessRightOnLeftValueError;

package/build/carbonbox/shared/either/domain/exceptions/FilterOperationNotImplementedError.js

@@ -1,17 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FilterOperationNotImplementedError = void 0;
-const RootError_1 = require("../../../domain/exceptions/RootError");
-class FilterOperationNotImplementedError extends RootError_1.RootError {
-    constructor(message) {
-        super(message);
+const CodedRootError_1 = require("../../../domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../domain/enums/ErrorCode");
+class FilterOperationNotImplementedError extends CodedRootError_1.CodedRootError {
+    constructor(message, contextInfo) {
+        const technicalMessage = `Filter operation must be implemented via EitherUtils${contextInfo ? ` in ${contextInfo}` : ''}`;
+        const context = {
+            requiredImplementation: 'EitherUtils',
+            operation: 'filter',
+            contextInfo: contextInfo || 'not specified',
+            errorType: 'operation_not_implemented',
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Implement the filter operation using EitherUtils for proper Either monad handling',
+            'Ensure that filter operations on Either types are delegated to EitherUtils methods',
+            'Review the Either monad pattern documentation for correct filter implementation',
+            'Check if the context requires specific filter logic and implement it in EitherUtils',
+        ];
+        super(ErrorCode_1.ErrorCode.FILTER_OPERATION_NOT_IMPLEMENTED, technicalMessage, context, suggestions);
         this.name = 'FilterOperationNotImplementedError';
     }
     static create(context) {
-        return new FilterOperationNotImplementedError(`Filter operation must be implemented via EitherUtils${context ? ` in ${context}` : ''}`);
+        return new FilterOperationNotImplementedError('', context);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.FilterOperationNotImplementedError = FilterOperationNotImplementedError;

package/build/carbonbox/shared/either/domain/exceptions/SwapOperationNotImplementedError.js

@@ -1,17 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SwapOperationNotImplementedError = void 0;
-const RootError_1 = require("../../../domain/exceptions/RootError");
-class SwapOperationNotImplementedError extends RootError_1.RootError {
-    constructor(message) {
-        super(message);
+const CodedRootError_1 = require("../../../domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../domain/enums/ErrorCode");
+class SwapOperationNotImplementedError extends CodedRootError_1.CodedRootError {
+    constructor(message, contextInfo) {
+        const technicalMessage = `Swap operation must be implemented via EitherUtils${contextInfo ? ` in ${contextInfo}` : ''}`;
+        const context = {
+            requiredImplementation: 'EitherUtils',
+            operation: 'swap',
+            contextInfo: contextInfo || 'not specified',
+            errorType: 'operation_not_implemented',
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Implement the swap operation using EitherUtils for proper Either monad handling',
+            'Ensure that swap operations on Either types are delegated to EitherUtils methods',
+            'Review the Either monad pattern documentation for correct swap implementation',
+            'Check if the context requires specific swap logic and implement it in EitherUtils',
+        ];
+        super(ErrorCode_1.ErrorCode.SWAP_OPERATION_NOT_IMPLEMENTED, technicalMessage, context, suggestions);
         this.name = 'SwapOperationNotImplementedError';
     }
     static create(context) {
-        return new SwapOperationNotImplementedError(`Swap operation must be implemented via EitherUtils${context ? ` in ${context}` : ''}`);
+        return new SwapOperationNotImplementedError('', context);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.SwapOperationNotImplementedError = SwapOperationNotImplementedError;

package/build/carbonbox/shared/either/index.js

@@ -3,7 +3,7 @@
 // EITHER PATTERN - PUNTO DE ENTRADA PRINCIPAL
 // =============================================================================
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IS_REFACTORED = exports.EITHER_VERSION = exports.ResultUtils = exports.RightEither = exports.LeftEither = exports.Either = exports.CannotAccessRightOnLeftValueError = exports.CannotAccessLeftOnRightValueError = exports.ResultExtensions = exports.EitherUtils = exports.ResultFactory = exports.EitherFactory = exports.RightEitherImpl = exports.LeftEitherImpl = void 0;
+exports.IS_REFACTORED = exports.EITHER_VERSION = exports.ResultUtils = exports.RightEither = exports.LeftEither = exports.Either = exports.SwapOperationNotImplementedError = exports.FilterOperationNotImplementedError = exports.CannotAccessRightOnLeftValueError = exports.CannotAccessLeftOnRightValueError = exports.ResultExtensions = exports.EitherUtils = exports.ResultFactory = exports.EitherFactory = exports.RightEitherImpl = exports.LeftEitherImpl = void 0;
 exports.configureEither = configureEither;
 exports.getEitherConfig = getEitherConfig;
 // ─── Imports para compatibilidad ────────────────────────────────────────────
@@ -28,6 +28,10 @@ var CannotAccessLeftOnRightValueError_1 = require("./domain/exceptions/CannotAcc
 Object.defineProperty(exports, "CannotAccessLeftOnRightValueError", { enumerable: true, get: function () { return CannotAccessLeftOnRightValueError_1.CannotAccessLeftOnRightValueError; } });
 var CannotAccessRightOnLeftValueError_1 = require("./domain/exceptions/CannotAccessRightOnLeftValueError");
 Object.defineProperty(exports, "CannotAccessRightOnLeftValueError", { enumerable: true, get: function () { return CannotAccessRightOnLeftValueError_1.CannotAccessRightOnLeftValueError; } });
+var FilterOperationNotImplementedError_1 = require("./domain/exceptions/FilterOperationNotImplementedError");
+Object.defineProperty(exports, "FilterOperationNotImplementedError", { enumerable: true, get: function () { return FilterOperationNotImplementedError_1.FilterOperationNotImplementedError; } });
+var SwapOperationNotImplementedError_1 = require("./domain/exceptions/SwapOperationNotImplementedError");
+Object.defineProperty(exports, "SwapOperationNotImplementedError", { enumerable: true, get: function () { return SwapOperationNotImplementedError_1.SwapOperationNotImplementedError; } });
 // =============================================================================
 // COMPATIBILIDAD CON API EXISTENTE
 // =============================================================================

package/build/carbonbox/stakeholders/carbon-clients/domain/entity/CarbonClient.js

@@ -57,16 +57,18 @@ class CarbonClient extends Stakeholder_1.Stakeholder {
         const lastAccessAt = skipDomainValidation
             ? CarbonClientLastAccessAt_1.CarbonClientLastAccessAt.fromPrimitives(props.lastAccessAt).toPrimitives()
             : CarbonClientLastAccessAt_1.CarbonClientLastAccessAt.create(props.lastAccessAt).toPrimitives();
-        const taxIdentification = props.taxIdentification === null
-            ? null
-            : (skipDomainValidation
+        let taxIdentification = null;
+        if (props.taxIdentification !== null) {
+            taxIdentification = skipDomainValidation
                 ? CarbonClientTaxIdentification_1.CarbonClientTaxIdentification.fromPrimitives(props.taxIdentification).toPrimitives()
-                : CarbonClientTaxIdentification_1.CarbonClientTaxIdentification.create(props.taxIdentification).toPrimitives());
-        const identityDocument = props.identityDocument === null
-            ? null
-            : (skipDomainValidation
+                : CarbonClientTaxIdentification_1.CarbonClientTaxIdentification.create(props.taxIdentification).toPrimitives();
+        }
+        let identityDocument = null;
+        if (props.identityDocument !== null) {
+            identityDocument = skipDomainValidation
                 ? CarbonClientIdentityDocument_1.CarbonClientIdentityDocument.fromPrimitives(props.identityDocument).toPrimitives()
-                : CarbonClientIdentityDocument_1.CarbonClientIdentityDocument.create(props.identityDocument).toPrimitives());
+                : CarbonClientIdentityDocument_1.CarbonClientIdentityDocument.create(props.identityDocument).toPrimitives();
+        }
         const roleType = skipDomainValidation
             ? CarbonClientRoleType_1.CarbonClientRoleType.fromPrimitives(props.roleType).toEnum()
             : CarbonClientRoleType_1.CarbonClientRoleType.create(props.roleType).toEnum();

package/build/carbonbox/stakeholders/carbon-clients/domain/exceptions/InvalidCarbonClientAccountTypeError.js

@@ -1,18 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidCarbonClientAccountTypeError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidCarbonClientAccountTypeError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidCarbonClientAccountTypeError extends CodedRootError_1.CodedRootError {
     constructor(value, validAccountTypes) {
-        const message = `Invalid carbon client account type: '${value}'. Valid account types are: ${validAccountTypes.join(', ')}.`;
-        super(message);
+        const technicalMessage = `Invalid carbon client account type provided: '${value}'. The specified account type is not recognized in the carbon client classification system.`;
+        const context = {
+            receivedValue: value,
+            validAccountTypes,
+            validAccountTypesCount: validAccountTypes.length,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid carbon client account types: ${validAccountTypes.join(', ')}`,
+            'Verify that the account type matches the client business classification requirements',
+            'Check the carbon client account type enum or configuration for available options',
+            'Review the client onboarding process to ensure proper account type selection',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_CARBON_CLIENT_ACCOUNT_TYPE, technicalMessage, context, suggestions);
         this.name = 'InvalidCarbonClientAccountTypeError';
     }
     static create(value, validAccountTypes) {
         return new InvalidCarbonClientAccountTypeError(value, validAccountTypes);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidCarbonClientAccountTypeError = InvalidCarbonClientAccountTypeError;

package/build/carbonbox/stakeholders/carbon-coordinators/domain/entity/CarbonCoordinator.js

@@ -53,16 +53,18 @@ class CarbonCoordinator extends Stakeholder_1.Stakeholder {
         const lastAccessAt = skipDomainValidation
             ? CarbonCoordinatorLastAccessAt_1.CarbonCoordinatorLastAccessAt.fromPrimitives(props.lastAccessAt).toPrimitives()
             : CarbonCoordinatorLastAccessAt_1.CarbonCoordinatorLastAccessAt.create(props.lastAccessAt).toPrimitives();
-        const taxIdentification = props.taxIdentification === null
-            ? null
-            : (skipDomainValidation
+        let taxIdentification = null;
+        if (props.taxIdentification !== null) {
+            taxIdentification = skipDomainValidation
                 ? CarbonCoordinatorTaxIdentification_1.CarbonCoordinatorTaxIdentification.fromPrimitives(props.taxIdentification).toPrimitives()
-                : CarbonCoordinatorTaxIdentification_1.CarbonCoordinatorTaxIdentification.create(props.taxIdentification).toPrimitives());
-        const identityDocument = props.identityDocument === null
-            ? null
-            : (skipDomainValidation
+                : CarbonCoordinatorTaxIdentification_1.CarbonCoordinatorTaxIdentification.create(props.taxIdentification).toPrimitives();
+        }
+        let identityDocument = null;
+        if (props.identityDocument !== null) {
+            identityDocument = skipDomainValidation
                 ? CarbonCoordinatorIdentityDocument_1.CarbonCoordinatorIdentityDocument.fromPrimitives(props.identityDocument).toPrimitives()
-                : CarbonCoordinatorIdentityDocument_1.CarbonCoordinatorIdentityDocument.create(props.identityDocument).toPrimitives());
+                : CarbonCoordinatorIdentityDocument_1.CarbonCoordinatorIdentityDocument.create(props.identityDocument).toPrimitives();
+        }
         const roleType = skipDomainValidation
             ? CarbonCoordinatorRoleType_1.CarbonCoordinatorRoleType.fromPrimitives(props.roleType).toEnum()
             : CarbonCoordinatorRoleType_1.CarbonCoordinatorRoleType.create(props.roleType).toEnum();

package/build/carbonbox/stakeholders/carbon-coordinators/domain/exceptions/InvalidCarbonCoordinatorAvailabilityStatusError.js

@@ -1,18 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidCarbonCoordinatorAvailabilityStatusError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidCarbonCoordinatorAvailabilityStatusError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidCarbonCoordinatorAvailabilityStatusError extends CodedRootError_1.CodedRootError {
     constructor(invalidValue, validValues, propertyName = 'availabilityStatus') {
-        const message = `${propertyName} constraint violation: '${invalidValue}' is not a valid availability status. Valid values are: [${validValues.join(', ')}].`;
-        super(message);
+        const technicalMessage = `Carbon coordinator ${propertyName} constraint violation: '${invalidValue}' is not a valid availability status. The provided status is not recognized in the coordinator availability management system.`;
+        const context = {
+            propertyName,
+            receivedValue: invalidValue,
+            validValues,
+            validValuesCount: validValues.length,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid availability status values: ${validValues.join(', ')}`,
+            `Verify that the ${propertyName} value matches the coordinator availability state requirements`,
+            'Check the carbon coordinator availability status enum or configuration for available options',
+            'Review the coordinator status transition logic to ensure valid state changes',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_CARBON_COORDINATOR_AVAILABILITY_STATUS, technicalMessage, context, suggestions);
         this.name = 'InvalidCarbonCoordinatorAvailabilityStatusError';
     }
     static create(invalidValue, validValues, propertyName = 'availabilityStatus') {
         return new InvalidCarbonCoordinatorAvailabilityStatusError(invalidValue, validValues, propertyName);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidCarbonCoordinatorAvailabilityStatusError = InvalidCarbonCoordinatorAvailabilityStatusError;

package/build/carbonbox/stakeholders/carbon-host/domain/entity/CarbonHost.js

@@ -36,11 +36,12 @@ class CarbonHost extends Stakeholder_1.Stakeholder {
             : CarbonHostLastAccessAt_1.CarbonHostLastAccessAt.create(props.lastAccessAt).toPrimitives();
         // USR-020: Host conserva taxIdentification (a nivel app sigue requerido); identityDocument
         // no aplica al Host (siempre null). El tipo base es nullable, de ahí el manejo defensivo.
-        const taxIdentification = props.taxIdentification === null
-            ? null
-            : (skipDomainValidation
+        let taxIdentification = null;
+        if (props.taxIdentification !== null) {
+            taxIdentification = skipDomainValidation
                 ? CarbonHostTaxIdentification_1.CarbonHostTaxIdentification.fromPrimitives(props.taxIdentification).toPrimitives()
-                : CarbonHostTaxIdentification_1.CarbonHostTaxIdentification.create(props.taxIdentification).toPrimitives());
+                : CarbonHostTaxIdentification_1.CarbonHostTaxIdentification.create(props.taxIdentification).toPrimitives();
+        }
         const roleType = skipDomainValidation
             ? CarbonHostRoleType_1.CarbonHostRoleType.fromPrimitives(props.roleType).toEnum()
             : CarbonHostRoleType_1.CarbonHostRoleType.create(props.roleType).toEnum();