agentlang 0.9.4 → 0.9.6

package/out/language/generated/ast.js

@@ -1,1468 +1,2318 @@
 /******************************************************************************
- * This file was generated by langium-cli 3.5.2.
+ * This file was generated by langium-cli 4.1.0.
  * DO NOT EDIT MANUALLY!
  ******************************************************************************/
-/* eslint-disable */
 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]*?\*\//,
     SL_COMMENT: /\/\/[^\n\r]*/,
 };
-export const AttributeValueExpression = 'AttributeValueExpression';
-export function isAttributeValueExpression(item) {
-    return reflection.isInstance(item, AttributeValueExpression);
-}
-export function isBoolean(item) {
-    return item === 'true' || item === 'false';
-}
-export function isDecimal(item) {
-    return typeof item === 'number';
-}
-export const Definition = 'Definition';
-export function isDefinition(item) {
-    return reflection.isInstance(item, Definition);
-}
-export const Expr = 'Expr';
-export function isExpr(item) {
-    return reflection.isInstance(item, Expr);
-}
-export const FlowStepSpec = 'FlowStepSpec';
-export function isFlowStepSpec(item) {
-    return reflection.isInstance(item, FlowStepSpec);
-}
-export function isGenericName(item) {
-    return isSTRING(item) || (typeof item === 'string' && (/(([_a-zA-Z][\w_]*)(\/([_a-zA-Z][\w_]*))?)/.test(item)));
-}
-export function isJoinType(item) {
-    return item === '@join' || item === '@inner_join' || item === '@left_join' || item === '@right_join' || item === '@full_join';
-}
-export const PrimExpr = 'PrimExpr';
-export function isPrimExpr(item) {
-    return reflection.isInstance(item, PrimExpr);
-}
-export function isQualifiedName(item) {
-    return isRef(item) || (typeof item === 'string' && (/(([_a-zA-Z][\w_]*)(\/([_a-zA-Z][\w_]*))?)/.test(item)));
-}
-export function isQueryId(item) {
-    return typeof item === 'string';
-}
-export function isRef(item) {
-    return typeof item === 'string';
-}
-export function isResolverPathEntry(item) {
-    return isQualifiedName(item) || isGenericName(item);
-}
-export const SchemaDefinition = 'SchemaDefinition';
-export function isSchemaDefinition(item) {
-    return reflection.isInstance(item, SchemaDefinition);
-}
-export function isSqlComparisonOpr(item) {
-    return item === '=' || item === '<>' || item === '!=' || item === '<' || item === '<=' || item === '>' || item === '>=' || item === 'in' || item === 'like' || item === 'between';
-}
-export function isSTRING(item) {
-    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 function isTaggedId(item) {
-    return typeof item === 'string';
-}
-export function isWorkflowHeaderPrefix(item) {
-    return item === 'create' || item === 'update' || item === 'delete';
-}
-export function isWorkflowHeaderTag(item) {
-    return item === '@after' || item === '@before';
-}
-export const ActionEntry = 'ActionEntry';
+export const ActionEntry = {
+    $type: 'ActionEntry',
+    event: 'event',
+    name: 'name'
+};
 export function isActionEntry(item) {
-    return reflection.isInstance(item, ActionEntry);
+    return reflection.isInstance(item, ActionEntry.$type);
 }
-export const AfterTriggerDefinition = 'AfterTriggerDefinition';
+export const AfterTriggerDefinition = {
+    $type: 'AfterTriggerDefinition',
+    triggers: 'triggers'
+};
 export function isAfterTriggerDefinition(item) {
-    return reflection.isInstance(item, AfterTriggerDefinition);
+    return reflection.isInstance(item, AfterTriggerDefinition.$type);
 }
-export const AgentDefinition = 'AgentDefinition';
+export const AgentDefinition = {
+    $type: 'AgentDefinition',
+    body: 'body',
+    name: 'name'
+};
 export function isAgentDefinition(item) {
-    return reflection.isInstance(item, AgentDefinition);
+    return reflection.isInstance(item, AgentDefinition.$type);
 }
-export const AgentXtraAttribute = 'AgentXtraAttribute';
+export const AgentEvaluatorDefinition = {
+    $type: 'AgentEvaluatorDefinition',
+    attributes: 'attributes',
+    name: 'name'
+};
+export function isAgentEvaluatorDefinition(item) {
+    return reflection.isInstance(item, AgentEvaluatorDefinition.$type);
+}
+export const AgentXtraAttribute = {
+    $type: 'AgentXtraAttribute',
+    name: 'name',
+    value: 'value'
+};
 export function isAgentXtraAttribute(item) {
-    return reflection.isInstance(item, AgentXtraAttribute);
+    return reflection.isInstance(item, AgentXtraAttribute.$type);
 }
-export const AgentXtraSpec = 'AgentXtraSpec';
+export const AgentXtraSpec = {
+    $type: 'AgentXtraSpec',
+    attributes: 'attributes'
+};
 export function isAgentXtraSpec(item) {
-    return reflection.isInstance(item, AgentXtraSpec);
+    return reflection.isInstance(item, AgentXtraSpec.$type);
 }
-export const AggregateFunctionSpec = 'AggregateFunctionSpec';
+export const AggregateFunctionSpec = {
+    $type: 'AggregateFunctionSpec',
+    args: 'args',
+    name: 'name'
+};
 export function isAggregateFunctionSpec(item) {
-    return reflection.isInstance(item, AggregateFunctionSpec);
+    return reflection.isInstance(item, AggregateFunctionSpec.$type);
 }
-export const AliasSpec = 'AliasSpec';
+export const AliasSpec = {
+    $type: 'AliasSpec',
+    alias: 'alias',
+    aliases: 'aliases'
+};
 export function isAliasSpec(item) {
-    return reflection.isInstance(item, AliasSpec);
+    return reflection.isInstance(item, AliasSpec.$type);
 }
-export const ArrayLiteral = 'ArrayLiteral';
+export const ArrayLiteral = {
+    $type: 'ArrayLiteral',
+    vals: 'vals'
+};
 export function isArrayLiteral(item) {
-    return reflection.isInstance(item, ArrayLiteral);
+    return reflection.isInstance(item, ArrayLiteral.$type);
 }
-export const AsyncFnCall = 'AsyncFnCall';
+export const AsyncFnCall = {
+    $type: 'AsyncFnCall',
+    fnCall: 'fnCall'
+};
 export function isAsyncFnCall(item) {
-    return reflection.isInstance(item, AsyncFnCall);
-}
-export const AttributeDefinition = 'AttributeDefinition';
+    return reflection.isInstance(item, AsyncFnCall.$type);
+}
+export const AttributeDefinition = {
+    $type: 'AttributeDefinition',
+    arrayType: 'arrayType',
+    enumSpec: 'enumSpec',
+    expr: 'expr',
+    name: 'name',
+    oneOfSpec: 'oneOfSpec',
+    properties: 'properties',
+    refSpec: 'refSpec',
+    type: 'type'
+};
 export function isAttributeDefinition(item) {
-    return reflection.isInstance(item, AttributeDefinition);
+    return reflection.isInstance(item, AttributeDefinition.$type);
 }
