ddd-node 5.0.1 → 6.1.0

package/dist/core/aggregate.d.ts

@@ -0,0 +1,67 @@
+import { Class } from "../types/class";
+import { ClassStatic } from "../types/class-static";
+import { AnyCommand } from "./command";
+import { Entity, EntityMetadata } from "./entity";
+import { AnyEvent, EventClass, EventClassWithTypedConstructor } from "./event";
+import { Id } from "./id";
+import { PropsOf } from "./model";
+export interface AggregateBaseMetadata extends EntityMetadata {
+    version: number;
+}
+export declare abstract class AggregateBase<Props extends object> extends Entity<Props> {
+    protected readonly _version: number;
+    constructor(metadata: AggregateBaseMetadata, props?: Props);
+    abstract version: number;
+    protected newEvent<E extends AnyEvent>(eventClass: EventClassWithTypedConstructor<E>, props: PropsOf<E>): E;
+}
+export declare class Aggregate<Props extends object> extends AggregateBase<Props> {
+    private _events;
+    constructor(metadata: AggregateBaseMetadata, props: Props);
+    static newAggregate<T extends AnyAggregate>(this: AggregateClassWithTypedConstructor<T>, props: PropsOf<T>, id?: Id): T;
+    get version(): number;
+    get events(): AnyEvent[];
+    recordEvent<E extends AnyEvent>(event: E): void;
+    recordEvent<E extends AnyEvent>(eventClass: EventClass<E>, props: PropsOf<E>): void;
+    clearEvents(): void;
+}
+export interface SnapshotMetadata extends AggregateBaseMetadata {
+}
+export interface Snapshot<T extends AnyAggregateES> {
+    metadata: SnapshotMetadata;
+    props: PropsOf<T>;
+}
+export declare class AggregateES<Props extends object> extends AggregateBase<Props> {
+    private _handledCommands;
+    private _pastEvents;
+    private _events;
+    constructor(metadata: AggregateBaseMetadata, props?: Props);
+    static newStream<T extends AnyAggregateES>(this: AggregateESClassWithTypedConstructor<T>, id?: Id): T;
+    static fromStream<T extends AnyAggregateES>(this: AggregateESClassWithTypedConstructor<T>, id: Id, events?: AnyEvent[]): T;
+    static fromSnapshot<T extends AnyAggregateES>(this: AggregateESClassWithTypedConstructor<T>, snapshot: Snapshot<T>, events?: AnyEvent[]): T;
+    static eventAppliersMap<T extends AnyAggregateES>(this: AggregateESClass<T>): Map<string, EventApplier>;
+    static commandHandlersMap<T extends AnyAggregateES>(this: AggregateESClass<T>): Map<string, CommandHandler>;
+    get version(): number;
+    get events(): AnyEvent[];
+    get handledCommands(): AnyCommand[];
+    eventAppliersMap(): Map<string, EventApplier>;
+    hasEvent(): boolean;
+    getApplierForEvent<E extends AnyEvent>(event: E): EventApplier<E>;
+    private validateEventBeforeApply;
+    private _applyEvent;
+    private applyPastEvent;
+    private applyPastEvents;
+    applyEvent<E extends AnyEvent>(event: E): void;
+    applyEvents(events: AnyEvent[]): void;
+    commandHandlersMap(): Map<string, CommandHandler>;
+    getHandlerForCommand<C extends AnyCommand>(command: C): CommandHandler<C, AnyEvent>;
+    handleCommand<C extends AnyCommand>(command: C): AnyEvent[];
+    snap(): Snapshot<this>;
+}
+export type AnyAggregate = Aggregate<any>;
+export type AggregateClass<T extends AnyAggregate = AnyAggregate, Arguments extends unknown[] = any[]> = Class<T, Arguments> & ClassStatic<typeof Aggregate<PropsOf<T>>>;
+export type AggregateClassWithTypedConstructor<T extends AnyAggregate = AnyAggregate> = AggregateClass<T, ConstructorParameters<typeof Aggregate<PropsOf<T>>>>;
+export type AnyAggregateES = AggregateES<any>;
+export type AggregateESClass<T extends AnyAggregateES = AnyAggregateES, Arguments extends unknown[] = any[]> = Class<T, Arguments> & ClassStatic<typeof AggregateES<PropsOf<T>>>;
+export type AggregateESClassWithTypedConstructor<T extends AnyAggregateES = AnyAggregateES> = AggregateESClass<T, ConstructorParameters<typeof AggregateES<PropsOf<T>>>>;
+export type EventApplier<T extends AnyEvent = AnyEvent> = (event: T) => void;
+export type CommandHandler<T extends AnyCommand = AnyCommand, U extends AnyEvent | AnyEvent[] = AnyEvent> = (command: T) => U;

