ddd-node 25.0.0 → 26.0.0

package/dist/base/decorators/index.d.ts

@@ -2,3 +2,4 @@ export * from "./prop";
 export * from "./model";
 export * from "./static";
 export * from "./mutable";
+export * from "./props-validator";

package/dist/base/decorators/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./prop"), exports);
 __exportStar(require("./model"), exports);
 __exportStar(require("./static"), exports);
 __exportStar(require("./mutable"), exports);
+__exportStar(require("./props-validator"), exports);

package/dist/base/decorators/model.d.ts

@@ -1,10 +1,10 @@
 import { AnyModel, ModelClass } from "../model";
-import { PropsValidator } from "../meta";
+import { ModelPropsValidator } from "../meta";
 export type ModelOptions<T extends AnyModel = AnyModel> = {
     name?: string;
     version?: number;
     domain?: string;
-    propsValidator?: PropsValidator<T>;
+    propsValidator?: ModelPropsValidator<T>;
     autoRegisterModel?: boolean;
 };
 export declare function Model<T extends ModelClass, I extends InstanceType<T> = InstanceType<T>>(options?: ModelOptions<I>): any;

package/dist/base/decorators/model.js

@@ -48,7 +48,7 @@ function Model(p1, p2, p3) {
             domain.modelRegistry.registerModel(target);
         }
         if (modelOptions?.propsValidator)
-            (0, meta_1.definePropsValidator)(target, modelOptions.propsValidator);
+            (0, meta_1.defineModelPropsValidator)(target, modelOptions.propsValidator);
     };
 }
 exports.Model = Model;

package/dist/base/decorators/prop.js

@@ -4,7 +4,7 @@ exports.Prop = void 0;
 const meta_1 = require("../meta");
 const Prop = (propTargetKey) => {
     return (target, key) => {
-        (0, meta_1.defineProp)(target, key, propTargetKey ?? key);
+        (0, meta_1.defineModelProp)(target, key, propTargetKey ?? key);
     };
 };
 exports.Prop = Prop;

package/dist/base/decorators/props-validator.d.ts

@@ -0,0 +1,2 @@
+import { AnyModel, ModelClass, ModelPropsValidator } from "..";
+export declare const PropsValidator: <T extends AnyModel>(target: ModelClass<T>, key: string, propertyDescriptor: TypedPropertyDescriptor<ModelPropsValidator<T>>) => void;

package/dist/base/decorators/props-validator.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropsValidator = void 0;
+const __1 = require("..");
+const PropsValidator = (target, key, propertyDescriptor) => {
+    (0, __1.defineModelPropsValidator)(target, propertyDescriptor.value);
+};
+exports.PropsValidator = PropsValidator;

package/dist/base/decorators/static.d.ts

@@ -1,3 +1,3 @@
 import { ModelClass } from "../model";
-import { StaticValueBuilder } from "../meta";
-export declare const Static: <T extends ModelClass<import("../model").AnyModel>, I extends InstanceType<T> = InstanceType<T>>(builder: StaticValueBuilder<I>) => (target: T, key: PropertyKey) => void;
+import { ModelStaticValueBuilder } from "../meta";
+export declare const Static: <T extends ModelClass<import("../model").AnyModel>, I extends InstanceType<T> = InstanceType<T>>(builder: ModelStaticValueBuilder<I>) => (target: T, key: PropertyKey) => void;

package/dist/base/decorators/static.js

@@ -4,8 +4,8 @@ exports.Static = void 0;
 const meta_1 = require("../meta");
 const Static = (builder) => {
     return (target, key) => {
-        (0, meta_1.setStaticValue)(target, key, builder);
-        (0, meta_1.defineStaticValueProperty)(target, key);
+        (0, meta_1.setModelStaticValue)(target, key, builder);
+        (0, meta_1.defineModelStaticValueProperty)(target, key);
     };
 };
 exports.Static = Static;

package/dist/base/meta/model-props-map.d.ts

@@ -1,6 +1,6 @@
 import { AnyModel, PropsOf } from "../model";
