ddd-node 17.3.0 → 20.0.0

package/dist/core/{model → model-with-id}/model-with-id.js

@@ -1,21 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModelWithId = void 0;
-const meta_1 = require("../../meta");
-const id_1 = require("../id");
-const model_1 = require("./model");
+const model_1 = require("../../model");
 class ModelWithId extends model_1.ModelBase {
     constructor(id) {
         super();
         this._id = id;
     }
-    static idService() {
-        return (0, meta_1.getIdService)(this);
-    }
-    static id(id) {
-        const idService = this.idService();
-        return new id_1.Id(id ?? idService.generateValue());
-    }
     id() {
         return this._id;
     }

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

@@ -0,0 +1,2 @@
+export * from "./value-object";
+export * from "./value-object.builder";

package/dist/core/value-object/index.js

@@ -0,0 +1,18 @@
+"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("./value-object"), exports);
+__exportStar(require("./value-object.builder"), exports);

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

@@ -0,0 +1,7 @@
+import { ModelBuilder } from "../../model";
+import { AnyValueObject, ValueObjectClassWithTypedConstructor } from "./value-object";
+export declare class ValueObjectBuilder<T extends AnyValueObject> extends ModelBuilder<T> {
+    private valueObjectClass;
+    constructor(valueObjectClass: ValueObjectClassWithTypedConstructor<T>);
+    build(): T;
+}

package/dist/core/value-object/value-object.builder.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueObjectBuilder = void 0;
+const model_1 = require("../../model");
+class ValueObjectBuilder extends model_1.ModelBuilder {
+    constructor(valueObjectClass) {
+        super();
+        this.valueObjectClass = valueObjectClass;
+    }
+    build() {
+        if (!this._props)
+            throw new Error("The props must be set before build");
+        return new this.valueObjectClass(this._props);
+    }
+}
+exports.ValueObjectBuilder = ValueObjectBuilder;

package/dist/core/{value-object.d.ts → value-object/value-object.d.ts}

@@ -1,6 +1,6 @@
 import { Class } from "type-fest";
-import { ModelBase, Props, PropsOf } from "./model";
-import { ClassStatic } from "../types";
+import { ModelBase, Props, PropsOf } from "../../model";
+import { ClassStatic } from "../../types";
 export declare class ValueObjectBase<P extends Props> extends ModelBase<P> {
     constructor(props: P);
     props(): P;

package/dist/core/value-object/value-object.js

@@ -0,0 +1,40 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueObjectBase = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const model_1 = require("../../model");
+let ValueObjectBase = class ValueObjectBase extends model_1.ModelBase {
+    constructor(props) {
+        super();
+        this.initializeProps(props);
+    }
+    props() {
+        return super.props();
+    }
+    equals(vo) {
+        const equalsType = vo instanceof this.constructor;
+        const equalsValue = JSON.stringify(vo.props()) === JSON.stringify(this.props());
+        return equalsType && equalsValue;
+    }
+    with(props) {
+        const newProps = lodash_1.default.merge(this.props(), props);
+        return new this.constructor(newProps);
+    }
+};
+exports.ValueObjectBase = ValueObjectBase;
+exports.ValueObjectBase = ValueObjectBase = __decorate([
+    (0, model_1.Mutable)(false),
+    __metadata("design:paramtypes", [Object])
+], ValueObjectBase);

package/dist/decorators/aggregate-es/handle.js

@@ -5,7 +5,7 @@ const meta_1 = require("../../meta");
 const Handle = (commandClass) => {
     return (target, propertyKey, descriptor) => {
         if (typeof descriptor.value === "function") {
-            const commandType = commandClass.commandType();
+            const { commandType } = commandClass.commandModelMetadata();
             (0, meta_1.defineCommandHandler)(target, commandType, descriptor.value);
         }
     };

package/dist/decorators/aggregate-es/when.js

@@ -5,7 +5,7 @@ const meta_1 = require("../../meta");
 const When = (eventClass) => {
     return (target, propertyKey, descriptor) => {
         if (typeof descriptor.value === "function") {
-            const eventType = eventClass.eventType();
+            const { eventType } = eventClass.eventModelMetadata();
             (0, meta_1.defineEventApplier)(target, eventType, descriptor.value);
         }
     };

package/dist/decorators/enum.d.ts

@@ -0,0 +1,2 @@
+import { EnumClass, EnumValue } from "../core";
+export declare const Enum: (value: EnumValue) => <T extends EnumClass<import("../core").EnumBase, any[]>>(target: T, key: string) => void;

package/dist/decorators/{model/enum.js → enum.js}

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Enum = void 0;
-const static_1 = require("./static");
+const model_1 = require("../model");
 const Enum = (value) => {
     return (target, key) => {
-        (0, static_1.Static)(() => new target(value))(target, key);
+        (0, model_1.Static)(() => new target(value))(target, key);
     };
 };
 exports.Enum = Enum;

package/dist/decorators/index.d.ts

@@ -1,4 +1,3 @@
 export * from "./aggregate-es";
-export * from "./id";
-export * from "./model";
 export * from "./message";
+export * from "./enum";

package/dist/decorators/index.js

@@ -15,6 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./aggregate-es"), exports);
-__exportStar(require("./id"), exports);
-__exportStar(require("./model"), exports);
 __exportStar(require("./message"), exports);
+__exportStar(require("./enum"), exports);

package/dist/decorators/message/command.js

@@ -4,7 +4,7 @@ exports.Command = void 0;
 const meta_1 = require("../../meta");
 const Command = (commandType) => {
     return (target) => {
-        (0, meta_1.setCommandType)(target, commandType);
+        (0, meta_1.defineCommandType)(target, commandType);
     };
 };
 exports.Command = Command;

package/dist/decorators/message/event.js

@@ -4,7 +4,7 @@ exports.Event = void 0;
 const meta_1 = require("../../meta");
 const Event = (eventType) => {
     return (target) => {
-        (0, meta_1.setEventType)(target, eventType);
+        (0, meta_1.defineEventType)(target, eventType);
     };
 };
 exports.Event = Event;

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+/// <reference types="src/declarations" />
+export * from "./model";
 export * from "./meta";
 export * from "./types";
 export * from "./utils";

package/dist/index.js

@@ -1,4 +1,5 @@
 "use strict";
+/// <reference path="./declarations/index.d.ts" />
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -14,6 +15,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("./model"), exports);
 __exportStar(require("./meta"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./utils"), exports);

package/dist/meta/aggregate-es/command-handler-map.d.ts

@@ -0,0 +1,8 @@
+import { AnyCommand, CommandHandler } from "../../core";
+export declare class CommandHandlerMap extends Map<string, CommandHandler> {
+}
+export declare const OwnCommandHandlerMapMetaKey: unique symbol;
+export declare const getOwnCommandHandlerMap: (target: object) => CommandHandlerMap;
+export declare const defineCommandHandler: <T extends AnyCommand>(target: object, commandType: string, handler: CommandHandler<T>) => void;
+export declare const CommandHandlerMapMetaKey: unique symbol;
+export declare const getCommandHandlerMap: (target: object) => CommandHandlerMap;

package/dist/meta/aggregate-es/command-handler-map.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCommandHandlerMap = exports.CommandHandlerMapMetaKey = exports.defineCommandHandler = exports.getOwnCommandHandlerMap = exports.OwnCommandHandlerMapMetaKey = exports.CommandHandlerMap = void 0;
+class CommandHandlerMap extends Map {
+}
+exports.CommandHandlerMap = CommandHandlerMap;
+exports.OwnCommandHandlerMapMetaKey = Symbol.for("OWN_COMMAND_HANDLER_MAP");
+const getOwnCommandHandlerMap = (target) => {
+    const ownCommandHandlerMap = () => Reflect.getOwnMetadata(exports.OwnCommandHandlerMapMetaKey, target);
+    if (!ownCommandHandlerMap())
+        Reflect.defineMetadata(exports.OwnCommandHandlerMapMetaKey, new CommandHandlerMap(), target);
+    return ownCommandHandlerMap();
+};
+exports.getOwnCommandHandlerMap = getOwnCommandHandlerMap;
+const defineCommandHandler = (target, commandType, handler) => {
+    const commandHandlersMap = (0, exports.getOwnCommandHandlerMap)(target);
+    commandHandlersMap.set(commandType, handler);
+};
+exports.defineCommandHandler = defineCommandHandler;
+exports.CommandHandlerMapMetaKey = Symbol.for("COMMAND_HANDLER_MAP");
+const getCommandHandlerMap = (target) => {
+    if (!Reflect.hasOwnMetadata(exports.CommandHandlerMapMetaKey, target)) {
+        const buildCommandHandlerMap = (target) => {
+            let _target = target;
+            const result = new CommandHandlerMap();
+            const ownCommandHandlerMaps = [];
+            do {
+                const ownCommandHandlerMap = (0, exports.getOwnCommandHandlerMap)(_target);
+                ownCommandHandlerMaps.unshift(ownCommandHandlerMap);
+                _target = Reflect.getPrototypeOf(_target);
+            } while (_target !== null);
+            ownCommandHandlerMaps.forEach((ownCommandHandlerMap) => {
+                ownCommandHandlerMap.forEach((commandHandler, methodName) => {
+                    result.set(methodName, commandHandler);
+                });
+            });
+            return result;
+        };
+        Reflect.defineMetadata(exports.CommandHandlerMapMetaKey, buildCommandHandlerMap(target), target);
+    }
+    return Reflect.getOwnMetadata(exports.CommandHandlerMapMetaKey, target);
+};
+exports.getCommandHandlerMap = getCommandHandlerMap;

package/dist/meta/aggregate-es/event-applier-map.d.ts

@@ -0,0 +1,9 @@
+import "reflect-metadata";
+import { AnyEvent, EventApplier } from "../../core";
+export declare class EventApplierMap extends Map<string, EventApplier> {
+}
+export declare const OwnEventApplierMapMetaKey: unique symbol;
+export declare const getOwnEventApplierMap: (target: object) => EventApplierMap;
+export declare const defineEventApplier: <T extends AnyEvent>(target: object, eventType: string, applier: EventApplier<T>) => void;
+export declare const EventApplierMapMetaKey: unique symbol;
+export declare const getEventApplierMap: (target: object) => EventApplierMap;

package/dist/meta/aggregate-es/event-applier-map.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEventApplierMap = exports.EventApplierMapMetaKey = exports.defineEventApplier = exports.getOwnEventApplierMap = exports.OwnEventApplierMapMetaKey = exports.EventApplierMap = void 0;
+require("reflect-metadata");
+class EventApplierMap extends Map {
+}
+exports.EventApplierMap = EventApplierMap;
+exports.OwnEventApplierMapMetaKey = Symbol.for("OWN_EVENT_APPLIER_MAP");
+const getOwnEventApplierMap = (target) => {
+    if (!Reflect.hasOwnMetadata(exports.OwnEventApplierMapMetaKey, target))
+        Reflect.defineMetadata(exports.OwnEventApplierMapMetaKey, new EventApplierMap(), target);
+    return Reflect.getMetadata(exports.OwnEventApplierMapMetaKey, target);
+};
+exports.getOwnEventApplierMap = getOwnEventApplierMap;
+const defineEventApplier = (target, eventType, applier) => {
+    const eventAppliersMap = (0, exports.getOwnEventApplierMap)(target);
+    eventAppliersMap.set(eventType, applier);
+};
+exports.defineEventApplier = defineEventApplier;
+exports.EventApplierMapMetaKey = Symbol.for("EVENT_HANDLER_MAP");
+const getEventApplierMap = (target) => {
+    if (!Reflect.hasOwnMetadata(exports.EventApplierMapMetaKey, target)) {
+        const buildEventApplierMap = (target) => {
+            let _target = target;
+            const result = new EventApplierMap();
+            const ownEventApplierMaps = [];
+            do {
+                const ownEventApplierMap = (0, exports.getOwnEventApplierMap)(_target);
+                ownEventApplierMaps.unshift(ownEventApplierMap);
+                _target = Reflect.getPrototypeOf(_target);
+            } while (_target !== null);
+            ownEventApplierMaps.forEach((ownEventApplierMap) => {
+                ownEventApplierMap.forEach((eventApplier, methodName) => {
+                    result.set(methodName, eventApplier);
+                });
+            });
+            return result;
+        };
+        Reflect.defineMetadata(exports.EventApplierMapMetaKey, buildEventApplierMap(target), target);
+    }
+    return Reflect.getOwnMetadata(exports.EventApplierMapMetaKey, target);
+};
+exports.getEventApplierMap = getEventApplierMap;

package/dist/meta/aggregate-es/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./event-applier-map";
+export * from "./command-handler-map";

package/dist/meta/aggregate-es/index.js

@@ -0,0 +1,18 @@
+"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("./event-applier-map"), exports);
+__exportStar(require("./command-handler-map"), exports);

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

@@ -1,4 +1,8 @@
 import "reflect-metadata";
 export type CommandType = string;
-export declare const setCommandType: (target: object, commandType: CommandType) => void;
-export declare const getCommandType: (target: object) => CommandType | undefined;
+export declare class CType extends String {
+    static validate(commandType: string): void;
+    constructor(commandType: CommandType);
+}
+export declare const defineCommandType: (target: object, commandType: CommandType) => void;
+export declare const getCommandType: (target: object) => CommandType;

package/dist/meta/command.metadata.js

@@ -1,13 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCommandType = exports.setCommandType = void 0;
+exports.getCommandType = exports.defineCommandType = exports.CType = void 0;
 require("reflect-metadata");
+class CType 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);
+        super(commandType);
+    }
+}
+exports.CType = CType;
 const CommandTypeMetaKey = Symbol.for("COMMAND_TYPE");
-const setCommandType = (target, commandType) => {
-    Reflect.defineMetadata(CommandTypeMetaKey, commandType, target);
+const defineCommandType = (target, commandType) => {
+    Reflect.defineMetadata(CommandTypeMetaKey, new CType(commandType), target);
 };
-exports.setCommandType = setCommandType;
+exports.defineCommandType = defineCommandType;
 const getCommandType = (target) => {
-    return Reflect.getOwnMetadata(CommandTypeMetaKey, target);
+    const commandType = Reflect.getOwnMetadata(CommandTypeMetaKey, target);
+    if (!commandType)
+        throw new Error("Command's type is not defined");
+    return commandType.valueOf();
 };
 exports.getCommandType = getCommandType;

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

@@ -1,4 +1,8 @@
 import "reflect-metadata";
 export type EventType = string;
-export declare const setEventType: (target: object, eventType: EventType) => void;
-export declare const getEventType: (target: object) => EventType | undefined;
+export declare class EType extends String {
+    static validate(eventType: string): void;
+    constructor(eventType: EventType);
+}
+export declare const defineEventType: (target: object, eventType: EventType) => void;
+export declare const getEventType: (target: object) => EventType;

package/dist/meta/event.metadata.js

@@ -1,13 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEventType = exports.setEventType = void 0;
+exports.getEventType = exports.defineEventType = exports.EType = void 0;
 require("reflect-metadata");
+class EType 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);
+        super(eventType);
+    }
+}
+exports.EType = EType;
 const EventTypeMetaKey = Symbol.for("EVENT_TYPE");