package/dist/core/aggregate.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateES = exports.Aggregate = exports.AggregateBase = void 0;
+const to_array_1 = require("../utils/to-array");
+const entity_1 = require("./entity");
+const id_1 = require("./id");
+const metadata_1 = require("./metadata");
+class AggregateBase extends entity_1.Entity {
+    constructor(metadata, props) {
+        super(metadata, props);
+        this._version = metadata.version;
+    }
+    newEvent(eventClass, props) {
+        const eventSource = {
+            type: this.type,
+            id: this.id,
+            version: this.version,
+        };
+        return eventClass.newEvent(eventSource, props);
+    }
+}
+exports.AggregateBase = AggregateBase;
+class Aggregate extends AggregateBase {
+    constructor(metadata, props) {
+        super(metadata, props);
+        this._events = [];
+    }
+    static newAggregate(props, id) {
+        return new this({
+            id: id !== null && id !== void 0 ? id : id_1.Id.unique(),
+            version: 0,
+        }, props);
+    }
+    get version() {
+        return this._version;
+    }
+    get events() {
+        return this._events;
+    }
+    recordEvent(param1, param2) {
+        let event;
+        if (typeof param1 === "function" && param2) {
+            event = this.newEvent(param1, param2);
+        }
+        else {
+            event = param1;
+        }
+        this._events.push(event);
+    }
+    clearEvents() {
+        this._events = [];
+    }
+}
+exports.Aggregate = Aggregate;
+class AggregateES extends AggregateBase {
+    constructor(metadata, props) {
+        super(metadata, props);
+        this._handledCommands = [];
+        this._events = [];
+        this._pastEvents = [];
+    }
+    static newStream(id) {
+        return new this({
+            id: id !== null && id !== void 0 ? id : id_1.Id.unique(),
+            version: 0,
+        });
+    }
+    static fromStream(id, events = []) {
+        const instance = this.newStream(id);
+        instance.applyPastEvents(events);
+        return instance;
+    }
+    static fromSnapshot(snapshot, events = []) {
+        const { metadata, props } = snapshot;
+        const instance = new this(metadata, props);
+        instance.applyPastEvents(events);
+        return instance;
+    }
+    static eventAppliersMap() {
+        return (0, metadata_1.getEventAppliersMap)(this.prototype);
+    }
+    static commandHandlersMap() {
+        return (0, metadata_1.getCommandHandlersMap)(this.prototype);
+    }
+    get version() {
+        return (this._version +
+            (this.hasEvent() ? this._events.length : this._pastEvents.length));
+    }
+    get events() {
+        return this._events;
+    }
+    get handledCommands() {
+        return this._handledCommands;
+    }
+    eventAppliersMap() {
+        return this.constructor.eventAppliersMap();
+    }
+    hasEvent() {
+        return Boolean(this._events.length);
+    }
+    getApplierForEvent(event) {
+        const { type } = event;
+        const applier = this.eventAppliersMap().get(type);
+        if (!applier)
+            throw new Error("Event applier not found");
+        return applier;
+    }
+    validateEventBeforeApply(event) {
+        const { source } = event;
+        if (source.type !== this.type)
+            throw new Error("Invalid source type");
+        if (!source.id.equals(this.id))
+            throw new Error("Invalid source id");
+        if (source.version !== this.version)
+            throw new Error("Invalid source version");
+    }
+    _applyEvent(event) {
+        const applier = this.getApplierForEvent(event);
+        this.validateEventBeforeApply(event);
+        applier.call(this, event);
+    }
+    applyPastEvent(event) {
+        if (this.hasEvent())
+            throw new Error();
+        this._applyEvent(event);
+        this._pastEvents.push(event);
+    }
+    applyPastEvents(pastEvents) {
+        pastEvents.forEach((pastEvent) => {
+            this.applyPastEvent(pastEvent);
+        });
+    }
+    applyEvent(event) {
+        this._applyEvent(event);
+        this._events.push(event);
+    }
+    applyEvents(events) {
+        events.forEach((event) => {
+            this.applyEvent(event);
+        });
+    }
+    commandHandlersMap() {
+        return this.constructor.commandHandlersMap();
+    }
+    getHandlerForCommand(command) {
+        const { type } = command;
+        const handler = this.commandHandlersMap().get(type);
+        if (!handler)
+            throw new Error("Command handler not found");
+        return handler;
+    }
+    handleCommand(command) {
+        const handler = this.getHandlerForCommand(command);
+        const events = (0, to_array_1.toArray)(handler.call(this, command));
+        events.forEach((event) => {
+            var _a;
+            event.setContext({
+                correlationId: (_a = command.context) === null || _a === void 0 ? void 0 : _a.correlationId,
+                causationId: command.id.value,
+            });
+        });
+        this.applyEvents(events);
+        this._handledCommands.push(command);
+        return events;
+    }
+    snap() {
+        if (!this._props)
+            throw new Error();
+        return {
+            metadata: {
+                id: this.id,
+                version: this.version,
+            },
+            props: this.props(),
+        };
+    }
+}
+exports.AggregateES = AggregateES;

