ddd-node 29.2.0 → 29.4.0

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

@@ -0,0 +1,24 @@
+import { Class } from "type-fest";
+import { CommandType } from "../../../meta";
+import { Props, InferredProps } from "../../../base";
+import { ClassStatic } from "../../../types";
+import { MessageBase, MessageMetadata } from "../message-base";
+import { CommandModelDescriptor } from "./command-model-descriptor";
+import { CommandBuilder } from ".";
+export interface CommandMetadata extends MessageMetadata {
+    commandType: CommandType;
+}
+export declare class CommandBase<P extends Props> extends MessageBase<P> {
+    static builder<T extends AnyCommand>(this: CommandClass<T>): CommandBuilder<T>;
+    protected readonly _commandType: CommandType;
+    static commandType(): string;
+    constructor(metadata: Omit<CommandMetadata, "commandType">, props: P);
+    modelDescriptor(): CommandModelDescriptor<typeof this>;
+    metadata(): CommandMetadata;
+    commandType(): string;
+}
+export type AnyCommand = CommandBase<Props>;
+export interface CommandClass<T extends AnyCommand = AnyCommand, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof CommandBase<InferredProps<T>>> {
+}
+export interface CommandClassWithTypedConstructor<T extends AnyCommand = AnyCommand> extends CommandClass<T, ConstructorParameters<typeof CommandBase<InferredProps<T>>>> {
+}

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandBase = void 0;
+const meta_1 = require("../../../meta");
+const message_base_1 = require("../message-base");
+const _1 = require(".");
+class CommandBase extends message_base_1.MessageBase {
+    static builder() {
+        return new _1.CommandBuilder(this);
+    }
+    static commandType() {
+        return (0, meta_1.getCommandType)(this);
+    }
+    constructor(metadata, props) {
+        super(metadata, props);
+        this._commandType = (0, meta_1.getCommandType)(this.constructor);
+    }
+    modelDescriptor() {
+        const commandClass = this.constructor;
+        return {
+            ...super.modelDescriptor(),
+            commandType: commandClass.commandType(),
+        };
+    }
+    metadata() {
+        return {
+            ...super.metadata(),
+            commandType: this._commandType,
+        };
+    }
+    commandType() {
+        return this._commandType;
+    }
+}
+exports.CommandBase = CommandBase;

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

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

package/dist/core/message/command/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("./command-model-descriptor"), exports);
+__exportStar(require("./command"), exports);
+__exportStar(require("./command.builder"), exports);

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

@@ -0,0 +1,6 @@
+import { AnyEvent } from ".";
+import { EventType } from "../../../meta";
+import { ModelDescriptor } from "../../../base";
+export interface EventModelDescriptor<T extends AnyEvent> extends ModelDescriptor<T> {
+    eventType: EventType;
+}

package/dist/core/message/event/event-model-descriptor.js

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

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

@@ -0,0 +1,9 @@
+import { AnyEvent, EventClassWithTypedConstructor, EventSource } from "./event";
+import { MessageBuilderBase } from "../message-base";
+export declare class EventBuilder<T extends AnyEvent> extends MessageBuilderBase<T> {
+    private eventClass;
+    protected source?: EventSource;
+    constructor(eventClass: EventClassWithTypedConstructor<T>);
+    withSource(source: EventSource): this;
+    build(): T;
+}

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventBuilder = void 0;
+const message_base_1 = require("../message-base");
+class EventBuilder extends message_base_1.MessageBuilderBase {
+    constructor(eventClass) {
+        super();
+        this.eventClass = eventClass;
+    }
+    withSource(source) {
+        this.source = source;
+        return this;
+    }
+    build() {
+        if (!this.source)
+            throw new Error("The event source must be set before build");
+        if (!this.props)
+            throw new Error("The props must be set before build");
+        return new this.eventClass({
+            id: this.id,
+            timestamp: this.timestamp,
+            source: this.source,
+            causationId: this.causationId,
+            correlationIds: this.correlationIds,
+        }, this.props);
+    }
+}
+exports.EventBuilder = EventBuilder;

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

