@carbonbox/domain 0.29.2 → 0.30.0

package/build/carbonbox/activity-data-collection/activity-data-submissions/domain/exceptions/InvalidActivityDataSubmissionCountryError.js

@@ -1,20 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidActivityDataSubmissionCountryError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
 const CountryCode_1 = require("../../../../shared/domain/enums/CountryCode");
-class InvalidActivityDataSubmissionCountryError extends RootError_1.RootError {
+class InvalidActivityDataSubmissionCountryError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue) {
         const validCountries = Object.values(CountryCode_1.CountryCode).join(', ');
-        const message = `Invalid activity data submission country '${receivedValue}': must be a valid ISO CountryCode (one of ${validCountries}).`;
-        super(message);
+        const technicalMessage = `Invalid activity data submission country '${receivedValue}': must be a valid ISO CountryCode (one of ${validCountries}).`;
+        const context = {
+            receivedValue,
+            validCountries: Object.values(CountryCode_1.CountryCode),
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Use a valid ISO 3166-1 alpha-2 country code (e.g., CO for Colombia, US for United States)',
+            'Verify the country code is in uppercase',
+            'Check if the CountryCode enum has been updated with new countries',
+            'Ensure the country code matches the expected format',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_SUBMISSION_COUNTRY, technicalMessage, context, suggestions);
         this.name = 'InvalidActivityDataSubmissionCountryError';
     }
     static create(receivedValue) {
         return new InvalidActivityDataSubmissionCountryError(receivedValue);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidActivityDataSubmissionCountryError = InvalidActivityDataSubmissionCountryError;

package/build/carbonbox/activity-data-collection/activity-data-submissions/domain/exceptions/InvalidActivityDataSubmissionStakeholderRoleError.js

@@ -1,19 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidActivityDataSubmissionStakeholderRoleError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidActivityDataSubmissionStakeholderRoleError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidActivityDataSubmissionStakeholderRoleError extends CodedRootError_1.CodedRootError {
     constructor(receivedRole, validRoles) {
         const validRolesList = validRoles.join(', ');
-        const message = `Invalid stakeholder role for activity data submission: '${receivedRole}'. Only ${validRolesList} can fill activity data submissions.`;
-        super(message);
+        const technicalMessage = `Invalid stakeholder role for activity data submission: '${receivedRole}'. Only ${validRolesList} can fill activity data submissions.`;
+        const context = {
+            receivedRole,
+            validRoles,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Ensure the stakeholder has one of these roles: ${validRolesList}`,
+            'Verify the stakeholder role is correctly assigned',
+            'Check if the role permissions have been updated',
+            'Contact administrator to update stakeholder role if needed',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_SUBMISSION_STAKEHOLDER_ROLE, technicalMessage, context, suggestions);
         this.name = 'InvalidActivityDataSubmissionStakeholderRoleError';
     }
     static create(receivedRole, validRoles) {
         return new InvalidActivityDataSubmissionStakeholderRoleError(receivedRole, validRoles);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidActivityDataSubmissionStakeholderRoleError = InvalidActivityDataSubmissionStakeholderRoleError;

package/build/carbonbox/activity-data-collection/activity-data-submissions/domain/exceptions/InvalidEmissionScopeError.js

@@ -1,18 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidEmissionScopeError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidEmissionScopeError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidEmissionScopeError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue) {
-        const message = `Invalid emission scope value '${receivedValue}': must be either a valid GHGScope (SCOPE_1, SCOPE_2, SCOPE_3) or ISOCategory (CATEGORY_1, CATEGORY_2, CATEGORY_3, CATEGORY_4, CATEGORY_5, CATEGORY_6).`;
-        super(message);
+        const technicalMessage = `Invalid emission scope value '${receivedValue}': must be either a valid GHGScope (SCOPE_1, SCOPE_2, SCOPE_3) or ISOCategory (CATEGORY_1, CATEGORY_2, CATEGORY_3, CATEGORY_4, CATEGORY_5, CATEGORY_6).`;
+        const context = {
+            receivedValue,
+            validGHGScopes: ['SCOPE_1', 'SCOPE_2', 'SCOPE_3'],
+            validISOCategories: ['CATEGORY_1', 'CATEGORY_2', 'CATEGORY_3', 'CATEGORY_4', 'CATEGORY_5', 'CATEGORY_6'],
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Use a valid GHG Protocol scope (SCOPE_1, SCOPE_2, SCOPE_3) for GHG Protocol standard',
+            'Use a valid ISO 14064 category (CATEGORY_1-6) for ISO 14064 standard',
+            'Verify the emission scope matches the selected reporting standard',
+            'Check if the emission scope enum has been updated',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_EMISSION_SCOPE, technicalMessage, context, suggestions);
         this.name = 'InvalidEmissionScopeError';
     }
     static create(receivedValue) {
         return new InvalidEmissionScopeError(receivedValue);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidEmissionScopeError = InvalidEmissionScopeError;

package/build/carbonbox/activity-data-collection/activity-data-submissions/domain/exceptions/InvalidEmissionScopeTypeError.js

@@ -1,18 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidEmissionScopeTypeError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidEmissionScopeTypeError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidEmissionScopeTypeError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue, expectedType) {
-        const message = `Cannot convert emission scope value '${receivedValue}' to ${expectedType}. Value is not a valid ${expectedType}.`;
-        super(message);
+        const technicalMessage = `Cannot convert emission scope value '${receivedValue}' to ${expectedType}. Value is not a valid ${expectedType}.`;
+        const context = {
+            receivedValue,
+            expectedType,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Ensure the emission scope value is a valid ${expectedType}`,
+            'Verify the value matches the expected type format',
+            'Check if the emission scope enum values have been updated',
+            'Ensure the conversion logic is appropriate for the reporting standard',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_EMISSION_SCOPE_TYPE, technicalMessage, context, suggestions);
         this.name = 'InvalidEmissionScopeTypeError';
     }
     static create(receivedValue, expectedType) {
         return new InvalidEmissionScopeTypeError(receivedValue, expectedType);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidEmissionScopeTypeError = InvalidEmissionScopeTypeError;

package/build/carbonbox/activity-data-collection/activity-data-submissions/domain/exceptions/InvalidFootprintTypeError.js

@@ -1,19 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidFootprintTypeError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidFootprintTypeError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidFootprintTypeError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue, validTypes) {
         const validTypesList = validTypes.join(', ');
-        const message = `Invalid footprint type value '${receivedValue}': must be one of ${validTypesList}.`;
-        super(message);
+        const technicalMessage = `Invalid footprint type value '${receivedValue}': must be one of ${validTypesList}.`;
+        const context = {
+            receivedValue,
+            validTypes,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid footprint types: ${validTypesList}`,
+            'Verify the footprint type value matches exactly (case-sensitive)',
+            'Check if the CarbonFootprint enum has been updated',
+            'Ensure the footprint type is appropriate for your submission context',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_ADC_FOOTPRINT_TYPE, technicalMessage, context, suggestions);
         this.name = 'InvalidFootprintTypeError';
     }
     static create(receivedValue, validTypes) {
         return new InvalidFootprintTypeError(receivedValue, validTypes);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidFootprintTypeError = InvalidFootprintTypeError;

package/build/carbonbox/activity-data-collection/activity-data-submissions/domain/exceptions/InvalidReportingStandardError.js

@@ -1,19 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidReportingStandardError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidReportingStandardError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidReportingStandardError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue, validStandards) {
         const validStandardsList = validStandards.join(', ');
-        const message = `Invalid reporting standard value '${receivedValue}': must be one of ${validStandardsList}.`;
-        super(message);
+        const technicalMessage = `Invalid reporting standard value '${receivedValue}': must be one of ${validStandardsList}.`;
+        const context = {
+            receivedValue,
+            validStandards,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid reporting standards: ${validStandardsList}`,
+            'Verify the reporting standard value matches exactly (case-sensitive)',
+            'Check if the ReportingStandard enum has been updated',
+            'Ensure the standard is supported for the selected footprint type',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_ADC_REPORTING_STANDARD, technicalMessage, context, suggestions);
         this.name = 'InvalidReportingStandardError';
     }
     static create(receivedValue, validStandards) {
         return new InvalidReportingStandardError(receivedValue, validStandards);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidReportingStandardError = InvalidReportingStandardError;

package/build/carbonbox/activity-data-collection/activity-data-submissions/domain/exceptions/InvalidSubScopeError.js

@@ -1,19 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidSubScopeError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidSubScopeError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidSubScopeError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue, validSubScopes) {
         const validSubScopesList = validSubScopes.join(', ');
-        const message = `Invalid sub-scope value '${receivedValue}': must be one of ${validSubScopesList} or null.`;
-        super(message);
+        const technicalMessage = `Invalid sub-scope value '${receivedValue}': must be one of ${validSubScopesList} or null.`;
+        const context = {
+            receivedValue,
+            validSubScopes,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid GHG sub-scopes: ${validSubScopesList}, or null`,
+            'Verify the sub-scope value matches exactly (case-sensitive)',
+            'Check if the GHGSubScope enum has been updated with new values',
+            'Ensure the sub-scope corresponds to the correct emission scope',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_SUB_SCOPE, technicalMessage, context, suggestions);
         this.name = 'InvalidSubScopeError';
     }
     static create(receivedValue, validSubScopes) {
         return new InvalidSubScopeError(receivedValue, validSubScopes);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidSubScopeError = InvalidSubScopeError;

package/build/carbonbox/activity-data-collection/activity-data-submissions/domain/exceptions/InvalidSubmissionStatusError.js

@@ -1,19 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidSubmissionStatusError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidSubmissionStatusError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidSubmissionStatusError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue, validStatuses) {
         const validStatusesList = validStatuses.join(', ');
-        const message = `Invalid submission status value '${receivedValue}': must be one of ${validStatusesList}.`;
-        super(message);
+        const technicalMessage = `Invalid submission status value '${receivedValue}': must be one of ${validStatusesList}.`;
+        const context = {
+            receivedValue,
+            validStatuses,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid submission statuses: ${validStatusesList}`,
+            'Verify the submission status value matches exactly (case-sensitive)',
+            'Check if the SubmissionStatus enum has been updated',
+            'Ensure the status transition is valid for the current submission state',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_SUBMISSION_STATUS, technicalMessage, context, suggestions);
         this.name = 'InvalidSubmissionStatusError';
     }
     static create(receivedValue, validStatuses) {
         return new InvalidSubmissionStatusError(receivedValue, validStatuses);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidSubmissionStatusError = InvalidSubmissionStatusError;

package/build/carbonbox/activity-data-collection/activity-data-submissions/domain/exceptions/InvalidUncertaintySourceError.js

@@ -1,19 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidUncertaintySourceError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidUncertaintySourceError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidUncertaintySourceError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue, validSources) {
         const validSourcesList = validSources.join(', ');
-        const message = `Invalid uncertainty source value '${receivedValue}': must be one of ${validSourcesList}.`;
-        super(message);
+        const technicalMessage = `Invalid uncertainty source value '${receivedValue}': must be one of ${validSourcesList}.`;
+        const context = {
+            receivedValue,
+            validSources,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid uncertainty sources: ${validSourcesList}`,
+            'Verify the uncertainty source value matches exactly (case-sensitive)',
+            'Check if the UncertaintySource enum has been updated',
+            'Ensure the value is being properly mapped from the source data',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_UNCERTAINTY_SOURCE, technicalMessage, context, suggestions);
         this.name = 'InvalidUncertaintySourceError';
     }
     static create(receivedValue, validSources) {
         return new InvalidUncertaintySourceError(receivedValue, validSources);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidUncertaintySourceError = InvalidUncertaintySourceError;

package/build/carbonbox/activity-data-collection/activity-data-submissions/domain/exceptions/UnknownFootprintTypeError.js

@@ -1,18 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnknownFootprintTypeError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class UnknownFootprintTypeError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class UnknownFootprintTypeError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue) {
-        const message = `Unknown footprint type: ${receivedValue}`;
-        super(message);
+        const technicalMessage = `Unknown footprint type: ${receivedValue}`;
+        const context = {
+            receivedValue,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Verify the footprint type value is supported (e.g., CORPORATE, PRODUCT, EVENT)',
+            'Check if the footprint type enum has been updated with new values',
+            'Ensure the value matches exactly one of the supported footprint types',
+            'Contact development team if this is a new footprint type that should be supported',
+        ];
+        super(ErrorCode_1.ErrorCode.UNKNOWN_FOOTPRINT_TYPE, technicalMessage, context, suggestions);
         this.name = 'UnknownFootprintTypeError';
     }
     static create(receivedValue) {
         return new UnknownFootprintTypeError(receivedValue);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.UnknownFootprintTypeError = UnknownFootprintTypeError;

package/build/carbonbox/activity-data-collection/activity-data-submissions/domain/exceptions/UnknownReportingStandardError.js

@@ -1,18 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnknownReportingStandardError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class UnknownReportingStandardError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class UnknownReportingStandardError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue) {
-        const message = `Unknown reporting standard: ${receivedValue}`;
-        super(message);
+        const technicalMessage = `Unknown reporting standard: ${receivedValue}`;
+        const context = {
+            receivedValue,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Verify the reporting standard value is supported (e.g., GHG_PROTOCOL, ISO_14064_1)',
+            'Check if the reporting standard enum has been updated with new values',
+            'Ensure the value matches exactly one of the supported standards',
+            'Contact development team if this is a new standard that should be supported',
+        ];
+        super(ErrorCode_1.ErrorCode.UNKNOWN_REPORTING_STANDARD, technicalMessage, context, suggestions);
         this.name = 'UnknownReportingStandardError';
     }
     static create(receivedValue) {
         return new UnknownReportingStandardError(receivedValue);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.UnknownReportingStandardError = UnknownReportingStandardError;

package/build/carbonbox/activity-data-collection/conditional-logic/domain/exceptions/InvalidConditionalActionError.js

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

package/build/carbonbox/activity-data-collection/conditional-logic/domain/exceptions/InvalidTriggerValueError.js

@@ -1,18 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidTriggerValueError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidTriggerValueError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidTriggerValueError extends CodedRootError_1.CodedRootError {
     constructor(receivedType) {
-        const message = `Invalid trigger value type '${receivedType}': must be string or number.`;
-        super(message);
+        const technicalMessage = `Invalid trigger value type '${receivedType}': must be string or number.`;
+        const context = {
+            receivedType,
+            validTypes: ['string', 'number'],
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Ensure the trigger value is either a string or a number',
+            'Check if the value is being correctly parsed from the form data',
+            'Verify that the field type configuration matches the expected trigger type',
+            'Review the data type validation rules for conditional logic triggers',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_TRIGGER_VALUE, technicalMessage, context, suggestions);
         this.name = 'InvalidTriggerValueError';
     }
     static create(receivedType) {
         return new InvalidTriggerValueError(receivedType);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidTriggerValueError = InvalidTriggerValueError;

package/build/carbonbox/activity-data-collection/conditional-logic/domain/exceptions/TriggerValueComparisonError.js

@@ -1,18 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TriggerValueComparisonError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class TriggerValueComparisonError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class TriggerValueComparisonError extends CodedRootError_1.CodedRootError {
     constructor(operation, valueType) {
-        const message = `Cannot ${operation} with non-numeric trigger value - ${valueType}`;
-        super(message);
+        const technicalMessage = `Cannot ${operation} with non-numeric trigger value - ${valueType}`;
+        const context = {
+            operation,
+            valueType,
+            requiredType: 'number',
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Ensure the trigger value is numeric for comparison operations',
+            'Convert the trigger value to a number before performing comparisons',
+            'Check if the field type is configured as numeric in the form',
+            'Review the conditional logic rules to use appropriate comparison operators',
+        ];
+        super(ErrorCode_1.ErrorCode.TRIGGER_VALUE_COMPARISON_ERROR, technicalMessage, context, suggestions);
         this.name = 'TriggerValueComparisonError';
     }
     static create(operation, valueType) {
         return new TriggerValueComparisonError(operation, valueType);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.TriggerValueComparisonError = TriggerValueComparisonError;

package/build/carbonbox/activity-data-collection/conditional-logic/domain/exceptions/TriggerValueConversionError.js

@@ -1,18 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TriggerValueConversionError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class TriggerValueConversionError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class TriggerValueConversionError extends CodedRootError_1.CodedRootError {
     constructor(value, targetType, actualType) {
-        const message = `Cannot convert trigger value '${value}' to ${targetType}. Value is of type ${actualType}.`;
-        super(message);
+        const technicalMessage = `Cannot convert trigger value '${value}' to ${targetType}. Value is of type ${actualType}.`;
+        const context = {
+            value,
+            targetType,
+            actualType,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Verify that the value can be converted from ${actualType} to ${targetType}`,
+            'Check if the value format is compatible with the target type',
+            'Ensure the conversion logic handles edge cases correctly',
+            'Review the data source to provide values in the expected format',
+        ];
+        super(ErrorCode_1.ErrorCode.TRIGGER_VALUE_CONVERSION_ERROR, technicalMessage, context, suggestions);
         this.name = 'TriggerValueConversionError';
     }
     static create(value, targetType, actualType) {
         return new TriggerValueConversionError(value, targetType, actualType);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.TriggerValueConversionError = TriggerValueConversionError;

package/build/carbonbox/activity-data-collection/conditional-logic/domain/exceptions/TriggerValueStringOperationError.js

@@ -1,18 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TriggerValueStringOperationError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class TriggerValueStringOperationError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class TriggerValueStringOperationError extends CodedRootError_1.CodedRootError {
     constructor(operation, valueType) {
-        const message = `Cannot ${operation} in non-string trigger value - ${valueType}`;
-        super(message);
+        const technicalMessage = `Cannot ${operation} in non-string trigger value - ${valueType}`;
+        const context = {
+            operation,
+            valueType,
+            requiredType: 'string',
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Ensure the trigger value is a string for string operations',
+            'Convert the trigger value to a string before performing string operations',
+            'Check if the field type is configured as text/string in the form',
+            'Review the conditional logic rules to use string-compatible operators',
+        ];
+        super(ErrorCode_1.ErrorCode.TRIGGER_VALUE_STRING_OPERATION_ERROR, technicalMessage, context, suggestions);
         this.name = 'TriggerValueStringOperationError';
     }
     static create(operation, valueType) {
         return new TriggerValueStringOperationError(operation, valueType);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.TriggerValueStringOperationError = TriggerValueStringOperationError;