@domainlang/language 0.1.81

package/out/generated/ast.d.ts

@@ -0,0 +1,770 @@
+/******************************************************************************
+ * This file was generated by langium-cli 4.1.0.
+ * DO NOT EDIT MANUALLY!
+ ******************************************************************************/
+import * as langium from 'langium';
+export declare const DomainLangTerminals: {
+    WS: RegExp;
+    ID: RegExp;
+    STRING: RegExp;
+    ML_COMMENT: RegExp;
+    SL_COMMENT: RegExp;
+};
+export type DomainLangTerminalNames = keyof typeof DomainLangTerminals;
+export type DomainLangKeywordNames = "," | "->" | "." | ":" | "<-" | "<->" | "=" | "><" | "ACL" | "AntiCorruptionLayer" | "BBoM" | "BigBallOfMud" | "BoundedContext" | "CF" | "Classification" | "Conformist" | "ContextMap" | "CustomerSupplier" | "Decision" | "Domain" | "DomainMap" | "Import" | "Metadata" | "Namespace" | "OHS" | "OpenHostService" | "P" | "PL" | "Partnership" | "Policy" | "PublishedLanguage" | "Rule" | "SK" | "SeparateWays" | "SharedKernel" | "Team" | "Term" | "UpstreamDownstream" | "[" | "]" | "aka" | "archetype" | "as" | "bc" | "businessModel" | "by" | "classification" | "cmap" | "contains" | "decision" | "decisions" | "description" | "dmap" | "dom" | "evolution" | "examples" | "for" | "from" | "glossary" | "import" | "in" | "integrations" | "integrity" | "is" | "meta" | "metadata" | "ns" | "policy" | "relationships" | "rule" | "rules" | "synonyms" | "team" | "term" | "terminology" | "this" | "type" | "vision" | "{" | "}";
+export type DomainLangTokenNames = DomainLangTerminalNames | DomainLangKeywordNames;
+/**
+ * Decisions, Policies, and Business Rules.
+ * All types are interchangeable - use what reads best for your domain.
+ */
+export type AbstractDecision = BusinessRule | Decision | Policy;
+export declare const AbstractDecision: {
+    readonly $type: "AbstractDecision";
+};
+export declare function isAbstractDecision(item: unknown): item is AbstractDecision;
+/**
+ * Assignment operators - flexible syntax.
+ */
+export type Assignment = ':' | '=' | 'is';
+export declare function isAssignment(item: unknown): item is Assignment;
+/**
+ * Bounded Context - A boundary within which a domain model is defined.
+ * Central pattern in DDD for managing complexity and team boundaries.
+ * Belongs to exactly ONE domain (fundamental DDD principle).
+ * Body properties can appear in any order. Validation enforces at-most-once constraint.
+ * The `classification` property indicates strategic importance per Bounded Context Canvas.
+ * The `evolution` property indicates maturity stage per Wardley Maps/BC Canvas.
+ * The `archetype` property indicates behavioral role per DDD archetypes (Gateway, Execution, etc).
+ */
+export interface BoundedContext extends langium.AstNode {
+    readonly $container: Model | NamespaceDeclaration;
+    readonly $type: 'Assignment' | 'BoundedContext';
+    archetype?: langium.Reference<Classification>;
+    businessModel?: langium.Reference<Classification>;
+    classification: Array<langium.Reference<Classification>>;
+    decisions: Array<AbstractDecision>;
+    description?: string;
+    domain?: langium.Reference<Domain>;
+    evolution?: langium.Reference<Classification>;
+    metadata: Array<MetadataEntry>;
+    name: string;
+    relationships: Array<Relationship>;
+    team: Array<langium.Reference<Team>>;
+    terminology: Array<DomainTerm>;
+}
+export declare const BoundedContext: {
+    readonly $type: "BoundedContext";
+    readonly archetype: "archetype";
+    readonly businessModel: "businessModel";
+    readonly classification: "classification";
+    readonly decisions: "decisions";
+    readonly description: "description";
+    readonly domain: "domain";
+    readonly evolution: "evolution";
+    readonly metadata: "metadata";
+    readonly name: "name";
+    readonly relationships: "relationships";
+    readonly team: "team";
+    readonly terminology: "terminology";
+};
+export declare function isBoundedContext(item: unknown): item is BoundedContext;
+/**
+ * Context reference - can be 'this' (self-reference) or a qualified name.
+ */
+export interface BoundedContextRef extends langium.AstNode {
+    readonly $type: 'BoundedContextRef' | 'ThisRef';
+    link?: langium.Reference<BoundedContext>;
+}
+export declare const BoundedContextRef: {
+    readonly $type: "BoundedContextRef";
+    readonly link: "link";
+};
+export declare function isBoundedContextRef(item: unknown): item is BoundedContextRef;
+export interface BusinessRule extends langium.AstNode {
+    readonly $container: BoundedContext;
+    readonly $type: 'Assignment' | 'BusinessRule';
+    classification: langium.Reference<Classification>;
+    name: string;
+    value: string;
+}
+export declare const BusinessRule: {
+    readonly $type: "BusinessRule";
+    readonly classification: "classification";
+    readonly name: "name";
+    readonly value: "value";
+};
+export declare function isBusinessRule(item: unknown): item is BusinessRule;
+/**
+ * Classification - Reusable label for categorizing elements.
+ * Examples: Core, Supporting, Generic, Strategic, Commodity, Architectural, Business, Technical.
+ */
+export interface Classification extends langium.AstNode {
+    readonly $container: Model | NamespaceDeclaration;
+    readonly $type: 'Classification';
+    name: string;
+}
+export declare const Classification: {
+    readonly $type: "Classification";
+    readonly name: "name";
+};
+export declare function isClassification(item: unknown): item is Classification;
+export type Container = Model | NamespaceDeclaration;
+export declare const Container: {
+    readonly $type: "Container";
+};
+export declare function isContainer(item: unknown): item is Container;
+/**
+ * Context Map - Visualizes relationships between Bounded Contexts.
+ * Shows integration patterns and team interactions.
+ */
+export interface ContextMap extends langium.AstNode {
+    readonly $container: Model | NamespaceDeclaration;
+    readonly $type: 'ContextMap';
+    boundedContexts: Array<langium.MultiReference<BoundedContext>>;
+    name: string;
+    relationships: Array<Relationship>;
+}
+export declare const ContextMap: {
+    readonly $type: "ContextMap";
+    readonly boundedContexts: "boundedContexts";
+    readonly name: "name";
+    readonly relationships: "relationships";
+};
+export declare function isContextMap(item: unknown): item is ContextMap;
+export interface Decision extends langium.AstNode {
+    readonly $container: BoundedContext;
+    readonly $type: 'Assignment' | 'Decision';
+    classification: langium.Reference<Classification>;
+    name: string;
+    value: string;
+}
+export declare const Decision: {
+    readonly $type: "Decision";
+    readonly classification: "classification";
+    readonly name: "name";
+    readonly value: "value";
+};
+export declare function isDecision(item: unknown): item is Decision;
+/**
+ * Domain - A sphere of knowledge or activity in DDD.
+ * Can be nested via `in` to show subdomain hierarchy.
+ * The `type` property indicates strategic importance (Core, Supporting, Generic) per Bounded Context Canvas.
+ * Body is optional - allows header-only Domain definitions.
+ */
+export interface Domain extends langium.AstNode {
+    readonly $container: Model | NamespaceDeclaration;
+    readonly $type: 'Assignment' | 'Domain';
+    description?: string;
+    name: string;
+    parent?: langium.Reference<Domain>;
+    type?: langium.Reference<Classification>;
+    vision?: string;
+}
+export declare const Domain: {
+    readonly $type: "Domain";
+    readonly description: "description";
+    readonly name: "name";
+    readonly parent: "parent";
+    readonly type: "type";
+    readonly vision: "vision";
+};
+export declare function isDomain(item: unknown): item is Domain;
+/**
+ * Domain Map - Visualizes relationships between Domains.
+ * Shows high-level domain organization and subdomain structure.
+ */
+export interface DomainMap extends langium.AstNode {
+    readonly $container: Model | NamespaceDeclaration;
+    readonly $type: 'DomainMap';
+    domains: Array<langium.MultiReference<Domain>>;
+    name: string;
+}
+export declare const DomainMap: {
+    readonly $type: "DomainMap";
+    readonly domains: "domains";
+    readonly name: "name";
+};
+export declare function isDomainMap(item: unknown): item is DomainMap;
+/**
+ * Domain Terminology - Ubiquitous language terms with definitions.
+ * Supports synonyms and examples for richer glossaries.
+ */
+export interface DomainTerm extends langium.AstNode {
+    readonly $container: BoundedContext;
+    readonly $type: 'Assignment' | 'DomainTerm';
+    examples: Array<string>;
+    meaning?: string;
+    name: string;
+    synonyms: Array<string>;
+}
+export declare const DomainTerm: {
+    readonly $type: "DomainTerm";
+    readonly examples: "examples";
+    readonly meaning: "meaning";
+    readonly name: "name";
+    readonly synonyms: "synonyms";
+};
+export declare function isDomainTerm(item: unknown): item is DomainTerm;
+/**
+ * Import Statement - Git-native import system inspired by Go modules and Deno.
+ *
+ * Supported formats:
+ *   - Local files: import "./shared/types.dlang"
+ *   - Workspace-relative: import "~/contexts/sales.dlang"
+ *   - GitHub packages: import "owner/repo@v1.0.0"
+ *   - GitLab/Git URLs: import "https://gitlab.com/owner/repo@v1.0.0"
+ *   - With aliases: import "ddd-patterns/core@v2.1.0" as DDD
+ *   - Named imports: import { OrderContext } from "./contexts.dlang"
+ */
+export interface ImportStatement extends langium.AstNode {
+    readonly $container: Model;
+    readonly $type: 'ImportStatement';
+    alias?: string;
+    integrity?: string;
+    symbols: Array<string>;
+    uri: string;
+}
+export declare const ImportStatement: {
+    readonly $type: "ImportStatement";
+    readonly alias: "alias";
+    readonly integrity: "integrity";
+    readonly symbols: "symbols";
+    readonly uri: "uri";
+};
+export declare function isImportStatement(item: unknown): item is ImportStatement;
+/**
+ * DDD Integration Patterns (used in relationships).
+ */
+export type IntegrationPattern = 'ACL' | 'AntiCorruptionLayer' | 'BBoM' | 'BigBallOfMud' | 'CF' | 'Conformist' | 'OHS' | 'OpenHostService' | 'P' | 'PL' | 'Partnership' | 'PublishedLanguage' | 'SK' | 'SharedKernel';
+export declare function isIntegrationPattern(item: unknown): item is IntegrationPattern;
+/**
+ * Metadata - Defines a key that can be used in metadata blocks.
+ * Examples: Language, Framework, Database, Repository.
+ * Can be defined locally or imported from stdlib.
+ */
+export interface Metadata extends langium.AstNode {
+    readonly $container: Model | NamespaceDeclaration;
+    readonly $type: 'Metadata';
+    name: string;
+}
+export declare const Metadata: {
+    readonly $type: "Metadata";
+    readonly name: "name";
+};
+export declare function isMetadata(item: unknown): item is Metadata;
+export interface MetadataEntry extends langium.AstNode {
+    readonly $container: BoundedContext;
+    readonly $type: 'Assignment' | 'MetadataEntry';
+    key: langium.Reference<Metadata>;
+    value: string;
+}
+export declare const MetadataEntry: {
+    readonly $type: "MetadataEntry";
+    readonly key: "key";
+    readonly value: "value";
+};
+export declare function isMetadataEntry(item: unknown): item is MetadataEntry;
+/**
+ * Root AST node - aggregates all top-level DDD elements.
+ * Produces the entry point for parsing .dlang files.
+ */
+export interface Model extends langium.AstNode {
+    readonly $type: 'Model';
+    children: Array<StructureElement>;
+    imports: Array<ImportStatement>;
+}
+export declare const Model: {
+    readonly $type: "Model";
+    readonly children: "children";
+    readonly imports: "imports";
+};
+export declare function isModel(item: unknown): item is Model;
+/**
+ * Namespace Declaration - Hierarchical namespacing for organizing models.
+ * Combines package modularity with group-style nesting.
+ */
+export interface NamespaceDeclaration extends langium.AstNode {
+    readonly $container: Model | NamespaceDeclaration;
+    readonly $type: 'NamespaceDeclaration';
+    children: Array<StructureElement>;
+    name: QualifiedName;
+}
+export declare const NamespaceDeclaration: {
+    readonly $type: "NamespaceDeclaration";
+    readonly children: "children";
+    readonly name: "name";
+};
+export declare function isNamespaceDeclaration(item: unknown): item is NamespaceDeclaration;
+/**
+ * Union of mapping constructs for visualizing architecture.
+ */
+export type ObjectMap = ContextMap | DomainMap;
+export declare const ObjectMap: {
+    readonly $type: "ObjectMap";
+};
+export declare function isObjectMap(item: unknown): item is ObjectMap;
+export interface Policy extends langium.AstNode {
+    readonly $container: BoundedContext;
+    readonly $type: 'Assignment' | 'Policy';
+    classification: langium.Reference<Classification>;
+    name: string;
+    value: string;
+}
+export declare const Policy: {
+    readonly $type: "Policy";
+    readonly classification: "classification";
+    readonly name: "name";
+    readonly value: "value";
+};
+export declare function isPolicy(item: unknown): item is Policy;
+/**
+ * Qualified Name - Hierarchical namespacing with dots.
+ */
+export type QualifiedName = string;
+export declare function isQualifiedName(item: unknown): item is QualifiedName;
+/**
+ * Relationship - Connection between two Bounded Contexts.
+ * Supports DDD integration patterns (ACL, OHS, PL, etc.) and relationship types.
+ */
+export interface Relationship extends langium.AstNode {
+    readonly $container: BoundedContext | ContextMap;
+    readonly $type: 'Assignment' | 'Relationship';
+    arrow: RelationshipArrow;
+    left: BoundedContextRef;
+    leftPatterns: Array<IntegrationPattern>;
+    right: BoundedContextRef;
+    rightPatterns: Array<IntegrationPattern>;
+    type?: RelationshipType;
+}
+export declare const Relationship: {
+    readonly $type: "Relationship";
+    readonly arrow: "arrow";
+    readonly left: "left";
+    readonly leftPatterns: "leftPatterns";
+    readonly right: "right";
+    readonly rightPatterns: "rightPatterns";
+    readonly type: "type";
+};
+export declare function isRelationship(item: unknown): item is Relationship;
+/**
+ * Relationship arrows - symbolic and named types.
+ *
+ * Arrow semantics:
+ *   ->   Upstream to downstream (left provides, right consumes)
+ *   <-   Downstream to upstream (right provides, left consumes)
+ *   <->  Bidirectional/Partnership (mutual dependency)
+ *   ><   Separate Ways (no integration, teams go their own way)
+ */
+export type RelationshipArrow = '->' | '<-' | '<->' | '><';
+export declare function isRelationshipArrow(item: unknown): item is RelationshipArrow;
+/**
+ * DDD Relationship Types.
+ */
+export type RelationshipType = 'CustomerSupplier' | 'Partnership' | 'SeparateWays' | 'SharedKernel' | 'UpstreamDownstream';
+export declare function isRelationshipType(item: unknown): item is RelationshipType;
+/**
+ * Top-level elements that can appear in the model.
+ * Unifies all major DDD constructs for flexible ordering.
+ */
+export type StructureElement = NamespaceDeclaration | ObjectMap | Type;
+export declare const StructureElement: {
+    readonly $type: "StructureElement";
+};
+export declare function isStructureElement(item: unknown): item is StructureElement;
+/**
+ * Team - People responsible for a Bounded Context or Domain.
+ * Represents organizational boundaries in DDD.
+ */
+export interface Team extends langium.AstNode {
+    readonly $container: Model | NamespaceDeclaration;
+    readonly $type: 'Team';
+    name: string;
+}
+export declare const Team: {
+    readonly $type: "Team";
+    readonly name: "name";
+};
+export declare function isTeam(item: unknown): item is Team;
+/**
+ * Context reference - can be 'this' (self-reference) or a qualified name.
+ */
+export interface ThisRef extends BoundedContextRef {
+    readonly $type: 'ThisRef';
+}
+export declare const ThisRef: {
+    readonly $type: "ThisRef";
+    readonly link: "link";
+};
+export declare function isThisRef(item: unknown): item is ThisRef;
+/**
+ * Union of all main DDD type constructs.
+ */
+export type Type = BoundedContext | Classification | Domain | Metadata | Team;
+export declare const Type: {
+    readonly $type: "Type";
+};
+export declare function isType(item: unknown): item is Type;
+export type DomainLangAstType = {
+    AbstractDecision: AbstractDecision;
+    BoundedContext: BoundedContext;
+    BoundedContextRef: BoundedContextRef;
+    BusinessRule: BusinessRule;
+    Classification: Classification;
+    Container: Container;
+    ContextMap: ContextMap;
+    Decision: Decision;
+    Domain: Domain;
+    DomainMap: DomainMap;
+    DomainTerm: DomainTerm;
+    ImportStatement: ImportStatement;
+    Metadata: Metadata;
+    MetadataEntry: MetadataEntry;
+    Model: Model;
+    NamespaceDeclaration: NamespaceDeclaration;
+    ObjectMap: ObjectMap;
+    Policy: Policy;
+    Relationship: Relationship;
+    StructureElement: StructureElement;
+    Team: Team;
+    ThisRef: ThisRef;
+    Type: Type;
+};
+export declare class DomainLangAstReflection extends langium.AbstractAstReflection {
+    readonly types: {
+        readonly AbstractDecision: {
+            readonly name: "AbstractDecision";
+            readonly properties: {};
+            readonly superTypes: [];
+        };
+        readonly BoundedContext: {
+            readonly name: "BoundedContext";
+            readonly properties: {
+                readonly archetype: {
+                    readonly name: "archetype";
+                    readonly referenceType: "Classification";
+                };
+                readonly businessModel: {
+                    readonly name: "businessModel";
+                    readonly referenceType: "Classification";
+                };
+                readonly classification: {
+                    readonly name: "classification";
+                    readonly defaultValue: [];
+                    readonly referenceType: "Classification";
+                };
+                readonly decisions: {
+                    readonly name: "decisions";
+                    readonly defaultValue: [];
+                };
+                readonly description: {
+                    readonly name: "description";
+                };
+                readonly domain: {
+                    readonly name: "domain";
+                    readonly referenceType: "Domain";
+                };
+                readonly evolution: {
+                    readonly name: "evolution";
+                    readonly referenceType: "Classification";
+                };
+                readonly metadata: {
+                    readonly name: "metadata";
+                    readonly defaultValue: [];
+                };
+                readonly name: {
+                    readonly name: "name";
+                };
+                readonly relationships: {
+                    readonly name: "relationships";
+                    readonly defaultValue: [];
+                };
+                readonly team: {
+                    readonly name: "team";
+                    readonly defaultValue: [];
+                    readonly referenceType: "Team";
+                };
+                readonly terminology: {
+                    readonly name: "terminology";
+                    readonly defaultValue: [];
+                };
+            };
+            readonly superTypes: ["Type"];
+        };
+        readonly BoundedContextRef: {
+            readonly name: "BoundedContextRef";
+            readonly properties: {
+                readonly link: {
+                    readonly name: "link";
+                    readonly referenceType: "BoundedContext";
+                };
+            };
+            readonly superTypes: [];
+        };
+        readonly BusinessRule: {
+            readonly name: "BusinessRule";
+            readonly properties: {
+                readonly classification: {
+                    readonly name: "classification";
+                    readonly referenceType: "Classification";
+                };
+                readonly name: {
+                    readonly name: "name";
+                };
+                readonly value: {
+                    readonly name: "value";
+                };
+            };
+            readonly superTypes: ["AbstractDecision"];
+        };
+        readonly Classification: {
+            readonly name: "Classification";
+            readonly properties: {
+                readonly name: {
+                    readonly name: "name";
+                };
+            };
+            readonly superTypes: ["Type"];
+        };
+        readonly Container: {
+            readonly name: "Container";
+            readonly properties: {};
+            readonly superTypes: [];
+        };
+        readonly ContextMap: {
+            readonly name: "ContextMap";
+            readonly properties: {
+                readonly boundedContexts: {
+                    readonly name: "boundedContexts";
+                    readonly defaultValue: [];
+                    readonly referenceType: "BoundedContext";
+                };
+                readonly name: {
+                    readonly name: "name";
+                };
+                readonly relationships: {
+                    readonly name: "relationships";
+                    readonly defaultValue: [];
+                };
+            };
+            readonly superTypes: ["ObjectMap"];
+        };
+        readonly Decision: {
+            readonly name: "Decision";
+            readonly properties: {
+                readonly classification: {
+                    readonly name: "classification";
+                    readonly referenceType: "Classification";
+                };
+                readonly name: {
+                    readonly name: "name";
+                };
+                readonly value: {
+                    readonly name: "value";
+                };
+            };
+            readonly superTypes: ["AbstractDecision"];
+        };
+        readonly Domain: {
+            readonly name: "Domain";
+            readonly properties: {
+                readonly description: {
+                    readonly name: "description";
+                };
+                readonly name: {
+                    readonly name: "name";
+                };
+                readonly parent: {
+                    readonly name: "parent";
+                    readonly referenceType: "Domain";
+                };
+                readonly type: {
+                    readonly name: "type";
+                    readonly referenceType: "Classification";
+                };
+                readonly vision: {
+                    readonly name: "vision";
+                };
+            };
+            readonly superTypes: ["Type"];
+        };
+        readonly DomainMap: {
+            readonly name: "DomainMap";
+            readonly properties: {
+                readonly domains: {
+                    readonly name: "domains";
+                    readonly defaultValue: [];
+                    readonly referenceType: "Domain";
+                };
+                readonly name: {
+                    readonly name: "name";
+                };
+            };
+            readonly superTypes: ["ObjectMap"];
+        };
+        readonly DomainTerm: {
+            readonly name: "DomainTerm";
+            readonly properties: {
+                readonly examples: {
+                    readonly name: "examples";
+                    readonly defaultValue: [];
+                };
+                readonly meaning: {
+                    readonly name: "meaning";
+                };
+                readonly name: {
+                    readonly name: "name";
+                };
+                readonly synonyms: {
+                    readonly name: "synonyms";
+                    readonly defaultValue: [];
+                };
+            };
+            readonly superTypes: [];
+        };
+        readonly ImportStatement: {
+            readonly name: "ImportStatement";
+            readonly properties: {
+                readonly alias: {
+                    readonly name: "alias";
+                };
+                readonly integrity: {
+                    readonly name: "integrity";
+                };
+                readonly symbols: {
+                    readonly name: "symbols";
+                    readonly defaultValue: [];
+                };
+                readonly uri: {
+                    readonly name: "uri";
+                };
+            };
+            readonly superTypes: [];
+        };
+        readonly Metadata: {
+            readonly name: "Metadata";
+            readonly properties: {
+                readonly name: {
+                    readonly name: "name";
+                };
+            };
+            readonly superTypes: ["Type"];
+        };
+        readonly MetadataEntry: {
+            readonly name: "MetadataEntry";
+            readonly properties: {
+                readonly key: {
+                    readonly name: "key";
+                    readonly referenceType: "Metadata";
+                };
+                readonly value: {
+                    readonly name: "value";
+                };
+            };
+            readonly superTypes: [];
+        };
+        readonly Model: {
+            readonly name: "Model";
+            readonly properties: {
+                readonly children: {
+                    readonly name: "children";
+                    readonly defaultValue: [];
+                };
+                readonly imports: {
+                    readonly name: "imports";
+                    readonly defaultValue: [];
+                };
+            };
+            readonly superTypes: ["Container"];
+        };
+        readonly NamespaceDeclaration: {
+            readonly name: "NamespaceDeclaration";
+            readonly properties: {
+                readonly children: {
+                    readonly name: "children";
+                    readonly defaultValue: [];
+                };
+                readonly name: {
+                    readonly name: "name";
+                };
+            };
+            readonly superTypes: ["Container", "StructureElement"];
+        };
+        readonly ObjectMap: {
+            readonly name: "ObjectMap";
+            readonly properties: {};
+            readonly superTypes: ["StructureElement"];
+        };
+        readonly Policy: {
+            readonly name: "Policy";
+            readonly properties: {
+                readonly classification: {
+                    readonly name: "classification";
+                    readonly referenceType: "Classification";
+                };
+                readonly name: {
+                    readonly name: "name";
+                };
+                readonly value: {
+                    readonly name: "value";
+                };
+            };
+            readonly superTypes: ["AbstractDecision"];
+        };
+        readonly Relationship: {
+            readonly name: "Relationship";
+            readonly properties: {
+                readonly arrow: {
+                    readonly name: "arrow";
+                };
+                readonly left: {
+                    readonly name: "left";
+                };
+                readonly leftPatterns: {
+                    readonly name: "leftPatterns";
+                    readonly defaultValue: [];
+                };
+                readonly right: {
+                    readonly name: "right";
+                };
+                readonly rightPatterns: {
+                    readonly name: "rightPatterns";
+                    readonly defaultValue: [];
+                };
+                readonly type: {
+                    readonly name: "type";
+                };
+            };
+            readonly superTypes: [];
+        };
+        readonly StructureElement: {
+            readonly name: "StructureElement";
+            readonly properties: {};
+            readonly superTypes: [];
+        };
+        readonly Team: {
+            readonly name: "Team";
+            readonly properties: {
+                readonly name: {
+                    readonly name: "name";
+                };
+            };
+            readonly superTypes: ["Type"];
+        };
+        readonly ThisRef: {
+            readonly name: "ThisRef";
+            readonly properties: {
+                readonly link: {
+                    readonly name: "link";
+                    readonly referenceType: "BoundedContext";
+                };
+            };
+            readonly superTypes: ["BoundedContextRef"];
+        };
+        readonly Type: {
+            readonly name: "Type";
+            readonly properties: {};
+            readonly superTypes: ["StructureElement"];
+        };
+    };
+}
+export declare const reflection: DomainLangAstReflection;