agentlang/src/language/generated/ast.ts

The easiest way to build the most reliable AI agents - enterprise-grade teams of AI agents that collaborate with each other and humans

/******************************************************************************
 * This file was generated by langium-cli 3.5.2.
 * DO NOT EDIT MANUALLY!
 ******************************************************************************/

/* eslint-disable */
import * as langium from 'langium';

export const AgentlangTerminals = {
    ID: /(([_a-zA-Z][\w_]*)(\/([_a-zA-Z][\w_]*))?)/,
    STRING: /("(((\\([\s\S]))|((?!(((\\|")|\r)|\n))[\s\S]*?))|(\r?\n))*")/,
    INT: /-?[0-9]+/,
    WS: /\s+/,
    ML_COMMENT: /\/\*[\s\S]*?\*\//,
    SL_COMMENT: /\/\/[^\n\r]*/,
};

export type AgentlangTerminalNames = keyof typeof AgentlangTerminals;

export type AgentlangKeywordNames =
    | "!="
    | "("
    | ")"
    | "*"
    | "+"
    | ","
    | "-"
    | "-->"
    | "."
    | "/"
    | ":"
    | ";"
    | "<"
    | "<="
    | "<>"
    | "="
    | "=="
    | ">"
    | ">="
    | "?"
    | "@"
    | "@actions"
    | "@after"
    | "@as"
    | "@async"
    | "@before"
    | "@catch"
    | "@distinct"
    | "@enum"
    | "@expr"
    | "@from"
    | "@full_join"
    | "@inner_join"
    | "@into"
    | "@join"
    | "@left_join"
    | "@meta"
    | "@oneof"
    | "@public"
    | "@rbac"
    | "@ref"
    | "@right_join"
    | "@then"
    | "@upsert"
    | "@with_unique"
    | "["
    | "]"
    | "agent"
    | "agentlang/retry"
    | "allow"
    | "and"
    | "attempts"
    | "await"
    | "backoff"
    | "between"
    | "case"
    | "commitTransaction"
    | "contains"
    | "create"
    | "decision"
    | "delete"
    | "directive"
    | "else"
    | "entity"
    | "error"
    | "event"
    | "extends"
    | "false"
    | "flow"
    | "for"
    | "glossaryEntry"
    | "if"
    | "import"
    | "in"
    | "like"
    | "module"
    | "not"
    | "not_found"
    | "onSubscription"
    | "or"
    | "purge"
    | "query"
    | "read"
    | "record"
    | "relationship"
    | "resolver"
    | "return"
    | "roles"
    | "rollbackTransaction"
    | "scenario"
    | "startTransaction"
    | "subscribe"
    | "true"
    | "update"
    | "upsert"
    | "where"
    | "workflow"
    | "{"
    | "}";

export type AgentlangTokenNames = AgentlangTerminalNames | AgentlangKeywordNames;

export type AttributeValueExpression = Expr;

export const AttributeValueExpression = 'AttributeValueExpression';

export function isAttributeValueExpression(item: unknown): item is AttributeValueExpression {
    return reflection.isInstance(item, AttributeValueExpression);
}

export type Boolean = 'false' | 'true';

export function isBoolean(item: unknown): item is Boolean {
    return item === 'true' || item === 'false';
}

export type Decimal = number;

export function isDecimal(item: unknown): item is Decimal {
    return typeof item === 'number';
}

export type Definition = AgentDefinition | DecisionDefinition | DirectiveDefinition | FlowDefinition | GlossaryEntryDefinition | PublicAgentDefinition | PublicWorkflowDefinition | RelationshipDefinition | ResolverDefinition | RetryDefinition | ScenarioDefinition | SchemaDefinition | StandaloneStatement | WorkflowDefinition;

export const Definition = 'Definition';

export function isDefinition(item: unknown): item is Definition {
    return reflection.isInstance(item, Definition);
}

export type Expr = BinExpr | PrimExpr;

export const Expr = 'Expr';

export function isExpr(item: unknown): item is Expr {
    return reflection.isInstance(item, Expr);
}

export type FlowStepSpec = CrudMap;

export const FlowStepSpec = 'FlowStepSpec';

export function isFlowStepSpec(item: unknown): item is FlowStepSpec {
    return reflection.isInstance(item, FlowStepSpec);
}

export type GenericName = string;

export function isGenericName(item: unknown): item is GenericName {
    return (typeof item === 'string' && (/(([_a-zA-Z][\w_]*)(\/([_a-zA-Z][\w_]*))?)/.test(item) || /("(((\\([\s\S]))|((?!(((\\|")|\r)|\n))[\s\S]*?))|(\r?\n))*")/.test(item)));
}

export type JoinType = '@full_join' | '@inner_join' | '@join' | '@left_join' | '@right_join';

export function isJoinType(item: unknown): item is JoinType {
    return item === '@join' || item === '@inner_join' || item === '@left_join' || item === '@right_join' || item === '@full_join';
}

export type PrimExpr = Group | Literal | NegExpr | NotExpr;

export const PrimExpr = 'PrimExpr';

export function isPrimExpr(item: unknown): item is PrimExpr {
    return reflection.isInstance(item, PrimExpr);
}

export type QualifiedName = Ref | string;

export function isQualifiedName(item: unknown): item is QualifiedName {
    return isRef(item) || (typeof item === 'string' && (/(([_a-zA-Z][\w_]*)(\/([_a-zA-Z][\w_]*))?)/.test(item)));
}

export type QueryId = string;

export function isQueryId(item: unknown): item is QueryId {
    return typeof item === 'string';
}

export type Ref = string;

export function isRef(item: unknown): item is Ref {
    return typeof item === 'string';
}

export type SchemaDefinition = EntityDefinition | EventDefinition | PublicEventDefinition | RecordDefinition;

export const SchemaDefinition = 'SchemaDefinition';

export function isSchemaDefinition(item: unknown): item is SchemaDefinition {
    return reflection.isInstance(item, SchemaDefinition);
}

export type SqlComparisonOpr = '!=' | '<' | '<=' | '<>' | '=' | '>' | '>=' | 'between' | 'in' | 'like';

export function isSqlComparisonOpr(item: unknown): item is SqlComparisonOpr {
    return item === '=' || item === '<>' || item === '!=' || item === '<' || item === '<=' || item === '>' || item === '>=' || item === 'in' || item === 'like' || item === 'between';
}

export type TaggedId = string;

export function isTaggedId(item: unknown): item is TaggedId {
    return typeof item === 'string';
}

