@carbonbox/domain 0.2.2 → 0.2.4

package/build/carbonbox/purchase-management-system/service-catalog/domain/enums/ServiceCatalogStatus.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceCatalogStatus = void 0;
+var ServiceCatalogStatus;
+(function (ServiceCatalogStatus) {
+    ServiceCatalogStatus["ACTIVE"] = "ACTIVE";
+    ServiceCatalogStatus["INACTIVE"] = "INACTIVE";
+    ServiceCatalogStatus["DISCONTINUED"] = "DISCONTINUED";
+})(ServiceCatalogStatus || (exports.ServiceCatalogStatus = ServiceCatalogStatus = {}));

package/build/carbonbox/purchase-management-system/service-catalog/domain/enums/ServiceCatalogType.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceCatalogType = void 0;
+var ServiceCatalogType;
+(function (ServiceCatalogType) {
+    ServiceCatalogType["BASE_SERVICE"] = "BASE_SERVICE";
+    ServiceCatalogType["ADDITIONAL_SERVICE"] = "ADDITIONAL_SERVICE";
+    ServiceCatalogType["PLATFORM_FEATURE"] = "PLATFORM_FEATURE";
+    ServiceCatalogType["DEPENDENT_SERVICE"] = "DEPENDENT_SERVICE";
+})(ServiceCatalogType || (exports.ServiceCatalogType = ServiceCatalogType = {}));

package/build/carbonbox/purchase-management-system/service-catalog/domain/exceptions/InvalidServiceCatalogCategoryError.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidServiceCatalogCategoryError = void 0;
+const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
+class InvalidServiceCatalogCategoryError extends RootError_1.RootError {
+    constructor(receivedValue, validCategories) {
+        const validCategoriesList = validCategories.join(', ');
+        const message = `Invalid service category value '${receivedValue}': must be one of ${validCategoriesList}.`;
+        super(message);
+        this.name = 'InvalidServiceCatalogCategoryError';
+    }
+    static create(receivedValue, validCategories) {
+        return new InvalidServiceCatalogCategoryError(receivedValue, validCategories);
+    }
+    logError() {
+        return `${this.name}: ${this.message}`;
+    }
+}
+exports.InvalidServiceCatalogCategoryError = InvalidServiceCatalogCategoryError;

package/build/carbonbox/purchase-management-system/service-catalog/domain/exceptions/InvalidServiceCatalogStatusError.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidServiceCatalogStatusError = void 0;
+const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
+class InvalidServiceCatalogStatusError extends RootError_1.RootError {
+    constructor(receivedValue, validStatuses) {
+        const validStatusesList = validStatuses.join(', ');
+        const message = `Invalid service status value '${receivedValue}': must be one of ${validStatusesList}.`;
+        super(message);
+        this.name = 'InvalidServiceCatalogStatusError';
+    }
+    static create(receivedValue, validStatuses) {
+        return new InvalidServiceCatalogStatusError(receivedValue, validStatuses);
+    }
+    logError() {
+        return `${this.name}: ${this.message}`;
+    }
+}
+exports.InvalidServiceCatalogStatusError = InvalidServiceCatalogStatusError;

package/build/carbonbox/purchase-management-system/service-catalog/domain/exceptions/InvalidServiceCatalogTypeError.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidServiceCatalogTypeError = void 0;
+const RootError_1 = require("../../../../shared/domain/exceptions/RootError");
+class InvalidServiceCatalogTypeError extends RootError_1.RootError {
+    constructor(receivedValue, validTypes) {
+        const validTypesList = validTypes.join(', ');
+        const message = `Invalid service type value '${receivedValue}': must be one of ${validTypesList}.`;
+        super(message);
+        this.name = 'InvalidServiceCatalogTypeError';
+    }
+    static create(receivedValue, validTypes) {
+        return new InvalidServiceCatalogTypeError(receivedValue, validTypes);
+    }
+    logError() {
+        return `${this.name}: ${this.message}`;
+    }
+}
+exports.InvalidServiceCatalogTypeError = InvalidServiceCatalogTypeError;

