@fornari-lanza/domain-design-language-language 0.0.1

package/src/generated/ast.ts

@@ -0,0 +1,1737 @@
+/******************************************************************************
+ * This file was generated by langium-cli 4.0.0.
+ * DO NOT EDIT MANUALLY!
+ ******************************************************************************/
+
+/* eslint-disable */
+import * as langium from 'langium';
+
+export const DomainDesignLanguageTerminals = {
+    WS: /\s+/,
+    ID: /[_a-zA-Z][\w_]*/,
+    STRING: /"(\\.|[^"\\])*"|'(\\.|[^'\\])*'/,
+    ML_COMMENT: /\/\*[\s\S]*?\*\//,
+    SL_COMMENT: /\/\/[^\n\r]*/,
+};
+
+export type DomainDesignLanguageTerminalNames = keyof typeof DomainDesignLanguageTerminals;
+
+export type DomainDesignLanguageKeywordNames =
+    | "("
+    | ")"
+    | ","
+    | "."
+    | ":"
+    | "Actor"
+    | "AggregateRoot"
+    | "AntiCorruptionLayer"
+    | "BoundedContext"
+    | "Command"
+    | "Conformist"
+    | "ContextMap"
+    | "Customer/Supplier"
+    | "DomainEvents"
+    | "DomainExceptions"
+    | "DomainService"
+    | "Entity"
+    | "Enum"
+    | "EventStorming"
+    | "ExternalSystem"
+    | "Methods"
+    | "OpenHostService"
+    | "Partnership"
+    | "Policy"
+    | "Port"
+    | "ProcessFlow"
+    | "PublishedLanguage"
+    | "ReadModel"
+    | "Relationship"
+    | "SharedKernel"
+    | "UID"
+    | "UbiquitousLanguage"
+    | "ValueObject"
+    | "["
+    | "]"
+    | "aliases:"
+    | "and"
+    | "between"
+    | "boolean"
+    | "calculation"
+    | "contract"
+    | "coordination"
+    | "correctivePolicies:"
+    | "date"
+    | "definition:"
+    | "dependencies:"
+    | "downstream:"
+    | "emits"
+    | "enforcedInvariants:"
+    | "given"
+    | "hotspot"
+    | "input:"
+    | "invokes"
+    | "issues"
+    | "many"
+    | "number"
+    | "on"
+    | "optional"
+    | "payload:"
+    | "projects"
+    | "response:"
+    | "string"
+    | "then"
+    | "to"
+    | "triggers"
+    | "type:"
+    | "upstream:"
+    | "uses"
+    | "views"
+    | "{"
+    | "}";
+
+export type DomainDesignLanguageTokenNames = DomainDesignLanguageTerminalNames | DomainDesignLanguageKeywordNames;
+
+export interface Actor extends langium.AstNode {
+    readonly $container: EventStormingDeclaration;
+    readonly $type: 'Actor';
+    description?: string;
+    name: string;
+}
+
+export const Actor = {
+    $type: 'Actor',
+    description: 'description',
+    name: 'name'
+} as const;
+
+export function isActor(item: unknown): item is Actor {
+    return reflection.isInstance(item, Actor.$type);
+}
+
+export interface ActorCommandStep extends langium.AstNode {
+    readonly $container: ProcessFlow;
+    readonly $type: 'ActorCommandStep';
+    command: langium.Reference<Command>;
+    issuer: langium.Reference<Actor>;
+}
+
+export const ActorCommandStep = {
+    $type: 'ActorCommandStep',
+    command: 'command',
+    issuer: 'issuer'
+} as const;
+
+export function isActorCommandStep(item: unknown): item is ActorCommandStep {
+    return reflection.isInstance(item, ActorCommandStep.$type);
+}
+
+export interface AggregateAttribute extends langium.AstNode {
+    readonly $container: AggregateRoot;
+    readonly $type: 'AggregateAttribute';
+    many: boolean;
+    optional: boolean;
+    type: Entity | Reference | ValueObject;
+}
+
+export const AggregateAttribute = {
+    $type: 'AggregateAttribute',
+    many: 'many',
+    optional: 'optional',
+    type: 'type'
+} as const;
+
+export function isAggregateAttribute(item: unknown): item is AggregateAttribute {
+    return reflection.isInstance(item, AggregateAttribute.$type);
+}
+
+export interface AggregateRoot extends langium.AstNode {
+    readonly $container: BoundedContext;
+    readonly $type: 'AggregateRoot';
+    attributes: Array<AggregateAttribute>;
+    correctivePolicies: Array<string>;
+    description: string;
+    enforcedInvariants: Array<string>;
+    events?: DomainEventsDeclaration;
+    exceptions?: ExceptionsDeclaration;
+    id: UID;
+    methods?: MethodsDeclaration;
+    name: string;
+}
+
+export const AggregateRoot = {
+    $type: 'AggregateRoot',
+    attributes: 'attributes',
+    correctivePolicies: 'correctivePolicies',
+    description: 'description',
+    enforcedInvariants: 'enforcedInvariants',
+    events: 'events',
+    exceptions: 'exceptions',
+    id: 'id',
+    methods: 'methods',
+    name: 'name'
+} as const;
+
+export function isAggregateRoot(item: unknown): item is AggregateRoot {
+    return reflection.isInstance(item, AggregateRoot.$type);
+}
+
+export interface AsymmetricRelationship extends langium.AstNode {
+    readonly $container: ContextMap;
+    readonly $type: 'AsymmetricRelationship';
+    customerSupplier: boolean;
+    description?: string;
+    downstream: langium.Reference<BoundedContext>;
+    downstreamRole?: DownstreamRole;
+    upstream: langium.Reference<BoundedContext>;
+    upstreamRoles: Array<UpstreamRole>;
+}
+
+export const AsymmetricRelationship = {
+    $type: 'AsymmetricRelationship',
+    customerSupplier: 'customerSupplier',
+    description: 'description',
+    downstream: 'downstream',
+    downstreamRole: 'downstreamRole',
+    upstream: 'upstream',
+    upstreamRoles: 'upstreamRoles'
+} as const;
+
+export function isAsymmetricRelationship(item: unknown): item is AsymmetricRelationship {
+    return reflection.isInstance(item, AsymmetricRelationship.$type);
+}
+
+export interface BoundedContext extends langium.AstNode {
+    readonly $container: DomainModel;
+    readonly $type: 'BoundedContext';
+    aggregates: Array<AggregateRoot>;
+    commands: Array<Command>;
+    description: string;
+    domainServices: Array<DomainService>;
+    eventStorming?: EventStormingDeclaration;
+    name: string;
+    ports: Array<Port>;
+    ubiquitousLanguage: UbiquitousLanguageDeclaration;
+}
+
+export const BoundedContext = {
+    $type: 'BoundedContext',
+    aggregates: 'aggregates',
+    commands: 'commands',
+    description: 'description',
+    domainServices: 'domainServices',
+    eventStorming: 'eventStorming',
+    name: 'name',
+    ports: 'ports',
+    ubiquitousLanguage: 'ubiquitousLanguage'
+} as const;
+
+export function isBoundedContext(item: unknown): item is BoundedContext {
+    return reflection.isInstance(item, BoundedContext.$type);
+}
+
+export interface Command extends langium.AstNode {
+    readonly $container: BoundedContext;
+    readonly $type: 'Command';
+    aggregate: langium.Reference<AggregateRoot>;
+    dependencies: Array<Dependency>;
+    description?: string;
+    domainServices: Array<langium.Reference<DomainService>>;
+    events: Array<langium.Reference<DomainEvent>>;
+    input?: InputDTO;
+    name: string;
+    response?: ResponseDTO;
+}
+
+export const Command = {
+    $type: 'Command',
+    aggregate: 'aggregate',
+    dependencies: 'dependencies',
+    description: 'description',
+    domainServices: 'domainServices',
+    events: 'events',
+    input: 'input',
+    name: 'name',
+    response: 'response'
+} as const;
+
+export function isCommand(item: unknown): item is Command {
+    return reflection.isInstance(item, Command.$type);
+}
+
+export interface ContextMap extends langium.AstNode {
+    readonly $container: DomainModel;
+    readonly $type: 'ContextMap';
+    relationships: Array<Relationship>;
+}
+
+export const ContextMap = {
+    $type: 'ContextMap',
+    relationships: 'relationships'
+} as const;
+
+export function isContextMap(item: unknown): item is ContextMap {
+    return reflection.isInstance(item, ContextMap.$type);
+}
+
+export interface Dependency extends langium.AstNode {
+    readonly $container: Command;
+    readonly $type: 'Dependency';
+    port: langium.Reference<Port>;
+}
+
+export const Dependency = {
+    $type: 'Dependency',
+    port: 'port'
+} as const;
+
+export function isDependency(item: unknown): item is Dependency {
+    return reflection.isInstance(item, Dependency.$type);
+}
+
+export interface DomainAttribute extends langium.AstNode {
+    readonly $container: DomainServiceInput | DomainServiceResponse | MethodInput;
+    readonly $type: 'DomainAttribute';
+    many: boolean;
+    name: string;
+    optional: boolean;
+    type: langium.Reference<DomainObject>;
+}
+
+export const DomainAttribute = {
+    $type: 'DomainAttribute',
+    many: 'many',
+    name: 'name',
+    optional: 'optional',
+    type: 'type'
+} as const;
+
+export function isDomainAttribute(item: unknown): item is DomainAttribute {
+    return reflection.isInstance(item, DomainAttribute.$type);
+}
+
+export interface DomainEvent extends langium.AstNode {
+    readonly $container: DomainEventsDeclaration;
+    readonly $type: 'DomainEvent';
+    description?: string;
+    name: string;
+    payload?: Payload;
+}
+
+export const DomainEvent = {
+    $type: 'DomainEvent',
+    description: 'description',
+    name: 'name',
+    payload: 'payload'
+} as const;
+
+export function isDomainEvent(item: unknown): item is DomainEvent {
+    return reflection.isInstance(item, DomainEvent.$type);
+}
+
+export interface DomainEventsDeclaration extends langium.AstNode {
+    readonly $container: AggregateRoot;
+    readonly $type: 'DomainEventsDeclaration';
+    events: Array<DomainEvent>;
+}
+
+export const DomainEventsDeclaration = {
+    $type: 'DomainEventsDeclaration',
+    events: 'events'
+} as const;
+
+export function isDomainEventsDeclaration(item: unknown): item is DomainEventsDeclaration {
+    return reflection.isInstance(item, DomainEventsDeclaration.$type);
+}
+
+export interface DomainException extends langium.AstNode {
+    readonly $container: ExceptionsDeclaration;
+    readonly $type: 'DomainException';
+    description?: string;
+    name: string;
+}
+
+export const DomainException = {
+    $type: 'DomainException',
+    description: 'description',
+    name: 'name'
+} as const;
+
+export function isDomainException(item: unknown): item is DomainException {
+    return reflection.isInstance(item, DomainException.$type);
+}
+
+export interface DomainModel extends langium.AstNode {
+    readonly $type: 'DomainModel';
+    boundedContext?: BoundedContext;
+    contextMap?: ContextMap;
+}
+
+export const DomainModel = {
+    $type: 'DomainModel',
+    boundedContext: 'boundedContext',
+    contextMap: 'contextMap'
+} as const;
+
+export function isDomainModel(item: unknown): item is DomainModel {
+    return reflection.isInstance(item, DomainModel.$type);
+}
+
+export type DomainObject = AggregateRoot | Entity | ValueObject;
+
+export const DomainObject = {
+    $type: 'DomainObject'
+} as const;
+
+export function isDomainObject(item: unknown): item is DomainObject {
+    return reflection.isInstance(item, DomainObject.$type);
+}
+
+export interface DomainService extends langium.AstNode {
+    readonly $container: BoundedContext;
+    readonly $type: 'DomainService';
+    description: string;
+    input?: DomainServiceInput;
+    name: string;
+    response?: DomainServiceResponse;
+    type: 'calculation' | 'contract' | 'coordination';
+}
+
+export const DomainService = {
+    $type: 'DomainService',
+    description: 'description',
+    input: 'input',
+    name: 'name',
+    response: 'response',
+    type: 'type'
+} as const;
+
+export function isDomainService(item: unknown): item is DomainService {
+    return reflection.isInstance(item, DomainService.$type);
+}
+
+export interface DomainServiceInput extends langium.AstNode {
+    readonly $container: DomainService;
+    readonly $type: 'DomainServiceInput';
+    attributes: Array<DomainAttribute>;
+}
+
+export const DomainServiceInput = {
+    $type: 'DomainServiceInput',
+    attributes: 'attributes'
+} as const;
+
+export function isDomainServiceInput(item: unknown): item is DomainServiceInput {
+    return reflection.isInstance(item, DomainServiceInput.$type);
+}
+
+export interface DomainServiceResponse extends langium.AstNode {
+    readonly $container: DomainService;
+    readonly $type: 'DomainServiceResponse';
+    attributes: Array<DomainAttribute | PrimitiveAttribute>;
+}
+
+export const DomainServiceResponse = {
+    $type: 'DomainServiceResponse',
+    attributes: 'attributes'
+} as const;
+
+export function isDomainServiceResponse(item: unknown): item is DomainServiceResponse {
+    return reflection.isInstance(item, DomainServiceResponse.$type);
+}
+
+export type DownstreamRole = 'AntiCorruptionLayer' | 'Conformist';
+
+export function isDownstreamRole(item: unknown): item is DownstreamRole {
+    return item === 'AntiCorruptionLayer' || item === 'Conformist';
+}
+
+export interface Entity extends langium.AstNode {
+    readonly $container: AggregateAttribute;
+    readonly $type: 'Entity';
+    attributes: Array<EntityAttribute>;
+    description: string;
+    id: UID;
+    name: string;
+}
+
+export const Entity = {
+    $type: 'Entity',
+    attributes: 'attributes',
+    description: 'description',
+    id: 'id',
+    name: 'name'
+} as const;
+
+export function isEntity(item: unknown): item is Entity {
+    return reflection.isInstance(item, Entity.$type);
+}
+
+export interface EntityAttribute extends langium.AstNode {
+    readonly $container: Entity;
+    readonly $type: 'EntityAttribute';
+    many: boolean;
+    optional: boolean;
+    type: Reference | ValueObject;
+}
+
+export const EntityAttribute = {
+    $type: 'EntityAttribute',
+    many: 'many',
+    optional: 'optional',
+    type: 'type'
+} as const;
+
+export function isEntityAttribute(item: unknown): item is EntityAttribute {
+    return reflection.isInstance(item, EntityAttribute.$type);
+}
+
+export interface Enum extends langium.AstNode {
+    readonly $container: PrimitiveAttribute;
+    readonly $type: 'Enum';
+    values: Array<string>;
+}
+
+export const Enum = {
+    $type: 'Enum',
+    values: 'values'
+} as const;
+
+export function isEnum(item: unknown): item is Enum {
+    return reflection.isInstance(item, Enum.$type);
+}
+
+export interface EventStormingDeclaration extends langium.AstNode {
+    readonly $container: BoundedContext;
+    readonly $type: 'EventStormingDeclaration';
+    elements: Array<EventStormingElement>;
+    flows: Array<ProcessFlow>;
+}
+
+export const EventStormingDeclaration = {
+    $type: 'EventStormingDeclaration',
+    elements: 'elements',
+    flows: 'flows'
+} as const;
+
+export function isEventStormingDeclaration(item: unknown): item is EventStormingDeclaration {
+    return reflection.isInstance(item, EventStormingDeclaration.$type);
+}
+
+export type EventStormingElement = Actor | ExternalSystem | ReadModel;
+
+export const EventStormingElement = {
+    $type: 'EventStormingElement'
+} as const;
+
+export function isEventStormingElement(item: unknown): item is EventStormingElement {
+    return reflection.isInstance(item, EventStormingElement.$type);
+}
+
+export interface ExceptionsDeclaration extends langium.AstNode {
+    readonly $container: AggregateRoot;
+    readonly $type: 'ExceptionsDeclaration';
+    exceptions: Array<DomainException>;
+}
+
+export const ExceptionsDeclaration = {
+    $type: 'ExceptionsDeclaration',
+    exceptions: 'exceptions'
+} as const;
+
+export function isExceptionsDeclaration(item: unknown): item is ExceptionsDeclaration {
+    return reflection.isInstance(item, ExceptionsDeclaration.$type);
+}
+
+export interface ExternalSystem extends langium.AstNode {
+    readonly $container: EventStormingDeclaration;
+    readonly $type: 'ExternalSystem';
+    description?: string;
+    name: string;
+}
+
+export const ExternalSystem = {
+    $type: 'ExternalSystem',
+    description: 'description',
+    name: 'name'
+} as const;
+
+export function isExternalSystem(item: unknown): item is ExternalSystem {
+    return reflection.isInstance(item, ExternalSystem.$type);
+}
+
+export interface GivenStep extends langium.AstNode {
+    readonly $container: ProcessFlow;
+    readonly $type: 'GivenStep';
+    actor: langium.Reference<Actor>;
+    readModel: langium.Reference<ReadModel>;
+}
+
+export const GivenStep = {
+    $type: 'GivenStep',
+    actor: 'actor',
+    readModel: 'readModel'
+} as const;
+
+export function isGivenStep(item: unknown): item is GivenStep {
+    return reflection.isInstance(item, GivenStep.$type);
+}
+
+export type IDType = 'number' | 'string';
+
+export function isIDType(item: unknown): item is IDType {
+    return item === 'string' || item === 'number';
+}
+
+export interface InputDTO extends langium.AstNode {
+    readonly $container: Command;
+    readonly $type: 'InputDTO';
+    attributes: Array<PrimitiveAttribute>;
+}
+
+export const InputDTO = {
+    $type: 'InputDTO',
+    attributes: 'attributes'
+} as const;
+
+export function isInputDTO(item: unknown): item is InputDTO {
+    return reflection.isInstance(item, InputDTO.$type);
+}
+
+export interface Method extends langium.AstNode {
+    readonly $container: MethodsDeclaration;
+    readonly $type: 'Method';
+    description?: string;
+    input?: MethodInput;
+    name: string;
+}
+
+export const Method = {
+    $type: 'Method',
+    description: 'description',
+    input: 'input',
+    name: 'name'
+} as const;
+
+export function isMethod(item: unknown): item is Method {
+    return reflection.isInstance(item, Method.$type);
+}
+
+export interface MethodInput extends langium.AstNode {
+    readonly $container: Method;
+    readonly $type: 'MethodInput';
+    attributes: Array<DomainAttribute>;
+}
+
+export const MethodInput = {
+    $type: 'MethodInput',
+    attributes: 'attributes'
+} as const;
+
+export function isMethodInput(item: unknown): item is MethodInput {
+    return reflection.isInstance(item, MethodInput.$type);
+}
+
+export interface MethodsDeclaration extends langium.AstNode {
+    readonly $container: AggregateRoot;
+    readonly $type: 'MethodsDeclaration';
+    methods: Array<Method>;
+}
+
+export const MethodsDeclaration = {
+    $type: 'MethodsDeclaration',
+    methods: 'methods'
+} as const;
+
+export function isMethodsDeclaration(item: unknown): item is MethodsDeclaration {
+    return reflection.isInstance(item, MethodsDeclaration.$type);
+}
+
+export interface Payload extends langium.AstNode {
+    readonly $container: DomainEvent;
+    readonly $type: 'Payload';
+    attributes: Array<PrimitiveAttribute>;
+}
+
+export const Payload = {
+    $type: 'Payload',
+    attributes: 'attributes'
+} as const;
+
+export function isPayload(item: unknown): item is Payload {
+    return reflection.isInstance(item, Payload.$type);
+}
+
+export interface Policy extends langium.AstNode {
+    readonly $container: PolicyTrigger;
+    readonly $type: 'Policy';
+    command: langium.Reference<Command>;
+    description?: string;
+    name: string;
+}
+
+export const Policy = {
+    $type: 'Policy',
+    command: 'command',
+    description: 'description',
+    name: 'name'
+} as const;
+
+export function isPolicy(item: unknown): item is Policy {
+    return reflection.isInstance(item, Policy.$type);
+}
+
+export interface PolicyTrigger extends langium.AstNode {
+    readonly $container: ReactionStep;
+    readonly $type: 'PolicyTrigger';
+    hotspot?: string;
+    policy: Policy;
+}
+
+export const PolicyTrigger = {
+    $type: 'PolicyTrigger',
+    hotspot: 'hotspot',
+    policy: 'policy'
+} as const;
+
+export function isPolicyTrigger(item: unknown): item is PolicyTrigger {
+    return reflection.isInstance(item, PolicyTrigger.$type);
+}
+
+export interface Port extends langium.AstNode {
+    readonly $container: BoundedContext;
+    readonly $type: 'Port';
+    description?: string;
+    name: string;
+}
+
+export const Port = {
+    $type: 'Port',
+    description: 'description',
+    name: 'name'
+} as const;
+
+export function isPort(item: unknown): item is Port {
+    return reflection.isInstance(item, Port.$type);
+}
+
+export type Primitive = 'boolean' | 'date' | 'number' | 'string';
+
+export function isPrimitive(item: unknown): item is Primitive {
+    return item === 'string' || item === 'number' || item === 'boolean' || item === 'date';
+}
+
+export interface PrimitiveAttribute extends langium.AstNode {
+    readonly $container: DomainServiceResponse | InputDTO | Payload | ResponseDTO | ValueObject;
+    readonly $type: 'PrimitiveAttribute';
+    many: boolean;
+    name: string;
+    optional: boolean;
+    type: Enum | Primitive;
+}
+
+export const PrimitiveAttribute = {
+    $type: 'PrimitiveAttribute',
+    many: 'many',
+    name: 'name',
+    optional: 'optional',
+    type: 'type'
+} as const;
+
+export function isPrimitiveAttribute(item: unknown): item is PrimitiveAttribute {
+    return reflection.isInstance(item, PrimitiveAttribute.$type);
+}
+
+export interface ProcessFlow extends langium.AstNode {
+    readonly $container: EventStormingDeclaration;
+    readonly $type: 'ProcessFlow';
+    command: ActorCommandStep;
+    description?: string;
+    given?: GivenStep;
+    name: string;
+    reactions: Array<ReactionStep>;
+}
+
+export const ProcessFlow = {
+    $type: 'ProcessFlow',
+    command: 'command',
+    description: 'description',
+    given: 'given',
+    name: 'name',
+    reactions: 'reactions'
+} as const;
+
+export function isProcessFlow(item: unknown): item is ProcessFlow {
+    return reflection.isInstance(item, ProcessFlow.$type);
+}
+
+export interface Projection extends langium.AstNode {
+    readonly $container: ReactionStep;
+    readonly $type: 'Projection';
+    hotspot?: string;
+    readModel: langium.Reference<ReadModel>;
+}
+
+export const Projection = {
+    $type: 'Projection',
+    hotspot: 'hotspot',
+    readModel: 'readModel'
+} as const;
+
+export function isProjection(item: unknown): item is Projection {
+    return reflection.isInstance(item, Projection.$type);
+}
+
+export type QualifiedName = string;
+
+export function isQualifiedName(item: unknown): item is QualifiedName {
+    return typeof item === 'string';
+}
+
+export type ReactionOutcome = PolicyTrigger | Projection;
+
+export const ReactionOutcome = {
+    $type: 'ReactionOutcome'
+} as const;
+
+export function isReactionOutcome(item: unknown): item is ReactionOutcome {
+    return reflection.isInstance(item, ReactionOutcome.$type);
+}
+
+export interface ReactionStep extends langium.AstNode {
+    readonly $container: ProcessFlow;
+    readonly $type: 'ReactionStep';
+    outcomes: Array<ReactionOutcome>;
+    trigger: langium.Reference<DomainEvent>;
+}
+
+export const ReactionStep = {
+    $type: 'ReactionStep',
+    outcomes: 'outcomes',
+    trigger: 'trigger'
+} as const;
+
+export function isReactionStep(item: unknown): item is ReactionStep {
+    return reflection.isInstance(item, ReactionStep.$type);
+}
+
+export interface ReadModel extends langium.AstNode {
+    readonly $container: EventStormingDeclaration;
+    readonly $type: 'ReadModel';
+    description?: string;
+    name: string;
+}
+
+export const ReadModel = {
+    $type: 'ReadModel',
+    description: 'description',
+    name: 'name'
+} as const;
+
+export function isReadModel(item: unknown): item is ReadModel {
+    return reflection.isInstance(item, ReadModel.$type);
+}
+
+export interface Reference extends langium.AstNode {
+    readonly $container: AggregateAttribute | EntityAttribute;
+    readonly $type: 'Reference';
+    name: string;
+    to: langium.Reference<AggregateRoot>;
+}
+
+export const Reference = {
+    $type: 'Reference',
+    name: 'name',
+    to: 'to'
+} as const;
+
+export function isReference(item: unknown): item is Reference {
+    return reflection.isInstance(item, Reference.$type);
+}
+
+export type Relationship = AsymmetricRelationship | SymmetricRelationship;
+
+export const Relationship = {
+    $type: 'Relationship'
+} as const;
+
+export function isRelationship(item: unknown): item is Relationship {
+    return reflection.isInstance(item, Relationship.$type);
+}
+
+export interface ResponseDTO extends langium.AstNode {
+    readonly $container: Command;
+    readonly $type: 'ResponseDTO';
+    attributes: Array<PrimitiveAttribute>;
+}
+
+export const ResponseDTO = {
+    $type: 'ResponseDTO',
+    attributes: 'attributes'
+} as const;
+
+export function isResponseDTO(item: unknown): item is ResponseDTO {
+    return reflection.isInstance(item, ResponseDTO.$type);
+}
+
+export interface SymmetricRelationship extends langium.AstNode {
+    readonly $container: ContextMap;
+    readonly $type: 'SymmetricRelationship';
+    description?: string;
+    participant1: langium.Reference<BoundedContext>;
+    participant2: langium.Reference<BoundedContext>;
+    type: 'Partnership' | 'SharedKernel';
+}
+
+export const SymmetricRelationship = {
+    $type: 'SymmetricRelationship',
+    description: 'description',
+    participant1: 'participant1',
+    participant2: 'participant2',
+    type: 'type'
+} as const;
+
+export function isSymmetricRelationship(item: unknown): item is SymmetricRelationship {
+    return reflection.isInstance(item, SymmetricRelationship.$type);
+}
+
+export interface Term extends langium.AstNode {
+    readonly $container: UbiquitousLanguageDeclaration;
+    readonly $type: 'Term';
+    aliases: Array<string>;
+    definition: string;
+    name: string;
+}
+
+export const Term = {
+    $type: 'Term',
+    aliases: 'aliases',
+    definition: 'definition',
+    name: 'name'
+} as const;
+
+export function isTerm(item: unknown): item is Term {
+    return reflection.isInstance(item, Term.$type);
+}
+
+export interface UbiquitousLanguageDeclaration extends langium.AstNode {
+    readonly $container: BoundedContext;
+    readonly $type: 'UbiquitousLanguageDeclaration';
+    terms: Array<Term>;
+}
+
+export const UbiquitousLanguageDeclaration = {
+    $type: 'UbiquitousLanguageDeclaration',
+    terms: 'terms'
+} as const;
+
+export function isUbiquitousLanguageDeclaration(item: unknown): item is UbiquitousLanguageDeclaration {
+    return reflection.isInstance(item, UbiquitousLanguageDeclaration.$type);
+}
+
+export interface UID extends langium.AstNode {
+    readonly $container: AggregateRoot | Entity;
+    readonly $type: 'UID';
+    enforcedInvariants: Array<string>;
+    type: IDType;
+}
+
+export const UID = {
+    $type: 'UID',
+    enforcedInvariants: 'enforcedInvariants',
+    type: 'type'
+} as const;
+
+export function isUID(item: unknown): item is UID {
+    return reflection.isInstance(item, UID.$type);
+}
+
+export type UpstreamRole = 'OpenHostService' | 'PublishedLanguage';
+
+export function isUpstreamRole(item: unknown): item is UpstreamRole {
+    return item === 'OpenHostService' || item === 'PublishedLanguage';
+}
+
+export interface ValueObject extends langium.AstNode {
+    readonly $container: AggregateAttribute | EntityAttribute;
+    readonly $type: 'ValueObject';
+    attributes: Array<PrimitiveAttribute>;
+    description?: string;
+    enforcedInvariants: Array<string>;
+    name: string;
+}
+
+export const ValueObject = {
+    $type: 'ValueObject',
+    attributes: 'attributes',
+    description: 'description',
+    enforcedInvariants: 'enforcedInvariants',
+    name: 'name'
+} as const;
+
+export function isValueObject(item: unknown): item is ValueObject {
+    return reflection.isInstance(item, ValueObject.$type);
+}
+
+export type DomainDesignLanguageAstType = {
+    Actor: Actor
+    ActorCommandStep: ActorCommandStep
+    AggregateAttribute: AggregateAttribute
+    AggregateRoot: AggregateRoot
+    AsymmetricRelationship: AsymmetricRelationship
+    BoundedContext: BoundedContext
+    Command: Command
+    ContextMap: ContextMap
+    Dependency: Dependency
+    DomainAttribute: DomainAttribute
+    DomainEvent: DomainEvent
+    DomainEventsDeclaration: DomainEventsDeclaration
+    DomainException: DomainException
+    DomainModel: DomainModel
+    DomainObject: DomainObject
+    DomainService: DomainService
+    DomainServiceInput: DomainServiceInput
+    DomainServiceResponse: DomainServiceResponse
+    Entity: Entity
+    EntityAttribute: EntityAttribute
+    Enum: Enum
+    EventStormingDeclaration: EventStormingDeclaration
+    EventStormingElement: EventStormingElement
+    ExceptionsDeclaration: ExceptionsDeclaration
+    ExternalSystem: ExternalSystem
+    GivenStep: GivenStep
+    InputDTO: InputDTO
+    Method: Method
+    MethodInput: MethodInput
+    MethodsDeclaration: MethodsDeclaration
+    Payload: Payload
+    Policy: Policy
+    PolicyTrigger: PolicyTrigger
+    Port: Port
+    PrimitiveAttribute: PrimitiveAttribute
+    ProcessFlow: ProcessFlow
+    Projection: Projection
+    ReactionOutcome: ReactionOutcome
+    ReactionStep: ReactionStep
+    ReadModel: ReadModel
+    Reference: Reference
+    Relationship: Relationship
+    ResponseDTO: ResponseDTO
+    SymmetricRelationship: SymmetricRelationship
+    Term: Term
+    UID: UID
+    UbiquitousLanguageDeclaration: UbiquitousLanguageDeclaration
+    ValueObject: ValueObject
+}
+
+export class DomainDesignLanguageAstReflection extends langium.AbstractAstReflection {
+    override readonly types = {
+        Actor: {
+            name: Actor.$type,
+            properties: {
+                description: {
+                    name: Actor.description
+                },
+                name: {
+                    name: Actor.name
+                }
+            },
+            superTypes: [EventStormingElement.$type]
+        },
+        ActorCommandStep: {
+            name: ActorCommandStep.$type,
+            properties: {
+                command: {
+                    name: ActorCommandStep.command,
+                    referenceType: Command.$type
+                },
+                issuer: {
+                    name: ActorCommandStep.issuer,
+                    referenceType: Actor.$type
+                }
+            },
+            superTypes: []
+        },
+        AggregateAttribute: {
+            name: AggregateAttribute.$type,
+            properties: {
+                many: {
+                    name: AggregateAttribute.many,
+                    defaultValue: false
+                },
+                optional: {
+                    name: AggregateAttribute.optional,
+                    defaultValue: false
+                },
+                type: {
+                    name: AggregateAttribute.type
+                }
+            },
+            superTypes: []
+        },
+        AggregateRoot: {
+            name: AggregateRoot.$type,
+            properties: {
+                attributes: {
+                    name: AggregateRoot.attributes,
+                    defaultValue: []
+                },
+                correctivePolicies: {
+                    name: AggregateRoot.correctivePolicies,
+                    defaultValue: []
+                },
+                description: {
+                    name: AggregateRoot.description
+                },
+                enforcedInvariants: {
+                    name: AggregateRoot.enforcedInvariants,
+                    defaultValue: []
+                },
+                events: {
+                    name: AggregateRoot.events
+                },
+                exceptions: {
+                    name: AggregateRoot.exceptions
+                },
+                id: {
+                    name: AggregateRoot.id
+                },
+                methods: {
+                    name: AggregateRoot.methods
+                },
+                name: {
+                    name: AggregateRoot.name
+                }
+            },
+            superTypes: [DomainObject.$type]
+        },
+        AsymmetricRelationship: {
+            name: AsymmetricRelationship.$type,
+            properties: {
+                customerSupplier: {
+                    name: AsymmetricRelationship.customerSupplier,
+                    defaultValue: false
+                },
+                description: {
+                    name: AsymmetricRelationship.description
+                },
+                downstream: {
+                    name: AsymmetricRelationship.downstream,
+                    referenceType: BoundedContext.$type
+                },
+                downstreamRole: {
+                    name: AsymmetricRelationship.downstreamRole
+                },
+                upstream: {
+                    name: AsymmetricRelationship.upstream,
+                    referenceType: BoundedContext.$type
+                },
+                upstreamRoles: {
+                    name: AsymmetricRelationship.upstreamRoles,
+                    defaultValue: []
+                }
+            },
+            superTypes: [Relationship.$type]
+        },
+        BoundedContext: {
+            name: BoundedContext.$type,
+            properties: {
+                aggregates: {
+                    name: BoundedContext.aggregates,
+                    defaultValue: []
+                },
+                commands: {
+                    name: BoundedContext.commands,
+                    defaultValue: []
+                },
+                description: {
+                    name: BoundedContext.description
+                },
+                domainServices: {
+                    name: BoundedContext.domainServices,
+                    defaultValue: []
+                },
+                eventStorming: {
+                    name: BoundedContext.eventStorming
+                },
+                name: {
+                    name: BoundedContext.name
+                },
+                ports: {
+                    name: BoundedContext.ports,
+                    defaultValue: []
+                },
+                ubiquitousLanguage: {
+                    name: BoundedContext.ubiquitousLanguage
+                }
+            },
+            superTypes: []
+        },
+        Command: {
+            name: Command.$type,
+            properties: {
+                aggregate: {
+                    name: Command.aggregate,
+                    referenceType: AggregateRoot.$type
+                },
+                dependencies: {
+                    name: Command.dependencies,
+                    defaultValue: []
+                },
+                description: {
+                    name: Command.description
+                },
+                domainServices: {
+                    name: Command.domainServices,
+                    defaultValue: [],
+                    referenceType: DomainService.$type
+                },
+                events: {
+                    name: Command.events,
+                    defaultValue: [],
+                    referenceType: DomainEvent.$type
+                },
+                input: {
+                    name: Command.input
+                },
+                name: {
+                    name: Command.name
+                },
+                response: {
+                    name: Command.response
+                }
+            },
+            superTypes: []
+        },
+        ContextMap: {
+            name: ContextMap.$type,
+            properties: {
+                relationships: {
+                    name: ContextMap.relationships,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        Dependency: {
+            name: Dependency.$type,
+            properties: {
+                port: {
+                    name: Dependency.port,
+                    referenceType: Port.$type
+                }
+            },
+            superTypes: []
+        },
+        DomainAttribute: {
+            name: DomainAttribute.$type,
+            properties: {
+                many: {
+                    name: DomainAttribute.many,
+                    defaultValue: false
+                },
+                name: {
+                    name: DomainAttribute.name
+                },
+                optional: {
+                    name: DomainAttribute.optional,
+                    defaultValue: false
+                },
+                type: {
+                    name: DomainAttribute.type,
+                    referenceType: DomainObject.$type
+                }
+            },
+            superTypes: []
+        },
+        DomainEvent: {
+            name: DomainEvent.$type,
+            properties: {
+                description: {
+                    name: DomainEvent.description
+                },
+                name: {
+                    name: DomainEvent.name
+                },
+                payload: {
+                    name: DomainEvent.payload
+                }
+            },
+            superTypes: []
+        },
+        DomainEventsDeclaration: {
+            name: DomainEventsDeclaration.$type,
+            properties: {
+                events: {
+                    name: DomainEventsDeclaration.events,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        DomainException: {
+            name: DomainException.$type,
+            properties: {
+                description: {
+                    name: DomainException.description
+                },
+                name: {
+                    name: DomainException.name
+                }
+            },
+            superTypes: []
+        },
+        DomainModel: {
+            name: DomainModel.$type,
+            properties: {
+                boundedContext: {
+                    name: DomainModel.boundedContext
+                },
+                contextMap: {
+                    name: DomainModel.contextMap
+                }
+            },
+            superTypes: []
+        },
+        DomainObject: {
+            name: DomainObject.$type,
+            properties: {
+            },
+            superTypes: []
+        },
+        DomainService: {
+            name: DomainService.$type,
+            properties: {
+                description: {
+                    name: DomainService.description
+                },
+                input: {
+                    name: DomainService.input
+                },
+                name: {
+                    name: DomainService.name
+                },
+                response: {
+                    name: DomainService.response
+                },
+                type: {
+                    name: DomainService.type
+                }
+            },
+            superTypes: []
+        },
+        DomainServiceInput: {
+            name: DomainServiceInput.$type,
+            properties: {
+                attributes: {
+                    name: DomainServiceInput.attributes,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        DomainServiceResponse: {
+            name: DomainServiceResponse.$type,
+            properties: {
+                attributes: {
+                    name: DomainServiceResponse.attributes,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        Entity: {
+            name: Entity.$type,
+            properties: {
+                attributes: {
+                    name: Entity.attributes,
+                    defaultValue: []
+                },
+                description: {
+                    name: Entity.description
+                },
+                id: {
+                    name: Entity.id
+                },
+                name: {
+                    name: Entity.name
+                }
+            },
+            superTypes: [DomainObject.$type]
+        },
+        EntityAttribute: {
+            name: EntityAttribute.$type,
+            properties: {
+                many: {
+                    name: EntityAttribute.many,
+                    defaultValue: false
+                },
+                optional: {
+                    name: EntityAttribute.optional,
+                    defaultValue: false
+                },
+                type: {
+                    name: EntityAttribute.type
+                }
+            },
+            superTypes: []
+        },
+        Enum: {
+            name: Enum.$type,
+            properties: {
+                values: {
+                    name: Enum.values,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        EventStormingDeclaration: {
+            name: EventStormingDeclaration.$type,
+            properties: {
+                elements: {
+                    name: EventStormingDeclaration.elements,
+                    defaultValue: []
+                },
+                flows: {
+                    name: EventStormingDeclaration.flows,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        EventStormingElement: {
+            name: EventStormingElement.$type,
+            properties: {
+            },
+            superTypes: []
+        },
+        ExceptionsDeclaration: {
+            name: ExceptionsDeclaration.$type,
+            properties: {
+                exceptions: {
+                    name: ExceptionsDeclaration.exceptions,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        ExternalSystem: {
+            name: ExternalSystem.$type,
+            properties: {
+                description: {
+                    name: ExternalSystem.description
+                },
+                name: {
+                    name: ExternalSystem.name
+                }
+            },
+            superTypes: [EventStormingElement.$type]
+        },
+        GivenStep: {
+            name: GivenStep.$type,
+            properties: {
+                actor: {
+                    name: GivenStep.actor,
+                    referenceType: Actor.$type
+                },
+                readModel: {
+                    name: GivenStep.readModel,
+                    referenceType: ReadModel.$type
+                }
+            },
+            superTypes: []
+        },
+        InputDTO: {
+            name: InputDTO.$type,
+            properties: {
+                attributes: {
+                    name: InputDTO.attributes,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        Method: {
+            name: Method.$type,
+            properties: {
+                description: {
+                    name: Method.description
+                },
+                input: {
+                    name: Method.input
+                },
+                name: {
+                    name: Method.name
+                }
+            },
+            superTypes: []
+        },
+        MethodInput: {
+            name: MethodInput.$type,
+            properties: {
+                attributes: {
+                    name: MethodInput.attributes,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        MethodsDeclaration: {
+            name: MethodsDeclaration.$type,
+            properties: {
+                methods: {
+                    name: MethodsDeclaration.methods,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        Payload: {
+            name: Payload.$type,
+            properties: {
+                attributes: {
+                    name: Payload.attributes,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        Policy: {
+            name: Policy.$type,
+            properties: {
+                command: {
+                    name: Policy.command,
+                    referenceType: Command.$type
+                },
+                description: {
+                    name: Policy.description
+                },
+                name: {
+                    name: Policy.name
+                }
+            },
+            superTypes: []
+        },
+        PolicyTrigger: {
+            name: PolicyTrigger.$type,
+            properties: {
+                hotspot: {
+                    name: PolicyTrigger.hotspot
+                },
+                policy: {
+                    name: PolicyTrigger.policy
+                }
+            },
+            superTypes: [ReactionOutcome.$type]
+        },
+        Port: {
+            name: Port.$type,
+            properties: {
+                description: {
+                    name: Port.description
+                },
+                name: {
+                    name: Port.name
+                }
+            },
+            superTypes: []
+        },
+        PrimitiveAttribute: {
+            name: PrimitiveAttribute.$type,
+            properties: {
+                many: {
+                    name: PrimitiveAttribute.many,
+                    defaultValue: false
+                },
+                name: {
+                    name: PrimitiveAttribute.name
+                },
+                optional: {
+                    name: PrimitiveAttribute.optional,
+                    defaultValue: false
+                },
+                type: {
+                    name: PrimitiveAttribute.type
+                }
+            },
+            superTypes: []
+        },
+        ProcessFlow: {
+            name: ProcessFlow.$type,
+            properties: {
+                command: {
+                    name: ProcessFlow.command
+                },
+                description: {
+                    name: ProcessFlow.description
+                },
+                given: {
+                    name: ProcessFlow.given
+                },
+                name: {
+                    name: ProcessFlow.name
+                },
+                reactions: {
+                    name: ProcessFlow.reactions,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        Projection: {
+            name: Projection.$type,
+            properties: {
+                hotspot: {
+                    name: Projection.hotspot
+                },
+                readModel: {
+                    name: Projection.readModel,
+                    referenceType: ReadModel.$type
+                }
+            },
+            superTypes: [ReactionOutcome.$type]
+        },
+        ReactionOutcome: {
+            name: ReactionOutcome.$type,
+            properties: {
+            },
+            superTypes: []
+        },
+        ReactionStep: {
+            name: ReactionStep.$type,
+            properties: {
+                outcomes: {
+                    name: ReactionStep.outcomes,
+                    defaultValue: []
+                },
+                trigger: {
+                    name: ReactionStep.trigger,
+                    referenceType: DomainEvent.$type
+                }
+            },
+            superTypes: []
+        },
+        ReadModel: {
+            name: ReadModel.$type,
+            properties: {
+                description: {
+                    name: ReadModel.description
+                },
+                name: {
+                    name: ReadModel.name
+                }
+            },
+            superTypes: [EventStormingElement.$type]
+        },
+        Reference: {
+            name: Reference.$type,
+            properties: {
+                name: {
+                    name: Reference.name
+                },
+                to: {
+                    name: Reference.to,
+                    referenceType: AggregateRoot.$type
+                }
+            },
+            superTypes: []
+        },
+        Relationship: {
+            name: Relationship.$type,
+            properties: {
+            },
+            superTypes: []
+        },
+        ResponseDTO: {
+            name: ResponseDTO.$type,
+            properties: {
+                attributes: {
+                    name: ResponseDTO.attributes,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        SymmetricRelationship: {
+            name: SymmetricRelationship.$type,
+            properties: {
+                description: {
+                    name: SymmetricRelationship.description
+                },
+                participant1: {
+                    name: SymmetricRelationship.participant1,
+                    referenceType: BoundedContext.$type
+                },
+                participant2: {
+                    name: SymmetricRelationship.participant2,
+                    referenceType: BoundedContext.$type
+                },
+                type: {
+                    name: SymmetricRelationship.type
+                }
+            },
+            superTypes: [Relationship.$type]
+        },
+        Term: {
+            name: Term.$type,
+            properties: {
+                aliases: {
+                    name: Term.aliases,
+                    defaultValue: []
+                },
+                definition: {
+                    name: Term.definition
+                },
+                name: {
+                    name: Term.name
+                }
+            },
+            superTypes: []
+        },
+        UID: {
+            name: UID.$type,
+            properties: {
+                enforcedInvariants: {
+                    name: UID.enforcedInvariants,
+                    defaultValue: []
+                },
+                type: {
+                    name: UID.type
+                }
+            },
+            superTypes: []
+        },
+        UbiquitousLanguageDeclaration: {
+            name: UbiquitousLanguageDeclaration.$type,
+            properties: {
+                terms: {
+                    name: UbiquitousLanguageDeclaration.terms,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        ValueObject: {
+            name: ValueObject.$type,
+            properties: {
+                attributes: {
+                    name: ValueObject.attributes,
+                    defaultValue: []
+                },
+                description: {
+                    name: ValueObject.description
+                },
+                enforcedInvariants: {
+                    name: ValueObject.enforcedInvariants,
+                    defaultValue: []
+                },
+                name: {
+                    name: ValueObject.name
+                }
+            },
+            superTypes: [DomainObject.$type]
+        }
+    } as const satisfies langium.AstMetaData
+}
+
+export const reflection = new DomainDesignLanguageAstReflection();