-const setEventType = (target, eventType) => {
-    Reflect.defineMetadata(EventTypeMetaKey, eventType, target);
+const defineEventType = (target, eventType) => {
+    Reflect.defineMetadata(EventTypeMetaKey, new EType(eventType), target);
 };
-exports.setEventType = setEventType;
+exports.defineEventType = defineEventType;
 const getEventType = (target) => {
-    return Reflect.getOwnMetadata(EventTypeMetaKey, target);
+    const eventType = Reflect.getOwnMetadata(EventTypeMetaKey, target);
+    if (!eventType)
+        throw new Error("Event's type is not defined");
+    return eventType.valueOf();
 };
 exports.getEventType = getEventType;

package/dist/meta/id.metadata.js

@@ -9,9 +9,8 @@ const defineIdService = (target, idService) => {
 exports.defineIdService = defineIdService;
 const getIdService = (target) => {
     const idService = () => Reflect.getMetadata(exports.IdServiceMetaKey, target);
-    if (idService())
-        return idService();
-    Reflect.defineMetadata(exports.IdServiceMetaKey, new core_1.Uuid4Service(), target);
+    if (!idService())
+        (0, exports.defineIdService)(target, new core_1.Uuid4Service());
     return idService();
 };
 exports.getIdService = getIdService;

package/dist/meta/index.d.ts

@@ -1,6 +1,4 @@
-export * from "./helpers";
-export * from "./aggregate.metadata";
+export * from "./aggregate-es";
 export * from "./id.metadata";
-export * from "./model.metadata";
 export * from "./event.metadata";
 export * from "./command.metadata";

package/dist/meta/index.js

@@ -14,9 +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("./helpers"), exports);
-__exportStar(require("./aggregate.metadata"), exports);
+__exportStar(require("./aggregate-es"), exports);
 __exportStar(require("./id.metadata"), exports);
-__exportStar(require("./model.metadata"), exports);
 __exportStar(require("./event.metadata"), exports);
 __exportStar(require("./command.metadata"), exports);

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

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

package/dist/{core/model → model/core}/index.js

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

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

@@ -0,0 +1,11 @@
+import { AnyModel, PropsOf } 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?: PropsOf<T>;
+    withProps(props: PropsOf<T>): this;
+    abstract build(): T;
+    buildSafe(): T | null;
+}