package/build/carbonbox/purchase-management-system/service-catalog/domain/repository/IServiceCatalogRepository.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/carbonbox/purchase-management-system/service-catalog/domain/types/ServiceCatalogPrimitives.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/carbonbox/purchase-management-system/service-catalog/domain/types/ServiceCatalogProps.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/carbonbox/purchase-management-system/service-catalog/domain/value-objects/ServiceCatalogAdditionalUserRoles.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceCatalogAdditionalUserRoles = void 0;
+const StringList_1 = require("../../../../shared/domain/value-objects/StringList");
+const UserRole_1 = require("../enums/UserRole");
+const InvalidUserRoleError_1 = require("../exceptions/InvalidUserRoleError");
+class ServiceCatalogAdditionalUserRoles extends StringList_1.StringList {
+    constructor(roles, skipDomainValidation) {
+        super(roles, skipDomainValidation, ServiceCatalogAdditionalUserRoles.PROPERTY_NAME, { allowEmpty: true });
+        if (skipDomainValidation === false) {
+            this.validateUserRoles(roles);
+        }
+    }
+    static create(roles) {
+        StringList_1.StringList.guardAgainstInvalidStringList(roles, ServiceCatalogAdditionalUserRoles.PROPERTY_NAME);
+        return new ServiceCatalogAdditionalUserRoles(roles, false);
+    }
+    static fromPrimitives(primitives) {
+        const value = primitives.map((primitive) => primitive);
+        return new ServiceCatalogAdditionalUserRoles(value, true);
+    }
+    /**
+     * Valida que todos los roles sean roles de usuario válidos.
+     */
+    validateUserRoles(roles) {
+        for (const role of roles) {
+            if (!ServiceCatalogAdditionalUserRoles.VALID_USER_ROLES.includes(role)) {
+                throw InvalidUserRoleError_1.InvalidUserRoleError.create(role, ServiceCatalogAdditionalUserRoles.VALID_USER_ROLES);
+            }
+        }
+    }
+    /**
+     * Verifica si contiene el rol de SUPPLIER.
+     */
+    hasSupplierRole() {
+        return this.value.includes(UserRole_1.UserRole.SUPPLIER);
+    }
+    /**
+     * Verifica si contiene el rol de OBSERVER.
+     */
+    hasObserverRole() {
+        return this.value.includes(UserRole_1.UserRole.OBSERVER);
+    }
+    /**
+     * Verifica si contiene el rol de AUDITOR.
+     */
+    hasAuditorRole() {
+        return this.value.includes(UserRole_1.UserRole.AUDITOR);
+    }
+    /**
+     * Obtiene los roles válidos de usuario.
+     */
+    static getValidUserRoles() {
+        return Object.freeze([...ServiceCatalogAdditionalUserRoles.VALID_USER_ROLES]);
+    }
+    /**
+     * Verifica si un valor es un rol de usuario válido.
+     */
+    static isValidUserRole(role) {
+        return ServiceCatalogAdditionalUserRoles.VALID_USER_ROLES.includes(role);
+    }
+    /**
+     * Agrega un nuevo rol si no está ya presente.
+     */
+    addRole(role) {
+        if (this.value.includes(role)) {
+            return this;
+        }
+        const newRoles = [...this.value, role];
+        return new ServiceCatalogAdditionalUserRoles(newRoles, false);
+    }
+    /**
+     * Remueve un rol específico.
+     */
+    removeRole(role) {
+        const newRoles = this.value.filter((r) => r !== role);
+        return new ServiceCatalogAdditionalUserRoles(newRoles, false);
+    }
+    /**
+     * Verifica si tiene al menos un rol de auditoría (AUDITOR o OBSERVER).
+     */
+    hasAuditRole() {
+        return this.hasAuditorRole() || this.hasObserverRole();
+    }
+    /**
+     * Verifica si tiene roles operacionales (SUPPLIER).
+     */
+    hasOperationalRole() {
+        return this.hasSupplierRole();
+    }
+    /**
+     * Obtiene el número de roles únicos.
+     */
+    getRoleCount() {
+        return this.value.length;
+    }
+    /**
+     * Verifica si está vacío (sin roles adicionales).
+     */
+    isEmpty() {
+        return this.value.length === 0;
+    }
+    /**
+     * Convierte los roles a enum para uso tipado.
+     */
+    toEnums() {
+        return this.value;
+    }
+    /**
+     * Obtiene una descripción de los roles para debugging.
+     */
+    getDescription() {
+        if (this.isEmpty()) {
+            return 'No additional user roles assigned';
+        }
+        return `Additional roles: ${this.value.join(', ')}`;
+    }
+    toPrimitives() {
+        return this.value;
+    }
+    /**
+     * Representación como string descriptiva.
+     */
+    toString() {
+        return this.value.join(', ') || 'No additional roles';
+    }
+}
+exports.ServiceCatalogAdditionalUserRoles = ServiceCatalogAdditionalUserRoles;
+ServiceCatalogAdditionalUserRoles.PROPERTY_NAME = 'additionalUserRoles';
+// Roles de usuario válidos
+ServiceCatalogAdditionalUserRoles.VALID_USER_ROLES = Object.values(UserRole_1.UserRole);

