@ddd-tool/domain-designer-cli 0.3.0 → 0.3.2

package/packages/core/dist/info.d.ts

@@ -0,0 +1,2 @@
+import type { DomainDesignInfoProvider } from './types'
+export declare function createInfoProvider(designId: string): DomainDesignInfoProvider

package/packages/core/dist/note.d.ts

@@ -0,0 +1,2 @@
+import { DomainDesignNoteProvider } from './types'
+export declare function createNoteProvider(_designCode: string): DomainDesignNoteProvider

package/packages/core/dist/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@ddd-tool/domain-designer-core",
+  "private": false,
+  "version": "0.3.2",
+  "type": "module",
+  "main": "./index.js",
+  "module": "index.js",
+  "license": "Apache-2.0",
+  "author": {
+    "name": "AlphaFoxz",
+    "url": "https://github.com/AlphaFoxz"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ddd-tool/domain-designer-core-ts.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ddd-tool/domain-designer-core-ts/issues"
+  },
+  "homepage": "https://github.com/ddd-tool/domain-designer-core-ts#readme"
+}

package/packages/core/dist/policy.d.ts

@@ -0,0 +1,2 @@
+import { DomainDesignPolicyProvider } from './types'
+export declare function createPolicyProvider(designId: string): DomainDesignPolicyProvider

package/packages/core/dist/read-model.d.ts

@@ -0,0 +1,2 @@
+import { DomainDesignReadModelProvider } from './types'
+export declare function createReadModelProvider(designId: string): DomainDesignReadModelProvider

package/packages/core/dist/service.d.ts

@@ -0,0 +1,2 @@
+import { DomainDesignServiceProvider } from './types'
+export declare function createServiceProvider(designId: string): DomainDesignServiceProvider

package/packages/core/dist/system.d.ts

@@ -0,0 +1,2 @@
+import { DomainDesignSystemProvider } from './types'
+export declare function createSystemProvider(designId: string): DomainDesignSystemProvider

package/packages/core/dist/types.d.ts

