@carbonbox/domain 0.2.3 → 0.2.5

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceCatalogCode = void 0;
+const Code_1 = require("../../../../shared/domain/value-objects/Code");
+class ServiceCatalogCode extends Code_1.Code {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, ServiceCatalogCode.PROPERTY_NAME);
+    }
+    static create(value) {
+        Code_1.Code.guardAgainstEmptyValue(value, ServiceCatalogCode.PROPERTY_NAME);
+        Code_1.Code.guardAgainstInvalidType(value, ServiceCatalogCode.PROPERTY_NAME);
+        Code_1.Code.guardAgainstInvalidCode(value, ServiceCatalogCode.PROPERTY_NAME);
+        return new ServiceCatalogCode(value, false);
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new ServiceCatalogCode(value, true);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.ServiceCatalogCode = ServiceCatalogCode;
+ServiceCatalogCode.PROPERTY_NAME = 'code';

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceCatalogCreatedByStakeholder = void 0;
+const StakeholderReference_1 = require("../../../../shared/domain/value-objects/StakeholderReference");
+class ServiceCatalogCreatedByStakeholder extends StakeholderReference_1.StakeholderReference {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, ServiceCatalogCreatedByStakeholder.PROPERTY_NAME);
+    }
+    static create(value) {
+        return new ServiceCatalogCreatedByStakeholder(value, false);
+    }
+    static fromPrimitives(primitives) {
+        const value = {
+            id: primitives.id,
+            displayName: primitives.displayName,
+            roleType: primitives.roleType,
+            taxIdentification: primitives.taxIdentification,
+        };
+        return new ServiceCatalogCreatedByStakeholder(value, true);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.ServiceCatalogCreatedByStakeholder = ServiceCatalogCreatedByStakeholder;
+ServiceCatalogCreatedByStakeholder.PROPERTY_NAME = 'createdByStakeholder';

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

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

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

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

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

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceCatalogExpertDedicationLevel = void 0;
+const NullableString_1 = require("../../../../shared/domain/value-objects/NullableString");
+const ExpertDedicationLevel_1 = require("../enums/ExpertDedicationLevel");
+const InvalidExpertDedicationLevelError_1 = require("../exceptions/InvalidExpertDedicationLevelError");
+class ServiceCatalogExpertDedicationLevel extends NullableString_1.NullableString {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, ServiceCatalogExpertDedicationLevel.PROPERTY_NAME);
+        if (skipDomainValidation === false) {
+            this.validateExpertDedicationLevel(value);
+        }
+    }
+    static create(value) {
+        return new ServiceCatalogExpertDedicationLevel(value, false);
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new ServiceCatalogExpertDedicationLevel(value, true);
+    }
+    /**
+     * Valida que el valor sea un nivel de dedicación de experto válido cuando no es null.
+     */
+    validateExpertDedicationLevel(value) {
+        if (value !== null && !ServiceCatalogExpertDedicationLevel.VALID_DEDICATION_LEVELS.includes(value)) {
+            throw InvalidExpertDedicationLevelError_1.InvalidExpertDedicationLevelError.create(value, ServiceCatalogExpertDedicationLevel.VALID_DEDICATION_LEVELS);
+        }
+    }
+    /**
+     * Verifica si es dedicación completa (full time).
+     */
+    isFullTime() {
+        if (!this.hasValue())
+            return null;
+        return this.value === ExpertDedicationLevel_1.ExpertDedicationLevel.FULL_TIME;
+    }
+    /**
+     * Verifica si es dedicación de 80 horas.
+     */
+    isEightyHours() {
+        if (!this.hasValue())
+            return null;
+        return this.value === ExpertDedicationLevel_1.ExpertDedicationLevel.EIGHTY_HOURS;
+    }
+    /**
+     * Verifica si es dedicación de 40 horas.
+     */
+    isFortyHours() {
+        if (!this.hasValue())
+            return null;
+        return this.value === ExpertDedicationLevel_1.ExpertDedicationLevel.FORTY_HOURS;
+    }
+    /**
+     * Verifica si es dedicación de 20 horas.
+     */
+    isTwentyHours() {
+        if (!this.hasValue())
+            return null;
+        return this.value === ExpertDedicationLevel_1.ExpertDedicationLevel.TWENTY_HOURS;
+    }
+    /**
+     * Verifica si es una dedicación alta (full time o 80 horas).
+     */
+    isHighDedication() {
+        if (!this.hasValue())
+            return null;
+        return this.isFullTime() || this.isEightyHours();
+    }
+    /**
+     * Verifica si es una dedicación baja (20 o 40 horas).
+     */
+    isLowDedication() {
+        if (!this.hasValue())
+            return null;
+        return this.isTwentyHours() || this.isFortyHours();
+    }
+    /**
+     * Verifica si es dedicación de tiempo parcial (no full time).
+     */
+    isPartTime() {
+        if (!this.hasValue())
+            return null;
+        return !this.isFullTime();
+    }
+    /**
+     * Obtiene las horas aproximadas de dedicación.
+     */
+    getApproximateHours() {
+        if (!this.hasValue())
+            return null;
+        switch (this.value) {
+            case ExpertDedicationLevel_1.ExpertDedicationLevel.FULL_TIME:
+                return 160; // Aproximadamente 40h/semana * 4 semanas
+            case ExpertDedicationLevel_1.ExpertDedicationLevel.EIGHTY_HOURS:
+                return 80;
+            case ExpertDedicationLevel_1.ExpertDedicationLevel.FORTY_HOURS:
+                return 40;
+            case ExpertDedicationLevel_1.ExpertDedicationLevel.TWENTY_HOURS:
+                return 20;
+            default:
+                return null;
+        }
+    }
+    /**
+     * Obtiene el nivel de intensidad de la dedicación.
+     */
+    getIntensityLevel() {
+        if (!this.hasValue())
+            return null;
+        if (this.isFullTime())
+            return 'high';
+        if (this.isEightyHours())
+            return 'high';
+        if (this.isFortyHours())
+            return 'medium';
+        if (this.isTwentyHours())
+            return 'low';
+        return null;
+    }
+    /**
+     * Obtiene los niveles de dedicación válidos.
+     */
+    static getValidDedicationLevels() {
+        return Object.freeze([...ServiceCatalogExpertDedicationLevel.VALID_DEDICATION_LEVELS]);
+    }
+    /**
+     * Verifica si un valor es un nivel de dedicación válido.
+     */
+    static isValidDedicationLevel(value) {
+        return ServiceCatalogExpertDedicationLevel.VALID_DEDICATION_LEVELS.includes(value);
+    }
+    /**
+     * Obtiene la descripción del nivel de dedicación.
+     */
+    getDescription() {
+        if (!this.hasValue())
+            return null;
+        const descriptions = {
+            [ExpertDedicationLevel_1.ExpertDedicationLevel.FULL_TIME]: 'Dedicación completa (tiempo completo)',
+            [ExpertDedicationLevel_1.ExpertDedicationLevel.EIGHTY_HOURS]: 'Dedicación alta (80 horas mensuales)',
+            [ExpertDedicationLevel_1.ExpertDedicationLevel.FORTY_HOURS]: 'Dedicación media (40 horas mensuales)',
+            [ExpertDedicationLevel_1.ExpertDedicationLevel.TWENTY_HOURS]: 'Dedicación baja (20 horas mensuales)',
+        };
+        return descriptions[this.value] || this.value;
+    }
+    /**
+     * Obtiene el factor de costo relativo (basado en horas).
+     */
+    getCostFactor() {
+        if (!this.hasValue())
+            return null;
+        const baseHours = 20; // 20 horas como base (factor 1.0)
+        const currentHours = this.getApproximateHours();
+        if (currentHours === null)
+            return null;
+        return currentHours / baseHours;
+    }
+    /**
+     * Verifica si requiere aprobación especial (dedicaciones altas).
+     */
+    requiresSpecialApproval() {
+        if (!this.hasValue())
+            return null;
+        return this.isHighDedication();
+    }
+    /**
+     * Obtiene las características del nivel de dedicación.
+     */
+    getCharacteristics() {
+        if (!this.hasValue())
+            return null;
+        return {
+            isFullTime: this.isFullTime(),
+            isPartTime: this.isPartTime(),
+            isHighDedication: this.isHighDedication(),
+            isLowDedication: this.isLowDedication(),
+            approximateHours: this.getApproximateHours(),
+            intensityLevel: this.getIntensityLevel(),
+            costFactor: this.getCostFactor(),
+            requiresSpecialApproval: this.requiresSpecialApproval(),
+        };
+    }
+    /**
+     * Convierte a enum para uso tipado.
+     */
+    toEnum() {
+        if (!this.hasValue())
+            return null;
+        return this.value;
+    }
+    toPrimitives() {
+        return this.value;
+    }
+    /**
+     * Representación como string descriptiva.
+     */
+    toString() {
+        if (!this.hasValue())
+            return 'No dedication level defined';
+        const levelNames = {
+            [ExpertDedicationLevel_1.ExpertDedicationLevel.FULL_TIME]: 'Tiempo Completo',
+            [ExpertDedicationLevel_1.ExpertDedicationLevel.EIGHTY_HOURS]: '80 Horas',
+            [ExpertDedicationLevel_1.ExpertDedicationLevel.FORTY_HOURS]: '40 Horas',
+            [ExpertDedicationLevel_1.ExpertDedicationLevel.TWENTY_HOURS]: '20 Horas',
+        };
+        return levelNames[this.value] || this.value;
+    }
+}
+exports.ServiceCatalogExpertDedicationLevel = ServiceCatalogExpertDedicationLevel;
+ServiceCatalogExpertDedicationLevel.PROPERTY_NAME = 'expertDedicationLevel';
+// Niveles de dedicación de experto válidos
+ServiceCatalogExpertDedicationLevel.VALID_DEDICATION_LEVELS = Object.values(ExpertDedicationLevel_1.ExpertDedicationLevel);

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

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceCatalogFixedPriceAmount = void 0;
+const NullableNumeric_1 = require("../../../../shared/domain/value-objects/NullableNumeric");
+class ServiceCatalogFixedPriceAmount extends NullableNumeric_1.NullableNumeric {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, ServiceCatalogFixedPriceAmount.PROPERTY_NAME, ServiceCatalogFixedPriceAmount.FIXED_PRICE_OPTIONS);
+    }
+    static create(value) {
+        return new ServiceCatalogFixedPriceAmount(value, false);
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new ServiceCatalogFixedPriceAmount(value, true);
+    }
+    /**
+     * Verifica si es un servicio gratuito.
+     */
+    isFree() {
+        if (!this.hasValue())
+            return null;
+        return this.value === 0;
+    }
+    /**
+     * Verifica si es un precio bajo (menos de $100).
+     */
+    isLowPrice() {
+        if (!this.hasValue())
+            return null;
+        return this.value > 0 && this.value < 100;
+    }
+    /**
+     * Verifica si es un precio medio (entre $100 y $1000).
+     */
+    isMediumPrice() {
+        if (!this.hasValue())
+            return null;
+        return this.value >= 100 && this.value <= 1000;
+    }
+    /**
+     * Verifica si es un precio alto (más de $1000).
+     */
+    isHighPrice() {
+        if (!this.hasValue())
+            return null;
+        return this.value > 1000;
+    }
+    /**
+     * Verifica si es un precio premium (más de $10000).
+     */
+    isPremiumPrice() {
+        if (!this.hasValue())
+            return null;
+        return this.value > 10000;
+    }
+    /**
+     * Obtiene el precio formateado como moneda.
+     */
+    getFormattedPrice(currencySymbol = '$') {
+        if (!this.hasValue())
+            return null;
+        return `${currencySymbol}${this.value.toLocaleString('en-US', {
+            minimumFractionDigits: 2,
+            maximumFractionDigits: 2,
+        })}`;
+    }
+    /**
+     * Obtiene el precio en miles (para display).
+     */
+    getPriceInThousands() {
+        if (!this.hasValue())
+            return null;
+        return Math.round((this.value / 1000) * 100) / 100;
+    }
+    /**
+     * Calcula el precio con impuestos.
+     */
+    calculatePriceWithTax(taxRate) {
+        if (!this.hasValue())
+            return null;
+        if (taxRate < 0 || taxRate > 1)
+            return null; // Tax rate debe estar entre 0 y 1
+        return this.value * (1 + taxRate);
+    }
+    /**
+     * Calcula un descuento sobre el precio fijo.
+     */
+    applyDiscount(discountPercentage) {
+        if (!this.hasValue())
+            return null;
+        if (discountPercentage < 0 || discountPercentage > 100)
+            return null;
+        const discountFactor = discountPercentage / 100;
+        return this.value * (1 - discountFactor);
+    }
+    /**
+     * Obtiene la categoría de precio.
+     */
+    getPriceCategory() {
+        if (!this.hasValue())
+            return null;
+        if (this.isFree())
+            return 'free';
+        if (this.isLowPrice())
+            return 'low';
+        if (this.isMediumPrice())
+            return 'medium';
+        if (this.isPremiumPrice())
+            return 'premium';
+        if (this.isHighPrice())
+            return 'high';
+        return null;
+    }
+    /**
+     * Verifica si el precio requiere aprobación especial.
+     */
+    requiresSpecialApproval() {
+        if (!this.hasValue())
+            return null;
+        // Precios premium requieren aprobación especial
+        return this.isPremiumPrice();
+    }
+    /**
+     * Obtiene una descripción del nivel de precio.
+     */
+    getPriceDescription() {
+        if (!this.hasValue())
+            return null;
+        const category = this.getPriceCategory();
+        const descriptions = {
+            free: 'Servicio gratuito',
+            low: 'Precio económico',
+            medium: 'Precio estándar',
+            high: 'Precio elevado',
+            premium: 'Precio premium',
+        };
+        return descriptions[category] || 'Precio no categorizado';
+    }
+    /**
+     * Compara con otro precio fijo.
+     */
+    compareWith(other) {
+        if (!this.hasValue() || !other.hasValue())
+            return null;
+        return this.value - other.value;
+    }
+    /**
+     * Verifica si está dentro de un rango de precios.
+     */
+    isWithinRange(minPrice, maxPrice) {
+        if (!this.hasValue())
+            return null;
+        return this.value >= minPrice && this.value <= maxPrice;
+    }
+    /**
+     * Obtiene las características del precio.
+     */
+    getCharacteristics() {
+        if (!this.hasValue())
+            return null;
+        return {
+            isFree: this.isFree(),
+            isLowPrice: this.isLowPrice(),
+            isMediumPrice: this.isMediumPrice(),
+            isHighPrice: this.isHighPrice(),
+            isPremiumPrice: this.isPremiumPrice(),
+            priceCategory: this.getPriceCategory(),
+            requiresSpecialApproval: this.requiresSpecialApproval(),
+            formattedPrice: this.getFormattedPrice(),
+        };
+    }
+    toPrimitives() {
+        return this.value;
+    }
+    /**
+     * Representación como string descriptiva.
+     */
+    toString() {
+        if (!this.hasValue())
+            return 'No fixed price defined';
+        return this.getFormattedPrice() || 'Invalid price';
+    }
+}
+exports.ServiceCatalogFixedPriceAmount = ServiceCatalogFixedPriceAmount;
+ServiceCatalogFixedPriceAmount.PROPERTY_NAME = 'fixedPriceAmount';
+ServiceCatalogFixedPriceAmount.FIXED_PRICE_OPTIONS = {
+    allowNegative: false, // Los precios fijos no pueden ser negativos
+    allowZero: true, // Permitir servicios gratuitos (precio fijo de 0)
+    allowDecimals: true, // Permitir decimales para precisión monetaria
+    maxDecimalPlaces: 2, // Máximo 2 decimales para valores monetarios
+    minValue: 0, // Valor mínimo es cero
+    maxValue: 999999999.99, // Valor máximo razonable para precios fijos
+};

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

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

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

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

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceCatalogId = void 0;
+const AggregateId_1 = require("../../../../shared/domain/value-objects/AggregateId");
+class ServiceCatalogId extends AggregateId_1.AggregateId {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, ServiceCatalogId.PROPERTY_NAME);
+    }
+    static create(value) {
+        AggregateId_1.AggregateId.guardAgainstEmptyValue(value, ServiceCatalogId.PROPERTY_NAME);
+        AggregateId_1.AggregateId.guardAgainstInvalidType(value, ServiceCatalogId.PROPERTY_NAME);
+        AggregateId_1.AggregateId.guardAgainstInvalidId(value, ServiceCatalogId.PROPERTY_NAME);
+        return new ServiceCatalogId(value, false);
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new ServiceCatalogId(value, true);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.ServiceCatalogId = ServiceCatalogId;
+ServiceCatalogId.PROPERTY_NAME = 'id';

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

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

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

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

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

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

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

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