@agilewallaby/c4-model 2.6.0 → 2.8.0

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 {
@@ -79,21 +82,28 @@ export type ContainerDefinition = TechnologyDefinition;
 export 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$1>;
@@ -105,21 +115,28 @@ export interface DefineContainer {
 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 readonly pathSegments;
 	private _containers;
-	constructor(name: string, softwareSystem: DefineContainer);
+	private _groups;
+	constructor(name: string, softwareSystem: DefineContainer, pathSegments?: string[]);
+	get canonicalName(): string;
+	get dslName(): string;
 	container(name: string, archetypeOrDef?: ElementArchetype | ContainerDefinition, override?: ContainerDefinition): Container;
+	group(groupName: string): SoftwareSystemGroup;
+	getGroups(): ReadonlyArray<SoftwareSystemGroup>;
 	getContainers(): ReadonlyArray<Container>;
+	getAllContainers(): 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);
 	container(name: string, archetypeOrDef?: ElementArchetype | ContainerDefinition, override?: ContainerDefinition): Container;
-	addGroup(groupName: string): SoftwareSystemGroup;
+	group(groupName: string): SoftwareSystemGroup;
 	getGroups(): ReadonlyArray<SoftwareSystemGroup>;
 	getChildElements(): ReadonlyArray<Element$1>;
 	getContainersNotInGroups(): ReadonlyArray<Container>;
@@ -130,6 +147,101 @@ export declare class Person extends Element$1 {
 	constructor(name: string, definition?: PersonDefinition, archetype?: ElementArchetype, overrideDefinition?: TechnologyDefinition);
 	getChildElements(): ReadonlyArray<Element$1>;
 }
+export interface ViewDefinition<T extends Element$1> {
+	subject?: T;
+	description: string;
+	title?: string;
+}
+export type AutoLayoutDirection = "tb" | "bt" | "lr" | "rl";
+export interface AutoLayout {
+	direction?: AutoLayoutDirection;
+	rankSeparation?: number;
+	nodeSeparation?: number;
+}
+export type ElementShape = "Box" | "RoundedBox" | "Circle" | "Ellipse" | "Hexagon" | "Diamond" | "Cylinder" | "Bucket" | "Pipe" | "Person" | "Robot" | "Folder" | "WebBrowser" | "Window" | "Terminal" | "Shell" | "MobileDevicePortrait" | "MobileDeviceLandscape" | "Component";
+export interface ElementStyleDefinition {
+	shape?: ElementShape;
+	icon?: string;
+	width?: number;
+	height?: number;
+	background?: string;
+	color?: string;
+	stroke?: string;
+	strokeWidth?: number;
+	fontSize?: number;
+	border?: "solid" | "dashed" | "dotted";
+	opacity?: number;
+	metadata?: boolean;
+	description?: boolean;
+}
+export interface RelationshipStyleDefinition {
+	thickness?: number;
+	color?: string;
+	style?: "solid" | "dashed" | "dotted";
+	routing?: "Direct" | "Orthogonal" | "Curved";
+	fontSize?: number;
+	width?: number;
+	position?: number;
+	opacity?: number;
+}
+export interface ElementStyleEntry {
+	tag: string;
+	definition: ElementStyleDefinition;
+}
+export interface RelationshipStyleEntry {
+	tag: string;
+	definition: RelationshipStyleDefinition;
+}
+export declare class View<T extends Element$1> {
+	readonly key: string;
+	readonly subject?: T;
+	readonly description: string;
+	readonly title?: string;
+	private _scopes;
+	private _autoLayout?;
+	private _isDefault;
+	private _properties;
+	constructor(key: string, viewDefinition: ViewDefinition<T>);
+	includeAll(): void;
+	includeElement(element: Element$1): void;
+	includeExpression(expression: string): void;
+	excludeAll(): void;
+	excludeElement(element: Element$1): void;
+	excludeExpression(expression: string): void;
+	autoLayout(direction?: AutoLayoutDirection, rankSeparation?: number, nodeSeparation?: number): void;
+	setDefault(): void;
+	addProperty(name: string, value: string): void;
+	get scopes(): ReadonlyArray<string>;
+	get autoLayoutConfig(): AutoLayout | undefined;
+	get isDefault(): boolean;
+	get properties(): ReadonlyMap<string, string>;
+}
+export declare class Views {
+	private readonly _systemLandscapeViews;
+	private readonly _systemContextViews;
+	private readonly _containerViews;
+	private readonly _componentViews;
+	private _elementStyles;
+	private _relationshipStyles;
+	private _themes;
+	private _properties;
+	addSystemLandscapeView(key: string, definition: ViewDefinition<Element$1>): View<Element$1>;
+	addSystemContextView(key: string, definition: ViewDefinition<SoftwareSystem>): View<SoftwareSystem>;
+	addContainerView(key: string, definition: ViewDefinition<SoftwareSystem>): View<SoftwareSystem>;
+	addComponentView(key: string, definition: ViewDefinition<Container>): View<Container>;
+	addElementStyle(tag: string, definition: ElementStyleDefinition): void;
+	addRelationshipStyle(tag: string, definition: RelationshipStyleDefinition): void;
+	addTheme(url: string): void;
+	addProperty(name: string, value: string): void;
+	get systemLandscapeViews(): ReadonlyArray<View<Element$1>>;
+	get systemContextViews(): ReadonlyArray<View<SoftwareSystem>>;
+	get containerViews(): ReadonlyArray<View<SoftwareSystem>>;
+	get componentViews(): ReadonlyArray<View<Container>>;
+	get elementStyles(): ReadonlyArray<ElementStyleEntry>;
+	get relationshipStyles(): ReadonlyArray<RelationshipStyleEntry>;
+	get themes(): ReadonlyArray<string>;
+	get properties(): ReadonlyMap<string, string>;
+}
 export type CatalogKeyOf<TRoot, TModule> = {
 	[K in keyof TRoot]: TRoot[K] extends TModule ? K : never;
 }[keyof TRoot];
@@ -137,7 +249,8 @@ export type Dependencies<TRoot, TModule> = Omit<TRoot, CatalogKeyOf<TRoot, TModu
 export interface C4Module<TRoot, TLocal, TArchetypes = Record<string, ElementArchetype | RelationshipArchetype>> {
 	readonly key: CatalogKeyOf<TRoot, TLocal>;
 	registerDefinitions(model: Model, archetypes: TArchetypes): TLocal;
-	buildRelationships(local: TLocal, dependencies: Dependencies<TRoot, TLocal>, archetypes: TArchetypes): void;
+	addRelationships(local: TLocal, dependencies: Dependencies<TRoot, TLocal>, archetypes: TArchetypes): void;
+	addViews?(views: Views, local: TLocal, dependencies: Dependencies<TRoot, TLocal>): void;
 }
 export interface DefineSoftwareSystem {
 	softwareSystem(name: string, archetypeOrDef?: ElementArchetype | SoftwareSystemDefinition, override?: SoftwareSystemDefinition): SoftwareSystem;
@@ -145,16 +258,24 @@ export interface DefineSoftwareSystem {
 export interface DefinePerson {
 	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 readonly pathSegments;
 	private softwareSystems;
 	private people;
-	constructor(name: string, model: DefineSoftwareSystem & DefinePerson);
+	private _groups;
+	constructor(name: string, model: DefineSoftwareSystem & DefinePerson, pathSegments?: string[]);
+	get canonicalName(): string;
+	get dslName(): string;
 	softwareSystem(name: string, archetypeOrDef?: ElementArchetype | SoftwareSystemDefinition, override?: SoftwareSystemDefinition): SoftwareSystem;
 	person(name: string, archetypeOrDef?: ElementArchetype | PersonDefinition, override?: PersonDefinition): Person;
+	group(groupName: string): ModelGroup;
+	getGroups(): ReadonlyArray<ModelGroup>;
 	getSoftwareSystems(): ReadonlyArray<SoftwareSystem>;
 	getPeople(): ReadonlyArray<Person>;
+	getAllSoftwareSystems(): ReadonlyArray<SoftwareSystem>;
+	getAllPeople(): ReadonlyArray<Person>;
 }
 export interface ModelDefinitions {
 	softwareSystem(name: string, archetypeOrDef?: ElementArchetype | SoftwareSystemDefinition, override?: SoftwareSystemDefinition): SoftwareSystem;
@@ -167,7 +288,7 @@ export declare class Model {
 	private people;
 	private groups;
 	softwareSystem(name: string, archetypeOrDef?: ElementArchetype | SoftwareSystemDefinition, override?: SoftwareSystemDefinition): SoftwareSystem;
-	addGroup(groupName: string): Group & ModelDefinitions;
+	group(groupName: string): ModelGroup;
 	person(name: string, archetypeOrDef?: ElementArchetype | PersonDefinition, override?: PersonDefinition): Person;
 	validate(): void;
 	getPeople(): ReadonlyArray<Person>;
@@ -176,40 +297,6 @@ export declare class Model {
 	getSoftwareSystemsNotInGroups(): ReadonlyArray<SoftwareSystem>;
 	getGroups(): ReadonlyArray<ModelGroup>;
 }
-export interface ViewDefinition<T extends Element$1> {
-	subject?: T;
-	description: string;
-	title?: string;
-}
-export declare class View<T extends Element$1> {
-	readonly key: string;
-	readonly subject?: T;
-	readonly description: string;
-	readonly title?: string;
-	private _scopes;
-	constructor(key: string, viewDefinition: ViewDefinition<T>);
-	includeAll(): void;
-	includeElement(element: T): void;
-	includeExpression(expression: string): void;
-	excludeAll(): void;
-	excludeElement(element: T): void;
-	excludeExpression(expression: string): void;
-	get scopes(): ReadonlyArray<string>;
-}
-export declare class Views {
-	private readonly _systemLandscapeViews;
-	private readonly _systemContextViews;
-	private readonly _containerViews;
-	private readonly _componentViews;
-	addSystemLandscapeView(key: string, definition: ViewDefinition<Element$1>): View<Element$1>;
-	addSystemContextView(key: string, definition: ViewDefinition<SoftwareSystem>): View<SoftwareSystem>;
-	addContainerView(key: string, definition: ViewDefinition<SoftwareSystem>): View<SoftwareSystem>;
-	addComponentView(key: string, definition: ViewDefinition<Container>): View<Container>;
-	get systemLandscapeViews(): ReadonlyArray<View<Element$1>>;
-	get systemContextViews(): ReadonlyArray<View<SoftwareSystem>>;
-	get containerViews(): ReadonlyArray<View<SoftwareSystem>>;
-	get componentViews(): ReadonlyArray<View<Container>>;
-}
 export declare class StructurizrDSLWriter {
 	private readonly model;
 	private readonly views;
@@ -224,9 +311,14 @@ export declare class StructurizrDSLWriter {
 	private writeSoftwareSystem;
 	private writeRelationship;
 	private writeRelationships;
+	private hasNestedModelGroups;
+	private hasNestedSoftwareSystemGroups;
+	private hasNestedContainerGroups;
+	private hasNestedGroups;
 	private writeModelGroup;
 	private writeModel;
 	private writeView;
+	private writeStyles;
 	private writeViews;
 	write(): string;
 	private writeLine;
@@ -236,24 +328,28 @@ export 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 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[]>;
+export declare function validateModel(model: Model, views: Views): Promise<void>;
+export declare function exportWorkspaceJsonFromDsl(dsl: string): Promise<unknown>;
+export declare function exportWorkspaceJson(model: Model, views: Views): Promise<unknown>;
 
 export {};