@carbonbox/domain 0.29.2 → 0.30.1

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

@@ -1,19 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidSemanticUuidFormatError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidSemanticUuidFormatError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidSemanticUuidFormatError extends CodedRootError_1.CodedRootError {
     constructor(semanticUuid, reason) {
-        const message = `The semantic UUID "${semanticUuid}" has invalid format structure: ${reason}. ${InvalidSemanticUuidFormatError.INVALID_SEMANTIC_UUID_FORMAT_ERROR_MESSAGE}`;
-        super(message);
+        const technicalMessage = `The semantic UUID "${semanticUuid}" has invalid format structure: ${reason}. Expected format: CONTEXT-DOMAIN-UUID.`;
+        const context = {
+            semanticUuid,
+            reason,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Ensure the semantic UUID follows the format: CONTEXT-DOMAIN-UUID',
+            'Verify the UUID portion is a valid UUIDv4',
+            'Check that context and domain codes are valid alphanumeric strings',
+            'Example: USR-CLT-550e8400-e29b-41d4-a716-446655440000',
+            'Validate that hyphens are correctly placed between segments',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_SEMANTIC_UUID_FORMAT, technicalMessage, context, suggestions);
         this.name = 'InvalidSemanticUuidFormatError';
     }
     static create(semanticUuid, reason) {
         return new InvalidSemanticUuidFormatError(semanticUuid, reason);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidSemanticUuidFormatError = InvalidSemanticUuidFormatError;
-InvalidSemanticUuidFormatError.INVALID_SEMANTIC_UUID_FORMAT_ERROR_MESSAGE = 'Invalid semantic UUID format structure';

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

@@ -1,18 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidStakeholderRoleTypeError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidStakeholderRoleTypeError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidStakeholderRoleTypeError extends CodedRootError_1.CodedRootError {
     constructor(invalidRole, validRoles) {
-        const message = `Invalid stakeholder role type: '${invalidRole}'. Valid roles: ${validRoles.join(', ')}.`;
-        super(message);
+        const technicalMessage = `Invalid stakeholder role type: '${invalidRole}'. Valid roles: ${validRoles.join(', ')}.`;
+        const context = {
+            invalidRole,
+            validRoles,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid stakeholder roles: ${validRoles.join(', ')}`,
+            'Verify the role matches the system requirements',
+            'Common roles include: Manager, Coordinator, Client, Host',
+            'Check the stakeholder role documentation',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_STAKEHOLDER_ROLE_TYPE, technicalMessage, context, suggestions);
         this.name = 'InvalidStakeholderRoleTypeError';
     }
     static create(invalidRole, validRoles) {
         return new InvalidStakeholderRoleTypeError(invalidRole, validRoles);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidStakeholderRoleTypeError = InvalidStakeholderRoleTypeError;

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

@@ -1,21 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidStringListError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidStringListError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidStringListError extends CodedRootError_1.CodedRootError {
     constructor(propertyName, expectedType, receivedType, invalidElements) {
         const invalidElementsMessage = invalidElements
             ? ` Invalid elements found: ${invalidElements.map((el) => `${el} (type: ${typeof el})`).join(', ')}.`
             : '';
-        const message = `Invalid array type for property '${propertyName}': expected ${expectedType}, but received ${receivedType}.${invalidElementsMessage}`;
-        super(message);
+        const technicalMessage = `Invalid array type for property '${propertyName}': expected ${expectedType}, but received ${receivedType}.${invalidElementsMessage}`;
+        const context = {
+            propertyName,
+            expectedType,
+            receivedType,
+            invalidElements: invalidElements ? invalidElements.map((el) => ({ value: el, type: typeof el })) : null,
+            hasInvalidElements: invalidElements !== null && invalidElements.length > 0,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Ensure all elements in '${propertyName}' are of type ${expectedType}`,
+            'Validate and filter array elements before creating the value object',
+            'Check the data source to ensure it provides the correct data types',
+            'Consider using type guards or validation functions to verify array element types',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_STRING_LIST, technicalMessage, context, suggestions);
         this.name = 'InvalidStringListError';
     }
     static create(propertyName, expectedType, receivedType, invalidElements) {
         return new InvalidStringListError(propertyName, expectedType, receivedType, invalidElements);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidStringListError = InvalidStringListError;

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidSubmissionError = void 0;
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidSubmissionError extends CodedRootError_1.CodedRootError {
+    constructor(submissionId, reason) {
+        const technicalMessage = `Submission '${submissionId}' is invalid: ${reason}`;
+        const context = {
+            submissionId,
+            reason,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Review the submission data for errors or missing information',
+            'Ensure all required fields are filled correctly',
+            'Check data formats and validation rules',
+            'Verify the submission status allows modifications',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_SUBMISSION, technicalMessage, context, suggestions);
+        this.name = 'InvalidSubmissionError';
+    }
+    static create(submissionId, reason) {
+        return new InvalidSubmissionError(submissionId, reason);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.InvalidSubmissionError = InvalidSubmissionError;

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

@@ -1,19 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidSupervisorRoleError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidSupervisorRoleError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidSupervisorRoleError extends CodedRootError_1.CodedRootError {
     constructor(invalidRole, allowedRoles, contextMessage) {
         const baseMessage = `Invalid supervisor role: '${invalidRole}'. Allowed supervisor 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 supervisor roles: ${allowedRoles.join(', ')}`,
+            'Verify the stakeholder has the required role to supervise others',
+            'Check the role hierarchy and supervision permissions',
+            'Common supervisor roles: Manager',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_SUPERVISOR_ROLE, technicalMessage, context, suggestions);
         this.name = 'InvalidSupervisorRoleError';
     }
     static create(invalidRole, allowedRoles, contextMessage) {
         return new InvalidSupervisorRoleError(invalidRole, allowedRoles, contextMessage);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidSupervisorRoleError = InvalidSupervisorRoleError;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidTaxIdError = void 0;
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidTaxIdError extends CodedRootError_1.CodedRootError {
+    constructor(taxId, country) {
+        const technicalMessage = country
+            ? `Tax identification number '${taxId}' is invalid for country ${country}`
+            : `Tax identification number '${taxId}' is invalid`;
+        const context = {
+            taxId,
+            country,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Verify the tax ID format for your country',
+            'Check for typos or missing digits',
+            'Ensure the tax ID includes any required check digits',
+            'Remove any spaces, dashes, or special characters',
+            'Consult your country\'s tax authority for valid formats',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_TAX_ID, technicalMessage, context, suggestions);
+        this.name = 'InvalidTaxIdError';
+    }
+    static create(taxId, country) {
+        return new InvalidTaxIdError(taxId, country);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.InvalidTaxIdError = InvalidTaxIdError;

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

@@ -1,19 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidTaxIdentificationNumberFormatError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidTaxIdentificationNumberFormatError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidTaxIdentificationNumberFormatError extends CodedRootError_1.CodedRootError {
     constructor(propertyName, value, expectedFormat) {
         const formatInfo = expectedFormat ? ` Expected format: ${expectedFormat}.` : '';
-        const message = `Tax identification number '${propertyName}' has an invalid format: '${value}'.${formatInfo}`;
-        super(message);
+        const technicalMessage = `Tax identification number '${propertyName}' has an invalid format: '${value}'.${formatInfo}`;
+        const context = {
+            propertyName,
+            value,
+            expectedFormat: expectedFormat || 'not specified',
+            hasExpectedFormat: !!expectedFormat,
+            constraint: 'tax_id_format',
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Ensure the tax identification number '${value}' matches the expected format${expectedFormat ? `: ${expectedFormat}` : ''}`,
+            'Validate the format before creating the value object',
+            'Check that the tax ID follows the country-specific format requirements',
+            'Remove any invalid characters or formatting from the tax identification number',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_TAX_IDENTIFICATION_NUMBER_FORMAT, technicalMessage, context, suggestions);
         this.name = 'InvalidTaxIdentificationNumberFormatError';
     }
     static create(propertyName, value, expectedFormat) {
         return new InvalidTaxIdentificationNumberFormatError(propertyName, value, expectedFormat);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidTaxIdentificationNumberFormatError = InvalidTaxIdentificationNumberFormatError;

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

@@ -1,18 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidTaxIdentificationNumberLengthError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidTaxIdentificationNumberLengthError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidTaxIdentificationNumberLengthError extends CodedRootError_1.CodedRootError {
     constructor(propertyName, currentLength, minLength, maxLength) {
-        const message = `Tax identification number '${propertyName}' must be between ${minLength} and ${maxLength} characters long, but received ${currentLength} characters.`;
-        super(message);
+        const technicalMessage = `Tax identification number '${propertyName}' must be between ${minLength} and ${maxLength} characters long, but received ${currentLength} characters.`;
+        const context = {
+            propertyName,
+            currentLength,
+            minLength,
+            maxLength,
+            constraint: 'tax_id_length',
+            isTooShort: currentLength < minLength,
+            isTooLong: currentLength > maxLength,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Ensure the tax identification number has between ${minLength} and ${maxLength} characters (current: ${currentLength})`,
+            'Verify the tax ID follows the correct length requirements for the country',
+            'Check for missing or extra digits in the tax identification number',
+            'Validate the length before creating the value object',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_TAX_IDENTIFICATION_NUMBER_LENGTH, technicalMessage, context, suggestions);
         this.name = 'InvalidTaxIdentificationNumberLengthError';
     }
     static create(propertyName, currentLength, minLength, maxLength) {
         return new InvalidTaxIdentificationNumberLengthError(propertyName, currentLength, minLength, maxLength);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidTaxIdentificationNumberLengthError = InvalidTaxIdentificationNumberLengthError;

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

@@ -1,18 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidTaxIdentificationTypeError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidTaxIdentificationTypeError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidTaxIdentificationTypeError extends CodedRootError_1.CodedRootError {
     constructor(invalidType, validTypes) {
-        const message = `Invalid tax identification type: '${invalidType}'. Valid types: ${validTypes.join(', ')}.`;
-        super(message);
+        const technicalMessage = `Invalid tax identification type: '${invalidType}'. Valid types: ${validTypes.join(', ')}.`;
+        const context = {
+            invalidType,
+            validTypes,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid tax identification types: ${validTypes.join(', ')}`,
+            'Common types include: NIT, RUT, RFC, EIN, VAT',
+            'Verify the type matches your country requirements',
+            'Check the tax authority documentation for valid types',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_TAX_IDENTIFICATION_TYPE, technicalMessage, context, suggestions);
         this.name = 'InvalidTaxIdentificationTypeError';
     }
     static create(invalidType, validTypes) {
         return new InvalidTaxIdentificationTypeError(invalidType, validTypes);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidTaxIdentificationTypeError = InvalidTaxIdentificationTypeError;

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

@@ -1,18 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidTimeFormatError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidTimeFormatError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidTimeFormatError extends CodedRootError_1.CodedRootError {
     constructor(value, expectedFormat) {
-        const message = `Invalid time format: '${value}' does not match the required format '${expectedFormat}'.`;
-        super(message);
+        const technicalMessage = `Invalid time format: '${value}' does not match the required format '${expectedFormat}'.`;
+        const context = {
+            receivedValue: value,
+            expectedFormat,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Provide time in the format: ${expectedFormat}`,
+            'Verify the time string format matches the expected pattern',
+            'Check for leading zeros if required (e.g., "09:30" instead of "9:30")',
+            'Ensure hours and minutes are within valid ranges',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_TIME_FORMAT, technicalMessage, context, suggestions);
         this.name = 'InvalidTimeFormatError';
     }
     static create(value, expectedFormat) {
         return new InvalidTimeFormatError(value, expectedFormat);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidTimeFormatError = InvalidTimeFormatError;

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

@@ -1,21 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidUrlListError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidUrlListError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidUrlListError 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 URLs in '${propertyName}' are valid and properly formatted`,
+            'Validate URL format (protocol, domain, path) before creating the value object',
+            'Check for common URL issues: missing protocol, invalid characters, or malformed structure',
+            'Consider using a URL validation library to ensure all URLs meet RFC 3986 standards',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_URL_LIST, technicalMessage, context, suggestions);
         this.name = 'InvalidUrlListError';
     }
     static create(propertyName, expectedType, receivedType, invalidElements = []) {
         return new InvalidUrlListError(propertyName, expectedType, receivedType, invalidElements);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidUrlListError = InvalidUrlListError;

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

@@ -1,18 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidUserBusinessStatusError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidUserBusinessStatusError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidUserBusinessStatusError extends CodedRootError_1.CodedRootError {
     constructor(value, validStatuses) {
-        const message = `Invalid user business status: '${value}'. Valid statuses are: ${validStatuses.join(', ')}.`;
-        super(message);
+        const technicalMessage = `Invalid user business status: '${value}'. Valid statuses are: ${validStatuses.join(', ')}.`;
+        const context = {
+            receivedValue: value,
+            validStatuses,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid business statuses: ${validStatuses.join(', ')}`,
+            'Verify the business status value matches exactly (case-sensitive)',
+            'Check if the business status enum has been updated',
+            'Ensure the value is being properly mapped from the source',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_USER_BUSINESS_STATUS, technicalMessage, context, suggestions);
         this.name = 'InvalidUserBusinessStatusError';
     }
     static create(value, validStatuses) {
         return new InvalidUserBusinessStatusError(value, validStatuses);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidUserBusinessStatusError = InvalidUserBusinessStatusError;

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

@@ -1,19 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidUserIdFormatError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidUserIdFormatError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidUserIdFormatError extends CodedRootError_1.CodedRootError {
     constructor(userId, reason) {
-        const message = `The UserId "${userId}" has invalid format or prefix: ${reason}. ${InvalidUserIdFormatError.INVALID_USER_ID_FORMAT_ERROR_MESSAGE}`;
-        super(message);
+        const technicalMessage = `The UserId "${userId}" has invalid format or prefix: ${reason}. Expected a valid user identifier with proper prefix and UUID structure.`;
+        const context = {
+            userId,
+            reason,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Ensure the UserId follows the format: PREFIX-DOMAIN-UUID',
+            'Verify the prefix matches a valid user type (e.g., HST, MGR, CRD, CLT)',
+            'Check that the UUID portion is a valid UUIDv4',
+            'Example valid UserId: HST-USR-550e8400-e29b-41d4-a716-446655440000',
+            'Validate that all components are correctly separated by hyphens',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_USER_ID_FORMAT, technicalMessage, context, suggestions);
         this.name = 'InvalidUserIdFormatError';
     }
     static create(userId, reason) {
         return new InvalidUserIdFormatError(userId, reason);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidUserIdFormatError = InvalidUserIdFormatError;
-InvalidUserIdFormatError.INVALID_USER_ID_FORMAT_ERROR_MESSAGE = 'Invalid UserId format or prefix structure';

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

@@ -1,18 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidUserPreferredLocaleError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidUserPreferredLocaleError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidUserPreferredLocaleError extends CodedRootError_1.CodedRootError {
     constructor(value, validLocales) {
-        const message = `Invalid preferred locale: '${value}'. Valid locales are: ${validLocales.join(', ')}.`;
-        super(message);
+        const technicalMessage = `Invalid preferred locale: '${value}'. Valid locales are: ${validLocales.join(', ')}. User locale must match supported language/region codes.`;
+        const context = {
+            value,
+            validLocales,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Valid locale codes are: ${validLocales.join(', ')}`,
+            'Locale codes should follow ISO 639-1 (language) and ISO 3166-1 (country) standards',
+            'Format: language-COUNTRY (e.g., en-US, es-CO, fr-FR)',
+            'Check that the locale is supported by the application',
+            'Verify the locale code is correctly formatted with hyphen separator',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_USER_PREFERRED_LOCALE, technicalMessage, context, suggestions);
         this.name = 'InvalidUserPreferredLocaleError';
     }
     static create(value, validLocales) {
         return new InvalidUserPreferredLocaleError(value, validLocales);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidUserPreferredLocaleError = InvalidUserPreferredLocaleError;

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

@@ -1,19 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidUserPrefixError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidUserPrefixError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidUserPrefixError extends CodedRootError_1.CodedRootError {
     constructor(userId, prefix, validPrefixes) {
-        const message = `The UserId "${userId}" has invalid prefix "${prefix}". Expected one of: [${validPrefixes.join(', ')}]. ${InvalidUserPrefixError.INVALID_USER_PREFIX_ERROR_MESSAGE}`;
-        super(message);
+        const technicalMessage = `The UserId "${userId}" has invalid prefix "${prefix}". Expected one of: [${validPrefixes.join(', ')}]. User prefixes must match valid stakeholder types.`;
+        const context = {
+            userId,
+            prefix,
+            validPrefixes,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Valid user prefixes are: ${validPrefixes.join(', ')}`,
+            'HST = Carbon Host (Administrator)',
+            'MGR = Carbon Manager',
+            'CRD = Carbon Coordinator',
+            'CLT = Carbon Client (End User)',
+            'Ensure the prefix matches your user role type',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_USER_PREFIX, technicalMessage, context, suggestions);
         this.name = 'InvalidUserPrefixError';
     }
     static create(userId, prefix, validPrefixes) {
         return new InvalidUserPrefixError(userId, prefix, validPrefixes);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidUserPrefixError = InvalidUserPrefixError;
-InvalidUserPrefixError.INVALID_USER_PREFIX_ERROR_MESSAGE = 'Invalid user prefix for UserId';

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

@@ -1,18 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidUserTypeError = void 0;
-const RootError_1 = require("./RootError");
-class InvalidUserTypeError extends RootError_1.RootError {
+const CodedRootError_1 = require("./CodedRootError");
+const ErrorCode_1 = require("../enums/ErrorCode");
+class InvalidUserTypeError extends CodedRootError_1.CodedRootError {
     constructor(value, validTypes) {
-        const message = `Invalid user type: '${value}'. Valid types are: ${validTypes.join(', ')}.`;
-        super(message);
+        const technicalMessage = `Invalid user type: '${value}'. Valid types are: ${validTypes.join(', ')}.`;
+        const context = {
+            value,
+            validTypes,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid user types: ${validTypes.join(', ')}`,
+            'Verify the user type matches the system requirements',
+            'Check the API documentation for valid user type values',
+            'Ensure the user type is spelled correctly',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_USER_TYPE, technicalMessage, context, suggestions);
         this.name = 'InvalidUserTypeError';
     }
     static create(value, validTypes) {
         return new InvalidUserTypeError(value, validTypes);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidUserTypeError = InvalidUserTypeError;