agentlang 0.9.4 → 0.9.5

package/src/language/generated/ast.ts

@@ -1,5 +1,5 @@
 /******************************************************************************
- * This file was generated by langium-cli 3.5.2.
+ * This file was generated by langium-cli 4.1.0.
  * DO NOT EDIT MANUALLY!
  ******************************************************************************/
 
@@ -7,9 +7,9 @@
 import * as langium from 'langium';
 
 export const AgentlangTerminals = {
-    ID: /(([_a-zA-Z][\w_]*)(\/([_a-zA-Z][\w_]*))?)/,
-    QUOTED_STRING: /("(((\\([\s\S]))|((?!(((\\|")|\r)|\n))[\s\S]*?))|(\r?\n))*")/,
-    TICK_QUOTED_STRING: /(`(((\\([\s\S]))|((?!(((\\|`)|\r)|\n))[\s\S]*?))|(\r?\n))*`)/,
+    ID: /(?:[_a-zA-Z][\w_]*)(\/(?:[_a-zA-Z][\w_]*))?/,
+    QUOTED_STRING: /"(\\(?:[\s\S])|(?:(?!(\\|"|\r|\n))[\s\S]*?)|\r?\n)*"/,
+    TICK_QUOTED_STRING: /`(\\(?:[\s\S])|(?:(?!(\\|`|\r|\n))[\s\S]*?)|\r?\n)*`/,
     INT: /-?[0-9]+/,
     WS: /\s+/,
     ML_COMMENT: /\/\*[\s\S]*?\*\//,
@@ -127,132 +127,6 @@ export type AgentlangKeywordNames =
 
 export type AgentlangTokenNames = AgentlangTerminalNames | AgentlangKeywordNames;
 
-export type AttributeValueExpression = Expr;
-
-export const AttributeValueExpression = 'AttributeValueExpression';
-
-export function isAttributeValueExpression(item: unknown): item is AttributeValueExpression {
-    return reflection.isInstance(item, AttributeValueExpression);
-}
-
-export type Boolean = 'false' | 'true';
-
-export function isBoolean(item: unknown): item is Boolean {
-    return item === 'true' || item === 'false';
-}
-
-export type Decimal = number;
-
-export function isDecimal(item: unknown): item is Decimal {
-    return typeof item === 'number';
-}
-
-export type Definition = AgentDefinition | DecisionDefinition | DirectiveDefinition | FlowDefinition | GlossaryEntryDefinition | PublicAgentDefinition | PublicWorkflowDefinition | RelationshipDefinition | ResolverDefinition | RetryDefinition | ScenarioDefinition | SchemaDefinition | StandaloneStatement | WorkflowDefinition;
-
-export const Definition = 'Definition';
-
-export function isDefinition(item: unknown): item is Definition {
-    return reflection.isInstance(item, Definition);
-}
-
-export type Expr = BinExpr | PrimExpr;
-
-export const Expr = 'Expr';
-
-export function isExpr(item: unknown): item is Expr {
-    return reflection.isInstance(item, Expr);
-}
-
-export type FlowStepSpec = Statement;
-
-export const FlowStepSpec = 'FlowStepSpec';
-
-export function isFlowStepSpec(item: unknown): item is FlowStepSpec {
-    return reflection.isInstance(item, FlowStepSpec);
-}
-
-export type GenericName = STRING | string;
-
-export function isGenericName(item: unknown): item is GenericName {
-    return isSTRING(item) || (typeof item === 'string' && (/(([_a-zA-Z][\w_]*)(\/([_a-zA-Z][\w_]*))?)/.test(item)));
-}
-
-export type JoinType = '@full_join' | '@inner_join' | '@join' | '@left_join' | '@right_join';
-
-export function isJoinType(item: unknown): item is JoinType {
-    return item === '@join' || item === '@inner_join' || item === '@left_join' || item === '@right_join' || item === '@full_join';
-}
-
-export type PrimExpr = Group | Literal | NegExpr | NotExpr;
-
-export const PrimExpr = 'PrimExpr';
-
-export function isPrimExpr(item: unknown): item is PrimExpr {
-    return reflection.isInstance(item, PrimExpr);
-}
-
-export type QualifiedName = Ref | string;
-
-export function isQualifiedName(item: unknown): item is QualifiedName {
-    return isRef(item) || (typeof item === 'string' && (/(([_a-zA-Z][\w_]*)(\/([_a-zA-Z][\w_]*))?)/.test(item)));
-}
-
-export type QueryId = string;
-
-export function isQueryId(item: unknown): item is QueryId {
-    return typeof item === 'string';
-}
-
-export type Ref = string;
-
-export function isRef(item: unknown): item is Ref {
-    return typeof item === 'string';
-}
-
-export type ResolverPathEntry = GenericName | QualifiedName;
-
-export function isResolverPathEntry(item: unknown): item is ResolverPathEntry {
-    return isQualifiedName(item) || isGenericName(item);
-}
-
-export type SchemaDefinition = EntityDefinition | EventDefinition | PublicEventDefinition | RecordDefinition;
-
-export const SchemaDefinition = 'SchemaDefinition';
-
-export function isSchemaDefinition(item: unknown): item is SchemaDefinition {
-    return reflection.isInstance(item, SchemaDefinition);
-}
-
-export type SqlComparisonOpr = '!=' | '<' | '<=' | '<>' | '=' | '>' | '>=' | 'between' | 'in' | 'like';
-
-export function isSqlComparisonOpr(item: unknown): item is SqlComparisonOpr {
-    return item === '=' || item === '<>' || item === '!=' || item === '<' || item === '<=' || item === '>' || item === '>=' || item === 'in' || item === 'like' || item === 'between';
-}
-
-export type STRING = string;
-
-export function isSTRING(item: unknown): item is STRING {
-    return (typeof item === 'string' && (/("(((\\([\s\S]))|((?!(((\\|")|\r)|\n))[\s\S]*?))|(\r?\n))*")/.test(item) || /(`(((\\([\s\S]))|((?!(((\\|`)|\r)|\n))[\s\S]*?))|(\r?\n))*`)/.test(item)));
-}
-
-export type TaggedId = string;
-
-export function isTaggedId(item: unknown): item is TaggedId {
-    return typeof item === 'string';
-}
-
-export type WorkflowHeaderPrefix = 'create' | 'delete' | 'update';
-
-export function isWorkflowHeaderPrefix(item: unknown): item is WorkflowHeaderPrefix {
-    return item === 'create' || item === 'update' || item === 'delete';
-}
-
-export type WorkflowHeaderTag = '@after' | '@before';
-
-export function isWorkflowHeaderTag(item: unknown): item is WorkflowHeaderTag {
-    return item === '@after' || item === '@before';
-}
-
 export interface ActionEntry extends langium.AstNode {
     readonly $container: EntityActionsDefinitions;
     readonly $type: 'ActionEntry';
@@ -260,10 +134,14 @@ export interface ActionEntry extends langium.AstNode {
     name: string;
 }
 
-export const ActionEntry = 'ActionEntry';
+export const ActionEntry = {
+    $type: 'ActionEntry',
+    event: 'event',
+    name: 'name'
+} as const;
 
 export function isActionEntry(item: unknown): item is ActionEntry {
-    return reflection.isInstance(item, ActionEntry);
+    return reflection.isInstance(item, ActionEntry.$type);
 }
 
 export interface AfterTriggerDefinition extends langium.AstNode {
@@ -272,10 +150,13 @@ export interface AfterTriggerDefinition extends langium.AstNode {
     triggers: TriggerDefinition;
 }
 
-export const AfterTriggerDefinition = 'AfterTriggerDefinition';
+export const AfterTriggerDefinition = {
+    $type: 'AfterTriggerDefinition',
+    triggers: 'triggers'
+} as const;
 
 export function isAfterTriggerDefinition(item: unknown): item is AfterTriggerDefinition {
-    return reflection.isInstance(item, AfterTriggerDefinition);
+    return reflection.isInstance(item, AfterTriggerDefinition.$type);
 }
 
 export interface AgentDefinition extends langium.AstNode {
@@ -285,10 +166,14 @@ export interface AgentDefinition extends langium.AstNode {
     name: GenericName;
 }
 
-export const AgentDefinition = 'AgentDefinition';
+export const AgentDefinition = {
+    $type: 'AgentDefinition',
+    body: 'body',
+    name: 'name'
+} as const;
 
 export function isAgentDefinition(item: unknown): item is AgentDefinition {
-    return reflection.isInstance(item, AgentDefinition);
+    return reflection.isInstance(item, AgentDefinition.$type);
 }
 
 export interface AgentXtraAttribute extends langium.AstNode {
@@ -298,10 +183,14 @@ export interface AgentXtraAttribute extends langium.AstNode {
     value: STRING;
 }
 
-export const AgentXtraAttribute = 'AgentXtraAttribute';
+export const AgentXtraAttribute = {
+    $type: 'AgentXtraAttribute',
+    name: 'name',
+    value: 'value'
+} as const;
 
 export function isAgentXtraAttribute(item: unknown): item is AgentXtraAttribute {
-    return reflection.isInstance(item, AgentXtraAttribute);
+    return reflection.isInstance(item, AgentXtraAttribute.$type);
 }
 
 export interface AgentXtraSpec extends langium.AstNode {
@@ -310,10 +199,13 @@ export interface AgentXtraSpec extends langium.AstNode {
     attributes: Array<AgentXtraAttribute>;
 }
 
-export const AgentXtraSpec = 'AgentXtraSpec';
+export const AgentXtraSpec = {
+    $type: 'AgentXtraSpec',
+    attributes: 'attributes'
+} as const;
 
 export function isAgentXtraSpec(item: unknown): item is AgentXtraSpec {
-    return reflection.isInstance(item, AgentXtraSpec);
+    return reflection.isInstance(item, AgentXtraSpec.$type);
 }
 
 export interface AggregateFunctionSpec extends langium.AstNode {
@@ -323,10 +215,14 @@ export interface AggregateFunctionSpec extends langium.AstNode {
     name: string;
 }
 
-export const AggregateFunctionSpec = 'AggregateFunctionSpec';
+export const AggregateFunctionSpec = {
+    $type: 'AggregateFunctionSpec',
+    args: 'args',
+    name: 'name'
+} as const;
 
 export function isAggregateFunctionSpec(item: unknown): item is AggregateFunctionSpec {
-    return reflection.isInstance(item, AggregateFunctionSpec);
+    return reflection.isInstance(item, AggregateFunctionSpec.$type);
 }
 
 export interface AliasSpec extends langium.AstNode {
@@ -336,10 +232,14 @@ export interface AliasSpec extends langium.AstNode {
     aliases: Array<string>;
 }
 
-export const AliasSpec = 'AliasSpec';
+export const AliasSpec = {
+    $type: 'AliasSpec',
+    alias: 'alias',
+    aliases: 'aliases'
+} as const;
 
 export function isAliasSpec(item: unknown): item is AliasSpec {
-    return reflection.isInstance(item, AliasSpec);
+    return reflection.isInstance(item, AliasSpec.$type);
 }
 
 export interface ArrayLiteral extends langium.AstNode {
@@ -348,10 +248,13 @@ export interface ArrayLiteral extends langium.AstNode {
     vals: Array<Statement>;
 }
 
-export const ArrayLiteral = 'ArrayLiteral';
+export const ArrayLiteral = {
+    $type: 'ArrayLiteral',
+    vals: 'vals'
+} as const;
 
 export function isArrayLiteral(item: unknown): item is ArrayLiteral {
-    return reflection.isInstance(item, ArrayLiteral);
+    return reflection.isInstance(item, ArrayLiteral.$type);
 }
 
 export interface AsyncFnCall extends langium.AstNode {
@@ -360,10 +263,13 @@ export interface AsyncFnCall extends langium.AstNode {
     fnCall: FnCall;
 }
 
-export const AsyncFnCall = 'AsyncFnCall';
+export const AsyncFnCall = {
+    $type: 'AsyncFnCall',
+    fnCall: 'fnCall'
+} as const;
 
 export function isAsyncFnCall(item: unknown): item is AsyncFnCall {
-    return reflection.isInstance(item, AsyncFnCall);
+    return reflection.isInstance(item, AsyncFnCall.$type);
 }
 
 export interface AttributeDefinition extends langium.AstNode {
@@ -379,10 +285,30 @@ export interface AttributeDefinition extends langium.AstNode {
     type?: QualifiedName;
 }
 
-export const AttributeDefinition = 'AttributeDefinition';
+export const AttributeDefinition = {
+    $type: 'AttributeDefinition',
+    arrayType: 'arrayType',
+    enumSpec: 'enumSpec',
+    expr: 'expr',
+    name: 'name',
+    oneOfSpec: 'oneOfSpec',
+    properties: 'properties',
+    refSpec: 'refSpec',
+    type: 'type'
+} as const;
 
 export function isAttributeDefinition(item: unknown): item is AttributeDefinition {
-    return reflection.isInstance(item, AttributeDefinition);
+    return reflection.isInstance(item, AttributeDefinition.$type);
+}
+
+export type AttributeValueExpression = Expr;
+
+export const AttributeValueExpression = {
+    $type: 'AttributeValueExpression'
+} as const;
+
+export function isAttributeValueExpression(item: unknown): item is AttributeValueExpression {
+    return reflection.isInstance(item, AttributeValueExpression.$type);
 }
 
 export interface BackoffSpec extends langium.AstNode {
@@ -391,10 +317,13 @@ export interface BackoffSpec extends langium.AstNode {
     attributes: Array<SetAttribute>;
 }
 
-export const BackoffSpec = 'BackoffSpec';
+export const BackoffSpec = {
+    $type: 'BackoffSpec',
+    attributes: 'attributes'
+} as const;
 
 export function isBackoffSpec(item: unknown): item is BackoffSpec {
-    return reflection.isInstance(item, BackoffSpec);
+    return reflection.isInstance(item, BackoffSpec.$type);
 }
 
 export interface BeforeTriggerDefinition extends langium.AstNode {
@@ -403,10 +332,13 @@ export interface BeforeTriggerDefinition extends langium.AstNode {
     triggers: TriggerDefinition;
 }
 
-export const BeforeTriggerDefinition = 'BeforeTriggerDefinition';
+export const BeforeTriggerDefinition = {
+    $type: 'BeforeTriggerDefinition',
+    triggers: 'triggers'
+} as const;
 
 export function isBeforeTriggerDefinition(item: unknown): item is BeforeTriggerDefinition {
-    return reflection.isInstance(item, BeforeTriggerDefinition);
+    return reflection.isInstance(item, BeforeTriggerDefinition.$type);
 }
 
 export interface BinExpr extends langium.AstNode {
@@ -417,10 +349,21 @@ export interface BinExpr extends langium.AstNode {
     op: '!=' | '*' | '+' | '-' | '/' | '<' | '<=' | '<>' | '==' | '>' | '>=' | 'and' | 'in' | 'like' | 'or';
 }
 
-export const BinExpr = 'BinExpr';
+export const BinExpr = {
+    $type: 'BinExpr',
+    e1: 'e1',
+    e2: 'e2',
+    op: 'op'
+} as const;
 
 export function isBinExpr(item: unknown): item is BinExpr {
-    return reflection.isInstance(item, BinExpr);
+    return reflection.isInstance(item, BinExpr.$type);
+}
+
+export type Boolean = 'false' | 'true';
+
+export function isBoolean(item: unknown): item is Boolean {
+    return item === 'true' || item === 'false';
 }
 
 export interface CaseEntry extends langium.AstNode {
@@ -430,10 +373,14 @@ export interface CaseEntry extends langium.AstNode {
     statements: Array<Statement>;
 }
 
-export const CaseEntry = 'CaseEntry';
+export const CaseEntry = {
+    $type: 'CaseEntry',
+    cond: 'cond',
+    statements: 'statements'
+} as const;
 
 export function isCaseEntry(item: unknown): item is CaseEntry {
-    return reflection.isInstance(item, CaseEntry);
+    return reflection.isInstance(item, CaseEntry.$type);
 }
 
 export interface CatchSpec extends langium.AstNode {
@@ -442,10 +389,13 @@ export interface CatchSpec extends langium.AstNode {
     handlers: Array<Handler>;
 }
 
-export const CatchSpec = 'CatchSpec';
+export const CatchSpec = {
+    $type: 'CatchSpec',
+    handlers: 'handlers'
+} as const;
 
 export function isCatchSpec(item: unknown): item is CatchSpec {
-    return reflection.isInstance(item, CatchSpec);
+    return reflection.isInstance(item, CatchSpec.$type);
 }
 
 export interface CompositeUniqueDefinition extends langium.AstNode {
@@ -454,10 +404,13 @@ export interface CompositeUniqueDefinition extends langium.AstNode {
     attrs: Array<string>;
 }
 
-export const CompositeUniqueDefinition = 'CompositeUniqueDefinition';
+export const CompositeUniqueDefinition = {
+    $type: 'CompositeUniqueDefinition',
+    attrs: 'attrs'
+} as const;
 
 export function isCompositeUniqueDefinition(item: unknown): item is CompositeUniqueDefinition {
-    return reflection.isInstance(item, CompositeUniqueDefinition);
+    return reflection.isInstance(item, CompositeUniqueDefinition.$type);
 }
 
 export interface ConditionalFlowStep extends langium.AstNode {
@@ -467,10 +420,14 @@ export interface ConditionalFlowStep extends langium.AstNode {
     next: FlowStepSpec;
 }
 
-export const ConditionalFlowStep = 'ConditionalFlowStep';
+export const ConditionalFlowStep = {
+    $type: 'ConditionalFlowStep',
+    expr: 'expr',
+    next: 'next'
+} as const;
 
 export function isConditionalFlowStep(item: unknown): item is ConditionalFlowStep {
-    return reflection.isInstance(item, ConditionalFlowStep);
+    return reflection.isInstance(item, ConditionalFlowStep.$type);
 }
 
 export interface CrudMap extends langium.AstNode {
@@ -489,10 +446,23 @@ export interface CrudMap extends langium.AstNode {
     where?: WhereSpec;
 }
 
-export const CrudMap = 'CrudMap';
+export const CrudMap = {
+    $type: 'CrudMap',
+    body: 'body',
+    distinct: 'distinct',
+    groupByClause: 'groupByClause',
+    into: 'into',
+    joins: 'joins',
+    name: 'name',
+    orderByClause: 'orderByClause',
+    relationships: 'relationships',
+    source: 'source',
+    upsert: 'upsert',
+    where: 'where'
+} as const;
 
 export function isCrudMap(item: unknown): item is CrudMap {
-    return reflection.isInstance(item, CrudMap);
+    return reflection.isInstance(item, CrudMap.$type);
 }
 
 export interface CrudMapBody extends langium.AstNode {
@@ -502,10 +472,20 @@ export interface CrudMapBody extends langium.AstNode {
     properties: Array<PropertyDefinition>;
 }
 
-export const CrudMapBody = 'CrudMapBody';
+export const CrudMapBody = {
+    $type: 'CrudMapBody',
+    attributes: 'attributes',
+    properties: 'properties'
+} as const;
 
 export function isCrudMapBody(item: unknown): item is CrudMapBody {
-    return reflection.isInstance(item, CrudMapBody);
+    return reflection.isInstance(item, CrudMapBody.$type);
+}
+
+export type Decimal = number;
+
+export function isDecimal(item: unknown): item is Decimal {
+    return typeof item === 'number';
 }
 
 export interface DecisionDefBody extends langium.AstNode {
@@ -514,10 +494,13 @@ export interface DecisionDefBody extends langium.AstNode {
     cases: Array<CaseEntry>;
 }
 
-export const DecisionDefBody = 'DecisionDefBody';
+export const DecisionDefBody = {
+    $type: 'DecisionDefBody',
+    cases: 'cases'
+} as const;
 
 export function isDecisionDefBody(item: unknown): item is DecisionDefBody {
-    return reflection.isInstance(item, DecisionDefBody);
+    return reflection.isInstance(item, DecisionDefBody.$type);
 }
 
 export interface DecisionDefinition extends langium.AstNode {
@@ -527,10 +510,24 @@ export interface DecisionDefinition extends langium.AstNode {
     name: GenericName;
 }
 
-export const DecisionDefinition = 'DecisionDefinition';
+export const DecisionDefinition = {
+    $type: 'DecisionDefinition',
+    body: 'body',
+    name: 'name'
+} as const;
 
 export function isDecisionDefinition(item: unknown): item is DecisionDefinition {
-    return reflection.isInstance(item, DecisionDefinition);
+    return reflection.isInstance(item, DecisionDefinition.$type);
+}
+
+export type Definition = AgentDefinition | DecisionDefinition | DirectiveDefinition | FlowDefinition | GlossaryEntryDefinition | PublicAgentDefinition | PublicWorkflowDefinition | RelationshipDefinition | ResolverDefinition | RetryDefinition | ScenarioDefinition | SchemaDefinition | StandaloneStatement | WorkflowDefinition;
+
+export const Definition = {
+    $type: 'Definition'
+} as const;
+
+export function isDefinition(item: unknown): item is Definition {
+    return reflection.isInstance(item, Definition.$type);
 }
 
 export interface Delete extends langium.AstNode {
@@ -539,10 +536,13 @@ export interface Delete extends langium.AstNode {
     pattern: Pattern;
 }
 
-export const Delete = 'Delete';
+export const Delete = {
+    $type: 'Delete',
+    pattern: 'pattern'
+} as const;
 
 export function isDelete(item: unknown): item is Delete {
-    return reflection.isInstance(item, Delete);
+    return reflection.isInstance(item, Delete.$type);
 }
 
 export interface DirectiveDefinition extends langium.AstNode {
@@ -553,10 +553,15 @@ export interface DirectiveDefinition extends langium.AstNode {
     name: Ref;
 }
 
-export const DirectiveDefinition = 'DirectiveDefinition';
+export const DirectiveDefinition = {
+    $type: 'DirectiveDefinition',
+    body: 'body',
+    dir: 'dir',
+    name: 'name'
+} as const;
 
 export function isDirectiveDefinition(item: unknown): item is DirectiveDefinition {
-    return reflection.isInstance(item, DirectiveDefinition);
+    return reflection.isInstance(item, DirectiveDefinition.$type);
 }
 
 export interface Else extends langium.AstNode {
@@ -565,10 +570,13 @@ export interface Else extends langium.AstNode {
     statements: Array<Statement>;
 }
 
-export const Else = 'Else';
+export const Else = {
+    $type: 'Else',
+    statements: 'statements'
+} as const;
 
 export function isElse(item: unknown): item is Else {
-    return reflection.isInstance(item, Else);
+    return reflection.isInstance(item, Else.$type);
 }
 
 export interface EntityActionsDefinitions extends langium.AstNode {
@@ -577,10 +585,13 @@ export interface EntityActionsDefinitions extends langium.AstNode {
     entries: Array<ActionEntry>;
 }
 
-export const EntityActionsDefinitions = 'EntityActionsDefinitions';
+export const EntityActionsDefinitions = {
+    $type: 'EntityActionsDefinitions',
+    entries: 'entries'
+} as const;
 
 export function isEntityActionsDefinitions(item: unknown): item is EntityActionsDefinitions {
-    return reflection.isInstance(item, EntityActionsDefinitions);
+    return reflection.isInstance(item, EntityActionsDefinitions.$type);
 }
 
 export interface EntityDefinition extends langium.AstNode {
@@ -591,10 +602,15 @@ export interface EntityDefinition extends langium.AstNode {
     schema: RecordSchemaDefinition;
 }
 
-export const EntityDefinition = 'EntityDefinition';
+export const EntityDefinition = {
+    $type: 'EntityDefinition',
+    extends: 'extends',
+    name: 'name',
+    schema: 'schema'
+} as const;
 
 export function isEntityDefinition(item: unknown): item is EntityDefinition {
-    return reflection.isInstance(item, EntityDefinition);
+    return reflection.isInstance(item, EntityDefinition.$type);
 }
 
 export interface EnumSpec extends langium.AstNode {
@@ -604,10 +620,14 @@ export interface EnumSpec extends langium.AstNode {
     values: Array<STRING>;
 }
 
-export const EnumSpec = 'EnumSpec';
+export const EnumSpec = {
+    $type: 'EnumSpec',
+    type: 'type',
+    values: 'values'
+} as const;
 
 export function isEnumSpec(item: unknown): item is EnumSpec {
-    return reflection.isInstance(item, EnumSpec);
+    return reflection.isInstance(item, EnumSpec.$type);
 }
 
 export interface EventDefinition extends langium.AstNode {
@@ -618,10 +638,25 @@ export interface EventDefinition extends langium.AstNode {
     schema: RecordSchemaDefinition;
 }
 
-export const EventDefinition = 'EventDefinition';
+export const EventDefinition = {
+    $type: 'EventDefinition',
+    extends: 'extends',
+    name: 'name',
+    schema: 'schema'
+} as const;
 
 export function isEventDefinition(item: unknown): item is EventDefinition {
-    return reflection.isInstance(item, EventDefinition);
+    return reflection.isInstance(item, EventDefinition.$type);
+}
+
+export type Expr = BinExpr | PrimExpr;
+
+export const Expr = {
+    $type: 'Expr'
+} as const;
+
+export function isExpr(item: unknown): item is Expr {
+    return reflection.isInstance(item, Expr.$type);
 }
 
 export interface ExtendsClause extends langium.AstNode {
@@ -630,10 +665,13 @@ export interface ExtendsClause extends langium.AstNode {
     parentName: QualifiedName;
 }
 
-export const ExtendsClause = 'ExtendsClause';
+export const ExtendsClause = {
+    $type: 'ExtendsClause',
+    parentName: 'parentName'
+} as const;
 
 export function isExtendsClause(item: unknown): item is ExtendsClause {
-    return reflection.isInstance(item, ExtendsClause);
+    return reflection.isInstance(item, ExtendsClause.$type);
 }
 
 export interface FlowDefBody extends langium.AstNode {
@@ -642,10 +680,13 @@ export interface FlowDefBody extends langium.AstNode {
     entries: Array<FlowEntry>;
 }
 
-export const FlowDefBody = 'FlowDefBody';
+export const FlowDefBody = {
+    $type: 'FlowDefBody',
+    entries: 'entries'
+} as const;
 
 export function isFlowDefBody(item: unknown): item is FlowDefBody {
-    return reflection.isInstance(item, FlowDefBody);
+    return reflection.isInstance(item, FlowDefBody.$type);
 }
 
 export interface FlowDefinition extends langium.AstNode {
@@ -655,10 +696,14 @@ export interface FlowDefinition extends langium.AstNode {
     name: GenericName;
 }
 
-export const FlowDefinition = 'FlowDefinition';
+export const FlowDefinition = {
+    $type: 'FlowDefinition',
+    body: 'body',
+    name: 'name'
+} as const;
 
 export function isFlowDefinition(item: unknown): item is FlowDefinition {
-    return reflection.isInstance(item, FlowDefinition);
+    return reflection.isInstance(item, FlowDefinition.$type);
 }
 
 export interface FlowEntry extends langium.AstNode {
@@ -669,10 +714,25 @@ export interface FlowEntry extends langium.AstNode {
     root: QueryId;
 }
 
-export const FlowEntry = 'FlowEntry';
+export const FlowEntry = {
+    $type: 'FlowEntry',
+    cond: 'cond',
+    next: 'next',
+    root: 'root'
+} as const;
 
 export function isFlowEntry(item: unknown): item is FlowEntry {
-    return reflection.isInstance(item, FlowEntry);
+    return reflection.isInstance(item, FlowEntry.$type);
+}
+
+export type FlowStepSpec = Statement;
+
+export const FlowStepSpec = {
+    $type: 'FlowStepSpec'
+} as const;
+
+export function isFlowStepSpec(item: unknown): item is FlowStepSpec {
+    return reflection.isInstance(item, FlowStepSpec.$type);
 }
 
 export interface FnCall extends langium.AstNode {
@@ -682,10 +742,14 @@ export interface FnCall extends langium.AstNode {
     name: Ref | string;
 }
 
-export const FnCall = 'FnCall';
+export const FnCall = {
+    $type: 'FnCall',
+    args: 'args',
+    name: 'name'
+} as const;
 
 export function isFnCall(item: unknown): item is FnCall {
-    return reflection.isInstance(item, FnCall);
+    return reflection.isInstance(item, FnCall.$type);
 }
 
 export interface ForEach extends langium.AstNode {
@@ -696,10 +760,15 @@ export interface ForEach extends langium.AstNode {
     var: string;
 }
 
-export const ForEach = 'ForEach';
+export const ForEach = {
+    $type: 'ForEach',
+    src: 'src',
+    statements: 'statements',
+    var: 'var'
+} as const;
 
 export function isForEach(item: unknown): item is ForEach {
-    return reflection.isInstance(item, ForEach);
+    return reflection.isInstance(item, ForEach.$type);
 }
 
 export interface FullTextSearch extends langium.AstNode {
@@ -710,10 +779,15 @@ export interface FullTextSearch extends langium.AstNode {
     query: Literal;
 }
 
-export const FullTextSearch = 'FullTextSearch';
+export const FullTextSearch = {
+    $type: 'FullTextSearch',
+    name: 'name',
+    options: 'options',
+    query: 'query'
+} as const;
 
 export function isFullTextSearch(item: unknown): item is FullTextSearch {
-    return reflection.isInstance(item, FullTextSearch);
+    return reflection.isInstance(item, FullTextSearch.$type);
 }
 
 export interface GenericDefBody extends langium.AstNode {
@@ -722,10 +796,19 @@ export interface GenericDefBody extends langium.AstNode {
     attributes: Array<GenericPropertyDef>;
 }
 
-export const GenericDefBody = 'GenericDefBody';
+export const GenericDefBody = {
+    $type: 'GenericDefBody',
+    attributes: 'attributes'
+} as const;
 
 export function isGenericDefBody(item: unknown): item is GenericDefBody {
-    return reflection.isInstance(item, GenericDefBody);
+    return reflection.isInstance(item, GenericDefBody.$type);
+}
+
+export type GenericName = STRING | string;
+
+export function isGenericName(item: unknown): item is GenericName {
+    return isSTRING(item) || (typeof item === 'string' && (/(?:[_a-zA-Z][\w_]*)(\/(?:[_a-zA-Z][\w_]*))?/.test(item)));
 }
 
 export interface GenericPropertyDef extends langium.AstNode {
@@ -735,10 +818,14 @@ export interface GenericPropertyDef extends langium.AstNode {
     value: Literal;
 }
 
-export const GenericPropertyDef = 'GenericPropertyDef';
+export const GenericPropertyDef = {
+    $type: 'GenericPropertyDef',
+    name: 'name',
+    value: 'value'
+} as const;
 
 export function isGenericPropertyDef(item: unknown): item is GenericPropertyDef {
-    return reflection.isInstance(item, GenericPropertyDef);
+    return reflection.isInstance(item, GenericPropertyDef.$type);
 }
 
 export interface GlossaryEntryDefinition extends langium.AstNode {
@@ -749,10 +836,15 @@ export interface GlossaryEntryDefinition extends langium.AstNode {
     name: Ref;
 }
 
-export const GlossaryEntryDefinition = 'GlossaryEntryDefinition';
+export const GlossaryEntryDefinition = {
+    $type: 'GlossaryEntryDefinition',
+    body: 'body',
+    glos: 'glos',
+    name: 'name'
+} as const;
 
 export function isGlossaryEntryDefinition(item: unknown): item is GlossaryEntryDefinition {
-    return reflection.isInstance(item, GlossaryEntryDefinition);
+    return reflection.isInstance(item, GlossaryEntryDefinition.$type);
 }
 
 export interface Group extends langium.AstNode {
@@ -761,10 +853,13 @@ export interface Group extends langium.AstNode {
     ge: Expr;
 }
 
-export const Group = 'Group';
+export const Group = {
+    $type: 'Group',
+    ge: 'ge'
+} as const;
 
 export function isGroup(item: unknown): item is Group {
-    return reflection.isInstance(item, Group);
+    return reflection.isInstance(item, Group.$type);
 }
 
 export interface GroupByClause extends langium.AstNode {
@@ -773,10 +868,13 @@ export interface GroupByClause extends langium.AstNode {
     colNames: Array<QualifiedName>;
 }
 
-export const GroupByClause = 'GroupByClause';
+export const GroupByClause = {
+    $type: 'GroupByClause',
+    colNames: 'colNames'
+} as const;
 
 export function isGroupByClause(item: unknown): item is GroupByClause {
-    return reflection.isInstance(item, GroupByClause);
+    return reflection.isInstance(item, GroupByClause.$type);
 }
 
 export interface Handler extends langium.AstNode {
@@ -786,10 +884,14 @@ export interface Handler extends langium.AstNode {
     stmt: Statement;
 }
 
-export const Handler = 'Handler';
+export const Handler = {
+    $type: 'Handler',
+    except: 'except',
+    stmt: 'stmt'
+} as const;
 
 export function isHandler(item: unknown): item is Handler {
-    return reflection.isInstance(item, Handler);
+    return reflection.isInstance(item, Handler.$type);
 }
 
 export interface If extends langium.AstNode {
@@ -800,10 +902,15 @@ export interface If extends langium.AstNode {
     statements: Array<Statement>;
 }
 
-export const If = 'If';
+export const If = {
+    $type: 'If',
+    cond: 'cond',
+    else: 'else',
+    statements: 'statements'
+} as const;
 
 export function isIf(item: unknown): item is If {
-    return reflection.isInstance(item, If);
+    return reflection.isInstance(item, If.$type);
 }
 
 export interface IfWithAlias extends langium.AstNode {
@@ -812,10 +919,13 @@ export interface IfWithAlias extends langium.AstNode {
     if: If;
 }
 
-export const IfWithAlias = 'IfWithAlias';
+export const IfWithAlias = {
+    $type: 'IfWithAlias',
+    if: 'if'
+} as const;
 
 export function isIfWithAlias(item: unknown): item is IfWithAlias {
-    return reflection.isInstance(item, IfWithAlias);
+    return reflection.isInstance(item, IfWithAlias.$type);
 }
 
 export interface Import extends langium.AstNode {
@@ -825,10 +935,14 @@ export interface Import extends langium.AstNode {
     path: STRING;
 }
 
-export const Import = 'Import';
+export const Import = {
+    $type: 'Import',
+    name: 'name',
+    path: 'path'
+} as const;
 
 export function isImport(item: unknown): item is Import {
-    return reflection.isInstance(item, Import);
+    return reflection.isInstance(item, Import.$type);
 }
 
 export interface JoinSpec extends langium.AstNode {
@@ -841,10 +955,23 @@ export interface JoinSpec extends langium.AstNode {
     type: JoinType;
 }
 
-export const JoinSpec = 'JoinSpec';
+export const JoinSpec = {
+    $type: 'JoinSpec',
+    lhs: 'lhs',
+    name: 'name',
+    op: 'op',
+    rhs: 'rhs',
+    type: 'type'
+} as const;
 
 export function isJoinSpec(item: unknown): item is JoinSpec {
-    return reflection.isInstance(item, JoinSpec);
+    return reflection.isInstance(item, JoinSpec.$type);
+}
+
+export type JoinType = '@full_join' | '@inner_join' | '@join' | '@left_join' | '@right_join';
+
+export function isJoinType(item: unknown): item is JoinType {
+    return item === '@join' || item === '@inner_join' || item === '@left_join' || item === '@right_join' || item === '@full_join';
 }
 
 export interface KvPair extends langium.AstNode {
@@ -854,10 +981,14 @@ export interface KvPair extends langium.AstNode {
     value: Literal;
 }
 
-export const KvPair = 'KvPair';
+export const KvPair = {
+    $type: 'KvPair',
+    key: 'key',
+    value: 'value'
+} as const;
 
 export function isKvPair(item: unknown): item is KvPair {
-    return reflection.isInstance(item, KvPair);
+    return reflection.isInstance(item, KvPair.$type);
 }
 
 export interface KvPairs extends langium.AstNode {
@@ -866,10 +997,13 @@ export interface KvPairs extends langium.AstNode {
     pairs: Array<KvPair>;
 }
 
-export const KvPairs = 'KvPairs';
+export const KvPairs = {
+    $type: 'KvPairs',
+    pairs: 'pairs'
+} as const;
 
 export function isKvPairs(item: unknown): item is KvPairs {
-    return reflection.isInstance(item, KvPairs);
+    return reflection.isInstance(item, KvPairs.$type);
 }
 
 export interface Literal extends langium.AstNode {
@@ -886,10 +1020,21 @@ export interface Literal extends langium.AstNode {
     str?: STRING;
 }
 
-export const Literal = 'Literal';
+export const Literal = {
+    $type: 'Literal',
+    array: 'array',
+    asyncFnCall: 'asyncFnCall',
+    bool: 'bool',
+    fnCall: 'fnCall',
+    id: 'id',
+    map: 'map',
+    num: 'num',
+    ref: 'ref',
+    str: 'str'
+} as const;
 
 export function isLiteral(item: unknown): item is Literal {
-    return reflection.isInstance(item, Literal);
+    return reflection.isInstance(item, Literal.$type);
 }
 
 export interface MapEntry extends langium.AstNode {
@@ -899,10 +1044,14 @@ export interface MapEntry extends langium.AstNode {
     value: Expr;
 }
 
-export const MapEntry = 'MapEntry';
+export const MapEntry = {
+    $type: 'MapEntry',
+    key: 'key',
+    value: 'value'
+} as const;
 
 export function isMapEntry(item: unknown): item is MapEntry {
-    return reflection.isInstance(item, MapEntry);
+    return reflection.isInstance(item, MapEntry.$type);
 }
 
 export interface MapKey extends langium.AstNode {
@@ -913,10 +1062,15 @@ export interface MapKey extends langium.AstNode {
     str?: STRING;
 }
 
-export const MapKey = 'MapKey';
+export const MapKey = {
+    $type: 'MapKey',
+    bool: 'bool',
+    num: 'num',
+    str: 'str'
+} as const;
 
 export function isMapKey(item: unknown): item is MapKey {
-    return reflection.isInstance(item, MapKey);
+    return reflection.isInstance(item, MapKey.$type);
 }
 
 export interface MapLiteral extends langium.AstNode {
@@ -925,10 +1079,13 @@ export interface MapLiteral extends langium.AstNode {
     entries: Array<MapEntry>;
 }
 
-export const MapLiteral = 'MapLiteral';
+export const MapLiteral = {
+    $type: 'MapLiteral',
+    entries: 'entries'
+} as const;
 
 export function isMapLiteral(item: unknown): item is MapLiteral {
-    return reflection.isInstance(item, MapLiteral);
+    return reflection.isInstance(item, MapLiteral.$type);
 }
 
 export interface MetaDefinition extends langium.AstNode {
@@ -937,10 +1094,13 @@ export interface MetaDefinition extends langium.AstNode {
     spec: MapLiteral;
 }
 
-export const MetaDefinition = 'MetaDefinition';
+export const MetaDefinition = {
+    $type: 'MetaDefinition',
+    spec: 'spec'
+} as const;
 
 export function isMetaDefinition(item: unknown): item is MetaDefinition {
-    return reflection.isInstance(item, MetaDefinition);
+    return reflection.isInstance(item, MetaDefinition.$type);
 }
 
 export interface ModuleDefinition extends langium.AstNode {
@@ -950,10 +1110,15 @@ export interface ModuleDefinition extends langium.AstNode {
     name: QualifiedName;
 }
 
-export const ModuleDefinition = 'ModuleDefinition';
+export const ModuleDefinition = {
+    $type: 'ModuleDefinition',
+    defs: 'defs',
+    imports: 'imports',
+    name: 'name'
+} as const;
 
 export function isModuleDefinition(item: unknown): item is ModuleDefinition {
-    return reflection.isInstance(item, ModuleDefinition);
+    return reflection.isInstance(item, ModuleDefinition.$type);
 }
 
 export interface NegExpr extends langium.AstNode {
@@ -962,10 +1127,13 @@ export interface NegExpr extends langium.AstNode {
     ne: Expr;
 }
 
-export const NegExpr = 'NegExpr';
+export const NegExpr = {
+    $type: 'NegExpr',
+    ne: 'ne'
+} as const;
 
 export function isNegExpr(item: unknown): item is NegExpr {
-    return reflection.isInstance(item, NegExpr);
+    return reflection.isInstance(item, NegExpr.$type);
 }
 
 export interface NodeDefinition extends langium.AstNode {
@@ -975,10 +1143,14 @@ export interface NodeDefinition extends langium.AstNode {
     name: QualifiedName;
 }
 
-export const NodeDefinition = 'NodeDefinition';
+export const NodeDefinition = {
+    $type: 'NodeDefinition',
+    alias: 'alias',
+    name: 'name'
+} as const;
 
 export function isNodeDefinition(item: unknown): item is NodeDefinition {
-    return reflection.isInstance(item, NodeDefinition);
+    return reflection.isInstance(item, NodeDefinition.$type);
 }
 
 export interface NotExpr extends langium.AstNode {
@@ -987,10 +1159,13 @@ export interface NotExpr extends langium.AstNode {
     ne: Expr;
 }
 
-export const NotExpr = 'NotExpr';
+export const NotExpr = {
+    $type: 'NotExpr',
+    ne: 'ne'
+} as const;
 
 export function isNotExpr(item: unknown): item is NotExpr {
-    return reflection.isInstance(item, NotExpr);
+    return reflection.isInstance(item, NotExpr.$type);
 }
 
 export interface OneOfSpec extends langium.AstNode {
@@ -999,10 +1174,13 @@ export interface OneOfSpec extends langium.AstNode {
     ref: Ref;
 }
 
-export const OneOfSpec = 'OneOfSpec';
+export const OneOfSpec = {
+    $type: 'OneOfSpec',
+    ref: 'ref'
+} as const;
 
 export function isOneOfSpec(item: unknown): item is OneOfSpec {
-    return reflection.isInstance(item, OneOfSpec);
+    return reflection.isInstance(item, OneOfSpec.$type);
 }
 
 export interface OrderByClause extends langium.AstNode {
@@ -1012,10 +1190,14 @@ export interface OrderByClause extends langium.AstNode {
     order?: '@asc' | '@desc';
 }
 
-export const OrderByClause = 'OrderByClause';
+export const OrderByClause = {
+    $type: 'OrderByClause',
+    colNames: 'colNames',
+    order: 'order'
+} as const;
 
 export function isOrderByClause(item: unknown): item is OrderByClause {
-    return reflection.isInstance(item, OrderByClause);
+    return reflection.isInstance(item, OrderByClause.$type);
 }
 
 export interface Pattern extends langium.AstNode {
@@ -1033,10 +1215,22 @@ export interface Pattern extends langium.AstNode {
     throwError?: ThrowError;
 }
 
-export const Pattern = 'Pattern';
+export const Pattern = {
+    $type: 'Pattern',
+    crudMap: 'crudMap',
+    delete: 'delete',
+    expr: 'expr',
+    forEach: 'forEach',
+    fullTextSearch: 'fullTextSearch',
+    if: 'if',
+    ifWithAlias: 'ifWithAlias',
+    purge: 'purge',
+    return: 'return',
+    throwError: 'throwError'
+} as const;
 
 export function isPattern(item: unknown): item is Pattern {
-    return reflection.isInstance(item, Pattern);
+    return reflection.isInstance(item, Pattern.$type);
 }
 
 export interface PrePostTriggerDefinition extends langium.AstNode {
@@ -1046,10 +1240,24 @@ export interface PrePostTriggerDefinition extends langium.AstNode {
     before?: BeforeTriggerDefinition;
 }
 
-export const PrePostTriggerDefinition = 'PrePostTriggerDefinition';
+export const PrePostTriggerDefinition = {
+    $type: 'PrePostTriggerDefinition',
+    after: 'after',
+    before: 'before'
+} as const;
 
 export function isPrePostTriggerDefinition(item: unknown): item is PrePostTriggerDefinition {
-    return reflection.isInstance(item, PrePostTriggerDefinition);
+    return reflection.isInstance(item, PrePostTriggerDefinition.$type);
+}
+
+export type PrimExpr = Group | Literal | NegExpr | NotExpr;
+
+export const PrimExpr = {
+    $type: 'PrimExpr'
+} as const;
+
+export function isPrimExpr(item: unknown): item is PrimExpr {
+    return reflection.isInstance(item, PrimExpr.$type);
 }
 
 export interface PropertyDefinition extends langium.AstNode {
@@ -1059,10 +1267,14 @@ export interface PropertyDefinition extends langium.AstNode {
     value?: KvPairs;
 }
 
-export const PropertyDefinition = 'PropertyDefinition';
+export const PropertyDefinition = {
+    $type: 'PropertyDefinition',
+    name: 'name',
+    value: 'value'
+} as const;
 
 export function isPropertyDefinition(item: unknown): item is PropertyDefinition {
-    return reflection.isInstance(item, PropertyDefinition);
+    return reflection.isInstance(item, PropertyDefinition.$type);
 }
 
 export interface PublicAgentDefinition extends langium.AstNode {
@@ -1071,10 +1283,13 @@ export interface PublicAgentDefinition extends langium.AstNode {
     def: AgentDefinition;
 }
 
-export const PublicAgentDefinition = 'PublicAgentDefinition';
+export const PublicAgentDefinition = {
+    $type: 'PublicAgentDefinition',
+    def: 'def'
+} as const;
 
 export function isPublicAgentDefinition(item: unknown): item is PublicAgentDefinition {
-    return reflection.isInstance(item, PublicAgentDefinition);
+    return reflection.isInstance(item, PublicAgentDefinition.$type);
 }
 
 export interface PublicEventDefinition extends langium.AstNode {
@@ -1083,10 +1298,13 @@ export interface PublicEventDefinition extends langium.AstNode {
     def: EventDefinition;
 }
 
-export const PublicEventDefinition = 'PublicEventDefinition';
+export const PublicEventDefinition = {
+    $type: 'PublicEventDefinition',
+    def: 'def'
+} as const;
 
 export function isPublicEventDefinition(item: unknown): item is PublicEventDefinition {
-    return reflection.isInstance(item, PublicEventDefinition);
+    return reflection.isInstance(item, PublicEventDefinition.$type);
 }
 
 export interface PublicWorkflowDefinition extends langium.AstNode {
@@ -1095,10 +1313,13 @@ export interface PublicWorkflowDefinition extends langium.AstNode {
     def: WorkflowDefinition;
 }
 
-export const PublicWorkflowDefinition = 'PublicWorkflowDefinition';
+export const PublicWorkflowDefinition = {
+    $type: 'PublicWorkflowDefinition',
+    def: 'def'
+} as const;
 
 export function isPublicWorkflowDefinition(item: unknown): item is PublicWorkflowDefinition {
-    return reflection.isInstance(item, PublicWorkflowDefinition);
+    return reflection.isInstance(item, PublicWorkflowDefinition.$type);
 }
 
 export interface Purge extends langium.AstNode {
@@ -1107,10 +1328,25 @@ export interface Purge extends langium.AstNode {
     pattern: Pattern;
 }
 
-export const Purge = 'Purge';
+export const Purge = {
+    $type: 'Purge',
+    pattern: 'pattern'
+} as const;
 
 export function isPurge(item: unknown): item is Purge {
-    return reflection.isInstance(item, Purge);
+    return reflection.isInstance(item, Purge.$type);
+}
+
+export type QualifiedName = Ref | string;
+
+export function isQualifiedName(item: unknown): item is QualifiedName {
+    return isRef(item) || (typeof item === 'string' && (/(?:[_a-zA-Z][\w_]*)(\/(?:[_a-zA-Z][\w_]*))?/.test(item)));
+}
+
+export type QueryId = string;
+
+export function isQueryId(item: unknown): item is QueryId {
+    return typeof item === 'string';
 }
 
 export interface RbacAllowSpec extends langium.AstNode {
@@ -1119,10 +1355,13 @@ export interface RbacAllowSpec extends langium.AstNode {
     oprs: Array<RbacOpr>;
 }
 
-export const RbacAllowSpec = 'RbacAllowSpec';
+export const RbacAllowSpec = {
+    $type: 'RbacAllowSpec',
+    oprs: 'oprs'
+} as const;
 
 export function isRbacAllowSpec(item: unknown): item is RbacAllowSpec {
-    return reflection.isInstance(item, RbacAllowSpec);
+    return reflection.isInstance(item, RbacAllowSpec.$type);
 }
 
 export interface RbacExpressionSpec extends langium.AstNode {
@@ -1132,10 +1371,14 @@ export interface RbacExpressionSpec extends langium.AstNode {
     rhs: Ref;
 }
 
-export const RbacExpressionSpec = 'RbacExpressionSpec';
+export const RbacExpressionSpec = {
+    $type: 'RbacExpressionSpec',
+    lhs: 'lhs',
+    rhs: 'rhs'
+} as const;
 
 export function isRbacExpressionSpec(item: unknown): item is RbacExpressionSpec {
-    return reflection.isInstance(item, RbacExpressionSpec);
+    return reflection.isInstance(item, RbacExpressionSpec.$type);
 }
 
 export interface RbacOpr extends langium.AstNode {
@@ -1144,10 +1387,13 @@ export interface RbacOpr extends langium.AstNode {
     value: 'create' | 'delete' | 'read' | 'update';
 }
 
-export const RbacOpr = 'RbacOpr';
+export const RbacOpr = {
+    $type: 'RbacOpr',
+    value: 'value'
+} as const;
 
 export function isRbacOpr(item: unknown): item is RbacOpr {
-    return reflection.isInstance(item, RbacOpr);
+    return reflection.isInstance(item, RbacOpr.$type);
 }
 
 export interface RbacRolesSpec extends langium.AstNode {
@@ -1156,10 +1402,13 @@ export interface RbacRolesSpec extends langium.AstNode {
     roles: Array<'*' | string>;
 }
 
-export const RbacRolesSpec = 'RbacRolesSpec';
+export const RbacRolesSpec = {
+    $type: 'RbacRolesSpec',
+    roles: 'roles'
+} as const;
 
 export function isRbacRolesSpec(item: unknown): item is RbacRolesSpec {
-    return reflection.isInstance(item, RbacRolesSpec);
+    return reflection.isInstance(item, RbacRolesSpec.$type);
 }
 
 export interface RbacSpecDefinition extends langium.AstNode {
@@ -1168,10 +1417,13 @@ export interface RbacSpecDefinition extends langium.AstNode {
     specEntries: Array<RbacSpecEntries>;
 }
 
-export const RbacSpecDefinition = 'RbacSpecDefinition';
+export const RbacSpecDefinition = {
+    $type: 'RbacSpecDefinition',
+    specEntries: 'specEntries'
+} as const;
 
 export function isRbacSpecDefinition(item: unknown): item is RbacSpecDefinition {
-    return reflection.isInstance(item, RbacSpecDefinition);
+    return reflection.isInstance(item, RbacSpecDefinition.$type);
 }
 
 export interface RbacSpecEntries extends langium.AstNode {
@@ -1180,10 +1432,13 @@ export interface RbacSpecEntries extends langium.AstNode {
     entries: Array<RbacSpecEntry>;
 }
 
-export const RbacSpecEntries = 'RbacSpecEntries';
+export const RbacSpecEntries = {
+    $type: 'RbacSpecEntries',
+    entries: 'entries'
+} as const;
 
 export function isRbacSpecEntries(item: unknown): item is RbacSpecEntries {
-    return reflection.isInstance(item, RbacSpecEntries);
+    return reflection.isInstance(item, RbacSpecEntries.$type);
 }
 
 export interface RbacSpecEntry extends langium.AstNode {
@@ -1194,10 +1449,15 @@ export interface RbacSpecEntry extends langium.AstNode {
     role?: RbacRolesSpec;
 }
 
-export const RbacSpecEntry = 'RbacSpecEntry';
+export const RbacSpecEntry = {
+    $type: 'RbacSpecEntry',
+    allow: 'allow',
+    expr: 'expr',
+    role: 'role'
+} as const;
 
 export function isRbacSpecEntry(item: unknown): item is RbacSpecEntry {
-    return reflection.isInstance(item, RbacSpecEntry);
+    return reflection.isInstance(item, RbacSpecEntry.$type);
 }
 
 export interface RecordDefinition extends langium.AstNode {
@@ -1208,10 +1468,15 @@ export interface RecordDefinition extends langium.AstNode {
     schema: RecordSchemaDefinition;
 }
 
-export const RecordDefinition = 'RecordDefinition';
+export const RecordDefinition = {
+    $type: 'RecordDefinition',
+    extends: 'extends',
+    name: 'name',
+    schema: 'schema'
+} as const;
 
 export function isRecordDefinition(item: unknown): item is RecordDefinition {
-    return reflection.isInstance(item, RecordDefinition);
+    return reflection.isInstance(item, RecordDefinition.$type);
 }
 
 export interface RecordExtraDefinition extends langium.AstNode {
@@ -1224,10 +1489,17 @@ export interface RecordExtraDefinition extends langium.AstNode {
     uq?: CompositeUniqueDefinition;
 }
 
-export const RecordExtraDefinition = 'RecordExtraDefinition';
+export const RecordExtraDefinition = {
+    $type: 'RecordExtraDefinition',
+    actions: 'actions',
+    meta: 'meta',
+    prePost: 'prePost',
+    rbacSpec: 'rbacSpec',
+    uq: 'uq'
+} as const;
 
 export function isRecordExtraDefinition(item: unknown): item is RecordExtraDefinition {
-    return reflection.isInstance(item, RecordExtraDefinition);
+    return reflection.isInstance(item, RecordExtraDefinition.$type);
 }
 
 export interface RecordSchemaDefinition extends langium.AstNode {
@@ -1237,10 +1509,20 @@ export interface RecordSchemaDefinition extends langium.AstNode {
     extras: Array<RecordExtraDefinition>;
 }
 
-export const RecordSchemaDefinition = 'RecordSchemaDefinition';
+export const RecordSchemaDefinition = {
+    $type: 'RecordSchemaDefinition',
+    attributes: 'attributes',
+    extras: 'extras'
+} as const;
 
 export function isRecordSchemaDefinition(item: unknown): item is RecordSchemaDefinition {
-    return reflection.isInstance(item, RecordSchemaDefinition);
+    return reflection.isInstance(item, RecordSchemaDefinition.$type);
+}
+
+export type Ref = string;
+
+export function isRef(item: unknown): item is Ref {
+    return typeof item === 'string';
 }
 
 export interface RefSpec extends langium.AstNode {
@@ -1250,10 +1532,14 @@ export interface RefSpec extends langium.AstNode {
     type?: QualifiedName;
 }
 
-export const RefSpec = 'RefSpec';
+export const RefSpec = {
+    $type: 'RefSpec',
+    ref: 'ref',
+    type: 'type'
+} as const;
 
 export function isRefSpec(item: unknown): item is RefSpec {
-    return reflection.isInstance(item, RefSpec);
+    return reflection.isInstance(item, RefSpec.$type);
 }
 
 export interface RelationshipDefinition extends langium.AstNode {
@@ -1266,10 +1552,17 @@ export interface RelationshipDefinition extends langium.AstNode {
     type: 'between' | 'contains';
 }
 
-export const RelationshipDefinition = 'RelationshipDefinition';
+export const RelationshipDefinition = {
+    $type: 'RelationshipDefinition',
+    name: 'name',
+    nodes: 'nodes',
+    properties: 'properties',
+    schema: 'schema',
+    type: 'type'
+} as const;
 
 export function isRelationshipDefinition(item: unknown): item is RelationshipDefinition {
-    return reflection.isInstance(item, RelationshipDefinition);
+    return reflection.isInstance(item, RelationshipDefinition.$type);
 }
 
 export interface RelationshipPattern extends langium.AstNode {
@@ -1279,10 +1572,14 @@ export interface RelationshipPattern extends langium.AstNode {
     pattern: Pattern;
 }
 
-export const RelationshipPattern = 'RelationshipPattern';
+export const RelationshipPattern = {
+    $type: 'RelationshipPattern',
+    name: 'name',
+    pattern: 'pattern'
+} as const;
 
 export function isRelationshipPattern(item: unknown): item is RelationshipPattern {
-    return reflection.isInstance(item, RelationshipPattern);
+    return reflection.isInstance(item, RelationshipPattern.$type);
 }
 
 export interface RelNodes extends langium.AstNode {
@@ -1292,10 +1589,14 @@ export interface RelNodes extends langium.AstNode {
     node2: NodeDefinition;
 }
 
-export const RelNodes = 'RelNodes';
+export const RelNodes = {
+    $type: 'RelNodes',
+    node1: 'node1',
+    node2: 'node2'
+} as const;
 
 export function isRelNodes(item: unknown): item is RelNodes {
-    return reflection.isInstance(item, RelNodes);
+    return reflection.isInstance(item, RelNodes.$type);
 }
 
 export interface ResolverDefinition extends langium.AstNode {
@@ -1306,10 +1607,15 @@ export interface ResolverDefinition extends langium.AstNode {
     paths: Array<ResolverPathEntry>;
 }
 
-export const ResolverDefinition = 'ResolverDefinition';
+export const ResolverDefinition = {
+    $type: 'ResolverDefinition',
+    methods: 'methods',
+    name: 'name',
+    paths: 'paths'
+} as const;
 
 export function isResolverDefinition(item: unknown): item is ResolverDefinition {
-    return reflection.isInstance(item, ResolverDefinition);
+    return reflection.isInstance(item, ResolverDefinition.$type);
 }
 
 export interface ResolverFnName extends langium.AstNode {
@@ -1318,10 +1624,13 @@ export interface ResolverFnName extends langium.AstNode {
     name: Ref | STRING | string;
 }
 
-export const ResolverFnName = 'ResolverFnName';
+export const ResolverFnName = {
+    $type: 'ResolverFnName',
+    name: 'name'
+} as const;
 
 export function isResolverFnName(item: unknown): item is ResolverFnName {
-    return reflection.isInstance(item, ResolverFnName);
+    return reflection.isInstance(item, ResolverFnName.$type);
 }
 
 export interface ResolverMethodName extends langium.AstNode {
@@ -1330,10 +1639,13 @@ export interface ResolverMethodName extends langium.AstNode {
     name: 'commitTransaction' | 'create' | 'delete' | 'onSubscription' | 'query' | 'rollbackTransaction' | 'startTransaction' | 'subscribe' | 'update' | 'upsert';
 }
 
-export const ResolverMethodName = 'ResolverMethodName';
+export const ResolverMethodName = {
+    $type: 'ResolverMethodName',
+    name: 'name'
+} as const;
 
 export function isResolverMethodName(item: unknown): item is ResolverMethodName {
-    return reflection.isInstance(item, ResolverMethodName);
+    return reflection.isInstance(item, ResolverMethodName.$type);
 }
 
 export interface ResolverMethodSpec extends langium.AstNode {
@@ -1343,10 +1655,20 @@ export interface ResolverMethodSpec extends langium.AstNode {
     key: ResolverMethodName;
 }
 
-export const ResolverMethodSpec = 'ResolverMethodSpec';
+export const ResolverMethodSpec = {
+    $type: 'ResolverMethodSpec',
+    fn: 'fn',
+    key: 'key'
+} as const;
 
 export function isResolverMethodSpec(item: unknown): item is ResolverMethodSpec {
-    return reflection.isInstance(item, ResolverMethodSpec);
+    return reflection.isInstance(item, ResolverMethodSpec.$type);
+}
+
+export type ResolverPathEntry = GenericName | QualifiedName;
+
+export function isResolverPathEntry(item: unknown): item is ResolverPathEntry {
+    return isQualifiedName(item) || isGenericName(item);
 }
 
 export interface RetryDefinition extends langium.AstNode {
@@ -1357,10 +1679,15 @@ export interface RetryDefinition extends langium.AstNode {
     name: string;
 }
 
-export const RetryDefinition = 'RetryDefinition';
+export const RetryDefinition = {
+    $type: 'RetryDefinition',
+    attempts: 'attempts',
+    backoff: 'backoff',
+    name: 'name'
+} as const;
 
 export function isRetryDefinition(item: unknown): item is RetryDefinition {
-    return reflection.isInstance(item, RetryDefinition);
+    return reflection.isInstance(item, RetryDefinition.$type);
 }
 
 export interface Return extends langium.AstNode {
@@ -1369,10 +1696,13 @@ export interface Return extends langium.AstNode {
     pattern: Pattern;
 }
 
-export const Return = 'Return';
+export const Return = {
+    $type: 'Return',
+    pattern: 'pattern'
+} as const;
 
 export function isReturn(item: unknown): item is Return {
-    return reflection.isInstance(item, Return);
+    return reflection.isInstance(item, Return.$type);
 }
 
 export interface RuntimeHint extends langium.AstNode {
@@ -1383,10 +1713,15 @@ export interface RuntimeHint extends langium.AstNode {
     thenSpec?: ThenSpec;
 }
 
-export const RuntimeHint = 'RuntimeHint';
+export const RuntimeHint = {
+    $type: 'RuntimeHint',
+    aliasSpec: 'aliasSpec',
+    catchSpec: 'catchSpec',
+    thenSpec: 'thenSpec'
+} as const;
 
 export function isRuntimeHint(item: unknown): item is RuntimeHint {
-    return reflection.isInstance(item, RuntimeHint);
+    return reflection.isInstance(item, RuntimeHint.$type);
 }
 
 export interface ScenarioDefinition extends langium.AstNode {
@@ -1397,10 +1732,25 @@ export interface ScenarioDefinition extends langium.AstNode {
     scn?: If;
 }
 
-export const ScenarioDefinition = 'ScenarioDefinition';
+export const ScenarioDefinition = {
+    $type: 'ScenarioDefinition',
+    body: 'body',
+    name: 'name',
+    scn: 'scn'
+} as const;
 
 export function isScenarioDefinition(item: unknown): item is ScenarioDefinition {
-    return reflection.isInstance(item, ScenarioDefinition);
+    return reflection.isInstance(item, ScenarioDefinition.$type);
+}
+
+export type SchemaDefinition = EntityDefinition | EventDefinition | PublicEventDefinition | RecordDefinition;
+
+export const SchemaDefinition = {
+    $type: 'SchemaDefinition'
+} as const;
+
+export function isSchemaDefinition(item: unknown): item is SchemaDefinition {
+    return reflection.isInstance(item, SchemaDefinition.$type);
 }
 
 export interface SelectIntoEntry extends langium.AstNode {
@@ -1411,10 +1761,15 @@ export interface SelectIntoEntry extends langium.AstNode {
     attribute?: Ref;
 }
 
-export const SelectIntoEntry = 'SelectIntoEntry';
+export const SelectIntoEntry = {
+    $type: 'SelectIntoEntry',
+    aggregate: 'aggregate',
+    alias: 'alias',
+    attribute: 'attribute'
+} as const;
 
 export function isSelectIntoEntry(item: unknown): item is SelectIntoEntry {
-    return reflection.isInstance(item, SelectIntoEntry);
+    return reflection.isInstance(item, SelectIntoEntry.$type);
 }
 
 export interface SelectIntoSpec extends langium.AstNode {
@@ -1423,10 +1778,13 @@ export interface SelectIntoSpec extends langium.AstNode {
     entries: Array<SelectIntoEntry>;
 }
 
-export const SelectIntoSpec = 'SelectIntoSpec';
+export const SelectIntoSpec = {
+    $type: 'SelectIntoSpec',
+    entries: 'entries'
+} as const;
 
 export function isSelectIntoSpec(item: unknown): item is SelectIntoSpec {
-    return reflection.isInstance(item, SelectIntoSpec);
+    return reflection.isInstance(item, SelectIntoSpec.$type);
 }
 
 export interface SetAttribute extends langium.AstNode {
@@ -1438,10 +1796,22 @@ export interface SetAttribute extends langium.AstNode {
     value?: AttributeValueExpression;
 }
 
-export const SetAttribute = 'SetAttribute';
+export const SetAttribute = {
+    $type: 'SetAttribute',
+    aggregate: 'aggregate',
+    name: 'name',
+    op: 'op',
+    value: 'value'
+} as const;
 
 export function isSetAttribute(item: unknown): item is SetAttribute {
-    return reflection.isInstance(item, SetAttribute);
+    return reflection.isInstance(item, SetAttribute.$type);
+}
+
+export type SqlComparisonOpr = '!=' | '<' | '<=' | '<>' | '=' | '>' | '>=' | 'between' | 'in' | 'like';
+
+export function isSqlComparisonOpr(item: unknown): item is SqlComparisonOpr {
+    return item === '=' || item === '<>' || item === '!=' || item === '<' || item === '<=' || item === '>' || item === '>=' || item === 'in' || item === 'like' || item === 'between';
 }
 
 export interface StandaloneStatement extends langium.AstNode {
@@ -1450,10 +1820,13 @@ export interface StandaloneStatement extends langium.AstNode {
     stmt: Statement;
 }
 
-export const StandaloneStatement = 'StandaloneStatement';
+export const StandaloneStatement = {
+    $type: 'StandaloneStatement',
+    stmt: 'stmt'
+} as const;
 
 export function isStandaloneStatement(item: unknown): item is StandaloneStatement {
-    return reflection.isInstance(item, StandaloneStatement);
+    return reflection.isInstance(item, StandaloneStatement.$type);
 }
 
 export interface Statement extends langium.AstNode {
@@ -1463,10 +1836,26 @@ export interface Statement extends langium.AstNode {
     pattern: Pattern;
 }
 
-export const Statement = 'Statement';
+export const Statement = {
+    $type: 'Statement',
+    hints: 'hints',
+    pattern: 'pattern'
+} as const;
 
 export function isStatement(item: unknown): item is Statement {
-    return reflection.isInstance(item, Statement);
+    return reflection.isInstance(item, Statement.$type);
+}
+
+export type STRING = string;
+
+export function isSTRING(item: unknown): item is STRING {
+    return (typeof item === 'string' && (/"(\\(?:[\s\S])|(?:(?!(\\|"|\r|\n))[\s\S]*?)|\r?\n)*"/.test(item) || /`(\\(?:[\s\S])|(?:(?!(\\|`|\r|\n))[\s\S]*?)|\r?\n)*`/.test(item)));
+}
+
+export type TaggedId = string;
+
+export function isTaggedId(item: unknown): item is TaggedId {
+    return typeof item === 'string';
 }
 
 export interface ThenSpec extends langium.AstNode {
@@ -1475,10 +1864,13 @@ export interface ThenSpec extends langium.AstNode {
     statements: Array<Statement>;
 }
 
-export const ThenSpec = 'ThenSpec';
+export const ThenSpec = {
+    $type: 'ThenSpec',
+    statements: 'statements'
+} as const;
 
 export function isThenSpec(item: unknown): item is ThenSpec {
-    return reflection.isInstance(item, ThenSpec);
+    return reflection.isInstance(item, ThenSpec.$type);
 }
 
 export interface ThrowError extends langium.AstNode {
@@ -1487,10 +1879,13 @@ export interface ThrowError extends langium.AstNode {
     reason: Expr;
 }
 
-export const ThrowError = 'ThrowError';
+export const ThrowError = {
+    $type: 'ThrowError',
+    reason: 'reason'
+} as const;
 
 export function isThrowError(item: unknown): item is ThrowError {
-    return reflection.isInstance(item, ThrowError);
+    return reflection.isInstance(item, ThrowError.$type);
 }
 
 export interface TriggerDefinition extends langium.AstNode {
@@ -1499,10 +1894,13 @@ export interface TriggerDefinition extends langium.AstNode {
     entries: Array<TriggerEntry>;
 }
 
-export const TriggerDefinition = 'TriggerDefinition';
+export const TriggerDefinition = {
+    $type: 'TriggerDefinition',
+    entries: 'entries'
+} as const;
 
 export function isTriggerDefinition(item: unknown): item is TriggerDefinition {
-    return reflection.isInstance(item, TriggerDefinition);
+    return reflection.isInstance(item, TriggerDefinition.$type);
 }
 
 export interface TriggerEntry extends langium.AstNode {
@@ -1513,10 +1911,15 @@ export interface TriggerEntry extends langium.AstNode {
     on: 'create' | 'delete' | 'update';
 }
 
-export const TriggerEntry = 'TriggerEntry';
+export const TriggerEntry = {
+    $type: 'TriggerEntry',
+    async: 'async',
+    event: 'event',
+    on: 'on'
+} as const;
 
 export function isTriggerEntry(item: unknown): item is TriggerEntry {
-    return reflection.isInstance(item, TriggerEntry);
+    return reflection.isInstance(item, TriggerEntry.$type);
 }
 
 export interface WhereSpec extends langium.AstNode {
@@ -1525,10 +1928,13 @@ export interface WhereSpec extends langium.AstNode {
     clauses: Array<WhereSpecClause>;
 }
 
-export const WhereSpec = 'WhereSpec';
+export const WhereSpec = {
+    $type: 'WhereSpec',
+    clauses: 'clauses'
+} as const;
 
 export function isWhereSpec(item: unknown): item is WhereSpec {
-    return reflection.isInstance(item, WhereSpec);
+    return reflection.isInstance(item, WhereSpec.$type);
 }
 
 export interface WhereSpecClause extends langium.AstNode {
@@ -1539,10 +1945,15 @@ export interface WhereSpecClause extends langium.AstNode {
     rhs: Expr;
 }
 
-export const WhereSpecClause = 'WhereSpecClause';
+export const WhereSpecClause = {
+    $type: 'WhereSpecClause',
+    lhs: 'lhs',
+    op: 'op',
+    rhs: 'rhs'
+} as const;
 
 export function isWhereSpecClause(item: unknown): item is WhereSpecClause {
-    return reflection.isInstance(item, WhereSpecClause);
+    return reflection.isInstance(item, WhereSpecClause.$type);
 }
 
 export interface WorkflowDefinition extends langium.AstNode {
@@ -1553,10 +1964,15 @@ export interface WorkflowDefinition extends langium.AstNode {
     statements: Array<Statement>;
 }
 
-export const WorkflowDefinition = 'WorkflowDefinition';
+export const WorkflowDefinition = {
+    $type: 'WorkflowDefinition',
+    header: 'header',
+    name: 'name',
+    statements: 'statements'
+} as const;
 
 export function isWorkflowDefinition(item: unknown): item is WorkflowDefinition {
-    return reflection.isInstance(item, WorkflowDefinition);
+    return reflection.isInstance(item, WorkflowDefinition.$type);
 }
 
 export interface WorkflowHeader extends langium.AstNode {
@@ -1567,10 +1983,27 @@ export interface WorkflowHeader extends langium.AstNode {
     tag: WorkflowHeaderTag;
 }
 
-export const WorkflowHeader = 'WorkflowHeader';
+export const WorkflowHeader = {
+    $type: 'WorkflowHeader',
+    name: 'name',
+    prefix: 'prefix',
+    tag: 'tag'
+} as const;
 
 export function isWorkflowHeader(item: unknown): item is WorkflowHeader {
-    return reflection.isInstance(item, WorkflowHeader);
+    return reflection.isInstance(item, WorkflowHeader.$type);
+}
+
+export type WorkflowHeaderPrefix = 'create' | 'delete' | 'update';
+
+export function isWorkflowHeaderPrefix(item: unknown): item is WorkflowHeaderPrefix {
+    return item === 'create' || item === 'update' || item === 'delete';
+}
+
+export type WorkflowHeaderTag = '@after' | '@before';
+
+export function isWorkflowHeaderTag(item: unknown): item is WorkflowHeaderTag {
+    return item === '@after' || item === '@before';
 }
 
 export type AgentlangAstType = {
@@ -1683,997 +2116,1352 @@ export type AgentlangAstType = {
 }
 
 export class AgentlangAstReflection extends langium.AbstractAstReflection {
-
-    getAllTypes(): string[] {
-        return [ActionEntry, AfterTriggerDefinition, AgentDefinition, AgentXtraAttribute, AgentXtraSpec, AggregateFunctionSpec, AliasSpec, ArrayLiteral, AsyncFnCall, AttributeDefinition, AttributeValueExpression, BackoffSpec, BeforeTriggerDefinition, BinExpr, CaseEntry, CatchSpec, CompositeUniqueDefinition, ConditionalFlowStep, CrudMap, CrudMapBody, DecisionDefBody, DecisionDefinition, Definition, Delete, DirectiveDefinition, Else, EntityActionsDefinitions, EntityDefinition, EnumSpec, EventDefinition, Expr, ExtendsClause, FlowDefBody, FlowDefinition, FlowEntry, FlowStepSpec, FnCall, ForEach, FullTextSearch, GenericDefBody, GenericPropertyDef, GlossaryEntryDefinition, Group, GroupByClause, Handler, If, IfWithAlias, Import, JoinSpec, KvPair, KvPairs, Literal, MapEntry, MapKey, MapLiteral, MetaDefinition, ModuleDefinition, NegExpr, NodeDefinition, NotExpr, OneOfSpec, OrderByClause, Pattern, PrePostTriggerDefinition, PrimExpr, PropertyDefinition, PublicAgentDefinition, PublicEventDefinition, PublicWorkflowDefinition, Purge, RbacAllowSpec, RbacExpressionSpec, RbacOpr, RbacRolesSpec, RbacSpecDefinition, RbacSpecEntries, RbacSpecEntry, RecordDefinition, RecordExtraDefinition, RecordSchemaDefinition, RefSpec, RelNodes, RelationshipDefinition, RelationshipPattern, ResolverDefinition, ResolverFnName, ResolverMethodName, ResolverMethodSpec, RetryDefinition, Return, RuntimeHint, ScenarioDefinition, SchemaDefinition, SelectIntoEntry, SelectIntoSpec, SetAttribute, StandaloneStatement, Statement, ThenSpec, ThrowError, TriggerDefinition, TriggerEntry, WhereSpec, WhereSpecClause, WorkflowDefinition, WorkflowHeader];
-    }
-
-    protected override computeIsSubtype(subtype: string, supertype: string): boolean {
-        switch (subtype) {
-            case AgentDefinition:
-            case DecisionDefinition:
-            case DirectiveDefinition:
-            case FlowDefinition:
-            case GlossaryEntryDefinition:
-            case PublicAgentDefinition:
-            case PublicWorkflowDefinition:
-            case RelationshipDefinition:
-            case ResolverDefinition:
-            case RetryDefinition:
-            case ScenarioDefinition:
-            case SchemaDefinition:
-            case StandaloneStatement:
-            case WorkflowDefinition: {
-                return this.isSubtype(Definition, supertype);
-            }
-            case BinExpr:
-            case PrimExpr: {
-                return this.isSubtype(Expr, supertype);
-            }
-            case EntityDefinition:
-            case EventDefinition:
-            case PublicEventDefinition:
-            case RecordDefinition: {
-                return this.isSubtype(SchemaDefinition, supertype);
-            }
-            case Expr: {
-                return this.isSubtype(AttributeValueExpression, supertype);
-            }
-            case Group:
-            case Literal:
-            case NegExpr:
-            case NotExpr: {
-                return this.isSubtype(PrimExpr, supertype);
-            }
-            case Statement: {
-                return this.isSubtype(FlowStepSpec, supertype);
-            }
-            default: {
-                return false;
-            }
-        }
-    }
-
-    getReferenceType(refInfo: langium.ReferenceInfo): string {
-        const referenceId = `${refInfo.container.$type}:${refInfo.property}`;
-        switch (referenceId) {
-            default: {
-                throw new Error(`${referenceId} is not a valid reference id.`);
-            }
-        }
-    }
-
-    getTypeMetaData(type: string): langium.TypeMetaData {
-        switch (type) {
-            case ActionEntry: {
-                return {
-                    name: ActionEntry,
-                    properties: [
-                        { name: 'event' },
-                        { name: 'name' }
-                    ]
-                };
-            }
-            case AfterTriggerDefinition: {
-                return {
-                    name: AfterTriggerDefinition,
-                    properties: [
-                        { name: 'triggers' }
-                    ]
-                };
-            }
-            case AgentDefinition: {
-                return {
-                    name: AgentDefinition,
-                    properties: [
-                        { name: 'body' },
-                        { name: 'name' }
-                    ]
-                };
-            }
-            case AgentXtraAttribute: {
-                return {
-                    name: AgentXtraAttribute,
-                    properties: [
-                        { name: 'name' },
-                        { name: 'value' }
-                    ]
-                };
-            }
-            case AgentXtraSpec: {
-                return {
-                    name: AgentXtraSpec,
-                    properties: [
-                        { name: 'attributes', defaultValue: [] }
-                    ]
-                };
-            }
-            case AggregateFunctionSpec: {
-                return {
-                    name: AggregateFunctionSpec,
-                    properties: [
-                        { name: 'args', defaultValue: [] },
-                        { name: 'name' }
-                    ]
-                };
-            }
-            case AliasSpec: {
-                return {
-                    name: AliasSpec,
-                    properties: [
-                        { name: 'alias' },
-                        { name: 'aliases', defaultValue: [] }
-                    ]
-                };
-            }
-            case ArrayLiteral: {
-                return {
-                    name: ArrayLiteral,
-                    properties: [
-                        { name: 'vals', defaultValue: [] }
-                    ]
-                };
-            }
-            case AsyncFnCall: {
-                return {
-                    name: AsyncFnCall,
-                    properties: [
-                        { name: 'fnCall' }
-                    ]
-                };
-            }
-            case AttributeDefinition: {
-                return {
-                    name: AttributeDefinition,
-                    properties: [
-                        { name: 'arrayType' },
-                        { name: 'enumSpec' },
-                        { name: 'expr' },
-                        { name: 'name' },
-                        { name: 'oneOfSpec' },
-                        { name: 'properties', defaultValue: [] },
-                        { name: 'refSpec' },
-                        { name: 'type' }
-                    ]
-                };
-            }
-            case BackoffSpec: {
-                return {
-                    name: BackoffSpec,
-                    properties: [
-                        { name: 'attributes', defaultValue: [] }
-                    ]
-                };
-            }
-            case BeforeTriggerDefinition: {
-                return {
-                    name: BeforeTriggerDefinition,
-                    properties: [
-                        { name: 'triggers' }
-                    ]
-                };
-            }
-            case BinExpr: {
-                return {
-                    name: BinExpr,
-                    properties: [
-                        { name: 'e1' },
-                        { name: 'e2' },
-                        { name: 'op' }
-                    ]
-                };
-            }
-            case CaseEntry: {
-                return {
-                    name: CaseEntry,
-                    properties: [
-                        { name: 'cond' },
-                        { name: 'statements', defaultValue: [] }
-                    ]
-                };
-            }
-            case CatchSpec: {
-                return {
-                    name: CatchSpec,
-                    properties: [
-                        { name: 'handlers', defaultValue: [] }
-                    ]
-                };
-            }
-            case CompositeUniqueDefinition: {
-                return {
-                    name: CompositeUniqueDefinition,
-                    properties: [
-                        { name: 'attrs', defaultValue: [] }
-                    ]
-                };
-            }
-            case ConditionalFlowStep: {
-                return {
-                    name: ConditionalFlowStep,
-                    properties: [
-                        { name: 'expr' },
-                        { name: 'next' }
-                    ]
-                };
-            }
-            case CrudMap: {
-                return {
-                    name: CrudMap,
-                    properties: [
-                        { name: 'body' },
-                        { name: 'distinct', defaultValue: [] },
-                        { name: 'groupByClause' },
-                        { name: 'into' },
-                        { name: 'joins', defaultValue: [] },
-                        { name: 'name' },
-                        { name: 'orderByClause' },
-                        { name: 'relationships', defaultValue: [] },
-                        { name: 'source' },
-                        { name: 'upsert', defaultValue: [] },
-                        { name: 'where' }
-                    ]
-                };
-            }
-            case CrudMapBody: {
-                return {
-                    name: CrudMapBody,
-                    properties: [
-                        { name: 'attributes', defaultValue: [] },
-                        { name: 'properties', defaultValue: [] }
-                    ]
-                };
-            }
-            case DecisionDefBody: {
-                return {
-                    name: DecisionDefBody,
-                    properties: [
-                        { name: 'cases', defaultValue: [] }
-                    ]
-                };
-            }
-            case DecisionDefinition: {
-                return {
-                    name: DecisionDefinition,
-                    properties: [
-                        { name: 'body' },
-                        { name: 'name' }
-                    ]
-                };
-            }
-            case Delete: {
-                return {
-                    name: Delete,
-                    properties: [
-                        { name: 'pattern' }
-                    ]
-                };
-            }
-            case DirectiveDefinition: {
-                return {
-                    name: DirectiveDefinition,
-                    properties: [
-                        { name: 'body' },
-                        { name: 'dir' },
-                        { name: 'name' }
-                    ]
-                };
-            }
-            case Else: {
-                return {
-                    name: Else,
-                    properties: [
-                        { name: 'statements', defaultValue: [] }
-                    ]
-                };
-            }
-            case EntityActionsDefinitions: {
-                return {
-                    name: EntityActionsDefinitions,
-                    properties: [
-                        { name: 'entries', defaultValue: [] }
-                    ]
-                };
-            }
-            case EntityDefinition: {
-                return {
-                    name: EntityDefinition,
-                    properties: [
-                        { name: 'extends' },
-                        { name: 'name' },
-                        { name: 'schema' }
-                    ]
-                };
-            }
-            case EnumSpec: {
-                return {
-                    name: EnumSpec,
-                    properties: [
-                        { name: 'type' },
-                        { name: 'values', defaultValue: [] }
-                    ]
-                };
-            }
-            case EventDefinition: {
-                return {
-                    name: EventDefinition,
-                    properties: [
-                        { name: 'extends' },
-                        { name: 'name' },
-                        { name: 'schema' }
-                    ]
-                };
-            }
-            case ExtendsClause: {
-                return {
-                    name: ExtendsClause,
-                    properties: [
-                        { name: 'parentName' }
-                    ]
-                };
-            }
-            case FlowDefBody: {
-                return {
-                    name: FlowDefBody,
-                    properties: [
-                        { name: 'entries', defaultValue: [] }
-                    ]
-                };
-            }
-            case FlowDefinition: {
-                return {
-                    name: FlowDefinition,
-                    properties: [
-                        { name: 'body' },
-                        { name: 'name' }
-                    ]
-                };
-            }
-            case FlowEntry: {
-                return {
-                    name: FlowEntry,
-                    properties: [
-                        { name: 'cond' },
-                        { name: 'next' },
-                        { name: 'root' }
-                    ]
-                };
-            }
-            case FnCall: {
-                return {
-                    name: FnCall,
-                    properties: [
-                        { name: 'args', defaultValue: [] },
-                        { name: 'name' }
-                    ]
-                };
-            }
-            case ForEach: {
-                return {
-                    name: ForEach,
-                    properties: [
-                        { name: 'src' },
-                        { name: 'statements', defaultValue: [] },
-                        { name: 'var' }
-                    ]
-                };
-            }
-            case FullTextSearch: {
-                return {
-                    name: FullTextSearch,
-                    properties: [
-                        { name: 'name' },
-                        { name: 'options' },
-                        { name: 'query' }
-                    ]
-                };
-            }
-            case GenericDefBody: {
-                return {
-                    name: GenericDefBody,
-                    properties: [
-                        { name: 'attributes', defaultValue: [] }
-                    ]
-                };
-            }
-            case GenericPropertyDef: {
-                return {
-                    name: GenericPropertyDef,
-                    properties: [
-                        { name: 'name' },
-                        { name: 'value' }
-                    ]
-                };
-            }
-            case GlossaryEntryDefinition: {
-                return {
-                    name: GlossaryEntryDefinition,
-                    properties: [
-                        { name: 'body' },
-                        { name: 'glos' },
-                        { name: 'name' }
-                    ]
-                };
-            }
-            case Group: {
-                return {
-                    name: Group,
-                    properties: [
-                        { name: 'ge' }
-                    ]
-                };
-            }
-            case GroupByClause: {
-                return {
-                    name: GroupByClause,
-                    properties: [
-                        { name: 'colNames', defaultValue: [] }
-                    ]
-                };
-            }
-            case Handler: {
-                return {
-                    name: Handler,
-                    properties: [
-                        { name: 'except' },
-                        { name: 'stmt' }
-                    ]
-                };
-            }
-            case If: {
-                return {
-                    name: If,
-                    properties: [
-                        { name: 'cond' },
-                        { name: 'else' },
-                        { name: 'statements', defaultValue: [] }
-                    ]
-                };
-            }
-            case IfWithAlias: {
-                return {
-                    name: IfWithAlias,
-                    properties: [
-                        { name: 'if' }
-                    ]
-                };
-            }
-            case Import: {
-                return {
-                    name: Import,
-                    properties: [
-                        { name: 'name' },
-                        { name: 'path' }
-                    ]
-                };
-            }
-            case JoinSpec: {
-                return {
-                    name: JoinSpec,
-                    properties: [
-                        { name: 'lhs' },
-                        { name: 'name' },
-                        { name: 'op' },
-                        { name: 'rhs' },
-                        { name: 'type' }
-                    ]
-                };
-            }
-            case KvPair: {
-                return {
-                    name: KvPair,
-                    properties: [
-                        { name: 'key' },
-                        { name: 'value' }
-                    ]
-                };
-            }
-            case KvPairs: {
-                return {
-                    name: KvPairs,
-                    properties: [
-                        { name: 'pairs', defaultValue: [] }
-                    ]
-                };
-            }
-            case Literal: {
-                return {
-                    name: Literal,
-                    properties: [
-                        { name: 'array' },
-                        { name: 'asyncFnCall' },
-                        { name: 'bool' },
-                        { name: 'fnCall' },
-                        { name: 'id' },
-                        { name: 'map' },
-                        { name: 'num' },
-                        { name: 'ref' },
-                        { name: 'str' }
-                    ]
-                };
-            }
-            case MapEntry: {
-                return {
-                    name: MapEntry,
-                    properties: [
-                        { name: 'key' },
-                        { name: 'value' }
-                    ]
-                };
-            }
-            case MapKey: {
-                return {
-                    name: MapKey,
-                    properties: [
-                        { name: 'bool' },
-                        { name: 'num' },
-                        { name: 'str' }
-                    ]
-                };
-            }
-            case MapLiteral: {
-                return {
-                    name: MapLiteral,
-                    properties: [
-                        { name: 'entries', defaultValue: [] }
-                    ]
-                };
-            }
-            case MetaDefinition: {
-                return {
-                    name: MetaDefinition,
-                    properties: [
-                        { name: 'spec' }
-                    ]
-                };
-            }
-            case ModuleDefinition: {
-                return {
-                    name: ModuleDefinition,
-                    properties: [
-                        { name: 'defs', defaultValue: [] },
-                        { name: 'imports', defaultValue: [] },
-                        { name: 'name' }
-                    ]
-                };
-            }
-            case NegExpr: {
-                return {
-                    name: NegExpr,
-                    properties: [
-                        { name: 'ne' }
-                    ]
-                };
-            }
-            case NodeDefinition: {
-                return {
-                    name: NodeDefinition,
-                    properties: [
-                        { name: 'alias' },
-                        { name: 'name' }
-                    ]
-                };
-            }
-            case NotExpr: {
-                return {
-                    name: NotExpr,
-                    properties: [
-                        { name: 'ne' }
-                    ]
-                };
-            }
-            case OneOfSpec: {
-                return {
-                    name: OneOfSpec,
-                    properties: [
-                        { name: 'ref' }
-                    ]
-                };
-            }
-            case OrderByClause: {
-                return {
-                    name: OrderByClause,
-                    properties: [
-                        { name: 'colNames', defaultValue: [] },
-                        { name: 'order' }
-                    ]
-                };
-            }
-            case Pattern: {
-                return {
-                    name: Pattern,
-                    properties: [
-                        { name: 'crudMap' },
-                        { name: 'delete' },
-                        { name: 'expr' },
-                        { name: 'forEach' },
-                        { name: 'fullTextSearch' },
-                        { name: 'if' },
-                        { name: 'ifWithAlias' },
-                        { name: 'purge' },
-                        { name: 'return' },
-                        { name: 'throwError' }
-                    ]
-                };
-            }
-            case PrePostTriggerDefinition: {
-                return {
-                    name: PrePostTriggerDefinition,
-                    properties: [
-                        { name: 'after' },
-                        { name: 'before' }
-                    ]
-                };
-            }
-            case PropertyDefinition: {
-                return {
-                    name: PropertyDefinition,
-                    properties: [
-                        { name: 'name' },
-                        { name: 'value' }
-                    ]
-                };
-            }
-            case PublicAgentDefinition: {
-                return {
-                    name: PublicAgentDefinition,
-                    properties: [
-                        { name: 'def' }
-                    ]
-                };
-            }
-            case PublicEventDefinition: {
-                return {
-                    name: PublicEventDefinition,
-                    properties: [
-                        { name: 'def' }
-                    ]
-                };
-            }
-            case PublicWorkflowDefinition: {
-                return {
-                    name: PublicWorkflowDefinition,
-                    properties: [
-                        { name: 'def' }
-                    ]
-                };
-            }
-            case Purge: {
-                return {
-                    name: Purge,
-                    properties: [
-                        { name: 'pattern' }
-                    ]
-                };
-            }
-            case RbacAllowSpec: {
-                return {
-                    name: RbacAllowSpec,
-                    properties: [
-                        { name: 'oprs', defaultValue: [] }
-                    ]
-                };
-            }
-            case RbacExpressionSpec: {
-                return {
-                    name: RbacExpressionSpec,
-                    properties: [
-                        { name: 'lhs' },
-                        { name: 'rhs' }
-                    ]
-                };
-            }
-            case RbacOpr: {
-                return {
-                    name: RbacOpr,
-                    properties: [
-                        { name: 'value' }
-                    ]
-                };
-            }
-            case RbacRolesSpec: {
-                return {
-                    name: RbacRolesSpec,
-                    properties: [
-                        { name: 'roles', defaultValue: [] }
-                    ]
-                };
-            }
-            case RbacSpecDefinition: {
-                return {
-                    name: RbacSpecDefinition,
-                    properties: [
-                        { name: 'specEntries', defaultValue: [] }
-                    ]
-                };
-            }
-            case RbacSpecEntries: {
-                return {
-                    name: RbacSpecEntries,
-                    properties: [
-                        { name: 'entries', defaultValue: [] }
-                    ]
-                };
-            }
-            case RbacSpecEntry: {
-                return {
-                    name: RbacSpecEntry,
-                    properties: [
-                        { name: 'allow' },
-                        { name: 'expr' },
-                        { name: 'role' }
-                    ]
-                };
-            }
-            case RecordDefinition: {
-                return {
-                    name: RecordDefinition,
-                    properties: [
-                        { name: 'extends' },
-                        { name: 'name' },
-                        { name: 'schema' }
-                    ]
-                };
-            }
-            case RecordExtraDefinition: {
-                return {
-                    name: RecordExtraDefinition,
-                    properties: [
-                        { name: 'actions' },
-                        { name: 'meta' },
-                        { name: 'prePost' },
-                        { name: 'rbacSpec' },
-                        { name: 'uq' }
-                    ]
-                };
-            }
-            case RecordSchemaDefinition: {
-                return {
-                    name: RecordSchemaDefinition,
-                    properties: [
-                        { name: 'attributes', defaultValue: [] },
-                        { name: 'extras', defaultValue: [] }
-                    ]
-                };
-            }
-            case RefSpec: {
-                return {
-                    name: RefSpec,
-                    properties: [
-                        { name: 'ref' },
-                        { name: 'type' }
-                    ]
-                };
-            }
-            case RelationshipDefinition: {
-                return {
-                    name: RelationshipDefinition,
-                    properties: [
-                        { name: 'name' },
-                        { name: 'nodes' },
-                        { name: 'properties', defaultValue: [] },
-                        { name: 'schema' },
-                        { name: 'type' }
-                    ]
-                };
-            }
-            case RelationshipPattern: {
-                return {
-                    name: RelationshipPattern,
-                    properties: [
-                        { name: 'name' },
-                        { name: 'pattern' }
-                    ]
-                };
-            }
-            case RelNodes: {
-                return {
-                    name: RelNodes,
-                    properties: [
-                        { name: 'node1' },
-                        { name: 'node2' }
-                    ]
-                };
-            }
-            case ResolverDefinition: {
-                return {
-                    name: ResolverDefinition,
-                    properties: [
-                        { name: 'methods', defaultValue: [] },
-                        { name: 'name' },
-                        { name: 'paths', defaultValue: [] }
-                    ]
-                };
-            }
-            case ResolverFnName: {
-                return {
-                    name: ResolverFnName,
-                    properties: [
-                        { name: 'name' }
-                    ]
-                };
-            }
-            case ResolverMethodName: {
-                return {
-                    name: ResolverMethodName,
-                    properties: [
-                        { name: 'name' }
-                    ]
-                };
-            }
-            case ResolverMethodSpec: {
-                return {
-                    name: ResolverMethodSpec,
-                    properties: [
-                        { name: 'fn' },
-                        { name: 'key' }
-                    ]
-                };
-            }
-            case RetryDefinition: {
-                return {
-                    name: RetryDefinition,
-                    properties: [
-                        { name: 'attempts' },
-                        { name: 'backoff' },
-                        { name: 'name' }
-                    ]
-                };
-            }
-            case Return: {
-                return {
-                    name: Return,
-                    properties: [
-                        { name: 'pattern' }
-                    ]
-                };
-            }
-            case RuntimeHint: {
-                return {
-                    name: RuntimeHint,
-                    properties: [
-                        { name: 'aliasSpec' },
-                        { name: 'catchSpec' },
-                        { name: 'thenSpec' }
-                    ]
-                };
-            }
-            case ScenarioDefinition: {
-                return {
-                    name: ScenarioDefinition,
-                    properties: [
-                        { name: 'body' },
-                        { name: 'name' },
-                        { name: 'scn' }
-                    ]
-                };
-            }
-            case SelectIntoEntry: {
-                return {
-                    name: SelectIntoEntry,
-                    properties: [
-                        { name: 'aggregate' },
-                        { name: 'alias' },
-                        { name: 'attribute' }
-                    ]
-                };
-            }
-            case SelectIntoSpec: {
-                return {
-                    name: SelectIntoSpec,
-                    properties: [
-                        { name: 'entries', defaultValue: [] }
-                    ]
-                };
-            }
-            case SetAttribute: {
-                return {
-                    name: SetAttribute,
-                    properties: [
-                        { name: 'aggregate' },
-                        { name: 'name' },
-                        { name: 'op' },
-                        { name: 'value' }
-                    ]
-                };
-            }
-            case StandaloneStatement: {
-                return {
-                    name: StandaloneStatement,
-                    properties: [
-                        { name: 'stmt' }
-                    ]
-                };
-            }
-            case Statement: {
-                return {
-                    name: Statement,
-                    properties: [
-                        { name: 'hints', defaultValue: [] },
-                        { name: 'pattern' }
-                    ]
-                };
-            }
-            case ThenSpec: {
-                return {
-                    name: ThenSpec,
-                    properties: [
-                        { name: 'statements', defaultValue: [] }
-                    ]
-                };
-            }
-            case ThrowError: {
-                return {
-                    name: ThrowError,
-                    properties: [
-                        { name: 'reason' }
-                    ]
-                };
-            }
-            case TriggerDefinition: {
-                return {
-                    name: TriggerDefinition,
-                    properties: [
-                        { name: 'entries', defaultValue: [] }
-                    ]
-                };
-            }
-            case TriggerEntry: {
-                return {
-                    name: TriggerEntry,
-                    properties: [
-                        { name: 'async' },
-                        { name: 'event' },
-                        { name: 'on' }
-                    ]
-                };
-            }
-            case WhereSpec: {
-                return {
-                    name: WhereSpec,
-                    properties: [
-                        { name: 'clauses', defaultValue: [] }
-                    ]
-                };
-            }
-            case WhereSpecClause: {
-                return {
-                    name: WhereSpecClause,
-                    properties: [
-                        { name: 'lhs' },
-                        { name: 'op' },
-                        { name: 'rhs' }
-                    ]
-                };
-            }
-            case WorkflowDefinition: {
-                return {
-                    name: WorkflowDefinition,
-                    properties: [
-                        { name: 'header' },
-                        { name: 'name' },
-                        { name: 'statements', defaultValue: [] }
-                    ]
-                };
-            }
-            case WorkflowHeader: {
-                return {
-                    name: WorkflowHeader,
-                    properties: [
-                        { name: 'name' },
-                        { name: 'prefix' },
-                        { name: 'tag' }
-                    ]
-                };
-            }
-            default: {
-                return {
-                    name: type,
-                    properties: []
-                };
-            }
+    override readonly types = {
+        ActionEntry: {
+            name: ActionEntry.$type,
+            properties: {
+                event: {
+                    name: ActionEntry.event
+                },
+                name: {
+                    name: ActionEntry.name
+                }
+            },
+            superTypes: []
+        },
+        AfterTriggerDefinition: {
+            name: AfterTriggerDefinition.$type,
+            properties: {
+                triggers: {
+                    name: AfterTriggerDefinition.triggers
+                }
+            },
+            superTypes: []
+        },
+        AgentDefinition: {
+            name: AgentDefinition.$type,
+            properties: {
+                body: {
+                    name: AgentDefinition.body
+                },
+                name: {
+                    name: AgentDefinition.name
+                }
+            },
+            superTypes: [Definition.$type]
+        },
+        AgentXtraAttribute: {
+            name: AgentXtraAttribute.$type,
+            properties: {
+                name: {
+                    name: AgentXtraAttribute.name
+                },
+                value: {
+                    name: AgentXtraAttribute.value
+                }
+            },
+            superTypes: []
+        },
+        AgentXtraSpec: {
+            name: AgentXtraSpec.$type,
+            properties: {
+                attributes: {
+                    name: AgentXtraSpec.attributes,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        AggregateFunctionSpec: {
+            name: AggregateFunctionSpec.$type,
+            properties: {
+                args: {
+                    name: AggregateFunctionSpec.args,
+                    defaultValue: []
+                },
+                name: {
+                    name: AggregateFunctionSpec.name
+                }
+            },
+            superTypes: []
+        },
+        AliasSpec: {
+            name: AliasSpec.$type,
+            properties: {
+                alias: {
+                    name: AliasSpec.alias
+                },
+                aliases: {
+                    name: AliasSpec.aliases,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        ArrayLiteral: {
+            name: ArrayLiteral.$type,
+            properties: {
+                vals: {
+                    name: ArrayLiteral.vals,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        AsyncFnCall: {
+            name: AsyncFnCall.$type,
+            properties: {
+                fnCall: {
+                    name: AsyncFnCall.fnCall
+                }
+            },
+            superTypes: []
+        },
+        AttributeDefinition: {
+            name: AttributeDefinition.$type,
+            properties: {
+                arrayType: {
+                    name: AttributeDefinition.arrayType
+                },
+                enumSpec: {
+                    name: AttributeDefinition.enumSpec
+                },
+                expr: {
+                    name: AttributeDefinition.expr
+                },
+                name: {
+                    name: AttributeDefinition.name
+                },
+                oneOfSpec: {
+                    name: AttributeDefinition.oneOfSpec
+                },
+                properties: {
+                    name: AttributeDefinition.properties,
+                    defaultValue: []
+                },
+                refSpec: {
+                    name: AttributeDefinition.refSpec
+                },
+                type: {
+                    name: AttributeDefinition.type
+                }
+            },
+            superTypes: []
+        },
+        AttributeValueExpression: {
+            name: AttributeValueExpression.$type,
+            properties: {
+            },
+            superTypes: []
+        },
+        BackoffSpec: {
+            name: BackoffSpec.$type,
+            properties: {
+                attributes: {
+                    name: BackoffSpec.attributes,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        BeforeTriggerDefinition: {
+            name: BeforeTriggerDefinition.$type,
+            properties: {
+                triggers: {
+                    name: BeforeTriggerDefinition.triggers
+                }
+            },
+            superTypes: []
+        },
+        BinExpr: {
+            name: BinExpr.$type,
+            properties: {
+                e1: {
+                    name: BinExpr.e1
+                },
+                e2: {
+                    name: BinExpr.e2
+                },
+                op: {
+                    name: BinExpr.op
+                }
+            },
+            superTypes: [Expr.$type]
+        },
+        CaseEntry: {
+            name: CaseEntry.$type,
+            properties: {
+                cond: {
+                    name: CaseEntry.cond
+                },
+                statements: {
+                    name: CaseEntry.statements,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        CatchSpec: {
+            name: CatchSpec.$type,
+            properties: {
+                handlers: {
+                    name: CatchSpec.handlers,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        CompositeUniqueDefinition: {
+            name: CompositeUniqueDefinition.$type,
+            properties: {
+                attrs: {
+                    name: CompositeUniqueDefinition.attrs,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        ConditionalFlowStep: {
+            name: ConditionalFlowStep.$type,
+            properties: {
+                expr: {
+                    name: ConditionalFlowStep.expr
+                },
+                next: {
+                    name: ConditionalFlowStep.next
+                }
+            },
+            superTypes: []
+        },
+        CrudMap: {
+            name: CrudMap.$type,
+            properties: {
+                body: {
+                    name: CrudMap.body
+                },
+                distinct: {
+                    name: CrudMap.distinct,
+                    defaultValue: []
+                },
+                groupByClause: {
+                    name: CrudMap.groupByClause
+                },
+                into: {
+                    name: CrudMap.into
+                },
+                joins: {
+                    name: CrudMap.joins,
+                    defaultValue: []
+                },
+                name: {
+                    name: CrudMap.name
+                },
+                orderByClause: {
+                    name: CrudMap.orderByClause
+                },
+                relationships: {
+                    name: CrudMap.relationships,
+                    defaultValue: []
+                },
+                source: {
+                    name: CrudMap.source
+                },
+                upsert: {
+                    name: CrudMap.upsert,
+                    defaultValue: []
+                },
+                where: {
+                    name: CrudMap.where
+                }
+            },
+            superTypes: []
+        },
+        CrudMapBody: {
+            name: CrudMapBody.$type,
+            properties: {
+                attributes: {
+                    name: CrudMapBody.attributes,
+                    defaultValue: []
+                },
+                properties: {
+                    name: CrudMapBody.properties,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        DecisionDefBody: {
+            name: DecisionDefBody.$type,
+            properties: {
+                cases: {
+                    name: DecisionDefBody.cases,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        DecisionDefinition: {
+            name: DecisionDefinition.$type,
+            properties: {
+                body: {
+                    name: DecisionDefinition.body
+                },
+                name: {
+                    name: DecisionDefinition.name
+                }
+            },
+            superTypes: [Definition.$type]
+        },
+        Definition: {
+            name: Definition.$type,
+            properties: {
+            },
+            superTypes: []
+        },
+        Delete: {
+            name: Delete.$type,
+            properties: {
+                pattern: {
+                    name: Delete.pattern
+                }
+            },
+            superTypes: []
+        },
+        DirectiveDefinition: {
+            name: DirectiveDefinition.$type,
+            properties: {
+                body: {
+                    name: DirectiveDefinition.body
+                },
+                dir: {
+                    name: DirectiveDefinition.dir
+                },
+                name: {
+                    name: DirectiveDefinition.name
+                }
+            },
+            superTypes: [Definition.$type]
+        },
+        Else: {
+            name: Else.$type,
+            properties: {
+                statements: {
+                    name: Else.statements,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        EntityActionsDefinitions: {
+            name: EntityActionsDefinitions.$type,
+            properties: {
+                entries: {
+                    name: EntityActionsDefinitions.entries,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        EntityDefinition: {
+            name: EntityDefinition.$type,
+            properties: {
+                extends: {
+                    name: EntityDefinition.extends
+                },
+                name: {
+                    name: EntityDefinition.name
+                },
+                schema: {
+                    name: EntityDefinition.schema
+                }
+            },
+            superTypes: [SchemaDefinition.$type]
+        },
+        EnumSpec: {
+            name: EnumSpec.$type,
+            properties: {
+                type: {
+                    name: EnumSpec.type
+                },
+                values: {
+                    name: EnumSpec.values,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        EventDefinition: {
+            name: EventDefinition.$type,
+            properties: {
+                extends: {
+                    name: EventDefinition.extends
+                },
+                name: {
+                    name: EventDefinition.name
+                },
+                schema: {
+                    name: EventDefinition.schema
+                }
+            },
+            superTypes: [SchemaDefinition.$type]
+        },
+        Expr: {
+            name: Expr.$type,
+            properties: {
+            },
+            superTypes: [AttributeValueExpression.$type]
+        },
+        ExtendsClause: {
+            name: ExtendsClause.$type,
+            properties: {
+                parentName: {
+                    name: ExtendsClause.parentName
+                }
+            },
+            superTypes: []
+        },
+        FlowDefBody: {
+            name: FlowDefBody.$type,
+            properties: {
+                entries: {
+                    name: FlowDefBody.entries,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        FlowDefinition: {
+            name: FlowDefinition.$type,
+            properties: {
+                body: {
+                    name: FlowDefinition.body
+                },
+                name: {
+                    name: FlowDefinition.name
+                }
+            },
+            superTypes: [Definition.$type]
+        },
+        FlowEntry: {
+            name: FlowEntry.$type,
+            properties: {
+                cond: {
+                    name: FlowEntry.cond
+                },
+                next: {
+                    name: FlowEntry.next
+                },
+                root: {
+                    name: FlowEntry.root
+                }
+            },
+            superTypes: []
+        },
+        FlowStepSpec: {
+            name: FlowStepSpec.$type,
+            properties: {
+            },
+            superTypes: []
+        },
+        FnCall: {
+            name: FnCall.$type,
+            properties: {
+                args: {
+                    name: FnCall.args,
+                    defaultValue: []
+                },
+                name: {
+                    name: FnCall.name
+                }
+            },
+            superTypes: []
+        },
+        ForEach: {
+            name: ForEach.$type,
+            properties: {
+                src: {
+                    name: ForEach.src
+                },
+                statements: {
+                    name: ForEach.statements,
+                    defaultValue: []
+                },
+                var: {
+                    name: ForEach.var
+                }
+            },
+            superTypes: []
+        },
+        FullTextSearch: {
+            name: FullTextSearch.$type,
+            properties: {
+                name: {
+                    name: FullTextSearch.name
+                },
+                options: {
+                    name: FullTextSearch.options
+                },
+                query: {
+                    name: FullTextSearch.query
+                }
+            },
+            superTypes: []
+        },
+        GenericDefBody: {
+            name: GenericDefBody.$type,
+            properties: {
+                attributes: {
+                    name: GenericDefBody.attributes,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        GenericPropertyDef: {
+            name: GenericPropertyDef.$type,
+            properties: {
+                name: {
+                    name: GenericPropertyDef.name
+                },
+                value: {
+                    name: GenericPropertyDef.value
+                }
+            },
+            superTypes: []
+        },
+        GlossaryEntryDefinition: {
+            name: GlossaryEntryDefinition.$type,
+            properties: {
+                body: {
+                    name: GlossaryEntryDefinition.body
+                },
+                glos: {
+                    name: GlossaryEntryDefinition.glos
+                },
+                name: {
+                    name: GlossaryEntryDefinition.name
+                }
+            },
+            superTypes: [Definition.$type]
+        },
+        Group: {
+            name: Group.$type,
+            properties: {
+                ge: {
+                    name: Group.ge
+                }
+            },
+            superTypes: [PrimExpr.$type]
+        },
+        GroupByClause: {
+            name: GroupByClause.$type,
+            properties: {
+                colNames: {
+                    name: GroupByClause.colNames,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        Handler: {
+            name: Handler.$type,
+            properties: {
+                except: {
+                    name: Handler.except
+                },
+                stmt: {
+                    name: Handler.stmt
+                }
+            },
+            superTypes: []
+        },
+        If: {
+            name: If.$type,
+            properties: {
+                cond: {
+                    name: If.cond
+                },
+                else: {
+                    name: If.else
+                },
+                statements: {
+                    name: If.statements,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        IfWithAlias: {
+            name: IfWithAlias.$type,
+            properties: {
+                if: {
+                    name: IfWithAlias.if
+                }
+            },
+            superTypes: []
+        },
+        Import: {
+            name: Import.$type,
+            properties: {
+                name: {
+                    name: Import.name
+                },
+                path: {
+                    name: Import.path
+                }
+            },
+            superTypes: []
+        },
+        JoinSpec: {
+            name: JoinSpec.$type,
+            properties: {
+                lhs: {
+                    name: JoinSpec.lhs
+                },
+                name: {
+                    name: JoinSpec.name
+                },
+                op: {
+                    name: JoinSpec.op
+                },
+                rhs: {
+                    name: JoinSpec.rhs
+                },
+                type: {
+                    name: JoinSpec.type
+                }
+            },
+            superTypes: []
+        },
+        KvPair: {
+            name: KvPair.$type,
+            properties: {
+                key: {
+                    name: KvPair.key
+                },
+                value: {
+                    name: KvPair.value
+                }
+            },
+            superTypes: []
+        },
+        KvPairs: {
+            name: KvPairs.$type,
+            properties: {
+                pairs: {
+                    name: KvPairs.pairs,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        Literal: {
+            name: Literal.$type,
+            properties: {
+                array: {
+                    name: Literal.array
+                },
+                asyncFnCall: {
+                    name: Literal.asyncFnCall
+                },
+                bool: {
+                    name: Literal.bool
+                },
+                fnCall: {
+                    name: Literal.fnCall
+                },
+                id: {
+                    name: Literal.id
+                },
+                map: {
+                    name: Literal.map
+                },
+                num: {
+                    name: Literal.num
+                },
+                ref: {
+                    name: Literal.ref
+                },
+                str: {
+                    name: Literal.str
+                }
+            },
+            superTypes: [PrimExpr.$type]
+        },
+        MapEntry: {
+            name: MapEntry.$type,
+            properties: {
+                key: {
+                    name: MapEntry.key
+                },
+                value: {
+                    name: MapEntry.value
+                }
+            },
+            superTypes: []
+        },
+        MapKey: {
+            name: MapKey.$type,
+            properties: {
+                bool: {
+                    name: MapKey.bool
+                },
+                num: {
+                    name: MapKey.num
+                },
+                str: {
+                    name: MapKey.str
+                }
+            },
+            superTypes: []
+        },
+        MapLiteral: {
+            name: MapLiteral.$type,
+            properties: {
+                entries: {
+                    name: MapLiteral.entries,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        MetaDefinition: {
+            name: MetaDefinition.$type,
+            properties: {
+                spec: {
+                    name: MetaDefinition.spec
+                }
+            },
+            superTypes: []
+        },
+        ModuleDefinition: {
+            name: ModuleDefinition.$type,
+            properties: {
+                defs: {
+                    name: ModuleDefinition.defs,
+                    defaultValue: []
+                },
+                imports: {
+                    name: ModuleDefinition.imports,
+                    defaultValue: []
+                },
+                name: {
+                    name: ModuleDefinition.name
+                }
+            },
+            superTypes: []
+        },
+        NegExpr: {
+            name: NegExpr.$type,
+            properties: {
+                ne: {
+                    name: NegExpr.ne
+                }
+            },
+            superTypes: [PrimExpr.$type]
+        },
+        NodeDefinition: {
+            name: NodeDefinition.$type,
+            properties: {
+                alias: {
+                    name: NodeDefinition.alias
+                },
+                name: {
+                    name: NodeDefinition.name
+                }
+            },
+            superTypes: []
+        },
+        NotExpr: {
+            name: NotExpr.$type,
+            properties: {
+                ne: {
+                    name: NotExpr.ne
+                }
+            },
+            superTypes: [PrimExpr.$type]
+        },
+        OneOfSpec: {
+            name: OneOfSpec.$type,
+            properties: {
+                ref: {
+                    name: OneOfSpec.ref
+                }
+            },
+            superTypes: []
+        },
+        OrderByClause: {
+            name: OrderByClause.$type,
+            properties: {
+                colNames: {
+                    name: OrderByClause.colNames,
+                    defaultValue: []
+                },
+                order: {
+                    name: OrderByClause.order
+                }
+            },
+            superTypes: []
+        },
+        Pattern: {
+            name: Pattern.$type,
+            properties: {
+                crudMap: {
+                    name: Pattern.crudMap
+                },
+                delete: {
+                    name: Pattern.delete
+                },
+                expr: {
+                    name: Pattern.expr
+                },
+                forEach: {
+                    name: Pattern.forEach
+                },
+                fullTextSearch: {
+                    name: Pattern.fullTextSearch
+                },
+                if: {
+                    name: Pattern.if
+                },
+                ifWithAlias: {
+                    name: Pattern.ifWithAlias
+                },
+                purge: {
+                    name: Pattern.purge
+                },
+                return: {
+                    name: Pattern.return
+                },
+                throwError: {
+                    name: Pattern.throwError
+                }
+            },
+            superTypes: []
+        },
+        PrePostTriggerDefinition: {
+            name: PrePostTriggerDefinition.$type,
+            properties: {
+                after: {
+                    name: PrePostTriggerDefinition.after
+                },
+                before: {
+                    name: PrePostTriggerDefinition.before
+                }
+            },
+            superTypes: []
+        },
+        PrimExpr: {
+            name: PrimExpr.$type,
+            properties: {
+            },
+            superTypes: [Expr.$type]
+        },
+        PropertyDefinition: {
+            name: PropertyDefinition.$type,
+            properties: {
+                name: {
+                    name: PropertyDefinition.name
+                },
+                value: {
+                    name: PropertyDefinition.value
+                }
+            },
+            superTypes: []
+        },
+        PublicAgentDefinition: {
+            name: PublicAgentDefinition.$type,
+            properties: {
+                def: {
+                    name: PublicAgentDefinition.def
+                }
+            },
+            superTypes: [Definition.$type]
+        },
+        PublicEventDefinition: {
+            name: PublicEventDefinition.$type,
+            properties: {
+                def: {
+                    name: PublicEventDefinition.def
+                }
+            },
+            superTypes: [SchemaDefinition.$type]
+        },
+        PublicWorkflowDefinition: {
+            name: PublicWorkflowDefinition.$type,
+            properties: {
+                def: {
+                    name: PublicWorkflowDefinition.def
+                }
+            },
+            superTypes: [Definition.$type]
+        },
+        Purge: {
+            name: Purge.$type,
+            properties: {
+                pattern: {
+                    name: Purge.pattern
+                }
+            },
+            superTypes: []
+        },
+        RbacAllowSpec: {
+            name: RbacAllowSpec.$type,
+            properties: {
+                oprs: {
+                    name: RbacAllowSpec.oprs,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        RbacExpressionSpec: {
+            name: RbacExpressionSpec.$type,
+            properties: {
+                lhs: {
+                    name: RbacExpressionSpec.lhs
+                },
+                rhs: {
+                    name: RbacExpressionSpec.rhs
+                }
+            },
+            superTypes: []
+        },
+        RbacOpr: {
+            name: RbacOpr.$type,
+            properties: {
+                value: {
+                    name: RbacOpr.value
+                }
+            },
+            superTypes: []
+        },
+        RbacRolesSpec: {
+            name: RbacRolesSpec.$type,
+            properties: {
+                roles: {
+                    name: RbacRolesSpec.roles,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        RbacSpecDefinition: {
+            name: RbacSpecDefinition.$type,
+            properties: {
+                specEntries: {
+                    name: RbacSpecDefinition.specEntries,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        RbacSpecEntries: {
+            name: RbacSpecEntries.$type,
+            properties: {
+                entries: {
+                    name: RbacSpecEntries.entries,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        RbacSpecEntry: {
+            name: RbacSpecEntry.$type,
+            properties: {
+                allow: {
+                    name: RbacSpecEntry.allow
+                },
+                expr: {
+                    name: RbacSpecEntry.expr
+                },
+                role: {
+                    name: RbacSpecEntry.role
+                }
+            },
+            superTypes: []
+        },
+        RecordDefinition: {
+            name: RecordDefinition.$type,
+            properties: {
+                extends: {
+                    name: RecordDefinition.extends
+                },
+                name: {
+                    name: RecordDefinition.name
+                },
+                schema: {
+                    name: RecordDefinition.schema
+                }
+            },
+            superTypes: [SchemaDefinition.$type]
+        },
+        RecordExtraDefinition: {
+            name: RecordExtraDefinition.$type,
+            properties: {
+                actions: {
+                    name: RecordExtraDefinition.actions
+                },
+                meta: {
+                    name: RecordExtraDefinition.meta
+                },
+                prePost: {
+                    name: RecordExtraDefinition.prePost
+                },
+                rbacSpec: {
+                    name: RecordExtraDefinition.rbacSpec
+                },
+                uq: {
+                    name: RecordExtraDefinition.uq
+                }
+            },
+            superTypes: []
+        },
+        RecordSchemaDefinition: {
+            name: RecordSchemaDefinition.$type,
+            properties: {
+                attributes: {
+                    name: RecordSchemaDefinition.attributes,
+                    defaultValue: []
+                },
+                extras: {
+                    name: RecordSchemaDefinition.extras,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        RefSpec: {
+            name: RefSpec.$type,
+            properties: {
+                ref: {
+                    name: RefSpec.ref
+                },
+                type: {
+                    name: RefSpec.type
+                }
+            },
+            superTypes: []
+        },
+        RelNodes: {
+            name: RelNodes.$type,
+            properties: {
+                node1: {
+                    name: RelNodes.node1
+                },
+                node2: {
+                    name: RelNodes.node2
+                }
+            },
+            superTypes: []
+        },
+        RelationshipDefinition: {
+            name: RelationshipDefinition.$type,
+            properties: {
+                name: {
+                    name: RelationshipDefinition.name
+                },
+                nodes: {
+                    name: RelationshipDefinition.nodes
+                },
+                properties: {
+                    name: RelationshipDefinition.properties,
+                    defaultValue: []
+                },
+                schema: {
+                    name: RelationshipDefinition.schema
+                },
+                type: {
+                    name: RelationshipDefinition.type
+                }
+            },
+            superTypes: [Definition.$type]
+        },
+        RelationshipPattern: {
+            name: RelationshipPattern.$type,
+            properties: {
+                name: {
+                    name: RelationshipPattern.name
+                },
+                pattern: {
+                    name: RelationshipPattern.pattern
+                }
+            },
+            superTypes: []
+        },
+        ResolverDefinition: {
+            name: ResolverDefinition.$type,
+            properties: {
+                methods: {
+                    name: ResolverDefinition.methods,
+                    defaultValue: []
+                },
+                name: {
+                    name: ResolverDefinition.name
+                },
+                paths: {
+                    name: ResolverDefinition.paths,
+                    defaultValue: []
+                }
+            },
+            superTypes: [Definition.$type]
+        },
+        ResolverFnName: {
+            name: ResolverFnName.$type,
+            properties: {
+                name: {
+                    name: ResolverFnName.name
+                }
+            },
+            superTypes: []
+        },
+        ResolverMethodName: {
+            name: ResolverMethodName.$type,
+            properties: {
+                name: {
+                    name: ResolverMethodName.name
+                }
+            },
+            superTypes: []
+        },
+        ResolverMethodSpec: {
+            name: ResolverMethodSpec.$type,
+            properties: {
+                fn: {
+                    name: ResolverMethodSpec.fn
+                },
+                key: {
+                    name: ResolverMethodSpec.key
+                }
+            },
+            superTypes: []
+        },
+        RetryDefinition: {
+            name: RetryDefinition.$type,
+            properties: {
+                attempts: {
+                    name: RetryDefinition.attempts
+                },
+                backoff: {
+                    name: RetryDefinition.backoff
+                },
+                name: {
+                    name: RetryDefinition.name
+                }
+            },
+            superTypes: [Definition.$type]
+        },
+        Return: {
+            name: Return.$type,
+            properties: {
+                pattern: {
+                    name: Return.pattern
+                }
+            },
+            superTypes: []
+        },
+        RuntimeHint: {
+            name: RuntimeHint.$type,
+            properties: {
+                aliasSpec: {
+                    name: RuntimeHint.aliasSpec
+                },
+                catchSpec: {
+                    name: RuntimeHint.catchSpec
+                },
+                thenSpec: {
+                    name: RuntimeHint.thenSpec
+                }
+            },
+            superTypes: []
+        },
+        ScenarioDefinition: {
+            name: ScenarioDefinition.$type,
+            properties: {
+                body: {
+                    name: ScenarioDefinition.body
+                },
+                name: {
+                    name: ScenarioDefinition.name
+                },
+                scn: {
+                    name: ScenarioDefinition.scn
+                }
+            },
+            superTypes: [Definition.$type]
+        },
+        SchemaDefinition: {
+            name: SchemaDefinition.$type,
+            properties: {
+            },
+            superTypes: [Definition.$type]
+        },
+        SelectIntoEntry: {
+            name: SelectIntoEntry.$type,
+            properties: {
+                aggregate: {
+                    name: SelectIntoEntry.aggregate
+                },
+                alias: {
+                    name: SelectIntoEntry.alias
+                },
+                attribute: {
+                    name: SelectIntoEntry.attribute
+                }
+            },
+            superTypes: []
+        },
+        SelectIntoSpec: {
+            name: SelectIntoSpec.$type,
+            properties: {
+                entries: {
+                    name: SelectIntoSpec.entries,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        SetAttribute: {
+            name: SetAttribute.$type,
+            properties: {
+                aggregate: {
+                    name: SetAttribute.aggregate
+                },
+                name: {
+                    name: SetAttribute.name
+                },
+                op: {
+                    name: SetAttribute.op
+                },
+                value: {
+                    name: SetAttribute.value
+                }
+            },
+            superTypes: []
+        },
+        StandaloneStatement: {
+            name: StandaloneStatement.$type,
+            properties: {
+                stmt: {
+                    name: StandaloneStatement.stmt
+                }
+            },
+            superTypes: [Definition.$type]
+        },
+        Statement: {
+            name: Statement.$type,
+            properties: {
+                hints: {
+                    name: Statement.hints,
+                    defaultValue: []
+                },
+                pattern: {
+                    name: Statement.pattern
+                }
+            },
+            superTypes: [FlowStepSpec.$type]
+        },
+        ThenSpec: {
+            name: ThenSpec.$type,
+            properties: {
+                statements: {
+                    name: ThenSpec.statements,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        ThrowError: {
+            name: ThrowError.$type,
+            properties: {
+                reason: {
+                    name: ThrowError.reason
+                }
+            },
+            superTypes: []
+        },
+        TriggerDefinition: {
+            name: TriggerDefinition.$type,
+            properties: {
+                entries: {
+                    name: TriggerDefinition.entries,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        TriggerEntry: {
+            name: TriggerEntry.$type,
+            properties: {
+                async: {
+                    name: TriggerEntry.async
+                },
+                event: {
+                    name: TriggerEntry.event
+                },
+                on: {
+                    name: TriggerEntry.on
+                }
+            },
+            superTypes: []
+        },
+        WhereSpec: {
+            name: WhereSpec.$type,
+            properties: {
+                clauses: {
+                    name: WhereSpec.clauses,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        WhereSpecClause: {
+            name: WhereSpecClause.$type,
+            properties: {
+                lhs: {
+                    name: WhereSpecClause.lhs
+                },
+                op: {
+                    name: WhereSpecClause.op
+                },
+                rhs: {
+                    name: WhereSpecClause.rhs
+                }
+            },
+            superTypes: []
+        },
+        WorkflowDefinition: {
+            name: WorkflowDefinition.$type,
+            properties: {
+                header: {
+                    name: WorkflowDefinition.header
+                },
+                name: {
+                    name: WorkflowDefinition.name
+                },
+                statements: {
+                    name: WorkflowDefinition.statements,
+                    defaultValue: []
+                }
+            },
+            superTypes: [Definition.$type]
+        },
+        WorkflowHeader: {
+            name: WorkflowHeader.$type,
+            properties: {
+                name: {
+                    name: WorkflowHeader.name
+                },
+                prefix: {
+                    name: WorkflowHeader.prefix
+                },
+                tag: {
+                    name: WorkflowHeader.tag
+                }
+            },
+            superTypes: []
         }
-    }
+    } as const satisfies langium.AstMetaData
 }
 
 export const reflection = new AgentlangAstReflection();