-export const BackoffSpec = 'BackoffSpec';
+export const AttributeValueExpression = {
+    $type: 'AttributeValueExpression'
+};
+export function isAttributeValueExpression(item) {
+    return reflection.isInstance(item, AttributeValueExpression.$type);
+}
+export const BackoffSpec = {
+    $type: 'BackoffSpec',
+    attributes: 'attributes'
+};
 export function isBackoffSpec(item) {
-    return reflection.isInstance(item, BackoffSpec);
+    return reflection.isInstance(item, BackoffSpec.$type);
 }
-export const BeforeTriggerDefinition = 'BeforeTriggerDefinition';
+export const BeforeTriggerDefinition = {
+    $type: 'BeforeTriggerDefinition',
+    triggers: 'triggers'
+};
 export function isBeforeTriggerDefinition(item) {
-    return reflection.isInstance(item, BeforeTriggerDefinition);
+    return reflection.isInstance(item, BeforeTriggerDefinition.$type);
 }
-export const BinExpr = 'BinExpr';
+export const BinExpr = {
+    $type: 'BinExpr',
+    e1: 'e1',
+    e2: 'e2',
+    op: 'op'
+};
 export function isBinExpr(item) {
-    return reflection.isInstance(item, BinExpr);
+    return reflection.isInstance(item, BinExpr.$type);
 }
-export const CaseEntry = 'CaseEntry';
+export function isBoolean(item) {
+    return item === 'true' || item === 'false';
+}
+export const CaseEntry = {
+    $type: 'CaseEntry',
+    cond: 'cond',
+    statements: 'statements'
+};
 export function isCaseEntry(item) {
-    return reflection.isInstance(item, CaseEntry);
+    return reflection.isInstance(item, CaseEntry.$type);
 }
-export const CatchSpec = 'CatchSpec';
+export const CatchSpec = {
+    $type: 'CatchSpec',
+    handlers: 'handlers'
+};
 export function isCatchSpec(item) {
-    return reflection.isInstance(item, CatchSpec);
+    return reflection.isInstance(item, CatchSpec.$type);
 }
-export const CompositeUniqueDefinition = 'CompositeUniqueDefinition';
+export const CompositeUniqueDefinition = {
+    $type: 'CompositeUniqueDefinition',
+    attrs: 'attrs'
+};
 export function isCompositeUniqueDefinition(item) {
-    return reflection.isInstance(item, CompositeUniqueDefinition);
+    return reflection.isInstance(item, CompositeUniqueDefinition.$type);
 }
-export const ConditionalFlowStep = 'ConditionalFlowStep';
+export const ConditionalFlowStep = {
+    $type: 'ConditionalFlowStep',
+    expr: 'expr',
+    next: 'next'
+};
 export function isConditionalFlowStep(item) {
-    return reflection.isInstance(item, ConditionalFlowStep);
-}
-export const CrudMap = 'CrudMap';
+    return reflection.isInstance(item, ConditionalFlowStep.$type);
+}
+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'
+};
 export function isCrudMap(item) {
-    return reflection.isInstance(item, CrudMap);
+    return reflection.isInstance(item, CrudMap.$type);
 }
-export const CrudMapBody = 'CrudMapBody';
+export const CrudMapBody = {
+    $type: 'CrudMapBody',
+    attributes: 'attributes',
+    properties: 'properties'
+};
 export function isCrudMapBody(item) {
-    return reflection.isInstance(item, CrudMapBody);
+    return reflection.isInstance(item, CrudMapBody.$type);
 }
-export const DecisionDefBody = 'DecisionDefBody';
+export function isDecimal(item) {
+    return typeof item === 'number';
+}
+export const DecisionDefBody = {
+    $type: 'DecisionDefBody',
+    cases: 'cases'
+};
 export function isDecisionDefBody(item) {
-    return reflection.isInstance(item, DecisionDefBody);
+    return reflection.isInstance(item, DecisionDefBody.$type);
 }