@@ -0,0 +1,558 @@
+export declare class DomainObjectSet<T extends DomainDesignObject> implements Iterable<T> {
+  private record
+  add(item: T): void
+  has(item: T): boolean
+  getById(__id: string): T
+  delete(item: T): boolean
+  [Symbol.iterator](): Iterator<T>
+}
+export declare const DomainDesignRule: Readonly<{
+  Note: 'Note'
+  Info: 'Info'
+  Actor: 'Actor'
+  Command: 'Command'
+  FacadeCommand: 'FacadeCommand'
+  Event: 'Event'
+  Agg: 'Agg'
+  System: 'System'
+  Policy: 'Policy'
+  Service: 'Service'
+  ReadModel: 'ReadModel'
+}>
+export type DomainDesignRule = Enum<typeof DomainDesignRule>
+export interface DomainDesignObject {
+  readonly _attributes: {
+    readonly rule: DomainDesignRule
+    readonly __id: string
+    readonly name: string
+    readonly note?: DomainDesignNote
+  }
+}
+export type DomainDesignNoteProvider = {
+  (temp: undefined): undefined
+  (temp: string): DomainDesignNote
+  (temp: DomainDesignNote): DomainDesignNote
+  (temp: TemplateStringsArray, ...values: DomainDesignNoteInject[]): DomainDesignNote
+}
+export type DomainDesignNote = Readonly<{
+  readonly _attributes: {
+    rule: Extract<DomainDesignRule, 'Note'>
+    readonly template: TemplateStringsArray
+    readonly inject: DomainDesignNoteInject[]
+  }
+}>
+export type DomainDesignNoteInject =
+  | DomainDesignInfo<any, any>
+  | DomainDesignCommand<any>
+  | DomainDesignFacadeCommand<any>
+  | DomainDesignEvent<any>
+  | DomainDesignAgg<any>
+  | DomainDesignActor
+  | DomainDesignSystem
+  | DomainDesignPolicy
+  | DomainDesignService
+export type DomainDesignInfoProvider = () => {
+  document<NAME extends string>(
+    name: NAME,
+    note?: string | DomainDesignNote,
+  ): DomainDesignInfo<'Document', NAME>
+  func<NAME extends string>(
+    name: NAME,
+    note?: string | DomainDesignNote,
+  ): DomainDesignInfo<'Function', NAME>
+  func<NAME extends string>(
+    name: NAME,
+    dependsOn: NonEmptyArray<
+      DomainDesignInfoFuncDependsOn | string | [string, string | DomainDesignNote]
+    >,
+    note?: string | DomainDesignNote,
+  ): DomainDesignInfo<'Function', NAME>
+  id<NAME extends string>(
+    name: NAME,
+    note?: string | DomainDesignNote,
+  ): DomainDesignInfo<'Id', NAME>
+  valueObj<NAME extends string>(
+    name: NAME,
+    note?: string | DomainDesignNote,
+  ): DomainDesignInfo<'ValueObject', NAME>
+  version<NAME extends string>(
+    name: NAME,
+    note?: string | DomainDesignNote,
+  ): DomainDesignInfo<'Version', NAME>
+}
+export type DomainDesignInfoType = 'Document' | 'Function' | 'Id' | 'ValueObject' | 'Version'
+export type DomainDesignInfoSimplify<NAME extends string> = NAME | [NAME, string | DomainDesignNote]
+export type DomainDesignInfoSubtype<TYPE extends DomainDesignInfoType> = TYPE extends
+  | 'Document'
+  | 'Id'
+  | 'Version'
+  | 'ValueObject'
+  ? 'None'
+  : TYPE extends 'Function'
+    ? DomainDesignInfoFuncDependsOn[]
+    : never
+export interface DomainDesignInfo<
+  TYPE extends DomainDesignInfoType,
+  NAME extends string,
+> extends DomainDesignObject {
+  readonly _attributes: {
+    readonly __id: string
+    readonly rule: Extract<DomainDesignRule, 'Info'>
+    readonly type: TYPE
+    readonly subtype: DomainDesignInfoSubtype<TYPE>
+    readonly name: NAME
+    readonly note?: DomainDesignNote
+  }
+  toFormat(): string
+}
+export type DomainDesignInfoFuncDependsOn = DomainDesignInfo<
+  Exclude<DomainDesignInfoType, 'Function'>,
+  string
+>
+export type DomainDesignInfoRecord = NonEmptyObject<
+  Record<string, DomainDesignInfo<DomainDesignInfoType, string>>
+>
+export type CustomInfo<G_NAME extends string> =
+  | DomainDesignInfo<DomainDesignInfoType, G_NAME>
+  | G_NAME
+  | [G_NAME, string | DomainDesignNote]
+export type CustomInfoArrayToInfoObject<
+  ARR extends Array<DomainDesignInfo<any, any> | string | [string, string | DomainDesignNote]>,
+> = {
+  [K in ARR[number] as K extends DomainDesignInfo<any, infer U>
+    ? U
+    : K extends string
+      ? K
+      : K extends [infer U, any]
+        ? U
+        : never]: K extends DomainDesignInfo<any, any>
+    ? K
+    : K extends string
+      ? DomainDesignInfo<'ValueObject', K>
+      : K extends [infer U extends string, any]
+        ? DomainDesignInfo<'ValueObject', U>
+        : never
+}
+export type DomainDesignActorProvider = {
+  (name: string, note?: string | DomainDesignNote): DomainDesignActor
+}
+export interface DomainDesignActor extends DomainDesignObject {
+  readonly _attributes: {
+    readonly __id: string
+    readonly rule: Extract<DomainDesignRule, 'Actor'>
+    readonly name: string
+    readonly note?: DomainDesignNote
+  }
+  command<COMMAND extends DomainDesignCommand<any>>(command: COMMAND): COMMAND
+  command<G_NAME extends string, ARR extends NonEmptyArray<CustomInfo<G_NAME>>>(
+    name: string,
+    infos: ARR,
+    note?: string | DomainDesignNote,
+  ): DomainDesignCommand<CustomInfoArrayToInfoObject<ARR>>
+  facadeCmd<FACADECMD extends DomainDesignFacadeCommand<any>>(command: FACADECMD): FACADECMD
+  facadeCmd<G_NAME extends string, ARR extends NonEmptyArray<CustomInfo<G_NAME>>>(
+    name: string,
+    infos: ARR,
+    note?: string | DomainDesignNote,
+  ): DomainDesignFacadeCommand<CustomInfoArrayToInfoObject<ARR>>
+  readModel<READ_MODEL extends DomainDesignReadModel<any>>(readModel: READ_MODEL): READ_MODEL
+  readModel<G_NAME extends string, ARR extends NonEmptyArray<CustomInfo<G_NAME>>>(
+    name: string,
+    infos: ARR | NonEmptyInitFunc<() => ARR>,
+  ): DomainDesignReadModel<CustomInfoArrayToInfoObject<ARR>>
+  toFormat(): string
+}
+export type DomainDesignCommandProvider = {
+  <G_NAME extends string, ARR extends NonEmptyArray<CustomInfo<G_NAME>>>(
+    name: string,
+    infos: ARR | NonEmptyInitFunc<() => ARR>,
+    note?: string | DomainDesignNote,
+  ): DomainDesignCommand<CustomInfoArrayToInfoObject<ARR>>
+}
+export interface DomainDesignCommand<
+  INFOS extends DomainDesignInfoRecord,
+> extends DomainDesignObject {
+  readonly _attributes: {
+    readonly __id: string
+    readonly rule: Extract<DomainDesignRule, 'Command'>
+    readonly name: string
+    readonly infos: INFOS
+    readonly note?: DomainDesignNote
+  }
+  readonly inner: INFOS
+  agg<AGG extends DomainDesignAgg<any>>(agg: AGG): AGG
+  agg<G_NAME extends string, ARR extends NonEmptyArray<CustomInfo<G_NAME>>>(
+    name: string,
+    agg: ARR,
+    note?: string | DomainDesignNote,
+  ): DomainDesignAgg<CustomInfoArrayToInfoObject<ARR>>
+  toFormat(): string
+}
+export type DomainDesignFacadeCommandProvider = {
+  <G_NAME extends string, ARR extends NonEmptyArray<CustomInfo<G_NAME>>>(
+    name: string,
+    infos: ARR | NonEmptyInitFunc<() => ARR>,
+    note?: string | DomainDesignNote,
+  ): DomainDesignFacadeCommand<CustomInfoArrayToInfoObject<ARR>>
+}
+export interface DomainDesignFacadeCommand<
+  INFOS extends DomainDesignInfoRecord,
+> extends DomainDesignObject {
+  readonly _attributes: {
+    readonly __id: string
+    readonly rule: Extract<DomainDesignRule, 'FacadeCommand'>
+    readonly name: string
+    readonly infos: INFOS
+    readonly note?: DomainDesignNote
+  }
+  readonly inner: INFOS
+  agg<AGG extends DomainDesignAgg<any>>(agg: AGG): AGG
+  agg<G_NAME extends string, ARR extends NonEmptyArray<CustomInfo<G_NAME>>>(
+    name: string,
+    agg: ARR,
+    note?: string | DomainDesignNote,
+  ): DomainDesignAgg<CustomInfoArrayToInfoObject<ARR>>
+  service(service: DomainDesignService): DomainDesignService
+  service(name: string, note?: string | DomainDesignNote): DomainDesignService
+  toFormat(): string
+}
+export type DomainDesignEventProvider = {
+  <G_NAME extends string, ARR extends NonEmptyArray<CustomInfo<G_NAME>>>(
+    name: string,
+    infos: ARR | NonEmptyInitFunc<() => ARR>,
+    note?: string | DomainDesignNote,
+  ): DomainDesignEvent<CustomInfoArrayToInfoObject<ARR>>
+}
+export interface DomainDesignEvent<
+  INFOS extends DomainDesignInfoRecord,
+> extends DomainDesignObject {
+  readonly _attributes: {
+    readonly __id: string
+    readonly rule: Extract<DomainDesignRule, 'Event'>
+    readonly name: string
+    readonly infos: INFOS
+    readonly note?: DomainDesignNote
+  }
+  readonly inner: INFOS
+  policy(policy: DomainDesignPolicy): DomainDesignPolicy
+  policy(name: string, note?: string | DomainDesignNote): DomainDesignPolicy
+  system(system: DomainDesignSystem): DomainDesignSystem
+  system(name: string, note?: string | DomainDesignNote): DomainDesignSystem
+  readModel<READ_MODEL extends DomainDesignReadModel<any>>(readModel: READ_MODEL): READ_MODEL
+  readModel<G_NAME extends string, ARR extends NonEmptyArray<CustomInfo<G_NAME>>>(
+    name: string,
+    infos: ARR | NonEmptyInitFunc<() => ARR>,
+  ): DomainDesignReadModel<CustomInfoArrayToInfoObject<ARR>>
+  toFormat(): string
+}
+export type DomainDesignAggProvider = {
+  <G_NAME extends string, ARR extends NonEmptyArray<CustomInfo<G_NAME>>>(
+    name: string,
+    infos: ARR | NonEmptyInitFunc<() => ARR>,
+    note?: string | DomainDesignNote,
+  ): DomainDesignAgg<CustomInfoArrayToInfoObject<ARR>>
+}
+export interface DomainDesignAgg<INFOS extends DomainDesignInfoRecord> extends DomainDesignObject {
+  readonly _attributes: {
+    readonly __id: string
+    readonly rule: Extract<DomainDesignRule, 'Agg'>
+    readonly name: string
+    readonly infos: INFOS
+    readonly note?: DomainDesignNote
+  }
+  readonly inner: INFOS
+  event<EVENT extends DomainDesignEvent<any>>(event: EVENT): EVENT
+  event<G_NAME extends string, ARR extends NonEmptyArray<CustomInfo<G_NAME>>>(
+    name: string,
+    infos: ARR,
+    note?: string | DomainDesignNote,
+  ): DomainDesignEvent<CustomInfoArrayToInfoObject<ARR>>
+  toFormat(): string
+}
+export type DomainDesignPolicyProvider = {
+  (name: string, note?: string | DomainDesignNote): DomainDesignPolicy
+}
+export interface DomainDesignPolicy extends DomainDesignObject {
+  readonly _attributes: {
+    readonly __id: string
+    readonly rule: Extract<DomainDesignRule, 'Policy'>
+    readonly name: string
+    readonly note?: DomainDesignNote
+  }
+  command<COMMAND extends DomainDesignCommand<any>>(command: COMMAND): COMMAND
+  command<G_NAME extends string, ARR extends NonEmptyArray<CustomInfo<G_NAME>>>(
+    name: string,
+    infos: ARR,
+    note?: string | DomainDesignNote,
+  ): DomainDesignCommand<CustomInfoArrayToInfoObject<ARR>>
+  facadeCmd<FACADECMD extends DomainDesignFacadeCommand<any>>(command: FACADECMD): FACADECMD
+  facadeCmd<G_NAME extends string, ARR extends NonEmptyArray<CustomInfo<G_NAME>>>(
+    name: string,
+    infos: ARR,
+    note?: string | DomainDesignNote,
+  ): DomainDesignFacadeCommand<CustomInfoArrayToInfoObject<ARR>>
+  service(service: DomainDesignService): DomainDesignService
+  service(name: string, note?: string | DomainDesignNote): DomainDesignService
+  toFormat(): string
+}
+export type DomainDesignSystemProvider = {
+  (name: string, note?: string | DomainDesignNote): DomainDesignSystem
+}
+export interface DomainDesignSystem extends DomainDesignObject {
+  readonly _attributes: {
+    readonly __id: string
+    readonly rule: Extract<DomainDesignRule, 'System'>
+    readonly name: string
+    readonly note?: DomainDesignNote
+  }
+  command<COMMAND extends DomainDesignCommand<any>>(command: COMMAND): COMMAND
+  command<G_NAME extends string, ARR extends NonEmptyArray<CustomInfo<G_NAME>>>(
+    name: string,
+    infos: ARR,
+    note?: string | DomainDesignNote,
+  ): DomainDesignCommand<CustomInfoArrayToInfoObject<ARR>>
+  facadeCmd<FACADECMD extends DomainDesignFacadeCommand<any>>(facadeCmd: FACADECMD): FACADECMD
+  facadeCmd<G_NAME extends string, ARR extends NonEmptyArray<CustomInfo<G_NAME>>>(
+    name: string,
+    infos: ARR,
+    note?: string | DomainDesignNote,
+  ): DomainDesignFacadeCommand<CustomInfoArrayToInfoObject<ARR>>
+  event<EVENT extends DomainDesignEvent<any>>(event: EVENT): EVENT
+  event<G_NAME extends string, ARR extends NonEmptyArray<CustomInfo<G_NAME>>>(
+    name: string,
+    infos: ARR,
+    note?: string | DomainDesignNote,
+  ): DomainDesignEvent<CustomInfoArrayToInfoObject<ARR>>
+  toFormat(): string
+}
+export type DomainDesignServiceProvider = (
+  name: string,
+  note?: string | DomainDesignNote,
+) => DomainDesignService
+export interface DomainDesignService extends DomainDesignObject {
+  readonly _attributes: {
+    readonly __id: string
+    readonly rule: Extract<DomainDesignRule, 'Service'>
+    readonly name: string
+    readonly note?: DomainDesignNote
+  }
+  command<COMMAND extends DomainDesignCommand<any>>(command: COMMAND): COMMAND
+  command<G_NAME extends string, ARR extends NonEmptyArray<CustomInfo<G_NAME>>>(
+    name: string,
+    infos: ARR,
+    note?: string | DomainDesignNote,
+  ): DomainDesignCommand<CustomInfoArrayToInfoObject<ARR>>
+  facadeCmd<FACADECMD extends DomainDesignFacadeCommand<any>>(facadeCmd: FACADECMD): FACADECMD
+  facadeCmd<G_NAME extends string, ARR extends NonEmptyArray<CustomInfo<G_NAME>>>(
+    name: string,
+    infos: ARR,
+    note?: string | DomainDesignNote,
+  ): DomainDesignFacadeCommand<CustomInfoArrayToInfoObject<ARR>>
+  agg<AGG extends DomainDesignAgg<any>>(agg: AGG): AGG
+  agg<G_NAME extends string, ARR extends NonEmptyArray<CustomInfo<G_NAME>>>(
+    name: string,
+    agg: ARR,
+    note?: string | DomainDesignNote,
+  ): DomainDesignAgg<CustomInfoArrayToInfoObject<ARR>>
+  toFormat(): string
+}
+export type DomainDesignReadModelProvider = {
+  <G_NAME extends string, ARR extends NonEmptyArray<CustomInfo<G_NAME>>>(
+    name: string,
+    infos: ARR | NonEmptyInitFunc<() => ARR>,
+    note?: string | DomainDesignNote,
+  ): DomainDesignReadModel<CustomInfoArrayToInfoObject<ARR>>
+}
+export interface DomainDesignReadModel<
+  INFOS extends DomainDesignInfoRecord,
+> extends DomainDesignObject {
+  readonly _attributes: {
+    readonly __id: string
+    readonly rule: Extract<DomainDesignRule, 'ReadModel'>
+    readonly name: string
+    readonly infos: INFOS
+    readonly note?: DomainDesignNote
+  }
+  readonly inner: INFOS
+  toFormat(): string
+}
+export type DomainDesignOptions = {
+  moduleName?: string
+  ignoreValueObjects?: string[]
+  __toFormatType?: 'BngleBrackets' | 'JSON' | 'JSONPretty'
+}
+export type NonEmptyArray<T> = [T, ...T[]]
+export type NonEmptyObject<T extends object> = keyof T extends never ? never : T
+export type NonEmptyInitFunc<T extends () => object> = keyof ReturnType<T> extends never ? never : T
+export declare function isDomainDesignInfo(param: any): param is DomainDesignInfo<any, any>
+export declare function isDomainDesignInfoFunc<NAME extends string>(
+  info: DomainDesignInfo<DomainDesignInfoType, NAME>,
+): info is DomainDesignInfo<'Function', NAME>
+export declare function isDomainDesignActor(param: any): param is DomainDesignActor
+export declare function isDomainDesignAgg(param: any): param is DomainDesignAgg<any>
+export declare function isDomainDesignCommand(param: any): param is DomainDesignCommand<any>
+export declare function isDomainDesignFacadeCommand(
+  param: any,
+): param is DomainDesignFacadeCommand<any>
+export declare function isDomainDesignEvent(param: any): param is DomainDesignEvent<any>
+export declare function isDomainDesignPolicy(param: any): param is DomainDesignPolicy
+export declare function isDomainDesignReadModel(param: any): param is DomainDesignReadModel<any>
+export declare function isDomainDesignService(param: any): param is DomainDesignService
+export declare function isDomainDesignSystem(param: any): param is DomainDesignSystem
+export declare function isAnyDomainDesignObject(param: any): param is DomainDesignObject
+export declare function isDomainDesigner(param: any): param is DomainDesigner
+export type DomainDesigner = {
+  startWorkflow: (name: string) => string
+  defineUserStory: (name: string, workflowNames: NonEmptyArray<string>) => void
+  note: DomainDesignNoteProvider
+  info: {
+    document<NAME extends string>(
+      name: NAME,
+      note?: string | DomainDesignNote,
+    ): DomainDesignInfo<'Document', NAME>
+    func<NAME extends string>(
+      name: NAME,
+      note?: string | DomainDesignNote,
+    ): DomainDesignInfo<'Function', NAME>
+    func<NAME extends string>(
+      name: NAME,
+      dependsOn: NonEmptyArray<
+        DomainDesignInfoFuncDependsOn | string | [string, string | DomainDesignNote]
+      >,
+      note?: string | DomainDesignNote,
+    ): DomainDesignInfo<'Function', NAME>
+    id<NAME extends string>(
+      name: NAME,
+      note?: string | DomainDesignNote,
+    ): DomainDesignInfo<'Id', NAME>
+    valueObj<NAME extends string>(
+      name: NAME,
+      note?: string | DomainDesignNote,
+    ): DomainDesignInfo<'ValueObject', NAME>
+    version<NAME extends string>(
+      name: NAME,
+      note?: string | DomainDesignNote,
+    ): DomainDesignInfo<'Version', NAME>
+  }
+  actor: DomainDesignActorProvider
+  command: DomainDesignCommandProvider
+  facadeCmd: DomainDesignFacadeCommandProvider
+  agg: DomainDesignAggProvider
+  event: DomainDesignEventProvider
+  system: DomainDesignSystemProvider
+  policy: DomainDesignPolicyProvider
+  service: DomainDesignServiceProvider
+  readModel: DomainDesignReadModelProvider
+  _getContext: () => {
+    startWorkflow(name: string): string
+    defineUserStory(name: string, workflowNames: NonEmptyArray<string>): void
+    linkTo(
+      srcRule:
+        | 'Info'
+        | 'Actor'
+        | 'Command'
+        | 'FacadeCommand'
+        | 'Agg'
+        | 'Event'
+        | 'Policy'
+        | 'Service'
+        | 'System'
+        | 'ReadModel',
+      srcId: string,
+      targetRule:
+        | 'Info'
+        | 'Actor'
+        | 'Command'
+        | 'FacadeCommand'
+        | 'Agg'
+        | 'Event'
+        | 'Policy'
+        | 'Service'
+        | 'System'
+        | 'ReadModel',
+      targetId: string,
+      linkType?: import('./common').LinkType,
+    ): void
+    getDesignerId(): string
+    getDesignerOptions(): Required<DomainDesignOptions>
+    getWorkflows(): Record<string, string[]>
+    getUserStories(): Record<string, string[]>
+    getLinks(): Record<string, import('./common').LinkType>
+    getIdMap(): Record<string, DomainDesignObject>
+    getAssociationMap(): Record<string, DomainObjectSet<DomainDesignObject>>
+    getCommands(): DomainDesignCommand<any>[]
+    getFacadeCommands(): DomainDesignFacadeCommand<any>[]
+    getActors(): DomainDesignActor[]
+    getEvents(): DomainDesignEvent<any>[]
+    getPolicies(): DomainDesignPolicy[]
+    getServices(): DomainDesignService[]
+    getSystems(): DomainDesignSystem[]
+    getAggs(): DomainDesignAgg<any>[]
+    getReadModels(): DomainDesignReadModel<any>[]
+    registerInfo(info: DomainDesignInfo<any, any>): void
+    registerCommand(command: DomainDesignCommand<any>): void
+    registerFacadeCommand(command: DomainDesignFacadeCommand<any>): void
+    registerActor(actor: DomainDesignActor): void
+    registerEvent(event: DomainDesignEvent<any>): void
+    registerPolicy(policy: DomainDesignPolicy): void
+    registerService(service: DomainDesignService): void
+    registerSystem(system: DomainDesignSystem): void
+    registerAgg(agg: DomainDesignAgg<any>): void
+    registerReadModel(readModel: DomainDesignReadModel<any>): void
+    customInfoArrToInfoObj<G_NAME extends string, ARR extends NonEmptyArray<CustomInfo<G_NAME>>>(
+      arr: ARR,
+    ): CustomInfoArrayToInfoObject<ARR>
+    customInfoArrToInfoArr<G_NAME extends string, ARR extends NonEmptyArray<CustomInfo<G_NAME>>>(
+      arr: ARR,
+    ): DomainDesignInfo<DomainDesignInfoType, string>[]
+    toFormat<
+      OBJ extends {
+        _attributes: {
+          __id: string
+          name: string
+        }
+      },
+    >(
+      obj: OBJ,
+    ): string
+    createNote: DomainDesignNoteProvider
+    info: {
+      document<NAME extends string>(
+        name: NAME,
+        note?: string | DomainDesignNote,
+      ): DomainDesignInfo<'Document', NAME>
+      func<NAME extends string>(
+        name: NAME,
+        note?: string | DomainDesignNote,
+      ): DomainDesignInfo<'Function', NAME>
+      func<NAME extends string>(
+        name: NAME,
+        dependsOn: NonEmptyArray<
+          DomainDesignInfoFuncDependsOn | string | [string, string | DomainDesignNote]
+        >,
+        note?: string | DomainDesignNote,
+      ): DomainDesignInfo<'Function', NAME>
+      id<NAME extends string>(
+        name: NAME,
+        note?: string | DomainDesignNote,
+      ): DomainDesignInfo<'Id', NAME>
+      valueObj<NAME extends string>(
+        name: NAME,
+        note?: string | DomainDesignNote,
+      ): DomainDesignInfo<'ValueObject', NAME>
+      version<NAME extends string>(
+        name: NAME,
+        note?: string | DomainDesignNote,
+      ): DomainDesignInfo<'Version', NAME>
+    }
+    createPersion: DomainDesignActorProvider
+    createCommand: DomainDesignCommandProvider
+    createFacadeCommand: DomainDesignFacadeCommandProvider
+    createAgg: DomainDesignAggProvider
+    createEvent: DomainDesignEventProvider
+    createPolicy: DomainDesignPolicyProvider
+    createService: DomainDesignServiceProvider
+    createSystem: DomainDesignSystemProvider
+    createReadModel: DomainDesignReadModelProvider
+  }
+}