package/build/carbonbox/purchase-management-system/service-catalog/domain/value-objects/ServiceCatalogAllowsDocumentReading.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceCatalogAllowsDocumentReading = void 0;
+const Boolean_1 = require("../../../../shared/domain/value-objects/Boolean");
+class ServiceCatalogAllowsDocumentReading extends Boolean_1.Boolean {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, ServiceCatalogAllowsDocumentReading.PROPERTY_NAME);
+    }
+    static create(value) {
+        Boolean_1.Boolean.guardAgainstInvalidType(value, ServiceCatalogAllowsDocumentReading.PROPERTY_NAME);
+        return new ServiceCatalogAllowsDocumentReading(value, false);
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new ServiceCatalogAllowsDocumentReading(value, true);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.ServiceCatalogAllowsDocumentReading = ServiceCatalogAllowsDocumentReading;
+ServiceCatalogAllowsDocumentReading.PROPERTY_NAME = 'allowsDocumentReading';

package/build/carbonbox/purchase-management-system/service-catalog/domain/value-objects/ServiceCatalogAllowsSectoralComparison.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceCatalogAllowsSectoralComparison = void 0;
+const Boolean_1 = require("../../../../shared/domain/value-objects/Boolean");
+class ServiceCatalogAllowsSectoralComparison extends Boolean_1.Boolean {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, ServiceCatalogAllowsSectoralComparison.PROPERTY_NAME);
+    }
+    static create(value) {
+        Boolean_1.Boolean.guardAgainstInvalidType(value, ServiceCatalogAllowsSectoralComparison.PROPERTY_NAME);
+        return new ServiceCatalogAllowsSectoralComparison(value, false);
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new ServiceCatalogAllowsSectoralComparison(value, true);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.ServiceCatalogAllowsSectoralComparison = ServiceCatalogAllowsSectoralComparison;
+ServiceCatalogAllowsSectoralComparison.PROPERTY_NAME = 'allowsSectoralComparison';

package/build/carbonbox/purchase-management-system/service-catalog/domain/value-objects/ServiceCatalogBasePricePercentage.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceCatalogBasePricePercentage = void 0;
+const NullableNumeric_1 = require("../../../../shared/domain/value-objects/NullableNumeric");
+class ServiceCatalogBasePricePercentage extends NullableNumeric_1.NullableNumeric {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, ServiceCatalogBasePricePercentage.PROPERTY_NAME, ServiceCatalogBasePricePercentage.PERCENTAGE_OPTIONS);
+    }
+    static create(value) {
+        return new ServiceCatalogBasePricePercentage(value, false);
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new ServiceCatalogBasePricePercentage(value, true);
+    }
+    /**
+     * Verifica si representa un incremento en el precio.
+     */
+    isIncrease() {
+        if (!this.hasValue())
+            return null;
+        return this.value > 0;
+    }
+    /**
+     * Verifica si representa un descuento en el precio.
+     */
+    isDiscount() {
+        if (!this.hasValue())
+            return null;
+        return this.value < 0;
+    }
+    /**
+     * Verifica si no hay cambio en el precio.
+     */
+    isNeutral() {
+        if (!this.hasValue())
+            return null;
+        return this.value === 0;
+    }
+    /**
+     * Verifica si es un incremento significativo (>= 50%).
+     */
+    isSignificantIncrease() {
+        if (!this.hasValue())
+            return null;
+        return this.value >= 50;
+    }
+    /**
+     * Verifica si es un descuento significativo (<= -25%).
+     */
+    isSignificantDiscount() {
+        if (!this.hasValue())
+            return null;
+        return this.value <= -25;
+    }
+    /**
+     * Obtiene el porcentaje formateado como string.
+     */
+    getFormattedPercentage() {
+        if (!this.hasValue())
+            return null;
+        const sign = this.value >= 0 ? '+' : '';
+        return `${sign}${this.value.toFixed(2)}%`;
+    }
+    /**
+     * Calcula el precio final basado en un precio base.
+     */
+    calculateFinalPrice(basePrice) {
+        if (!this.hasValue())
+            return null;
+        if (basePrice < 0)
+            return null; // No permitir precios base negativos
+        const multiplier = 1 + (this.value / 100);
+        return basePrice * multiplier;
+    }
+    /**
+     * Obtiene el factor multiplicador (1 + porcentaje/100).
+     */
+    getMultiplier() {
+        if (!this.hasValue())
+            return null;
+        return 1 + (this.value / 100);
+    }
+    /**
+     * Obtiene una descripción del impacto del porcentaje.
+     */
+    getImpactDescription() {
+        if (!this.hasValue())
+            return null;
+        const value = this.value;
+        if (value === 0)
+            return 'Sin cambio en el precio';
+        if (value > 0) {
+            if (value >= 100)
+                return 'Incremento muy alto';
+            if (value >= 50)
+                return 'Incremento alto';
+            if (value >= 25)
+                return 'Incremento moderado';
+            return 'Incremento bajo';
+        }
+        if (value <= -75)
+            return 'Descuento muy alto';
+        if (value <= -50)
+            return 'Descuento alto';
+        if (value <= -25)
+            return 'Descuento moderado';
+        return 'Descuento bajo';
+    }
+    /**
+     * Verifica si el porcentaje está dentro de un rango típico de servicios.
+     */
+    isWithinTypicalRange() {
+        if (!this.hasValue())
+            return null;
+        // Rango típico: entre -50% (descuento máximo común) y +200% (incremento máximo común)
+        return this.value >= -50 && this.value <= 200;
+    }
+    toPrimitives() {
+        return this.value;
+    }
+    /**
+     * Representación como string descriptiva.
+     */
+    toString() {
+        if (!this.hasValue())
+            return 'No percentage defined';
+        return this.getFormattedPercentage() || 'Invalid percentage';
+    }
+}
+exports.ServiceCatalogBasePricePercentage = ServiceCatalogBasePricePercentage;
+ServiceCatalogBasePricePercentage.PROPERTY_NAME = 'basePricePercentage';
+ServiceCatalogBasePricePercentage.PERCENTAGE_OPTIONS = {
+    allowNegative: true, // Permitir descuentos (valores negativos)
+    allowZero: true, // Permitir 0% (sin cambio en el precio)
+    allowDecimals: true, // Permitir decimales para precisión en porcentajes
+    maxDecimalPlaces: 2, // Máximo 2 decimales para porcentajes (ej: 25.50%)
+    minValue: -100, // Mínimo -100% (descuento total)
+    maxValue: 1000, // Máximo 1000% (incremento masivo para casos excepcionales)
+};