-export const DecisionDefinition = 'DecisionDefinition';
+export const DecisionDefinition = {
+    $type: 'DecisionDefinition',
+    body: 'body',
+    name: 'name'
+};
 export function isDecisionDefinition(item) {
-    return reflection.isInstance(item, DecisionDefinition);
+    return reflection.isInstance(item, DecisionDefinition.$type);
 }
-export const Delete = 'Delete';
+export const Definition = {
+    $type: 'Definition'
+};
+export function isDefinition(item) {
+    return reflection.isInstance(item, Definition.$type);
+}
+export const Delete = {
+    $type: 'Delete',
+    pattern: 'pattern'
+};
 export function isDelete(item) {
-    return reflection.isInstance(item, Delete);
+    return reflection.isInstance(item, Delete.$type);
 }
-export const DirectiveDefinition = 'DirectiveDefinition';
+export const DirectiveDefinition = {
+    $type: 'DirectiveDefinition',
+    body: 'body',
+    dir: 'dir',
+    name: 'name'
+};
 export function isDirectiveDefinition(item) {
-    return reflection.isInstance(item, DirectiveDefinition);
+    return reflection.isInstance(item, DirectiveDefinition.$type);
 }
-export const Else = 'Else';
+export const Else = {
+    $type: 'Else',
+    statements: 'statements'
+};
 export function isElse(item) {
-    return reflection.isInstance(item, Else);
+    return reflection.isInstance(item, Else.$type);
 }
-export const EntityActionsDefinitions = 'EntityActionsDefinitions';
+export const EntityActionsDefinitions = {
+    $type: 'EntityActionsDefinitions',
+    entries: 'entries'
+};
 export function isEntityActionsDefinitions(item) {
-    return reflection.isInstance(item, EntityActionsDefinitions);
+    return reflection.isInstance(item, EntityActionsDefinitions.$type);
 }
-export const EntityDefinition = 'EntityDefinition';
+export const EntityDefinition = {
+    $type: 'EntityDefinition',
+    extends: 'extends',
+    name: 'name',
+    schema: 'schema'
+};
 export function isEntityDefinition(item) {
-    return reflection.isInstance(item, EntityDefinition);
+    return reflection.isInstance(item, EntityDefinition.$type);
 }
-export const EnumSpec = 'EnumSpec';
+export const EnumSpec = {
+    $type: 'EnumSpec',
+    type: 'type',
+    values: 'values'
+};
 export function isEnumSpec(item) {
-    return reflection.isInstance(item, EnumSpec);
+    return reflection.isInstance(item, EnumSpec.$type);
 }
-export const EventDefinition = 'EventDefinition';
+export const EventDefinition = {
+    $type: 'EventDefinition',
+    extends: 'extends',
+    name: 'name',
+    schema: 'schema'
+};
 export function isEventDefinition(item) {
-    return reflection.isInstance(item, EventDefinition);
+    return reflection.isInstance(item, EventDefinition.$type);
 }
-export const ExtendsClause = 'ExtendsClause';
+export const Expr = {
+    $type: 'Expr'
+};
+export function isExpr(item) {
+    return reflection.isInstance(item, Expr.$type);
+}
+export const ExtendsClause = {
+    $type: 'ExtendsClause',
+    parentName: 'parentName'
+};
 export function isExtendsClause(item) {
-    return reflection.isInstance(item, ExtendsClause);
+    return reflection.isInstance(item, ExtendsClause.$type);
 }
-export const FlowDefBody = 'FlowDefBody';
+export const FlowDefBody = {
+    $type: 'FlowDefBody',
+    entries: 'entries'
+};
 export function isFlowDefBody(item) {
-    return reflection.isInstance(item, FlowDefBody);
+    return reflection.isInstance(item, FlowDefBody.$type);
 }
-export const FlowDefinition = 'FlowDefinition';
+export const FlowDefinition = {
+    $type: 'FlowDefinition',
+    body: 'body',
+    name: 'name'
+};
 export function isFlowDefinition(item) {
-    return reflection.isInstance(item, FlowDefinition);
+    return reflection.isInstance(item, FlowDefinition.$type);
 }
-export const FlowEntry = 'FlowEntry';
+export const FlowEntry = {
+    $type: 'FlowEntry',
+    cond: 'cond',
+    next: 'next',
+    root: 'root'
+};
 export function isFlowEntry(item) {
-    return reflection.isInstance(item, FlowEntry);
+    return reflection.isInstance(item, FlowEntry.$type);
 }
-export const FnCall = 'FnCall';
+export const FlowStepSpec = {
+    $type: 'FlowStepSpec'
+};
+export function isFlowStepSpec(item) {
+    return reflection.isInstance(item, FlowStepSpec.$type);
+}
+export const FnCall = {
+    $type: 'FnCall',
+    args: 'args',
+    name: 'name'
+};
 export function isFnCall(item) {
-    return reflection.isInstance(item, FnCall);
+    return reflection.isInstance(item, FnCall.$type);
 }
-export const ForEach = 'ForEach';
+export const ForEach = {
+    $type: 'ForEach',
+    src: 'src',
+    statements: 'statements',
+    var: 'var'
+};
 export function isForEach(item) {
-    return reflection.isInstance(item, ForEach);
+    return reflection.isInstance(item, ForEach.$type);
 }
-export const FullTextSearch = 'FullTextSearch';
+export const FullTextSearch = {
+    $type: 'FullTextSearch',
+    name: 'name',
+    options: 'options',
+    query: 'query'
+};
 export function isFullTextSearch(item) {
-    return reflection.isInstance(item, FullTextSearch);
+    return reflection.isInstance(item, FullTextSearch.$type);
 }