export type WorkflowHeaderPrefix = 'create' | 'delete' | 'update';

export function isWorkflowHeaderPrefix(item: unknown): item is WorkflowHeaderPrefix {
    return item === 'create' || item === 'update' || item === 'delete';
}

export type WorkflowHeaderTag = '@after' | '@before';

export function isWorkflowHeaderTag(item: unknown): item is WorkflowHeaderTag {
    return item === '@after' || item === '@before';
}

export interface ActionEntry extends langium.AstNode {
    readonly $container: EntityActionsDefinitions;
    readonly $type: 'ActionEntry';
    event: string;
    name: string;
}

export const ActionEntry = 'ActionEntry';

export function isActionEntry(item: unknown): item is ActionEntry {
    return reflection.isInstance(item, ActionEntry);
}

export interface AfterTriggerDefinition extends langium.AstNode {
    readonly $container: PrePostTriggerDefinition;
    readonly $type: 'AfterTriggerDefinition';
    triggers: TriggerDefinition;
}

export const AfterTriggerDefinition = 'AfterTriggerDefinition';

export function isAfterTriggerDefinition(item: unknown): item is AfterTriggerDefinition {
    return reflection.isInstance(item, AfterTriggerDefinition);
}

export interface AgentDefinition extends langium.AstNode {
    readonly $container: ModuleDefinition | PublicAgentDefinition;
    readonly $type: 'AgentDefinition';
    body?: GenericDefBody;
    name: GenericName;
}

export const AgentDefinition = 'AgentDefinition';

export function isAgentDefinition(item: unknown): item is AgentDefinition {
    return reflection.isInstance(item, AgentDefinition);
}

export interface AgentXtraAttribute extends langium.AstNode {
    readonly $container: AgentXtraSpec;
    readonly $type: 'AgentXtraAttribute' | 'Ref';
    name: string;
    value: string;
}

export const AgentXtraAttribute = 'AgentXtraAttribute';

export function isAgentXtraAttribute(item: unknown): item is AgentXtraAttribute {
    return reflection.isInstance(item, AgentXtraAttribute);
}

export interface AgentXtraSpec extends langium.AstNode {
    readonly $container: GlossaryEntryDefinition;
    readonly $type: 'AgentXtraSpec';
    attributes: Array<AgentXtraAttribute>;
}

export const AgentXtraSpec = 'AgentXtraSpec';

export function isAgentXtraSpec(item: unknown): item is AgentXtraSpec {
    return reflection.isInstance(item, AgentXtraSpec);
}

export interface AliasSpec extends langium.AstNode {
    readonly $container: RuntimeHint;
    readonly $type: 'AliasSpec';
    alias?: string;
    aliases: Array<string>;
}

export const AliasSpec = 'AliasSpec';

export function isAliasSpec(item: unknown): item is AliasSpec {
    return reflection.isInstance(item, AliasSpec);
}

export interface ArrayLiteral extends langium.AstNode {
    readonly $container: Literal;
    readonly $type: 'ArrayLiteral';
    vals: Array<Statement>;
}

export const ArrayLiteral = 'ArrayLiteral';

export function isArrayLiteral(item: unknown): item is ArrayLiteral {
    return reflection.isInstance(item, ArrayLiteral);
}

export interface AsyncFnCall extends langium.AstNode {
    readonly $container: Literal;
    readonly $type: 'AsyncFnCall';
    fnCall: FnCall;
}

export const AsyncFnCall = 'AsyncFnCall';

export function isAsyncFnCall(item: unknown): item is AsyncFnCall {
    return reflection.isInstance(item, AsyncFnCall);
}

export interface AttributeDefinition extends langium.AstNode {
    readonly $container: RecordSchemaDefinition;
    readonly $type: 'AttributeDefinition';
    arrayType?: QualifiedName;
    enumSpec?: EnumSpec;
    expr?: Expr;
    name: string;
    oneOfSpec?: OneOfSpec;
    properties: Array<PropertyDefinition>;
    refSpec?: RefSpec;
    type?: QualifiedName;
}

export const AttributeDefinition = 'AttributeDefinition';

export function isAttributeDefinition(item: unknown): item is AttributeDefinition {
    return reflection.isInstance(item, AttributeDefinition);
}

export interface BackoffSpec extends langium.AstNode {
    readonly $container: RetryDefinition;
    readonly $type: 'BackoffSpec';
    attributes: Array<SetAttribute>;
}

export const BackoffSpec = 'BackoffSpec';

export function isBackoffSpec(item: unknown): item is BackoffSpec {
    return reflection.isInstance(item, BackoffSpec);
}

export interface BeforeTriggerDefinition extends langium.AstNode {
    readonly $container: PrePostTriggerDefinition;
    readonly $type: 'BeforeTriggerDefinition';
    triggers: TriggerDefinition;
}

export const BeforeTriggerDefinition = 'BeforeTriggerDefinition';

export function isBeforeTriggerDefinition(item: unknown): item is BeforeTriggerDefinition {
    return reflection.isInstance(item, BeforeTriggerDefinition);
}

export interface BinExpr extends langium.AstNode {
    readonly $container: AttributeDefinition | BinExpr | CaseEntry | FnCall | Group | If | MapEntry | NegExpr | NotExpr | Pattern | SetAttribute;
    readonly $type: 'BinExpr';
    e1: Expr | PrimExpr;
    e2: Expr | PrimExpr;
    op: '!=' | '*' | '+' | '-' | '/' | '<' | '<=' | '<>' | '==' | '>' | '>=' | 'and' | 'in' | 'like' | 'or';
}

export const BinExpr = 'BinExpr';

export function isBinExpr(item: unknown): item is BinExpr {
    return reflection.isInstance(item, BinExpr);
}

export interface CaseEntry extends langium.AstNode {
    readonly $container: DecisionDefBody;
    readonly $type: 'CaseEntry';
    cond: Expr;
    statements: Array<Statement>;
}

export const CaseEntry = 'CaseEntry';

export function isCaseEntry(item: unknown): item is CaseEntry {
    return reflection.isInstance(item, CaseEntry);
}

export interface CatchSpec extends langium.AstNode {
    readonly $container: RuntimeHint;
    readonly $type: 'CatchSpec';
    handlers: Array<Handler>;
}

export const CatchSpec = 'CatchSpec';

export function isCatchSpec(item: unknown): item is CatchSpec {
    return reflection.isInstance(item, CatchSpec);
}