package/build/carbonbox/purchase-management-system/service-catalog/domain/value-objects/ServiceCatalogCategory.js

@@ -0,0 +1,247 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ServiceCatalogCategory_instances, _a, _ServiceCatalogCategory_validateServiceCatalogCategory;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceCatalogCategory = void 0;
+const String_1 = require("../../../../shared/domain/value-objects/String");
+const ServiceCatalogCategory_1 = require("../enums/ServiceCatalogCategory");
+const InvalidServiceCatalogCategoryError_1 = require("../exceptions/InvalidServiceCatalogCategoryError");
+class ServiceCatalogCategory extends String_1.String {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, _a.PROPERTY_NAME);
+        _ServiceCatalogCategory_instances.add(this);
+        if (skipDomainValidation === false) {
+            __classPrivateFieldGet(this, _ServiceCatalogCategory_instances, "m", _ServiceCatalogCategory_validateServiceCatalogCategory).call(this, value);
+        }
+    }
+    static create(value) {
+        String_1.String.guardAgainstEmptyValue(value, _a.PROPERTY_NAME);
+        String_1.String.guardAgainstInvalidType(value, _a.PROPERTY_NAME);
+        return new _a(value, false);
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new _a(value, true);
+    }
+    /**
+     * Verifica si es una categoría de huella de carbono.
+     */
+    isCarbonFootprintCategory() {
+        return this.isCorporateFootprint() || this.isProductFootprint() || this.isEventFootprint();
+    }
+    /**
+     * Verifica si es huella corporativa.
+     */
+    isCorporateFootprint() {
+        return this.value === ServiceCatalogCategory_1.ServiceCatalogCategory.CORPORATE_FOOTPRINT;
+    }
+    /**
+     * Verifica si es huella de producto.
+     */
+    isProductFootprint() {
+        return this.value === ServiceCatalogCategory_1.ServiceCatalogCategory.PRODUCT_FOOTPRINT;
+    }
+    /**
+     * Verifica si es huella de evento.
+     */
+    isEventFootprint() {
+        return this.value === ServiceCatalogCategory_1.ServiceCatalogCategory.EVENT_FOOTPRINT;
+    }
+    /**
+     * Verifica si es soporte experto.
+     */
+    isExpertSupport() {
+        return this.value === ServiceCatalogCategory_1.ServiceCatalogCategory.EXPERT_SUPPORT;
+    }
+    /**
+     * Verifica si es entrenamiento.
+     */
+    isTraining() {
+        return this.value === ServiceCatalogCategory_1.ServiceCatalogCategory.TRAINING;
+    }
+    /**
+     * Verifica si es soporte de auditoría.
+     */
+    isAuditSupport() {
+        return this.value === ServiceCatalogCategory_1.ServiceCatalogCategory.AUDIT_SUPPORT;
+    }
+    /**
+     * Verifica si es validación de datos.
+     */
+    isDataValidation() {
+        return this.value === ServiceCatalogCategory_1.ServiceCatalogCategory.DATA_VALIDATION;
+    }
+    /**
+     * Verifica si es reportería.
+     */
+    isReporting() {
+        return this.value === ServiceCatalogCategory_1.ServiceCatalogCategory.REPORTING;
+    }
+    /**
+     * Verifica si es lectura de documentos.
+     */
+    isDocumentReading() {
+        return this.value === ServiceCatalogCategory_1.ServiceCatalogCategory.DOCUMENT_READING;
+    }
+    /**
+     * Verifica si es comparación sectorial.
+     */
+    isSectoralComparison() {
+        return this.value === ServiceCatalogCategory_1.ServiceCatalogCategory.SECTORAL_COMPARISON;
+    }
+    /**
+     * Verifica si es usuarios adicionales.
+     */
+    isAdditionalUsers() {
+        return this.value === ServiceCatalogCategory_1.ServiceCatalogCategory.ADDITIONAL_USERS;
+    }
+    /**
+     * Verifica si es CarbonBox Academy.
+     */
+    isCarbonBoxAcademy() {
+        return this.value === ServiceCatalogCategory_1.ServiceCatalogCategory.CARBONBOX_ACADEMY;
+    }
+    /**
+     * Verifica si es indicadores ESG.
+     */
+    isESGIndicators() {
+        return this.value === ServiceCatalogCategory_1.ServiceCatalogCategory.ESG_INDICATORS;
+    }
+    /**
+     * Verifica si es compensación de carbono.
+     */
+    isCarbonOffsetting() {
+        return this.value === ServiceCatalogCategory_1.ServiceCatalogCategory.CARBON_OFFSETTING;
+    }
+    /**
+     * Verifica si es una categoría de soporte técnico.
+     */
+    isTechnicalSupportCategory() {
+        return this.isExpertSupport() || this.isAuditSupport() || this.isDataValidation();
+    }
+    /**
+     * Verifica si es una categoría de características de plataforma.
+     */
+    isPlatformFeatureCategory() {
+        return this.isDocumentReading() || this.isSectoralComparison() || this.isCarbonBoxAcademy() || this.isESGIndicators();
+    }
+    /**
+     * Verifica si es una categoría de extensión de usuarios.
+     */
+    isUserExtensionCategory() {
+        return this.isAdditionalUsers();
+    }
+    /**
+     * Verifica si es una categoría de sostenibilidad avanzada.
+     */
+    isAdvancedSustainabilityCategory() {
+        return this.isESGIndicators() || this.isCarbonOffsetting();
+    }
+    /**
+     * Obtiene las categorías de servicio válidas.
+     */
+    static getValidServiceCategories() {
+        return Object.freeze([..._a.VALID_SERVICE_CATEGORIES]);
+    }
+    /**
+     * Verifica si un valor es una categoría de servicio válida.
+     */
+    static isValidServiceCatalogCategory(value) {
+        return _a.VALID_SERVICE_CATEGORIES.includes(value);
+    }
+    /**
+     * Obtiene el tipo de categoría principal.
+     */
+    getCategoryType() {
+        if (this.isCarbonFootprintCategory())
+            return 'footprint';
+        if (this.isTechnicalSupportCategory() || this.isTraining())
+            return 'support';
+        if (this.isPlatformFeatureCategory())
+            return 'platform';
+        if (this.isUserExtensionCategory())
+            return 'user_extension';
+        if (this.isAdvancedSustainabilityCategory())
+            return 'sustainability';
+        if (this.isReporting())
+            return 'reporting';
+        // Este caso nunca debería ocurrir debido a las validaciones
+        return 'support'; // Valor por defecto
+    }
+    /**
+     * Obtiene la descripción de la categoría.
+     */
+    getDescription() {
+        const descriptions = {
+            [ServiceCatalogCategory_1.ServiceCatalogCategory.CORPORATE_FOOTPRINT]: 'Servicios de huella de carbono corporativa',
+            [ServiceCatalogCategory_1.ServiceCatalogCategory.PRODUCT_FOOTPRINT]: 'Servicios de huella de carbono de producto',
+            [ServiceCatalogCategory_1.ServiceCatalogCategory.EVENT_FOOTPRINT]: 'Servicios de huella de carbono de eventos',
+            [ServiceCatalogCategory_1.ServiceCatalogCategory.EXPERT_SUPPORT]: 'Soporte especializado de expertos',
+            [ServiceCatalogCategory_1.ServiceCatalogCategory.TRAINING]: 'Servicios de capacitación y entrenamiento',
+            [ServiceCatalogCategory_1.ServiceCatalogCategory.AUDIT_SUPPORT]: 'Soporte para procesos de auditoría',
+            [ServiceCatalogCategory_1.ServiceCatalogCategory.DATA_VALIDATION]: 'Validación y verificación de datos',
+            [ServiceCatalogCategory_1.ServiceCatalogCategory.REPORTING]: 'Servicios de reportería y documentación',
+            [ServiceCatalogCategory_1.ServiceCatalogCategory.DOCUMENT_READING]: 'Lectura y análisis de documentos',
+            [ServiceCatalogCategory_1.ServiceCatalogCategory.SECTORAL_COMPARISON]: 'Comparación sectorial de métricas',
+            [ServiceCatalogCategory_1.ServiceCatalogCategory.ADDITIONAL_USERS]: 'Usuarios adicionales en la plataforma',
+            [ServiceCatalogCategory_1.ServiceCatalogCategory.CARBONBOX_ACADEMY]: 'Acceso a CarbonBox Academy',
+            [ServiceCatalogCategory_1.ServiceCatalogCategory.ESG_INDICATORS]: 'Indicadores ESG avanzados',
+            [ServiceCatalogCategory_1.ServiceCatalogCategory.CARBON_OFFSETTING]: 'Servicios de compensación de carbono',
+        };
+        return descriptions[this.value] || this.value;
+    }
+    /**
+     * Obtiene las características de la categoría.
+     */
+    getCharacteristics() {
+        return {
+            isCarbonFootprintCategory: this.isCarbonFootprintCategory(),
+            isTechnicalSupportCategory: this.isTechnicalSupportCategory(),
+            isPlatformFeatureCategory: this.isPlatformFeatureCategory(),
+            isUserExtensionCategory: this.isUserExtensionCategory(),
+            isAdvancedSustainabilityCategory: this.isAdvancedSustainabilityCategory(),
+            categoryType: this.getCategoryType(),
+        };
+    }
+    toPrimitives() {
+        return this.value;
+    }
+    toEnum() {
+        return this.value;
+    }
+    /**
+     * Representación como string descriptiva.
+     */
+    toString() {
+        const categoryNames = {
+            [ServiceCatalogCategory_1.ServiceCatalogCategory.CORPORATE_FOOTPRINT]: 'Huella Corporativa',
+            [ServiceCatalogCategory_1.ServiceCatalogCategory.PRODUCT_FOOTPRINT]: 'Huella de Producto',
+            [ServiceCatalogCategory_1.ServiceCatalogCategory.EVENT_FOOTPRINT]: 'Huella de Evento',
+            [ServiceCatalogCategory_1.ServiceCatalogCategory.EXPERT_SUPPORT]: 'Soporte Experto',
+            [ServiceCatalogCategory_1.ServiceCatalogCategory.TRAINING]: 'Entrenamiento',
+            [ServiceCatalogCategory_1.ServiceCatalogCategory.AUDIT_SUPPORT]: 'Soporte de Auditoría',
+            [ServiceCatalogCategory_1.ServiceCatalogCategory.DATA_VALIDATION]: 'Validación de Datos',
+            [ServiceCatalogCategory_1.ServiceCatalogCategory.REPORTING]: 'Reportería',
+            [ServiceCatalogCategory_1.ServiceCatalogCategory.DOCUMENT_READING]: 'Lectura de Documentos',
+            [ServiceCatalogCategory_1.ServiceCatalogCategory.SECTORAL_COMPARISON]: 'Comparación Sectorial',
+            [ServiceCatalogCategory_1.ServiceCatalogCategory.ADDITIONAL_USERS]: 'Usuarios Adicionales',
+            [ServiceCatalogCategory_1.ServiceCatalogCategory.CARBONBOX_ACADEMY]: 'CarbonBox Academy',
+            [ServiceCatalogCategory_1.ServiceCatalogCategory.ESG_INDICATORS]: 'Indicadores ESG',
+            [ServiceCatalogCategory_1.ServiceCatalogCategory.CARBON_OFFSETTING]: 'Compensación de Carbono',
+        };
+        return categoryNames[this.value] || this.value;
+    }
+}
+exports.ServiceCatalogCategory = ServiceCatalogCategory;
+_a = ServiceCatalogCategory, _ServiceCatalogCategory_instances = new WeakSet(), _ServiceCatalogCategory_validateServiceCatalogCategory = function _ServiceCatalogCategory_validateServiceCatalogCategory(value) {
+    if (!_a.VALID_SERVICE_CATEGORIES.includes(value)) {
+        throw InvalidServiceCatalogCategoryError_1.InvalidServiceCatalogCategoryError.create(value, _a.VALID_SERVICE_CATEGORIES);
+    }
+};
+ServiceCatalogCategory.PROPERTY_NAME = 'category';
+// Categorías de servicio válidas
+ServiceCatalogCategory.VALID_SERVICE_CATEGORIES = Object.values(ServiceCatalogCategory_1.ServiceCatalogCategory);