ddd-node 5.0.1 → 6.1.0

package/dist/core/model-type.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueObjectType = exports.ValueObjectTypePrefix = exports.CommandType = exports.CommandTypePrefix = exports.EventType = exports.EventTypePrefix = exports.AggregateType = exports.AggregateTypePrefix = exports.EntityType = exports.EntityTypePrefix = exports.createPrefixedModelTypeClass = exports.ModelType = exports.ModelTypePatternRegex = exports.seperator = void 0;
+exports.seperator = "#";
+exports.ModelTypePatternRegex = new RegExp(".+" + exports.seperator + ".+");
+class ModelType {
+    constructor(prefix, name) {
+        this.prefix = prefix;
+        this.name = name;
+    }
+    static from(value) {
+        if (!this.isPattern(value))
+            throw new Error("Invalid value");
+        const [prefix, ...names] = value.split(exports.seperator);
+        const name = names.join(exports.seperator);
+        return new ModelType(prefix, name);
+    }
+    static isPattern(type) {
+        return exports.ModelTypePatternRegex.test(type);
+    }
+    get value() {
+        return `${this.prefix}${exports.seperator}${this.name}`;
+    }
+}
+exports.ModelType = ModelType;
+//
+const createPrefixedModelTypeClass = (prefix) => {
+    return class extends ModelType {
+        constructor(name) {
+            super(prefix, name);
+        }
+    };
+};
+exports.createPrefixedModelTypeClass = createPrefixedModelTypeClass;
+//
+exports.EntityTypePrefix = "Entity";
+class EntityType extends (0, exports.createPrefixedModelTypeClass)(exports.EntityTypePrefix) {
+}
+exports.EntityType = EntityType;
+exports.AggregateTypePrefix = "Aggregate";
+class AggregateType extends (0, exports.createPrefixedModelTypeClass)(exports.AggregateTypePrefix) {
+}
+exports.AggregateType = AggregateType;
+exports.EventTypePrefix = "Event";
+class EventType extends (0, exports.createPrefixedModelTypeClass)(exports.EventTypePrefix) {
+}
+exports.EventType = EventType;
+exports.CommandTypePrefix = "Command";
+class CommandType extends (0, exports.createPrefixedModelTypeClass)(exports.CommandTypePrefix) {
+}
+exports.CommandType = CommandType;
+exports.ValueObjectTypePrefix = "ValueObject";
+class ValueObjectType extends (0, exports.createPrefixedModelTypeClass)(exports.ValueObjectTypePrefix) {
+}
+exports.ValueObjectType = ValueObjectType;

package/dist/core/model.d.ts

@@ -0,0 +1,14 @@
+import { Class } from "../types/class";
+export declare class Model<Props extends object> {
+    protected _props?: Props;
+    constructor(props?: Props);
+    static isModel(obj: object): boolean;
+    protected setProps(props: Props): void;
+    validate(): void;
+    get type(): `${string}#${string}`;
+    props(): Props | undefined;
+}
+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 EmptyProps = {};

package/dist/{base/props-envelope.js → core/model.js}

@@ -3,25 +3,28 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PropsEnvelope = void 0;
+exports.Model = void 0;
 const lodash_1 = __importDefault(require("lodash"));