export interface CompositeUniqueDefinition extends langium.AstNode {
    readonly $container: RecordExtraDefinition;
    readonly $type: 'CompositeUniqueDefinition';
    attrs: Array<string>;
}

export const CompositeUniqueDefinition = 'CompositeUniqueDefinition';

export function isCompositeUniqueDefinition(item: unknown): item is CompositeUniqueDefinition {
    return reflection.isInstance(item, CompositeUniqueDefinition);
}

export interface ConditionalFlowStep extends langium.AstNode {
    readonly $container: FlowEntry;
    readonly $type: 'ConditionalFlowStep';
    expr: string;
    next: FlowStepSpec;
}

export const ConditionalFlowStep = 'ConditionalFlowStep';

export function isConditionalFlowStep(item: unknown): item is ConditionalFlowStep {
    return reflection.isInstance(item, ConditionalFlowStep);
}

export interface CrudMap extends langium.AstNode {
    readonly $container: ConditionalFlowStep | FlowEntry | Pattern;
    readonly $type: 'CrudMap';
    body?: CrudMapBody;
    distinct: Array<'@distinct'>;
    into?: SelectIntoSpec;
    join?: JoinSpec;
    name: QualifiedName | QueryId;
    relationships: Array<RelationshipPattern>;
    source?: Literal;
    upsert: Array<'@upsert'>;
}

export const CrudMap = 'CrudMap';

export function isCrudMap(item: unknown): item is CrudMap {
    return reflection.isInstance(item, CrudMap);
}

export interface CrudMapBody extends langium.AstNode {
    readonly $container: CrudMap;
    readonly $type: 'CrudMapBody';
    attributes: Array<SetAttribute>;
    properties: Array<PropertyDefinition>;
}

export const CrudMapBody = 'CrudMapBody';

export function isCrudMapBody(item: unknown): item is CrudMapBody {
    return reflection.isInstance(item, CrudMapBody);
}

export interface DecisionDefBody extends langium.AstNode {
    readonly $container: DecisionDefinition;
    readonly $type: 'DecisionDefBody';
    cases: Array<CaseEntry>;
}

export const DecisionDefBody = 'DecisionDefBody';

export function isDecisionDefBody(item: unknown): item is DecisionDefBody {
    return reflection.isInstance(item, DecisionDefBody);
}

export interface DecisionDefinition extends langium.AstNode {
    readonly $container: ModuleDefinition;
    readonly $type: 'DecisionDefinition';
    body?: DecisionDefBody;
    name: GenericName;
}

export const DecisionDefinition = 'DecisionDefinition';

export function isDecisionDefinition(item: unknown): item is DecisionDefinition {
    return reflection.isInstance(item, DecisionDefinition);
}

export interface Delete extends langium.AstNode {
    readonly $container: Pattern;
    readonly $type: 'Delete';
    pattern: Pattern;
}

export const Delete = 'Delete';

export function isDelete(item: unknown): item is Delete {
    return reflection.isInstance(item, Delete);
}

export interface DirectiveDefinition extends langium.AstNode {
    readonly $container: ModuleDefinition;
    readonly $type: 'DirectiveDefinition';
    body?: MapLiteral;
    dir?: If;
    name: Ref;
}

export const DirectiveDefinition = 'DirectiveDefinition';

export function isDirectiveDefinition(item: unknown): item is DirectiveDefinition {
    return reflection.isInstance(item, DirectiveDefinition);
}

export interface Else extends langium.AstNode {
    readonly $container: If;
    readonly $type: 'Else';
    statements: Array<Statement>;
}

export const Else = 'Else';

export function isElse(item: unknown): item is Else {
    return reflection.isInstance(item, Else);
}

export interface EntityActionsDefinitions extends langium.AstNode {
    readonly $container: RecordExtraDefinition;
    readonly $type: 'EntityActionsDefinitions';
    entries: Array<ActionEntry>;
}

export const EntityActionsDefinitions = 'EntityActionsDefinitions';

export function isEntityActionsDefinitions(item: unknown): item is EntityActionsDefinitions {
    return reflection.isInstance(item, EntityActionsDefinitions);
}

export interface EntityDefinition extends langium.AstNode {
    readonly $container: ModuleDefinition;
    readonly $type: 'EntityDefinition';
    extends?: ExtendsClause;
    name: QualifiedName;
    schema: RecordSchemaDefinition;
}

export const EntityDefinition = 'EntityDefinition';

export function isEntityDefinition(item: unknown): item is EntityDefinition {
    return reflection.isInstance(item, EntityDefinition);
}

export interface EnumSpec extends langium.AstNode {
    readonly $container: AttributeDefinition;
    readonly $type: 'EnumSpec';
    type?: QualifiedName;
    values: Array<string>;
}

export const EnumSpec = 'EnumSpec';

export function isEnumSpec(item: unknown): item is EnumSpec {
    return reflection.isInstance(item, EnumSpec);
}

export interface EventDefinition extends langium.AstNode {
    readonly $container: ModuleDefinition | PublicEventDefinition;
    readonly $type: 'EventDefinition';
    extends?: ExtendsClause;
    name: QualifiedName;
    schema: RecordSchemaDefinition;
}

export const EventDefinition = 'EventDefinition';

export function isEventDefinition(item: unknown): item is EventDefinition {
    return reflection.isInstance(item, EventDefinition);
}

export interface ExtendsClause extends langium.AstNode {
    readonly $container: EntityDefinition | EventDefinition | RecordDefinition;
    readonly $type: 'ExtendsClause';
    parentName: QualifiedName;
}

export const ExtendsClause = 'ExtendsClause';

export function isExtendsClause(item: unknown): item is ExtendsClause {
    return reflection.isInstance(item, ExtendsClause);
}

export interface FlowDefBody extends langium.AstNode {
    readonly $container: FlowDefinition;
    readonly $type: 'FlowDefBody';
    entries: Array<FlowEntry>;
}

export const FlowDefBody = 'FlowDefBody';

export function isFlowDefBody(item: unknown): item is FlowDefBody {
    return reflection.isInstance(item, FlowDefBody);
}

export interface FlowDefinition extends langium.AstNode {
    readonly $container: ModuleDefinition;
    readonly $type: 'FlowDefinition';
    body?: FlowDefBody;
    name: GenericName;
}

export const FlowDefinition = 'FlowDefinition';

export function isFlowDefinition(item: unknown): item is FlowDefinition {
    return reflection.isInstance(item, FlowDefinition);
}

export interface FlowEntry extends langium.AstNode {
    readonly $container: FlowDefBody;
    readonly $type: 'FlowEntry';
    cond?: ConditionalFlowStep;
    next?: FlowStepSpec;
    root: GenericName;
}

