@venn-lang/core 0.1.0

package/src/generated/ast.ts

@@ -0,0 +1,2383 @@
+/******************************************************************************
+ * This file was generated by langium-cli 4.3.0.
+ * DO NOT EDIT MANUALLY!
+ ******************************************************************************/
+
+/* eslint-disable */
+import * as langium from 'langium';
+
+export const VennTerminals = {
+    NL: /([ \t]*(\r?\n|;)[ \t]*)+/,
+    WS: /[ \t]+/,
+    COMMENT: /#[^\n\r]*/,
+    INSTANT: /[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(\.[0-9]+)?Z/,
+    STRING: /"(\\.|[^"\\])*"|'(\\.|[^'\\])*'/,
+    NUMBER: /[0-9]+(_[0-9]+)*(\.[0-9]+(_[0-9]+)*)?(ms|kb|mb|gb|b|s|m|h|%)?/,
+    ID: /[_a-zA-Z]\w*/,
+};
+
+export type VennTerminalNames = keyof typeof VennTerminals;
+
+export type VennKeywordNames =
+    | "!"
+    | "!="
+    | "%"
+    | "&&"
+    | "("
+    | ")"
+    | "*"
+    | "+"
+    | ","
+    | "-"
+    | "->"
+    | "."
+    | "/"
+    | ":"
+    | "<"
+    | "<="
+    | "="
+    | "=="
+    | "=>"
+    | ">"
+    | ">="
+    | "?"
+    | "?."
+    | "??"
+    | "@"
+    | "["
+    | "]"
+    | "afterEach"
+    | "all"
+    | "as"
+    | "beforeEach"
+    | "break"
+    | "capture"
+    | "catch"
+    | "config"
+    | "const"
+    | "continue"
+    | "dataset"
+    | "deco"
+    | "defer"
+    | "else"
+    | "expect"
+    | "factory"
+    | "false"
+    | "finally"
+    | "flow"
+    | "fn"
+    | "forEach"
+    | "fragment"
+    | "from"
+    | "group"
+    | "if"
+    | "import"
+    | "in"
+    | "let"
+    | "matrix"
+    | "module"
+    | "not"
+    | "null"
+    | "on"
+    | "parallel"
+    | "pub"
+    | "race"
+    | "repeat"
+    | "report"
+    | "return"
+    | "run"
+    | "setup"
+    | "soft"
+    | "step"
+    | "teardown"
+    | "true"
+    | "try"
+    | "type"
+    | "use"
+    | "while"
+    | "{"
+    | "|"
+    | "||"
+    | "}"
+    | "~=";
+
+export type VennTokenNames = VennTerminalNames | VennKeywordNames;
+
+export interface ActionCall extends Declaration, Statement {
+    readonly $type: 'ActionCall';
+    args: Array<Expr>;
+    call?: ArgList;
+    called: boolean;
+    opts?: MapLit;
+    target: QualifiedName;
+}
+
+export const ActionCall = {
+    $type: 'ActionCall',
+    annotations: 'annotations',
+    args: 'args',
+    call: 'call',
+    called: 'called',
+    opts: 'opts',
+    target: 'target'
+} as const;
+
+export function isActionCall(item: unknown): item is ActionCall {
+    return reflection.isInstance(item, ActionCall.$type);
+}
+
+export interface Annotation extends langium.AstNode {
+    readonly $container: Declaration | FieldDecl | Param | Statement;
+    readonly $type: 'Annotation';
+    args?: ArgList;
+    name: string;
+}
+
+export const Annotation = {
+    $type: 'Annotation',
+    args: 'args',
+    name: 'name'
+} as const;
+
+export function isAnnotation(item: unknown): item is Annotation {
+    return reflection.isInstance(item, Annotation.$type);
+}
+
+export interface Arg extends langium.AstNode {
+    readonly $container: ArgList;
+    readonly $type: 'Arg';
+    name?: string;
+    value: Expr;
+}
+
+export const Arg = {
+    $type: 'Arg',
+    name: 'name',
+    value: 'value'
+} as const;
+
+export function isArg(item: unknown): item is Arg {
+    return reflection.isInstance(item, Arg.$type);
+}
+
+export interface ArgList extends langium.AstNode {
+    readonly $container: ActionCall | Annotation | Call | RunStmt;
+    readonly $type: 'ArgList';
+    args: Array<Arg>;
+}
+
+export const ArgList = {
+    $type: 'ArgList',
+    args: 'args'
+} as const;
+
+export function isArgList(item: unknown): item is ArgList {
+    return reflection.isInstance(item, ArgList.$type);
+}
+
+export interface Binary extends langium.AstNode {
+    readonly $container: ActionCall | Arg | Binary | Call | CaptureStmt | DatasetDecl | ExpectStmt | FnBody | ForEachStmt | IfStmt | Index | LetStmt | LifecycleDecl | ListLit | MapEntry | MatcherClause | Member | RepeatStmt | ReportDecl | ReturnStmt | Ternary | Unary | WhileStmt;
+    readonly $type: 'Binary';
+    left: Expr;
+    operator: '!=' | '%' | '&&' | '*' | '+' | '-' | '/' | '<' | '<=' | '==' | '>' | '>=' | '??' | 'in' | '||' | '~=';
+    right: Expr;
+}
+
+export const Binary = {
+    $type: 'Binary',
+    left: 'left',
+    operator: 'operator',
+    right: 'right'
+} as const;
+
+export function isBinary(item: unknown): item is Binary {
+    return reflection.isInstance(item, Binary.$type);
+}
+
+export interface Block extends langium.AstNode {
+    readonly $container: DecoDecl | FlowDecl | ForEachStmt | FragmentDecl | GroupDecl | IfStmt | LifecycleDecl | ParallelStmt | RaceStmt | RepeatStmt | StepDecl | TryStmt | WhileStmt;
+    readonly $type: 'Block';
+    stmts: Array<Statement>;
+}
+
+export const Block = {
+    $type: 'Block',
+    stmts: 'stmts'
+} as const;
+
+export function isBlock(item: unknown): item is Block {
+    return reflection.isInstance(item, Block.$type);
+}
+
+export interface BoolLit extends langium.AstNode {
+    readonly $container: ActionCall | Arg | Binary | Call | CaptureStmt | DatasetDecl | ExpectStmt | FnBody | ForEachStmt | IfStmt | Index | LetStmt | LifecycleDecl | ListLit | MapEntry | MatcherClause | Member | RepeatStmt | ReportDecl | ReturnStmt | Ternary | Unary | WhileStmt;
+    readonly $type: 'BoolLit';
+    value: 'false' | 'true';
+}
+
+export const BoolLit = {
+    $type: 'BoolLit',
+    value: 'value'
+} as const;
+
+export function isBoolLit(item: unknown): item is BoolLit {
+    return reflection.isInstance(item, BoolLit.$type);
+}
+
+export interface BreakStmt extends Statement {
+    readonly $type: 'BreakStmt';
+}
+
+export const BreakStmt = {
+    $type: 'BreakStmt',
+    annotations: 'annotations'
+} as const;
+
+export function isBreakStmt(item: unknown): item is BreakStmt {
+    return reflection.isInstance(item, BreakStmt.$type);
+}
+
+export interface Call extends langium.AstNode {
+    readonly $container: ActionCall | Arg | Binary | Call | CaptureStmt | DatasetDecl | ExpectStmt | FnBody | ForEachStmt | IfStmt | Index | LetStmt | LifecycleDecl | ListLit | MapEntry | MatcherClause | Member | RepeatStmt | ReportDecl | ReturnStmt | Ternary | Unary | WhileStmt;
+    readonly $type: 'Call';
+    args?: ArgList;
+    callee: Expr;
+}
+
+export const Call = {
+    $type: 'Call',
+    args: 'args',
+    callee: 'callee'
+} as const;
+
+export function isCall(item: unknown): item is Call {
+    return reflection.isInstance(item, Call.$type);
+}
+
+export interface CaptureStmt extends Statement {
+    readonly $type: 'CaptureStmt';
+    name: string;
+    opts?: MapLit;
+    value: Expr;
+}
+
+export const CaptureStmt = {
+    $type: 'CaptureStmt',
+    annotations: 'annotations',
+    name: 'name',
+    opts: 'opts',
+    value: 'value'
+} as const;
+
+export function isCaptureStmt(item: unknown): item is CaptureStmt {
+    return reflection.isInstance(item, CaptureStmt.$type);
+}
+
+export interface ConfigDecl extends Declaration {
+    readonly $type: 'ConfigDecl';
+    body: MapLit;
+}
+
+export const ConfigDecl = {
+    $type: 'ConfigDecl',
+    annotations: 'annotations',
+    body: 'body'
+} as const;
+
+export function isConfigDecl(item: unknown): item is ConfigDecl {
+    return reflection.isInstance(item, ConfigDecl.$type);
+}
+
+export interface ContinueStmt extends Statement {
+    readonly $type: 'ContinueStmt';
+}
+
+export const ContinueStmt = {
+    $type: 'ContinueStmt',
+    annotations: 'annotations'
+} as const;
+
+export function isContinueStmt(item: unknown): item is ContinueStmt {
+    return reflection.isInstance(item, ContinueStmt.$type);
+}
+
+export interface DatasetDecl extends Declaration {
+    readonly $type: 'DatasetDecl';
+    declaredType?: TypeRef;
+    name: string;
+    value: Expr;
+}
+
+export const DatasetDecl = {
+    $type: 'DatasetDecl',
+    annotations: 'annotations',
+    declaredType: 'declaredType',
+    name: 'name',
+    value: 'value'
+} as const;
+
+export function isDatasetDecl(item: unknown): item is DatasetDecl {
+    return reflection.isInstance(item, DatasetDecl.$type);
+}
+
+export interface Declaration extends langium.AstNode {
+    readonly $type: 'ActionCall' | 'ConfigDecl' | 'DatasetDecl' | 'Declaration' | 'DecoDecl' | 'ExpectStmt' | 'FactoryDecl' | 'FlowDecl' | 'FnDecl' | 'ForEachStmt' | 'FragmentDecl' | 'IfStmt' | 'LetStmt' | 'LifecycleDecl' | 'MatrixDecl' | 'ParallelStmt' | 'RaceStmt' | 'RepeatStmt' | 'ReportDecl' | 'RunStmt' | 'TryStmt' | 'TypeDecl' | 'WhileStmt';
+    annotations: Array<Annotation>;
+}
+
+export const Declaration = {
+    $type: 'Declaration',
+    annotations: 'annotations'
+} as const;
+
+export function isDeclaration(item: unknown): item is Declaration {
+    return reflection.isInstance(item, Declaration.$type);
+}
+
+export interface DecoDecl extends Declaration {
+    readonly $type: 'DecoDecl';
+    body: Block;
+    export: boolean;
+    name: string;
+    params?: ParamList;
+}
+
+export const DecoDecl = {
+    $type: 'DecoDecl',
+    annotations: 'annotations',
+    body: 'body',
+    export: 'export',
+    name: 'name',
+    params: 'params'
+} as const;
+
+export function isDecoDecl(item: unknown): item is DecoDecl {
+    return reflection.isInstance(item, DecoDecl.$type);
+}
+
+export interface Document extends langium.AstNode {
+    readonly $type: 'Document';
+    decls: Array<Declaration>;
+    imports: Array<ImportDecl>;
+    name?: QualifiedName;
+}
+
+export const Document = {
+    $type: 'Document',
+    decls: 'decls',
+    imports: 'imports',
+    name: 'name'
+} as const;
+
+export function isDocument(item: unknown): item is Document {
+    return reflection.isInstance(item, Document.$type);
+}
+
+export type ElseBranch = Block | IfStmt;
+
+export const ElseBranch = {
+    $type: 'ElseBranch'
+} as const;
+
+export function isElseBranch(item: unknown): item is ElseBranch {
+    return reflection.isInstance(item, ElseBranch.$type);
+}
+
+export interface ExpectStmt extends Declaration, Statement {
+    readonly $type: 'ExpectStmt';
+    checks: Array<Expr>;
+    matcher?: MatcherClause;
+    modifier?: 'all' | 'soft';
+    negate: boolean;
+    subject?: Expr;
+}
+
+export const ExpectStmt = {
+    $type: 'ExpectStmt',
+    annotations: 'annotations',
+    checks: 'checks',
+    matcher: 'matcher',
+    modifier: 'modifier',
+    negate: 'negate',
+    subject: 'subject'
+} as const;
+
+export function isExpectStmt(item: unknown): item is ExpectStmt {
+    return reflection.isInstance(item, ExpectStmt.$type);
+}
+
+export type Expr = Binary | BoolLit | Call | FnExpr | Index | InstantLit | ListLit | MapLit | Member | NullLit | NumberLit | Ref | StringLit | Ternary | Unary;
+
+export const Expr = {
+    $type: 'Expr'
+} as const;
+
+export function isExpr(item: unknown): item is Expr {
+    return reflection.isInstance(item, Expr.$type);
+}
+
+export interface FactoryDecl extends Declaration {
+    readonly $type: 'FactoryDecl';
+    body: MapLit;
+    name: string;
+}
+
+export const FactoryDecl = {
+    $type: 'FactoryDecl',
+    annotations: 'annotations',
+    body: 'body',
+    name: 'name'
+} as const;
+
+export function isFactoryDecl(item: unknown): item is FactoryDecl {
+    return reflection.isInstance(item, FactoryDecl.$type);
+}
+
+export interface FieldDecl extends langium.AstNode {
+    readonly $container: TypeBody;
+    readonly $type: 'FieldDecl';
+    annotations: Array<Annotation>;
+    fieldType: TypeRef;
+    name: string;
+    optional: boolean;
+}
+
+export const FieldDecl = {
+    $type: 'FieldDecl',
+    annotations: 'annotations',
+    fieldType: 'fieldType',
+    name: 'name',
+    optional: 'optional'
+} as const;
+
+export function isFieldDecl(item: unknown): item is FieldDecl {
+    return reflection.isInstance(item, FieldDecl.$type);
+}
+
+export interface FlowDecl extends Declaration {
+    readonly $type: 'FlowDecl';
+    body: Block;
+    title: string;
+}
+
+export const FlowDecl = {
+    $type: 'FlowDecl',
+    annotations: 'annotations',
+    body: 'body',
+    title: 'title'
+} as const;
+
+export function isFlowDecl(item: unknown): item is FlowDecl {
+    return reflection.isInstance(item, FlowDecl.$type);
+}
+
+export interface FnBody extends langium.AstNode {
+    readonly $container: FnDecl | FnExpr;
+    readonly $type: 'FnBody';
+    locals: Array<LetStmt>;
+    result: Expr;
+}
+
+export const FnBody = {
+    $type: 'FnBody',
+    locals: 'locals',
+    result: 'result'
+} as const;
+
+export function isFnBody(item: unknown): item is FnBody {
+    return reflection.isInstance(item, FnBody.$type);
+}
+
+export interface FnDecl extends Declaration {
+    readonly $type: 'FnDecl';
+    body: FnBody;
+    export: boolean;
+    name: string;
+    params?: ParamList;
+    returns?: TypeRef;
+}
+
+export const FnDecl = {
+    $type: 'FnDecl',
+    annotations: 'annotations',
+    body: 'body',
+    export: 'export',
+    name: 'name',
+    params: 'params',
+    returns: 'returns'
+} as const;
+
+export function isFnDecl(item: unknown): item is FnDecl {
+    return reflection.isInstance(item, FnDecl.$type);
+}
+
+export interface FnExpr extends langium.AstNode {
+    readonly $container: ActionCall | Arg | Binary | Call | CaptureStmt | DatasetDecl | ExpectStmt | FnBody | ForEachStmt | IfStmt | Index | LetStmt | LifecycleDecl | ListLit | MapEntry | MatcherClause | Member | RepeatStmt | ReportDecl | ReturnStmt | Ternary | Unary | WhileStmt;
+    readonly $type: 'FnExpr';
+    body: FnBody;
+    params: ParamList;
+    returns?: TypeRef;
+}
+
+export const FnExpr = {
+    $type: 'FnExpr',
+    body: 'body',
+    params: 'params',
+    returns: 'returns'
+} as const;
+
+export function isFnExpr(item: unknown): item is FnExpr {
+    return reflection.isInstance(item, FnExpr.$type);
+}
+
+export interface ForEachStmt extends Declaration, Statement {
+    readonly $type: 'ForEachStmt';
+    body: Block;
+    item: string;
+    opts?: MapLit;
+    source: Expr;
+}
+
+export const ForEachStmt = {
+    $type: 'ForEachStmt',
+    annotations: 'annotations',
+    body: 'body',
+    item: 'item',
+    opts: 'opts',
+    source: 'source'
+} as const;
+
+export function isForEachStmt(item: unknown): item is ForEachStmt {
+    return reflection.isInstance(item, ForEachStmt.$type);
+}
+
+export interface FragmentDecl extends Declaration {
+    readonly $type: 'FragmentDecl';
+    body: Block;
+    export: boolean;
+    name: string;
+    params?: ParamList;
+    returns?: TypeRef;
+}
+
+export const FragmentDecl = {
+    $type: 'FragmentDecl',
+    annotations: 'annotations',
+    body: 'body',
+    export: 'export',
+    name: 'name',
+    params: 'params',
+    returns: 'returns'
+} as const;
+
+export function isFragmentDecl(item: unknown): item is FragmentDecl {
+    return reflection.isInstance(item, FragmentDecl.$type);
+}
+
+export interface GroupDecl extends Statement {
+    readonly $type: 'GroupDecl';
+    body: Block;
+    title: string;
+}
+
+export const GroupDecl = {
+    $type: 'GroupDecl',
+    annotations: 'annotations',
+    body: 'body',
+    title: 'title'
+} as const;
+
+export function isGroupDecl(item: unknown): item is GroupDecl {
+    return reflection.isInstance(item, GroupDecl.$type);
+}
+
+export interface IfStmt extends Declaration, Statement {
+    readonly $container: IfStmt;
+    readonly $type: 'IfStmt';
+    cond: Expr;
+    otherwise?: ElseBranch;
+    then: Block;
+}
+
+export const IfStmt = {
+    $type: 'IfStmt',
+    annotations: 'annotations',
+    cond: 'cond',
+    otherwise: 'otherwise',
+    then: 'then'
+} as const;
+
+export function isIfStmt(item: unknown): item is IfStmt {
+    return reflection.isInstance(item, IfStmt.$type);
+}
+
+export type ImportDecl = UseDecl | ValueImport;
+
+export const ImportDecl = {
+    $type: 'ImportDecl'
+} as const;
+
+export function isImportDecl(item: unknown): item is ImportDecl {
+    return reflection.isInstance(item, ImportDecl.$type);
+}
+
+export interface Index extends langium.AstNode {
+    readonly $container: ActionCall | Arg | Binary | Call | CaptureStmt | DatasetDecl | ExpectStmt | FnBody | ForEachStmt | IfStmt | Index | LetStmt | LifecycleDecl | ListLit | MapEntry | MatcherClause | Member | RepeatStmt | ReportDecl | ReturnStmt | Ternary | Unary | WhileStmt;
+    readonly $type: 'Index';
+    index: Expr;
+    receiver: Expr;
+}
+
+export const Index = {
+    $type: 'Index',
+    index: 'index',
+    receiver: 'receiver'
+} as const;
+
+export function isIndex(item: unknown): item is Index {
+    return reflection.isInstance(item, Index.$type);
+}
+
+export interface InstantLit extends langium.AstNode {
+    readonly $container: ActionCall | Arg | Binary | Call | CaptureStmt | DatasetDecl | ExpectStmt | FnBody | ForEachStmt | IfStmt | Index | LetStmt | LifecycleDecl | ListLit | MapEntry | MatcherClause | Member | RepeatStmt | ReportDecl | ReturnStmt | Ternary | Unary | WhileStmt;
+    readonly $type: 'InstantLit';
+    value: string;
+}
+
+export const InstantLit = {
+    $type: 'InstantLit',
+    value: 'value'
+} as const;
+
+export function isInstantLit(item: unknown): item is InstantLit {
+    return reflection.isInstance(item, InstantLit.$type);
+}
+
+export interface LetStmt extends Declaration, Statement {
+    readonly $container: FnBody;
+    readonly $type: 'LetStmt';
+    args: Array<Expr>;
+    declaredType?: TypeRef;
+    kind: 'const' | 'let';
+    name: string;
+    opts?: MapLit;
+    value: Expr;
+}
+
+export const LetStmt = {
+    $type: 'LetStmt',
+    annotations: 'annotations',
+    args: 'args',
+    declaredType: 'declaredType',
+    kind: 'kind',
+    name: 'name',
+    opts: 'opts',
+    value: 'value'
+} as const;
+
+export function isLetStmt(item: unknown): item is LetStmt {
+    return reflection.isInstance(item, LetStmt.$type);
+}
+
+export interface LifecycleDecl extends Declaration, Statement {
+    readonly $type: 'LifecycleDecl';
+    arg?: Expr;
+    body: Block;
+    event?: string;
+    hook?: 'afterEach' | 'beforeEach' | 'defer' | 'setup' | 'teardown';
+}
+
+export const LifecycleDecl = {
+    $type: 'LifecycleDecl',
+    annotations: 'annotations',
+    arg: 'arg',
+    body: 'body',
+    event: 'event',
+    hook: 'hook'
+} as const;
+
+export function isLifecycleDecl(item: unknown): item is LifecycleDecl {
+    return reflection.isInstance(item, LifecycleDecl.$type);
+}
+
+export interface ListLit extends langium.AstNode {
+    readonly $container: ActionCall | Arg | Binary | Call | CaptureStmt | DatasetDecl | ExpectStmt | FnBody | ForEachStmt | IfStmt | Index | LetStmt | LifecycleDecl | ListLit | MapEntry | MatcherClause | Member | RepeatStmt | ReportDecl | ReturnStmt | Ternary | Unary | WhileStmt;
+    readonly $type: 'ListLit';
+    items: Array<Expr>;
+}
+
+export const ListLit = {
+    $type: 'ListLit',
+    items: 'items'
+} as const;
+
+export function isListLit(item: unknown): item is ListLit {
+    return reflection.isInstance(item, ListLit.$type);
+}
+
+export interface LiteralType extends langium.AstNode {
+    readonly $container: TypeRef;
+    readonly $type: 'LiteralType';
+    value: string;
+}
+
+export const LiteralType = {
+    $type: 'LiteralType',
+    value: 'value'
+} as const;
+
+export function isLiteralType(item: unknown): item is LiteralType {
+    return reflection.isInstance(item, LiteralType.$type);
+}
+
+export interface MapEntry extends langium.AstNode {
+    readonly $container: MapLit;
+    readonly $type: 'MapEntry';
+    key: MapKey;
+    value: Expr;
+}
+
+export const MapEntry = {
+    $type: 'MapEntry',
+    key: 'key',
+    value: 'value'
+} as const;
+
+export function isMapEntry(item: unknown): item is MapEntry {
+    return reflection.isInstance(item, MapEntry.$type);
+}
+
+export type MapKey = Word | string;
+
+export function isMapKey(item: unknown): item is MapKey {
+    return isWord(item) || (typeof item === 'string' && (/"(\\.|[^"\\])*"|'(\\.|[^'\\])*'/.test(item)));
+}
+
+export interface MapLit extends langium.AstNode {
+    readonly $container: ActionCall | Arg | Binary | Call | CaptureStmt | ConfigDecl | DatasetDecl | ExpectStmt | FactoryDecl | FnBody | ForEachStmt | IfStmt | Index | LetStmt | LifecycleDecl | ListLit | MapEntry | MatcherClause | MatrixDecl | Member | ParallelStmt | RaceStmt | RepeatStmt | ReportDecl | ReturnStmt | Ternary | Unary | WhileStmt;
+    readonly $type: 'MapLit';
+    entries: Array<MapEntry>;
+}
+
+export const MapLit = {
+    $type: 'MapLit',
+    entries: 'entries'
+} as const;
+
+export function isMapLit(item: unknown): item is MapLit {
+    return reflection.isInstance(item, MapLit.$type);
+}
+
+export interface MatcherClause extends langium.AstNode {
+    readonly $container: ExpectStmt;
+    readonly $type: 'MatcherClause';
+    args: Array<Expr>;
+    name: string;
+    opts?: MapLit;
+}
+
+export const MatcherClause = {
+    $type: 'MatcherClause',
+    args: 'args',
+    name: 'name',
+    opts: 'opts'
+} as const;
+
+export function isMatcherClause(item: unknown): item is MatcherClause {
+    return reflection.isInstance(item, MatcherClause.$type);
+}
+
+export interface MatrixDecl extends Declaration {
+    readonly $type: 'MatrixDecl';
+    body: MapLit;
+}
+
+export const MatrixDecl = {
+    $type: 'MatrixDecl',
+    annotations: 'annotations',
+    body: 'body'
+} as const;
+
+export function isMatrixDecl(item: unknown): item is MatrixDecl {
+    return reflection.isInstance(item, MatrixDecl.$type);
+}
+
+export interface Member extends langium.AstNode {
+    readonly $container: ActionCall | Arg | Binary | Call | CaptureStmt | DatasetDecl | ExpectStmt | FnBody | ForEachStmt | IfStmt | Index | LetStmt | LifecycleDecl | ListLit | MapEntry | MatcherClause | Member | RepeatStmt | ReportDecl | ReturnStmt | Ternary | Unary | WhileStmt;
+    readonly $type: 'Member';
+    member: Word | string;
+    optional: boolean;
+    receiver: Expr;
+}
+
+export const Member = {
+    $type: 'Member',
+    member: 'member',
+    optional: 'optional',
+    receiver: 'receiver'
+} as const;
+
+export function isMember(item: unknown): item is Member {
+    return reflection.isInstance(item, Member.$type);
+}
+
+export interface NamedType extends langium.AstNode {
+    readonly $container: TypeRef;
+    readonly $type: 'NamedType';
+    args: Array<TypeRef>;
+    name: QualifiedName;
+}
+
+export const NamedType = {
+    $type: 'NamedType',
+    args: 'args',
+    name: 'name'
+} as const;
+
+export function isNamedType(item: unknown): item is NamedType {
+    return reflection.isInstance(item, NamedType.$type);
+}
+
+export interface NullLit extends langium.AstNode {
+    readonly $container: ActionCall | Arg | Binary | Call | CaptureStmt | DatasetDecl | ExpectStmt | FnBody | ForEachStmt | IfStmt | Index | LetStmt | LifecycleDecl | ListLit | MapEntry | MatcherClause | Member | RepeatStmt | ReportDecl | ReturnStmt | Ternary | Unary | WhileStmt;
+    readonly $type: 'NullLit';
+}
+
+export const NullLit = {
+    $type: 'NullLit'
+} as const;
+
+export function isNullLit(item: unknown): item is NullLit {
+    return reflection.isInstance(item, NullLit.$type);
+}
+
+export interface NumberLit extends langium.AstNode {
+    readonly $container: ActionCall | Arg | Binary | Call | CaptureStmt | DatasetDecl | ExpectStmt | FnBody | ForEachStmt | IfStmt | Index | LetStmt | LifecycleDecl | ListLit | MapEntry | MatcherClause | Member | RepeatStmt | ReportDecl | ReturnStmt | Ternary | Unary | WhileStmt;
+    readonly $type: 'NumberLit';
+    raw: string;
+}
+
+export const NumberLit = {
+    $type: 'NumberLit',
+    raw: 'raw'
+} as const;
+
+export function isNumberLit(item: unknown): item is NumberLit {
+    return reflection.isInstance(item, NumberLit.$type);
+}
+
+export interface ParallelStmt extends Declaration, Statement {
+    readonly $type: 'ParallelStmt';
+    body: Block;
+    opts?: MapLit;
+}
+
+export const ParallelStmt = {
+    $type: 'ParallelStmt',
+    annotations: 'annotations',
+    body: 'body',
+    opts: 'opts'
+} as const;
+
+export function isParallelStmt(item: unknown): item is ParallelStmt {
+    return reflection.isInstance(item, ParallelStmt.$type);
+}
+
+export interface Param extends langium.AstNode {
+    readonly $container: ParamList;
+    readonly $type: 'Param';
+    annotations: Array<Annotation>;
+    name: string;
+    paramType?: TypeRef;
+}
+
+export const Param = {
+    $type: 'Param',
+    annotations: 'annotations',
+    name: 'name',
+    paramType: 'paramType'
+} as const;
+
+export function isParam(item: unknown): item is Param {
+    return reflection.isInstance(item, Param.$type);
+}
+
+export interface ParamList extends langium.AstNode {
+    readonly $container: DecoDecl | FnDecl | FnExpr | FragmentDecl;
+    readonly $type: 'ParamList';
+    params: Array<Param>;
+}
+
+export const ParamList = {
+    $type: 'ParamList',
+    params: 'params'
+} as const;
+
+export function isParamList(item: unknown): item is ParamList {
+    return reflection.isInstance(item, ParamList.$type);
+}
+
+export type QualifiedName = string;
+
+export function isQualifiedName(item: unknown): item is QualifiedName {
+    return typeof item === 'string';
+}
+
+export interface RaceStmt extends Declaration, Statement {
+    readonly $type: 'RaceStmt';
+    body: Block;
+    opts?: MapLit;
+}
+
+export const RaceStmt = {
+    $type: 'RaceStmt',
+    annotations: 'annotations',
+    body: 'body',
+    opts: 'opts'
+} as const;
+
+export function isRaceStmt(item: unknown): item is RaceStmt {
+    return reflection.isInstance(item, RaceStmt.$type);
+}
+
+export interface Ref extends langium.AstNode {
+    readonly $container: ActionCall | Arg | Binary | Call | CaptureStmt | DatasetDecl | ExpectStmt | FnBody | ForEachStmt | IfStmt | Index | LetStmt | LifecycleDecl | ListLit | MapEntry | MatcherClause | Member | RepeatStmt | ReportDecl | ReturnStmt | Ternary | Unary | WhileStmt;
+    readonly $type: 'Ref';
+    name: RefName;
+}
+
+export const Ref = {
+    $type: 'Ref',
+    name: 'name'
+} as const;
+
+export function isRef(item: unknown): item is Ref {
+    return reflection.isInstance(item, Ref.$type);
+}
+
+export type RefName = 'flow' | 'matrix' | 'step' | string;
+
+export function isRefName(item: unknown): item is RefName {
+    return item === 'matrix' || item === 'flow' || item === 'step' || (typeof item === 'string' && (/[_a-zA-Z]\w*/.test(item)));
+}
+
+export interface RepeatStmt extends Declaration, Statement {
+    readonly $type: 'RepeatStmt';
+    body: Block;
+    count: Expr;
+    index?: string;
+}
+
+export const RepeatStmt = {
+    $type: 'RepeatStmt',
+    annotations: 'annotations',
+    body: 'body',
+    count: 'count',
+    index: 'index'
+} as const;
+
+export function isRepeatStmt(item: unknown): item is RepeatStmt {
+    return reflection.isInstance(item, RepeatStmt.$type);
+}
+
+export interface ReportDecl extends Declaration {
+    readonly $type: 'ReportDecl';
+    reporters: Array<Expr>;
+}
+
+export const ReportDecl = {
+    $type: 'ReportDecl',
+    annotations: 'annotations',
+    reporters: 'reporters'
+} as const;
+
+export function isReportDecl(item: unknown): item is ReportDecl {
+    return reflection.isInstance(item, ReportDecl.$type);
+}
+
+export interface ReturnStmt extends Statement {
+    readonly $type: 'ReturnStmt';
+    value?: Expr;
+}
+
+export const ReturnStmt = {
+    $type: 'ReturnStmt',
+    annotations: 'annotations',
+    value: 'value'
+} as const;
+
+export function isReturnStmt(item: unknown): item is ReturnStmt {
+    return reflection.isInstance(item, ReturnStmt.$type);
+}
+
+export interface RunStmt extends Declaration, Statement {
+    readonly $type: 'RunStmt';
+    args?: ArgList;
+    bind?: string;
+    target: QualifiedName;
+}
+
+export const RunStmt = {
+    $type: 'RunStmt',
+    annotations: 'annotations',
+    args: 'args',
+    bind: 'bind',
+    target: 'target'
+} as const;
+
+export function isRunStmt(item: unknown): item is RunStmt {
+    return reflection.isInstance(item, RunStmt.$type);
+}
+
+export type SingleType = LiteralType | NamedType;
+
+export const SingleType = {
+    $type: 'SingleType'
+} as const;
+
+export function isSingleType(item: unknown): item is SingleType {
+    return reflection.isInstance(item, SingleType.$type);
+}
+
+export interface Statement extends langium.AstNode {
+    readonly $type: 'ActionCall' | 'BreakStmt' | 'CaptureStmt' | 'ContinueStmt' | 'ExpectStmt' | 'ForEachStmt' | 'GroupDecl' | 'IfStmt' | 'LetStmt' | 'LifecycleDecl' | 'ParallelStmt' | 'RaceStmt' | 'RepeatStmt' | 'ReturnStmt' | 'RunStmt' | 'Statement' | 'StepDecl' | 'TryStmt' | 'WhileStmt';
+    annotations: Array<Annotation>;
+}
+
+export const Statement = {
+    $type: 'Statement',
+    annotations: 'annotations'
+} as const;
+
+export function isStatement(item: unknown): item is Statement {
+    return reflection.isInstance(item, Statement.$type);
+}
+
+export interface StepDecl extends Statement {
+    readonly $type: 'StepDecl';
+    body: Block;
+    title: string;
+}
+
+export const StepDecl = {
+    $type: 'StepDecl',
+    annotations: 'annotations',
+    body: 'body',
+    title: 'title'
+} as const;
+
+export function isStepDecl(item: unknown): item is StepDecl {
+    return reflection.isInstance(item, StepDecl.$type);
+}
+
+export interface StringLit extends langium.AstNode {
+    readonly $container: ActionCall | Arg | Binary | Call | CaptureStmt | DatasetDecl | ExpectStmt | FnBody | ForEachStmt | IfStmt | Index | LetStmt | LifecycleDecl | ListLit | MapEntry | MatcherClause | Member | RepeatStmt | ReportDecl | ReturnStmt | Ternary | Unary | WhileStmt;
+    readonly $type: 'StringLit';
+    value: string;
+}
+
+export const StringLit = {
+    $type: 'StringLit',
+    value: 'value'
+} as const;
+
+export function isStringLit(item: unknown): item is StringLit {
+    return reflection.isInstance(item, StringLit.$type);
+}
+
+export interface Ternary extends langium.AstNode {
+    readonly $container: ActionCall | Arg | Binary | Call | CaptureStmt | DatasetDecl | ExpectStmt | FnBody | ForEachStmt | IfStmt | Index | LetStmt | LifecycleDecl | ListLit | MapEntry | MatcherClause | Member | RepeatStmt | ReportDecl | ReturnStmt | Ternary | Unary | WhileStmt;
+    readonly $type: 'Ternary';
+    condition: Expr;
+    otherwise: Expr;
+    then: Expr;
+}
+
+export const Ternary = {
+    $type: 'Ternary',
+    condition: 'condition',
+    otherwise: 'otherwise',
+    then: 'then'
+} as const;
+
+export function isTernary(item: unknown): item is Ternary {
+    return reflection.isInstance(item, Ternary.$type);
+}
+
+export interface TryStmt extends Declaration, Statement {
+    readonly $type: 'TryStmt';
+    body: Block;
+    error?: string;
+    finalizer?: Block;
+    handler?: Block;
+}
+
+export const TryStmt = {
+    $type: 'TryStmt',
+    annotations: 'annotations',
+    body: 'body',
+    error: 'error',
+    finalizer: 'finalizer',
+    handler: 'handler'
+} as const;
+
+export function isTryStmt(item: unknown): item is TryStmt {
+    return reflection.isInstance(item, TryStmt.$type);
+}
+
+export interface TypeBody extends langium.AstNode {
+    readonly $container: TypeDecl;
+    readonly $type: 'TypeBody';
+    fields: Array<FieldDecl>;
+}
+
+export const TypeBody = {
+    $type: 'TypeBody',
+    fields: 'fields'
+} as const;
+
+export function isTypeBody(item: unknown): item is TypeBody {
+    return reflection.isInstance(item, TypeBody.$type);
+}
+
+export interface TypeDecl extends Declaration {
+    readonly $type: 'TypeDecl';
+    alias?: TypeRef;
+    body?: TypeBody;
+    name: string;
+}
+
+export const TypeDecl = {
+    $type: 'TypeDecl',
+    alias: 'alias',
+    annotations: 'annotations',
+    body: 'body',
+    name: 'name'
+} as const;
+
+export function isTypeDecl(item: unknown): item is TypeDecl {
+    return reflection.isInstance(item, TypeDecl.$type);
+}
+
+export interface TypeRef extends langium.AstNode {
+    readonly $container: DatasetDecl | FieldDecl | FnDecl | FnExpr | FragmentDecl | LetStmt | NamedType | Param | TypeDecl;
+    readonly $type: 'TypeRef';
+    members: Array<SingleType>;
+}
+
+export const TypeRef = {
+    $type: 'TypeRef',
+    members: 'members'
+} as const;
+
+export function isTypeRef(item: unknown): item is TypeRef {
+    return reflection.isInstance(item, TypeRef.$type);
+}
+
+export interface Unary extends langium.AstNode {
+    readonly $container: ActionCall | Arg | Binary | Call | CaptureStmt | DatasetDecl | ExpectStmt | FnBody | ForEachStmt | IfStmt | Index | LetStmt | LifecycleDecl | ListLit | MapEntry | MatcherClause | Member | RepeatStmt | ReportDecl | ReturnStmt | Ternary | Unary | WhileStmt;
+    readonly $type: 'Unary';
+    operand: Expr;
+    operator: '!' | '-';
+}
+
+export const Unary = {
+    $type: 'Unary',
+    operand: 'operand',
+    operator: 'operator'
+} as const;
+
+export function isUnary(item: unknown): item is Unary {
+    return reflection.isInstance(item, Unary.$type);
+}
+
+export interface UseDecl extends langium.AstNode {
+    readonly $container: Document;
+    readonly $type: 'UseDecl';
+    alias?: string;
+    pkg: string;
+}
+
+export const UseDecl = {
+    $type: 'UseDecl',
+    alias: 'alias',
+    pkg: 'pkg'
+} as const;
+
+export function isUseDecl(item: unknown): item is UseDecl {
+    return reflection.isInstance(item, UseDecl.$type);
+}
+
+export interface ValueImport extends langium.AstNode {
+    readonly $container: Document;
+    readonly $type: 'ValueImport';
+    default?: string;
+    export: boolean;
+    names: Array<string>;
+    path: string;
+    wildcard?: string;
+}
+
+export const ValueImport = {
+    $type: 'ValueImport',
+    default: 'default',
+    export: 'export',
+    names: 'names',
+    path: 'path',
+    wildcard: 'wildcard'
+} as const;
+
+export function isValueImport(item: unknown): item is ValueImport {
+    return reflection.isInstance(item, ValueImport.$type);
+}
+
+export interface WhileStmt extends Declaration, Statement {
+    readonly $type: 'WhileStmt';
+    body: Block;
+    cond: Expr;
+}
+
+export const WhileStmt = {
+    $type: 'WhileStmt',
+    annotations: 'annotations',
+    body: 'body',
+    cond: 'cond'
+} as const;
+
+export function isWhileStmt(item: unknown): item is WhileStmt {
+    return reflection.isInstance(item, WhileStmt.$type);
+}
+
+export type Word = 'afterEach' | 'all' | 'as' | 'beforeEach' | 'break' | 'capture' | 'catch' | 'config' | 'const' | 'continue' | 'dataset' | 'deco' | 'defer' | 'else' | 'expect' | 'factory' | 'finally' | 'flow' | 'fn' | 'forEach' | 'fragment' | 'from' | 'group' | 'if' | 'import' | 'in' | 'let' | 'matrix' | 'module' | 'not' | 'on' | 'parallel' | 'pub' | 'race' | 'repeat' | 'report' | 'return' | 'run' | 'setup' | 'soft' | 'step' | 'teardown' | 'try' | 'type' | 'use' | 'while' | string;
+
+export function isWord(item: unknown): item is Word {
+    return item === 'module' || item === 'use' || item === 'as' || item === 'pub' || item === 'import' || item === 'from' || item === 'flow' || item === 'fragment' || item === 'fn' || item === 'deco' || item === 'return' || item === 'const' || item === 'let' || item === 'config' || item === 'matrix' || item === 'report' || item === 'type' || item === 'factory' || item === 'dataset' || item === 'setup' || item === 'teardown' || item === 'beforeEach' || item === 'afterEach' || item === 'defer' || item === 'on' || item === 'step' || item === 'group' || item === 'if' || item === 'else' || item === 'forEach' || item === 'in' || item === 'repeat' || item === 'while' || item === 'parallel' || item === 'race' || item === 'try' || item === 'catch' || item === 'finally' || item === 'capture' || item === 'run' || item === 'break' || item === 'continue' || item === 'expect' || item === 'all' || item === 'soft' || item === 'not' || (typeof item === 'string' && (/[_a-zA-Z]\w*/.test(item)));
+}
+
+export type VennAstType = {
+    ActionCall: ActionCall
+    Annotation: Annotation
+    Arg: Arg
+    ArgList: ArgList
+    Binary: Binary
+    Block: Block
+    BoolLit: BoolLit
+    BreakStmt: BreakStmt
+    Call: Call
+    CaptureStmt: CaptureStmt
+    ConfigDecl: ConfigDecl
+    ContinueStmt: ContinueStmt
+    DatasetDecl: DatasetDecl
+    Declaration: Declaration
+    DecoDecl: DecoDecl
+    Document: Document
+    ElseBranch: ElseBranch
+    ExpectStmt: ExpectStmt
+    Expr: Expr
+    FactoryDecl: FactoryDecl
+    FieldDecl: FieldDecl
+    FlowDecl: FlowDecl
+    FnBody: FnBody
+    FnDecl: FnDecl
+    FnExpr: FnExpr
+    ForEachStmt: ForEachStmt
+    FragmentDecl: FragmentDecl
+    GroupDecl: GroupDecl
+    IfStmt: IfStmt
+    ImportDecl: ImportDecl
+    Index: Index
+    InstantLit: InstantLit
+    LetStmt: LetStmt
+    LifecycleDecl: LifecycleDecl
+    ListLit: ListLit
+    LiteralType: LiteralType
+    MapEntry: MapEntry
+    MapLit: MapLit
+    MatcherClause: MatcherClause
+    MatrixDecl: MatrixDecl
+    Member: Member
+    NamedType: NamedType
+    NullLit: NullLit
+    NumberLit: NumberLit
+    ParallelStmt: ParallelStmt
+    Param: Param
+    ParamList: ParamList
+    RaceStmt: RaceStmt
+    Ref: Ref
+    RepeatStmt: RepeatStmt
+    ReportDecl: ReportDecl
+    ReturnStmt: ReturnStmt
+    RunStmt: RunStmt
+    SingleType: SingleType
+    Statement: Statement
+    StepDecl: StepDecl
+    StringLit: StringLit
+    Ternary: Ternary
+    TryStmt: TryStmt
+    TypeBody: TypeBody
+    TypeDecl: TypeDecl
+    TypeRef: TypeRef
+    Unary: Unary
+    UseDecl: UseDecl
+    ValueImport: ValueImport
+    WhileStmt: WhileStmt
+}
+
+export class VennAstReflection extends langium.AbstractAstReflection {
+    override readonly types = {
+        ActionCall: {
+            name: ActionCall.$type,
+            properties: {
+                annotations: {
+                    name: ActionCall.annotations,
+                    defaultValue: [],
+                    optional: true
+                },
+                args: {
+                    name: ActionCall.args,
+                    defaultValue: [],
+                    optional: true
+                },
+                call: {
+                    name: ActionCall.call,
+                    optional: true
+                },
+                called: {
+                    name: ActionCall.called,
+                    defaultValue: false,
+                    optional: true
+                },
+                opts: {
+                    name: ActionCall.opts,
+                    optional: true
+                },
+                target: {
+                    name: ActionCall.target
+                }
+            },
+            superTypes: [Declaration.$type, Statement.$type]
+        },
+        Annotation: {
+            name: Annotation.$type,
+            properties: {
+                args: {
+                    name: Annotation.args,
+                    optional: true
+                },
+                name: {
+                    name: Annotation.name
+                }
+            },
+            superTypes: []
+        },
+        Arg: {
+            name: Arg.$type,
+            properties: {
+                name: {
+                    name: Arg.name,
+                    optional: true
+                },
+                value: {
+                    name: Arg.value
+                }
+            },
+            superTypes: []
+        },
+        ArgList: {
+            name: ArgList.$type,
+            properties: {
+                args: {
+                    name: ArgList.args,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        Binary: {
+            name: Binary.$type,
+            properties: {
+                left: {
+                    name: Binary.left
+                },
+                operator: {
+                    name: Binary.operator
+                },
+                right: {
+                    name: Binary.right
+                }
+            },
+            superTypes: [Expr.$type]
+        },
+        Block: {
+            name: Block.$type,
+            properties: {
+                stmts: {
+                    name: Block.stmts,
+                    defaultValue: [],
+                    optional: true
+                }
+            },
+            superTypes: [ElseBranch.$type]
+        },
+        BoolLit: {
+            name: BoolLit.$type,
+            properties: {
+                value: {
+                    name: BoolLit.value
+                }
+            },
+            superTypes: [Expr.$type]
+        },
+        BreakStmt: {
+            name: BreakStmt.$type,
+            properties: {
+                annotations: {
+                    name: BreakStmt.annotations,
+                    defaultValue: [],
+                    optional: true
+                }
+            },
+            superTypes: [Statement.$type]
+        },
+        Call: {
+            name: Call.$type,
+            properties: {
+                args: {
+                    name: Call.args,
+                    optional: true
+                },
+                callee: {
+                    name: Call.callee
+                }
+            },
+            superTypes: [Expr.$type]
+        },
+        CaptureStmt: {
+            name: CaptureStmt.$type,
+            properties: {
+                annotations: {
+                    name: CaptureStmt.annotations,
+                    defaultValue: [],
+                    optional: true
+                },
+                name: {
+                    name: CaptureStmt.name
+                },
+                opts: {
+                    name: CaptureStmt.opts,
+                    optional: true
+                },
+                value: {
+                    name: CaptureStmt.value
+                }
+            },
+            superTypes: [Statement.$type]
+        },
+        ConfigDecl: {
+            name: ConfigDecl.$type,
+            properties: {
+                annotations: {
+                    name: ConfigDecl.annotations,
+                    defaultValue: [],
+                    optional: true
+                },
+                body: {
+                    name: ConfigDecl.body
+                }
+            },
+            superTypes: [Declaration.$type]
+        },
+        ContinueStmt: {
+            name: ContinueStmt.$type,
+            properties: {
+                annotations: {
+                    name: ContinueStmt.annotations,
+                    defaultValue: [],
+                    optional: true
+                }
+            },
+            superTypes: [Statement.$type]
+        },
+        DatasetDecl: {
+            name: DatasetDecl.$type,
+            properties: {
+                annotations: {
+                    name: DatasetDecl.annotations,
+                    defaultValue: [],
+                    optional: true
+                },
+                declaredType: {
+                    name: DatasetDecl.declaredType,
+                    optional: true
+                },
+                name: {
+                    name: DatasetDecl.name
+                },
+                value: {
+                    name: DatasetDecl.value
+                }
+            },
+            superTypes: [Declaration.$type]
+        },
+        Declaration: {
+            name: Declaration.$type,
+            properties: {
+                annotations: {
+                    name: Declaration.annotations,
+                    defaultValue: [],
+                    optional: true
+                }
+            },
+            superTypes: []
+        },
+        DecoDecl: {
+            name: DecoDecl.$type,
+            properties: {
+                annotations: {
+                    name: DecoDecl.annotations,
+                    defaultValue: [],
+                    optional: true
+                },
+                body: {
+                    name: DecoDecl.body
+                },
+                export: {
+                    name: DecoDecl.export,
+                    defaultValue: false,
+                    optional: true
+                },
+                name: {
+                    name: DecoDecl.name
+                },
+                params: {
+                    name: DecoDecl.params,
+                    optional: true
+                }
+            },
+            superTypes: [Declaration.$type]
+        },
+        Document: {
+            name: Document.$type,
+            properties: {
+                decls: {
+                    name: Document.decls,
+                    defaultValue: [],
+                    optional: true
+                },
+                imports: {
+                    name: Document.imports,
+                    defaultValue: [],
+                    optional: true
+                },
+                name: {
+                    name: Document.name,
+                    optional: true
+                }
+            },
+            superTypes: []
+        },
+        ElseBranch: {
+            name: ElseBranch.$type,
+            properties: {
+            },
+            superTypes: []
+        },
+        ExpectStmt: {
+            name: ExpectStmt.$type,
+            properties: {
+                annotations: {
+                    name: ExpectStmt.annotations,
+                    defaultValue: [],
+                    optional: true
+                },
+                checks: {
+                    name: ExpectStmt.checks,
+                    defaultValue: [],
+                    optional: true
+                },
+                matcher: {
+                    name: ExpectStmt.matcher,
+                    optional: true
+                },
+                modifier: {
+                    name: ExpectStmt.modifier,
+                    optional: true
+                },
+                negate: {
+                    name: ExpectStmt.negate,
+                    defaultValue: false,
+                    optional: true
+                },
+                subject: {
+                    name: ExpectStmt.subject,
+                    optional: true
+                }
+            },
+            superTypes: [Declaration.$type, Statement.$type]
+        },
+        Expr: {
+            name: Expr.$type,
+            properties: {
+            },
+            superTypes: []
+        },
+        FactoryDecl: {
+            name: FactoryDecl.$type,
+            properties: {
+                annotations: {
+                    name: FactoryDecl.annotations,
+                    defaultValue: [],
+                    optional: true
+                },
+                body: {
+                    name: FactoryDecl.body
+                },
+                name: {
+                    name: FactoryDecl.name
+                }
+            },
+            superTypes: [Declaration.$type]
+        },
+        FieldDecl: {
+            name: FieldDecl.$type,
+            properties: {
+                annotations: {
+                    name: FieldDecl.annotations,
+                    defaultValue: [],
+                    optional: true
+                },
+                fieldType: {
+                    name: FieldDecl.fieldType
+                },
+                name: {
+                    name: FieldDecl.name
+                },
+                optional: {
+                    name: FieldDecl.optional,
+                    defaultValue: false,
+                    optional: true
+                }
+            },
+            superTypes: []
+        },
+        FlowDecl: {
+            name: FlowDecl.$type,
+            properties: {
+                annotations: {
+                    name: FlowDecl.annotations,
+                    defaultValue: [],
+                    optional: true
+                },
+                body: {
+                    name: FlowDecl.body
+                },
+                title: {
+                    name: FlowDecl.title
+                }
+            },
+            superTypes: [Declaration.$type]
+        },
+        FnBody: {
+            name: FnBody.$type,
+            properties: {
+                locals: {
+                    name: FnBody.locals,
+                    defaultValue: [],
+                    optional: true
+                },
+                result: {
+                    name: FnBody.result
+                }
+            },
+            superTypes: []
+        },
+        FnDecl: {
+            name: FnDecl.$type,
+            properties: {
+                annotations: {
+                    name: FnDecl.annotations,
+                    defaultValue: [],
+                    optional: true
+                },
+                body: {
+                    name: FnDecl.body
+                },
+                export: {
+                    name: FnDecl.export,
+                    defaultValue: false,
+                    optional: true
+                },
+                name: {
+                    name: FnDecl.name
+                },
+                params: {
+                    name: FnDecl.params,
+                    optional: true
+                },
+                returns: {
+                    name: FnDecl.returns,
+                    optional: true
+                }
+            },
+            superTypes: [Declaration.$type]
+        },
+        FnExpr: {
+            name: FnExpr.$type,
+            properties: {
+                body: {
+                    name: FnExpr.body
+                },
+                params: {
+                    name: FnExpr.params
+                },
+                returns: {
+                    name: FnExpr.returns,
+                    optional: true
+                }
+            },
+            superTypes: [Expr.$type]
+        },
+        ForEachStmt: {
+            name: ForEachStmt.$type,
+            properties: {
+                annotations: {
+                    name: ForEachStmt.annotations,
+                    defaultValue: [],
+                    optional: true
+                },
+                body: {
+                    name: ForEachStmt.body
+                },
+                item: {
+                    name: ForEachStmt.item
+                },
+                opts: {
+                    name: ForEachStmt.opts,
+                    optional: true
+                },
+                source: {
+                    name: ForEachStmt.source
+                }
+            },
+            superTypes: [Declaration.$type, Statement.$type]
+        },
+        FragmentDecl: {
+            name: FragmentDecl.$type,
+            properties: {
+                annotations: {
+                    name: FragmentDecl.annotations,
+                    defaultValue: [],
+                    optional: true
+                },
+                body: {
+                    name: FragmentDecl.body
+                },
+                export: {
+                    name: FragmentDecl.export,
+                    defaultValue: false,
+                    optional: true
+                },
+                name: {
+                    name: FragmentDecl.name
+                },
+                params: {
+                    name: FragmentDecl.params,
+                    optional: true
+                },
+                returns: {
+                    name: FragmentDecl.returns,
+                    optional: true
+                }
+            },
+            superTypes: [Declaration.$type]
+        },
+        GroupDecl: {
+            name: GroupDecl.$type,
+            properties: {
+                annotations: {
+                    name: GroupDecl.annotations,
+                    defaultValue: [],
+                    optional: true
+                },
+                body: {
+                    name: GroupDecl.body
+                },
+                title: {
+                    name: GroupDecl.title
+                }
+            },
+            superTypes: [Statement.$type]
+        },
+        IfStmt: {
+            name: IfStmt.$type,
+            properties: {
+                annotations: {
+                    name: IfStmt.annotations,
+                    defaultValue: [],
+                    optional: true
+                },
+                cond: {
+                    name: IfStmt.cond
+                },
+                otherwise: {
+                    name: IfStmt.otherwise,
+                    optional: true
+                },
+                then: {
+                    name: IfStmt.then
+                }
+            },
+            superTypes: [Declaration.$type, Statement.$type, ElseBranch.$type]
+        },
+        ImportDecl: {
+            name: ImportDecl.$type,
+            properties: {
+            },
+            superTypes: []
+        },
+        Index: {
+            name: Index.$type,
+            properties: {
+                index: {
+                    name: Index.index
+                },
+                receiver: {
+                    name: Index.receiver
+                }
+            },
+            superTypes: [Expr.$type]
+        },
+        InstantLit: {
+            name: InstantLit.$type,
+            properties: {
+                value: {
+                    name: InstantLit.value
+                }
+            },
+            superTypes: [Expr.$type]
+        },
+        LetStmt: {
+            name: LetStmt.$type,
+            properties: {
+                annotations: {
+                    name: LetStmt.annotations,
+                    defaultValue: [],
+                    optional: true
+                },
+                args: {
+                    name: LetStmt.args,
+                    defaultValue: [],
+                    optional: true
+                },
+                declaredType: {
+                    name: LetStmt.declaredType,
+                    optional: true
+                },
+                kind: {
+                    name: LetStmt.kind
+                },
+                name: {
+                    name: LetStmt.name
+                },
+                opts: {
+                    name: LetStmt.opts,
+                    optional: true
+                },
+                value: {
+                    name: LetStmt.value
+                }
+            },
+            superTypes: [Declaration.$type, Statement.$type]
+        },
+        LifecycleDecl: {
+            name: LifecycleDecl.$type,
+            properties: {
+                annotations: {
+                    name: LifecycleDecl.annotations,
+                    defaultValue: [],
+                    optional: true
+                },
+                arg: {
+                    name: LifecycleDecl.arg,
+                    optional: true
+                },
+                body: {
+                    name: LifecycleDecl.body
+                },
+                event: {
+                    name: LifecycleDecl.event,
+                    optional: true
+                },
+                hook: {
+                    name: LifecycleDecl.hook,
+                    optional: true
+                }
+            },
+            superTypes: [Declaration.$type, Statement.$type]
+        },
+        ListLit: {
+            name: ListLit.$type,
+            properties: {
+                items: {
+                    name: ListLit.items,
+                    defaultValue: [],
+                    optional: true
+                }
+            },
+            superTypes: [Expr.$type]
+        },
+        LiteralType: {
+            name: LiteralType.$type,
+            properties: {
+                value: {
+                    name: LiteralType.value
+                }
+            },
+            superTypes: [SingleType.$type]
+        },
+        MapEntry: {
+            name: MapEntry.$type,
+            properties: {
+                key: {
+                    name: MapEntry.key
+                },
+                value: {
+                    name: MapEntry.value
+                }
+            },
+            superTypes: []
+        },
+        MapLit: {
+            name: MapLit.$type,
+            properties: {
+                entries: {
+                    name: MapLit.entries,
+                    defaultValue: [],
+                    optional: true
+                }
+            },
+            superTypes: [Expr.$type]
+        },
+        MatcherClause: {
+            name: MatcherClause.$type,
+            properties: {
+                args: {
+                    name: MatcherClause.args,
+                    defaultValue: [],
+                    optional: true
+                },
+                name: {
+                    name: MatcherClause.name
+                },
+                opts: {
+                    name: MatcherClause.opts,
+                    optional: true
+                }
+            },
+            superTypes: []
+        },
+        MatrixDecl: {
+            name: MatrixDecl.$type,
+            properties: {
+                annotations: {
+                    name: MatrixDecl.annotations,
+                    defaultValue: [],
+                    optional: true
+                },
+                body: {
+                    name: MatrixDecl.body
+                }
+            },
+            superTypes: [Declaration.$type]
+        },
+        Member: {
+            name: Member.$type,
+            properties: {
+                member: {
+                    name: Member.member
+                },
+                optional: {
+                    name: Member.optional,
+                    defaultValue: false,
+                    optional: true
+                },
+                receiver: {
+                    name: Member.receiver
+                }
+            },
+            superTypes: [Expr.$type]
+        },
+        NamedType: {
+            name: NamedType.$type,
+            properties: {
+                args: {
+                    name: NamedType.args,
+                    defaultValue: [],
+                    optional: true
+                },
+                name: {
+                    name: NamedType.name
+                }
+            },
+            superTypes: [SingleType.$type]
+        },
+        NullLit: {
+            name: NullLit.$type,
+            properties: {
+            },
+            superTypes: [Expr.$type]
+        },
+        NumberLit: {
+            name: NumberLit.$type,
+            properties: {
+                raw: {
+                    name: NumberLit.raw
+                }
+            },
+            superTypes: [Expr.$type]
+        },
+        ParallelStmt: {
+            name: ParallelStmt.$type,
+            properties: {
+                annotations: {
+                    name: ParallelStmt.annotations,
+                    defaultValue: [],
+                    optional: true
+                },
+                body: {
+                    name: ParallelStmt.body
+                },
+                opts: {
+                    name: ParallelStmt.opts,
+                    optional: true
+                }
+            },
+            superTypes: [Declaration.$type, Statement.$type]
+        },
+        Param: {
+            name: Param.$type,
+            properties: {
+                annotations: {
+                    name: Param.annotations,
+                    defaultValue: [],
+                    optional: true
+                },
+                name: {
+                    name: Param.name
+                },
+                paramType: {
+                    name: Param.paramType,
+                    optional: true
+                }
+            },
+            superTypes: []
+        },
+        ParamList: {
+            name: ParamList.$type,
+            properties: {
+                params: {
+                    name: ParamList.params,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        RaceStmt: {
+            name: RaceStmt.$type,
+            properties: {
+                annotations: {
+                    name: RaceStmt.annotations,
+                    defaultValue: [],
+                    optional: true
+                },
+                body: {
+                    name: RaceStmt.body
+                },
+                opts: {
+                    name: RaceStmt.opts,
+                    optional: true
+                }
+            },
+            superTypes: [Declaration.$type, Statement.$type]
+        },
+        Ref: {
+            name: Ref.$type,
+            properties: {
+                name: {
+                    name: Ref.name
+                }
+            },
+            superTypes: [Expr.$type]
+        },
+        RepeatStmt: {
+            name: RepeatStmt.$type,
+            properties: {
+                annotations: {
+                    name: RepeatStmt.annotations,
+                    defaultValue: [],
+                    optional: true
+                },
+                body: {
+                    name: RepeatStmt.body
+                },
+                count: {
+                    name: RepeatStmt.count
+                },
+                index: {
+                    name: RepeatStmt.index,
+                    optional: true
+                }
+            },
+            superTypes: [Declaration.$type, Statement.$type]
+        },
+        ReportDecl: {
+            name: ReportDecl.$type,
+            properties: {
+                annotations: {
+                    name: ReportDecl.annotations,
+                    defaultValue: [],
+                    optional: true
+                },
+                reporters: {
+                    name: ReportDecl.reporters,
+                    defaultValue: []
+                }
+            },
+            superTypes: [Declaration.$type]
+        },
+        ReturnStmt: {
+            name: ReturnStmt.$type,
+            properties: {
+                annotations: {
+                    name: ReturnStmt.annotations,
+                    defaultValue: [],
+                    optional: true
+                },
+                value: {
+                    name: ReturnStmt.value,
+                    optional: true
+                }
+            },
+            superTypes: [Statement.$type]
+        },
+        RunStmt: {
+            name: RunStmt.$type,
+            properties: {
+                annotations: {
+                    name: RunStmt.annotations,
+                    defaultValue: [],
+                    optional: true
+                },
+                args: {
+                    name: RunStmt.args,
+                    optional: true
+                },
+                bind: {
+                    name: RunStmt.bind,
+                    optional: true
+                },
+                target: {
+                    name: RunStmt.target
+                }
+            },
+            superTypes: [Declaration.$type, Statement.$type]
+        },
+        SingleType: {
+            name: SingleType.$type,
+            properties: {
+            },
+            superTypes: []
+        },
+        Statement: {
+            name: Statement.$type,
+            properties: {
+                annotations: {
+                    name: Statement.annotations,
+                    defaultValue: [],
+                    optional: true
+                }
+            },
+            superTypes: []
+        },
+        StepDecl: {
+            name: StepDecl.$type,
+            properties: {
+                annotations: {
+                    name: StepDecl.annotations,
+                    defaultValue: [],
+                    optional: true
+                },
+                body: {
+                    name: StepDecl.body
+                },
+                title: {
+                    name: StepDecl.title
+                }
+            },
+            superTypes: [Statement.$type]
+        },
+        StringLit: {
+            name: StringLit.$type,
+            properties: {
+                value: {
+                    name: StringLit.value
+                }
+            },
+            superTypes: [Expr.$type]
+        },
+        Ternary: {
+            name: Ternary.$type,
+            properties: {
+                condition: {
+                    name: Ternary.condition
+                },
+                otherwise: {
+                    name: Ternary.otherwise
+                },
+                then: {
+                    name: Ternary.then
+                }
+            },
+            superTypes: [Expr.$type]
+        },
+        TryStmt: {
+            name: TryStmt.$type,
+            properties: {
+                annotations: {
+                    name: TryStmt.annotations,
+                    defaultValue: [],
+                    optional: true
+                },
+                body: {
+                    name: TryStmt.body
+                },
+                error: {
+                    name: TryStmt.error,
+                    optional: true
+                },
+                finalizer: {
+                    name: TryStmt.finalizer,
+                    optional: true
+                },
+                handler: {
+                    name: TryStmt.handler,
+                    optional: true
+                }
+            },
+            superTypes: [Declaration.$type, Statement.$type]
+        },
+        TypeBody: {
+            name: TypeBody.$type,
+            properties: {
+                fields: {
+                    name: TypeBody.fields,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        TypeDecl: {
+            name: TypeDecl.$type,
+            properties: {
+                alias: {
+                    name: TypeDecl.alias,
+                    optional: true
+                },
+                annotations: {
+                    name: TypeDecl.annotations,
+                    defaultValue: [],
+                    optional: true
+                },
+                body: {
+                    name: TypeDecl.body,
+                    optional: true
+                },
+                name: {
+                    name: TypeDecl.name
+                }
+            },
+            superTypes: [Declaration.$type]
+        },
+        TypeRef: {
+            name: TypeRef.$type,
+            properties: {
+                members: {
+                    name: TypeRef.members,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        Unary: {
+            name: Unary.$type,
+            properties: {
+                operand: {
+                    name: Unary.operand
+                },
+                operator: {
+                    name: Unary.operator
+                }
+            },
+            superTypes: [Expr.$type]
+        },
+        UseDecl: {
+            name: UseDecl.$type,
+            properties: {
+                alias: {
+                    name: UseDecl.alias,
+                    optional: true
+                },
+                pkg: {
+                    name: UseDecl.pkg
+                }
+            },
+            superTypes: [ImportDecl.$type]
+        },
+        ValueImport: {
+            name: ValueImport.$type,
+            properties: {
+                default: {
+                    name: ValueImport.default,
+                    optional: true
+                },
+                export: {
+                    name: ValueImport.export,
+                    defaultValue: false,
+                    optional: true
+                },
+                names: {
+                    name: ValueImport.names,
+                    defaultValue: [],
+                    optional: true
+                },
+                path: {
+                    name: ValueImport.path
+                },
+                wildcard: {
+                    name: ValueImport.wildcard,
+                    optional: true
+                }
+            },
+            superTypes: [ImportDecl.$type]
+        },
+        WhileStmt: {
+            name: WhileStmt.$type,
+            properties: {
+                annotations: {
+                    name: WhileStmt.annotations,
+                    defaultValue: [],
+                    optional: true
+                },
+                body: {
+                    name: WhileStmt.body
+                },
+                cond: {
+                    name: WhileStmt.cond
+                }
+            },
+            superTypes: [Declaration.$type, Statement.$type]
+        }
+    } as const satisfies langium.AstMetaData
+}
+
+export const reflection = new VennAstReflection();