-export const GenericDefBody = 'GenericDefBody';
+export const GenericDefBody = {
+    $type: 'GenericDefBody',
+    attributes: 'attributes'
+};
 export function isGenericDefBody(item) {
-    return reflection.isInstance(item, GenericDefBody);
+    return reflection.isInstance(item, GenericDefBody.$type);
+}
+export function isGenericName(item) {
+    return isSTRING(item) || (typeof item === 'string' && (/(?:[_a-zA-Z][\w_]*)(\/(?:[_a-zA-Z][\w_]*))?/.test(item)));
 }
-export const GenericPropertyDef = 'GenericPropertyDef';
+export const GenericPropertyDef = {
+    $type: 'GenericPropertyDef',
+    name: 'name',
+    value: 'value'
+};
 export function isGenericPropertyDef(item) {
-    return reflection.isInstance(item, GenericPropertyDef);
+    return reflection.isInstance(item, GenericPropertyDef.$type);
 }
-export const GlossaryEntryDefinition = 'GlossaryEntryDefinition';
+export const GlossaryEntryDefinition = {
+    $type: 'GlossaryEntryDefinition',
+    body: 'body',
+    glos: 'glos',
+    name: 'name'
+};
 export function isGlossaryEntryDefinition(item) {
-    return reflection.isInstance(item, GlossaryEntryDefinition);
+    return reflection.isInstance(item, GlossaryEntryDefinition.$type);
 }
-export const Group = 'Group';
+export const Group = {
+    $type: 'Group',
+    ge: 'ge'
+};
 export function isGroup(item) {
-    return reflection.isInstance(item, Group);
+    return reflection.isInstance(item, Group.$type);
 }
-export const GroupByClause = 'GroupByClause';
+export const GroupByClause = {
+    $type: 'GroupByClause',
+    colNames: 'colNames'
+};
 export function isGroupByClause(item) {
-    return reflection.isInstance(item, GroupByClause);
+    return reflection.isInstance(item, GroupByClause.$type);
 }
-export const Handler = 'Handler';
+export const Handler = {
+    $type: 'Handler',
+    except: 'except',
+    stmt: 'stmt'
+};
 export function isHandler(item) {
-    return reflection.isInstance(item, Handler);
+    return reflection.isInstance(item, Handler.$type);
 }
-export const If = 'If';
+export const If = {
+    $type: 'If',
+    cond: 'cond',
+    else: 'else',
+    statements: 'statements'
+};
 export function isIf(item) {
-    return reflection.isInstance(item, If);
+    return reflection.isInstance(item, If.$type);
 }
-export const IfWithAlias = 'IfWithAlias';
+export const IfWithAlias = {
+    $type: 'IfWithAlias',
+    if: 'if'
+};
 export function isIfWithAlias(item) {
-    return reflection.isInstance(item, IfWithAlias);
+    return reflection.isInstance(item, IfWithAlias.$type);
 }
-export const Import = 'Import';
+export const Import = {
+    $type: 'Import',
+    name: 'name',
+    path: 'path'
+};
 export function isImport(item) {
-    return reflection.isInstance(item, Import);
-}
-export const JoinSpec = 'JoinSpec';
+    return reflection.isInstance(item, Import.$type);
+}
+export const JoinSpec = {
+    $type: 'JoinSpec',
+    lhs: 'lhs',
+    name: 'name',
+    op: 'op',
+    rhs: 'rhs',
+    type: 'type'
+};
 export function isJoinSpec(item) {
-    return reflection.isInstance(item, JoinSpec);
+    return reflection.isInstance(item, JoinSpec.$type);
 }
-export const KvPair = 'KvPair';
+export function isJoinType(item) {
+    return item === '@join' || item === '@inner_join' || item === '@left_join' || item === '@right_join' || item === '@full_join';
+}
+export const KvPair = {
+    $type: 'KvPair',
+    key: 'key',
+    value: 'value'
+};
 export function isKvPair(item) {
-    return reflection.isInstance(item, KvPair);
+    return reflection.isInstance(item, KvPair.$type);
 }
-export const KvPairs = 'KvPairs';
+export const KvPairs = {
+    $type: 'KvPairs',
+    pairs: 'pairs'
+};
 export function isKvPairs(item) {
-    return reflection.isInstance(item, KvPairs);
-}
-export const Literal = 'Literal';
+    return reflection.isInstance(item, KvPairs.$type);
+}
+export const Literal = {
+    $type: 'Literal',
+    array: 'array',
+    asyncFnCall: 'asyncFnCall',
+    bool: 'bool',
+    fnCall: 'fnCall',
+    id: 'id',
+    map: 'map',
+    num: 'num',
+    ref: 'ref',
+    str: 'str'
+};
 export function isLiteral(item) {
-    return reflection.isInstance(item, Literal);
+    return reflection.isInstance(item, Literal.$type);
 }
-export const MapEntry = 'MapEntry';
+export const MapEntry = {
+    $type: 'MapEntry',
+    key: 'key',
+    value: 'value'
+};
 export function isMapEntry(item) {
-    return reflection.isInstance(item, MapEntry);
+    return reflection.isInstance(item, MapEntry.$type);
 }
-export const MapKey = 'MapKey';
+export const MapKey = {
+    $type: 'MapKey',
+    bool: 'bool',
+    num: 'num',
+    str: 'str'
+};
 export function isMapKey(item) {
-    return reflection.isInstance(item, MapKey);
+    return reflection.isInstance(item, MapKey.$type);
 }
-export const MapLiteral = 'MapLiteral';
+export const MapLiteral = {
+    $type: 'MapLiteral',
+    entries: 'entries'
+};
 export function isMapLiteral(item) {
-    return reflection.isInstance(item, MapLiteral);
+    return reflection.isInstance(item, MapLiteral.$type);
 }