package/dist/model/core/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/model/core/model.d.ts

@@ -0,0 +1,41 @@
+import { Class } from "type-fest";
+import { ModelId, ModelName, ModelVersion, PropsMap, PropsValidator, StaticValuesMap } from "../meta";
+import { ClassStatic } from "../../types";
+export interface Props {
+    [key: PropertyKey]: any;
+}
+export type EmptyProps = {
+    [key: PropertyKey]: never;
+};
+export declare class ModelMetadata<T extends AnyModel = AnyModel> {
+    private modelClass;
+    constructor(modelClass: ModelClass<T>);
+    get modelMutable(): boolean;
+    get modelName(): ModelName;
+    get modelVersion(): ModelVersion;
+    get modelId(): ModelId;
+    get ownPropsValidator(): PropsValidator<T> | undefined;
+    get propsValidators(): PropsValidator[];
+    get ownStaticValues(): StaticValuesMap<T>;
+    get ownPropsMap(): PropsMap<T>;
+    get propsMap(): PropsMap<T>;
+}
+export declare class ModelBase<P extends Props> {
+    static readonly EMPTY_PROPS: EmptyProps;
+    protected _props: P;
+    static isModel(model: any): model is AnyModel;
+    static modelMetadata<T extends AnyModel>(this: ModelClass<T>): ModelMetadata<T>;
+    constructor();
+    protected redefineModel(): void;
+    protected redefineProp(key: keyof this, propTargetKey: keyof P): void;
+    protected modelMetadata(): ModelMetadata<typeof this>;
+    validateProps(props: P): void;
+    validate(): void;
+    propsIsEmpty(): boolean;
+    props(): P | null;
+    protected initializeProps(props: P): void;
+}
+export type AnyModel = ModelBase<Props>;
+export type PropsOf<T extends AnyModel> = T extends ModelBase<infer P extends Props> ? P : never;
+export interface ModelClass<T extends AnyModel = AnyModel> extends Class<T>, ClassStatic<typeof ModelBase<PropsOf<T>>> {
+}