@domainlang/language 0.1.81

package/src/generated/ast.ts

@@ -0,0 +1,999 @@
+/******************************************************************************
+ * This file was generated by langium-cli 4.1.0.
+ * DO NOT EDIT MANUALLY!
+ ******************************************************************************/
+
+/* eslint-disable */
+import * as langium from 'langium';
+
+export const DomainLangTerminals = {
+    WS: /\s+/,
+    ID: /[_a-zA-Z][\w_-]*/,
+    STRING: /"(\\.|[^"\\])*"|'(\\.|[^'\\])*'/,
+    ML_COMMENT: /\/\*[\s\S]*?\*\//,
+    SL_COMMENT: /\/\/[^\n\r]*/,
+};
+
+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 const AbstractDecision = {
+    $type: 'AbstractDecision'
+} as const;
+
+export function isAbstractDecision(item: unknown): item is AbstractDecision {
+    return reflection.isInstance(item, AbstractDecision.$type);
+}
+
+/**
+ * Assignment operators - flexible syntax.
+ */
+export type Assignment = ':' | '=' | 'is';
+
+export function isAssignment(item: unknown): item is Assignment {
+    return item === ':' || item === 'is' || item === '=';
+}
+
+/**
+ * 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 const BoundedContext = {
+    $type: 'BoundedContext',
+    archetype: 'archetype',
+    businessModel: 'businessModel',
+    classification: 'classification',
+    decisions: 'decisions',
+    description: 'description',
+    domain: 'domain',
+    evolution: 'evolution',
+    metadata: 'metadata',
+    name: 'name',
+    relationships: 'relationships',
+    team: 'team',
+    terminology: 'terminology'
+} as const;
+
+export function isBoundedContext(item: unknown): item is BoundedContext {
+    return reflection.isInstance(item, BoundedContext.$type);
+}
+
+/**
+ * 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 const BoundedContextRef = {
+    $type: 'BoundedContextRef',
+    link: 'link'
+} as const;
+
+export function isBoundedContextRef(item: unknown): item is BoundedContextRef {
+    return reflection.isInstance(item, BoundedContextRef.$type);
+}
+
+export interface BusinessRule extends langium.AstNode {
+    readonly $container: BoundedContext;
+    readonly $type: 'Assignment' | 'BusinessRule';
+    classification: langium.Reference<Classification>;
+    name: string;
+    value: string;
+}
+
+export const BusinessRule = {
+    $type: 'BusinessRule',
+    classification: 'classification',
+    name: 'name',
+    value: 'value'
+} as const;
+
+export function isBusinessRule(item: unknown): item is BusinessRule {
+    return reflection.isInstance(item, BusinessRule.$type);
+}
+
+/**
+ * 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 const Classification = {
+    $type: 'Classification',
+    name: 'name'
+} as const;
+
+export function isClassification(item: unknown): item is Classification {
+    return reflection.isInstance(item, Classification.$type);
+}
+
+export type Container = Model | NamespaceDeclaration;
+
+export const Container = {
+    $type: 'Container'
+} as const;
+
+export function isContainer(item: unknown): item is Container {
+    return reflection.isInstance(item, Container.$type);
+}
+
+/**
+ * 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 const ContextMap = {
+    $type: 'ContextMap',
+    boundedContexts: 'boundedContexts',
+    name: 'name',
+    relationships: 'relationships'
+} as const;
+
+export function isContextMap(item: unknown): item is ContextMap {
+    return reflection.isInstance(item, ContextMap.$type);
+}
+
+export interface Decision extends langium.AstNode {
+    readonly $container: BoundedContext;
+    readonly $type: 'Assignment' | 'Decision';
+    classification: langium.Reference<Classification>;
+    name: string;
+    value: string;
+}
+
+export const Decision = {
+    $type: 'Decision',
+    classification: 'classification',
+    name: 'name',
+    value: 'value'
+} as const;
+
+export function isDecision(item: unknown): item is Decision {
+    return reflection.isInstance(item, Decision.$type);
+}
+
+/**
+ * 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 const Domain = {
+    $type: 'Domain',
+    description: 'description',
+    name: 'name',
+    parent: 'parent',
+    type: 'type',
+    vision: 'vision'
+} as const;
+
+export function isDomain(item: unknown): item is Domain {
+    return reflection.isInstance(item, Domain.$type);
+}
+
+/**
+ * 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 const DomainMap = {
+    $type: 'DomainMap',
+    domains: 'domains',
+    name: 'name'
+} as const;
+
+export function isDomainMap(item: unknown): item is DomainMap {
+    return reflection.isInstance(item, DomainMap.$type);
+}
+
+/**
+ * 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 const DomainTerm = {
+    $type: 'DomainTerm',
+    examples: 'examples',
+    meaning: 'meaning',
+    name: 'name',
+    synonyms: 'synonyms'
+} as const;
+
+export function isDomainTerm(item: unknown): item is DomainTerm {
+    return reflection.isInstance(item, DomainTerm.$type);
+}
+
+/**
+ * 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 const ImportStatement = {
+    $type: 'ImportStatement',
+    alias: 'alias',
+    integrity: 'integrity',
+    symbols: 'symbols',
+    uri: 'uri'
+} as const;
+
+export function isImportStatement(item: unknown): item is ImportStatement {
+    return reflection.isInstance(item, ImportStatement.$type);
+}
+
+/**
+ * DDD Integration Patterns (used in relationships).
+ */
+export type IntegrationPattern = 'ACL' | 'AntiCorruptionLayer' | 'BBoM' | 'BigBallOfMud' | 'CF' | 'Conformist' | 'OHS' | 'OpenHostService' | 'P' | 'PL' | 'Partnership' | 'PublishedLanguage' | 'SK' | 'SharedKernel';
+
+export function isIntegrationPattern(item: unknown): item is IntegrationPattern {
+    return item === 'PL' || item === 'PublishedLanguage' || item === 'OHS' || item === 'OpenHostService' || item === 'CF' || item === 'Conformist' || item === 'ACL' || item === 'AntiCorruptionLayer' || item === 'P' || item === 'Partnership' || item === 'SK' || item === 'SharedKernel' || item === 'BBoM' || item === 'BigBallOfMud';
+}
+
+/**
+ * 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 const Metadata = {
+    $type: 'Metadata',
+    name: 'name'
+} as const;
+
+export function isMetadata(item: unknown): item is Metadata {
+    return reflection.isInstance(item, Metadata.$type);
+}
+
+export interface MetadataEntry extends langium.AstNode {
+    readonly $container: BoundedContext;
+    readonly $type: 'Assignment' | 'MetadataEntry';
+    key: langium.Reference<Metadata>;
+    value: string;
+}
+
+export const MetadataEntry = {
+    $type: 'MetadataEntry',
+    key: 'key',
+    value: 'value'
+} as const;
+
+export function isMetadataEntry(item: unknown): item is MetadataEntry {
+    return reflection.isInstance(item, MetadataEntry.$type);
+}
+
+/**
+ * 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 const Model = {
+    $type: 'Model',
+    children: 'children',
+    imports: 'imports'
+} as const;
+
+export function isModel(item: unknown): item is Model {
+    return reflection.isInstance(item, Model.$type);
+}
+
+/**
+ * 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 const NamespaceDeclaration = {
+    $type: 'NamespaceDeclaration',
+    children: 'children',
+    name: 'name'
+} as const;
+
+export function isNamespaceDeclaration(item: unknown): item is NamespaceDeclaration {
+    return reflection.isInstance(item, NamespaceDeclaration.$type);
+}
+
+/**
+ * Union of mapping constructs for visualizing architecture.
+ */
+export type ObjectMap = ContextMap | DomainMap;
+
+export const ObjectMap = {
+    $type: 'ObjectMap'
+} as const;
+
+export function isObjectMap(item: unknown): item is ObjectMap {
+    return reflection.isInstance(item, ObjectMap.$type);
+}
+
+export interface Policy extends langium.AstNode {
+    readonly $container: BoundedContext;
+    readonly $type: 'Assignment' | 'Policy';
+    classification: langium.Reference<Classification>;
+    name: string;
+    value: string;
+}
+
+export const Policy = {
+    $type: 'Policy',
+    classification: 'classification',
+    name: 'name',
+    value: 'value'
+} as const;
+
+export function isPolicy(item: unknown): item is Policy {
+    return reflection.isInstance(item, Policy.$type);
+}
+
+/**
+ * Qualified Name - Hierarchical namespacing with dots.
+ */
+export type QualifiedName = string;
+
+export function isQualifiedName(item: unknown): item is QualifiedName {
+    return typeof item === 'string';
+}
+
+/**
+ * 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 const Relationship = {
+    $type: 'Relationship',
+    arrow: 'arrow',
+    left: 'left',
+    leftPatterns: 'leftPatterns',
+    right: 'right',
+    rightPatterns: 'rightPatterns',
+    type: 'type'
+} as const;
+
+export function isRelationship(item: unknown): item is Relationship {
+    return reflection.isInstance(item, Relationship.$type);
+}
+
+/**
+ * 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 function isRelationshipArrow(item: unknown): item is RelationshipArrow {
+    return item === '<->' || item === '->' || item === '<-' || item === '><';
+}
+
+/**
+ * DDD Relationship Types.
+ */
+export type RelationshipType = 'CustomerSupplier' | 'Partnership' | 'SeparateWays' | 'SharedKernel' | 'UpstreamDownstream';
+
+export function isRelationshipType(item: unknown): item is RelationshipType {
+    return item === 'Partnership' || item === 'SharedKernel' || item === 'CustomerSupplier' || item === 'UpstreamDownstream' || item === 'SeparateWays';
+}
+
+/**
+ * Top-level elements that can appear in the model.
+ * Unifies all major DDD constructs for flexible ordering.
+ */
+export type StructureElement = NamespaceDeclaration | ObjectMap | Type;
+
+export const StructureElement = {
+    $type: 'StructureElement'
+} as const;
+
+export function isStructureElement(item: unknown): item is StructureElement {
+    return reflection.isInstance(item, StructureElement.$type);
+}
+
+/**
+ * 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 const Team = {
+    $type: 'Team',
+    name: 'name'
+} as const;
+
+export function isTeam(item: unknown): item is Team {
+    return reflection.isInstance(item, Team.$type);
+}
+
+/**
+ * Context reference - can be 'this' (self-reference) or a qualified name.
+ */
+export interface ThisRef extends BoundedContextRef {
+    readonly $type: 'ThisRef';
+}
+
+export const ThisRef = {
+    $type: 'ThisRef',
+    link: 'link'
+} as const;
+
+export function isThisRef(item: unknown): item is ThisRef {
+    return reflection.isInstance(item, ThisRef.$type);
+}
+
+/**
+ * Union of all main DDD type constructs.
+ */
+export type Type = BoundedContext | Classification | Domain | Metadata | Team;
+
+export const Type = {
+    $type: 'Type'
+} as const;
+
+export function isType(item: unknown): item is Type {
+    return reflection.isInstance(item, Type.$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 class DomainLangAstReflection extends langium.AbstractAstReflection {
+    override readonly types = {
+        AbstractDecision: {
+            name: AbstractDecision.$type,
+            properties: {
+            },
+            superTypes: []
+        },
+        BoundedContext: {
+            name: BoundedContext.$type,
+            properties: {
+                archetype: {
+                    name: BoundedContext.archetype,
+                    referenceType: Classification.$type
+                },
+                businessModel: {
+                    name: BoundedContext.businessModel,
+                    referenceType: Classification.$type
+                },
+                classification: {
+                    name: BoundedContext.classification,
+                    defaultValue: [],
+                    referenceType: Classification.$type
+                },
+                decisions: {
+                    name: BoundedContext.decisions,
+                    defaultValue: []
+                },
+                description: {
+                    name: BoundedContext.description
+                },
+                domain: {
+                    name: BoundedContext.domain,
+                    referenceType: Domain.$type
+                },
+                evolution: {
+                    name: BoundedContext.evolution,
+                    referenceType: Classification.$type
+                },
+                metadata: {
+                    name: BoundedContext.metadata,
+                    defaultValue: []
+                },
+                name: {
+                    name: BoundedContext.name
+                },
+                relationships: {
+                    name: BoundedContext.relationships,
+                    defaultValue: []
+                },
+                team: {
+                    name: BoundedContext.team,
+                    defaultValue: [],
+                    referenceType: Team.$type
+                },
+                terminology: {
+                    name: BoundedContext.terminology,
+                    defaultValue: []
+                }
+            },
+            superTypes: [Type.$type]
+        },
+        BoundedContextRef: {
+            name: BoundedContextRef.$type,
+            properties: {
+                link: {
+                    name: BoundedContextRef.link,
+                    referenceType: BoundedContext.$type
+                }
+            },
+            superTypes: []
+        },
+        BusinessRule: {
+            name: BusinessRule.$type,
+            properties: {
+                classification: {
+                    name: BusinessRule.classification,
+                    referenceType: Classification.$type
+                },
+                name: {
+                    name: BusinessRule.name
+                },
+                value: {
+                    name: BusinessRule.value
+                }
+            },
+            superTypes: [AbstractDecision.$type]
+        },
+        Classification: {
+            name: Classification.$type,
+            properties: {
+                name: {
+                    name: Classification.name
+                }
+            },
+            superTypes: [Type.$type]
+        },
+        Container: {
+            name: Container.$type,
+            properties: {
+            },
+            superTypes: []
+        },
+        ContextMap: {
+            name: ContextMap.$type,
+            properties: {
+                boundedContexts: {
+                    name: ContextMap.boundedContexts,
+                    defaultValue: [],
+                    referenceType: BoundedContext.$type
+                },
+                name: {
+                    name: ContextMap.name
+                },
+                relationships: {
+                    name: ContextMap.relationships,
+                    defaultValue: []
+                }
+            },
+            superTypes: [ObjectMap.$type]
+        },
+        Decision: {
+            name: Decision.$type,
+            properties: {
+                classification: {
+                    name: Decision.classification,
+                    referenceType: Classification.$type
+                },
+                name: {
+                    name: Decision.name
+                },
+                value: {
+                    name: Decision.value
+                }
+            },
+            superTypes: [AbstractDecision.$type]
+        },
+        Domain: {
+            name: Domain.$type,
+            properties: {
+                description: {
+                    name: Domain.description
+                },
+                name: {
+                    name: Domain.name
+                },
+                parent: {
+                    name: Domain.parent,
+                    referenceType: Domain.$type
+                },
+                type: {
+                    name: Domain.type,
+                    referenceType: Classification.$type
+                },
+                vision: {
+                    name: Domain.vision
+                }
+            },
+            superTypes: [Type.$type]
+        },
+        DomainMap: {
+            name: DomainMap.$type,
+            properties: {
+                domains: {
+                    name: DomainMap.domains,
+                    defaultValue: [],
+                    referenceType: Domain.$type
+                },
+                name: {
+                    name: DomainMap.name
+                }
+            },
+            superTypes: [ObjectMap.$type]
+        },
+        DomainTerm: {
+            name: DomainTerm.$type,
+            properties: {
+                examples: {
+                    name: DomainTerm.examples,
+                    defaultValue: []
+                },
+                meaning: {
+                    name: DomainTerm.meaning
+                },
+                name: {
+                    name: DomainTerm.name
+                },
+                synonyms: {
+                    name: DomainTerm.synonyms,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        ImportStatement: {
+            name: ImportStatement.$type,
+            properties: {
+                alias: {
+                    name: ImportStatement.alias
+                },
+                integrity: {
+                    name: ImportStatement.integrity
+                },
+                symbols: {
+                    name: ImportStatement.symbols,
+                    defaultValue: []
+                },
+                uri: {
+                    name: ImportStatement.uri
+                }
+            },
+            superTypes: []
+        },
+        Metadata: {
+            name: Metadata.$type,
+            properties: {
+                name: {
+                    name: Metadata.name
+                }
+            },
+            superTypes: [Type.$type]
+        },
+        MetadataEntry: {
+            name: MetadataEntry.$type,
+            properties: {
+                key: {
+                    name: MetadataEntry.key,
+                    referenceType: Metadata.$type
+                },
+                value: {
+                    name: MetadataEntry.value
+                }
+            },
+            superTypes: []
+        },
+        Model: {
+            name: Model.$type,
+            properties: {
+                children: {
+                    name: Model.children,
+                    defaultValue: []
+                },
+                imports: {
+                    name: Model.imports,
+                    defaultValue: []
+                }
+            },
+            superTypes: [Container.$type]
+        },
+        NamespaceDeclaration: {
+            name: NamespaceDeclaration.$type,
+            properties: {
+                children: {
+                    name: NamespaceDeclaration.children,
+                    defaultValue: []
+                },
+                name: {
+                    name: NamespaceDeclaration.name
+                }
+            },
+            superTypes: [Container.$type, StructureElement.$type]
+        },
+        ObjectMap: {
+            name: ObjectMap.$type,
+            properties: {
+            },
+            superTypes: [StructureElement.$type]
+        },
+        Policy: {
+            name: Policy.$type,
+            properties: {
+                classification: {
+                    name: Policy.classification,
+                    referenceType: Classification.$type
+                },
+                name: {
+                    name: Policy.name
+                },
+                value: {
+                    name: Policy.value
+                }
+            },
+            superTypes: [AbstractDecision.$type]
+        },
+        Relationship: {
+            name: Relationship.$type,
+            properties: {
+                arrow: {
+                    name: Relationship.arrow
+                },
+                left: {
+                    name: Relationship.left
+                },
+                leftPatterns: {
+                    name: Relationship.leftPatterns,
+                    defaultValue: []
+                },
+                right: {
+                    name: Relationship.right
+                },
+                rightPatterns: {
+                    name: Relationship.rightPatterns,
+                    defaultValue: []
+                },
+                type: {
+                    name: Relationship.type
+                }
+            },
+            superTypes: []
+        },
+        StructureElement: {
+            name: StructureElement.$type,
+            properties: {
+            },
+            superTypes: []
+        },
+        Team: {
+            name: Team.$type,
+            properties: {
+                name: {
+                    name: Team.name
+                }
+            },
+            superTypes: [Type.$type]
+        },
+        ThisRef: {
+            name: ThisRef.$type,
+            properties: {
+                link: {
+                    name: ThisRef.link,
+                    referenceType: BoundedContext.$type
+                }
+            },
+            superTypes: [BoundedContextRef.$type]
+        },
+        Type: {
+            name: Type.$type,
+            properties: {
+            },
+            superTypes: [StructureElement.$type]
+        }
+    } as const satisfies langium.AstMetaData
+}
+
+export const reflection = new DomainLangAstReflection();