-export const MetaDefinition = 'MetaDefinition';
+export const MetaDefinition = {
+    $type: 'MetaDefinition',
+    spec: 'spec'
+};
 export function isMetaDefinition(item) {
-    return reflection.isInstance(item, MetaDefinition);
+    return reflection.isInstance(item, MetaDefinition.$type);
 }
-export const ModuleDefinition = 'ModuleDefinition';
+export const ModuleDefinition = {
+    $type: 'ModuleDefinition',
+    defs: 'defs',
+    imports: 'imports',
+    name: 'name'
+};
 export function isModuleDefinition(item) {
-    return reflection.isInstance(item, ModuleDefinition);
+    return reflection.isInstance(item, ModuleDefinition.$type);
 }
-export const NegExpr = 'NegExpr';
+export const NegExpr = {
+    $type: 'NegExpr',
+    ne: 'ne'
+};
 export function isNegExpr(item) {
-    return reflection.isInstance(item, NegExpr);
+    return reflection.isInstance(item, NegExpr.$type);
 }
-export const NodeDefinition = 'NodeDefinition';
+export const NodeDefinition = {
+    $type: 'NodeDefinition',
+    alias: 'alias',
+    name: 'name'
+};
 export function isNodeDefinition(item) {
-    return reflection.isInstance(item, NodeDefinition);
+    return reflection.isInstance(item, NodeDefinition.$type);
 }
-export const NotExpr = 'NotExpr';
+export const NotExpr = {
+    $type: 'NotExpr',
+    ne: 'ne'
+};
 export function isNotExpr(item) {
-    return reflection.isInstance(item, NotExpr);
+    return reflection.isInstance(item, NotExpr.$type);
 }
-export const OneOfSpec = 'OneOfSpec';
+export const OneOfSpec = {
+    $type: 'OneOfSpec',
+    ref: 'ref'
+};
 export function isOneOfSpec(item) {
-    return reflection.isInstance(item, OneOfSpec);
+    return reflection.isInstance(item, OneOfSpec.$type);
 }
-export const OrderByClause = 'OrderByClause';
+export const OrderByClause = {
+    $type: 'OrderByClause',
+    colNames: 'colNames',
+    order: 'order'
+};
 export function isOrderByClause(item) {
-    return reflection.isInstance(item, OrderByClause);
-}
-export const Pattern = 'Pattern';
+    return reflection.isInstance(item, OrderByClause.$type);
+}
+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'
+};
 export function isPattern(item) {
-    return reflection.isInstance(item, Pattern);
+    return reflection.isInstance(item, Pattern.$type);
 }
-export const PrePostTriggerDefinition = 'PrePostTriggerDefinition';
+export const PrePostTriggerDefinition = {
+    $type: 'PrePostTriggerDefinition',
+    after: 'after',
+    before: 'before'
+};
 export function isPrePostTriggerDefinition(item) {
-    return reflection.isInstance(item, PrePostTriggerDefinition);
+    return reflection.isInstance(item, PrePostTriggerDefinition.$type);
+}
+export const PrimExpr = {
+    $type: 'PrimExpr'
+};
+export function isPrimExpr(item) {
+    return reflection.isInstance(item, PrimExpr.$type);
 }
-export const PropertyDefinition = 'PropertyDefinition';
+export const PropertyDefinition = {
+    $type: 'PropertyDefinition',
+    name: 'name',
+    value: 'value'
+};
 export function isPropertyDefinition(item) {
-    return reflection.isInstance(item, PropertyDefinition);
+    return reflection.isInstance(item, PropertyDefinition.$type);
 }
-export const PublicAgentDefinition = 'PublicAgentDefinition';
+export const PublicAgentDefinition = {
+    $type: 'PublicAgentDefinition',
+    def: 'def'
+};
 export function isPublicAgentDefinition(item) {
-    return reflection.isInstance(item, PublicAgentDefinition);
+    return reflection.isInstance(item, PublicAgentDefinition.$type);
 }
-export const PublicEventDefinition = 'PublicEventDefinition';
+export const PublicEventDefinition = {
+    $type: 'PublicEventDefinition',
+    def: 'def'
+};
 export function isPublicEventDefinition(item) {
-    return reflection.isInstance(item, PublicEventDefinition);
+    return reflection.isInstance(item, PublicEventDefinition.$type);
 }
-export const PublicWorkflowDefinition = 'PublicWorkflowDefinition';
+export const PublicWorkflowDefinition = {
+    $type: 'PublicWorkflowDefinition',
+    def: 'def'
+};
 export function isPublicWorkflowDefinition(item) {
-    return reflection.isInstance(item, PublicWorkflowDefinition);
+    return reflection.isInstance(item, PublicWorkflowDefinition.$type);
 }
-export const Purge = 'Purge';
+export const Purge = {
+    $type: 'Purge',
+    pattern: 'pattern'
+};
 export function isPurge(item) {
-    return reflection.isInstance(item, Purge);
+    return reflection.isInstance(item, Purge.$type);
+}
+export function isQualifiedName(item) {
+    return isRef(item) || (typeof item === 'string' && (/(?:[_a-zA-Z][\w_]*)(\/(?:[_a-zA-Z][\w_]*))?/.test(item)));
+}
+export function isQueryId(item) {
+    return typeof item === 'string';
 }
-export const RbacAllowSpec = 'RbacAllowSpec';
+export const RbacAllowSpec = {
+    $type: 'RbacAllowSpec',
+    oprs: 'oprs'
+};
 export function isRbacAllowSpec(item) {
-    return reflection.isInstance(item, RbacAllowSpec);
+    return reflection.isInstance(item, RbacAllowSpec.$type);
 }
