@agilewallaby/c4-model 2.5.0 → 2.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agilewallaby/c4-model",
-  "version": "2.5.0",
+  "version": "2.7.0",
   "publishConfig": {
     "access": "public"
   },

package/src/buildModel.d.ts

@@ -1,16 +1,18 @@
 import { Model } from './model';
+import { ElementArchetype, RelationshipArchetype } from './archetype';
 type Catalog = Record<string, unknown>;
 type RootCatalog = Record<string, Catalog>;
 export interface AnyC4Module {
     readonly key: string;
-    registerDefinitions(model: Model): Catalog;
-    buildRelationships(local: Catalog, dependencies: RootCatalog): void;
+    registerDefinitions(model: Model, archetypes: Record<string, ElementArchetype | RelationshipArchetype>): Catalog;
+    buildRelationships(local: Catalog, dependencies: RootCatalog, archetypes: Record<string, ElementArchetype | RelationshipArchetype>): void;
 }
 export interface BuildModelOptions {
     modelName?: string;
     modules?: ReadonlyArray<AnyC4Module>;
     globPath?: string;
     searchRoot?: string;
+    archetypes?: Record<string, ElementArchetype | RelationshipArchetype>;
 }
 export declare function buildModelWithCatalog<TRoot>(options?: BuildModelOptions): Promise<{
     model: Model;

package/src/container.d.ts

@@ -3,23 +3,23 @@ import { Component, ComponentDefinition } from './component';
 import { ElementArchetype } from './archetype';
 export type ContainerDefinition = TechnologyDefinition;
 interface DefineComponent {
-    defineComponent(name: string, archetypeOrDef?: ElementArchetype | ComponentDefinition, override?: ComponentDefinition): Component;
+    component(name: string, archetypeOrDef?: ElementArchetype | ComponentDefinition, override?: ComponentDefinition): Component;
 }
-export declare class ContainerGroup extends Group implements DefineComponent {
+export declare class ContainerGroup extends Group<Component> implements DefineComponent {
     readonly name: string;
     private readonly container;
     private _components;
     constructor(name: string, container: DefineComponent);
-    defineComponent(name: string, archetypeOrDef?: ElementArchetype | ComponentDefinition, override?: ComponentDefinition): Component;
+    component(name: string, archetypeOrDef?: ElementArchetype | ComponentDefinition, override?: ComponentDefinition): Component;
     getComponents(): ReadonlyArray<Component>;
 }
-export declare class Container extends TechnicalElement implements DefineComponent {
+export declare class Container extends TechnicalElement<Component> implements DefineComponent {
     readonly name: string;
     private _components;
     private _groups;
     constructor(name: string, definition?: ContainerDefinition, archetype?: ElementArchetype, overrideDefinition?: TechnologyDefinition);
-    defineComponent(name: string, archetypeOrDef?: ElementArchetype | ComponentDefinition, override?: ComponentDefinition): Component;
-    addGroup(groupName: string): ContainerGroup;
+    component(name: string, archetypeOrDef?: ElementArchetype | ComponentDefinition, override?: ComponentDefinition): Component;
+    group(groupName: string): ContainerGroup;
     getGroups(): ReadonlyArray<ContainerGroup>;
     getComponentsNotInGroups(): ReadonlyArray<Component>;
     getChildElements(): ReadonlyArray<Element>;

package/src/core.d.ts

@@ -6,7 +6,7 @@ export interface Definition {
 export interface TechnologyDefinition extends Definition {
     technology?: string;
 }
-export declare abstract class Element {
+export declare abstract class Element<TChild extends Element = never> {
     readonly name: string;
     readonly description?: string;
     readonly tags: ReadonlyArray<string>;
@@ -17,11 +17,12 @@ export declare abstract class Element {
     get canonicalName(): string;
     uses(otherElement: Element, archetypeOrDef?: RelationshipArchetype | TechnologyDefinition, override?: TechnologyDefinition): void;
     get relationships(): ReadonlyArray<Relationship>;
+    with<TChildren extends Record<string, TChild>>(callback: (self: this) => TChildren): this & TChildren;
     abstract getChildElements(): ReadonlyArray<Element>;
     getRelationshipsInHierarchy(): ReadonlyArray<Relationship>;
     getChildElementNames(path?: string): ReadonlyArray<string>;
 }
-export declare abstract class TechnicalElement extends Element {
+export declare abstract class TechnicalElement<TChild extends Element = never> extends Element<TChild> {
     readonly technology?: string;
     constructor(name: string, defaultTags?: string[], definition?: TechnologyDefinition, archetype?: ElementArchetype, overrideDefinition?: TechnologyDefinition);
 }
@@ -35,7 +36,9 @@ export declare class Relationship {
     readonly overrideDefinition?: TechnologyDefinition;
     constructor(source: Element, destination: Element, definition?: TechnologyDefinition, archetype?: RelationshipArchetype, overrideDefinition?: TechnologyDefinition);
 }
-export declare class Group {
+export declare class Group<TChild extends Element | Group = never> {
     readonly name: string;
     constructor(name: string);
+    get canonicalName(): string;
+    with<TChildren extends Record<string, TChild>>(callback: (self: this) => TChildren): this & TChildren;
 }

package/src/index.cjs

@@ -214,6 +214,10 @@ var Element = class {
   get relationships() {
     return this._relationships;
   }
+  with(callback) {
+    const children = callback(this);
+    return Object.assign(this, children);
+  }
   getRelationshipsInHierarchy() {
     return this._relationships.concat(this.getChildElements().flatMap((element) => element.getRelationshipsInHierarchy()));
   }
@@ -252,6 +256,13 @@ var Group = class {
   constructor(name) {
     this.name = name;
   }
+  get canonicalName() {
+    return camelCase(this.name);
+  }
+  with(callback) {
+    const children = callback(this);
+    return Object.assign(this, children);
+  }
   // TODO: Implement this in some useful way?
   // public addToGroup(groupCollection: string, groupMember: T) {}
 };
@@ -275,8 +286,8 @@ var ContainerGroup = class extends Group {
     this.container = container;
   }
   _components = /* @__PURE__ */ new Map();
-  defineComponent(name, archetypeOrDef, override) {
-    const component = this.container.defineComponent(name, archetypeOrDef, override);
+  component(name, archetypeOrDef, override) {
+    const component = this.container.component(name, archetypeOrDef, override);
     this._components.set(name, component);
     return component;
   }
@@ -291,7 +302,7 @@ var Container = class extends TechnicalElement {
   }
   _components = /* @__PURE__ */ new Map();
   _groups = /* @__PURE__ */ new Map();
-  defineComponent(name, archetypeOrDef, override) {
+  component(name, archetypeOrDef, override) {
     if (this._components.has(name)) {
       throw Error(`A Component named '${name}' is defined elsewhere in this Container. A Component can be defined only once.`);
     }
@@ -307,7 +318,7 @@ var Container = class extends TechnicalElement {
     this._components.set(name, component);
     return component;
   }
-  addGroup(groupName) {
+  group(groupName) {
     let group = this._groups.get(groupName);
     if (!group) {
       group = new ContainerGroup(groupName, this);
@@ -335,8 +346,8 @@ var SoftwareSystemGroup = class extends Group {
     this.softwareSystem = softwareSystem;
   }
   _containers = /* @__PURE__ */ new Map();
-  defineContainer(name, archetypeOrDef, override) {
-    const container = this.softwareSystem.defineContainer(name, archetypeOrDef, override);
+  container(name, archetypeOrDef, override) {
+    const container = this.softwareSystem.container(name, archetypeOrDef, override);
     this._containers.set(name, container);
     return container;
   }
@@ -351,7 +362,7 @@ var SoftwareSystem = class extends Element {
   }
   _containers = /* @__PURE__ */ new Map();
   _groups = /* @__PURE__ */ new Map();
-  defineContainer(name, archetypeOrDef, override) {
+  container(name, archetypeOrDef, override) {
     if (this._containers.has(name)) {
       throw Error(`A Container named '${name}' is defined elsewhere in this SoftwareSystem. A Container can be defined only once.`);
     }
@@ -367,7 +378,7 @@ var SoftwareSystem = class extends Element {
     this._containers.set(name, container);
     return container;
   }
-  addGroup(groupName) {
+  group(groupName) {
     let group = this._groups.get(groupName);
     if (!group) {
       group = new SoftwareSystemGroup(groupName, this);
@@ -407,13 +418,13 @@ var ModelGroup = class extends Group {
   }
   softwareSystems = /* @__PURE__ */ new Map();
   people = /* @__PURE__ */ new Map();
-  defineSoftwareSystem(name, archetypeOrDef, override) {
-    const softwareSystem = this.model.defineSoftwareSystem(name, archetypeOrDef, override);
+  softwareSystem(name, archetypeOrDef, override) {
+    const softwareSystem = this.model.softwareSystem(name, archetypeOrDef, override);
     this.softwareSystems.set(name, softwareSystem);
     return softwareSystem;
   }
-  definePerson(name, archetypeOrDef, override) {
-    const person = this.model.definePerson(name, archetypeOrDef, override);
+  person(name, archetypeOrDef, override) {
+    const person = this.model.person(name, archetypeOrDef, override);
     this.people.set(name, person);
     return person;
   }
@@ -431,7 +442,7 @@ var Model = class {
   softwareSystems = /* @__PURE__ */ new Map();
   people = /* @__PURE__ */ new Map();
   groups = /* @__PURE__ */ new Map();
-  defineSoftwareSystem(name, archetypeOrDef, override) {
+  softwareSystem(name, archetypeOrDef, override) {
     if (this.softwareSystems.has(name)) {
       throw Error(`A SoftwareSystem named '${name}' is defined elsewhere in this Model. A SoftwareSystem can be defined only once.`);
     }
@@ -448,7 +459,7 @@ var Model = class {
     return system;
   }
   // TODO:Should be a Group<SoftwareSystem | Person> if that is added back in
-  addGroup(groupName) {
+  group(groupName) {
     let group = this.groups.get(groupName);
     if (!group) {
       group = new ModelGroup(groupName, this);
@@ -456,7 +467,7 @@ var Model = class {
     }
     return group;
   }
-  definePerson(name, archetypeOrDef, override) {
+  person(name, archetypeOrDef, override) {
     if (this.people.has(name)) {
       throw Error(`A Person named '${name}' is defined elsewhere in this Model. A Person can be defined only once.`);
     }
@@ -472,6 +483,7 @@ var Model = class {
     this.people.set(name, person);
     return person;
   }
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
   validate() {
   }
   getPeople() {
@@ -698,7 +710,7 @@ var StructurizrDSLWriter = class {
   }
   writeContainerGroup(group, level) {
     let containerGroupDsl = "";
-    containerGroupDsl += this.writeLine(`${group.name} = group "${group.name}" {`, level);
+    containerGroupDsl += this.writeLine(`${group.canonicalName} = group "${group.name}" {`, level);
     group.getComponents().forEach((component) => {
       containerGroupDsl += this.writeComponent(component, level + 1);
     });
@@ -722,7 +734,7 @@ var StructurizrDSLWriter = class {
   }
   writeSoftwareSystemGroup(group, level) {
     let softwareSystemGroupDsl = "";
-    softwareSystemGroupDsl += this.writeLine(`${group.name} = group "${group.name}" {`, level);
+    softwareSystemGroupDsl += this.writeLine(`${group.canonicalName} = group "${group.name}" {`, level);
     group.getContainers().forEach((container) => {
       softwareSystemGroupDsl += this.writeContainer(container, level + 1);
     });
@@ -780,7 +792,7 @@ var StructurizrDSLWriter = class {
   }
   writeModelGroup(group, level) {
     let modelGroupDsl = "";
-    modelGroupDsl += this.writeLine(`${group.name} = group "${group.name}" {`, level);
+    modelGroupDsl += this.writeLine(`${group.canonicalName} = group "${group.name}" {`, level);
     group.getPeople().forEach((person) => {
       modelGroupDsl += this.writeElement("person", person, level + 1);
     });
@@ -866,7 +878,7 @@ var import_url = require("url");
 var import_meta = {};
 var _dirname = typeof __dirname !== "undefined" ? __dirname : (0, import_path.dirname)((0, import_url.fileURLToPath)(import_meta.url));
 async function buildModelWithCatalog(options = {}) {
-  const { modelName = "model", modules: explicitModules } = options;
+  const { modelName = "model", modules: explicitModules, archetypes = {} } = options;
   const model = new Model(modelName);
   let c4Modules;
   if (explicitModules) {
@@ -886,13 +898,13 @@ async function buildModelWithCatalog(options = {}) {
   const registrations = [];
   const rootCatalog = {};
   for (const instance of c4Modules) {
-    const local = instance.registerDefinitions(model);
+    const local = instance.registerDefinitions(model, archetypes);
     rootCatalog[instance.key] = local;
     registrations.push({ instance, key: instance.key, local });
   }
   for (const { instance, key, local } of registrations) {
     const dependencies = Object.fromEntries(Object.entries(rootCatalog).filter(([k]) => k !== key));
-    instance.buildRelationships(local, dependencies);
+    instance.buildRelationships(local, dependencies, archetypes);
   }
   return { model, catalog: rootCatalog };
 }

package/src/index.d.ts

@@ -7,7 +7,7 @@ export interface Definition {
 export interface TechnologyDefinition extends Definition {
 	technology?: string;
 }
-declare abstract class Element$1 {
+declare abstract class Element$1<TChild extends Element$1 = never> {
 	readonly name: string;
 	readonly description?: string;
 	readonly tags: ReadonlyArray<string>;
@@ -18,11 +18,12 @@ declare abstract class Element$1 {
 	get canonicalName(): string;
 	uses(otherElement: Element$1, archetypeOrDef?: RelationshipArchetype | TechnologyDefinition, override?: TechnologyDefinition): void;
 	get relationships(): ReadonlyArray<Relationship>;
+	with<TChildren extends Record<string, TChild>>(callback: (self: this) => TChildren): this & TChildren;
 	abstract getChildElements(): ReadonlyArray<Element$1>;
 	getRelationshipsInHierarchy(): ReadonlyArray<Relationship>;
 	getChildElementNames(path?: string): ReadonlyArray<string>;
 }
-declare abstract class TechnicalElement extends Element$1 {
+declare abstract class TechnicalElement<TChild extends Element$1 = never> extends Element$1<TChild> {
 	readonly technology?: string;
 	constructor(name: string, defaultTags?: string[], definition?: TechnologyDefinition, archetype?: ElementArchetype, overrideDefinition?: TechnologyDefinition);
 }
@@ -36,9 +37,11 @@ declare class Relationship {
 	readonly overrideDefinition?: TechnologyDefinition;
 	constructor(source: Element$1, destination: Element$1, definition?: TechnologyDefinition, archetype?: RelationshipArchetype, overrideDefinition?: TechnologyDefinition);
 }
-declare class Group {
+declare class Group<TChild extends Element$1 | Group = never> {
 	readonly name: string;
 	constructor(name: string);
+	get canonicalName(): string;
+	with<TChildren extends Record<string, TChild>>(callback: (self: this) => TChildren): this & TChildren;
 }
 export type ElementKind = "person" | "softwareSystem" | "container" | "component";
 export declare class ElementArchetype {
@@ -77,49 +80,49 @@ export declare class Component extends TechnicalElement {
 }
 export type ContainerDefinition = TechnologyDefinition;
 export interface DefineComponent {
-	defineComponent(name: string, archetypeOrDef?: ElementArchetype | ComponentDefinition, override?: ComponentDefinition): Component;
+	component(name: string, archetypeOrDef?: ElementArchetype | ComponentDefinition, override?: ComponentDefinition): Component;
 }
-export declare class ContainerGroup extends Group implements DefineComponent {
+export declare class ContainerGroup extends Group<Component> implements DefineComponent {
 	readonly name: string;
 	private readonly container;
 	private _components;
 	constructor(name: string, container: DefineComponent);
-	defineComponent(name: string, archetypeOrDef?: ElementArchetype | ComponentDefinition, override?: ComponentDefinition): Component;
+	component(name: string, archetypeOrDef?: ElementArchetype | ComponentDefinition, override?: ComponentDefinition): Component;
 	getComponents(): ReadonlyArray<Component>;
 }
-export declare class Container extends TechnicalElement implements DefineComponent {
+export declare class Container extends TechnicalElement<Component> implements DefineComponent {
 	readonly name: string;
 	private _components;
 	private _groups;
 	constructor(name: string, definition?: ContainerDefinition, archetype?: ElementArchetype, overrideDefinition?: TechnologyDefinition);
-	defineComponent(name: string, archetypeOrDef?: ElementArchetype | ComponentDefinition, override?: ComponentDefinition): Component;
-	addGroup(groupName: string): ContainerGroup;
+	component(name: string, archetypeOrDef?: ElementArchetype | ComponentDefinition, override?: ComponentDefinition): Component;
+	group(groupName: string): ContainerGroup;
 	getGroups(): ReadonlyArray<ContainerGroup>;
 	getComponentsNotInGroups(): ReadonlyArray<Component>;
 	getChildElements(): ReadonlyArray<Element$1>;
 }
 export type SoftwareSystemDefinition = Definition;
 export interface DefineContainer {
-	defineContainer(name: string, archetypeOrDef?: ElementArchetype | ContainerDefinition, override?: ContainerDefinition): Container;
+	container(name: string, archetypeOrDef?: ElementArchetype | ContainerDefinition, override?: ContainerDefinition): Container;
 }
 export interface SoftwareSystemReference {
 	name: string;
 }
-export declare class SoftwareSystemGroup extends Group implements DefineContainer {
+export declare class SoftwareSystemGroup extends Group<Container> implements DefineContainer {
 	readonly name: string;
 	private readonly softwareSystem;
 	private _containers;
 	constructor(name: string, softwareSystem: DefineContainer);
-	defineContainer(name: string, archetypeOrDef?: ElementArchetype | ContainerDefinition, override?: ContainerDefinition): Container;
+	container(name: string, archetypeOrDef?: ElementArchetype | ContainerDefinition, override?: ContainerDefinition): Container;
 	getContainers(): ReadonlyArray<Container>;
 }
-export declare class SoftwareSystem extends Element$1 implements DefineContainer {
+export declare class SoftwareSystem extends Element$1<Container> implements DefineContainer {
 	readonly name: string;
 	private _containers;
 	private _groups;
 	constructor(name: string, definition?: SoftwareSystemDefinition, archetype?: ElementArchetype, overrideDefinition?: TechnologyDefinition);
-	defineContainer(name: string, archetypeOrDef?: ElementArchetype | ContainerDefinition, override?: ContainerDefinition): Container;
-	addGroup(groupName: string): SoftwareSystemGroup;
+	container(name: string, archetypeOrDef?: ElementArchetype | ContainerDefinition, override?: ContainerDefinition): Container;
+	group(groupName: string): SoftwareSystemGroup;
 	getGroups(): ReadonlyArray<SoftwareSystemGroup>;
 	getChildElements(): ReadonlyArray<Element$1>;
 	getContainersNotInGroups(): ReadonlyArray<Container>;
@@ -134,31 +137,31 @@ export type CatalogKeyOf<TRoot, TModule> = {
 	[K in keyof TRoot]: TRoot[K] extends TModule ? K : never;
 }[keyof TRoot];
 export type Dependencies<TRoot, TModule> = Omit<TRoot, CatalogKeyOf<TRoot, TModule>>;
-export interface C4Module<TRoot, TLocal> {
+export interface C4Module<TRoot, TLocal, TArchetypes = Record<string, ElementArchetype | RelationshipArchetype>> {
 	readonly key: CatalogKeyOf<TRoot, TLocal>;
-	registerDefinitions(model: Model): TLocal;
-	buildRelationships(local: TLocal, dependencies: Dependencies<TRoot, TLocal>): void;
+	registerDefinitions(model: Model, archetypes: TArchetypes): TLocal;
+	buildRelationships(local: TLocal, dependencies: Dependencies<TRoot, TLocal>, archetypes: TArchetypes): void;
 }
 export interface DefineSoftwareSystem {
-	defineSoftwareSystem(name: string, archetypeOrDef?: ElementArchetype | SoftwareSystemDefinition, override?: SoftwareSystemDefinition): SoftwareSystem;
+	softwareSystem(name: string, archetypeOrDef?: ElementArchetype | SoftwareSystemDefinition, override?: SoftwareSystemDefinition): SoftwareSystem;
 }
 export interface DefinePerson {
-	definePerson(name: string, archetypeOrDef?: ElementArchetype | PersonDefinition, override?: PersonDefinition): Person;
+	person(name: string, archetypeOrDef?: ElementArchetype | PersonDefinition, override?: PersonDefinition): Person;
 }
-export declare class ModelGroup extends Group implements DefineSoftwareSystem, DefinePerson {
+export declare class ModelGroup extends Group<Person | SoftwareSystem> implements DefineSoftwareSystem, DefinePerson {
 	readonly name: string;
 	private readonly model;
 	private softwareSystems;
 	private people;
 	constructor(name: string, model: DefineSoftwareSystem & DefinePerson);
-	defineSoftwareSystem(name: string, archetypeOrDef?: ElementArchetype | SoftwareSystemDefinition, override?: SoftwareSystemDefinition): SoftwareSystem;
-	definePerson(name: string, archetypeOrDef?: ElementArchetype | PersonDefinition, override?: PersonDefinition): Person;
+	softwareSystem(name: string, archetypeOrDef?: ElementArchetype | SoftwareSystemDefinition, override?: SoftwareSystemDefinition): SoftwareSystem;
+	person(name: string, archetypeOrDef?: ElementArchetype | PersonDefinition, override?: PersonDefinition): Person;
 	getSoftwareSystems(): ReadonlyArray<SoftwareSystem>;
 	getPeople(): ReadonlyArray<Person>;
 }
 export interface ModelDefinitions {
-	defineSoftwareSystem(name: string, archetypeOrDef?: ElementArchetype | SoftwareSystemDefinition, override?: SoftwareSystemDefinition): SoftwareSystem;
-	definePerson(name: string, archetypeOrDef?: ElementArchetype | PersonDefinition, override?: PersonDefinition): Person;
+	softwareSystem(name: string, archetypeOrDef?: ElementArchetype | SoftwareSystemDefinition, override?: SoftwareSystemDefinition): SoftwareSystem;
+	person(name: string, archetypeOrDef?: ElementArchetype | PersonDefinition, override?: PersonDefinition): Person;
 }
 export declare class Model {
 	name: string;
@@ -166,9 +169,9 @@ export declare class Model {
 	private softwareSystems;
 	private people;
 	private groups;
-	defineSoftwareSystem(name: string, archetypeOrDef?: ElementArchetype | SoftwareSystemDefinition, override?: SoftwareSystemDefinition): SoftwareSystem;
-	addGroup(groupName: string): Group & ModelDefinitions;
-	definePerson(name: string, archetypeOrDef?: ElementArchetype | PersonDefinition, override?: PersonDefinition): Person;
+	softwareSystem(name: string, archetypeOrDef?: ElementArchetype | SoftwareSystemDefinition, override?: SoftwareSystemDefinition): SoftwareSystem;
+	group(groupName: string): Group & ModelDefinitions;
+	person(name: string, archetypeOrDef?: ElementArchetype | PersonDefinition, override?: PersonDefinition): Person;
 	validate(): void;
 	getPeople(): ReadonlyArray<Person>;
 	getSoftwareSystems(): ReadonlyArray<SoftwareSystem>;
@@ -235,14 +238,15 @@ export type Catalog = Record<string, unknown>;
 export type RootCatalog = Record<string, Catalog>;
 export interface AnyC4Module {
 	readonly key: string;
-	registerDefinitions(model: Model): Catalog;
-	buildRelationships(local: Catalog, dependencies: RootCatalog): void;
+	registerDefinitions(model: Model, archetypes: Record<string, ElementArchetype | RelationshipArchetype>): Catalog;
+	buildRelationships(local: Catalog, dependencies: RootCatalog, archetypes: Record<string, ElementArchetype | RelationshipArchetype>): void;
 }
 export interface BuildModelOptions {
 	modelName?: string;
 	modules?: ReadonlyArray<AnyC4Module>;
 	globPath?: string;
 	searchRoot?: string;
+	archetypes?: Record<string, ElementArchetype | RelationshipArchetype>;
 }
 export declare function buildModelWithCatalog<TRoot>(options?: BuildModelOptions): Promise<{
 	model: Model;

package/src/index.js

@@ -162,6 +162,10 @@ var Element = class {
   get relationships() {
     return this._relationships;
   }
+  with(callback) {
+    const children = callback(this);
+    return Object.assign(this, children);
+  }
   getRelationshipsInHierarchy() {
     return this._relationships.concat(this.getChildElements().flatMap((element) => element.getRelationshipsInHierarchy()));
   }
@@ -200,6 +204,13 @@ var Group = class {
   constructor(name) {
     this.name = name;
   }
+  get canonicalName() {
+    return camelCase(this.name);
+  }
+  with(callback) {
+    const children = callback(this);
+    return Object.assign(this, children);
+  }
   // TODO: Implement this in some useful way?
   // public addToGroup(groupCollection: string, groupMember: T) {}
 };
@@ -223,8 +234,8 @@ var ContainerGroup = class extends Group {
     this.container = container;
   }
   _components = /* @__PURE__ */ new Map();
-  defineComponent(name, archetypeOrDef, override) {
-    const component = this.container.defineComponent(name, archetypeOrDef, override);
+  component(name, archetypeOrDef, override) {
+    const component = this.container.component(name, archetypeOrDef, override);
     this._components.set(name, component);
     return component;
   }
@@ -239,7 +250,7 @@ var Container = class extends TechnicalElement {
   }
   _components = /* @__PURE__ */ new Map();
   _groups = /* @__PURE__ */ new Map();
-  defineComponent(name, archetypeOrDef, override) {
+  component(name, archetypeOrDef, override) {
     if (this._components.has(name)) {
       throw Error(`A Component named '${name}' is defined elsewhere in this Container. A Component can be defined only once.`);
     }
@@ -255,7 +266,7 @@ var Container = class extends TechnicalElement {
     this._components.set(name, component);
     return component;
   }
-  addGroup(groupName) {
+  group(groupName) {
     let group = this._groups.get(groupName);
     if (!group) {
       group = new ContainerGroup(groupName, this);
@@ -283,8 +294,8 @@ var SoftwareSystemGroup = class extends Group {
     this.softwareSystem = softwareSystem;
   }
   _containers = /* @__PURE__ */ new Map();
-  defineContainer(name, archetypeOrDef, override) {
-    const container = this.softwareSystem.defineContainer(name, archetypeOrDef, override);
+  container(name, archetypeOrDef, override) {
+    const container = this.softwareSystem.container(name, archetypeOrDef, override);
     this._containers.set(name, container);
     return container;
   }
@@ -299,7 +310,7 @@ var SoftwareSystem = class extends Element {
   }
   _containers = /* @__PURE__ */ new Map();
   _groups = /* @__PURE__ */ new Map();
-  defineContainer(name, archetypeOrDef, override) {
+  container(name, archetypeOrDef, override) {
     if (this._containers.has(name)) {
       throw Error(`A Container named '${name}' is defined elsewhere in this SoftwareSystem. A Container can be defined only once.`);
     }
@@ -315,7 +326,7 @@ var SoftwareSystem = class extends Element {
     this._containers.set(name, container);
     return container;
   }
-  addGroup(groupName) {
+  group(groupName) {
     let group = this._groups.get(groupName);
     if (!group) {
       group = new SoftwareSystemGroup(groupName, this);
@@ -355,13 +366,13 @@ var ModelGroup = class extends Group {
   }
   softwareSystems = /* @__PURE__ */ new Map();
   people = /* @__PURE__ */ new Map();
-  defineSoftwareSystem(name, archetypeOrDef, override) {
-    const softwareSystem = this.model.defineSoftwareSystem(name, archetypeOrDef, override);
+  softwareSystem(name, archetypeOrDef, override) {
+    const softwareSystem = this.model.softwareSystem(name, archetypeOrDef, override);
     this.softwareSystems.set(name, softwareSystem);
     return softwareSystem;
   }
-  definePerson(name, archetypeOrDef, override) {
-    const person = this.model.definePerson(name, archetypeOrDef, override);
+  person(name, archetypeOrDef, override) {
+    const person = this.model.person(name, archetypeOrDef, override);
     this.people.set(name, person);
     return person;
   }
@@ -379,7 +390,7 @@ var Model = class {
   softwareSystems = /* @__PURE__ */ new Map();
   people = /* @__PURE__ */ new Map();
   groups = /* @__PURE__ */ new Map();
-  defineSoftwareSystem(name, archetypeOrDef, override) {
+  softwareSystem(name, archetypeOrDef, override) {
     if (this.softwareSystems.has(name)) {
       throw Error(`A SoftwareSystem named '${name}' is defined elsewhere in this Model. A SoftwareSystem can be defined only once.`);
     }
@@ -396,7 +407,7 @@ var Model = class {
     return system;
   }
   // TODO:Should be a Group<SoftwareSystem | Person> if that is added back in
-  addGroup(groupName) {
+  group(groupName) {
     let group = this.groups.get(groupName);
     if (!group) {
       group = new ModelGroup(groupName, this);
@@ -404,7 +415,7 @@ var Model = class {
     }
     return group;
   }
-  definePerson(name, archetypeOrDef, override) {
+  person(name, archetypeOrDef, override) {
     if (this.people.has(name)) {
       throw Error(`A Person named '${name}' is defined elsewhere in this Model. A Person can be defined only once.`);
     }
@@ -420,6 +431,7 @@ var Model = class {
     this.people.set(name, person);
     return person;
   }
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
   validate() {
   }
   getPeople() {
@@ -646,7 +658,7 @@ var StructurizrDSLWriter = class {
   }
   writeContainerGroup(group, level) {
     let containerGroupDsl = "";
-    containerGroupDsl += this.writeLine(`${group.name} = group "${group.name}" {`, level);
+    containerGroupDsl += this.writeLine(`${group.canonicalName} = group "${group.name}" {`, level);
     group.getComponents().forEach((component) => {
       containerGroupDsl += this.writeComponent(component, level + 1);
     });
@@ -670,7 +682,7 @@ var StructurizrDSLWriter = class {
   }
   writeSoftwareSystemGroup(group, level) {
     let softwareSystemGroupDsl = "";
-    softwareSystemGroupDsl += this.writeLine(`${group.name} = group "${group.name}" {`, level);
+    softwareSystemGroupDsl += this.writeLine(`${group.canonicalName} = group "${group.name}" {`, level);
     group.getContainers().forEach((container) => {
       softwareSystemGroupDsl += this.writeContainer(container, level + 1);
     });
@@ -728,7 +740,7 @@ var StructurizrDSLWriter = class {
   }
   writeModelGroup(group, level) {
     let modelGroupDsl = "";
-    modelGroupDsl += this.writeLine(`${group.name} = group "${group.name}" {`, level);
+    modelGroupDsl += this.writeLine(`${group.canonicalName} = group "${group.name}" {`, level);
     group.getPeople().forEach((person) => {
       modelGroupDsl += this.writeElement("person", person, level + 1);
     });
@@ -813,7 +825,7 @@ import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 var _dirname = typeof __dirname !== "undefined" ? __dirname : dirname(fileURLToPath(import.meta.url));
 async function buildModelWithCatalog(options = {}) {
-  const { modelName = "model", modules: explicitModules } = options;
+  const { modelName = "model", modules: explicitModules, archetypes = {} } = options;
   const model = new Model(modelName);
   let c4Modules;
   if (explicitModules) {
@@ -833,13 +845,13 @@ async function buildModelWithCatalog(options = {}) {
   const registrations = [];
   const rootCatalog = {};
   for (const instance of c4Modules) {
-    const local = instance.registerDefinitions(model);
+    const local = instance.registerDefinitions(model, archetypes);
     rootCatalog[instance.key] = local;
     registrations.push({ instance, key: instance.key, local });
   }
   for (const { instance, key, local } of registrations) {
     const dependencies = Object.fromEntries(Object.entries(rootCatalog).filter(([k]) => k !== key));
-    instance.buildRelationships(local, dependencies);
+    instance.buildRelationships(local, dependencies, archetypes);
   }
   return { model, catalog: rootCatalog };
 }

package/src/model.d.ts

@@ -1,36 +1,36 @@
 import { Group } from './core';
 import { SoftwareSystem, SoftwareSystemDefinition } from './softwareSystem';
 import { Person, PersonDefinition } from './person';
-import { ElementArchetype } from './archetype';
+import { ElementArchetype, RelationshipArchetype } from './archetype';
 export type CatalogKeyOf<TRoot, TModule> = {
     [K in keyof TRoot]: TRoot[K] extends TModule ? K : never;
 }[keyof TRoot];
 export type Dependencies<TRoot, TModule> = Omit<TRoot, CatalogKeyOf<TRoot, TModule>>;
-export interface C4Module<TRoot, TLocal> {
+export interface C4Module<TRoot, TLocal, TArchetypes = Record<string, ElementArchetype | RelationshipArchetype>> {
     readonly key: CatalogKeyOf<TRoot, TLocal>;
-    registerDefinitions(model: Model): TLocal;
-    buildRelationships(local: TLocal, dependencies: Dependencies<TRoot, TLocal>): void;
+    registerDefinitions(model: Model, archetypes: TArchetypes): TLocal;
+    buildRelationships(local: TLocal, dependencies: Dependencies<TRoot, TLocal>, archetypes: TArchetypes): void;
 }
 interface DefineSoftwareSystem {
-    defineSoftwareSystem(name: string, archetypeOrDef?: ElementArchetype | SoftwareSystemDefinition, override?: SoftwareSystemDefinition): SoftwareSystem;
+    softwareSystem(name: string, archetypeOrDef?: ElementArchetype | SoftwareSystemDefinition, override?: SoftwareSystemDefinition): SoftwareSystem;
 }
 interface DefinePerson {
-    definePerson(name: string, archetypeOrDef?: ElementArchetype | PersonDefinition, override?: PersonDefinition): Person;
+    person(name: string, archetypeOrDef?: ElementArchetype | PersonDefinition, override?: PersonDefinition): Person;
 }
-export declare class ModelGroup extends Group implements DefineSoftwareSystem, DefinePerson {
+export declare class ModelGroup extends Group<Person | SoftwareSystem> implements DefineSoftwareSystem, DefinePerson {
     readonly name: string;
     private readonly model;
     private softwareSystems;
     private people;
     constructor(name: string, model: DefineSoftwareSystem & DefinePerson);
-    defineSoftwareSystem(name: string, archetypeOrDef?: ElementArchetype | SoftwareSystemDefinition, override?: SoftwareSystemDefinition): SoftwareSystem;
-    definePerson(name: string, archetypeOrDef?: ElementArchetype | PersonDefinition, override?: PersonDefinition): Person;
+    softwareSystem(name: string, archetypeOrDef?: ElementArchetype | SoftwareSystemDefinition, override?: SoftwareSystemDefinition): SoftwareSystem;
+    person(name: string, archetypeOrDef?: ElementArchetype | PersonDefinition, override?: PersonDefinition): Person;
     getSoftwareSystems(): ReadonlyArray<SoftwareSystem>;
     getPeople(): ReadonlyArray<Person>;
 }
 export interface ModelDefinitions {
-    defineSoftwareSystem(name: string, archetypeOrDef?: ElementArchetype | SoftwareSystemDefinition, override?: SoftwareSystemDefinition): SoftwareSystem;
-    definePerson(name: string, archetypeOrDef?: ElementArchetype | PersonDefinition, override?: PersonDefinition): Person;
+    softwareSystem(name: string, archetypeOrDef?: ElementArchetype | SoftwareSystemDefinition, override?: SoftwareSystemDefinition): SoftwareSystem;
+    person(name: string, archetypeOrDef?: ElementArchetype | PersonDefinition, override?: PersonDefinition): Person;
 }
 export declare class Model {
     name: string;
@@ -38,9 +38,9 @@ export declare class Model {
     private softwareSystems;
     private people;
     private groups;
-    defineSoftwareSystem(name: string, archetypeOrDef?: ElementArchetype | SoftwareSystemDefinition, override?: SoftwareSystemDefinition): SoftwareSystem;
-    addGroup(groupName: string): Group & ModelDefinitions;
-    definePerson(name: string, archetypeOrDef?: ElementArchetype | PersonDefinition, override?: PersonDefinition): Person;
+    softwareSystem(name: string, archetypeOrDef?: ElementArchetype | SoftwareSystemDefinition, override?: SoftwareSystemDefinition): SoftwareSystem;
+    group(groupName: string): Group & ModelDefinitions;
+    person(name: string, archetypeOrDef?: ElementArchetype | PersonDefinition, override?: PersonDefinition): Person;
     validate(): void;
     getPeople(): ReadonlyArray<Person>;
     getSoftwareSystems(): ReadonlyArray<SoftwareSystem>;

package/src/softwareSystem.d.ts

@@ -3,26 +3,26 @@ import { Container, ContainerDefinition } from './container';
 import { ElementArchetype } from './archetype';
 export type SoftwareSystemDefinition = Definition;
 interface DefineContainer {
-    defineContainer(name: string, archetypeOrDef?: ElementArchetype | ContainerDefinition, override?: ContainerDefinition): Container;
+    container(name: string, archetypeOrDef?: ElementArchetype | ContainerDefinition, override?: ContainerDefinition): Container;
 }
 export interface SoftwareSystemReference {
     name: string;
 }
-export declare class SoftwareSystemGroup extends Group implements DefineContainer {
+export declare class SoftwareSystemGroup extends Group<Container> implements DefineContainer {
     readonly name: string;
     private readonly softwareSystem;
     private _containers;
     constructor(name: string, softwareSystem: DefineContainer);
-    defineContainer(name: string, archetypeOrDef?: ElementArchetype | ContainerDefinition, override?: ContainerDefinition): Container;
+    container(name: string, archetypeOrDef?: ElementArchetype | ContainerDefinition, override?: ContainerDefinition): Container;
     getContainers(): ReadonlyArray<Container>;
 }
-export declare class SoftwareSystem extends Element implements DefineContainer {
+export declare class SoftwareSystem extends Element<Container> implements DefineContainer {
     readonly name: string;
     private _containers;
     private _groups;
     constructor(name: string, definition?: SoftwareSystemDefinition, archetype?: ElementArchetype, overrideDefinition?: TechnologyDefinition);
-    defineContainer(name: string, archetypeOrDef?: ElementArchetype | ContainerDefinition, override?: ContainerDefinition): Container;
-    addGroup(groupName: string): SoftwareSystemGroup;
+    container(name: string, archetypeOrDef?: ElementArchetype | ContainerDefinition, override?: ContainerDefinition): Container;
+    group(groupName: string): SoftwareSystemGroup;
     getGroups(): ReadonlyArray<SoftwareSystemGroup>;
     getChildElements(): ReadonlyArray<Element>;
     getContainersNotInGroups(): ReadonlyArray<Container>;