export const FlowEntry = 'FlowEntry';

export function isFlowEntry(item: unknown): item is FlowEntry {
    return reflection.isInstance(item, FlowEntry);
}

export interface FnCall extends langium.AstNode {
    readonly $container: AsyncFnCall | Literal;
    readonly $type: 'FnCall';
    args: Array<Expr>;
    name: Ref | string;
}

export const FnCall = 'FnCall';

export function isFnCall(item: unknown): item is FnCall {
    return reflection.isInstance(item, FnCall);
}

export interface ForEach extends langium.AstNode {
    readonly $container: Pattern;
    readonly $type: 'ForEach';
    src: Pattern;
    statements: Array<Statement>;
    var: string;
}

export const ForEach = 'ForEach';

export function isForEach(item: unknown): item is ForEach {
    return reflection.isInstance(item, ForEach);
}

export interface FullTextSearch extends langium.AstNode {
    readonly $container: Pattern;
    readonly $type: 'FullTextSearch';
    name: QueryId;
    options?: MapLiteral;
    query: Literal;
}

export const FullTextSearch = 'FullTextSearch';

export function isFullTextSearch(item: unknown): item is FullTextSearch {
    return reflection.isInstance(item, FullTextSearch);
}

export interface GenericDefBody extends langium.AstNode {
    readonly $container: AgentDefinition;
    readonly $type: 'GenericDefBody';
    attributes: Array<GenericPropertyDef>;
}

export const GenericDefBody = 'GenericDefBody';

export function isGenericDefBody(item: unknown): item is GenericDefBody {
    return reflection.isInstance(item, GenericDefBody);
}

export interface GenericPropertyDef extends langium.AstNode {
    readonly $container: GenericDefBody;
    readonly $type: 'GenericPropertyDef';
    name: string;
    value: Literal;
}

export const GenericPropertyDef = 'GenericPropertyDef';

export function isGenericPropertyDef(item: unknown): item is GenericPropertyDef {
    return reflection.isInstance(item, GenericPropertyDef);
}

export interface GlossaryEntryDefinition extends langium.AstNode {
    readonly $container: ModuleDefinition;
    readonly $type: 'GlossaryEntryDefinition';
    body?: MapLiteral;
    glos?: AgentXtraSpec;
    name: Ref;
}

export const GlossaryEntryDefinition = 'GlossaryEntryDefinition';

export function isGlossaryEntryDefinition(item: unknown): item is GlossaryEntryDefinition {
    return reflection.isInstance(item, GlossaryEntryDefinition);
}

export interface Group extends langium.AstNode {
    readonly $container: AttributeDefinition | BinExpr | CaseEntry | FnCall | Group | If | MapEntry | NegExpr | NotExpr | Pattern | SetAttribute;
    readonly $type: 'Group';
    ge: Expr;
}

export const Group = 'Group';

export function isGroup(item: unknown): item is Group {
    return reflection.isInstance(item, Group);
}

export interface Handler extends langium.AstNode {
    readonly $container: CatchSpec;
    readonly $type: 'Handler';
    except: 'error' | 'not_found';
    stmt: Statement;
}

export const Handler = 'Handler';

export function isHandler(item: unknown): item is Handler {
    return reflection.isInstance(item, Handler);
}

export interface If extends langium.AstNode {
    readonly $container: DirectiveDefinition | Pattern | ScenarioDefinition;
    readonly $type: 'If';
    cond: Expr;
    else?: Else;
    statements: Array<Statement>;
}

export const If = 'If';

export function isIf(item: unknown): item is If {
    return reflection.isInstance(item, If);
}

export interface Import extends langium.AstNode {
    readonly $container: ModuleDefinition;
    readonly $type: 'Import';
    name: string;
    path: string;
}

export const Import = 'Import';

export function isImport(item: unknown): item is Import {
    return reflection.isInstance(item, Import);
}

export interface JoinSpec extends langium.AstNode {
    readonly $container: CrudMap;
    readonly $type: 'JoinSpec';
    lhs: QueryId;
    name: QualifiedName;
    op?: SqlComparisonOpr;
    rhs: Ref;
    type: JoinType;
}

export const JoinSpec = 'JoinSpec';

export function isJoinSpec(item: unknown): item is JoinSpec {
    return reflection.isInstance(item, JoinSpec);
}

export interface KvPair extends langium.AstNode {
    readonly $container: KvPairs;
    readonly $type: 'KvPair';
    key?: string;
    value: Literal;
}

export const KvPair = 'KvPair';

export function isKvPair(item: unknown): item is KvPair {
    return reflection.isInstance(item, KvPair);
}

export interface KvPairs extends langium.AstNode {
    readonly $container: PropertyDefinition;
    readonly $type: 'KvPairs';
    pairs: Array<KvPair>;
}

export const KvPairs = 'KvPairs';

export function isKvPairs(item: unknown): item is KvPairs {
    return reflection.isInstance(item, KvPairs);
}

export interface Literal extends langium.AstNode {
    readonly $container: AttributeDefinition | BinExpr | CaseEntry | CrudMap | FnCall | FullTextSearch | GenericPropertyDef | Group | If | KvPair | MapEntry | NegExpr | NotExpr | Pattern | SetAttribute;
    readonly $type: 'Literal';
    array?: ArrayLiteral;
    asyncFnCall?: AsyncFnCall;
    bool?: Boolean;
    fnCall?: FnCall;
    id?: string;
    map?: MapLiteral;
    num?: Decimal;
    ref?: Ref;
    str?: string;
}

export const Literal = 'Literal';

export function isLiteral(item: unknown): item is Literal {
    return reflection.isInstance(item, Literal);
}

export interface MapEntry extends langium.AstNode {
    readonly $container: MapLiteral;
    readonly $type: 'MapEntry';
    key: MapKey;
    value: Expr;
}

export const MapEntry = 'MapEntry';

export function isMapEntry(item: unknown): item is MapEntry {
    return reflection.isInstance(item, MapEntry);
}

export interface MapKey extends langium.AstNode {
    readonly $container: MapEntry;
    readonly $type: 'MapKey';
    bool?: Boolean;
    num?: Decimal;
    str?: string;
}

export const MapKey = 'MapKey';

export function isMapKey(item: unknown): item is MapKey {
    return reflection.isInstance(item, MapKey);
}