-export const RbacExpressionSpec = 'RbacExpressionSpec';
+export const RbacExpressionSpec = {
+    $type: 'RbacExpressionSpec',
+    lhs: 'lhs',
+    rhs: 'rhs'
+};
 export function isRbacExpressionSpec(item) {
-    return reflection.isInstance(item, RbacExpressionSpec);
+    return reflection.isInstance(item, RbacExpressionSpec.$type);
 }
-export const RbacOpr = 'RbacOpr';
+export const RbacOpr = {
+    $type: 'RbacOpr',
+    value: 'value'
+};
 export function isRbacOpr(item) {
-    return reflection.isInstance(item, RbacOpr);
+    return reflection.isInstance(item, RbacOpr.$type);
 }
-export const RbacRolesSpec = 'RbacRolesSpec';
+export const RbacRolesSpec = {
+    $type: 'RbacRolesSpec',
+    roles: 'roles'
+};
 export function isRbacRolesSpec(item) {
-    return reflection.isInstance(item, RbacRolesSpec);
+    return reflection.isInstance(item, RbacRolesSpec.$type);
 }
-export const RbacSpecDefinition = 'RbacSpecDefinition';
+export const RbacSpecDefinition = {
+    $type: 'RbacSpecDefinition',
+    specEntries: 'specEntries'
+};
 export function isRbacSpecDefinition(item) {
-    return reflection.isInstance(item, RbacSpecDefinition);
+    return reflection.isInstance(item, RbacSpecDefinition.$type);
 }
-export const RbacSpecEntries = 'RbacSpecEntries';
+export const RbacSpecEntries = {
+    $type: 'RbacSpecEntries',
+    entries: 'entries'
+};
 export function isRbacSpecEntries(item) {
-    return reflection.isInstance(item, RbacSpecEntries);
+    return reflection.isInstance(item, RbacSpecEntries.$type);
 }
-export const RbacSpecEntry = 'RbacSpecEntry';
+export const RbacSpecEntry = {
+    $type: 'RbacSpecEntry',
+    allow: 'allow',
+    expr: 'expr',
+    role: 'role'
+};
 export function isRbacSpecEntry(item) {
-    return reflection.isInstance(item, RbacSpecEntry);
+    return reflection.isInstance(item, RbacSpecEntry.$type);
 }
-export const RecordDefinition = 'RecordDefinition';
+export const RecordDefinition = {
+    $type: 'RecordDefinition',
+    extends: 'extends',
+    name: 'name',
+    schema: 'schema'
+};
 export function isRecordDefinition(item) {
-    return reflection.isInstance(item, RecordDefinition);
-}
-export const RecordExtraDefinition = 'RecordExtraDefinition';
+    return reflection.isInstance(item, RecordDefinition.$type);
+}
+export const RecordExtraDefinition = {
+    $type: 'RecordExtraDefinition',
+    actions: 'actions',
+    meta: 'meta',
+    prePost: 'prePost',
+    rbacSpec: 'rbacSpec',
+    uq: 'uq'
+};
 export function isRecordExtraDefinition(item) {
-    return reflection.isInstance(item, RecordExtraDefinition);
+    return reflection.isInstance(item, RecordExtraDefinition.$type);
 }
-export const RecordSchemaDefinition = 'RecordSchemaDefinition';
+export const RecordSchemaDefinition = {
+    $type: 'RecordSchemaDefinition',
+    attributes: 'attributes',
+    extras: 'extras'
+};
 export function isRecordSchemaDefinition(item) {
-    return reflection.isInstance(item, RecordSchemaDefinition);
+    return reflection.isInstance(item, RecordSchemaDefinition.$type);
 }