package/dist/core/command.d.ts

@@ -0,0 +1,13 @@
+import { Class } from "../types/class";
+import { ClassStatic } from "../types/class-static";
+import { Message, MessageContext, MessageMetadata } from "./message";
+import { PropsOf } from "./model";
+export interface CommandMetadata extends MessageMetadata {
+}
+export declare class Command<Props extends object> extends Message<Props> {
+    constructor(metadata: CommandMetadata, props: Props);
+    static newCommand<T extends AnyCommand>(this: CommandClassWithTypedConstructor<T>, props: PropsOf<T>, context?: MessageContext): T;
+}
+export type AnyCommand = Command<any>;
+export type CommandClass<T extends AnyCommand = AnyCommand, Arguments extends unknown[] = any[]> = Class<T, Arguments> & ClassStatic<typeof Command<PropsOf<T>>>;
+export type CommandClassWithTypedConstructor<T extends AnyCommand = AnyCommand> = CommandClass<T, ConstructorParameters<typeof Command<PropsOf<T>>>>;

package/dist/core/command.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Command = void 0;
+const id_1 = require("./id");
+const message_1 = require("./message");
+class Command extends message_1.Message {
+    constructor(metadata, props) {
+        super(metadata, props);
+    }
+    static newCommand(props, context) {
+        return new this({
+            id: id_1.Id.unique(),
+            timestamp: Date.now(),
+            context,
+        }, props);
+    }
+}
+exports.Command = Command;

package/dist/core/entity.d.ts

@@ -0,0 +1,17 @@
+import { Class } from "../types/class";
+import { ClassStatic } from "../types/class-static";
+import { Id } from "./id";
+import { Model, PropsOf } from "./model";
+export interface EntityMetadata {
+    readonly id: Id;
+}
+export declare class Entity<Props extends object> extends Model<Props> {
+    private readonly _id;
+    constructor(metadata: EntityMetadata, props?: Props);
+    static newEntity<T extends AnyEntity>(this: EntityClassWithTypedConstructor<T>, props: PropsOf<T>): T;
+    get id(): Id;
+    hasId(id: Id): boolean;
+}
+export type AnyEntity = Entity<object>;
+export type EntityClass<T extends AnyEntity = AnyEntity, Arguments extends unknown[] = any[]> = Class<T, Arguments> & ClassStatic<typeof Entity<PropsOf<T>>>;
+export type EntityClassWithTypedConstructor<T extends AnyEntity = AnyEntity> = EntityClass<T, ConstructorParameters<typeof Entity<PropsOf<T>>>>;

package/dist/core/entity.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entity = void 0;
+const id_1 = require("./id");
+const model_1 = require("./model");
+class Entity extends model_1.Model {
+    constructor(metadata, props) {
+        super(props);
+        this._id = metadata.id;
+    }
+    static newEntity(props) {
+        return new this({
+            id: id_1.Id.unique(),
+        }, props);
+    }
+    get id() {
+        return this._id;
+    }
+    hasId(id) {
+        return this.id.equals(id);
+    }
+}
+exports.Entity = Entity;

package/dist/core/event.d.ts

@@ -0,0 +1,27 @@
+import { Class } from "../types/class";
+import { ClassStatic } from "../types/class-static";
+import { Id } from "./id";
+import { Message, MessageContext, MessageMetadata } from "./message";
+import { PropsOf } from "./model";
+import { ModelTypePattern } from "./model-type";
+export type EventSource = Readonly<{
+    type: ModelTypePattern;
+    id: Id;
+    version: number;
+}>;
+export interface EventMetadata extends MessageMetadata {
+    source: EventSource;
+}
+export declare class Event<Props extends object> extends Message<Props> {
+    private readonly _source;
+    constructor(metadata: EventMetadata, props: Props);
+    static newEvent<T extends AnyEvent>(this: EventClassWithTypedConstructor<T>, source: EventSource, props: PropsOf<T>, context?: MessageContext): T;
+    get source(): Readonly<{
+        type: `${string}#${string}`;
+        id: Id;
+        version: number;
+    }>;
+}
+export type AnyEvent = Event<any>;
+export type EventClass<T extends AnyEvent = AnyEvent, Arguments extends unknown[] = any[]> = Class<T, Arguments> & ClassStatic<typeof Event<PropsOf<T>>>;
+export type EventClassWithTypedConstructor<T extends AnyEvent = AnyEvent> = EventClass<T, ConstructorParameters<typeof Event<PropsOf<T>>>>;

