@agilewallaby/c4-model 2.1.0 → 2.3.0

package/src/model.d.ts

@@ -1,6 +1,7 @@
 import { Group } from './core';
 import { SoftwareSystem, SoftwareSystemDefinition } from './softwareSystem';
 import { Person, PersonDefinition } from './person';
+import { ElementArchetype } from './archetype';
 export type CatalogKeyOf<TRoot, TModule> = {
     [K in keyof TRoot]: TRoot[K] extends TModule ? K : never;
 }[keyof TRoot];
@@ -11,10 +12,10 @@ export interface C4Module<TRoot, TLocal> {
     buildRelationships(local: TLocal, dependencies: Dependencies<TRoot, TLocal>): void;
 }
 interface DefineSoftwareSystem {
-    defineSoftwareSystem(name: string, definition?: SoftwareSystemDefinition): SoftwareSystem;
+    defineSoftwareSystem(name: string, archetypeOrDef?: ElementArchetype | SoftwareSystemDefinition, override?: SoftwareSystemDefinition): SoftwareSystem;
 }
 interface DefinePerson {
-    definePerson(name: string, definition?: PersonDefinition): Person;
+    definePerson(name: string, archetypeOrDef?: ElementArchetype | PersonDefinition, override?: PersonDefinition): Person;
 }
 export declare class ModelGroup extends Group implements DefineSoftwareSystem, DefinePerson {
     readonly name: string;
@@ -22,14 +23,14 @@ export declare class ModelGroup extends Group implements DefineSoftwareSystem, D
     private softwareSystems;
     private people;
     constructor(name: string, model: DefineSoftwareSystem & DefinePerson);
-    defineSoftwareSystem(name: string, definition?: SoftwareSystemDefinition): SoftwareSystem;
-    definePerson(name: string, definition?: PersonDefinition): Person;
+    defineSoftwareSystem(name: string, archetypeOrDef?: ElementArchetype | SoftwareSystemDefinition, override?: SoftwareSystemDefinition): SoftwareSystem;
+    definePerson(name: string, archetypeOrDef?: ElementArchetype | PersonDefinition, override?: PersonDefinition): Person;
     getSoftwareSystems(): ReadonlyArray<SoftwareSystem>;
     getPeople(): ReadonlyArray<Person>;
 }
 export interface ModelDefinitions {
-    defineSoftwareSystem(name: string, definition?: SoftwareSystemDefinition): SoftwareSystem;
-    definePerson(name: string, definition?: PersonDefinition): Person;
+    defineSoftwareSystem(name: string, archetypeOrDef?: ElementArchetype | SoftwareSystemDefinition, override?: SoftwareSystemDefinition): SoftwareSystem;
+    definePerson(name: string, archetypeOrDef?: ElementArchetype | PersonDefinition, override?: PersonDefinition): Person;
 }
 export declare class Model {
     name: string;
@@ -37,9 +38,9 @@ export declare class Model {
     private softwareSystems;
     private people;
     private groups;
-    defineSoftwareSystem(name: string, definition?: SoftwareSystemDefinition): SoftwareSystem;
+    defineSoftwareSystem(name: string, archetypeOrDef?: ElementArchetype | SoftwareSystemDefinition, override?: SoftwareSystemDefinition): SoftwareSystem;
     addGroup(groupName: string): Group & ModelDefinitions;
-    definePerson(name: string, definition?: PersonDefinition): Person;
+    definePerson(name: string, archetypeOrDef?: ElementArchetype | PersonDefinition, override?: PersonDefinition): Person;
     validate(): void;
     getPeople(): ReadonlyArray<Person>;
     getSoftwareSystems(): ReadonlyArray<SoftwareSystem>;
@@ -47,14 +48,4 @@ export declare class Model {
     getSoftwareSystemsNotInGroups(): ReadonlyArray<SoftwareSystem>;
     getGroups(): ReadonlyArray<ModelGroup>;
 }
-export interface BuildModelOptions {
-    modelName?: string;
-    globPath?: string;
-    searchRoot?: string;
-}
-export declare function buildModelWithCatalog<TRoot>(options?: BuildModelOptions): Promise<{
-    model: Model;
-    catalog: TRoot;
-}>;
-export declare function buildModel(options?: BuildModelOptions): Promise<Model>;
 export {};

package/src/person.d.ts

@@ -1,7 +1,8 @@
-import { Definition, Element } from './core';
+import { Definition, Element, TechnologyDefinition } from './core';
+import { ElementArchetype } from './archetype';
 export type PersonDefinition = Definition;
 export declare class Person extends Element {
     readonly name: string;
-    constructor(name: string, definition?: PersonDefinition);
+    constructor(name: string, definition?: PersonDefinition, archetype?: ElementArchetype, overrideDefinition?: TechnologyDefinition);
     getChildElements(): ReadonlyArray<Element>;
 }

package/src/softwareSystem.d.ts

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

package/src/structurizrDslWriter.d.ts

@@ -4,12 +4,15 @@ export declare class StructurizrDSLWriter {
     private readonly model;
     private readonly views;
     constructor(model: Model, views: Views);
+    private collectArchetypes;
+    private writeArchetypes;
     private writeElement;
     private writeComponent;
     private writeContainerGroup;
     private writeContainer;
     private writeSoftwareSystemGroup;
     private writeSoftwareSystem;
+    private writeRelationship;
     private writeRelationships;
     private writeModelGroup;
     private writeModel;