@@ -0,0 +1,35 @@
+import { Class } from "type-fest";
+import { EventType } from "../../../meta";
+import { Props, InferredProps } from "../../../base";
+import { ClassStatic } from "../../../types";
+import { Id } from "../../model-with-id";
+import { MessageBase, MessageMetadata } from "../message-base";
+import { EventModelDescriptor } from "./event-model-descriptor";
+import { EventBuilder } from ".";
+export type EventSource = Readonly<{
+    aggregateId: Id;
+    aggregateVersion: number;
+}>;
+export interface EventMetadata extends MessageMetadata {
+    eventType: EventType;
+    source: EventSource;
+}
+export declare class EventBase<P extends Props> extends MessageBase<P> {
+    static builder<T extends AnyEvent>(this: EventClass<T>): EventBuilder<T>;
+    private readonly _eventType;
+    private readonly _source;
+    constructor(metadata: Omit<EventMetadata, "eventType">, props: P);
+    static eventType(): EventType;
+    modelDescriptor(): EventModelDescriptor<typeof this>;
+    metadata(): EventMetadata;
+    eventType(): string;
+    source(): Readonly<{
+        aggregateId: string;
+        aggregateVersion: number;
+    }>;
+}
+export type AnyEvent = EventBase<Props>;
+export interface EventClass<T extends AnyEvent = AnyEvent, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof EventBase<InferredProps<T>>> {
+}
+export interface EventClassWithTypedConstructor<T extends AnyEvent = AnyEvent> extends EventClass<T, ConstructorParameters<typeof EventBase<InferredProps<T>>>> {
+}

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventBase = void 0;
+const meta_1 = require("../../../meta");
+const message_base_1 = require("../message-base");
+const _1 = require(".");
+class EventBase extends message_base_1.MessageBase {
+    static builder() {
+        return new _1.EventBuilder(this);
+    }
+    constructor(metadata, props) {
+        super(metadata, props);
+        this._eventType = (0, meta_1.getEventType)(this.constructor);
+        this._source = metadata.source;
+    }
+    static eventType() {
+        return (0, meta_1.getEventType)(this);
+    }
+    modelDescriptor() {
+        const eventClass = this.constructor;
+        return {
+            ...super.modelDescriptor(),
+            eventType: eventClass.eventType(),
+        };
+    }
+    metadata() {
+        return {
+            ...super.metadata(),
+            eventType: this._eventType,
+            source: this._source,
+        };
+    }
+    eventType() {
+        return this._eventType;
+    }
+    source() {
+        return this._source;
+    }
+}
+exports.EventBase = EventBase;

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

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

package/dist/core/message/event/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("./event"), exports);
+__exportStar(require("./event-model-descriptor"), exports);
+__exportStar(require("./event.builder"), exports);

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

@@ -0,0 +1,3 @@
+export * from "./message-base";
+export * from "./command";
+export * from "./event";

package/dist/core/message/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("./message-base"), exports);
+__exportStar(require("./command"), exports);
+__exportStar(require("./event"), exports);

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

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

package/dist/core/message/message-base/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("./message"), exports);
+__exportStar(require("./message.builder"), exports);

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

