/******************************************************************************
 * This file was generated by langium-cli 4.2.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"
    | "C"
    | "CF"
    | "Classification"
    | "Conformist"
    | "ContextMap"
    | "Customer"
    | "Decision"
    | "Domain"
    | "DomainMap"
    | "Import"
    | "Metadata"
    | "Namespace"
    | "OHS"
    | "OpenHostService"
    | "P"
    | "PL"
    | "Partnership"
    | "Policy"
    | "PublishedLanguage"
    | "Rule"
    | "S"
    | "SK"
    | "SW"
    | "SeparateWays"
    | "SharedKernel"
    | "Supplier"
    | "Team"
    | "Term"
    | "["
    | "]"
    | "aka"
    | "archetype"
    | "as"
    | "bc"
    | "businessModel"
    | "by"
    | "classification"
    | "cmap"
    | "contains"
    | "decision"
    | "decisions"
    | "description"
    | "dmap"
    | "dom"
    | "evolution"
    | "examples"
    | "for"
    | "glossary"
    | "import"
    | "in"
    | "integrations"
    | "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.
 * 
 * [Read more on domainlang.net](https://domainlang.net/reference/language#decisions-policies-rules)
 */
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);
}

/**
 * DDD Side Patterns - describe one side's role in a directional relationship.
 * Each pattern produces a distinct AST node type via {infer} actions.
 * Short and long forms parse to the same node type.
 */
export interface AntiCorruptionLayer extends langium.AstNode {
    readonly $container: DirectionalRelationship;
    readonly $type: 'AntiCorruptionLayer';
}

export const AntiCorruptionLayer = {
    $type: 'AntiCorruptionLayer'
} as const;

export function isAntiCorruptionLayer(item: unknown): item is AntiCorruptionLayer {
    return reflection.isInstance(item, AntiCorruptionLayer.$type);
}

/**
 * Assignment operators - flexible syntax.
 */
export type Assignment = ':' | '=' | 'is';

export function isAssignment(item: unknown): item is Assignment {
    return item === ':' || item === 'is' || item === '=';
}

/**
 * DDD Side Patterns - describe one side's role in a directional relationship.
 * Each pattern produces a distinct AST node type via {infer} actions.
 * Short and long forms parse to the same node type.
 */
export interface BigBallOfMud extends langium.AstNode {
    readonly $container: DirectionalRelationship;
    readonly $type: 'BigBallOfMud';
}

export const BigBallOfMud = {
    $type: 'BigBallOfMud'
} as const;

export function isBigBallOfMud(item: unknown): item is BigBallOfMud {
    return reflection.isInstance(item, BigBallOfMud.$type);
}

/**
 * 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).
 * 
 * [Read more on domainlang.net](https://domainlang.net/reference/language#bounded-contexts)
 */
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.
 * 
 * [Read more on domainlang.net](https://domainlang.net/reference/language#classifications)
 */
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);
}

/**
 * DDD Side Patterns - describe one side's role in a directional relationship.
 * Each pattern produces a distinct AST node type via {infer} actions.
 * Short and long forms parse to the same node type.
 */
export interface Conformist extends langium.AstNode {
    readonly $container: DirectionalRelationship;
    readonly $type: 'Conformist';
}

export const Conformist = {
    $type: 'Conformist'
} as const;