export interface MapLiteral extends langium.AstNode {
    readonly $container: DirectiveDefinition | FullTextSearch | GlossaryEntryDefinition | Literal | MetaDefinition | ScenarioDefinition;
    readonly $type: 'MapLiteral';
    entries: Array<MapEntry>;
}

export const MapLiteral = 'MapLiteral';

export function isMapLiteral(item: unknown): item is MapLiteral {
    return reflection.isInstance(item, MapLiteral);
}

export interface MetaDefinition extends langium.AstNode {
    readonly $container: RecordExtraDefinition;
    readonly $type: 'MetaDefinition';
    spec: MapLiteral;
}

export const MetaDefinition = 'MetaDefinition';

export function isMetaDefinition(item: unknown): item is MetaDefinition {
    return reflection.isInstance(item, MetaDefinition);
}

export interface ModuleDefinition extends langium.AstNode {
    readonly $type: 'ModuleDefinition';
    defs: Array<Definition>;
    imports: Array<Import>;
    name: QualifiedName;
}

export const ModuleDefinition = 'ModuleDefinition';

export function isModuleDefinition(item: unknown): item is ModuleDefinition {
    return reflection.isInstance(item, ModuleDefinition);
}

export interface NegExpr extends langium.AstNode {
    readonly $container: AttributeDefinition | BinExpr | CaseEntry | FnCall | Group | If | MapEntry | NegExpr | NotExpr | Pattern | SetAttribute;
    readonly $type: 'NegExpr';
    ne: Expr;
}

export const NegExpr = 'NegExpr';

export function isNegExpr(item: unknown): item is NegExpr {
    return reflection.isInstance(item, NegExpr);
}

export interface NodeDefinition extends langium.AstNode {
    readonly $container: RelNodes;
    readonly $type: 'NodeDefinition';
    alias?: string;
    name: QualifiedName;
}

export const NodeDefinition = 'NodeDefinition';

export function isNodeDefinition(item: unknown): item is NodeDefinition {
    return reflection.isInstance(item, NodeDefinition);
}

export interface NotExpr extends langium.AstNode {
    readonly $container: AttributeDefinition | BinExpr | CaseEntry | FnCall | Group | If | MapEntry | NegExpr | NotExpr | Pattern | SetAttribute;
    readonly $type: 'NotExpr';
    ne: Expr;
}

export const NotExpr = 'NotExpr';

export function isNotExpr(item: unknown): item is NotExpr {
    return reflection.isInstance(item, NotExpr);
}

export interface OneOfSpec extends langium.AstNode {
    readonly $container: AttributeDefinition;
    readonly $type: 'OneOfSpec';
    ref: Ref;
}

export const OneOfSpec = 'OneOfSpec';

export function isOneOfSpec(item: unknown): item is OneOfSpec {
    return reflection.isInstance(item, OneOfSpec);
}

export interface Pattern extends langium.AstNode {
    readonly $container: Delete | ForEach | Purge | RelationshipPattern | Return | Statement;
    readonly $type: 'Pattern';
    crudMap?: CrudMap;
    delete?: Delete;
    expr?: Expr;
    forEach?: ForEach;
    fullTextSearch?: FullTextSearch;
    if?: If;
    purge?: Purge;
    return?: Return;
}

export const Pattern = 'Pattern';

export function isPattern(item: unknown): item is Pattern {
    return reflection.isInstance(item, Pattern);
}

export interface PrePostTriggerDefinition extends langium.AstNode {
    readonly $container: RecordExtraDefinition;
    readonly $type: 'PrePostTriggerDefinition';
    after?: AfterTriggerDefinition;
    before?: BeforeTriggerDefinition;
}

export const PrePostTriggerDefinition = 'PrePostTriggerDefinition';

export function isPrePostTriggerDefinition(item: unknown): item is PrePostTriggerDefinition {
    return reflection.isInstance(item, PrePostTriggerDefinition);
}

export interface PropertyDefinition extends langium.AstNode {
    readonly $container: AttributeDefinition | CrudMapBody | RelationshipDefinition;
    readonly $type: 'PropertyDefinition';
    name: TaggedId;
    value?: KvPairs;
}

export const PropertyDefinition = 'PropertyDefinition';

export function isPropertyDefinition(item: unknown): item is PropertyDefinition {
    return reflection.isInstance(item, PropertyDefinition);
}

export interface PublicAgentDefinition extends langium.AstNode {
    readonly $container: ModuleDefinition;
    readonly $type: 'PublicAgentDefinition';
    def: AgentDefinition;
}

export const PublicAgentDefinition = 'PublicAgentDefinition';

export function isPublicAgentDefinition(item: unknown): item is PublicAgentDefinition {
    return reflection.isInstance(item, PublicAgentDefinition);
}

export interface PublicEventDefinition extends langium.AstNode {
    readonly $container: ModuleDefinition;
    readonly $type: 'PublicEventDefinition';
    def: EventDefinition;
}

export const PublicEventDefinition = 'PublicEventDefinition';

export function isPublicEventDefinition(item: unknown): item is PublicEventDefinition {
    return reflection.isInstance(item, PublicEventDefinition);
}

export interface PublicWorkflowDefinition extends langium.AstNode {
    readonly $container: ModuleDefinition;
    readonly $type: 'PublicWorkflowDefinition';
    def: WorkflowDefinition;
}

export const PublicWorkflowDefinition = 'PublicWorkflowDefinition';

export function isPublicWorkflowDefinition(item: unknown): item is PublicWorkflowDefinition {
    return reflection.isInstance(item, PublicWorkflowDefinition);
}

export interface Purge extends langium.AstNode {
    readonly $container: Pattern;
    readonly $type: 'Purge';
    pattern: Pattern;
}

export const Purge = 'Purge';

export function isPurge(item: unknown): item is Purge {
    return reflection.isInstance(item, Purge);
}

export interface RbacAllowSpec extends langium.AstNode {
    readonly $container: RbacSpecEntry;
    readonly $type: 'RbacAllowSpec';
    oprs: Array<RbacOpr>;
}

export const RbacAllowSpec = 'RbacAllowSpec';

export function isRbacAllowSpec(item: unknown): item is RbacAllowSpec {
    return reflection.isInstance(item, RbacAllowSpec);
}

export interface RbacExpressionSpec extends langium.AstNode {
    readonly $container: RbacSpecEntry;
    readonly $type: 'RbacExpressionSpec';
    lhs: Ref;
    rhs: Ref;
}

export const RbacExpressionSpec = 'RbacExpressionSpec';

export function isRbacExpressionSpec(item: unknown): item is RbacExpressionSpec {
    return reflection.isInstance(item, RbacExpressionSpec);
}

