ddd-node 29.2.0 → 29.4.0

package/dist/base/model/errors.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropsInitializedError = void 0;
+class PropsInitializedError extends Error {
+    constructor() {
+        super("Props is initialized");
+    }
+}
+exports.PropsInitializedError = PropsInitializedError;

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

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

package/dist/base/model/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./model"), exports);
+__exportStar(require("./model-descriptor"), exports);
+__exportStar(require("./model.builder"), exports);

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

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

package/dist/base/model/model-descriptor.js

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

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

@@ -0,0 +1,11 @@
+import { AnyModel, InferredProps } from "./model";
+export interface IModelBuilder<T extends AnyModel = AnyModel> {
+    buildSafe(): T | null;
+    build(): T;
+}
+export declare abstract class ModelBuilder<T extends AnyModel = AnyModel> implements IModelBuilder<T> {
+    protected props?: InferredProps<T>;
+    withProps(props: InferredProps<T>): this;
+    abstract build(): T;
+    buildSafe(): T | null;
+}

package/dist/base/model/model.builder.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelBuilder = void 0;
+class ModelBuilder {
+    withProps(props) {
+        this.props = props;
+        return this;
+    }
+    buildSafe() {
+        try {
+            return this.build();
+        }
+        catch (err) {
+            return null;
+        }
+    }
+}
+exports.ModelBuilder = ModelBuilder;

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

@@ -0,0 +1,40 @@
+import { AbstractClass, Class } from "type-fest";
+import { ClassStatic } from "../../types";
+import { ModelId, ModelName, ModelPropsMap, ModelPropsValidator, ModelStaticValuesMap, ModelVersion } from "../meta";
+import { ModelDescriptor } from "./model-descriptor";
+export interface Props {
+    [key: PropertyKey]: any;
+}
+export type EmptyProps = {
+    [key: PropertyKey]: never;
+};
+export declare class ModelBase<P extends Props> {
+    static readonly EMPTY_PROPS: EmptyProps;
+    protected _props: P;
+    static isModel(model: any): model is AnyModel;
+    static modelMutable<T extends AnyModel>(this: ModelClass<T>): boolean;
+    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 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;
+    modelDescriptor(): ModelDescriptor<typeof this>;
+    validateProps(props: P): void;
+    validate(): void;
+    propsIsEmpty(): boolean;
+    props(): P | null;
+    metadata(): any;
+    protected initializeProps(props: P): void;
+}
+export type AnyModel = ModelBase<Props>;
+export type InferredProps<T extends AnyModel> = T extends ModelBase<infer P> ? P : never;
+export interface ModelClass<T extends AnyModel = AnyModel> extends Class<T>, ClassStatic<typeof ModelBase<InferredProps<T>>> {
+}
+export interface AbstractModelClass<T extends AnyModel = AnyModel> extends AbstractClass<T>, ClassStatic<typeof ModelBase<InferredProps<T>>> {
+}