-export const RefSpec = 'RefSpec';
-export function isRefSpec(item) {
-    return reflection.isInstance(item, RefSpec);
+export function isRef(item) {
+    return typeof item === 'string';
 }
-export const RelationshipDefinition = 'RelationshipDefinition';
+export const RefSpec = {
+    $type: 'RefSpec',
+    ref: 'ref',
+    type: 'type'
+};
+export function isRefSpec(item) {
+    return reflection.isInstance(item, RefSpec.$type);
+}
+export const RelationshipDefinition = {
+    $type: 'RelationshipDefinition',
+    name: 'name',
+    nodes: 'nodes',
+    properties: 'properties',
+    schema: 'schema',
+    type: 'type'
+};
 export function isRelationshipDefinition(item) {
-    return reflection.isInstance(item, RelationshipDefinition);
+    return reflection.isInstance(item, RelationshipDefinition.$type);
 }
-export const RelationshipPattern = 'RelationshipPattern';
+export const RelationshipPattern = {
+    $type: 'RelationshipPattern',
+    name: 'name',
+    pattern: 'pattern'
+};
 export function isRelationshipPattern(item) {
-    return reflection.isInstance(item, RelationshipPattern);
+    return reflection.isInstance(item, RelationshipPattern.$type);
 }
-export const RelNodes = 'RelNodes';
+export const RelNodes = {
+    $type: 'RelNodes',
+    node1: 'node1',
+    node2: 'node2'
+};
 export function isRelNodes(item) {
-    return reflection.isInstance(item, RelNodes);
+    return reflection.isInstance(item, RelNodes.$type);
 }
-export const ResolverDefinition = 'ResolverDefinition';
+export const ResolverDefinition = {
+    $type: 'ResolverDefinition',
+    methods: 'methods',
+    name: 'name',
+    paths: 'paths'
+};
 export function isResolverDefinition(item) {
-    return reflection.isInstance(item, ResolverDefinition);
+    return reflection.isInstance(item, ResolverDefinition.$type);
 }
-export const ResolverFnName = 'ResolverFnName';
+export const ResolverFnName = {
+    $type: 'ResolverFnName',
+    name: 'name'
+};
 export function isResolverFnName(item) {
-    return reflection.isInstance(item, ResolverFnName);
+    return reflection.isInstance(item, ResolverFnName.$type);
 }
-export const ResolverMethodName = 'ResolverMethodName';
+export const ResolverMethodName = {
+    $type: 'ResolverMethodName',
+    name: 'name'
+};
 export function isResolverMethodName(item) {
-    return reflection.isInstance(item, ResolverMethodName);
+    return reflection.isInstance(item, ResolverMethodName.$type);
 }
-export const ResolverMethodSpec = 'ResolverMethodSpec';
+export const ResolverMethodSpec = {
+    $type: 'ResolverMethodSpec',
+    fn: 'fn',
+    key: 'key'
+};
 export function isResolverMethodSpec(item) {
-    return reflection.isInstance(item, ResolverMethodSpec);
+    return reflection.isInstance(item, ResolverMethodSpec.$type);
 }
-export const RetryDefinition = 'RetryDefinition';
+export function isResolverPathEntry(item) {
+    return isQualifiedName(item) || isGenericName(item);
+}
+export const RetryDefinition = {
+    $type: 'RetryDefinition',
+    attempts: 'attempts',
+    backoff: 'backoff',
+    name: 'name'
+};
 export function isRetryDefinition(item) {
-    return reflection.isInstance(item, RetryDefinition);
+    return reflection.isInstance(item, RetryDefinition.$type);
 }
-export const Return = 'Return';
+export const Return = {
+    $type: 'Return',
+    pattern: 'pattern'
+};
 export function isReturn(item) {
-    return reflection.isInstance(item, Return);
+    return reflection.isInstance(item, Return.$type);
 }
-export const RuntimeHint = 'RuntimeHint';
+export const RuntimeHint = {
+    $type: 'RuntimeHint',
+    aliasSpec: 'aliasSpec',
+    catchSpec: 'catchSpec',
+    thenSpec: 'thenSpec'
+};
 export function isRuntimeHint(item) {
-    return reflection.isInstance(item, RuntimeHint);
+    return reflection.isInstance(item, RuntimeHint.$type);
 }
-export const ScenarioDefinition = 'ScenarioDefinition';
+export const ScenarioDefinition = {
+    $type: 'ScenarioDefinition',
+    body: 'body',
+    name: 'name',
+    scn: 'scn'
+};
 export function isScenarioDefinition(item) {
-    return reflection.isInstance(item, ScenarioDefinition);
+    return reflection.isInstance(item, ScenarioDefinition.$type);
 }
-export const SelectIntoEntry = 'SelectIntoEntry';
+export const SchemaDefinition = {
+    $type: 'SchemaDefinition'
+};
+export function isSchemaDefinition(item) {
+    return reflection.isInstance(item, SchemaDefinition.$type);
+}
+export const SelectIntoEntry = {
+    $type: 'SelectIntoEntry',
+    aggregate: 'aggregate',
+    alias: 'alias',
+    attribute: 'attribute'
+};
 export function isSelectIntoEntry(item) {
-    return reflection.isInstance(item, SelectIntoEntry);
+    return reflection.isInstance(item, SelectIntoEntry.$type);
 }
-export const SelectIntoSpec = 'SelectIntoSpec';
+export const SelectIntoSpec = {
+    $type: 'SelectIntoSpec',
+    entries: 'entries'
+};
 export function isSelectIntoSpec(item) {
-    return reflection.isInstance(item, SelectIntoSpec);
-}
-export const SetAttribute = 'SetAttribute';
+    return reflection.isInstance(item, SelectIntoSpec.$type);
+}
+export const SetAttribute = {
+    $type: 'SetAttribute',
+    aggregate: 'aggregate',
+    name: 'name',
+    op: 'op',
+    value: 'value'
+};
 export function isSetAttribute(item) {
-    return reflection.isInstance(item, SetAttribute);
+    return reflection.isInstance(item, SetAttribute.$type);
+}
+export function isSqlComparisonOpr(item) {
+    return item === '=' || item === '<>' || item === '!=' || item === '<' || item === '<=' || item === '>' || item === '>=' || item === 'in' || item === 'like' || item === 'between';
 }
-export const StandaloneStatement = 'StandaloneStatement';
+export const StandaloneStatement = {
+    $type: 'StandaloneStatement',
+    stmt: 'stmt'
+};
 export function isStandaloneStatement(item) {
-    return reflection.isInstance(item, StandaloneStatement);
+    return reflection.isInstance(item, StandaloneStatement.$type);
 }