export interface RbacOpr extends langium.AstNode {
    readonly $container: RbacAllowSpec;
    readonly $type: 'RbacOpr';
    value: 'create' | 'delete' | 'read' | 'update';
}

export const RbacOpr = 'RbacOpr';

export function isRbacOpr(item: unknown): item is RbacOpr {
    return reflection.isInstance(item, RbacOpr);
}

export interface RbacRolesSpec extends langium.AstNode {
    readonly $container: RbacSpecEntry;
    readonly $type: 'RbacRolesSpec';
    roles: Array<'*' | string>;
}

export const RbacRolesSpec = 'RbacRolesSpec';

export function isRbacRolesSpec(item: unknown): item is RbacRolesSpec {
    return reflection.isInstance(item, RbacRolesSpec);
}

export interface RbacSpecDefinition extends langium.AstNode {
    readonly $container: RecordExtraDefinition;
    readonly $type: 'RbacSpecDefinition';
    specEntries: Array<RbacSpecEntries>;
}

export const RbacSpecDefinition = 'RbacSpecDefinition';

export function isRbacSpecDefinition(item: unknown): item is RbacSpecDefinition {
    return reflection.isInstance(item, RbacSpecDefinition);
}

export interface RbacSpecEntries extends langium.AstNode {
    readonly $container: RbacSpecDefinition;
    readonly $type: 'RbacSpecEntries';
    entries: Array<RbacSpecEntry>;
}

export const RbacSpecEntries = 'RbacSpecEntries';

export function isRbacSpecEntries(item: unknown): item is RbacSpecEntries {
    return reflection.isInstance(item, RbacSpecEntries);
}

export interface RbacSpecEntry extends langium.AstNode {
    readonly $container: RbacSpecEntries;
    readonly $type: 'RbacSpecEntry';
    allow?: RbacAllowSpec;
    expr?: RbacExpressionSpec;
    role?: RbacRolesSpec;
}

export const RbacSpecEntry = 'RbacSpecEntry';

export function isRbacSpecEntry(item: unknown): item is RbacSpecEntry {
    return reflection.isInstance(item, RbacSpecEntry);
}

export interface RecordDefinition extends langium.AstNode {
    readonly $container: ModuleDefinition;
    readonly $type: 'RecordDefinition';
    extends?: ExtendsClause;
    name: QualifiedName;
    schema: RecordSchemaDefinition;
}

export const RecordDefinition = 'RecordDefinition';

export function isRecordDefinition(item: unknown): item is RecordDefinition {
    return reflection.isInstance(item, RecordDefinition);
}

export interface RecordExtraDefinition extends langium.AstNode {
    readonly $container: RecordSchemaDefinition;
    readonly $type: 'RecordExtraDefinition';
    actions?: EntityActionsDefinitions;
    meta?: MetaDefinition;
    prePost?: PrePostTriggerDefinition;
    rbacSpec?: RbacSpecDefinition;
    uq?: CompositeUniqueDefinition;
}

export const RecordExtraDefinition = 'RecordExtraDefinition';

export function isRecordExtraDefinition(item: unknown): item is RecordExtraDefinition {
    return reflection.isInstance(item, RecordExtraDefinition);
}

export interface RecordSchemaDefinition extends langium.AstNode {
    readonly $container: EntityDefinition | EventDefinition | RecordDefinition | RelationshipDefinition;
    readonly $type: 'RecordSchemaDefinition';
    attributes: Array<AttributeDefinition>;
    extras: Array<RecordExtraDefinition>;
}

export const RecordSchemaDefinition = 'RecordSchemaDefinition';

export function isRecordSchemaDefinition(item: unknown): item is RecordSchemaDefinition {
    return reflection.isInstance(item, RecordSchemaDefinition);
}

export interface RefSpec extends langium.AstNode {
    readonly $container: AttributeDefinition;
    readonly $type: 'RefSpec';
    ref: QualifiedName;
    type?: QualifiedName;
}

export const RefSpec = 'RefSpec';

export function isRefSpec(item: unknown): item is RefSpec {
    return reflection.isInstance(item, RefSpec);
}

export interface RelationshipDefinition extends langium.AstNode {
    readonly $container: ModuleDefinition;
    readonly $type: 'RelationshipDefinition';
    name: QualifiedName;
    nodes: RelNodes;
    properties: Array<PropertyDefinition>;
    schema?: RecordSchemaDefinition;
    type: 'between' | 'contains';
}

export const RelationshipDefinition = 'RelationshipDefinition';

export function isRelationshipDefinition(item: unknown): item is RelationshipDefinition {
    return reflection.isInstance(item, RelationshipDefinition);
}

export interface RelationshipPattern extends langium.AstNode {
    readonly $container: CrudMap;
    readonly $type: 'RelationshipPattern';
    name: QualifiedName;
    pattern: Pattern;
}

export const RelationshipPattern = 'RelationshipPattern';

export function isRelationshipPattern(item: unknown): item is RelationshipPattern {
    return reflection.isInstance(item, RelationshipPattern);
}

export interface RelNodes extends langium.AstNode {
    readonly $container: RelationshipDefinition;
    readonly $type: 'RelNodes';
    node1: NodeDefinition;
    node2: NodeDefinition;
}

export const RelNodes = 'RelNodes';

export function isRelNodes(item: unknown): item is RelNodes {
    return reflection.isInstance(item, RelNodes);
}

export interface ResolverDefinition extends langium.AstNode {
    readonly $container: ModuleDefinition;
    readonly $type: 'ResolverDefinition';
    methods: Array<ResolverMethodSpec>;
    name: GenericName;
    paths: Array<GenericName>;
}

export const ResolverDefinition = 'ResolverDefinition';

export function isResolverDefinition(item: unknown): item is ResolverDefinition {
    return reflection.isInstance(item, ResolverDefinition);
}

export interface ResolverFnName extends langium.AstNode {
    readonly $container: ResolverMethodSpec;
    readonly $type: 'ResolverFnName';
    name: Ref | string;
}

export const ResolverFnName = 'ResolverFnName';

export function isResolverFnName(item: unknown): item is ResolverFnName {
    return reflection.isInstance(item, ResolverFnName);
}

export interface ResolverMethodName extends langium.AstNode {
    readonly $container: ResolverMethodSpec;
    readonly $type: 'ResolverMethodName';
    name: 'commitTransaction' | 'create' | 'delete' | 'onSubscription' | 'query' | 'rollbackTransaction' | 'startTransaction' | 'subscribe' | 'update' | 'upsert';
}