@@ -0,0 +1,16 @@
+import { ModelWithIdBuilder } from "../../model-with-id";
+import { AnyMessage, CorrelationIds, MessageClassWithTypedConstructor } from "./message";
+export declare abstract class MessageBuilderBase<T extends AnyMessage> extends ModelWithIdBuilder<T> {
+    protected timestamp: number;
+    protected causationId?: string;
+    protected correlationIds: CorrelationIds;
+    withCausationId(causationId: string): this;
+    withCorrelationIds(correlationIds: CorrelationIds): this;
+    withTimestamp(timestamp: number): this;
+    withTimestampNow(): this;
+}
+export declare class MessageBuilder<T extends AnyMessage> extends MessageBuilderBase<T> {
+    private messageClass;
+    constructor(messageClass: MessageClassWithTypedConstructor<T>);
+    build(): T;
+}

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageBuilder = exports.MessageBuilderBase = void 0;
+const model_with_id_1 = require("../../model-with-id");
+class MessageBuilderBase extends model_with_id_1.ModelWithIdBuilder {
+    constructor() {
+        super(...arguments);
+        this.timestamp = Date.now();
+        this.correlationIds = {};
+    }
+    withCausationId(causationId) {
+        this.causationId = causationId;
+        return this;
+    }
+    withCorrelationIds(correlationIds) {
+        this.correlationIds = correlationIds;
+        return this;
+    }
+    withTimestamp(timestamp) {
+        this.timestamp = timestamp;
+        return this;
+    }
+    withTimestampNow() {
+        return this.withTimestamp(Date.now());
+    }
+}
+exports.MessageBuilderBase = MessageBuilderBase;
+class MessageBuilder extends MessageBuilderBase {
+    constructor(messageClass) {
+        super();
+        this.messageClass = messageClass;
+    }
+    build() {
+        if (!this.props)
+            throw new Error("The props must be set before build");
+        return new this.messageClass({
+            id: this.id,
+            timestamp: this.timestamp,
+            correlationIds: this.correlationIds,
+            causationId: this.causationId,
+        }, this.props);
+    }
+}
+exports.MessageBuilder = MessageBuilder;

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

@@ -0,0 +1,31 @@
+import { Class } from "type-fest";
+import { Props, InferredProps } from "../../../base";
+import { ClassStatic } from "../../../types";
+import { ModelWithId, ModelWithIdMetadata } from "../../model-with-id";
+export interface CorrelationIds {
+    [type: string]: string | undefined;
+}
+export interface MessageMetadata extends ModelWithIdMetadata {
+    timestamp: number;
+    causationId?: string;
+    correlationIds: CorrelationIds;
+}
+export declare class MessageBase<P extends Props> extends ModelWithId<P> {
+    private readonly _timestamp;
+    private _causationId?;
+    private _correlationIds;
+    constructor(metadata: MessageMetadata, props: P);
+    props(): P;
+    metadata(): MessageMetadata;
+    timestamp(): number;
+    correlationIds(): CorrelationIds;
+    causationId(): string | undefined;
+    setCausationId(causationId: string): void;
+    addCorrelationId(type: string, correlationId: string): void;
+    setCorrelationIds(correlationIds: CorrelationIds): void;
+}
+export type AnyMessage = MessageBase<Props>;
+export interface MessageClass<T extends AnyMessage = AnyMessage, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof MessageBase<InferredProps<T>>> {
+}
+export interface MessageClassWithTypedConstructor<T extends AnyMessage = AnyMessage> extends MessageClass<T, ConstructorParameters<typeof MessageBase<InferredProps<T>>>> {
+}

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

@@ -0,0 +1,58 @@
+"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.MessageBase = void 0;
+const base_1 = require("../../../base");
+const model_with_id_1 = require("../../model-with-id");
+let MessageBase = class MessageBase extends model_with_id_1.ModelWithId {
+    constructor(metadata, props) {
+        super(metadata);
+        this._timestamp = metadata.timestamp;
+        this._causationId = metadata.causationId;
+        this._correlationIds = metadata.correlationIds;
+        this.initializeProps(props);
+    }
+    props() {
+        return super.props();
+    }
+    metadata() {
+        return {
+            ...super.metadata(),
+            timestamp: this._timestamp,
+            correlationIds: this._correlationIds,
+            causationId: this._causationId,
+        };
+    }
+    timestamp() {
+        return this._timestamp;
+    }
+    correlationIds() {
+        return this._correlationIds;
+    }
+    causationId() {
+        return this._causationId;
+    }
+    setCausationId(causationId) {
+        if (!this._causationId)
+            this._causationId = causationId;
+    }
+    addCorrelationId(type, correlationId) {
+        this._correlationIds[type] = correlationId;
+    }
+    setCorrelationIds(correlationIds) {
+        this._correlationIds = correlationIds;
+    }
+};
+exports.MessageBase = MessageBase;
+exports.MessageBase = MessageBase = __decorate([
+    (0, base_1.Mutable)(false),
+    __metadata("design:paramtypes", [Object, Object])
+], MessageBase);

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

