@agilewallaby/c4-model 2.3.0 → 2.4.0

package/package.json

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

package/src/index.d.ts

@@ -1,10 +1,258 @@
-export * from './archetype';
-export * from './model';
-export * from './person';
-export * from './softwareSystem';
-export * from './container';
-export * from './component';
-export * from './views';
-export * from './structurizrDslWriter';
-export * from './buildModel';
-export * from './generateDiagrams';
+// Generated by dts-bundle-generator v9.5.1
+
+export interface Definition {
+	description?: string;
+	tags?: string[];
+}
+export interface TechnologyDefinition extends Definition {
+	technology?: string;
+}
+declare abstract class Element$1 {
+	readonly name: string;
+	readonly description?: string;
+	readonly tags: ReadonlyArray<string>;
+	readonly archetype?: ElementArchetype;
+	readonly overrideDefinition?: TechnologyDefinition;
+	private _relationships;
+	constructor(name: string, defaultTags?: string[], definition?: Definition, archetype?: ElementArchetype, overrideDefinition?: TechnologyDefinition);
+	get canonicalName(): string;
+	uses(otherElement: Element$1, archetypeOrDef?: RelationshipArchetype | TechnologyDefinition, override?: TechnologyDefinition): void;
+	get relationships(): ReadonlyArray<Relationship>;
+	abstract getChildElements(): ReadonlyArray<Element$1>;
+	getRelationshipsInHierarchy(): ReadonlyArray<Relationship>;
+	getChildElementNames(path?: string): ReadonlyArray<string>;
+}
+declare abstract class TechnicalElement extends Element$1 {
+	readonly technology?: string;
+	constructor(name: string, defaultTags?: string[], definition?: TechnologyDefinition, archetype?: ElementArchetype, overrideDefinition?: TechnologyDefinition);
+}
+declare class Relationship {
+	readonly source: Element$1;
+	readonly destination: Element$1;
+	readonly description?: string;
+	readonly tags: ReadonlyArray<string>;
+	readonly technology?: string;
+	readonly archetype?: RelationshipArchetype;
+	readonly overrideDefinition?: TechnologyDefinition;
+	constructor(source: Element$1, destination: Element$1, definition?: TechnologyDefinition, archetype?: RelationshipArchetype, overrideDefinition?: TechnologyDefinition);
+}
+declare class Group {
+	readonly name: string;
+	constructor(name: string);
+}
+export type ElementKind = "person" | "softwareSystem" | "container" | "component";
+export declare class ElementArchetype {
+	readonly name: string;
+	readonly elementKind: ElementKind;
+	readonly parent?: ElementArchetype | undefined;
+	readonly ownDescription?: string;
+	readonly ownTechnology?: string;
+	readonly ownTags: ReadonlyArray<string>;
+	readonly description?: string;
+	readonly technology?: string;
+	readonly tags: ReadonlyArray<string>;
+	constructor(name: string, elementKind: ElementKind, definition?: TechnologyDefinition, parent?: ElementArchetype | undefined);
+}
+export declare class RelationshipArchetype {
+	readonly name: string;
+	readonly parent?: RelationshipArchetype | undefined;
+	readonly ownDescription?: string;
+	readonly ownTechnology?: string;
+	readonly ownTags: ReadonlyArray<string>;
+	readonly description?: string;
+	readonly technology?: string;
+	readonly tags: ReadonlyArray<string>;
+	constructor(name: string, definition?: TechnologyDefinition, parent?: RelationshipArchetype | undefined);
+}
+export declare function mergeArchetypeWithOverride(archetype: {
+	description?: string;
+	technology?: string;
+	tags: ReadonlyArray<string>;
+}, override?: TechnologyDefinition): TechnologyDefinition;
+export type ComponentDefinition = TechnologyDefinition;
+export declare class Component extends TechnicalElement {
+	readonly name: string;
+	constructor(name: string, definition?: ComponentDefinition, archetype?: ElementArchetype, overrideDefinition?: TechnologyDefinition);
+	getChildElements(): ReadonlyArray<Element$1>;
+}
+export type ContainerDefinition = TechnologyDefinition;
+export interface DefineComponent {
+	defineComponent(name: string, archetypeOrDef?: ElementArchetype | ComponentDefinition, override?: ComponentDefinition): Component;
+}
+export declare class ContainerGroup extends Group implements DefineComponent {
+	readonly name: string;
+	private readonly container;
+	private _components;
+	constructor(name: string, container: DefineComponent);
+	defineComponent(name: string, archetypeOrDef?: ElementArchetype | ComponentDefinition, override?: ComponentDefinition): Component;
+	getComponents(): ReadonlyArray<Component>;
+}
+export declare class Container extends TechnicalElement 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;
+	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;
+}
+export interface SoftwareSystemReference {
+	name: string;
+}
+export declare class SoftwareSystemGroup extends Group implements DefineContainer {
+	readonly name: string;
+	private readonly softwareSystem;
+	private _containers;
+	constructor(name: string, softwareSystem: DefineContainer);
+	defineContainer(name: string, archetypeOrDef?: ElementArchetype | ContainerDefinition, override?: ContainerDefinition): Container;
+	getContainers(): ReadonlyArray<Container>;
+}
+export declare class SoftwareSystem extends Element$1 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;
+	getGroups(): ReadonlyArray<SoftwareSystemGroup>;
+	getChildElements(): ReadonlyArray<Element$1>;
+	getContainersNotInGroups(): ReadonlyArray<Container>;
+}
+export type PersonDefinition = Definition;
+export declare class Person extends Element$1 {
+	readonly name: string;
+	constructor(name: string, definition?: PersonDefinition, archetype?: ElementArchetype, overrideDefinition?: TechnologyDefinition);
+	getChildElements(): ReadonlyArray<Element$1>;
+}
+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> {
+	readonly key: CatalogKeyOf<TRoot, TLocal>;
+	registerDefinitions(model: Model): TLocal;
+	buildRelationships(local: TLocal, dependencies: Dependencies<TRoot, TLocal>): void;
+}
+export interface DefineSoftwareSystem {
+	defineSoftwareSystem(name: string, archetypeOrDef?: ElementArchetype | SoftwareSystemDefinition, override?: SoftwareSystemDefinition): SoftwareSystem;
+}
+export interface DefinePerson {
+	definePerson(name: string, archetypeOrDef?: ElementArchetype | PersonDefinition, override?: PersonDefinition): Person;
+}
+export declare class ModelGroup extends Group 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;
+	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;
+}
+export declare class Model {
+	name: string;
+	constructor(name: string);
+	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;
+	validate(): void;
+	getPeople(): ReadonlyArray<Person>;
+	getSoftwareSystems(): ReadonlyArray<SoftwareSystem>;
+	getPeopleNotInGroups(): ReadonlyArray<Person>;
+	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;
+	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;
+	private writeView;
+	private writeViews;
+	write(): string;
+	private writeLine;
+}
+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;
+}
+export interface BuildModelOptions {
+	modelName?: string;
+	modules?: ReadonlyArray<AnyC4Module>;
+	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 interface GenerateDiagramsOptions<TRoot> extends BuildModelOptions {
+	views: (catalog: TRoot) => Views;
+	outputDir: string;
+}
+export declare function generateDiagrams<TRoot>(options: GenerateDiagramsOptions<TRoot>): Promise<string[]>;
+
+export {};