export const ResolverMethodName = 'ResolverMethodName';

export function isResolverMethodName(item: unknown): item is ResolverMethodName {
    return reflection.isInstance(item, ResolverMethodName);
}

export interface ResolverMethodSpec extends langium.AstNode {
    readonly $container: ResolverDefinition;
    readonly $type: 'ResolverMethodSpec';
    fn: ResolverFnName;
    key: ResolverMethodName;
}

export const ResolverMethodSpec = 'ResolverMethodSpec';

export function isResolverMethodSpec(item: unknown): item is ResolverMethodSpec {
    return reflection.isInstance(item, ResolverMethodSpec);
}

export interface RetryDefinition extends langium.AstNode {
    readonly $container: ModuleDefinition;
    readonly $type: 'RetryDefinition';
    attempts?: Decimal;
    backoff?: BackoffSpec;
    name: string;
}

export const RetryDefinition = 'RetryDefinition';

export function isRetryDefinition(item: unknown): item is RetryDefinition {
    return reflection.isInstance(item, RetryDefinition);
}

export interface Return extends langium.AstNode {
    readonly $container: Pattern;
    readonly $type: 'Return';
    pattern: Pattern;
}

export const Return = 'Return';

export function isReturn(item: unknown): item is Return {
    return reflection.isInstance(item, Return);
}

export interface RuntimeHint extends langium.AstNode {
    readonly $container: Statement;
    readonly $type: 'RuntimeHint';
    aliasSpec?: AliasSpec;
    catchSpec?: CatchSpec;
    thenSpec?: ThenSpec;
}

export const RuntimeHint = 'RuntimeHint';

export function isRuntimeHint(item: unknown): item is RuntimeHint {
    return reflection.isInstance(item, RuntimeHint);
}

export interface ScenarioDefinition extends langium.AstNode {
    readonly $container: ModuleDefinition;
    readonly $type: 'ScenarioDefinition';
    body?: MapLiteral;
    name: Ref;
    scn?: If;
}

export const ScenarioDefinition = 'ScenarioDefinition';

export function isScenarioDefinition(item: unknown): item is ScenarioDefinition {
    return reflection.isInstance(item, ScenarioDefinition);
}

export interface SelectIntoEntry extends langium.AstNode {
    readonly $container: SelectIntoSpec;
    readonly $type: 'SelectIntoEntry';
    alias: string;
    attribute: Ref;
}

export const SelectIntoEntry = 'SelectIntoEntry';

export function isSelectIntoEntry(item: unknown): item is SelectIntoEntry {
    return reflection.isInstance(item, SelectIntoEntry);
}

export interface SelectIntoSpec extends langium.AstNode {
    readonly $container: CrudMap;
    readonly $type: 'SelectIntoSpec';
    entries: Array<SelectIntoEntry>;
}

export const SelectIntoSpec = 'SelectIntoSpec';

export function isSelectIntoSpec(item: unknown): item is SelectIntoSpec {
    return reflection.isInstance(item, SelectIntoSpec);
}

export interface SetAttribute extends langium.AstNode {
    readonly $container: BackoffSpec | CrudMapBody;
    readonly $type: 'SetAttribute';
    name: QueryId;
    op?: SqlComparisonOpr;
    value: AttributeValueExpression;
}

export const SetAttribute = 'SetAttribute';

export function isSetAttribute(item: unknown): item is SetAttribute {
    return reflection.isInstance(item, SetAttribute);
}

export interface StandaloneStatement extends langium.AstNode {
    readonly $container: ModuleDefinition;
    readonly $type: 'StandaloneStatement';
    stmt: Statement;
}

export const StandaloneStatement = 'StandaloneStatement';

export function isStandaloneStatement(item: unknown): item is StandaloneStatement {
    return reflection.isInstance(item, StandaloneStatement);
}

export interface Statement extends langium.AstNode {
    readonly $container: ArrayLiteral | CaseEntry | Else | ForEach | Handler | If | StandaloneStatement | ThenSpec | WorkflowDefinition;
    readonly $type: 'Statement';
    hints: Array<RuntimeHint>;
    pattern: Pattern;
}

export const Statement = 'Statement';

export function isStatement(item: unknown): item is Statement {
    return reflection.isInstance(item, Statement);
}

export interface ThenSpec extends langium.AstNode {
    readonly $container: RuntimeHint;
    readonly $type: 'ThenSpec';
    statements: Array<Statement>;
}

export const ThenSpec = 'ThenSpec';

export function isThenSpec(item: unknown): item is ThenSpec {
    return reflection.isInstance(item, ThenSpec);
}

export interface TriggerDefinition extends langium.AstNode {
    readonly $container: AfterTriggerDefinition | BeforeTriggerDefinition;
    readonly $type: 'TriggerDefinition';
    entries: Array<TriggerEntry>;
}

export const TriggerDefinition = 'TriggerDefinition';

export function isTriggerDefinition(item: unknown): item is TriggerDefinition {
    return reflection.isInstance(item, TriggerDefinition);
}

export interface TriggerEntry extends langium.AstNode {
    readonly $container: TriggerDefinition;
    readonly $type: 'TriggerEntry';
    async?: '@async';
    event: string;
    on: 'create' | 'delete' | 'update';
}

export const TriggerEntry = 'TriggerEntry';

export function isTriggerEntry(item: unknown): item is TriggerEntry {
    return reflection.isInstance(item, TriggerEntry);
}

export interface WorkflowDefinition extends langium.AstNode {
    readonly $container: ModuleDefinition | PublicWorkflowDefinition;
    readonly $type: 'WorkflowDefinition';
    header?: WorkflowHeader;
    name?: string;
    statements: Array<Statement>;
}

export const WorkflowDefinition = 'WorkflowDefinition';

export function isWorkflowDefinition(item: unknown): item is WorkflowDefinition {
    return reflection.isInstance(item, WorkflowDefinition);
}

export interface WorkflowHeader extends langium.AstNode {
    readonly $container: WorkflowDefinition;
    readonly $type: 'WorkflowHeader';
    name: QualifiedName;
    prefix: WorkflowHeaderPrefix;
    tag: WorkflowHeaderTag;
}

export const WorkflowHeader = 'WorkflowHeader';

export function isWorkflowHeader(item: unknown): item is WorkflowHeader {
    return reflection.isInstance(item, WorkflowHeader);
}