@@ -0,0 +1 @@
+export type Id = string;

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

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

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

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

package/dist/core/model-with-id/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("./id"), exports);
+__exportStar(require("./model-with-id"), exports);
+__exportStar(require("./model-with-id.builder"), exports);

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

@@ -0,0 +1,9 @@
+import { ModelBuilder } from "../../base";
+import { AnyModelWithId } from "./model-with-id";
+import { Id } from "./id";
+export declare abstract class ModelWithIdBuilder<T extends AnyModelWithId> extends ModelBuilder<T> {
+    protected id: Id;
+    newId(): string;
+    withId(id: Id): this;
+    withNewId(): this;
+}

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelWithIdBuilder = void 0;
+const uuid_1 = require("uuid");
+const base_1 = require("../../base");
+class ModelWithIdBuilder extends base_1.ModelBuilder {
+    constructor() {
+        super(...arguments);
+        this.id = this.newId();
+    }
+    newId() {
+        return (0, uuid_1.v4)();
+    }
+    withId(id) {
+        this.id = id;
+        return this;
+    }
+    withNewId() {
+        return this.withId(this.newId());
+    }
+}
+exports.ModelWithIdBuilder = ModelWithIdBuilder;

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

@@ -0,0 +1,13 @@
+import { Id } from "./id";
+import { ModelBase, Props } from "../../base";
+export interface ModelWithIdMetadata {
+    id: Id;
+}
+export declare class ModelWithId<P extends Props> extends ModelBase<P> {
+    protected readonly _id: Id;
+    constructor(metadata: ModelWithIdMetadata);
+    metadata(): ModelWithIdMetadata;
+    id(): string;
+    hasId(id: Id): boolean;
+}
+export type AnyModelWithId = ModelWithId<Props>;

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelWithId = void 0;
+const base_1 = require("../../base");
+class ModelWithId extends base_1.ModelBase {
+    constructor(metadata) {
+        super();
+        this._id = metadata.id;
+    }
+    metadata() {
+        return {
+            ...super.metadata(),
+            id: this._id,
+        };
+    }
+    id() {
+        return this._id;
+    }
+    hasId(id) {
+        return this._id === id;
+    }
+}
+exports.ModelWithId = ModelWithId;

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

@@ -0,0 +1 @@
+export * from "./repository";

package/dist/core/repository/index.js

@@ -0,0 +1,17 @@
+"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("./repository"), exports);

package/dist/core/repository/repository.d.ts

@@ -0,0 +1,6 @@
+import { Id } from "../model-with-id";
+import { AnyAggregate } from "../aggregate";
+export interface IRepository<T extends AnyAggregate> {
+    id(id: Id): Promise<T | null>;
+    save(instance: T): Promise<any>;
+}

package/dist/core/repository/repository.js

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

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 "../../base";
+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 base_1 = require("../../base");
+class ValueObjectBuilder extends base_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/value-object.d.ts

@@ -0,0 +1,17 @@
+import { Class } from "type-fest";
+import { ModelBase, Props, InferredProps } from "../../base";
+import { ClassStatic } from "../../types";
+export declare class ValueObjectBase<P extends Props> extends ModelBase<P> {
+    constructor(props: P);
+    props(): P;
+    equals<V extends AnyValueObject>(vo: V): boolean;
+    with(props: Partial<P>): typeof this;
+    clone(): this;
+    getEqualityValue(): string;
+    protected getEqualityObject(): any;
+}
+export type AnyValueObject = ValueObjectBase<Props>;
+export interface ValueObjectClass<T extends AnyValueObject = AnyValueObject> extends Class<T>, ClassStatic<typeof ValueObjectBase<InferredProps<T>>> {
+}
+export interface ValueObjectClassWithTypedConstructor<T extends AnyValueObject = AnyValueObject> extends Class<T, ConstructorParameters<typeof ValueObjectBase<InferredProps<T>>>> {
+}