package/dist/core/event.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Event = void 0;
+const id_1 = require("./id");
+const message_1 = require("./message");
+class Event extends message_1.Message {
+    constructor(metadata, props) {
+        super(metadata, props);
+        this._source = metadata.source;
+    }
+    static newEvent(source, props, context) {
+        return new this({
+            id: id_1.Id.unique(),
+            timestamp: Date.now(),
+            source,
+            context,
+        }, props);
+    }
+    get source() {
+        return this._source;
+    }
+}
+exports.Event = Event;

package/dist/{base → core}/id.d.ts

@@ -1,7 +1,8 @@
 export declare class Id {
     private _value;
-    constructor(value: string);
+    private constructor();
     static unique(): Id;
+    static from(value: string): Id;
     get value(): string;
     equals(id: Id): boolean;
 }

package/dist/{base → core}/id.js

@@ -10,6 +10,12 @@ class Id {
         const value = (0, uuid_1.v4)();
         return new Id(value);
     }
+    static from(value) {
+        const isUUID4 = (0, uuid_1.validate)(value) && (0, uuid_1.version)(value) === 4;
+        if (!isUUID4)
+            throw new Error("Invalid uuid version 4 value");
+        return new Id(value);
+    }
     get value() {
         return this._value;
     }

package/dist/{base → core}/index.d.ts

@@ -1,9 +1,11 @@
 export * from "./aggregate";
-export * from "./message";
 export * from "./command";
 export * from "./entity";
 export * from "./event";
 export * from "./id";
-export * from "./props-envelope";
-export * from "./repository";
+export * from "./message";
+export * from "./metadata";
+export * from "./model";
+export * from "./model-type";
+export * from "./registry";
 export * from "./value-object";

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

@@ -15,11 +15,13 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./aggregate"), exports);
-__exportStar(require("./message"), exports);
 __exportStar(require("./command"), exports);
 __exportStar(require("./entity"), exports);
 __exportStar(require("./event"), exports);
 __exportStar(require("./id"), exports);
-__exportStar(require("./props-envelope"), exports);
-__exportStar(require("./repository"), exports);
+__exportStar(require("./message"), exports);
+__exportStar(require("./metadata"), exports);
+__exportStar(require("./model"), exports);
+__exportStar(require("./model-type"), exports);
+__exportStar(require("./registry"), exports);
 __exportStar(require("./value-object"), exports);

package/dist/core/message.d.ts

@@ -0,0 +1,21 @@
+import { Id } from "./id";
+import { Model } from "./model";
+export interface MessageContext {
+    correlationId?: string;
+    causationId?: string;
+}
+export interface MessageMetadata {
+    readonly id: Id;
+    readonly timestamp: number;
+    context?: MessageContext;
+}
+export declare class Message<Props extends object> extends Model<Props> {
+    private readonly _id;
+    private readonly _timestamp;
+    private _context?;
+    protected constructor(metadata: MessageMetadata, props: Props);
+    get id(): Id;
+    get timestamp(): number;
+    get context(): MessageContext | undefined;
+    setContext(context: Partial<MessageContext>): void;
+}

package/dist/core/message.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Message = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const model_1 = require("./model");
+class Message extends model_1.Model {
+    constructor(metadata, props) {
+        var _a;
+        super(props);
+        this._id = metadata.id;
+        this._timestamp = metadata.timestamp;
+        this._context = (_a = metadata === null || metadata === void 0 ? void 0 : metadata.context) !== null && _a !== void 0 ? _a : {};
+    }
+    get id() {
+        return this._id;
+    }
+    get timestamp() {
+        return this._timestamp;
+    }
+    get context() {
+        return this._context;
+    }
+    setContext(context) {
+        this._context = lodash_1.default.merge(this.context, context);
+    }
+}
+exports.Message = Message;

package/dist/core/metadata.d.ts

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

package/dist/core/metadata.js

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

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

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