export type AgentlangAstType = {
    ActionEntry: ActionEntry
    AfterTriggerDefinition: AfterTriggerDefinition
    AgentDefinition: AgentDefinition
    AgentXtraAttribute: AgentXtraAttribute
    AgentXtraSpec: AgentXtraSpec
    AliasSpec: AliasSpec
    ArrayLiteral: ArrayLiteral
    AsyncFnCall: AsyncFnCall
    AttributeDefinition: AttributeDefinition
    AttributeValueExpression: AttributeValueExpression
    BackoffSpec: BackoffSpec
    BeforeTriggerDefinition: BeforeTriggerDefinition
    BinExpr: BinExpr
    CaseEntry: CaseEntry
    CatchSpec: CatchSpec
    CompositeUniqueDefinition: CompositeUniqueDefinition
    ConditionalFlowStep: ConditionalFlowStep
    CrudMap: CrudMap
    CrudMapBody: CrudMapBody
    DecisionDefBody: DecisionDefBody
    DecisionDefinition: DecisionDefinition
    Definition: Definition
    Delete: Delete
    DirectiveDefinition: DirectiveDefinition
    Else: Else
    EntityActionsDefinitions: EntityActionsDefinitions
    EntityDefinition: EntityDefinition
    EnumSpec: EnumSpec
    EventDefinition: EventDefinition
    Expr: Expr
    ExtendsClause: ExtendsClause
    FlowDefBody: FlowDefBody
    FlowDefinition: FlowDefinition
    FlowEntry: FlowEntry
    FlowStepSpec: FlowStepSpec
    FnCall: FnCall
    ForEach: ForEach
    FullTextSearch: FullTextSearch
    GenericDefBody: GenericDefBody
    GenericPropertyDef: GenericPropertyDef
    GlossaryEntryDefinition: GlossaryEntryDefinition
    Group: Group
    Handler: Handler
    If: If
    Import: Import
    JoinSpec: JoinSpec
    KvPair: KvPair
    KvPairs: KvPairs
    Literal: Literal
    MapEntry: MapEntry
    MapKey: MapKey
    MapLiteral: MapLiteral
    MetaDefinition: MetaDefinition
    ModuleDefinition: ModuleDefinition
    NegExpr: NegExpr
    NodeDefinition: NodeDefinition
    NotExpr: NotExpr
    OneOfSpec: OneOfSpec
    Pattern: Pattern
    PrePostTriggerDefinition: PrePostTriggerDefinition
    PrimExpr: PrimExpr
    PropertyDefinition: PropertyDefinition
    PublicAgentDefinition: PublicAgentDefinition
    PublicEventDefinition: PublicEventDefinition
    PublicWorkflowDefinition: PublicWorkflowDefinition
    Purge: Purge
    RbacAllowSpec: RbacAllowSpec
    RbacExpressionSpec: RbacExpressionSpec
    RbacOpr: RbacOpr
    RbacRolesSpec: RbacRolesSpec
    RbacSpecDefinition: RbacSpecDefinition
    RbacSpecEntries: RbacSpecEntries
    RbacSpecEntry: RbacSpecEntry
    RecordDefinition: RecordDefinition
    RecordExtraDefinition: RecordExtraDefinition
    RecordSchemaDefinition: RecordSchemaDefinition
    RefSpec: RefSpec
    RelNodes: RelNodes
    RelationshipDefinition: RelationshipDefinition
    RelationshipPattern: RelationshipPattern
    ResolverDefinition: ResolverDefinition
    ResolverFnName: ResolverFnName
    ResolverMethodName: ResolverMethodName
    ResolverMethodSpec: ResolverMethodSpec
    RetryDefinition: RetryDefinition
    Return: Return
    RuntimeHint: RuntimeHint
    ScenarioDefinition: ScenarioDefinition
    SchemaDefinition: SchemaDefinition
    SelectIntoEntry: SelectIntoEntry
    SelectIntoSpec: SelectIntoSpec
    SetAttribute: SetAttribute
    StandaloneStatement: StandaloneStatement
    Statement: Statement
    ThenSpec: ThenSpec
    TriggerDefinition: TriggerDefinition
    TriggerEntry: TriggerEntry
    WorkflowDefinition: WorkflowDefinition
    WorkflowHeader: WorkflowHeader
}

export class AgentlangAstReflection extends langium.AbstractAstReflection {

    getAllTypes(): string[] {
        return [ActionEntry, AfterTriggerDefinition, AgentDefinition, AgentXtraAttribute, AgentXtraSpec, 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, Handler, If, Import, JoinSpec, KvPair, KvPairs, Literal, MapEntry, MapKey, MapLiteral, MetaDefinition, ModuleDefinition, NegExpr, NodeDefinition, NotExpr, OneOfSpec, 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, TriggerDefinition, TriggerEntry, WorkflowDefinition, WorkflowHeader];
    }

    protected override computeIsSubtype(subtype: string, supertype: string): boolean {
        switch (subtype) {
            case AgentDefinition:
            case DecisionDefinition:
            case DirectiveDefinition:
            case FlowDefinition:
            case GlossaryEntryDefinition:
            case PublicAgentDefinition:
            case PublicWorkflowDefinition:
            case RelationshipDefinition:
            case ResolverDefinition:
            case RetryDefinition:
            case ScenarioDefinition:
            case SchemaDefinition:
            case StandaloneStatement:
            case WorkflowDefinition: {
                return this.isSubtype(Definition, supertype);
            }
            case BinExpr:
            case PrimExpr: {
                return this.isSubtype(Expr, supertype);
            }
            case CrudMap: {
                return this.isSubtype(FlowStepSpec, 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);
            }
            default: {
                return false;
            }
        }
    }

    getReferenceType(refInfo: langium.ReferenceInfo): string {
        const referenceId = `${refInfo.container.$type}:${refInfo.property}`;
        switch (referenceId) {
            default: {
                throw new Error(`${referenceId} is not a valid reference id.`);
            }
        }
    }

    getTypeMetaData(type: string): langium.TypeMetaData {
        switch (type) {
            case ActionEntry: {
                return {
                    name: ActionEntry,
                    properties: [
                        { name: 'event' },
                        { name: 'name' }
                    ]
                };
            }
            case AfterTriggerDefinition: {
                return {
                    name: AfterTriggerDefinition,
                    properties: [
                        { name: 'triggers' }
                    ]
                };
            }
            case AgentDefinition: {
                return {
                    name: AgentDefinition,
                    properties: [
                        { name: 'body' },
                        { name: 'name' }
                    ]
                };
            }
            case AgentXtraAttribute: {
                return {