export function isConformist(item: unknown): item is Conformist {
    return reflection.isInstance(item, Conformist.$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.
 * 
 * [Read more on domainlang.net](https://domainlang.net/reference/language#context-maps)
 */
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);
}

/**
 * DDD Side Patterns - describe one side's role in a directional relationship.
 * Each pattern produces a distinct AST node type via {infer} actions.
 * Short and long forms parse to the same node type.
 */
export interface Customer extends langium.AstNode {
    readonly $container: DirectionalRelationship;
    readonly $type: 'Customer';
}

export const Customer = {
    $type: 'Customer'
} as const;

export function isCustomer(item: unknown): item is Customer {
    return reflection.isInstance(item, Customer.$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);
}

/**
 * Directional relationship arrows.
 * 
 * Arrow semantics:
 *   ->   Upstream to downstream (left provides, right consumes)
 *   <-   Downstream to upstream (right provides, left consumes)
 *   <->  Bidirectional (mutual data flow with explicit patterns)
 */
export type DirectionalArrow = '->' | '<-' | '<->';

export function isDirectionalArrow(item: unknown): item is DirectionalArrow {
    return item === '<->' || item === '->' || item === '<-';
}

/**
 * Directional relationship - upstream/downstream with optional side patterns.
 * 
 * Examples:
 *   Orders [OHS] -> [CF] Payments
 *   Orders [S] -> [C] Payments
 *   Orders -> Payments
 *   Orders [OHS] <-> [CF] Payments
 */
export interface DirectionalRelationship extends langium.AstNode {
    readonly $container: BoundedContext | ContextMap;
    readonly $type: 'DirectionalRelationship';
    arrow: DirectionalArrow;
    left: BoundedContextRef;
    leftPatterns: Array<SidePattern>;
    right: BoundedContextRef;
    rightPatterns: Array<SidePattern>;
}

export const DirectionalRelationship = {
    $type: 'DirectionalRelationship',
    arrow: 'arrow',
    left: 'left',
    leftPatterns: 'leftPatterns',
    right: 'right',
    rightPatterns: 'rightPatterns'
} as const;

export function isDirectionalRelationship(item: unknown): item is DirectionalRelationship {
    return reflection.isInstance(item, DirectionalRelationship.$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.
 * 
 * [Read more on domainlang.net](https://domainlang.net/reference/language#domains)
 */
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.
 * 
 * [Read more on domainlang.net](https://domainlang.net/reference/language#domain-maps)
 */
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.
 * 
 * [Read more on domainlang.net](https://domainlang.net/reference/language#terminology)
 */
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 - Manifest-centric import system per PRS-010.
 * 
 * Simplified syntax where import statements use short specifiers:
 *   - External dependencies (from manifest): import "core" as Core
 *   - Local files: import "./shared/types.dlang"
 *   - Workspace-relative: import "~/contexts/sales.dlang"
 * 
 * All resolution details (source, version, integrity) live in model.yaml manifest.
 * Named imports and inline integrity checks have been removed per PRS-010.
 * 
 * [Read more on domainlang.net](https://domainlang.net/reference/language#imports)
 */
export interface ImportStatement extends langium.AstNode {
    readonly $container: Model;
    readonly $type: 'ImportStatement';
    alias?: string;
    uri: string;
}

export const ImportStatement = {
    $type: 'ImportStatement',
    alias: 'alias',
    uri: 'uri'
} as const;

export function isImportStatement(item: unknown): item is ImportStatement {
    return reflection.isInstance(item, ImportStatement.$type);
}

/**
 * Metadata - Defines a key that can be used in metadata blocks.
 * Examples: Language, Framework, Database, Repository.
 * Can be defined locally or imported from stdlib.
 * 
 * [Read more on domainlang.net](https://domainlang.net/reference/language#metadata)
 */
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.
 * 
 * [Read more on domainlang.net](https://domainlang.net/reference/language#namespaces)
 */
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);
}

/**
 * DDD Side Patterns - describe one side's role in a directional relationship.
 * Each pattern produces a distinct AST node type via {infer} actions.
 * Short and long forms parse to the same node type.
 */
export interface OpenHostService extends langium.AstNode {
    readonly $container: DirectionalRelationship;
    readonly $type: 'OpenHostService';
}

export const OpenHostService = {
    $type: 'OpenHostService'
} as const;

export function isOpenHostService(item: unknown): item is OpenHostService {
    return reflection.isInstance(item, OpenHostService.$type);
}

/**
 * DDD Symmetric Patterns - describe the relationship between two contexts.
 * These are mutual/shared patterns, not directional.
 */
export interface Partnership extends langium.AstNode {
    readonly $container: SymmetricRelationship;
    readonly $type: 'Partnership';
}

export const Partnership = {
    $type: 'Partnership'
} as const;

export function isPartnership(item: unknown): item is Partnership {
    return reflection.isInstance(item, Partnership.$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);
}

/**
 * DDD Side Patterns - describe one side's role in a directional relationship.
 * Each pattern produces a distinct AST node type via {infer} actions.
 * Short and long forms parse to the same node type.
 */
export interface PublishedLanguage extends langium.AstNode {
    readonly $container: DirectionalRelationship;
    readonly $type: 'PublishedLanguage';
}

export const PublishedLanguage = {
    $type: 'PublishedLanguage'
} as const;

export function isPublishedLanguage(item: unknown): item is PublishedLanguage {
    return reflection.isInstance(item, PublishedLanguage.$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.
 * Uses entity–relationship–entity structure where the relationship expression
 * (type, arrow, side annotations) sits between the two entity references.
 * 
 * Forms:
 *   Directional: Orders [OHS] -> [CF] Payments
 *   Symmetric:   CardManagement [SK] AccountManagement
 *   Separate Ways arrow: Orders >< Payments
 * 
 * [Read more on domainlang.net](https://domainlang.net/reference/language#relationships)
 */
export type Relationship = DirectionalRelationship | SymmetricRelationship;

export const Relationship = {
    $type: 'Relationship'
} as const;

export function isRelationship(item: unknown): item is Relationship {
    return reflection.isInstance(item, Relationship.$type);
}

/**
 * DDD Symmetric Patterns - describe the relationship between two contexts.
 * These are mutual/shared patterns, not directional.
 */
export interface SeparateWays extends langium.AstNode {
    readonly $container: SymmetricRelationship;
    readonly $type: 'SeparateWays';
}

export const SeparateWays = {
    $type: 'SeparateWays'
} as const;

export function isSeparateWays(item: unknown): item is SeparateWays {
    return reflection.isInstance(item, SeparateWays.$type);
}

/**
 * DDD Symmetric Patterns - describe the relationship between two contexts.
 * These are mutual/shared patterns, not directional.
 */
export interface SharedKernel extends langium.AstNode {
    readonly $container: SymmetricRelationship;
    readonly $type: 'SharedKernel';
}

export const SharedKernel = {
    $type: 'SharedKernel'
} as const;

export function isSharedKernel(item: unknown): item is SharedKernel {
    return reflection.isInstance(item, SharedKernel.$type);
}

/**
 * DDD Side Patterns - describe one side's role in a directional relationship.
 * Each pattern produces a distinct AST node type via {infer} actions.
 * Short and long forms parse to the same node type.
 */
export type SidePattern = AntiCorruptionLayer | BigBallOfMud | Conformist | Customer | OpenHostService | PublishedLanguage | Supplier;

export const SidePattern = {
    $type: 'SidePattern'
} as const;

export function isSidePattern(item: unknown): item is SidePattern {
    return reflection.isInstance(item, SidePattern.$type);
}

/**
 * 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);
}

/**
 * DDD Side Patterns - describe one side's role in a directional relationship.
 * Each pattern produces a distinct AST node type via {infer} actions.
 * Short and long forms parse to the same node type.
 */
export interface Supplier extends langium.AstNode {
    readonly $container: DirectionalRelationship;
    readonly $type: 'Supplier';
}

export const Supplier = {
    $type: 'Supplier'
} as const;

export function isSupplier(item: unknown): item is Supplier {
    return reflection.isInstance(item, Supplier.$type);
}

/**
 * DDD Symmetric Patterns - describe the relationship between two contexts.
 * These are mutual/shared patterns, not directional.
 */
export type SymmetricPattern = Partnership | SeparateWays | SharedKernel;

export const SymmetricPattern = {
    $type: 'SymmetricPattern'
} as const;

export function isSymmetricPattern(item: unknown): item is SymmetricPattern {
    return reflection.isInstance(item, SymmetricPattern.$type);
}

/**
 * Symmetric relationship - mutual pattern between two contexts, no directionality.
 * 
 * Examples:
 *   CardManagement [SK] AccountManagement
 *   Orders [P] Payments
 *   Orders >< Payments
 *   Orders [SW] Payments
 */
export interface SymmetricRelationship extends langium.AstNode {
    readonly $container: BoundedContext | ContextMap;
    readonly $type: 'SymmetricRelationship';
    arrow?: '><';
    left: BoundedContextRef;
    pattern?: SymmetricPattern;
    right: BoundedContextRef;
}

export const SymmetricRelationship = {
    $type: 'SymmetricRelationship',
    arrow: 'arrow',
    left: 'left',
    pattern: 'pattern',
    right: 'right'
} as const;

export function isSymmetricRelationship(item: unknown): item is SymmetricRelationship {
    return reflection.isInstance(item, SymmetricRelationship.$type);
}

/**
 * Team - People responsible for a Bounded Context or Domain.
 * Represents organizational boundaries in DDD.
 * 
 * [Read more on domainlang.net](https://domainlang.net/reference/language#teams)
 */
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
    AntiCorruptionLayer: AntiCorruptionLayer
    BigBallOfMud: BigBallOfMud
    BoundedContext: BoundedContext
    BoundedContextRef: BoundedContextRef
    BusinessRule: BusinessRule
    Classification: Classification
    Conformist: Conformist
    Container: Container
    ContextMap: ContextMap
    Customer: Customer
    Decision: Decision
    DirectionalRelationship: DirectionalRelationship
    Domain: Domain
    DomainMap: DomainMap
    DomainTerm: DomainTerm
    ImportStatement: ImportStatement
    Metadata: Metadata
    MetadataEntry: MetadataEntry
    Model: Model
    NamespaceDeclaration: NamespaceDeclaration
    ObjectMap: ObjectMap
    OpenHostService: OpenHostService
    Partnership: Partnership
    Policy: Policy
    PublishedLanguage: PublishedLanguage
    Relationship: Relationship
    SeparateWays: SeparateWays
    SharedKernel: SharedKernel
    SidePattern: SidePattern
    StructureElement: StructureElement
    Supplier: Supplier
    SymmetricPattern: SymmetricPattern
    SymmetricRelationship: SymmetricRelationship
    Team: Team
    ThisRef: ThisRef
    Type: Type
}

export class DomainLangAstReflection extends langium.AbstractAstReflection {
    override readonly types = {
        AbstractDecision: {
            name: AbstractDecision.$type,
            properties: {
            },
            superTypes: []
        },
        AntiCorruptionLayer: {
            name: AntiCorruptionLayer.$type,
            properties: {
            },
            superTypes: [SidePattern.$type]
        },
        BigBallOfMud: {
            name: BigBallOfMud.$type,
            properties: {
            },
            superTypes: [SidePattern.$type]
        },
        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]
        },
        Conformist: {
            name: Conformist.$type,
            properties: {
            },
            superTypes: [SidePattern.$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]
        },
        Customer: {
            name: Customer.$type,
            properties: {
            },
            superTypes: [SidePattern.$type]
        },
        Decision: {
            name: Decision.$type,
            properties: {
                classification: {
                    name: Decision.classification,
                    referenceType: Classification.$type
                },
                name: {
                    name: Decision.name
                },
                value: {
                    name: Decision.value
                }
            },
            superTypes: [AbstractDecision.$type]
        },
        DirectionalRelationship: {
            name: DirectionalRelationship.$type,
            properties: {
                arrow: {
                    name: DirectionalRelationship.arrow
                },
                left: {
                    name: DirectionalRelationship.left
                },
                leftPatterns: {
                    name: DirectionalRelationship.leftPatterns,
                    defaultValue: []
                },
                right: {
                    name: DirectionalRelationship.right
                },
                rightPatterns: {
                    name: DirectionalRelationship.rightPatterns,
                    defaultValue: []
                }
            },
            superTypes: [Relationship.$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
                },
                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]
        },
        OpenHostService: {
            name: OpenHostService.$type,
            properties: {
            },
            superTypes: [SidePattern.$type]
        },
        Partnership: {
            name: Partnership.$type,
            properties: {
            },
            superTypes: [SymmetricPattern.$type]
        },
        Policy: {
            name: Policy.$type,
            properties: {
                classification: {
                    name: Policy.classification,
                    referenceType: Classification.$type
                },
                name: {
                    name: Policy.name
                },
                value: {
                    name: Policy.value
                }
            },
            superTypes: [AbstractDecision.$type]
        },
        PublishedLanguage: {
            name: PublishedLanguage.$type,
            properties: {
            },
            superTypes: [SidePattern.$type]
        },
        Relationship: {
            name: Relationship.$type,
            properties: {
            },
            superTypes: []
        },
        SeparateWays: {
            name: SeparateWays.$type,
            properties: {
            },
            superTypes: [SymmetricPattern.$type]
        },
        SharedKernel: {
            name: SharedKernel.$type,
            properties: {
            },
            superTypes: [SymmetricPattern.$type]
        },
        SidePattern: {
            name: SidePattern.$type,
            properties: {
            },
            superTypes: []
        },
        StructureElement: {
            name: StructureElement.$type,
            properties: {
            },
            superTypes: []
        },
        Supplier: {
            name: Supplier.$type,
            properties: {
            },
            superTypes: [SidePattern.$type]
        },
        SymmetricPattern: {
            name: SymmetricPattern.$type,
            properties: {
            },
            superTypes: []
        },
        SymmetricRelationship: {
            name: SymmetricRelationship.$type,
            properties: {
                arrow: {
                    name: SymmetricRelationship.arrow
                },
                left: {
                    name: SymmetricRelationship.left
                },
                pattern: {
                    name: SymmetricRelationship.pattern
                },
                right: {
                    name: SymmetricRelationship.right
                }
            },
            superTypes: [Relationship.$type]
        },
        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();