-class PropsEnvelope {
+const metadata_1 = require("./metadata");
+class Model {
     constructor(props) {
-        if (props)
-            this.initProps(props);
-    }
-    validate() { }
-    initProps(props) {
-        if (this.props)
-            return;
         this._props = props;
-        this.validate();
     }
-    get props() {
-        return this._props;
+    static isModel(obj) {
+        return obj instanceof Model;
+    }
+    setProps(props) {
+        if (!this._props) {
+            this._props = props;
+            this.validate();
+        }
+    }
+    validate() { }
+    get type() {
+        return (0, metadata_1.getModelType)(Object.getPrototypeOf(this));
     }
-    getProps() {
+    props() {
         return lodash_1.default.cloneDeep(this._props);
     }
 }
-exports.PropsEnvelope = PropsEnvelope;
+exports.Model = Model;

package/dist/core/registry.d.ts

@@ -0,0 +1,12 @@
+import { ModelClass } from "./model";
+import { ModelTypePattern } from "./model-type";
+export declare class ModelRegistry {
+    private static _instance;
+    private modelMap;
+    private constructor();
+    static instance(): ModelRegistry;
+    getMap(): Map<`${string}#${string}`, ModelClass>;
+    hasModel(type: ModelTypePattern): boolean;
+    registerModel(type: ModelTypePattern, modelClass: ModelClass): void;
+    getModel(type: ModelTypePattern): ModelClass | undefined;
+}

package/dist/core/registry.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelRegistry = void 0;
+class ModelRegistry {
+    constructor() {
+        this.modelMap = new Map();
+    }
+    static instance() {
+        if (!this._instance)
+            this._instance = new ModelRegistry();
+        return this._instance;
+    }
+    getMap() {
+        return this.modelMap;
+    }
+    hasModel(type) {
+        return this.modelMap.has(type);
+    }
+    registerModel(type, modelClass) {
+        if (this.hasModel(type))
+            throw new Error(`Duplicate model for type ${type}`);
+        this.modelMap.set(type, modelClass);
+    }
+    getModel(type) {
+        return this.modelMap.get(type);
+    }
+}
+exports.ModelRegistry = ModelRegistry;

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

@@ -0,0 +1,10 @@
+import { Class } from "../types/class";
+import { Model, PropsOf } from "./model";
+export declare class ValueObject<Props extends object> extends Model<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>>>>;

package/dist/{base → core}/value-object.js

@@ -4,27 +4,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValueObject = void 0;
-const value_object_1 = require("../metadata/value-object");
 const lodash_1 = __importDefault(require("lodash"));
-const props_envelope_1 = require("./props-envelope");
-class ValueObject extends props_envelope_1.PropsEnvelope {
+const model_1 = require("./model");
+class ValueObject extends model_1.Model {
     constructor(props) {
         super(props);
     }
-    static valueObjectType() {
-        return (0, value_object_1.getValueObjectType)(this.prototype);
-    }
-    valueObjectType() {
-        const prototype = Object.getPrototypeOf(this);
-        return (0, value_object_1.getValueObjectType)(prototype);
-    }
     equals(vo) {
         const equalsType = vo instanceof this.constructor;
         const equalsValue = JSON.stringify(vo) === JSON.stringify(this);
         return equalsType && equalsValue;
     }
     with(props) {
-        const newProps = lodash_1.default.merge(this.getProps(), props);
+        const newProps = lodash_1.default.merge(this.props(), props);
         return new this.constructor(newProps);
     }
 }

package/dist/decorators/aggregate.d.ts

@@ -1,7 +1,6 @@
-import { AggregateClass, AggregateCommandHandler, AggregateEventApplier, AnyAggregate } from "../base/aggregate";
-import { AnyCommand } from "../base/command";
-import { AnyEvent } from "../base/event";
-import { Class } from "../types/class";
-export declare const TypeAggregate: <T extends AnyAggregate>(aggregateType?: string) => <U extends AggregateClass<T>>(target: U) => void;
-export declare const ApplyEvent: <E extends AnyEvent>(eventClass: Class<E>) => <T extends AggregateEventApplier<E>>(target: object, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => void;
-export declare const ProcessCommand: <C extends AnyCommand>(commandClass: Class<C>) => <T extends AggregateCommandHandler<C>>(target: object, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => void;
+import { AggregateClass, AggregateESClass, CommandHandler, EventApplier } from "../core/aggregate";
+import { AnyCommand, CommandClass } from "../core/command";
+import { AnyEvent, EventClass } from "../core/event";
+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;

package/dist/decorators/aggregate.js

@@ -1,32 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProcessCommand = exports.ApplyEvent = exports.TypeAggregate = void 0;
-const aggregate_1 = require("../metadata/aggregate");
-const command_1 = require("../metadata/command");
-const event_1 = require("../metadata/event");
-const TypeAggregate = (aggregateType) => {
-    return (target) => {
-        aggregateType = aggregateType !== null && aggregateType !== void 0 ? aggregateType : target.name;
-        (0, aggregate_1.defineAggregateType)(target.prototype, aggregateType);
-        aggregate_1.AggregateRegistry.register(aggregateType, target);
-    };
+exports.handleCommand = exports.applyEvent = exports.aggregate = void 0;
+const metadata_1 = require("../core/metadata");
+const model_type_1 = require("../core/model-type");
+const model_1 = require("./model");
+const aggregate = (name) => (target) => {
+    const aggregateType = new model_type_1.AggregateType(name !== null && name !== void 0 ? name : target.name);
+    (0, model_1.model)(aggregateType.value)(target);
 };
-exports.TypeAggregate = TypeAggregate;
-const ApplyEvent = (eventClass) => {
+exports.aggregate = aggregate;
+const applyEvent = (eventClass) => {
     return (target, propertyKey, descriptor) => {
         if (typeof descriptor.value === "function") {
-            const eventType = (0, event_1.getEventType)(eventClass.prototype);
-            (0, aggregate_1.defineAggregateEventApplier)(target, eventType, descriptor.value);
+            const type = (0, metadata_1.getModelType)(eventClass.prototype);
+            (0, metadata_1.defineEventApplier)(target, type, descriptor.value);
         }
     };
 };
-exports.ApplyEvent = ApplyEvent;
-const ProcessCommand = (commandClass) => {
+exports.applyEvent = applyEvent;
+const handleCommand = (commandClass) => {
     return (target, propertyKey, descriptor) => {
         if (typeof descriptor.value === "function") {
-            const commandType = (0, command_1.getCommandType)(commandClass.prototype);
-            (0, aggregate_1.defineAggregateCommandHandler)(target, commandType, descriptor.value);
+            const type = (0, metadata_1.getModelType)(commandClass.prototype);
+            (0, metadata_1.defineCommandHandler)(target, type, descriptor.value);
         }
     };
 };
-exports.ProcessCommand = ProcessCommand;
+exports.handleCommand = handleCommand;

package/dist/decorators/command.d.ts

@@ -1,2 +1,2 @@
-import { AnyCommand, CommandClass } from "../base/command";
-export declare const TypeCommand: <T extends AnyCommand>(aggregateType: string, commandType?: string) => <U extends CommandClass<T>>(target: U) => void;
+import { CommandClass } from "../core/command";
+export declare const command: (name?: string) => <T extends CommandClass>(target: T) => void;

package/dist/decorators/command.js

@@ -1,14 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeCommand = void 0;
-const command_1 = require("../metadata/command");
-const message_1 = require("./message");
-const TypeCommand = (aggregateType, commandType) => {
-    return (target) => {
-        (0, message_1.TypeMessage)(aggregateType)(target);
-        commandType = commandType !== null && commandType !== void 0 ? commandType : target.name;
-        (0, command_1.defineCommandType)(target.prototype, commandType);
-        command_1.CommandRegistry.register(commandType, target);
-    };
+exports.command = void 0;
+const model_type_1 = require("../core/model-type");
+const model_1 = require("./model");
+const command = (name) => (target) => {
+    const commandType = new model_type_1.CommandType(name !== null && name !== void 0 ? name : target.name);
+    (0, model_1.model)(commandType.value)(target);
 };
-exports.TypeCommand = TypeCommand;
+exports.command = command;

package/dist/decorators/entity.d.ts

@@ -1,2 +1,2 @@
-import { AnyEntity, EntityClass } from "../base/entity";
-export declare const TypeEntity: <T extends AnyEntity>(entityType?: string) => <U extends EntityClass<T>>(target: U) => void;
+import { EntityClass } from "../core/entity";
+export declare const entity: (name?: string) => <T extends EntityClass>(target: T) => void;

package/dist/decorators/entity.js

@@ -1,12 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeEntity = void 0;
-const entity_1 = require("../metadata/entity");
-const TypeEntity = (entityType) => {
-    return (target) => {
-        entityType = entityType !== null && entityType !== void 0 ? entityType : target.name;
-        (0, entity_1.defineEntityType)(target.prototype, entityType);
-        entity_1.EntityRegistry.register(entityType, target);
-    };
+exports.entity = void 0;
+const model_type_1 = require("../core/model-type");
+const model_1 = require("./model");
+const entity = (name) => (target) => {
+    const entityType = new model_type_1.EntityType(name !== null && name !== void 0 ? name : target.name);
+    (0, model_1.model)(entityType.value)(target);
 };
-exports.TypeEntity = TypeEntity;
+exports.entity = entity;

package/dist/decorators/event.d.ts

@@ -1,2 +1,2 @@
-import { AnyEvent, EventClass } from "../base/event";
-export declare const TypeEvent: <T extends AnyEvent>(aggregateType: string, eventType?: string) => <U extends EventClass<T>>(target: U) => void;
+import { EventClass } from "../core/event";
+export declare const event: (name?: string) => <T extends EventClass>(target: T) => void;

package/dist/decorators/event.js

@@ -1,14 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeEvent = void 0;
-const event_1 = require("../metadata/event");
-const message_1 = require("./message");
-const TypeEvent = (aggregateType, eventType) => {
-    return (target) => {
-        (0, message_1.TypeMessage)(aggregateType)(target);
-        eventType = eventType !== null && eventType !== void 0 ? eventType : target.name;
-        (0, event_1.defineEventType)(target.prototype, eventType !== null && eventType !== void 0 ? eventType : target.name);
-        event_1.EventRegistry.register(eventType, target);
-    };
+exports.event = void 0;
+const model_type_1 = require("../core/model-type");
+const model_1 = require("./model");
+const event = (name) => (target) => {
+    const eventType = new model_type_1.EventType(name !== null && name !== void 0 ? name : target.name);
+    (0, model_1.model)(eventType.value)(target);
 };
-exports.TypeEvent = TypeEvent;
+exports.event = event;

package/dist/decorators/index.d.ts

@@ -1,6 +1,6 @@
 export * from "./aggregate";
-export * from "./message";
-export * from "./entity";
 export * from "./command";
+export * from "./entity";
 export * from "./event";
+export * from "./model";
 export * from "./value-object";

package/dist/decorators/index.js

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

package/dist/decorators/model.d.ts

@@ -0,0 +1,3 @@
+import { ModelClass } from "../core/model";
+import { ModelTypePattern } from "../core/model-type";
+export declare const model: (type: ModelTypePattern) => <T extends ModelClass>(target: T) => void;

package/dist/decorators/model.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.model = void 0;
+const metadata_1 = require("../core/metadata");
+const registry_1 = require("../core/registry");
+const model = (type) => {
+    return (target) => {
+        registry_1.ModelRegistry.instance().registerModel(type, target);
+        (0, metadata_1.defineModelType)(target.prototype, type);
+    };
+};
+exports.model = model;

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

@@ -1,2 +1,2 @@
-import { AnyValueObject, ValueObjectClass } from "../base/value-object";
-export declare const TypeValueObject: <T extends AnyValueObject>(valueObjectType?: string) => <U extends ValueObjectClass<T>>(target: U) => void;
+import { ValueObjectClass } from "../core/value-object";
+export declare const valueObject: (name?: string) => <T extends ValueObjectClass>(target: T) => void;

package/dist/decorators/value-object.js

@@ -1,12 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeValueObject = void 0;
-const value_object_1 = require("../metadata/value-object");
-const TypeValueObject = (valueObjectType) => {
-    return (target) => {
-        valueObjectType = valueObjectType !== null && valueObjectType !== void 0 ? valueObjectType : target.name;
-        (0, value_object_1.defineValueObjectType)(target.prototype, valueObjectType);
-        value_object_1.ValueObjectRegistry.register(valueObjectType, target);
-    };
+exports.valueObject = void 0;
+const model_type_1 = require("../core/model-type");
+const model_1 = require("./model");
+const valueObject = (name) => (target) => {
+    const valueObjectType = new model_type_1.ValueObjectType(name !== null && name !== void 0 ? name : target.name);
+    (0, model_1.model)(valueObjectType.value)(target);
 };
-exports.TypeValueObject = TypeValueObject;
+exports.valueObject = valueObject;

package/dist/index.d.ts

@@ -1,5 +1,4 @@
-export * from "./base";
+export * from "./core";
 export * from "./decorators";
-export * from "./metadata";
 export * from "./types";
 export * from "./utils";

package/dist/index.js

@@ -14,8 +14,7 @@ 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("./base"), exports);
+__exportStar(require("./core"), exports);
 __exportStar(require("./decorators"), exports);
-__exportStar(require("./metadata"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./utils"), exports);

package/dist/types/class.d.ts

@@ -2,8 +2,3 @@ export type Constructor<T, Arguments extends unknown[] = any[]> = new (...argume
 export type Class<T, Arguments extends unknown[] = any[]> = Constructor<T, Arguments> & {
     prototype: T;
 };
-export type AbstractConstructor<T, Arguments extends unknown[] = any[]> = abstract new (...arguments_: Arguments) => T;
-export type AbstractClass<T, Arguments extends unknown[] = any[]> = AbstractConstructor<T, Arguments> & {
-    prototype: T;
-};
-export type AbstractableClass<T, Arguments extends unknown[] = any[]> = Class<T, Arguments> | AbstractClass<T, Arguments>;

package/dist/utils/index.d.ts

@@ -1,2 +1 @@
-export * from "./id";
 export * from "./to-array";

package/dist/utils/index.js

@@ -14,5 +14,4 @@ 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("./id"), exports);
 __exportStar(require("./to-array"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ddd-node",
-  "version": "5.0.1",
+  "version": "6.1.0",
   "description": "Domain Driven Design base for NodeJs",
   "main": "dist/index.js",
   "scripts": {

package/tsconfig.json

@@ -30,9 +30,8 @@
     // "moduleResolution": "node10",                     /* Specify how TypeScript looks up a file from a given module specifier. */
     "baseUrl": "./" /* Specify the base directory to resolve non-relative module names. */,
     "paths": {
-      "#base/*": ["src/base/*"],
+      "#core/*": ["src/core/*"],
       "#decorators/*": ["src/decorator/*"],
-      "#metadata/*": ["src/metadata/*"],
       "#utils/*": ["src/utils/*"],
       "#types/*": ["src/types/*"]
     } /* Specify a set of entries that re-map imports to additional lookup locations. */,

package/dist/base/aggregate.d.ts

@@ -1,70 +0,0 @@
-import { Class } from "../types/class";
-import { ClassStatic } from "../types/class-static";
-import { AnyCommand } from "./command";
-import { Entity, IEntityMetadata } from "./entity";
-import { AnyEvent, EventClass, NewEventMetadataOptions } from "./event";
-import { Id } from "./id";
-import { PropsOf } from "./props-envelope";
-export interface IAggregateMetadata extends IEntityMetadata {
-    readonly aggregateType: string;
-    readonly version: number;
-}
-export type AggregateMetadataWithoutEntityType = Omit<IAggregateMetadata, "entityType">;
-export type NewAggregateMetadata = Partial<Omit<IAggregateMetadata, "aggregateType">>;
-export declare class Aggregate<P extends object> extends Entity<P> implements IAggregateMetadata {
-    private readonly _aggregateType;
-    protected readonly _version: number;
-    protected events: AnyEvent[];
-    constructor(metadata: AggregateMetadataWithoutEntityType, props?: P);
-    static aggregateType(): string;
-    static newAggregate<T extends AnyAggregate>(this: AggregateClass<T>, props?: PropsOf<T>, metadata?: NewAggregateMetadata): T;
-    get version(): number;
-    get aggregateType(): string;
-    getEvents(): AnyEvent[];
-    hasEvents(): boolean;
-    nextVersion(): number;
-    protected newEvent<E extends AnyEvent>(eventClass: EventClass<E>, props: PropsOf<E>, metadata?: NewEventMetadataOptions): E;
-    protected addEvent<E extends AnyEvent>(event: E): void;
-    protected addNewEvent<E extends AnyEvent>(eventClass: EventClass<E>, props: PropsOf<E>, metadata?: NewEventMetadataOptions): void;
-}
-export type SnapshotAggregateMetadata = AggregateMetadataWithoutEntityType;
-export interface SnapshotWithProps<P extends object> {
-    metadata: SnapshotAggregateMetadata;
-    props: P;
-}
-export interface Snapshot<T extends AnyAggregateES> extends SnapshotWithProps<PropsOf<T>> {
-}
-export declare class AggregateES<P extends object> extends Aggregate<P> {
-    protected handledCommands: AnyCommand[];
-    protected pastEvents: AnyEvent[];
-    static stream<T extends AnyAggregateES>(this: AggregateESClass<T>, id: Id, events: AnyEvent[]): T;
-    static snapshot<T extends AnyAggregateES>(this: AggregateESClass<T>, snapshot: Snapshot<T>, eventsAfterSnapshot: AnyEvent[]): T;
-    getHandledCommands(): AnyCommand[];
-    getPastEvents(): AnyEvent[];
-    lastEvent(): AnyEvent | undefined;
-    currentVersion(): number;
-    nextVersion(): number;
-    private addPastEvent;
-    private validateEventBeforeApply;
-    getEventApplierSafe(eventType: string): AggregateEventApplier<AnyEvent> | null;
-    getEventApplier(eventType: string): AggregateEventApplier<AnyEvent>;
-    applyEvent<E extends AnyEvent>(event: E, fromHistory?: boolean): void;
-    applyEvents(events: AnyEvent[], fromHistory?: boolean): void;
-    getCommandHandlerSafe(commandType: string): AggregateCommandHandler<AnyCommand> | null;
-    getCommandHandler(commandType: string): AggregateCommandHandler<AnyCommand>;
-    private validateCommandBeforeProcess;
-    processCommand<C extends AnyCommand>(command: C): AnyEvent[];
-    snap(): SnapshotWithProps<P>;
-}
-export type AnyAggregate = Aggregate<any>;
-export type AnyAggregateES = AggregateES<any>;
-export type AggregateEventApplier<E extends AnyEvent> = (event: E) => void;
-export type AggregateCommandHandler<C extends AnyCommand, E extends AnyEvent = AnyEvent> = (command: C) => E | E[];
-export type AggregateConstructorParamsWithProps<P extends object> = ConstructorParameters<typeof Aggregate<P>>;
-export type AggregateClassWithProps<P extends object> = Class<Aggregate<P>, AggregateConstructorParamsWithProps<P>> & ClassStatic<typeof Aggregate<P>>;
-export type AggregateESClassWithProps<P extends object> = Class<AggregateES<P>, AggregateConstructorParamsWithProps<P>> & ClassStatic<typeof AggregateES<P>>;
-export type AggregateConstructorParams<T extends AnyAggregate> = AggregateConstructorParamsWithProps<PropsOf<T>>;
-export type AggregateClass<T extends AnyAggregate> = Class<T, AggregateConstructorParams<T>> & ClassStatic<typeof Aggregate<PropsOf<T>>>;
-export type AggregateESClass<T extends AnyAggregateES> = Class<T, AggregateConstructorParams<T>> & ClassStatic<typeof AggregateES<PropsOf<T>>>;
-export type InferAggregateClass<T extends AnyAggregate> = T extends AnyAggregateES ? AggregateESClass<T> : AggregateClass<T>;
-export type AnyAggregateClass = Class<AnyAggregate>;