-export const Statement = 'Statement';
+export const Statement = {
+    $type: 'Statement',
+    hints: 'hints',
+    pattern: 'pattern'
+};
 export function isStatement(item) {
-    return reflection.isInstance(item, Statement);
+    return reflection.isInstance(item, Statement.$type);
+}
+export function isSTRING(item) {
+    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 const ThenSpec = 'ThenSpec';
+export function isTaggedId(item) {
+    return typeof item === 'string';
+}
+export const ThenSpec = {
+    $type: 'ThenSpec',
+    statements: 'statements'
+};
 export function isThenSpec(item) {
-    return reflection.isInstance(item, ThenSpec);
+    return reflection.isInstance(item, ThenSpec.$type);
 }
-export const ThrowError = 'ThrowError';
+export const ThrowError = {
+    $type: 'ThrowError',
+    reason: 'reason'
+};
 export function isThrowError(item) {
-    return reflection.isInstance(item, ThrowError);
+    return reflection.isInstance(item, ThrowError.$type);
 }
-export const TriggerDefinition = 'TriggerDefinition';
+export const TriggerDefinition = {
+    $type: 'TriggerDefinition',
+    entries: 'entries'
+};
 export function isTriggerDefinition(item) {
-    return reflection.isInstance(item, TriggerDefinition);
+    return reflection.isInstance(item, TriggerDefinition.$type);
 }
-export const TriggerEntry = 'TriggerEntry';
+export const TriggerEntry = {
+    $type: 'TriggerEntry',
+    async: 'async',
+    event: 'event',
+    on: 'on'
+};
 export function isTriggerEntry(item) {
-    return reflection.isInstance(item, TriggerEntry);
+    return reflection.isInstance(item, TriggerEntry.$type);
 }
-export const WhereSpec = 'WhereSpec';
+export const WhereSpec = {
+    $type: 'WhereSpec',
+    clauses: 'clauses'
+};
 export function isWhereSpec(item) {
-    return reflection.isInstance(item, WhereSpec);
+    return reflection.isInstance(item, WhereSpec.$type);
 }
-export const WhereSpecClause = 'WhereSpecClause';
+export const WhereSpecClause = {
+    $type: 'WhereSpecClause',
+    lhs: 'lhs',
+    op: 'op',
+    rhs: 'rhs'
+};
 export function isWhereSpecClause(item) {
-    return reflection.isInstance(item, WhereSpecClause);
-}
-export const WorkflowDefinition = 'WorkflowDefinition';
+    return reflection.isInstance(item, WhereSpecClause.$type);
+}
+export const WorkflowDefinition = {
+    $type: 'WorkflowDefinition',
+    directives: 'directives',
+    header: 'header',
+    name: 'name',
+    statements: 'statements'
+};
 export function isWorkflowDefinition(item) {
-    return reflection.isInstance(item, WorkflowDefinition);
+    return reflection.isInstance(item, WorkflowDefinition.$type);
+}
+export const WorkflowDirectiveEntry = {
+    $type: 'WorkflowDirectiveEntry',
+    tag: 'tag',
+    value: 'value'
+};
+export function isWorkflowDirectiveEntry(item) {
+    return reflection.isInstance(item, WorkflowDirectiveEntry.$type);
 }
-export const WorkflowHeader = 'WorkflowHeader';
+export const WorkflowDirectives = {
+    $type: 'WorkflowDirectives',
+    entries: 'entries'
+};
+export function isWorkflowDirectives(item) {
+    return reflection.isInstance(item, WorkflowDirectives.$type);
+}
+export const WorkflowHeader = {
+    $type: 'WorkflowHeader',
+    name: 'name',
+    prefix: 'prefix',
+    tag: 'tag'
+};
 export function isWorkflowHeader(item) {
-    return reflection.isInstance(item, WorkflowHeader);
+    return reflection.isInstance(item, WorkflowHeader.$type);
+}
+export function isWorkflowHeaderPrefix(item) {
+    return item === 'create' || item === 'update' || item === 'delete';
+}
+export function isWorkflowHeaderTag(item) {
+    return item === '@after' || item === '@before';
 }
 export class AgentlangAstReflection extends langium.AbstractAstReflection {
-    getAllTypes() {
-        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];
-    }
-    computeIsSubtype(subtype, supertype) {
-        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) {
-        const referenceId = `${refInfo.container.$type}:${refInfo.property}`;
-        switch (referenceId) {
-            default: {
-                throw new Error(`${referenceId} is not a valid reference id.`);
-            }
-        }
-    }
-    getTypeMetaData(type) {
-        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: []
-                };
-            }
-        }
+    constructor() {
+        super(...arguments);
+        this.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]
+            },
+            AgentEvaluatorDefinition: {
+                name: AgentEvaluatorDefinition.$type,
+                properties: {
+                    attributes: {
+                        name: AgentEvaluatorDefinition.attributes,
+                        defaultValue: []
+                    },
+                    name: {
+                        name: AgentEvaluatorDefinition.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: {
+                    directives: {
+                        name: WorkflowDefinition.directives
+                    },
+                    header: {
+                        name: WorkflowDefinition.header
+                    },
+                    name: {
+                        name: WorkflowDefinition.name
+                    },
+                    statements: {
+                        name: WorkflowDefinition.statements,
+                        defaultValue: []
+                    }
+                },
+                superTypes: [Definition.$type]
+            },
+            WorkflowDirectiveEntry: {
+                name: WorkflowDirectiveEntry.$type,
+                properties: {
+                    tag: {
+                        name: WorkflowDirectiveEntry.tag
+                    },
+                    value: {
+                        name: WorkflowDirectiveEntry.value
+                    }
+                },
+                superTypes: []
+            },
+            WorkflowDirectives: {
+                name: WorkflowDirectives.$type,
+                properties: {
+                    entries: {
+                        name: WorkflowDirectives.entries,
+                        defaultValue: []
+                    }
+                },
+                superTypes: []
+            },
+            WorkflowHeader: {
+                name: WorkflowHeader.$type,
+                properties: {
+                    name: {
+                        name: WorkflowHeader.name
+                    },
+                    prefix: {
+                        name: WorkflowHeader.prefix
+                    },
+                    tag: {
+                        name: WorkflowHeader.tag
+                    }
+                },
+                superTypes: []
+            }
+        };
     }
 }
 export const reflection = new AgentlangAstReflection();