ddd-node 9.2.1 → 12.1.0

package/dist/core/model/model-with-id.d.ts

@@ -1,6 +1,12 @@
-import { Id, IdGenerator } from "../id";
-import { Model } from "./model";
-export declare class ModelWithId<Props extends object> extends Model<Props> {
-    static getIdGenerator(this: any): IdGenerator;
+import { Id, IdGeneratorBase } from "../id";
+import { ModelBase } from "./model";
+export declare abstract class ModelWithId<Props extends object> extends ModelBase<Props> {
+    protected readonly _id: Id;
+    constructor(id: Id);
+    static getIdGenerator(this: any): IdGeneratorBase;
     static id(id?: Id): Id;
+    getId(): Id;
+    hasId(id: Id): boolean;
+    rawId(): string;
 }
+export type AnyModelWithId = ModelWithId<any>;

package/dist/core/model/model-with-id.js

@@ -2,15 +2,28 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModelWithId = void 0;
 const id_1 = require("../id");
-const metadata_1 = require("../metadata");
+const id_metadata_1 = require("../metadata/id.metadata");
 const model_1 = require("./model");
-class ModelWithId extends model_1.Model {
+class ModelWithId extends model_1.ModelBase {
+    constructor(id) {
+        super();
+        this._id = id;
+    }
     static getIdGenerator() {
-        return (0, metadata_1.getIdGenerator)(this) || new id_1.Uuid4Generator();
+        return (0, id_metadata_1.getIdGenerator)(this) || new id_1.Uuid4Generator();
     }
     static id(id) {
         const generator = this.getIdGenerator();
         return id ? generator.fromId(id) : generator.newId();
     }
+    getId() {
+        return this._id;
+    }
+    hasId(id) {
+        return this._id.equals(id);
+    }
+    rawId() {
+        return this._id.value;
+    }
 }
 exports.ModelWithId = ModelWithId;

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

@@ -1,15 +1,25 @@
-import { Class } from "../../types/index";
-export declare class Model<Props extends object> {
+import { ClassStatic } from "../../types/index";
+import { Class } from "type-fest";
+import { ModelMetadata } from "../metadata/model.metadata";
+export declare class ModelBase<Props extends object> {
+    static readonly EMPTY_PROPS: {};
+    private _metadata;
+    private _propKeys;
     protected _props: Props;
-    constructor(props?: Props);
-    static isModel(obj: object): obj is AnyModel;
-    static type(): `${string}#${string}`;
-    protected initializeProps(props: Props): void;
+    static isMutable(): boolean;
+    static isModel(model: any): model is AnyModel;
+    constructor();
+    private redefineModel;
+    isMutable(): boolean;
+    getPropKeys(): Set<string | symbol>;
+    validateProps(props: Props): void;
     validate(): void;
-    getType(): `${string}#${string}`;
-    props(): Props;
+    getModelMetadata(): ModelMetadata<this>;
+    modelName(): string;
+    props(): any;
+    protected initializeProps(props: Props): void;
 }
-export type AnyModel = Model<object>;
-export type PropsOf<T> = T extends Model<infer P> ? P : never;
-export type ModelClass<T extends AnyModel = AnyModel> = Class<T>;
+export type AnyModel = ModelBase<object>;
+export type PropsOf<T extends AnyModel> = T extends ModelBase<infer P extends object> ? P : never;
+export type ModelClass<T extends AnyModel = AnyModel> = Class<T> & ClassStatic<typeof ModelBase<PropsOf<T>>>;
 export type EmptyProps = {};

package/dist/core/model/model.js

@@ -3,32 +3,87 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Model = void 0;
+exports.ModelBase = void 0;
 const lodash_1 = __importDefault(require("lodash"));
-const metadata_1 = require("../metadata");
-class Model {
-    constructor(props) {
-        if (props)
-            this.initializeProps(props);
+const model_metadata_1 = require("../metadata/model.metadata");
+class ModelBase {
+    static isMutable() {
+        return false;
     }
-    static isModel(obj) {
-        return obj instanceof Model;
+    static isModel(model) {
+        return model instanceof ModelBase;
     }
-    static type() {
-        return (0, metadata_1.getModelType)(this.prototype);
+    constructor() {
+        this._props = ModelBase.EMPTY_PROPS;
+        this.redefineModel();
     }
-    initializeProps(props) {
-        if (!this._props) {
-            this._props = props;
-            this.validate();
+    redefineModel() {
+        this.getPropKeys().forEach((propKey) => {
+            Object.defineProperty(this, propKey, {
+                configurable: true,
+                enumerable: true,
+                get() {
+                    var _a;
+                    return (_a = this._props) === null || _a === void 0 ? void 0 : _a[propKey];
+                },
+                set() {
+                    throw new Error(`Prop "${propKey.toString()}" cannot be set directly`);
+                },
+            });
+        });
+    }
+    isMutable() {
+        return this.constructor.isMutable();
+    }
+    getPropKeys() {
+        if (!this._propKeys) {
+            this._propKeys = (0, model_metadata_1.getPropKeySet)(Reflect.getPrototypeOf(this));
         }
+        return this._propKeys;
     }
-    validate() { }
-    getType() {
-        return (0, metadata_1.getModelType)(Object.getPrototypeOf(this));
+    validateProps(props) {
+        const { validator } = this.getModelMetadata();
+        if (validator)
+            validator(props);
+    }
+    validate() {
+        this.validateProps(this._props);
+    }
+    getModelMetadata() {
+        if (!this._metadata) {
+            this._metadata = (0, model_metadata_1.getModelMetadata)(this.constructor);
+        }
+        return this._metadata;
+    }
+    modelName() {
+        return this.getModelMetadata().name;
     }
     props() {
-        return lodash_1.default.cloneDeep(this._props);
+        return lodash_1.default.cloneDeepWith(this._props, (value) => {
+            if (ModelBase.isModel(value)) {
+                value.redefineModel();
+                return value;
+            }
+        });
+    }
+    initializeProps(props) {
+        if (this._props !== ModelBase.EMPTY_PROPS)
+            throw new Error("Props is initialized");
+        if (!this.isMutable()) {
+            this._props = props;
+            Object.freeze(this._props);
+        }
+        else {
+            this._props = new Proxy(props, {
+                set: (target, propKey, value) => {
+                    let result = Reflect.set(target, propKey, value);
+                    this.validate();
+                    return result;
+                },
+            });
+        }
+        this.validate();
     }
 }
-exports.Model = Model;
+exports.ModelBase = ModelBase;
+ModelBase.EMPTY_PROPS = {};

package/dist/core/value-object.d.ts

@@ -1,10 +1,11 @@
-import { Class } from "../types/index";
-import { Model, PropsOf } from "./model";
-export declare class ValueObject<Props extends object> extends Model<Props> {
+import { Class } from "type-fest";
+import { ModelBase, PropsOf } from "./model";
+import { ClassStatic } from "../types/index";
+export declare abstract class ValueObjectBase<Props extends object> extends ModelBase<Props> {
     constructor(props: Props);
     equals<V extends AnyValueObject>(vo: V): boolean;
     with(props: Partial<Props>): this;
 }
-export type AnyValueObject = ValueObject<any>;
-export type ValueObjectClass<T extends AnyValueObject = AnyValueObject> = Class<T>;
-export type ValueObjectClassWithTypedConstructor<T extends AnyValueObject = AnyValueObject> = Class<T, ConstructorParameters<typeof ValueObject<PropsOf<T>>>>;
+export type AnyValueObject = ValueObjectBase<any>;
+export type ValueObjectClass<T extends AnyValueObject = AnyValueObject> = Class<T> & ClassStatic<typeof ValueObjectBase<PropsOf<T>>>;
+export type ValueObjectClassWithTypedConstructor<T extends AnyValueObject = AnyValueObject> = Class<T, ConstructorParameters<typeof ValueObjectBase<PropsOf<T>>>>;

package/dist/core/value-object.js

@@ -3,12 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueObject = void 0;
+exports.ValueObjectBase = void 0;
 const lodash_1 = __importDefault(require("lodash"));
 const model_1 = require("./model");
-class ValueObject extends model_1.Model {
+class ValueObjectBase extends model_1.ModelBase {
     constructor(props) {
-        super(props);
+        super();
+        this.initializeProps(props);
     }
     equals(vo) {
         const equalsType = vo instanceof this.constructor;
@@ -20,4 +21,4 @@ class ValueObject extends model_1.Model {
         return new this.constructor(newProps);
     }
 }
-exports.ValueObject = ValueObject;
+exports.ValueObjectBase = ValueObjectBase;

package/dist/decorators/aggregate.d.ts

@@ -1,4 +1,3 @@
-import { AggregateClass, AggregateESClass, AnyCommand, AnyEvent, CommandClass, CommandHandler, EventApplier, EventClass } from "../core/index";
-export declare const aggregate: (name?: string) => <T extends AggregateClass | AggregateESClass>(target: T) => void;
-export declare const applyEvent: <T extends AnyEvent>(eventClass: EventClass<T>) => <U extends EventApplier<T>>(target: object, propertyKey: string, descriptor: TypedPropertyDescriptor<U>) => void;
-export declare const handleCommand: <T extends AnyCommand>(commandClass: CommandClass<T>) => <U extends CommandHandler<T>>(target: object, propertyKey: string, descriptor: TypedPropertyDescriptor<U>) => void;
+import { AnyCommand, AnyEvent, CommandClass, CommandHandler, EventApplier, EventClass } from "../core/index";
+export declare const ApplyEvent: <T extends AnyEvent>(eventClass: EventClass<T>) => <U extends EventApplier<T>>(target: object, propertyKey: string, descriptor: TypedPropertyDescriptor<U>) => void;
+export declare const HandleCommand: <T extends AnyCommand>(commandClass: CommandClass<T>) => <U extends CommandHandler<T>>(target: object, propertyKey: string, descriptor: TypedPropertyDescriptor<U>) => void;

package/dist/decorators/aggregate.js

@@ -1,28 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleCommand = exports.applyEvent = exports.aggregate = void 0;
+exports.HandleCommand = exports.ApplyEvent = void 0;
 const _core_1 = require("../core/index");
-const model_1 = require("./model");
-const aggregate = (name) => (target) => {
-    const aggregateType = new _core_1.AggregateType(name !== null && name !== void 0 ? name : target.name);
-    (0, model_1.model)(aggregateType.value)(target);
-};
-exports.aggregate = aggregate;
-const applyEvent = (eventClass) => {
+const ApplyEvent = (eventClass) => {
     return (target, propertyKey, descriptor) => {
         if (typeof descriptor.value === "function") {
-            const type = (0, _core_1.getModelType)(eventClass.prototype);
-            (0, _core_1.defineEventApplier)(target, type, descriptor.value);
+            const eventName = (0, _core_1.getModelName)(eventClass);
+            (0, _core_1.defineEventApplier)(target, eventName, descriptor.value);
         }
     };
 };
-exports.applyEvent = applyEvent;
-const handleCommand = (commandClass) => {
+exports.ApplyEvent = ApplyEvent;
+const HandleCommand = (commandClass) => {
     return (target, propertyKey, descriptor) => {
         if (typeof descriptor.value === "function") {
-            const type = (0, _core_1.getModelType)(commandClass.prototype);
-            (0, _core_1.defineCommandHandler)(target, type, descriptor.value);
+            const commandName = (0, _core_1.getModelName)(commandClass);
+            (0, _core_1.defineCommandHandler)(target, commandName, descriptor.value);
         }
     };
 };
-exports.handleCommand = handleCommand;
+exports.HandleCommand = HandleCommand;

package/dist/decorators/id.d.ts

@@ -1,2 +1,2 @@
-import { IdGenerator } from "../core/index";
-export declare const id: <T extends IdGenerator>(idGenerator: T) => (target: object) => void;
+import { AnyModelWithId, IdGeneratorBase, ModelClass } from "../core/index";
+export declare const UseId: (idGenerator: IdGeneratorBase) => <T extends AnyModelWithId>(target: ModelClass<T>) => void;

package/dist/decorators/id.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.id = void 0;
+exports.UseId = void 0;
 const _core_1 = require("../core/index");
-const id = (idGenerator) => {
+const UseId = (idGenerator) => {
     return (target) => {
-        console.log("Target", target);
         (0, _core_1.defineIdGenerator)(target, idGenerator);
     };
 };
-exports.id = id;
+exports.UseId = UseId;

package/dist/decorators/index.d.ts

@@ -1,7 +1,3 @@
 export * from "./aggregate";
-export * from "./command";
-export * from "./entity";
-export * from "./event";
 export * from "./id";
 export * from "./model";
-export * from "./value-object";

package/dist/decorators/index.js

@@ -15,9 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./aggregate"), exports);
-__exportStar(require("./command"), exports);
-__exportStar(require("./entity"), exports);
-__exportStar(require("./event"), exports);
 __exportStar(require("./id"), exports);
 __exportStar(require("./model"), exports);
-__exportStar(require("./value-object"), exports);

package/dist/decorators/model.d.ts

@@ -1,2 +1,12 @@
-import { ModelClass, ModelTypePattern } from "../core/index";
-export declare const model: (type: ModelTypePattern) => <T extends ModelClass>(target: T) => void;
+import { AnyModel, ModelClass, PropsValidator } from "../core/index";
+import { TypedClassDecorator } from "./type";
+export declare const Prop: (target: object, propKey: string) => void;
+export declare const Name: (name?: string) => <T extends AnyModel>(target: ModelClass<T>) => void;
+export declare const Validate: <T extends AnyModel>(validator?: PropsValidator<T> | undefined) => (target: ModelClass<T>) => void;
+export type ModelOptions<T extends AnyModel> = {
+    name?: string;
+    validator?: PropsValidator<T>;
+};
+export declare function Model<T extends ModelClass, I extends InstanceType<T> = InstanceType<T>>(options?: ModelOptions<I>): TypedClassDecorator<T>;
+export declare function Model<T extends ModelClass, I extends InstanceType<T> = InstanceType<T>>(name?: string, validator?: PropsValidator<I>): TypedClassDecorator<T>;
+export declare function Model<T extends ModelClass, I extends InstanceType<T> = InstanceType<T>>(name?: string, options?: Omit<ModelOptions<I>, "name">): TypedClassDecorator<T>;

package/dist/decorators/model.js

@@ -1,11 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.model = void 0;
+exports.Model = exports.Validate = exports.Name = exports.Prop = void 0;
 const _core_1 = require("../core/index");
-const model = (type) => {
+const Prop = (target, propKey) => {
+    (0, _core_1.setPropKey)(target, propKey);
+};
+exports.Prop = Prop;
+const Name = (name) => {
+    return (target) => {
+        (0, _core_1.setModelName)(target, name !== null && name !== void 0 ? name : target.name);
+    };
+};
+exports.Name = Name;
+const Validate = (validator) => {
     return (target) => {
-        _core_1.ModelRegistry.instance().registerModel(type, target);
-        (0, _core_1.defineModelType)(target.prototype, type);
+        if (validator)
+            (0, _core_1.setValidateProps)(target, validator);
     };
 };
-exports.model = model;
+exports.Validate = Validate;
+function Model(p1, p2) {
+    return (target) => {
+        let options = {};
+        if (p1 && !p2) {
+            if (typeof p1 === "string")
+                options = { name: p1 };
+            else
+                options = p1;
+        }
+        else if (p1 && p2) {
+            p1 = p1;
+            if (typeof p2 === "function")
+                options = { name: p1, validator: p2 };
+            else
+                options = Object.assign({ name: p1 }, p2);
+        }
+        const { name, validator } = options;
+        (0, exports.Name)(name)(target);
+        (0, exports.Validate)(validator)(target);
+    };
+}
+exports.Model = Model;

package/dist/decorators/type.d.ts

@@ -0,0 +1,2 @@
+import { Class } from "type-fest";
+export type TypedClassDecorator<T extends Class<any> = Class<any>> = (target: T) => T | void;

package/dist/decorators/type.js

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

package/dist/types/class-static.d.ts

@@ -1,2 +1,2 @@
-import { Class } from "./class";
-export type ClassStatic<T extends Class<any>> = Omit<T, "constructor" | "prototype">;
+import { AnyClass } from "./class";
+export type ClassStatic<T extends AnyClass<any>> = Omit<T, "constructor" | "prototype">;

package/dist/types/class.d.ts

@@ -1,4 +1,2 @@
-export type Constructor<T, Arguments extends unknown[] = any[]> = new (...arguments_: Arguments) => T;
-export type Class<T, Arguments extends unknown[] = any[]> = Constructor<T, Arguments> & {
-    prototype: T;
-};
+import { AbstractClass, Class } from "type-fest";
+export type AnyClass<T = any> = Class<T> | AbstractClass<T>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ddd-node",
-  "version": "9.2.1",
+  "version": "12.1.0",
   "description": "Domain Driven Design base for NodeJs",
   "main": "dist/index.js",
   "scripts": {
@@ -32,6 +32,7 @@
     "nodejs-snowflake": "^2.0.1",
     "reflect-metadata": "^0.1.13",
     "tsc-alias": "^1.8.8",
+    "type-fest": "^4.15.0",
     "uuid": "^9.0.1"
   }
 }

package/tsconfig.json

@@ -31,7 +31,7 @@
     "baseUrl": "./" /* Specify the base directory to resolve non-relative module names. */,
     "paths": {
       "#core": ["src/core/index"],
-      "#decorators": ["src/dedcorators/index"],
+      "#decorators": ["src/decorators/index"],
       "#utils": ["src/utils/index"],
       "#types": ["src/types/index"]
     } /* Specify a set of entries that re-map imports to additional lookup locations. */,

package/dist/core/metadata.d.ts

@@ -1,17 +0,0 @@
-import "reflect-metadata";
-import { CommandHandler, EventApplier } from "./aggregate";
-import { IdGenerator } from "./id";
-import { ModelTypePattern } from "./model";
-import { AnyCommand, AnyEvent } from "./message";
-export declare const MODEL_TYPE = "MODEL_TYPE";
-export declare const defineModelType: (target: object, type: ModelTypePattern) => void;
-export declare const getModelType: (target: object) => ModelTypePattern;
-export declare const ID_GENERATOR = "ID_GENERATOR";
-export declare const defineIdGenerator: (target: object, idGenerator: IdGenerator) => void;
-export declare const getIdGenerator: (target: object) => any;
-export declare const EVENT_APPLIERS = "EVENT_APPLIERS";
-export declare const getEventAppliersMap: (target: object) => Map<string, EventApplier>;
-export declare const defineEventApplier: <T extends AnyEvent>(target: object, eventType: string, applier: EventApplier<T>) => void;
-export declare const COMMAND_HANDLERS = "COMMAND_HANDLERS";
-export declare const getCommandHandlersMap: (target: object) => Map<string, CommandHandler>;
-export declare const defineCommandHandler: <T extends AnyCommand>(target: object, commandType: string, handler: CommandHandler<T>) => void;

package/dist/core/metadata.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defineCommandHandler = exports.getCommandHandlersMap = exports.COMMAND_HANDLERS = exports.defineEventApplier = exports.getEventAppliersMap = exports.EVENT_APPLIERS = exports.getIdGenerator = exports.defineIdGenerator = exports.ID_GENERATOR = exports.getModelType = exports.defineModelType = exports.MODEL_TYPE = void 0;
-require("reflect-metadata");
-// Model type
-exports.MODEL_TYPE = "MODEL_TYPE";
-const defineModelType = (target, type) => {
-    Reflect.defineMetadata(exports.MODEL_TYPE, type, target);
-};
-exports.defineModelType = defineModelType;
-const getModelType = (target) => {
-    const type = Reflect.getMetadata(exports.MODEL_TYPE, target);
-    if (!type)
-        throw new Error("The type has not been defined");
-    return type;
-};
-exports.getModelType = getModelType;
-// Id generator
-exports.ID_GENERATOR = "ID_GENERATOR";
-const defineIdGenerator = (target, idGenerator) => {
-    Reflect.defineMetadata(exports.ID_GENERATOR, idGenerator, target);
-};
-exports.defineIdGenerator = defineIdGenerator;
-const getIdGenerator = (target) => {
-    return Reflect.getMetadata(exports.ID_GENERATOR, target);
-};
-exports.getIdGenerator = getIdGenerator;
-// Event applier map
-exports.EVENT_APPLIERS = "EVENT_APPLIERS";
-const getEventAppliersMap = (target) => {
-    return (Reflect.getMetadata(exports.EVENT_APPLIERS, target) ||
-        new Map());
-};
-exports.getEventAppliersMap = getEventAppliersMap;
-const defineEventApplier = (target, eventType, applier) => {
-    const eventAppliersMap = (0, exports.getEventAppliersMap)(target);
-    eventAppliersMap.set(eventType, applier);
-    Reflect.defineMetadata(exports.EVENT_APPLIERS, eventAppliersMap, target);
-};
-exports.defineEventApplier = defineEventApplier;
-// Command handler map
-exports.COMMAND_HANDLERS = "COMMAND_HANDLERS";
-const getCommandHandlersMap = (target) => {
-    return (Reflect.getMetadata(exports.COMMAND_HANDLERS, target) ||
-        new Map());
-};
-exports.getCommandHandlersMap = getCommandHandlersMap;
-const defineCommandHandler = (target, commandType, handler) => {
-    const commandHandlersMap = (0, exports.getCommandHandlersMap)(target);
-    commandHandlersMap.set(commandType, handler);
-    Reflect.defineMetadata(exports.COMMAND_HANDLERS, commandHandlersMap, target);
-};
-exports.defineCommandHandler = defineCommandHandler;

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

@@ -1,85 +0,0 @@
-import { Class, ClassStatic } from "../../types/index";
-export declare const seperator: "#";
-export type ModelTypePattern<Prefix extends string = string> = `${Prefix}${typeof seperator}${string}`;
-export declare const ModelTypePatternRegex: RegExp;
-export declare class ModelType<Prefix extends string = string> {
-    readonly prefix: Prefix;
-    readonly name: string;
-    constructor(prefix: Prefix, name: string);
-    static from<Prefix extends string = string>(value: ModelTypePattern<Prefix>): ModelType<Prefix>;
-    static isPattern(type: string): type is ModelTypePattern;
-    get value(): ModelTypePattern<Prefix>;
-}
-export type PrefixOf<T extends ModelType> = T extends ModelType<infer Prefix> ? Prefix : never;
-export type ModelTypeClass<T extends ModelType> = Class<T> & ClassStatic<typeof ModelType<PrefixOf<T>>>;
-export type ModelTypePatternOf<T extends ModelType> = ModelTypePattern<PrefixOf<T>>;
-export declare const createPrefixedModelTypeClass: <Prefix extends string = string>(prefix: Prefix) => {
-    new (name: string): {
-        readonly prefix: Prefix;
-        readonly name: string;
-        readonly value: `${Prefix}#${string}`;
-    };
-    from<Prefix_1 extends string = string>(value: `${Prefix_1}#${string}`): ModelType<Prefix_1>;
-    isPattern(type: string): type is `${string}#${string}`;
-};
-export declare const EntityTypePrefix: "Entity";
-declare const EntityType_base: {
-    new (name: string): {
-        readonly prefix: "Entity";
-        readonly name: string;
-        readonly value: `Entity#${string}`;
-    };
-    from<Prefix extends string = string>(value: `${Prefix}#${string}`): ModelType<Prefix>;
-    isPattern(type: string): type is `${string}#${string}`;
-};
-export declare class EntityType extends EntityType_base {
-}
-export declare const AggregateTypePrefix: "Aggregate";
-declare const AggregateType_base: {
-    new (name: string): {
-        readonly prefix: "Aggregate";
-        readonly name: string;
-        readonly value: `Aggregate#${string}`;
-    };
-    from<Prefix extends string = string>(value: `${Prefix}#${string}`): ModelType<Prefix>;
-    isPattern(type: string): type is `${string}#${string}`;
-};
-export declare class AggregateType extends AggregateType_base {
-}
-export declare const EventTypePrefix: "Event";
-declare const EventType_base: {
-    new (name: string): {
-        readonly prefix: "Event";
-        readonly name: string;
-        readonly value: `Event#${string}`;
-    };
-    from<Prefix extends string = string>(value: `${Prefix}#${string}`): ModelType<Prefix>;
-    isPattern(type: string): type is `${string}#${string}`;
-};
-export declare class EventType extends EventType_base {
-}
-export declare const CommandTypePrefix: "Command";
-declare const CommandType_base: {
-    new (name: string): {
-        readonly prefix: "Command";
-        readonly name: string;
-        readonly value: `Command#${string}`;
-    };
-    from<Prefix extends string = string>(value: `${Prefix}#${string}`): ModelType<Prefix>;
-    isPattern(type: string): type is `${string}#${string}`;
-};
-export declare class CommandType extends CommandType_base {
-}
-export declare const ValueObjectTypePrefix: "ValueObject";
-declare const ValueObjectType_base: {
-    new (name: string): {
-        readonly prefix: "ValueObject";
-        readonly name: string;
-        readonly value: `ValueObject#${string}`;
-    };
-    from<Prefix extends string = string>(value: `${Prefix}#${string}`): ModelType<Prefix>;
-    isPattern(type: string): type is `${string}#${string}`;
-};
-export declare class ValueObjectType extends ValueObjectType_base {
-}
-export {};