package/packages/playground/node_modules/.vite/deps/_metadata.json

@@ -1,25 +1,25 @@
 {
-  "hash": "7d85a8f4",
-  "configHash": "4749372a",
-  "lockfileHash": "0b6433a6",
-  "browserHash": "148b3554",
+  "hash": "6258a39b",
+  "configHash": "4731d055",
+  "lockfileHash": "2041c8ef",
+  "browserHash": "a90cdbb1",
   "optimized": {
     "primevue/button": {
       "src": "../../../../../node_modules/primevue/button/index.mjs",
       "file": "primevue_button.js",
-      "fileHash": "17016d8b",
+      "fileHash": "a7a9f415",
       "needsInterop": false
     },
     "primevue/dock": {
       "src": "../../../../../node_modules/primevue/dock/index.mjs",
       "file": "primevue_dock.js",
-      "fileHash": "126be8d6",
+      "fileHash": "a1c740ab",
       "needsInterop": false
     },
     "vue": {
       "src": "../../../../../node_modules/vue/dist/vue.runtime.esm-bundler.js",
       "file": "vue.js",
-      "fileHash": "21498892",
+      "fileHash": "21900bd3",
       "needsInterop": false
     }
   },

package/packages/playground/package.json

@@ -1,21 +1,19 @@
-{
-  "name": "playground",
-  "version": "0.3.0",
-  "private": true,
-  "description": "",
-  "type": "module",
-  "scripts": {
-    "dev": "vite",
-    "test": "exit 0",
-    "build": "exit 0",
-    "verify": "vue-tsc -p ./tsconfig.json"
-  },
-  "devDependencies": {
-    "@ddd-tool/domain-designer-core": "workspace:^",
-    "@ddd-tool/domain-designer-ui-component": "workspace:^",
-    "@primeuix/themes": "^2.0.3",
-    "primeicons": "^7.0.0",
-    "primevue": "^4.5.4",
-    "vue": "^3.5.27"
-  }
-}
+{
+  "name": "playground",
+  "version": "0.3.2",
+  "private": true,
+  "description": "",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "test": "exit 0",
+    "build": "exit 0",
+    "verify": "vue-tsc -p ./tsconfig.json"
+  },
+  "devDependencies": {
+    "@primeuix/themes": "^2.0.3",
+    "primeicons": "^7.0.0",
+    "primevue": "^4.5.4",
+    "vue": "^3.5.27"
+  }
+}