@agilewallaby/c4-model 2.6.0 → 2.8.0

package/src/model.d.ts

@@ -2,6 +2,7 @@ import { Group } from './core';
 import { SoftwareSystem, SoftwareSystemDefinition } from './softwareSystem';
 import { Person, PersonDefinition } from './person';
 import { ElementArchetype, RelationshipArchetype } from './archetype';
+import { Views } from './views';
 export type CatalogKeyOf<TRoot, TModule> = {
     [K in keyof TRoot]: TRoot[K] extends TModule ? K : never;
 }[keyof TRoot];
@@ -9,7 +10,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;
 }
 interface DefineSoftwareSystem {
     softwareSystem(name: string, archetypeOrDef?: ElementArchetype | SoftwareSystemDefinition, override?: SoftwareSystemDefinition): SoftwareSystem;
@@ -17,16 +19,24 @@ interface DefineSoftwareSystem {
 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;
@@ -39,7 +49,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>;

package/src/softwareSystem.d.ts

@@ -8,21 +8,28 @@ 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 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);
     container(name: string, archetypeOrDef?: ElementArchetype | ContainerDefinition, override?: ContainerDefinition): Container;
-    addGroup(groupName: string): SoftwareSystemGroup;
+    group(groupName: string): SoftwareSystemGroup;
     getGroups(): ReadonlyArray<SoftwareSystemGroup>;
     getChildElements(): ReadonlyArray<Element>;
     getContainersNotInGroups(): ReadonlyArray<Container>;

package/src/structurizrDslWriter.d.ts

@@ -14,9 +14,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;

package/src/validateModel.d.ts

@@ -0,0 +1,3 @@
+import { Model } from './model';
+import { Views } from './views';
+export declare function validateModel(model: Model, views: Views): Promise<void>;

package/src/views.d.ts

@@ -6,33 +6,94 @@ interface ViewDefinition<T extends Element> {
     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> {
     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: T): void;
+    includeElement(element: Element): void;
     includeExpression(expression: string): void;
     excludeAll(): void;
-    excludeElement(element: T): void;
+    excludeElement(element: Element): 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>): View<Element>;
     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>>;
     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 {};