ddd-node 22.0.2 → 23.0.0

package/dist/core/aggregate/event-sourced-aggregate/{event-sourced-aggregate-model-metadata.d.ts → event-sourced-aggregate-model-descriptor.d.ts}

@@ -1,7 +1,7 @@
 import { AnyEventSourcedAggregate } from ".";
 import { CommandHandlerMap, EventApplierMap } from "../../../meta";
-import { IModelMetadata } from "../../../model";
-export interface IEventSourcedAggregateModelMetadata<T extends AnyEventSourcedAggregate> extends IModelMetadata<T> {
+import { ModelDescriptor } from "../../../model";
+export interface EventSourcedAggregateModelDescriptor<T extends AnyEventSourcedAggregate> extends ModelDescriptor<T> {
     ownEventApplierMap: EventApplierMap;
     eventApplierMap: EventApplierMap;
     ownCommandHandlerMap: CommandHandlerMap;

package/dist/core/aggregate/event-sourced-aggregate/event-sourced-aggregate.d.ts

@@ -4,7 +4,7 @@ import { ClassStatic } from "../../../types";
 import { AnyCommand, AnyEvent, EventClassWithTypedConstructor } from "../../message";
 import { AggregateBase, AggregateMetadata } from "../aggregate-base";
 import { IEventDispatcher } from "../event-dispatcher.interface";
-import { IEventSourcedAggregateModelMetadata } from "./event-sourced-aggregate-model-metadata";
+import { EventSourcedAggregateModelDescriptor } from "./event-sourced-aggregate-model-descriptor";
 import { Snapshot, SnapshotMetadata } from "./snapshot";
 export interface EventSourceAggregateMetadata extends AggregateMetadata {
 }
@@ -17,7 +17,7 @@ export declare class EventSourcedAggregateBase<P extends Props> extends Aggregat
     static eventApplierMap<T extends AnyEventSourcedAggregate>(this: EventSourcedAggregateClass<T>): import("../../../meta").EventApplierMap;
     static ownCommandHandlerMap<T extends AnyEventSourcedAggregate>(this: EventSourcedAggregateClass<T>): import("../../../meta").CommandHandlerMap;
     static commandHandlerMap<T extends AnyEventSourcedAggregate>(this: EventSourcedAggregateClass<T>): import("../../../meta").CommandHandlerMap;
-    modelMetadata(): IEventSourcedAggregateModelMetadata<typeof this>;
+    modelDescriptor(): EventSourcedAggregateModelDescriptor<typeof this>;
     version(): number;
     pastEvents(): AnyEvent[];
     events(): AnyEvent[];

package/dist/core/aggregate/event-sourced-aggregate/event-sourced-aggregate.js

@@ -23,10 +23,10 @@ class EventSourcedAggregateBase extends aggregate_base_1.AggregateBase {
     static commandHandlerMap() {
         return (0, meta_1.getCommandHandlerMap)(this.prototype);
     }
-    modelMetadata() {
+    modelDescriptor() {
         const aggregateClass = this.constructor;
         return {
-            ...super.modelMetadata(),
+            ...super.modelDescriptor(),
             ownEventApplierMap: aggregateClass.ownEventApplierMap(),
             eventApplierMap: aggregateClass.eventApplierMap(),
             ownCommandHandlerMap: aggregateClass.ownCommandHandlerMap(),
@@ -49,8 +49,8 @@ class EventSourcedAggregateBase extends aggregate_base_1.AggregateBase {
         return Boolean(this._events.length);
     }
     getApplierForEvent(event) {
-        const { eventType } = event.modelMetadata();
-        const { eventApplierMap } = this.modelMetadata();
+        const { eventType } = event.modelDescriptor();
+        const { eventApplierMap } = this.modelDescriptor();
         const applier = eventApplierMap.get(eventType);
         if (!applier)
             throw new Error("Event applier not found");
@@ -92,8 +92,8 @@ class EventSourcedAggregateBase extends aggregate_base_1.AggregateBase {
         this.applyEvent(this.newEvent(eventClass, props));
     }
     getHandlerForCommand(command) {
-        const { commandType } = command.modelMetadata();
-        const { commandHandlerMap } = this.modelMetadata();
+        const { commandType } = command.modelDescriptor();
+        const { commandHandlerMap } = this.modelDescriptor();
         const handler = commandHandlerMap.get(commandType);
         if (!handler)
             throw new Error("Command handler not found");

package/dist/core/message/command/command-model-descriptor.d.ts

@@ -0,0 +1,6 @@
+import { AnyCommand } from "./command";
+import { CommandType } from "../../../meta";
+import { ModelDescriptor } from "../../../model";
+export interface CommandModelDescriptor<T extends AnyCommand> extends ModelDescriptor<T> {
+    commandType: CommandType;
+}

package/dist/core/message/command/command.d.ts

@@ -3,7 +3,7 @@ import { CommandType } from "../../../meta";
 import { Props, PropsOf } from "../../../model";
 import { ClassStatic } from "../../../types";
 import { MessageBase, MessageMetadata } from "../message-base";
-import { ICommandModelMetadata } from "./command-model.metadata";
+import { CommandModelDescriptor } from "./command-model-descriptor";
 export interface CommandMetadata extends MessageMetadata {
     commandType: CommandType;
 }
@@ -11,7 +11,7 @@ export declare abstract class CommandBase<P extends Props> extends MessageBase<P
     protected readonly _commandType: CommandType;
     static commandType(): string;
     constructor(metadata: Omit<CommandMetadata, "commandType">, props: P);
-    modelMetadata(): ICommandModelMetadata<typeof this>;
+    modelDescriptor(): CommandModelDescriptor<typeof this>;
     metadata(): CommandMetadata;
     commandType(): string;
 }

package/dist/core/message/command/command.js

@@ -11,10 +11,10 @@ class CommandBase extends message_base_1.MessageBase {
         super(metadata, props);
         this._commandType = (0, meta_1.getCommandType)(this.constructor);
     }
-    modelMetadata() {
+    modelDescriptor() {
         const commandClass = this.constructor;
         return {
-            ...super.modelMetadata(),
+            ...super.modelDescriptor(),
             commandType: commandClass.commandType(),
         };
     }

package/dist/core/message/command/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./command-model.metadata";
+export * from "./command-model-descriptor";
 export * from "./command";
 export * from "./command.builder";

package/dist/core/message/command/index.js

@@ -14,6 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./command-model.metadata"), exports);
+__exportStar(require("./command-model-descriptor"), exports);
 __exportStar(require("./command"), exports);
 __exportStar(require("./command.builder"), exports);

package/dist/core/message/event/event-model-descriptor.d.ts

@@ -0,0 +1,5 @@
+import { AnyEvent } from ".";
+import { ModelDescriptor } from "../../../model";
+export interface EventModelDescriptor<T extends AnyEvent> extends ModelDescriptor<T> {
+    eventType: string;
+}

package/dist/core/message/event/event.d.ts

@@ -4,7 +4,7 @@ import { Props, PropsOf } from "../../../model";
 import { ClassStatic } from "../../../types";
 import { Id } from "../../id";
 import { MessageBase, MessageMetadata } from "../message-base";
-import { IEventModelMetadata } from "./event-model.metadata";
+import { EventModelDescriptor } from "./event-model-descriptor";
 export type EventSource = Readonly<{
     aggregateId: Id;
     aggregateVersion: number;
@@ -13,12 +13,12 @@ export interface EventMetadata extends MessageMetadata {
     eventType: EventType;
     source: EventSource;
 }
-export declare class EventBase<P extends Props> extends MessageBase<P> {
+export declare abstract class EventBase<P extends Props> extends MessageBase<P> {
     private readonly _eventType;
     private readonly _source;
     constructor(metadata: Omit<EventMetadata, "eventType">, props: P);
     static eventType(): EventType;
-    modelMetadata(): IEventModelMetadata<typeof this>;
+    modelDescriptor(): EventModelDescriptor<typeof this>;
     metadata(): EventMetadata;
     eventType(): string;
     source(): Readonly<{

package/dist/core/message/event/event.js

@@ -12,10 +12,10 @@ class EventBase extends message_base_1.MessageBase {
     static eventType() {
         return (0, meta_1.getEventType)(this);
     }
-    modelMetadata() {
+    modelDescriptor() {
         const eventClass = this.constructor;
         return {
-            ...super.modelMetadata(),
+            ...super.modelDescriptor(),
             eventType: eventClass.eventType(),
         };
     }

package/dist/core/message/event/index.d.ts

@@ -1,3 +1,3 @@
 export * from "./event";
-export * from "./event-model.metadata";
+export * from "./event-model-descriptor";
 export * from "./event.builder";

package/dist/core/message/event/index.js

@@ -15,5 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./event"), exports);
-__exportStar(require("./event-model.metadata"), exports);
+__exportStar(require("./event-model-descriptor"), exports);
 __exportStar(require("./event.builder"), exports);

package/dist/meta/command.metadata.d.ts

@@ -1,6 +1,6 @@
 import "reflect-metadata";
 export type CommandType = string;
-export declare class CType extends String {
+export declare class $CommandType extends String {
     static validate(commandType: string): void;
     constructor(commandType: CommandType);
 }

package/dist/meta/command.metadata.js

@@ -1,21 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCommandType = exports.defineCommandType = exports.CType = void 0;
+exports.getCommandType = exports.defineCommandType = exports.$CommandType = void 0;
 require("reflect-metadata");
-class CType extends String {
+class $CommandType extends String {
     static validate(commandType) {
         if (commandType.trim().length === 0)
             throw new Error("Command type cannot be an empty string");
     }
     constructor(commandType) {
-        CType.validate(commandType);
+        $CommandType.validate(commandType);
         super(commandType);
     }
 }
-exports.CType = CType;
+exports.$CommandType = $CommandType;
 const CommandTypeMetaKey = Symbol.for("COMMAND_TYPE");
 const defineCommandType = (target, commandType) => {
-    Reflect.defineMetadata(CommandTypeMetaKey, new CType(commandType), target);
+    Reflect.defineMetadata(CommandTypeMetaKey, new $CommandType(commandType), target);
 };
 exports.defineCommandType = defineCommandType;
 const getCommandType = (target) => {

package/dist/meta/event.metadata.d.ts

@@ -1,6 +1,6 @@
 import "reflect-metadata";
 export type EventType = string;
-export declare class EType extends String {
+export declare class $EventType extends String {
     static validate(eventType: string): void;
     constructor(eventType: EventType);
 }

package/dist/meta/event.metadata.js

@@ -1,21 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEventType = exports.defineEventType = exports.EType = void 0;
+exports.getEventType = exports.defineEventType = exports.$EventType = void 0;
 require("reflect-metadata");
-class EType extends String {
+class $EventType extends String {
     static validate(eventType) {
         if (eventType.trim().length === 0)
             throw new Error("Event type cannot be an empty string");
     }
     constructor(eventType) {
-        EType.validate(eventType);
+        $EventType.validate(eventType);
         super(eventType);
     }
 }
-exports.EType = EType;
+exports.$EventType = $EventType;
 const EventTypeMetaKey = Symbol.for("EVENT_TYPE");
 const defineEventType = (target, eventType) => {
-    Reflect.defineMetadata(EventTypeMetaKey, new EType(eventType), target);
+    Reflect.defineMetadata(EventTypeMetaKey, new $EventType(eventType), target);
 };
 exports.defineEventType = defineEventType;
 const getEventType = (target) => {

package/dist/model/core/index.d.ts

@@ -1,3 +1,3 @@
 export * from "./model";
-export * from "./model-metadata";
+export * from "./model-descriptor";
 export * from "./model.builder";

package/dist/model/core/index.js

@@ -15,5 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./model"), exports);
-__exportStar(require("./model-metadata"), exports);
+__exportStar(require("./model-descriptor"), exports);
 __exportStar(require("./model.builder"), exports);

package/dist/model/core/{model-metadata.d.ts → model-descriptor.d.ts}

@@ -1,10 +1,10 @@
 import { AnyModel } from "./model";
 import { ModelId, ModelName, ModelVersion, PropsMap, PropsValidator, StaticValuesMap } from "../meta";
-export interface IModelMetadata<T extends AnyModel = AnyModel> {
-    modelMutable: boolean;
+export interface ModelDescriptor<T extends AnyModel = AnyModel> {
     modelId: ModelId;
     modelName: ModelName;
     modelVersion: ModelVersion;
+    modelMutable: boolean;
     ownPropsValidator?: PropsValidator<T>;
     propsValidators: PropsValidator[];
     ownStaticValues: StaticValuesMap<T>;

package/dist/model/core/model.d.ts

@@ -1,7 +1,7 @@
 import { Class } from "type-fest";
 import { ModelId, ModelName, ModelVersion, PropsMap, PropsValidator, StaticValuesMap } from "../meta";
 import { ClassStatic } from "../../types";
-import { IModelMetadata } from "./model-metadata";
+import { ModelDescriptor } from "./model-descriptor";
 export interface Props {
     [key: PropertyKey]: any;
 }
@@ -24,7 +24,7 @@ export declare class ModelBase<P extends Props> {
     constructor();
     redefineModel(): void;
     protected redefineProp(key: keyof this, propTargetKey: keyof P): void;
-    modelMetadata(): IModelMetadata<typeof this>;
+    modelDescriptor(): ModelDescriptor<typeof this>;
     validateProps(props: P): void;
     validate(): void;
     propsIsEmpty(): boolean;

package/dist/model/core/model.js

@@ -43,7 +43,7 @@ class ModelBase {
         this.redefineModel();
     }
     redefineModel() {
-        this.modelMetadata().propsMap.forEach((propTargetKey, key) => {
+        this.modelDescriptor().propsMap.forEach((propTargetKey, key) => {
             this.redefineProp(key, propTargetKey);
         });
     }
@@ -57,7 +57,7 @@ class ModelBase {
             },
         });
     }
-    modelMetadata() {
+    modelDescriptor() {
         const modelClass = this.constructor;
         return {
             modelMutable: modelClass.modelMutable(),
@@ -72,7 +72,7 @@ class ModelBase {
         };
     }
     validateProps(props) {
-        const propsValidators = this.modelMetadata().propsValidators;
+        const propsValidators = this.modelDescriptor().propsValidators;
         propsValidators.forEach((propsValidator) => propsValidator(props));
     }
     validate() {
@@ -97,7 +97,7 @@ class ModelBase {
     initializeProps(props) {
         if (!this.propsIsEmpty())
             throw new errors_1.PropsInitializedError();
-        if (!this.modelMetadata().modelMutable) {
+        if (!this.modelDescriptor().modelMutable) {
             this._props = props;
             Object.freeze(this._props);
         }

package/dist/model/meta/model-id.d.ts

@@ -2,15 +2,15 @@ import { AnyModel, ModelClass } from "../core";
 import { ModelName } from "./model-name";
 import { ModelVersion } from "./model-version";
 export type ModelId = string;
-export type MIdFormat = `${string}${typeof MId.Divider}${number}`;
-export declare class MId extends String {
+export type ModelIdFormat = `${string}${typeof $ModelId.Divider}${number}`;
+export declare class $ModelId extends String {
     readonly modelName: ModelName;
     readonly modelVersion: ModelVersion;
     static Divider: "|";
     static Format: RegExp;
-    static fromValue(value: ModelId): MId;
+    static fromValue(value: ModelId): $ModelId;
     static makeValue(modelName: ModelName, modelVersion: ModelVersion): ModelId;
     constructor(modelName: ModelName, modelVersion: ModelVersion);
 }
-export declare const setModelId: <T extends AnyModel>(target: ModelClass<T>, modelId: MId) => void;
+export declare const setModelId: <T extends AnyModel>(target: ModelClass<T>, modelId: $ModelId) => void;
 export declare const getModelId: <T extends AnyModel>(target: ModelClass<T>) => ModelId;

package/dist/model/meta/model-id.js

@@ -1,28 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getModelId = exports.setModelId = exports.MId = void 0;
+exports.getModelId = exports.setModelId = exports.$ModelId = void 0;
 const model_name_1 = require("./model-name");
 const model_version_1 = require("./model-version");
-class MId extends String {
+class $ModelId extends String {
     static fromValue(value) {
         if (!this.Format.test(value))
-            throw new Error(`Cannot parse MId from value ${value}`);
+            throw new Error(`Cannot parse $ModelId from value ${value}`);
         const [modelName, modelVersion] = value.split(this.Divider);
-        return new MId(modelName, Number(modelVersion));
+        return new $ModelId(modelName, Number(modelVersion));
     }
     static makeValue(modelName, modelVersion) {
         const modelId = `${modelName}${this.Divider}${modelVersion}`;
         return modelId;
     }
     constructor(modelName, modelVersion) {
-        super(MId.makeValue(modelName, modelVersion));
+        super($ModelId.makeValue(modelName, modelVersion));
         this.modelName = modelName;
         this.modelVersion = modelVersion;
     }
 }
-exports.MId = MId;
-MId.Divider = "|";
-MId.Format = new RegExp(/^.+\|[0-9]+$/);
+exports.$ModelId = $ModelId;
+$ModelId.Divider = "|";
+$ModelId.Format = new RegExp(/^.+\|[0-9]+$/);
 const ModelIdMetaKey = Symbol.for("MODEL_ID");
 const setModelId = (target, modelId) => {
     Reflect.defineMetadata(ModelIdMetaKey, modelId, target);
@@ -32,7 +32,7 @@ const getModelId = (target) => {
     if (!Reflect.hasOwnMetadata(ModelIdMetaKey, target)) {
         const modelName = (0, model_name_1.getModelName)(target);
         const modelVersion = (0, model_version_1.getModelVersion)(target);
-        (0, exports.setModelId)(target, new MId(modelName, modelVersion));
+        (0, exports.setModelId)(target, new $ModelId(modelName, modelVersion));
     }
     return Reflect.getOwnMetadata(ModelIdMetaKey, target).valueOf();
 };

package/dist/model/meta/model-name.d.ts

@@ -1,6 +1,6 @@
 import { AnyModel, ModelClass } from "../core";
 export type ModelName = string;
-export declare class MName extends String {
+export declare class $ModelName extends String {
     static validate(modelName: ModelName): void;
     constructor(modelName: ModelName);
 }

package/dist/model/meta/model-name.js

@@ -1,20 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getModelName = exports.defineModelName = exports.MName = void 0;
-class MName extends String {
+exports.getModelName = exports.defineModelName = exports.$ModelName = void 0;
+class $ModelName extends String {
     static validate(modelName) {
         if (modelName.trim().length === 0)
             throw new Error("Model name cannot be an empty string");
     }
     constructor(modelName) {
-        MName.validate(modelName);
+        $ModelName.validate(modelName);
         super(modelName);
     }
 }
-exports.MName = MName;
+exports.$ModelName = $ModelName;
 const ModelNameMetaKey = Symbol.for("MODEL_NAME");
 const defineModelName = (target, modelName) => {
-    Reflect.defineMetadata(ModelNameMetaKey, new MName(modelName), target);
+    Reflect.defineMetadata(ModelNameMetaKey, new $ModelName(modelName), target);
 };
 exports.defineModelName = defineModelName;
 const getModelName = (target) => {

package/dist/model/meta/model-version.d.ts

@@ -1,6 +1,6 @@
 import { AnyModel, ModelClass } from "../core";
 export type ModelVersion = number;
-export declare class MVersion extends Number {
+export declare class $ModelVersion extends Number {
     static validate(modelVersion: ModelVersion): void;
     constructor(modelVersion: ModelVersion);
 }

package/dist/model/meta/model-version.js

@@ -1,20 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getModelVersion = exports.defineModelVersion = exports.MVersion = void 0;
-class MVersion extends Number {
+exports.getModelVersion = exports.defineModelVersion = exports.$ModelVersion = void 0;
+class $ModelVersion extends Number {
     static validate(modelVersion) {
         if (modelVersion < 0 && Number.isInteger(modelVersion))
             throw new Error("Model version must be a non-negative integer number");
     }
     constructor(modelVersion) {
-        MVersion.validate(modelVersion);
+        $ModelVersion.validate(modelVersion);
         super(modelVersion);
     }
 }
-exports.MVersion = MVersion;
+exports.$ModelVersion = $ModelVersion;
 const ModelVersionMetaKey = Symbol.for("MODEL_VERSION");
 const defineModelVersion = (target, modelVersion) => {
-    Reflect.defineMetadata(ModelVersionMetaKey, new MVersion(modelVersion), target);
+    Reflect.defineMetadata(ModelVersionMetaKey, new $ModelVersion(modelVersion), target);
 };
 exports.defineModelVersion = defineModelVersion;
 const getModelVersion = (target) => {

package/dist/model/model-registry.js

@@ -27,7 +27,7 @@ class ModelRegistry {
         return modelVersionMap.get(modelVersion);
     }
     getModelByModelId(modelId) {
-        const { modelName, modelVersion } = meta_1.MId.fromValue(modelId);
+        const { modelName, modelVersion } = meta_1.$ModelId.fromValue(modelId);
         return this.getModel(modelName, modelVersion);
     }
     hasRegisteredModel(p1, p2) {

package/dist/package.json

@@ -1 +1 @@
-{"name":"ddd-node","version":"22.0.2","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":"23.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": "22.0.2",
+  "version": "23.0.0",
   "description": "Domain Driven Design base for NodeJs",
   "type": "module",
   "main": "dist/index.js",

package/dist/core/message/command/command-model.metadata.d.ts

@@ -1,6 +0,0 @@
-import { AnyCommand } from "./command";
-import { CommandType } from "../../../meta";
-import { IModelMetadata } from "../../../model";
-export interface ICommandModelMetadata<T extends AnyCommand> extends IModelMetadata<T> {
-    commandType: CommandType;
-}

package/dist/core/message/event/event-model.metadata.d.ts

@@ -1,5 +0,0 @@
-import { AnyEvent } from ".";
-import { IModelMetadata } from "../../../model";
-export interface IEventModelMetadata<T extends AnyEvent> extends IModelMetadata<T> {
-    eventType: string;
-}