@agilewallaby/c4-model 2.6.0 → 2.8.0

package/package.json

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

package/src/buildModel.d.ts

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

package/src/container.d.ts

@@ -5,21 +5,28 @@ export type ContainerDefinition = TechnologyDefinition;
 interface DefineComponent {
     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 readonly pathSegments;
     private _components;
-    constructor(name: string, container: DefineComponent);
+    private _groups;
+    constructor(name: string, container: DefineComponent, pathSegments?: string[]);
+    get canonicalName(): string;
+    get dslName(): string;
     component(name: string, archetypeOrDef?: ElementArchetype | ComponentDefinition, override?: ComponentDefinition): Component;
+    group(groupName: string): ContainerGroup;
+    getGroups(): ReadonlyArray<ContainerGroup>;
     getComponents(): ReadonlyArray<Component>;
+    getAllComponents(): 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);
     component(name: string, archetypeOrDef?: ElementArchetype | ComponentDefinition, override?: ComponentDefinition): Component;
-    addGroup(groupName: string): ContainerGroup;
+    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/exportWorkspaceJson.d.ts

@@ -0,0 +1,4 @@
+import { Model } from './model';
+import { Views } from './views';
+export declare function exportWorkspaceJsonFromDsl(dsl: string): Promise<unknown>;
+export declare function exportWorkspaceJson(model: Model, views: Views): Promise<unknown>;

package/src/generateDiagrams.d.ts

@@ -1,7 +1,5 @@
 import { BuildModelOptions } from './buildModel';
-import { Views } from './views';
-export interface GenerateDiagramsOptions<TRoot> extends BuildModelOptions {
-    views: (catalog: TRoot) => Views;
+export interface GenerateDiagramsOptions<TRoot> extends BuildModelOptions<TRoot> {
     outputDir: string;
 }
 export declare function generateDiagrams<TRoot>(options: GenerateDiagramsOptions<TRoot>): Promise<string[]>;