@carbonbox/domain 0.29.2 → 0.30.0

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

@@ -1,18 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnknownConditionalActionCategoryError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class UnknownConditionalActionCategoryError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class UnknownConditionalActionCategoryError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue) {
-        const message = `Unknown conditional action category: ${receivedValue}`;
-        super(message);
+        const technicalMessage = `Unknown conditional action category: ${receivedValue}`;
+        const context = {
+            receivedValue,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Verify that the conditional action category is correctly defined',
+            'Check if the category name is spelled correctly',
+            'Review the available conditional action categories in the system',
+            'Ensure the category is registered in the conditional logic configuration',
+        ];
+        super(ErrorCode_1.ErrorCode.UNKNOWN_CONDITIONAL_ACTION_CATEGORY, technicalMessage, context, suggestions);
         this.name = 'UnknownConditionalActionCategoryError';
     }
     static create(receivedValue) {
         return new UnknownConditionalActionCategoryError(receivedValue);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.UnknownConditionalActionCategoryError = UnknownConditionalActionCategoryError;

package/build/carbonbox/carbon-footprint-configurations/shared/domain/exceptions/ConfigurationLockedError.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigurationLockedError = void 0;
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class ConfigurationLockedError extends CodedRootError_1.CodedRootError {
+    constructor(configurationId, reason) {
+        const technicalMessage = reason
+            ? `Configuration '${configurationId}' is locked and cannot be modified: ${reason}`
+            : `Configuration '${configurationId}' is locked and cannot be modified`;
+        const context = {
+            configurationId,
+            reason,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Unlock the configuration before making changes',
+            'Contact an administrator to unlock this configuration',
+            'Check if the configuration is being used by active processes',
+            'Verify the lock status and expiration time',
+            'Create a new configuration version instead of modifying the locked one',
+        ];
+        super(ErrorCode_1.ErrorCode.CONFIGURATION_LOCKED, technicalMessage, context, suggestions);
+        this.name = 'ConfigurationLockedError';
+    }
+    static create(configurationId, reason) {
+        return new ConfigurationLockedError(configurationId, reason);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.ConfigurationLockedError = ConfigurationLockedError;

package/build/carbonbox/carbon-footprint-configurations/shared/domain/exceptions/DuplicateConfigurationError.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuplicateConfigurationError = void 0;
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class DuplicateConfigurationError extends CodedRootError_1.CodedRootError {
+    constructor(period, existingConfigurationId) {
+        const technicalMessage = existingConfigurationId
+            ? `A configuration already exists for period '${period}'. Existing configuration ID: ${existingConfigurationId}`
+            : `A configuration already exists for this period: ${period}`;
+        const context = {
+            period,
+            existingConfigurationId,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Use a different collection period for this configuration',
+            'Update the existing configuration instead of creating a new one',
+            'Check if there is an overlapping configuration for this period',
+            'Verify the period dates to avoid conflicts',
+            'Deactivate or delete the existing configuration if appropriate',
+        ];
+        super(ErrorCode_1.ErrorCode.DUPLICATE_CONFIGURATION, technicalMessage, context, suggestions);
+        this.name = 'DuplicateConfigurationError';
+    }
+    static create(period, existingConfigurationId) {
+        return new DuplicateConfigurationError(period, existingConfigurationId);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.DuplicateConfigurationError = DuplicateConfigurationError;

package/build/carbonbox/carbon-footprint-configurations/shared/domain/exceptions/InvalidCarbonFootprintTypeError.js

@@ -1,18 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidCarbonFootprintTypeError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidCarbonFootprintTypeError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidCarbonFootprintTypeError extends CodedRootError_1.CodedRootError {
     constructor(invalidValue, validTypes) {
-        const message = `Invalid carbon footprint type '${invalidValue}'. Valid types are: ${validTypes.join(', ')}.`;
-        super(message);
+        const validTypesList = validTypes.join(', ');
+        const technicalMessage = `Invalid carbon footprint type '${invalidValue}'. Valid types are: ${validTypesList}.`;
+        const context = {
+            invalidValue,
+            validTypes: Array.from(validTypes),
+            validTypesList,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid carbon footprint types: ${validTypesList}`,
+            'Verify that the footprint type is correctly spelled',
+            'Check if the footprint type is supported in your configuration',
+            'Review the system documentation for available carbon footprint types',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_CARBON_FOOTPRINT_TYPE, technicalMessage, context, suggestions);
         this.name = 'InvalidCarbonFootprintTypeError';
     }
     static create(invalidValue, validTypes) {
         return new InvalidCarbonFootprintTypeError(invalidValue, validTypes);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidCarbonFootprintTypeError = InvalidCarbonFootprintTypeError;

package/build/carbonbox/carbon-footprint-configurations/shared/domain/exceptions/InvalidCollectionPeriodError.js

@@ -1,18 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidCollectionPeriodError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidCollectionPeriodError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidCollectionPeriodError extends CodedRootError_1.CodedRootError {
     constructor(invalidValue, validPeriods) {
-        const message = `Invalid collection period '${invalidValue}'. Valid periods are: ${validPeriods.join(', ')}.`;
-        super(message);
+        const technicalMessage = `Invalid collection period '${invalidValue}'. Valid periods are: ${validPeriods.join(', ')}.`;
+        const context = {
+            invalidValue,
+            validPeriods: Array.from(validPeriods),
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the supported collection periods: ${validPeriods.join(', ')}`,
+            'Verify the collection period dates are valid and in ISO 8601 format',
+            'Ensure the start date is before the end date',
+            'Check that the period aligns with your reporting requirements',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_COLLECTION_PERIOD, technicalMessage, context, suggestions);
         this.name = 'InvalidCollectionPeriodError';
     }
     static create(invalidValue, validPeriods) {
         return new InvalidCollectionPeriodError(invalidValue, validPeriods);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidCollectionPeriodError = InvalidCollectionPeriodError;

package/build/carbonbox/carbon-footprint-configurations/shared/domain/exceptions/InvalidConfigurationStatusError.js

@@ -1,18 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidConfigurationStatusError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidConfigurationStatusError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidConfigurationStatusError extends CodedRootError_1.CodedRootError {
     constructor(invalidValue, validStatuses) {
-        const message = `Invalid configuration status '${invalidValue}'. Valid statuses are: ${validStatuses.join(', ')}.`;
-        super(message);
+        const validStatusesList = validStatuses.join(', ');
+        const technicalMessage = `Invalid configuration status '${invalidValue}'. Valid statuses are: ${validStatusesList}.`;
+        const context = {
+            invalidValue,
+            validStatuses: Array.from(validStatuses),
+            validStatusesList,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid configuration statuses: ${validStatusesList}`,
+            'Verify that the status value is correctly spelled',
+            'Check if the status transition is allowed for this configuration',
+            'Review the configuration status workflow in the documentation',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_CONFIGURATION_STATUS, technicalMessage, context, suggestions);
         this.name = 'InvalidConfigurationStatusError';
     }
     static create(invalidValue, validStatuses) {
         return new InvalidConfigurationStatusError(invalidValue, validStatuses);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidConfigurationStatusError = InvalidConfigurationStatusError;

package/build/carbonbox/carbon-footprint-configurations/shared/domain/exceptions/InvalidReportingStandardError.js

@@ -1,18 +1,30 @@
 "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(invalidValue, validStandards) {
-        const message = `Invalid reporting standard '${invalidValue}'. Valid standards are: ${validStandards.join(', ')}.`;
-        super(message);
+        const technicalMessage = `Invalid reporting standard '${invalidValue}'. Valid standards are: ${validStandards.join(', ')}.`;
+        const context = {
+            invalidValue,
+            validStandards: Array.from(validStandards),
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the supported reporting standards: ${validStandards.join(', ')}`,
+            'Verify the reporting standard matches your carbon footprint configuration requirements',
+            'Check the API documentation for valid reporting standard values',
+            'Common standards include: GHG Protocol, ISO 14064-1',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_REPORTING_STANDARD, technicalMessage, context, suggestions);
         this.name = 'InvalidReportingStandardError';
     }
     static create(invalidValue, validStandards) {
         return new InvalidReportingStandardError(invalidValue, validStandards);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidReportingStandardError = InvalidReportingStandardError;

package/build/carbonbox/company-resources/facilities/domain/exceptions/InvalidOperationalScopeError.js

@@ -1,18 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidOperationalScopeError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidOperationalScopeError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidOperationalScopeError extends CodedRootError_1.CodedRootError {
     constructor(invalidValue, validScopes) {
-        const message = `Invalid operational scope '${invalidValue}'. Valid scopes are: ${validScopes.join(', ')}.`;
-        super(message);
+        const validScopesList = validScopes.join(', ');
+        const technicalMessage = `Invalid operational scope '${invalidValue}'. Valid scopes are: ${validScopesList}.`;
+        const context = {
+            invalidValue,
+            validScopes: Array.from(validScopes),
+            validScopesList,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid operational scopes: ${validScopesList}`,
+            'Verify that the operational scope value is correctly spelled',
+            'Check if the scope is applicable to this facility type',
+            'Review the facility configuration documentation for valid operational scopes',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_OPERATIONAL_SCOPE, technicalMessage, context, suggestions);
         this.name = 'InvalidOperationalScopeError';
     }
     static create(invalidValue, validScopes) {
         return new InvalidOperationalScopeError(invalidValue, validScopes);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidOperationalScopeError = InvalidOperationalScopeError;

package/build/carbonbox/emission-calculation-formulas/calculation-variables/domain/exceptions/InvalidCalculationVariableActivityDataConditionsForStrategyError.js

@@ -1,12 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidCalculationVariableActivityDataConditionsForStrategyError = 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 CalculationVariableResolutionStrategy_1 = require("../enums/CalculationVariableResolutionStrategy");
-class InvalidCalculationVariableActivityDataConditionsForStrategyError extends RootError_1.RootError {
+class InvalidCalculationVariableActivityDataConditionsForStrategyError extends CodedRootError_1.CodedRootError {
     constructor(resolutionStrategy, activityDataConditionsLength) {
-        const message = InvalidCalculationVariableActivityDataConditionsForStrategyError.buildMessage(resolutionStrategy, activityDataConditionsLength);
-        super(message);
+        const technicalMessage = InvalidCalculationVariableActivityDataConditionsForStrategyError.buildMessage(resolutionStrategy, activityDataConditionsLength);
+        const context = {
+            resolutionStrategy,
+            activityDataConditionsLength,
+            expectedLength: resolutionStrategy === CalculationVariableResolutionStrategy_1.CalculationVariableResolutionStrategy.PASSTHROUGH ? 0 : 'at least 1',
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            resolutionStrategy === CalculationVariableResolutionStrategy_1.CalculationVariableResolutionStrategy.PASSTHROUGH
+                ? 'Remove all entries from activityDataConditions array for PASSTHROUGH strategy'
+                : 'Add at least one entry to activityDataConditions array for CONDITIONAL_LOOKUP strategy',
+            'Verify the resolutionStrategy value matches the intended behavior',
+            'Check the calculation variable configuration documentation',
+            'Review the relationship between resolutionStrategy and activityDataConditions',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_CALCULATION_VARIABLE_ACTIVITY_DATA_CONDITIONS_FOR_STRATEGY, technicalMessage, context, suggestions);
         this.name = 'InvalidCalculationVariableActivityDataConditionsForStrategyError';
     }
     static create(resolutionStrategy, activityDataConditionsLength) {
@@ -19,7 +34,7 @@ class InvalidCalculationVariableActivityDataConditionsForStrategyError extends R
         return 'Calculation variable with resolutionStrategy=\'CONDITIONAL_LOOKUP\' must have at least one entry in activityDataConditions. Received empty array.';
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidCalculationVariableActivityDataConditionsForStrategyError = InvalidCalculationVariableActivityDataConditionsForStrategyError;

package/build/carbonbox/emission-calculation-formulas/calculation-variables/domain/exceptions/InvalidCalculationVariableResolutionStrategyError.js

@@ -1,19 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidCalculationVariableResolutionStrategyError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class InvalidCalculationVariableResolutionStrategyError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class InvalidCalculationVariableResolutionStrategyError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue, validStrategies) {
         const validStrategiesList = validStrategies.join(', ');
-        const message = `Invalid calculation variable resolution strategy value '${receivedValue}': must be one of ${validStrategiesList}.`;
-        super(message);
+        const technicalMessage = `Invalid calculation variable resolution strategy value '${receivedValue}': must be one of ${validStrategiesList}.`;
+        const context = {
+            receivedValue,
+            validStrategies,
+            validStrategiesList,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Use one of the valid resolution strategies: ${validStrategiesList}`,
+            'Verify that the strategy value is correctly spelled',
+            'Check the CalculationVariableResolutionStrategy enum for valid options',
+            'Review the calculation variable documentation for strategy usage',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_CALCULATION_VARIABLE_RESOLUTION_STRATEGY, technicalMessage, context, suggestions);
         this.name = 'InvalidCalculationVariableResolutionStrategyError';
     }
     static create(receivedValue, validStrategies) {
         return new InvalidCalculationVariableResolutionStrategyError(receivedValue, validStrategies);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidCalculationVariableResolutionStrategyError = InvalidCalculationVariableResolutionStrategyError;

package/build/carbonbox/emission-calculation-formulas/domain/exceptions/DuplicateGreenhouseGasError.js

@@ -1,21 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DuplicateGreenhouseGasError = void 0;
-const RootError_1 = require("../../../shared/domain/exceptions/RootError");
-class DuplicateGreenhouseGasError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../shared/domain/enums/ErrorCode");
+class DuplicateGreenhouseGasError extends CodedRootError_1.CodedRootError {
     constructor(propertyName, duplicateGases) {
         const duplicateGasesMessage = duplicateGases.length > 0
             ? ` Duplicate gases found: ${duplicateGases.join(', ')}.`
             : '';
-        const message = `Duplicate greenhouse gas types found in property '${propertyName}'.${duplicateGasesMessage} Each greenhouse gas type must be unique.`;
-        super(message);
+        const technicalMessage = `Duplicate greenhouse gas types found in property '${propertyName}'.${duplicateGasesMessage} Each greenhouse gas type must be unique.`;
+        const context = {
+            propertyName,
+            duplicateGases,
+            duplicateCount: duplicateGases.length,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Remove duplicate greenhouse gas entries from the property',
+            'Verify that each greenhouse gas type appears only once in the collection',
+            'Check the data source for duplicate GHG entries',
+            'Review the greenhouse gas configuration before saving',
+        ];
+        super(ErrorCode_1.ErrorCode.DUPLICATE_GREENHOUSE_GAS, technicalMessage, context, suggestions);
         this.name = 'DuplicateGreenhouseGasError';
     }
     static create(propertyName, duplicateGases) {
         return new DuplicateGreenhouseGasError(propertyName, duplicateGases);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.DuplicateGreenhouseGasError = DuplicateGreenhouseGasError;

package/build/carbonbox/emission-calculation-formulas/domain/exceptions/InvalidEmissionCalculationFormulaActivityVariableSymbolError.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidEmissionCalculationFormulaActivityVariableSymbolError = 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");
 /**
  * Cross-aggregate invariant violation between
  * `EmissionCalculationFormula.variables` and
@@ -16,24 +17,45 @@ const RootError_1 = require("../../../shared/domain/exceptions/RootError");
  *    but does not match any of the symbols declared in the formula's
  *    `variables` collection.
  */
-class InvalidEmissionCalculationFormulaActivityVariableSymbolError extends RootError_1.RootError {
-    constructor(message) {
-        super(message);
+class InvalidEmissionCalculationFormulaActivityVariableSymbolError extends CodedRootError_1.CodedRootError {
+    constructor(message, context) {
+        const suggestions = [
+            'Verify that the activityVariableSymbol matches one of the declared variable symbols',
+            'For multi-variable formulas, explicitly provide an activityVariableSymbol',
+            'Check the formula variables collection for correct symbol declarations',
+            'Review the emission calculation formula documentation',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_EMISSION_CALCULATION_FORMULA_ACTIVITY_VARIABLE_SYMBOL, message, context, suggestions);
         this.name = 'InvalidEmissionCalculationFormulaActivityVariableSymbolError';
     }
     static create(message) {
-        return new InvalidEmissionCalculationFormulaActivityVariableSymbolError(message);
+        const context = {
+            timestamp: new Date().toISOString(),
+        };
+        return new InvalidEmissionCalculationFormulaActivityVariableSymbolError(message, context);
     }
     static missingForMultiVariable(declaredSymbols) {
-        const message = `EmissionCalculationFormula declares ${declaredSymbols.length} variables ([${declaredSymbols.join(', ')}]) but no activityVariableSymbol was provided. Auto-inference is only allowed for mono-variable formulas; multi-variable formulas must explicitly designate which variable represents the activity.`;
-        return new InvalidEmissionCalculationFormulaActivityVariableSymbolError(message);
+        const technicalMessage = `EmissionCalculationFormula declares ${declaredSymbols.length} variables ([${declaredSymbols.join(', ')}]) but no activityVariableSymbol was provided. Auto-inference is only allowed for mono-variable formulas; multi-variable formulas must explicitly designate which variable represents the activity.`;
+        const context = {
+            errorType: 'MISSING_FOR_MULTI_VARIABLE',
+            declaredSymbols: Array.from(declaredSymbols),
+            declaredSymbolsCount: declaredSymbols.length,
+            timestamp: new Date().toISOString(),
+        };
+        return new InvalidEmissionCalculationFormulaActivityVariableSymbolError(technicalMessage, context);
     }
     static symbolNotDeclared(activityVariableSymbol, declaredSymbols) {
-        const message = `EmissionCalculationFormula.activityVariableSymbol='${activityVariableSymbol}' does not match any declared variable symbol. Declared symbols: [${declaredSymbols.join(', ')}].`;
-        return new InvalidEmissionCalculationFormulaActivityVariableSymbolError(message);
+        const technicalMessage = `EmissionCalculationFormula.activityVariableSymbol='${activityVariableSymbol}' does not match any declared variable symbol. Declared symbols: [${declaredSymbols.join(', ')}].`;
+        const context = {
+            errorType: 'SYMBOL_NOT_DECLARED',
+            activityVariableSymbol,
+            declaredSymbols: Array.from(declaredSymbols),
+            timestamp: new Date().toISOString(),
+        };
+        return new InvalidEmissionCalculationFormulaActivityVariableSymbolError(technicalMessage, context);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidEmissionCalculationFormulaActivityVariableSymbolError = InvalidEmissionCalculationFormulaActivityVariableSymbolError;

package/build/carbonbox/emission-calculation-formulas/domain/exceptions/InvalidGreenhouseGasTypeError.js

@@ -1,21 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidGreenhouseGasTypeError = void 0;
-const RootError_1 = require("../../../shared/domain/exceptions/RootError");
-class InvalidGreenhouseGasTypeError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../shared/domain/enums/ErrorCode");
+class InvalidGreenhouseGasTypeError extends CodedRootError_1.CodedRootError {
     constructor(propertyName, expectedGasTypes, receivedValue) {
         const expectedGasTypesMessage = expectedGasTypes.length > 0
             ? ` Expected one of: ${expectedGasTypes.join(', ')}.`
             : '';
-        const message = `Invalid greenhouse gas type for property '${propertyName}': received '${receivedValue}' (type: ${typeof receivedValue}).${expectedGasTypesMessage}`;
-        super(message);
+        const technicalMessage = `Invalid greenhouse gas type for property '${propertyName}': received '${receivedValue}' (type: ${typeof receivedValue}).${expectedGasTypesMessage}`;
+        const context = {
+            propertyName,
+            expectedGasTypes,
+            receivedValue,
+            receivedType: typeof receivedValue,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            expectedGasTypes.length > 0 ? `Use one of the expected gas types: ${expectedGasTypes.join(', ')}` : 'Verify the greenhouse gas type value',
+            'Check if the gas type is correctly spelled',
+            'Ensure the gas type is supported in the GHG Protocol',
+            'Review the greenhouse gas types documentation',
+        ];
+        super(ErrorCode_1.ErrorCode.INVALID_GREENHOUSE_GAS_TYPE, technicalMessage, context, suggestions);
         this.name = 'InvalidGreenhouseGasTypeError';
     }
     static create(propertyName, expectedGasTypes, receivedValue) {
         return new InvalidGreenhouseGasTypeError(propertyName, expectedGasTypes, receivedValue);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.InvalidGreenhouseGasTypeError = InvalidGreenhouseGasTypeError;

package/build/carbonbox/emission-calculation-formulas/domain/exceptions/UnauthorizedFormulaCreationRoleError.js

@@ -1,18 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnauthorizedFormulaCreationRoleError = void 0;
-const RootError_1 = require("../../../shared/domain/exceptions/RootError");
-class UnauthorizedFormulaCreationRoleError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../shared/domain/enums/ErrorCode");
+class UnauthorizedFormulaCreationRoleError extends CodedRootError_1.CodedRootError {
     constructor(unauthorizedRole, allowedRoles) {
-        const message = `Unauthorized role '${unauthorizedRole}' for emission formula creation. Only ${allowedRoles.join(' and ')} stakeholders are authorized to create emission formulas.`;
-        super(message);
+        const technicalMessage = `Unauthorized role '${unauthorizedRole}' for emission formula creation. Only ${allowedRoles.join(' and ')} stakeholders are authorized to create emission formulas.`;
+        const context = {
+            unauthorizedRole,
+            allowedRoles,
+            allowedRolesList: allowedRoles.join(', '),
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Request access from a user with one of these roles: ${allowedRoles.join(' or ')}`,
+            'Verify that your user account has the correct role assigned',
+            'Contact an administrator to upgrade your permissions',
+            'Review the stakeholder role hierarchy documentation',
+        ];
+        super(ErrorCode_1.ErrorCode.UNAUTHORIZED_FORMULA_CREATION_ROLE, technicalMessage, context, suggestions);
         this.name = 'UnauthorizedFormulaCreationRoleError';
     }
     static create(unauthorizedRole, allowedRoles) {
         return new UnauthorizedFormulaCreationRoleError(unauthorizedRole, allowedRoles);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.UnauthorizedFormulaCreationRoleError = UnauthorizedFormulaCreationRoleError;

package/build/carbonbox/emission-calculation-results/ghg-emission-results/domain/exceptions/UnknownGreenhouseGasCategoryError.js

@@ -1,18 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnknownGreenhouseGasCategoryError = void 0;
-const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
-class UnknownGreenhouseGasCategoryError extends RootError_1.RootError {
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+class UnknownGreenhouseGasCategoryError extends CodedRootError_1.CodedRootError {
     constructor(receivedValue) {
-        const message = `Unknown greenhouse gas category: ${receivedValue}`;
-        super(message);
+        const technicalMessage = `Unknown greenhouse gas category received: '${receivedValue}'. The provided greenhouse gas category is not recognized in the system's GHG emission results classification.`;
+        const context = {
+            receivedValue,
+            validCategories: [
+                'CO2',
+                'CH4',
+                'N2O',
+                'HFCs',
+                'PFCs',
+                'SF6',
+                'NF3',
+            ],
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Verify that the greenhouse gas category '${receivedValue}' is one of the valid GHG Protocol categories`,
+            'Check the emission calculation formula configuration for correct gas category assignments',
+            'Review the GHG emission results mapping logic for potential data transformation errors',
+            'Ensure the greenhouse gas category is correctly extracted from the calculation results',
+        ];
+        super(ErrorCode_1.ErrorCode.UNKNOWN_GREENHOUSE_GAS_CATEGORY, technicalMessage, context, suggestions);
         this.name = 'UnknownGreenhouseGasCategoryError';
     }
     static create(receivedValue) {
         return new UnknownGreenhouseGasCategoryError(receivedValue);
     }
     logError() {
-        return `${this.name}: ${this.message}`;
+        return `${this.name}: ${this.technicalMessage}`;
     }
 }
 exports.UnknownGreenhouseGasCategoryError = UnknownGreenhouseGasCategoryError;