package/dist/base/model/model.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelBase = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const meta_1 = require("../meta");
+const errors_1 = require("./errors");
+class ModelBase {
+    static isModel(model) {
+        return model instanceof ModelBase;
+    }
+    static modelMutable() {
+        return (0, meta_1.getModelMutable)(this) ?? false;
+    }
+    static modelName() {
+        return (0, meta_1.getModelName)(this);
+    }
+    static modelVersion() {
+        return (0, meta_1.getModelVersion)(this);
+    }
+    static modelId() {
+        return (0, meta_1.getModelId)(this);
+    }
+    static ownModelPropsValidator() {
+        return (0, meta_1.getOwnModelPropsValidator)(this);
+    }
+    static modelPropsValidators() {
+        return (0, meta_1.getModelPropsValidators)(this);
+    }
+    static ownModelStaticValues() {
+        return (0, meta_1.getOwnModelStaticValues)(this);
+    }
+    static ownModelPropsMap() {
+        return (0, meta_1.getOwnModelPropsMap)(this.prototype);
+    }
+    static modelPropsMap() {
+        return (0, meta_1.getModelPropsMap)(this.prototype);
+    }
+    constructor() {
+        this._props = ModelBase.EMPTY_PROPS;
+        this.redefineModel();
+    }
+    redefineModel() {
+        this.modelDescriptor().modelPropsMap.forEach((propTargetKey, key) => {
+            this.redefineProp(key, propTargetKey);
+        });
+    }
+    redefineProp(key, propTargetKey) {
+        Object.defineProperty(this, key, {
+            // must be true because the props() method need to recall redefineModel(-> redefineProp)
+            configurable: true,
+            enumerable: true,
+            get() {
+                return this._props?.[propTargetKey];
+            },
+        });
+    }
+    modelDescriptor() {
+        const modelClass = this.constructor;
+        return {
+            modelMutable: modelClass.modelMutable(),
+            modelId: modelClass.modelId(),
+            modelName: modelClass.modelName(),
+            modelVersion: modelClass.modelVersion(),
+            ownModelPropsValidator: modelClass.ownModelPropsValidator(),
+            modelPropsValidators: modelClass.modelPropsValidators(),
+            ownModelStaticValues: modelClass.ownModelStaticValues(),
+            ownModelPropsMap: modelClass.ownModelPropsMap(),
+            modelPropsMap: modelClass.modelPropsMap(),
+        };
+    }
+    validateProps(props) {
+        const modelPropsValidators = this.modelDescriptor().modelPropsValidators;
+        modelPropsValidators.forEach((propsValidator) => propsValidator.call(this.constructor, props));
+    }
+    validate() {
+        this.validateProps(this._props);
+    }
+    propsIsEmpty() {
+        return this._props === ModelBase.EMPTY_PROPS;
+    }
+    props() {
+        if (this.propsIsEmpty())
+            return null;
+        return lodash_1.default.cloneDeepWith(this._props, (value) => {
+            if (ModelBase.isModel(value)) {
+                value.redefineModel();
+                return value;
+            }
+        });
+    }
+    metadata() {
+        return {};
+    }
+    initializeProps(props) {
+        if (!this.propsIsEmpty())
+            throw new errors_1.PropsInitializedError();
+        if (!this.modelDescriptor().modelMutable) {
+            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.ModelBase = ModelBase;
+ModelBase.EMPTY_PROPS = {};

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

@@ -0,0 +1,17 @@
+import { AnyModel, ModelClass } from "./model";
+import { ModelId, ModelName, ModelVersion } from "./meta";
+export declare class ModelVersionMap<T extends AnyModel = AnyModel> extends Map<ModelVersion, ModelClass<T>> {
+    readonly modelName: ModelName;
+    constructor(modelName: ModelName);
+}
+export declare class ModelMap<T extends AnyModel = AnyModel> extends Map<ModelName, ModelVersionMap<T>> {
+}
+export declare class ModelRegistry {
+    private readonly modelMap;
+    getModelVersionMap<T extends AnyModel = AnyModel>(modelName: ModelName): ModelVersionMap<T>;
+    getModel<T extends AnyModel = AnyModel>(modelName: ModelName, modelVersion?: ModelVersion): ModelClass<T> | undefined;
+    getModelByModelId<T extends AnyModel = AnyModel>(modelId: ModelId): ModelClass<T> | undefined;
+    hasRegisteredModel(modelName: ModelName, modelVersion: ModelVersion): boolean;
+    hasRegisteredModel(model: ModelClass): boolean;
+    registerModel(modelClass: ModelClass): this;
+}

package/dist/base/model-registry.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelRegistry = exports.ModelMap = exports.ModelVersionMap = void 0;
+const meta_1 = require("./meta");
+class ModelVersionMap extends Map {
+    constructor(modelName) {
+        super();
+        this.modelName = modelName;
+    }
+}
+exports.ModelVersionMap = ModelVersionMap;
+class ModelMap extends Map {
+}
+exports.ModelMap = ModelMap;
+class ModelRegistry {
+    constructor() {
+        this.modelMap = new ModelMap();
+    }
+    getModelVersionMap(modelName) {
+        const modelVersionMap = () => this.modelMap.get(modelName);
+        if (!modelVersionMap())
+            this.modelMap.set(modelName, new ModelVersionMap(modelName));
+        return modelVersionMap();
+    }
+    getModel(modelName, modelVersion = 0) {
+        const modelVersionMap = this.getModelVersionMap(modelName);
+        return modelVersionMap.get(modelVersion);
+    }
+    getModelByModelId(modelId) {
+        const { modelName, modelVersion } = meta_1.$ModelId.fromValue(modelId);
+        return this.getModel(modelName, modelVersion);
+    }
+    hasRegisteredModel(p1, p2) {
+        let modelName, modelVersion;
+        if (typeof p1 === "string") {
+            modelName = p1;
+            modelVersion = p2;
+        }
+        else {
+            modelName = p1.modelName();
+            modelVersion = p1.modelVersion();
+        }
+        return Boolean(this.getModel(modelName, modelVersion));
+    }
+    registerModel(modelClass) {
+        const modelName = modelClass.modelName();
+        const modelVersion = modelClass.modelVersion();
+        if (this.hasRegisteredModel(modelName, modelVersion))
+            throw new Error(`Model ${modelName} with version ${modelVersion} has been registered`);
+        const modelVersionMap = this.getModelVersionMap(modelName);
+        modelVersionMap.set(modelVersion, modelClass);
+        return this;
+    }
+}
+exports.ModelRegistry = ModelRegistry;

package/dist/core/aggregate/aggregate-base/aggregate-event-publisher.interface.d.ts

@@ -0,0 +1,4 @@
+import { AnyEvent } from "../../message";
+export interface IAggregateEventPublisher {
+    publish(events: AnyEvent | AnyEvent[]): void;
+}

package/dist/core/aggregate/aggregate-base/aggregate-event-publisher.interface.js

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

package/dist/core/aggregate/aggregate-base/aggregate.builder.d.ts

@@ -0,0 +1,6 @@
+import { ModelWithIdBuilder } from "../../model-with-id";
+import { AnyAggregate } from "./aggregate";
+export declare abstract class AggregateBuilderBase<T extends AnyAggregate> extends ModelWithIdBuilder<T> {
+    protected version: number;
+    withVersion(version: number): this;
+}

package/dist/core/aggregate/aggregate-base/aggregate.builder.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateBuilderBase = void 0;
+const model_with_id_1 = require("../../model-with-id");
+class AggregateBuilderBase extends model_with_id_1.ModelWithIdBuilder {
+    constructor() {
+        super(...arguments);
+        this.version = 0;
+    }
+    withVersion(version) {
+        this.version = version;
+        return this;
+    }
+}
+exports.AggregateBuilderBase = AggregateBuilderBase;

package/dist/core/aggregate/aggregate-base/aggregate.d.ts

@@ -0,0 +1,17 @@
+import { Props, InferredProps } from "../../../base";
+import { ModelWithId, ModelWithIdMetadata } from "../../model-with-id";
+import { AnyEvent, EventClassWithTypedConstructor, EventSource } from "../../message";
+import { IAggregateEventPublisher } from "./aggregate-event-publisher.interface";
+export interface AggregateMetadata extends ModelWithIdMetadata {
+    version: number;
+}
+export declare abstract class AggregateBase<P extends Props> extends ModelWithId<P> {
+    protected readonly _version: number;
+    constructor(metadata: AggregateMetadata, props?: P);
+    abstract version(): number;
+    metadata(): AggregateMetadata;
+    protected createEventSource(): EventSource;
+    protected newEvent<E extends AnyEvent>(eventClass: EventClassWithTypedConstructor<E>, props: InferredProps<E>): E;
+    abstract publishEvents(publisher: IAggregateEventPublisher): void;
+}
+export type AnyAggregate = AggregateBase<Props>;

package/dist/core/aggregate/aggregate-base/aggregate.js

@@ -0,0 +1,46 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateBase = void 0;
+const base_1 = require("../../../base");
+const model_with_id_1 = require("../../model-with-id");
+let AggregateBase = class AggregateBase extends model_with_id_1.ModelWithId {
+    constructor(metadata, props) {
+        super(metadata);
+        if (props)
+            this.initializeProps(props);
+        this._version = metadata.version;
+    }
+    metadata() {
+        return {
+            ...super.metadata(),
+            version: this.version(),
+        };
+    }
+    createEventSource() {
+        return {
+            aggregateId: this.id(),
+            aggregateVersion: this.version(),
+        };
+    }
+    newEvent(eventClass, props) {
+        return eventClass
+            .builder()
+            .withSource(this.createEventSource())
+            .withProps(props)
+            .build();
+    }
+};
+exports.AggregateBase = AggregateBase;
+exports.AggregateBase = AggregateBase = __decorate([
+    (0, base_1.Mutable)(true),
+    __metadata("design:paramtypes", [Object, Object])
+], AggregateBase);

package/dist/core/aggregate/aggregate-base/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./aggregate";
+export * from "./aggregate.builder";
+export * from "./aggregate-event-publisher.interface";

package/dist/core/aggregate/aggregate-base/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./aggregate"), exports);
+__exportStar(require("./aggregate.builder"), exports);
+__exportStar(require("./aggregate-event-publisher.interface"), exports);

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

@@ -0,0 +1,9 @@
+import { AnyEventSourcedAggregate } from ".";
+import { CommandHandlerMap, EventApplierMap } from "../../../meta";
+import { ModelDescriptor } from "../../../base";
+export interface EventSourcedAggregateModelDescriptor<T extends AnyEventSourcedAggregate> extends ModelDescriptor<T> {
+    ownEventApplierMap: EventApplierMap;
+    eventApplierMap: EventApplierMap;
+    ownCommandHandlerMap: CommandHandlerMap;
+    commandHandlerMap: CommandHandlerMap;
+}

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

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

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

@@ -0,0 +1,13 @@
+import { AnyEvent } from "../../message";
+import { AggregateBuilderBase } from "../aggregate-base";
+import { AnyEventSourcedAggregate, EventSourcedAggregateClassWithTypedConstructor } from "./event-sourced-aggregate";
+import { Snapshot } from "./snapshot";
+export declare class EventSourcedAggregateBuilder<T extends AnyEventSourcedAggregate> extends AggregateBuilderBase<T> {
+    private aggregateClass;
+    private pastEvents?;
+    private snapshot?;
+    constructor(aggregateClass: EventSourcedAggregateClassWithTypedConstructor<T>);
+    withPastEvents(pastEvents: AnyEvent[]): this;
+    withSnapshot(snapshot: Snapshot<T>): this;
+    build(): T;
+}

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventSourcedAggregateBuilder = void 0;
+const aggregate_base_1 = require("../aggregate-base");
+class EventSourcedAggregateBuilder extends aggregate_base_1.AggregateBuilderBase {
+    constructor(aggregateClass) {
+        super();
+        this.aggregateClass = aggregateClass;
+    }
+    withPastEvents(pastEvents) {
+        this.pastEvents = pastEvents;
+        return this;
+    }
+    withSnapshot(snapshot) {
+        this.snapshot = snapshot;
+        return this;
+    }
+    build() {
+        if (this.snapshot) {
+            const { id, version } = this.snapshot.metadata;
+            const { props } = this.snapshot;
+            this.withId(id).withVersion(version).withProps(props);
+        }
+        const instance = new this.aggregateClass({
+            id: this.id,
+            version: this.version,
+        }, this.props);
+        if (this.pastEvents)
+            instance.applyPastEvents(this.pastEvents);
+        return instance;
+    }
+}
+exports.EventSourcedAggregateBuilder = EventSourcedAggregateBuilder;

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

@@ -0,0 +1,49 @@
+import { Class } from "type-fest";
+import { Props, InferredProps } from "../../../base";
+import { ClassStatic } from "../../../types";
+import { AnyCommand, AnyEvent, EventClassWithTypedConstructor } from "../../message";
+import { AggregateBase, AggregateMetadata } from "../aggregate-base";
+import { IAggregateEventPublisher } from "../aggregate-base";
+import { EventSourcedAggregateModelDescriptor } from "./event-sourced-aggregate-model-descriptor";
+import { Snapshot, SnapshotMetadata } from "./snapshot";
+import { EventSourcedAggregateBuilder } from ".";
+export interface EventSourceAggregateMetadata extends AggregateMetadata {
+}
+export declare class EventSourcedAggregateBase<P extends Props> extends AggregateBase<P> {
+    static builder<T extends AnyEventSourcedAggregate>(this: EventSourcedAggregateClass<T>): EventSourcedAggregateBuilder<T>;
+    private _handledCommands;
+    private _pastEvents;
+    private _events;
+    constructor(metadata: EventSourceAggregateMetadata, props?: P);
+    static ownEventApplierMap<T extends AnyEventSourcedAggregate>(this: EventSourcedAggregateClass<T>): import("../../../meta").EventApplierMap;
+    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;
+    modelDescriptor(): EventSourcedAggregateModelDescriptor<typeof this>;
+    version(): number;
+    pastEvents(): AnyEvent[];
+    events(): AnyEvent[];
+    handledCommands(): AnyCommand[];
+    hasNewEvent(): boolean;
+    getEventApplier<E extends AnyEvent>(event: E): EventApplier<E>;
+    private validateEventBeforeApply;
+    private _applyEvent;
+    private applyPastEvent;
+    applyPastEvents(pastEvents: AnyEvent[]): void;
+    applyEvent<E extends AnyEvent>(event: E): void;
+    applyEvents(events: AnyEvent[]): void;
+    applyNewEvent<E extends AnyEvent>(eventClass: EventClassWithTypedConstructor<E>, props: InferredProps<E>): void;
+    getCommandHandler<C extends AnyCommand>(command: C): CommandHandler<C, AnyEvent | AnyEvent[]>;
+    handleCommand<C extends AnyCommand>(command: C): AnyEvent[];
+    snapMetadata(): SnapshotMetadata;
+    snap(): Snapshot<this>;
+    protected archiveEvents(): void;
+    publishEvents(publisher: IAggregateEventPublisher): void;
+}
+export type AnyEventSourcedAggregate = EventSourcedAggregateBase<Props>;
+export interface EventSourcedAggregateClass<T extends AnyEventSourcedAggregate = AnyEventSourcedAggregate, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof EventSourcedAggregateBase<InferredProps<T>>> {
+}
+export interface EventSourcedAggregateClassWithTypedConstructor<T extends AnyEventSourcedAggregate = AnyEventSourcedAggregate> extends EventSourcedAggregateClass<T, ConstructorParameters<typeof EventSourcedAggregateBase<InferredProps<T>>>> {
+}
+export type EventApplier<T extends AnyEvent = AnyEvent> = (event: T) => void;
+export type CommandHandler<T extends AnyCommand = AnyCommand, U extends AnyEvent | AnyEvent[] = AnyEvent | AnyEvent[]> = (command: T) => U;