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

package/out/generated/ast.js

@@ -0,0 +1,1147 @@
+/******************************************************************************
+ * 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 const Actor = {
+    $type: 'Actor',
+    description: 'description',
+    name: 'name'
+};
+export function isActor(item) {
+    return reflection.isInstance(item, Actor.$type);
+}
+export const ActorCommandStep = {
+    $type: 'ActorCommandStep',
+    command: 'command',
+    issuer: 'issuer'
+};
+export function isActorCommandStep(item) {
+    return reflection.isInstance(item, ActorCommandStep.$type);
+}
+export const AggregateAttribute = {
+    $type: 'AggregateAttribute',
+    many: 'many',
+    optional: 'optional',
+    type: 'type'
+};
+export function isAggregateAttribute(item) {
+    return reflection.isInstance(item, AggregateAttribute.$type);
+}
+export const AggregateRoot = {
+    $type: 'AggregateRoot',
+    attributes: 'attributes',
+    correctivePolicies: 'correctivePolicies',
+    description: 'description',
+    enforcedInvariants: 'enforcedInvariants',
+    events: 'events',
+    exceptions: 'exceptions',
+    id: 'id',
+    methods: 'methods',
+    name: 'name'
+};
+export function isAggregateRoot(item) {
+    return reflection.isInstance(item, AggregateRoot.$type);
+}
+export const AsymmetricRelationship = {
+    $type: 'AsymmetricRelationship',
+    customerSupplier: 'customerSupplier',
+    description: 'description',
+    downstream: 'downstream',
+    downstreamRole: 'downstreamRole',
+    upstream: 'upstream',
+    upstreamRoles: 'upstreamRoles'
+};
+export function isAsymmetricRelationship(item) {
+    return reflection.isInstance(item, AsymmetricRelationship.$type);
+}
+export const BoundedContext = {
+    $type: 'BoundedContext',
+    aggregates: 'aggregates',
+    commands: 'commands',
+    description: 'description',
+    domainServices: 'domainServices',
+    eventStorming: 'eventStorming',
+    name: 'name',
+    ports: 'ports',
+    ubiquitousLanguage: 'ubiquitousLanguage'
+};
+export function isBoundedContext(item) {
+    return reflection.isInstance(item, BoundedContext.$type);
+}
+export const Command = {
+    $type: 'Command',
+    aggregate: 'aggregate',
+    dependencies: 'dependencies',
+    description: 'description',
+    domainServices: 'domainServices',
+    events: 'events',
+    input: 'input',
+    name: 'name',
+    response: 'response'
+};
+export function isCommand(item) {
+    return reflection.isInstance(item, Command.$type);
+}
+export const ContextMap = {
+    $type: 'ContextMap',
+    relationships: 'relationships'
+};
+export function isContextMap(item) {
+    return reflection.isInstance(item, ContextMap.$type);
+}
+export const Dependency = {
+    $type: 'Dependency',
+    port: 'port'
+};
+export function isDependency(item) {
+    return reflection.isInstance(item, Dependency.$type);
+}
+export const DomainAttribute = {
+    $type: 'DomainAttribute',
+    many: 'many',
+    name: 'name',
+    optional: 'optional',
+    type: 'type'
+};
+export function isDomainAttribute(item) {
+    return reflection.isInstance(item, DomainAttribute.$type);
+}
+export const DomainEvent = {
+    $type: 'DomainEvent',
+    description: 'description',
+    name: 'name',
+    payload: 'payload'
+};
+export function isDomainEvent(item) {
+    return reflection.isInstance(item, DomainEvent.$type);
+}
+export const DomainEventsDeclaration = {
+    $type: 'DomainEventsDeclaration',
+    events: 'events'
+};
+export function isDomainEventsDeclaration(item) {
+    return reflection.isInstance(item, DomainEventsDeclaration.$type);
+}
+export const DomainException = {
+    $type: 'DomainException',
+    description: 'description',
+    name: 'name'
+};
+export function isDomainException(item) {
+    return reflection.isInstance(item, DomainException.$type);
+}
+export const DomainModel = {
+    $type: 'DomainModel',
+    boundedContext: 'boundedContext',
+    contextMap: 'contextMap'
+};
+export function isDomainModel(item) {
+    return reflection.isInstance(item, DomainModel.$type);
+}
+export const DomainObject = {
+    $type: 'DomainObject'
+};
+export function isDomainObject(item) {
+    return reflection.isInstance(item, DomainObject.$type);
+}
+export const DomainService = {
+    $type: 'DomainService',
+    description: 'description',
+    input: 'input',
+    name: 'name',
+    response: 'response',
+    type: 'type'
+};
+export function isDomainService(item) {
+    return reflection.isInstance(item, DomainService.$type);
+}
+export const DomainServiceInput = {
+    $type: 'DomainServiceInput',
+    attributes: 'attributes'
+};
+export function isDomainServiceInput(item) {
+    return reflection.isInstance(item, DomainServiceInput.$type);
+}
+export const DomainServiceResponse = {
+    $type: 'DomainServiceResponse',
+    attributes: 'attributes'
+};
+export function isDomainServiceResponse(item) {
+    return reflection.isInstance(item, DomainServiceResponse.$type);
+}
+export function isDownstreamRole(item) {
+    return item === 'AntiCorruptionLayer' || item === 'Conformist';
+}
+export const Entity = {
+    $type: 'Entity',
+    attributes: 'attributes',
+    description: 'description',
+    id: 'id',
+    name: 'name'
+};
+export function isEntity(item) {
+    return reflection.isInstance(item, Entity.$type);
+}
+export const EntityAttribute = {
+    $type: 'EntityAttribute',
+    many: 'many',
+    optional: 'optional',
+    type: 'type'
+};
+export function isEntityAttribute(item) {
+    return reflection.isInstance(item, EntityAttribute.$type);
+}
+export const Enum = {
+    $type: 'Enum',
+    values: 'values'
+};
+export function isEnum(item) {
+    return reflection.isInstance(item, Enum.$type);
+}
+export const EventStormingDeclaration = {
+    $type: 'EventStormingDeclaration',
+    elements: 'elements',
+    flows: 'flows'
+};
+export function isEventStormingDeclaration(item) {
+    return reflection.isInstance(item, EventStormingDeclaration.$type);
+}
+export const EventStormingElement = {
+    $type: 'EventStormingElement'
+};
+export function isEventStormingElement(item) {
+    return reflection.isInstance(item, EventStormingElement.$type);
+}
+export const ExceptionsDeclaration = {
+    $type: 'ExceptionsDeclaration',
+    exceptions: 'exceptions'
+};
+export function isExceptionsDeclaration(item) {
+    return reflection.isInstance(item, ExceptionsDeclaration.$type);
+}
+export const ExternalSystem = {
+    $type: 'ExternalSystem',
+    description: 'description',
+    name: 'name'
+};
+export function isExternalSystem(item) {
+    return reflection.isInstance(item, ExternalSystem.$type);
+}
+export const GivenStep = {
+    $type: 'GivenStep',
+    actor: 'actor',
+    readModel: 'readModel'
+};
+export function isGivenStep(item) {
+    return reflection.isInstance(item, GivenStep.$type);
+}
+export function isIDType(item) {
+    return item === 'string' || item === 'number';
+}
+export const InputDTO = {
+    $type: 'InputDTO',
+    attributes: 'attributes'
+};
+export function isInputDTO(item) {
+    return reflection.isInstance(item, InputDTO.$type);
+}
+export const Method = {
+    $type: 'Method',
+    description: 'description',
+    input: 'input',
+    name: 'name'
+};
+export function isMethod(item) {
+    return reflection.isInstance(item, Method.$type);
+}
+export const MethodInput = {
+    $type: 'MethodInput',
+    attributes: 'attributes'
+};
+export function isMethodInput(item) {
+    return reflection.isInstance(item, MethodInput.$type);
+}
+export const MethodsDeclaration = {
+    $type: 'MethodsDeclaration',
+    methods: 'methods'
+};
+export function isMethodsDeclaration(item) {
+    return reflection.isInstance(item, MethodsDeclaration.$type);
+}
+export const Payload = {
+    $type: 'Payload',
+    attributes: 'attributes'
+};
+export function isPayload(item) {
+    return reflection.isInstance(item, Payload.$type);
+}
+export const Policy = {
+    $type: 'Policy',
+    command: 'command',
+    description: 'description',
+    name: 'name'
+};
+export function isPolicy(item) {
+    return reflection.isInstance(item, Policy.$type);
+}
+export const PolicyTrigger = {
+    $type: 'PolicyTrigger',
+    hotspot: 'hotspot',
+    policy: 'policy'
+};
+export function isPolicyTrigger(item) {
+    return reflection.isInstance(item, PolicyTrigger.$type);
+}
+export const Port = {
+    $type: 'Port',
+    description: 'description',
+    name: 'name'
+};
+export function isPort(item) {
+    return reflection.isInstance(item, Port.$type);
+}
+export function isPrimitive(item) {
+    return item === 'string' || item === 'number' || item === 'boolean' || item === 'date';
+}
+export const PrimitiveAttribute = {
+    $type: 'PrimitiveAttribute',
+    many: 'many',
+    name: 'name',
+    optional: 'optional',
+    type: 'type'
+};
+export function isPrimitiveAttribute(item) {
+    return reflection.isInstance(item, PrimitiveAttribute.$type);
+}
+export const ProcessFlow = {
+    $type: 'ProcessFlow',
+    command: 'command',
+    description: 'description',
+    given: 'given',
+    name: 'name',
+    reactions: 'reactions'
+};
+export function isProcessFlow(item) {
+    return reflection.isInstance(item, ProcessFlow.$type);
+}
+export const Projection = {
+    $type: 'Projection',
+    hotspot: 'hotspot',
+    readModel: 'readModel'
+};
+export function isProjection(item) {
+    return reflection.isInstance(item, Projection.$type);
+}
+export function isQualifiedName(item) {
+    return typeof item === 'string';
+}
+export const ReactionOutcome = {
+    $type: 'ReactionOutcome'
+};
+export function isReactionOutcome(item) {
+    return reflection.isInstance(item, ReactionOutcome.$type);
+}
+export const ReactionStep = {
+    $type: 'ReactionStep',
+    outcomes: 'outcomes',
+    trigger: 'trigger'
+};
+export function isReactionStep(item) {
+    return reflection.isInstance(item, ReactionStep.$type);
+}
+export const ReadModel = {
+    $type: 'ReadModel',
+    description: 'description',
+    name: 'name'
+};
+export function isReadModel(item) {
+    return reflection.isInstance(item, ReadModel.$type);
+}
+export const Reference = {
+    $type: 'Reference',
+    name: 'name',
+    to: 'to'
+};
+export function isReference(item) {
+    return reflection.isInstance(item, Reference.$type);
+}
+export const Relationship = {
+    $type: 'Relationship'
+};
+export function isRelationship(item) {
+    return reflection.isInstance(item, Relationship.$type);
+}
+export const ResponseDTO = {
+    $type: 'ResponseDTO',
+    attributes: 'attributes'
+};
+export function isResponseDTO(item) {
+    return reflection.isInstance(item, ResponseDTO.$type);
+}
+export const SymmetricRelationship = {
+    $type: 'SymmetricRelationship',
+    description: 'description',
+    participant1: 'participant1',
+    participant2: 'participant2',
+    type: 'type'
+};
+export function isSymmetricRelationship(item) {
+    return reflection.isInstance(item, SymmetricRelationship.$type);
+}
+export const Term = {
+    $type: 'Term',
+    aliases: 'aliases',
+    definition: 'definition',
+    name: 'name'
+};
+export function isTerm(item) {
+    return reflection.isInstance(item, Term.$type);
+}
+export const UbiquitousLanguageDeclaration = {
+    $type: 'UbiquitousLanguageDeclaration',
+    terms: 'terms'
+};
+export function isUbiquitousLanguageDeclaration(item) {
+    return reflection.isInstance(item, UbiquitousLanguageDeclaration.$type);
+}
+export const UID = {
+    $type: 'UID',
+    enforcedInvariants: 'enforcedInvariants',
+    type: 'type'
+};
+export function isUID(item) {
+    return reflection.isInstance(item, UID.$type);
+}
+export function isUpstreamRole(item) {
+    return item === 'OpenHostService' || item === 'PublishedLanguage';
+}
+export const ValueObject = {
+    $type: 'ValueObject',
+    attributes: 'attributes',
+    description: 'description',
+    enforcedInvariants: 'enforcedInvariants',
+    name: 'name'
+};
+export function isValueObject(item) {
+    return reflection.isInstance(item, ValueObject.$type);
+}
+export class DomainDesignLanguageAstReflection extends langium.AbstractAstReflection {
+    constructor() {
+        super(...arguments);
+        this.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]
+            }
+        };
+    }
+}
+export const reflection = new DomainDesignLanguageAstReflection();
+//# sourceMappingURL=ast.js.map