-export declare class PropsMap<T extends AnyModel = AnyModel> extends Map<PropertyKey, keyof PropsOf<T>> {
+export declare class ModelPropsMap<T extends AnyModel = AnyModel> extends Map<PropertyKey, keyof PropsOf<T>> {
 }
-export declare const getOwnPropsMap: <T extends AnyModel = AnyModel>(target: object) => PropsMap<T>;
-export declare const defineProp: <T extends AnyModel = AnyModel>(target: object, key: PropertyKey, propTargetKey?: keyof PropsOf<T> | undefined) => void;
-export declare const getPropsMap: <T extends AnyModel = AnyModel>(target: object) => PropsMap<T>;
+export declare const getOwnModelPropsMap: <T extends AnyModel = AnyModel>(target: object) => ModelPropsMap<T>;
+export declare const defineModelProp: <T extends AnyModel = AnyModel>(target: object, key: PropertyKey, propTargetKey?: keyof PropsOf<T> | undefined) => void;
+export declare const getModelPropsMap: <T extends AnyModel = AnyModel>(target: object) => ModelPropsMap<T>;

package/dist/base/meta/model-props-map.js

@@ -1,45 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPropsMap = exports.defineProp = exports.getOwnPropsMap = exports.PropsMap = void 0;
+exports.getModelPropsMap = exports.defineModelProp = exports.getOwnModelPropsMap = exports.ModelPropsMap = void 0;
 const model_1 = require("../model");
-const OwnPropsMapMetaKey = Symbol.for("OWN_PROPS_MAP");
-class PropsMap extends Map {
+const OwnModelPropsMapMetaKey = Symbol.for("OWN_MODEL_PROPS_MAP");
+class ModelPropsMap extends Map {
 }
-exports.PropsMap = PropsMap;
+exports.ModelPropsMap = ModelPropsMap;
 // target is prototype
-const getOwnPropsMap = (target) => {
-    if (!Reflect.hasOwnMetadata(OwnPropsMapMetaKey, target))
-        Reflect.defineMetadata(OwnPropsMapMetaKey, new PropsMap(), target);
-    return Reflect.getOwnMetadata(OwnPropsMapMetaKey, target);
+const getOwnModelPropsMap = (target) => {
+    if (!Reflect.hasOwnMetadata(OwnModelPropsMapMetaKey, target))
+        Reflect.defineMetadata(OwnModelPropsMapMetaKey, new ModelPropsMap(), target);
+    return Reflect.getOwnMetadata(OwnModelPropsMapMetaKey, target);
 };
-exports.getOwnPropsMap = getOwnPropsMap;
-const defineProp = (target, key, propTargetKey) => {
-    const ownPropsMap = (0, exports.getOwnPropsMap)(target);
+exports.getOwnModelPropsMap = getOwnModelPropsMap;
+const defineModelProp = (target, key, propTargetKey) => {
+    const ownModelPropsMap = (0, exports.getOwnModelPropsMap)(target);
     if (propTargetKey)
-        ownPropsMap.set(key, propTargetKey);
+        ownModelPropsMap.set(key, propTargetKey);
 };
-exports.defineProp = defineProp;
-const PropsMapMetaKey = Symbol.for("PROPS_MAP");
-const getPropsMap = (target) => {
-    if (!Reflect.hasOwnMetadata(PropsMapMetaKey, target)) {
+exports.defineModelProp = defineModelProp;
+const ModelPropsMapMetaKey = Symbol.for("MODEL_PROPS_MAP");
+const getModelPropsMap = (target) => {
+    if (!Reflect.hasOwnMetadata(ModelPropsMapMetaKey, target)) {
         const buildPropsMap = (target) => {
             let _target = target;
-            const result = new PropsMap();
+            const result = new ModelPropsMap();
             const ownPropsMapList = [];
             do {
                 if (model_1.ModelBase.isModel(_target)) {
-                    const ownPropsMap = (0, exports.getOwnPropsMap)(_target);
-                    ownPropsMapList.unshift(ownPropsMap);
+                    const ownModelPropsMap = (0, exports.getOwnModelPropsMap)(_target);
+                    ownPropsMapList.unshift(ownModelPropsMap);
                 }
                 _target = Reflect.getPrototypeOf(_target);
             } while (_target !== null);
-            ownPropsMapList.forEach((ownPropsMap) => {
-                ownPropsMap.forEach((targetPropKey, key) => result.set(key, targetPropKey));
+            ownPropsMapList.forEach((ownModelPropsMap) => {
+                ownModelPropsMap.forEach((targetPropKey, key) => result.set(key, targetPropKey));
             });
             return result;
         };
-        Reflect.defineMetadata(PropsMapMetaKey, buildPropsMap(target), target);
+        Reflect.defineMetadata(ModelPropsMapMetaKey, buildPropsMap(target), target);
     }
-    return Reflect.getOwnMetadata(PropsMapMetaKey, target);
+    return Reflect.getOwnMetadata(ModelPropsMapMetaKey, target);
 };
-exports.getPropsMap = getPropsMap;
+exports.getModelPropsMap = getModelPropsMap;

package/dist/base/meta/model-props-validator.d.ts

@@ -1,6 +1,6 @@
 import { AnyModel, PropsOf } from "../model";
-export type PropsValidator<T extends AnyModel = AnyModel> = (props: PropsOf<T>) => void;
-export declare const definePropsValidator: <T extends AnyModel>(target: object, validator: PropsValidator<T>) => void;
-export declare const getOwnPropsValidator: <T extends AnyModel>(target: object) => PropsValidator<T> | undefined;
-export declare const PropsValidatorsMetaKey: unique symbol;
-export declare const getPropsValidators: (target: object) => PropsValidator[];
+export type ModelPropsValidator<T extends AnyModel = AnyModel> = (props: PropsOf<T>) => void;
+export declare const defineModelPropsValidator: <T extends AnyModel>(target: object, validator: ModelPropsValidator<T>) => void;
+export declare const getOwnModelPropsValidator: <T extends AnyModel>(target: object) => ModelPropsValidator<T> | undefined;
+export declare const ModelPropsValidatorsMetaKey: unique symbol;
+export declare const getModelPropsValidators: (target: object) => ModelPropsValidator[];

package/dist/base/meta/model-props-validator.js

@@ -3,31 +3,31 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPropsValidators = exports.PropsValidatorsMetaKey = exports.getOwnPropsValidator = exports.definePropsValidator = void 0;
+exports.getModelPropsValidators = exports.ModelPropsValidatorsMetaKey = exports.getOwnModelPropsValidator = exports.defineModelPropsValidator = void 0;
 const lodash_1 = __importDefault(require("lodash"));
-const OwnPropsValidatorMetaKey = Symbol.for("OWN_PROPS_VALIDATOR");
-const definePropsValidator = (target, validator) => {
+const OwnPropsValidatorMetaKey = Symbol.for("OWN_MODEL_PROPS_VALIDATOR");
+const defineModelPropsValidator = (target, validator) => {
     Reflect.defineMetadata(OwnPropsValidatorMetaKey, validator, target);
 };
-exports.definePropsValidator = definePropsValidator;
-const getOwnPropsValidator = (target) => {
+exports.defineModelPropsValidator = defineModelPropsValidator;
+const getOwnModelPropsValidator = (target) => {
     return Reflect.getOwnMetadata(OwnPropsValidatorMetaKey, target);
 };
-exports.getOwnPropsValidator = getOwnPropsValidator;
-exports.PropsValidatorsMetaKey = Symbol.for("PROPS_VALIDATORS");
-const getPropsValidators = (target) => {
-    if (!Reflect.hasOwnMetadata(exports.PropsValidatorsMetaKey, target)) {
+exports.getOwnModelPropsValidator = getOwnModelPropsValidator;
+exports.ModelPropsValidatorsMetaKey = Symbol.for("MODEL_PROPS_VALIDATORS");
+const getModelPropsValidators = (target) => {
+    if (!Reflect.hasOwnMetadata(exports.ModelPropsValidatorsMetaKey, target)) {
         let result = [];
         let _target = target;
         do {
-            const ownValidator = (0, exports.getOwnPropsValidator)(_target);
+            const ownValidator = (0, exports.getOwnModelPropsValidator)(_target);
             if (ownValidator)
                 result.push(ownValidator);
             _target = Reflect.getPrototypeOf(_target);
         } while (_target !== null);
         result = lodash_1.default.uniq(result);
-        Reflect.defineMetadata(exports.PropsValidatorsMetaKey, result, target);
+        Reflect.defineMetadata(exports.ModelPropsValidatorsMetaKey, result, target);
     }
-    return Reflect.getOwnMetadata(exports.PropsValidatorsMetaKey, target);
+    return Reflect.getOwnMetadata(exports.ModelPropsValidatorsMetaKey, target);
 };
-exports.getPropsValidators = getPropsValidators;
+exports.getModelPropsValidators = getModelPropsValidators;

package/dist/base/meta/model-static-values.d.ts

@@ -1,13 +1,13 @@
 import { AnyModel, ModelClass } from "../model";
-export type StaticValueBuilder<T extends AnyModel = AnyModel> = () => T;
-export declare class StaticValue<T extends AnyModel = AnyModel> {
+export type ModelStaticValueBuilder<T extends AnyModel = AnyModel> = () => T;
+export declare class ModelStaticValue<T extends AnyModel = AnyModel> {
     private _value;
-    constructor(value: T | StaticValueBuilder<T>);
+    constructor(value: T | ModelStaticValueBuilder<T>);
     get value(): T;
 }
-export declare class StaticValuesMap<T extends AnyModel = AnyModel> extends Map<PropertyKey, StaticValue<T>> {
+export declare class ModelStaticValuesMap<T extends AnyModel = AnyModel> extends Map<PropertyKey, ModelStaticValue<T>> {
 }
-export declare const getOwnStaticValues: <T extends AnyModel>(target: object) => StaticValuesMap<T>;
-export declare const setStaticValue: <T extends AnyModel>(target: object, key: PropertyKey, value: T | StaticValueBuilder<T>) => void;
-export declare const getStaticValue: (target: object, key: PropertyKey) => AnyModel | undefined;
-export declare const defineStaticValueProperty: (target: ModelClass, key: PropertyKey) => void;
+export declare const getOwnModelStaticValues: <T extends AnyModel>(target: object) => ModelStaticValuesMap<T>;
+export declare const setModelStaticValue: <T extends AnyModel>(target: object, key: PropertyKey, value: T | ModelStaticValueBuilder<T>) => void;
+export declare const getModelStaticValue: (target: object, key: PropertyKey) => AnyModel | undefined;
+export declare const defineModelStaticValueProperty: (target: ModelClass, key: PropertyKey) => void;

package/dist/base/meta/model-static-values.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defineStaticValueProperty = exports.getStaticValue = exports.setStaticValue = exports.getOwnStaticValues = exports.StaticValuesMap = exports.StaticValue = void 0;
-class StaticValue {
+exports.defineModelStaticValueProperty = exports.getModelStaticValue = exports.setModelStaticValue = exports.getOwnModelStaticValues = exports.ModelStaticValuesMap = exports.ModelStaticValue = void 0;
+class ModelStaticValue {
     constructor(value) {
         this._value = value;
     }
@@ -12,43 +12,43 @@ class StaticValue {
         return this._value;
     }
 }
-exports.StaticValue = StaticValue;
-const OwnStaticValuesMetaKey = Symbol.for("OWN_STATIC_VALUES");
-class StaticValuesMap extends Map {
+exports.ModelStaticValue = ModelStaticValue;
+const OwnModelStaticValuesMetaKey = Symbol.for("OWN_MODEL_STATIC_VALUES");
+class ModelStaticValuesMap extends Map {
 }
-exports.StaticValuesMap = StaticValuesMap;
-const getOwnStaticValues = (target) => {
-    if (!Reflect.hasOwnMetadata(OwnStaticValuesMetaKey, target))
-        Reflect.defineMetadata(OwnStaticValuesMetaKey, new StaticValuesMap(), target);
-    return Reflect.getOwnMetadata(OwnStaticValuesMetaKey, target);
+exports.ModelStaticValuesMap = ModelStaticValuesMap;
+const getOwnModelStaticValues = (target) => {
+    if (!Reflect.hasOwnMetadata(OwnModelStaticValuesMetaKey, target))
+        Reflect.defineMetadata(OwnModelStaticValuesMetaKey, new ModelStaticValuesMap(), target);
+    return Reflect.getOwnMetadata(OwnModelStaticValuesMetaKey, target);
 };
-exports.getOwnStaticValues = getOwnStaticValues;
-const setStaticValue = (target, key, value) => {
-    const staticValues = (0, exports.getOwnStaticValues)(target);
-    staticValues.set(key, new StaticValue(value));
+exports.getOwnModelStaticValues = getOwnModelStaticValues;
+const setModelStaticValue = (target, key, value) => {
+    const staticValues = (0, exports.getOwnModelStaticValues)(target);
+    staticValues.set(key, new ModelStaticValue(value));
 };
-exports.setStaticValue = setStaticValue;
-const getStaticValue = (target, key) => {
+exports.setModelStaticValue = setModelStaticValue;
+const getModelStaticValue = (target, key) => {
     let _target = target;
     do {
-        const staticValues = (0, exports.getOwnStaticValues)(_target);
+        const staticValues = (0, exports.getOwnModelStaticValues)(_target);
         if (staticValues.has(key))
             return staticValues.get(key)?.value;
         _target = Reflect.getPrototypeOf(_target);
     } while (_target !== null);
     return undefined;
 };
-exports.getStaticValue = getStaticValue;
-const defineStaticValueProperty = (target, key) => {
+exports.getModelStaticValue = getModelStaticValue;
+const defineModelStaticValueProperty = (target, key) => {
     Object.defineProperty(target, key, {
         configurable: false,
         enumerable: true,
         get() {
-            return (0, exports.getStaticValue)(target, key);
+            return (0, exports.getModelStaticValue)(target, key);
         },
         set() {
             throw new Error("Static value is readonly");
         },
     });
 };
-exports.defineStaticValueProperty = defineStaticValueProperty;
+exports.defineModelStaticValueProperty = defineModelStaticValueProperty;

package/dist/base/model/model-descriptor.d.ts

@@ -1,13 +1,13 @@
 import { AnyModel } from "./model";
-import { ModelId, ModelName, ModelVersion, PropsMap, PropsValidator, StaticValuesMap } from "../meta";
+import { ModelId, ModelName, ModelVersion, ModelPropsMap, ModelPropsValidator, ModelStaticValuesMap } from "../meta";
 export interface ModelDescriptor<T extends AnyModel = AnyModel> {
     modelId: ModelId;
     modelName: ModelName;
     modelVersion: ModelVersion;
     modelMutable: boolean;
-    ownPropsValidator?: PropsValidator<T>;
-    propsValidators: PropsValidator[];
-    ownStaticValues: StaticValuesMap<T>;
-    ownPropsMap: PropsMap<T>;
-    propsMap: PropsMap<T>;
+    ownModelPropsValidator?: ModelPropsValidator<T>;
+    modelPropsValidators: ModelPropsValidator[];
+    ownModelStaticValues: ModelStaticValuesMap<T>;
+    ownModelPropsMap: ModelPropsMap<T>;
+    modelPropsMap: ModelPropsMap<T>;
 }

package/dist/base/model/model.d.ts

@@ -1,6 +1,6 @@
 import { AbstractClass, Class } from "type-fest";
 import { ClassStatic } from "../../types";
-import { ModelId, ModelName, ModelVersion, PropsMap, PropsValidator, StaticValuesMap } from "../meta";
+import { ModelId, ModelName, ModelPropsMap, ModelPropsValidator, ModelStaticValuesMap, ModelVersion } from "../meta";
 import { ModelDescriptor } from "./model-descriptor";
 export interface Props {
     [key: PropertyKey]: any;
@@ -16,11 +16,11 @@ export declare class ModelBase<P extends Props> {
     static modelName<T extends AnyModel>(this: ModelClass<T>): ModelName;
     static modelVersion<T extends AnyModel>(this: ModelClass<T>): ModelVersion;
     static modelId<T extends AnyModel>(this: ModelClass<T>): ModelId;
-    static ownPropsValidator<T extends AnyModel>(this: ModelClass<T>): PropsValidator<T> | undefined;
-    static propsValidators<T extends AnyModel>(this: ModelClass<T>): PropsValidator[];
-    static ownStaticValues<T extends AnyModel>(this: ModelClass<T>): StaticValuesMap<T>;
-    static ownPropsMap<T extends AnyModel>(this: ModelClass<T>): PropsMap<T>;
-    static propsMap<T extends AnyModel>(this: ModelClass<T>): PropsMap<T>;
+    static ownModelPropsValidator<T extends AnyModel>(this: ModelClass<T>): ModelPropsValidator<T> | undefined;
+    static modelPropsValidators<T extends AnyModel>(this: ModelClass<T>): ModelPropsValidator[];
+    static ownModelStaticValues<T extends AnyModel>(this: ModelClass<T>): ModelStaticValuesMap<T>;
+    static ownModelPropsMap<T extends AnyModel>(this: ModelClass<T>): ModelPropsMap<T>;
+    static modelPropsMap<T extends AnyModel>(this: ModelClass<T>): ModelPropsMap<T>;
     constructor();
     redefineModel(): void;
     protected redefineProp<K extends keyof P>(key: keyof this, propTargetKey: K): void;

package/dist/base/model/model.js

@@ -23,27 +23,27 @@ class ModelBase {
     static modelId() {
         return (0, meta_1.getModelId)(this);
     }
-    static ownPropsValidator() {
-        return (0, meta_1.getOwnPropsValidator)(this);
+    static ownModelPropsValidator() {
+        return (0, meta_1.getOwnModelPropsValidator)(this);
     }
-    static propsValidators() {
-        return (0, meta_1.getPropsValidators)(this);
+    static modelPropsValidators() {
+        return (0, meta_1.getModelPropsValidators)(this);
     }
-    static ownStaticValues() {
-        return (0, meta_1.getOwnStaticValues)(this);
+    static ownModelStaticValues() {
+        return (0, meta_1.getOwnModelStaticValues)(this);
     }
-    static ownPropsMap() {
-        return (0, meta_1.getOwnPropsMap)(this.prototype);
+    static ownModelPropsMap() {
+        return (0, meta_1.getOwnModelPropsMap)(this.prototype);
     }
-    static propsMap() {
-        return (0, meta_1.getPropsMap)(this.prototype);
+    static modelPropsMap() {
+        return (0, meta_1.getModelPropsMap)(this.prototype);
     }
     constructor() {
         this._props = ModelBase.EMPTY_PROPS;
         this.redefineModel();
     }
     redefineModel() {
-        this.modelDescriptor().propsMap.forEach((propTargetKey, key) => {
+        this.modelDescriptor().modelPropsMap.forEach((propTargetKey, key) => {
             this.redefineProp(key, propTargetKey);
         });
     }
@@ -64,16 +64,16 @@ class ModelBase {
             modelId: modelClass.modelId(),
             modelName: modelClass.modelName(),
             modelVersion: modelClass.modelVersion(),
-            ownPropsValidator: modelClass.ownPropsValidator(),
-            propsValidators: modelClass.propsValidators(),
-            ownStaticValues: modelClass.ownStaticValues(),
-            ownPropsMap: modelClass.ownPropsMap(),
-            propsMap: modelClass.propsMap(),
+            ownModelPropsValidator: modelClass.ownModelPropsValidator(),
+            modelPropsValidators: modelClass.modelPropsValidators(),
+            ownModelStaticValues: modelClass.ownModelStaticValues(),
+            ownModelPropsMap: modelClass.ownModelPropsMap(),
+            modelPropsMap: modelClass.modelPropsMap(),
         };
     }
     validateProps(props) {
-        const propsValidators = this.modelDescriptor().propsValidators;
-        propsValidators.forEach((propsValidator) => propsValidator.call(this.constructor, props));
+        const modelPropsValidators = this.modelDescriptor().modelPropsValidators;
+        modelPropsValidators.forEach((propsValidator) => propsValidator.call(this.constructor, props));
     }
     validate() {
         this.validateProps(this._props);

package/dist/core/enum/enum-builder.js

@@ -16,7 +16,7 @@ class EnumBuilder extends base_1.ModelBuilder {
             throw new Error("Cannot parse enum without value");
         const { enumClass } = this;
         let result;
-        enumClass.ownStaticValues().forEach((staticValue) => {
+        enumClass.ownModelStaticValues().forEach((staticValue) => {
             if (staticValue.value instanceof enumClass) {
                 const staticEnum = staticValue.value;
                 if (staticEnum.value === this._value && !result) {

package/dist/core/enum/enum.js

@@ -17,7 +17,7 @@ let EnumBase = class EnumBase extends base_1.ModelBase {
         return new _1.EnumBuilder(this);
     }
     static values() {
-        return Array.from(this.ownStaticValues().values()).map((staticValue) => staticValue.value);
+        return Array.from(this.ownModelStaticValues().values()).map((staticValue) => staticValue.value);
     }
     static from(value) {
         return this.builder().withValue(value).build();

package/dist/package.json

@@ -1 +1 @@
-{"name":"ddd-node","version":"25.0.0","description":"Domain Driven Design base for NodeJs","type":"commonjs","main":"index.js","types":"index.d.ts","files":["dist"],"repository":{"type":"git","url":"https://github.com/nqd881/ddd-node"},"keywords":["ddd","ddd-node","ddd-base","ddd-ts","ddd-js"],"author":"Quoc Dai","license":"ISC","devDependencies":{"@types/chai":"^4.3.16","@types/lodash":"^4.14.200","@types/mocha":"^10.0.6","@types/uuid":"^9.0.6","chai":"^5.1.1","chai-deep-match":"^1.2.1","ddd-node":"file:dist","mocha":"^10.4.0","ts-node":"^10.9.1","tsconfig-paths":"^4.2.0","typescript":"^5.2.2"},"dependencies":{"lodash":"^4.17.21","reflect-metadata":"^0.1.13","tsc-alias":"^1.8.8","type-fest":"^4.20.1","uuid":"^9.0.1"}}
+{"name":"ddd-node","version":"26.0.0","description":"Domain Driven Design base for NodeJs","type":"commonjs","main":"index.js","types":"index.d.ts","files":["dist"],"repository":{"type":"git","url":"https://github.com/nqd881/ddd-node"},"keywords":["ddd","ddd-node","ddd-base","ddd-ts","ddd-js"],"author":"Quoc Dai","license":"ISC","devDependencies":{"@types/chai":"^4.3.16","@types/lodash":"^4.14.200","@types/mocha":"^10.0.6","@types/uuid":"^9.0.6","chai":"^5.1.1","chai-deep-match":"^1.2.1","ddd-node":"file:dist","mocha":"^10.4.0","ts-node":"^10.9.1","tsconfig-paths":"^4.2.0","typescript":"^5.2.2"},"dependencies":{"lodash":"^4.17.21","reflect-metadata":"^0.1.13","tsc-alias":"^1.8.8","type-fest":"^4.20.1","uuid":"^9.0.1"}}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ddd-node",
-  "version": "25.0.0",
+  "version": "26.0.0",
   "description": "Domain Driven Design base for NodeJs",
   "type": "module",
   "main": "dist/index.js",