@reqlan/language 1.4.0

package/src/generated/ast.ts

@@ -0,0 +1,1481 @@
+/******************************************************************************
+ * This file was generated by langium-cli 4.3.0.
+ * DO NOT EDIT MANUALLY!
+ ******************************************************************************/
+
+/* eslint-disable */
+import * as langium from 'langium';
+
+/** Contains the reachable terminals & keywords and all available types of the 'Reqlan' language. */
+export namespace Reqlan {
+
+    export const Terminals = {
+        NL: /\r?\n/,
+        WS: /[ \t]+/,
+        ML_COMMENT: /\/\*[\s\S]*?\*\//,
+        SL_COMMENT: /\/\/[^\n\r]*/,
+        MARKDOWN_LINK: /\[(?!\[)[^\]]+\]\([^)]+\)/,
+        ID: /[_a-zA-Z][\w-]*/,
+        STRING: /"(\\.|[^"\\\r\n])*"|'(\\.|[^'\\\r\n])*'/,
+        NUMBER: /\d+/,
+        WORD: /[A-Za-z_][\w']*/,
+        OTHER: /[^\s\w\[\]()`]/,
+        INLINE_CODE: /`[^`\n]+`/,
+        CODE_FENCE: /```[^\n]*(?:\r?\n[\s\S]*?)?```/,
+    };
+
+    export type TerminalNames = keyof typeof Terminals;
+
+    export type KeywordNames =
+        | "!"
+        | "("
+        | ")"
+        | ","
+        | "-"
+        | "."
+        | ":"
+        | ";"
+        | "?"
+        | "@"
+        | "["
+        | "[["
+        | "]"
+        | "]]"
+        | "`"
+        | "as"
+        | "from"
+        | "import"
+        | "{"
+        | "|"
+        | "}";
+
+    export type TokenNames = TerminalNames | KeywordNames;
+
+    export type AstType = {
+        AliasPart: AliasPart
+        AnonymousBlock: AnonymousBlock
+        Attribute: Attribute
+        AttributeValue: AttributeValue
+        BlockElement: BlockElement
+        BlockLine: BlockLine
+        BlockValue: BlockValue
+        BodyElement: BodyElement
+        BodyLine: BodyLine
+        BracketReference: BracketReference
+        CodeSnippet: CodeSnippet
+        FileReference: FileReference
+        FileSymbolReference: FileSymbolReference
+        FromImport: FromImport
+        FromImportSpecifier: FromImportSpecifier
+        Idea: Idea
+        IdeaDeclaration: IdeaDeclaration
+        IdeaSet: IdeaSet
+        Import: Import
+        InlineTextPart: InlineTextPart
+        ListItem: ListItem
+        ListItemBody: ListItemBody
+        ListValue: ListValue
+        LocalReference: LocalReference
+        MarkdownLink: MarkdownLink
+        Model: Model
+        NamedBlockListItem: NamedBlockListItem
+        NamedList: NamedList
+        NamespaceImport: NamespaceImport
+        NestedList: NestedList
+        NonBangInlineTextPart: NonBangInlineTextPart
+        OneLinerBody: OneLinerBody
+        OneLinerIdea: OneLinerIdea
+        OneLinerListItem: OneLinerListItem
+        QualifiedImport: QualifiedImport
+        QualifiedReference: QualifiedReference
+        ReferenceTarget: ReferenceTarget
+        RichTextPart: RichTextPart
+        ScalarValue: ScalarValue
+        TopLevelElement: TopLevelElement
+        WikiLink: WikiLink
+    }
+
+}
+
+/** Contains the reachable terminals & keywords and all available types of the 'ReqlanComment' language. */
+export namespace ReqlanComment {
+
+    export const Terminals = {
+        ID: /[_a-zA-Z][\w-]*/,
+        STRING: /"(\\.|[^"\\])*"/,
+    };
+
+    export type TerminalNames = keyof typeof Terminals;
+
+    export type KeywordNames =
+        | "."
+        | ":"
+        | "["
+        | "]"
+        | "rq";
+
+    export type TokenNames = TerminalNames | KeywordNames;
+
+    export type AstType = {
+        CommentModel: CommentModel
+        CommentReference: CommentReference
+        CommentReferenceTarget: CommentReferenceTarget
+        LocalCommentReference: LocalCommentReference
+        QualifiedCommentReference: QualifiedCommentReference
+    }
+
+}
+
+
+// the terminals, keywords and types of the whole 'Reqlan' project
+
+export const ReqlanTerminals = {
+    ...Reqlan.Terminals,
+    ...ReqlanComment.Terminals,
+};
+
+export type ReqlanTerminalNames = keyof typeof ReqlanTerminals;
+
+export type ReqlanKeywordNames = Reqlan.KeywordNames | ReqlanComment.KeywordNames;
+
+export type ReqlanTokenNames = ReqlanTerminalNames | ReqlanKeywordNames;
+
+export type ReqlanAstType = Reqlan.AstType & ReqlanComment.AstType
+
+
+// all type definitions of the the whole 'Reqlan' project
+
+export interface AliasPart extends langium.AstNode {
+    readonly $container: WikiLink;
+    readonly $type: 'AliasPart';
+    text: PlainText;
+}
+
+export const AliasPart = {
+    $type: 'AliasPart',
+    text: 'text'
+} as const;
+
+export function isAliasPart(item: unknown): item is AliasPart {
+    return reflection.isInstance(item, AliasPart.$type);
+}
+
+export interface AnonymousBlock extends langium.AstNode {
+    readonly $container: ListValue | NamedList | NestedList;
+    readonly $type: 'AnonymousBlock';
+    elements: Array<BodyElement>;
+}
+
+export const AnonymousBlock = {
+    $type: 'AnonymousBlock',
+    elements: 'elements'
+} as const;
+
+export function isAnonymousBlock(item: unknown): item is AnonymousBlock {
+    return reflection.isInstance(item, AnonymousBlock.$type);
+}
+
+export interface Attribute extends langium.AstNode {
+    readonly $container: AnonymousBlock | BlockValue | Idea | NamedBlockListItem;
+    readonly $type: 'Attribute';
+    name: string;
+    negated: boolean;
+    value?: AttributeValue;
+}
+
+export const Attribute = {
+    $type: 'Attribute',
+    name: 'name',
+    negated: 'negated',
+    value: 'value'
+} as const;
+
+export function isAttribute(item: unknown): item is Attribute {
+    return reflection.isInstance(item, Attribute.$type);
+}
+
+export type AttributeValue = BlockValue | ListValue | ScalarValue;
+
+export const AttributeValue = {
+    $type: 'AttributeValue'
+} as const;
+
+export function isAttributeValue(item: unknown): item is AttributeValue {
+    return reflection.isInstance(item, AttributeValue.$type);
+}
+
+export type BlockElement = Attribute | BlockLine | CodeSnippet | NamedList | NestedList;
+
+export const BlockElement = {
+    $type: 'BlockElement'
+} as const;
+
+export function isBlockElement(item: unknown): item is BlockElement {
+    return reflection.isInstance(item, BlockElement.$type);
+}
+
+export interface BlockLine extends langium.AstNode {
+    readonly $container: BlockValue;
+    readonly $type: 'BlockLine';
+    parts: Array<RichTextPart>;
+}
+
+export const BlockLine = {
+    $type: 'BlockLine',
+    parts: 'parts'
+} as const;
+
+export function isBlockLine(item: unknown): item is BlockLine {
+    return reflection.isInstance(item, BlockLine.$type);
+}
+
+export interface BlockValue extends langium.AstNode {
+    readonly $container: Attribute;
+    readonly $type: 'BlockValue';
+    elements: Array<BlockElement>;
+}
+
+export const BlockValue = {
+    $type: 'BlockValue',
+    elements: 'elements'
+} as const;
+
+export function isBlockValue(item: unknown): item is BlockValue {
+    return reflection.isInstance(item, BlockValue.$type);
+}
+
+export type BodyElement = Attribute | BodyLine | CodeSnippet | NamedList | NestedList;
+
+export const BodyElement = {
+    $type: 'BodyElement'
+} as const;
+
+export function isBodyElement(item: unknown): item is BodyElement {
+    return reflection.isInstance(item, BodyElement.$type);
+}
+
+export interface BodyLine extends langium.AstNode {
+    readonly $container: AnonymousBlock | Idea | NamedBlockListItem;
+    readonly $type: 'BodyLine';
+    parts: Array<RichTextPart>;
+}
+
+export const BodyLine = {
+    $type: 'BodyLine',
+    parts: 'parts'
+} as const;
+
+export function isBodyLine(item: unknown): item is BodyLine {
+    return reflection.isInstance(item, BodyLine.$type);
+}
+
+export interface BracketReference extends InlineTextPart, NonBangInlineTextPart, RichTextPart {
+    readonly $container: ListItemBody | OneLinerBody;
+    readonly $type: 'BracketReference';
+    target: ReferenceTarget;
+}
+
+export const BracketReference = {
+    $type: 'BracketReference',
+    inlineCode: 'inlineCode',
+    lparen: 'lparen',
+    rparen: 'rparen',
+    target: 'target',
+    text: 'text'
+} as const;
+
+export function isBracketReference(item: unknown): item is BracketReference {
+    return reflection.isInstance(item, BracketReference.$type);
+}
+
+export interface CodeSnippet extends langium.AstNode {
+    readonly $container: AnonymousBlock | BlockValue | Idea | NamedBlockListItem;
+    readonly $type: 'CodeSnippet';
+    raw: string;
+}
+
+export const CodeSnippet = {
+    $type: 'CodeSnippet',
+    raw: 'raw'
+} as const;
+
+export function isCodeSnippet(item: unknown): item is CodeSnippet {
+    return reflection.isInstance(item, CodeSnippet.$type);
+}
+
+export interface CommentModel extends langium.AstNode {
+    readonly $type: 'CommentModel';
+    references: Array<CommentReference>;
+}
+
+export const CommentModel = {
+    $type: 'CommentModel',
+    references: 'references'
+} as const;
+
+export function isCommentModel(item: unknown): item is CommentModel {
+    return reflection.isInstance(item, CommentModel.$type);
+}
+
+export interface CommentReference extends langium.AstNode {
+    readonly $container: CommentModel;
+    readonly $type: 'CommentReference';
+    target: CommentReferenceTarget;
+}
+
+export const CommentReference = {
+    $type: 'CommentReference',
+    target: 'target'
+} as const;
+
+export function isCommentReference(item: unknown): item is CommentReference {
+    return reflection.isInstance(item, CommentReference.$type);
+}
+
+export type CommentReferenceTarget = LocalCommentReference | QualifiedCommentReference;
+
+export const CommentReferenceTarget = {
+    $type: 'CommentReferenceTarget'
+} as const;
+
+export function isCommentReferenceTarget(item: unknown): item is CommentReferenceTarget {
+    return reflection.isInstance(item, CommentReferenceTarget.$type);
+}
+
+export interface FileReference extends langium.AstNode {
+    readonly $container: BracketReference | WikiLink;
+    readonly $type: 'FileReference';
+    file: string;
+}
+
+export const FileReference = {
+    $type: 'FileReference',
+    file: 'file'
+} as const;
+
+export function isFileReference(item: unknown): item is FileReference {
+    return reflection.isInstance(item, FileReference.$type);
+}
+
+export interface FileSymbolReference extends langium.AstNode {
+    readonly $container: BracketReference | WikiLink;
+    readonly $type: 'FileSymbolReference';
+    file: string;
+    symbols: Array<string>;
+}
+
+export const FileSymbolReference = {
+    $type: 'FileSymbolReference',
+    file: 'file',
+    symbols: 'symbols'
+} as const;
+
+export function isFileSymbolReference(item: unknown): item is FileSymbolReference {
+    return reflection.isInstance(item, FileSymbolReference.$type);
+}
+
+export interface FromImport extends langium.AstNode {
+    readonly $container: Model;
+    readonly $type: 'FromImport';
+    path: string;
+    specifiers: Array<FromImportSpecifier>;
+}
+
+export const FromImport = {
+    $type: 'FromImport',
+    path: 'path',
+    specifiers: 'specifiers'
+} as const;
+
+export function isFromImport(item: unknown): item is FromImport {
+    return reflection.isInstance(item, FromImport.$type);
+}
+
+export interface FromImportSpecifier extends langium.AstNode {
+    readonly $container: FromImport;
+    readonly $type: 'FromImportSpecifier';
+    alias?: string;
+    idea: langium.Reference<IdeaDeclaration>;
+}
+
+export const FromImportSpecifier = {
+    $type: 'FromImportSpecifier',
+    alias: 'alias',
+    idea: 'idea'
+} as const;
+
+export function isFromImportSpecifier(item: unknown): item is FromImportSpecifier {
+    return reflection.isInstance(item, FromImportSpecifier.$type);
+}
+
+export interface Idea extends langium.AstNode {
+    readonly $container: Model;
+    readonly $type: 'Idea';
+    elements: Array<BodyElement>;
+    name: IdeaName;
+}
+
+export const Idea = {
+    $type: 'Idea',
+    elements: 'elements',
+    name: 'name'
+} as const;
+
+export function isIdea(item: unknown): item is Idea {
+    return reflection.isInstance(item, Idea.$type);
+}
+
+export type IdeaDeclaration = Idea | OneLinerIdea;
+
+export const IdeaDeclaration = {
+    $type: 'IdeaDeclaration'
+} as const;
+
+export function isIdeaDeclaration(item: unknown): item is IdeaDeclaration {
+    return reflection.isInstance(item, IdeaDeclaration.$type);
+}
+
+export type IdeaMemberName = string;
+
+export function isIdeaMemberName(item: unknown): item is IdeaMemberName {
+    return (typeof item === 'string' && (/[_a-zA-Z][\w-]*/.test(item) || /"(\\.|[^"\\\r\n])*"|'(\\.|[^'\\\r\n])*'/.test(item)));
+}
+
+export type IdeaName = string;
+
+export function isIdeaName(item: unknown): item is IdeaName {
+    return (typeof item === 'string' && (/[_a-zA-Z][\w-]*/.test(item) || /"(\\.|[^"\\\r\n])*"|'(\\.|[^'\\\r\n])*'/.test(item)));
+}
+
+export interface IdeaSet extends langium.AstNode {
+    readonly $container: Model;
+    readonly $type: 'IdeaSet';
+    members: Array<langium.Reference<IdeaDeclaration>>;
+    name: IdeaName;
+}
+
+export const IdeaSet = {
+    $type: 'IdeaSet',
+    members: 'members',
+    name: 'name'
+} as const;
+
+export function isIdeaSet(item: unknown): item is IdeaSet {
+    return reflection.isInstance(item, IdeaSet.$type);
+}
+
+export type Import = FromImport | NamespaceImport | QualifiedImport;
+
+export const Import = {
+    $type: 'Import'
+} as const;
+
+export function isImport(item: unknown): item is Import {
+    return reflection.isInstance(item, Import.$type);
+}
+
+export interface InlineTextPart extends langium.AstNode {
+    readonly $container: ListItemBody | OneLinerBody | ScalarValue;
+    readonly $type: 'BracketReference' | 'InlineTextPart' | 'MarkdownLink' | 'WikiLink';
+    inlineCode?: string;
+    text?: PlainText;
+}
+
+export const InlineTextPart = {
+    $type: 'InlineTextPart',
+    inlineCode: 'inlineCode',
+    text: 'text'
+} as const;
+
+export function isInlineTextPart(item: unknown): item is InlineTextPart {
+    return reflection.isInstance(item, InlineTextPart.$type);
+}
+
+export type ListItem = AnonymousBlock | NamedBlockListItem | NestedList | OneLinerListItem;
+
+export const ListItem = {
+    $type: 'ListItem'
+} as const;
+
+export function isListItem(item: unknown): item is ListItem {
+    return reflection.isInstance(item, ListItem.$type);
+}
+
+export interface ListItemBody extends langium.AstNode {
+    readonly $container: OneLinerListItem;
+    readonly $type: 'ListItemBody';
+    content: Array<BracketReference | ListItemText | MarkdownLink | WikiLink>;
+}
+
+export const ListItemBody = {
+    $type: 'ListItemBody',
+    content: 'content'
+} as const;
+
+export function isListItemBody(item: unknown): item is ListItemBody {
+    return reflection.isInstance(item, ListItemBody.$type);
+}
+
+export type ListItemPunctuation = '!' | '-' | '.' | ':' | ';' | '?';
+
+export function isListItemPunctuation(item: unknown): item is ListItemPunctuation {
+    return item === '.' || item === ':' || item === ';' || item === '!' || item === '?' || item === '-';
+}
+
+export type ListItemText = '(' | '`' | 'as' | 'from' | 'import' | '|' | ListItemPunctuation | string;
+
+export function isListItemText(item: unknown): item is ListItemText {
+    return isListItemPunctuation(item) || item === '(' || item === '|' || item === 'from' || item === 'import' || item === 'as' || item === '`' || (typeof item === 'string' && (/[A-Za-z_][\w']*/.test(item) || /[_a-zA-Z][\w-]*/.test(item) || /\d+/.test(item) || /`[^`\n]+`/.test(item) || /[^\s\w\[\]()`]/.test(item)));
+}
+
+export interface ListValue extends langium.AstNode {
+    readonly $container: Attribute;
+    readonly $type: 'ListValue';
+    items: Array<ListItem>;
+}
+
+export const ListValue = {
+    $type: 'ListValue',
+    items: 'items'
+} as const;
+
+export function isListValue(item: unknown): item is ListValue {
+    return reflection.isInstance(item, ListValue.$type);
+}
+
+export interface LocalCommentReference extends langium.AstNode {
+    readonly $container: CommentReference;
+    readonly $type: 'LocalCommentReference';
+    idea: string;
+}
+
+export const LocalCommentReference = {
+    $type: 'LocalCommentReference',
+    idea: 'idea'
+} as const;
+
+export function isLocalCommentReference(item: unknown): item is LocalCommentReference {
+    return reflection.isInstance(item, LocalCommentReference.$type);
+}
+
+export interface LocalReference extends langium.AstNode {
+    readonly $container: BracketReference | WikiLink;
+    readonly $type: 'LocalReference';
+    idea: langium.Reference<IdeaDeclaration>;
+}
+
+export const LocalReference = {
+    $type: 'LocalReference',
+    idea: 'idea'
+} as const;
+
+export function isLocalReference(item: unknown): item is LocalReference {
+    return reflection.isInstance(item, LocalReference.$type);
+}
+
+export interface MarkdownLink extends InlineTextPart, NonBangInlineTextPart, RichTextPart {
+    readonly $container: ListItemBody | OneLinerBody;
+    readonly $type: 'MarkdownLink';
+    raw: string;
+}
+
+export const MarkdownLink = {
+    $type: 'MarkdownLink',
+    inlineCode: 'inlineCode',
+    lparen: 'lparen',
+    raw: 'raw',
+    rparen: 'rparen',
+    text: 'text'
+} as const;
+
+export function isMarkdownLink(item: unknown): item is MarkdownLink {
+    return reflection.isInstance(item, MarkdownLink.$type);
+}
+
+export interface Model extends langium.AstNode {
+    readonly $type: 'Model';
+    elements: Array<TopLevelElement>;
+    imports: Array<Import>;
+}
+
+export const Model = {
+    $type: 'Model',
+    elements: 'elements',
+    imports: 'imports'
+} as const;
+
+export function isModel(item: unknown): item is Model {
+    return reflection.isInstance(item, Model.$type);
+}
+
+export interface NamedBlockListItem extends langium.AstNode {
+    readonly $container: ListValue | NamedList | NestedList;
+    readonly $type: 'NamedBlockListItem';
+    elements: Array<BodyElement>;
+    name: string;
+}
+
+export const NamedBlockListItem = {
+    $type: 'NamedBlockListItem',
+    elements: 'elements',
+    name: 'name'
+} as const;
+
+export function isNamedBlockListItem(item: unknown): item is NamedBlockListItem {
+    return reflection.isInstance(item, NamedBlockListItem.$type);
+}
+
+export interface NamedList extends langium.AstNode {
+    readonly $container: AnonymousBlock | BlockValue | Idea | NamedBlockListItem;
+    readonly $type: 'NamedList';
+    items: Array<ListItem>;
+    label: string;
+}
+
+export const NamedList = {
+    $type: 'NamedList',
+    items: 'items',
+    label: 'label'
+} as const;
+
+export function isNamedList(item: unknown): item is NamedList {
+    return reflection.isInstance(item, NamedList.$type);
+}
+
+export interface NamespaceImport extends langium.AstNode {
+    readonly $container: Model;
+    readonly $type: 'NamespaceImport';
+    alias?: string;
+    path: string;
+}
+
+export const NamespaceImport = {
+    $type: 'NamespaceImport',
+    alias: 'alias',
+    path: 'path'
+} as const;
+
+export function isNamespaceImport(item: unknown): item is NamespaceImport {
+    return reflection.isInstance(item, NamespaceImport.$type);
+}
+
+export interface NestedList extends langium.AstNode {
+    readonly $container: AnonymousBlock | BlockValue | Idea | ListValue | NamedBlockListItem | NamedList | NestedList;
+    readonly $type: 'NestedList';
+    items: Array<ListItem>;
+}
+
+export const NestedList = {
+    $type: 'NestedList',
+    items: 'items'
+} as const;
+
+export function isNestedList(item: unknown): item is NestedList {
+    return reflection.isInstance(item, NestedList.$type);
+}
+
+export interface NonBangInlineTextPart extends langium.AstNode {
+    readonly $container: ListItemBody | OneLinerBody | ScalarValue;
+    readonly $type: 'BracketReference' | 'MarkdownLink' | 'NonBangInlineTextPart' | 'WikiLink';
+    inlineCode?: string;
+    text?: NonBangPlainText;
+}
+
+export const NonBangInlineTextPart = {
+    $type: 'NonBangInlineTextPart',
+    inlineCode: 'inlineCode',
+    text: 'text'
+} as const;
+
+export function isNonBangInlineTextPart(item: unknown): item is NonBangInlineTextPart {
+    return reflection.isInstance(item, NonBangInlineTextPart.$type);
+}
+
+export type NonBangPlainText = '[' | ']' | '`' | 'as' | 'from' | 'import' | '|' | NonBangPunctuation | string;
+
+export function isNonBangPlainText(item: unknown): item is NonBangPlainText {
+    return isNonBangPunctuation(item) || item === '[' || item === ']' || item === '|' || item === 'from' || item === 'import' || item === 'as' || item === '`' || (typeof item === 'string' && (/[A-Za-z_][\w']*/.test(item) || /[_a-zA-Z][\w-]*/.test(item) || /\d+/.test(item) || /[^\s\w\[\]()`]/.test(item)));
+}
+
+export type NonBangPunctuation = ',' | '-' | '.' | ';' | '?';
+
+export function isNonBangPunctuation(item: unknown): item is NonBangPunctuation {
+    return item === '.' || item === ',' || item === ';' || item === '?' || item === '-';
+}
+
+export interface OneLinerBody extends langium.AstNode {
+    readonly $container: OneLinerIdea;
+    readonly $type: 'OneLinerBody';
+    content: Array<BracketReference | MarkdownLink | OneLinerText | WikiLink>;
+}
+
+export const OneLinerBody = {
+    $type: 'OneLinerBody',
+    content: 'content'
+} as const;
+
+export function isOneLinerBody(item: unknown): item is OneLinerBody {
+    return reflection.isInstance(item, OneLinerBody.$type);
+}
+
+export interface OneLinerIdea extends langium.AstNode {
+    readonly $container: Model;
+    readonly $type: 'OneLinerIdea';
+    body?: OneLinerBody;
+    name: IdeaName;
+}
+
+export const OneLinerIdea = {
+    $type: 'OneLinerIdea',
+    body: 'body',
+    name: 'name'
+} as const;
+
+export function isOneLinerIdea(item: unknown): item is OneLinerIdea {
+    return reflection.isInstance(item, OneLinerIdea.$type);
+}
+
+export interface OneLinerListItem extends langium.AstNode {
+    readonly $container: ListValue | NamedList | NestedList;
+    readonly $type: 'OneLinerListItem';
+    body: ListItemBody;
+}
+
+export const OneLinerListItem = {
+    $type: 'OneLinerListItem',
+    body: 'body'
+} as const;
+
+export function isOneLinerListItem(item: unknown): item is OneLinerListItem {
+    return reflection.isInstance(item, OneLinerListItem.$type);
+}
+
+export type OneLinerText = '(' | ')' | '`' | 'as' | 'from' | 'import' | '|' | PlainPunctuation | string;
+
+export function isOneLinerText(item: unknown): item is OneLinerText {
+    return isPlainPunctuation(item) || item === '(' || item === ')' || item === '|' || item === 'from' || item === 'import' || item === 'as' || item === '`' || (typeof item === 'string' && (/[A-Za-z_][\w']*/.test(item) || /[_a-zA-Z][\w-]*/.test(item) || /\d+/.test(item) || /`[^`\n]+`/.test(item) || /[^\s\w\[\]()`]/.test(item)));
+}
+
+export type PlainPunctuation = '!' | ',' | '-' | '.' | ':' | ';' | '?';
+
+export function isPlainPunctuation(item: unknown): item is PlainPunctuation {
+    return item === '.' || item === ',' || item === ':' || item === ';' || item === '!' || item === '?' || item === '-';
+}
+
+export type PlainText = '[' | ']' | '`' | 'as' | 'from' | 'import' | '|' | PlainPunctuation | string;
+
+export function isPlainText(item: unknown): item is PlainText {
+    return isPlainPunctuation(item) || item === '[' || item === ']' || item === '|' || item === 'from' || item === 'import' || item === 'as' || item === '`' || (typeof item === 'string' && (/[A-Za-z_][\w']*/.test(item) || /[_a-zA-Z][\w-]*/.test(item) || /\d+/.test(item) || /[^\s\w\[\]()`]/.test(item)));
+}
+
+export interface QualifiedCommentReference extends langium.AstNode {
+    readonly $container: CommentReference;
+    readonly $type: 'QualifiedCommentReference';
+    idea: string;
+    path: string;
+}
+
+export const QualifiedCommentReference = {
+    $type: 'QualifiedCommentReference',
+    idea: 'idea',
+    path: 'path'
+} as const;
+
+export function isQualifiedCommentReference(item: unknown): item is QualifiedCommentReference {
+    return reflection.isInstance(item, QualifiedCommentReference.$type);
+}
+
+export interface QualifiedImport extends langium.AstNode {
+    readonly $container: Model;
+    readonly $type: 'QualifiedImport';
+    alias?: string;
+    idea: langium.Reference<IdeaDeclaration>;
+    ideaset: string;
+    path: string;
+}
+
+export const QualifiedImport = {
+    $type: 'QualifiedImport',
+    alias: 'alias',
+    idea: 'idea',
+    ideaset: 'ideaset',
+    path: 'path'
+} as const;
+
+export function isQualifiedImport(item: unknown): item is QualifiedImport {
+    return reflection.isInstance(item, QualifiedImport.$type);
+}
+
+export interface QualifiedReference extends langium.AstNode {
+    readonly $container: BracketReference | WikiLink;
+    readonly $type: 'QualifiedReference';
+    idea: langium.Reference<IdeaDeclaration>;
+    ideaset?: langium.Reference<IdeaSet>;
+    path?: langium.Reference<Import>;
+    qualifier?: langium.Reference<Import>;
+}
+
+export const QualifiedReference = {
+    $type: 'QualifiedReference',
+    idea: 'idea',
+    ideaset: 'ideaset',
+    path: 'path',
+    qualifier: 'qualifier'
+} as const;
+
+export function isQualifiedReference(item: unknown): item is QualifiedReference {
+    return reflection.isInstance(item, QualifiedReference.$type);
+}
+
+export type ReferenceName = string;
+
+export function isReferenceName(item: unknown): item is ReferenceName {
+    return (typeof item === 'string' && (/[_a-zA-Z][\w-]*/.test(item)));
+}
+
+export type ReferenceTarget = FileReference | FileSymbolReference | LocalReference | QualifiedReference;
+
+export const ReferenceTarget = {
+    $type: 'ReferenceTarget'
+} as const;
+
+export function isReferenceTarget(item: unknown): item is ReferenceTarget {
+    return reflection.isInstance(item, ReferenceTarget.$type);
+}
+
+export interface RichTextPart extends langium.AstNode {
+    readonly $container: BlockLine | BodyLine | ListItemBody | OneLinerBody;
+    readonly $type: 'BracketReference' | 'MarkdownLink' | 'RichTextPart' | 'WikiLink';
+    inlineCode?: string;
+    lparen?: '(';
+    rparen?: ')';
+    text?: PlainText;
+}
+
+export const RichTextPart = {
+    $type: 'RichTextPart',
+    inlineCode: 'inlineCode',
+    lparen: 'lparen',
+    rparen: 'rparen',
+    text: 'text'
+} as const;
+
+export function isRichTextPart(item: unknown): item is RichTextPart {
+    return reflection.isInstance(item, RichTextPart.$type);
+}
+
+export interface ScalarValue extends langium.AstNode {
+    readonly $container: Attribute;
+    readonly $type: 'ScalarValue';
+    parts: Array<InlineTextPart | NonBangInlineTextPart>;
+}
+
+export const ScalarValue = {
+    $type: 'ScalarValue',
+    parts: 'parts'
+} as const;
+
+export function isScalarValue(item: unknown): item is ScalarValue {
+    return reflection.isInstance(item, ScalarValue.$type);
+}
+
+export type TopLevelElement = Idea | IdeaSet | OneLinerIdea;
+
+export const TopLevelElement = {
+    $type: 'TopLevelElement'
+} as const;
+
+export function isTopLevelElement(item: unknown): item is TopLevelElement {
+    return reflection.isInstance(item, TopLevelElement.$type);
+}
+
+export interface WikiLink extends InlineTextPart, NonBangInlineTextPart, RichTextPart {
+    readonly $container: ListItemBody | OneLinerBody;
+    readonly $type: 'WikiLink';
+    alias: Array<AliasPart>;
+    target: ReferenceTarget;
+}
+
+export const WikiLink = {
+    $type: 'WikiLink',
+    alias: 'alias',
+    inlineCode: 'inlineCode',
+    lparen: 'lparen',
+    rparen: 'rparen',
+    target: 'target',
+    text: 'text'
+} as const;
+
+export function isWikiLink(item: unknown): item is WikiLink {
+    return reflection.isInstance(item, WikiLink.$type);
+}
+
+export class ReqlanAstReflection extends langium.AbstractAstReflection {
+    override readonly types = {
+        AliasPart: {
+            name: AliasPart.$type,
+            properties: {
+                text: {
+                    name: AliasPart.text
+                }
+            },
+            superTypes: []
+        },
+        AnonymousBlock: {
+            name: AnonymousBlock.$type,
+            properties: {
+                elements: {
+                    name: AnonymousBlock.elements,
+                    defaultValue: [],
+                    optional: true
+                }
+            },
+            superTypes: [ListItem.$type]
+        },
+        Attribute: {
+            name: Attribute.$type,
+            properties: {
+                name: {
+                    name: Attribute.name
+                },
+                negated: {
+                    name: Attribute.negated,
+                    defaultValue: false,
+                    optional: true
+                },
+                value: {
+                    name: Attribute.value,
+                    optional: true
+                }
+            },
+            superTypes: [BlockElement.$type, BodyElement.$type]
+        },
+        AttributeValue: {
+            name: AttributeValue.$type,
+            properties: {
+            },
+            superTypes: []
+        },
+        BlockElement: {
+            name: BlockElement.$type,
+            properties: {
+            },
+            superTypes: []
+        },
+        BlockLine: {
+            name: BlockLine.$type,
+            properties: {
+                parts: {
+                    name: BlockLine.parts,
+                    defaultValue: []
+                }
+            },
+            superTypes: [BlockElement.$type]
+        },
+        BlockValue: {
+            name: BlockValue.$type,
+            properties: {
+                elements: {
+                    name: BlockValue.elements,
+                    defaultValue: [],
+                    optional: true
+                }
+            },
+            superTypes: [AttributeValue.$type]
+        },
+        BodyElement: {
+            name: BodyElement.$type,
+            properties: {
+            },
+            superTypes: []
+        },
+        BodyLine: {
+            name: BodyLine.$type,
+            properties: {
+                parts: {
+                    name: BodyLine.parts,
+                    defaultValue: []
+                }
+            },
+            superTypes: [BodyElement.$type]
+        },
+        BracketReference: {
+            name: BracketReference.$type,
+            properties: {
+                inlineCode: {
+                    name: BracketReference.inlineCode,
+                    optional: true
+                },
+                lparen: {
+                    name: BracketReference.lparen,
+                    optional: true
+                },
+                rparen: {
+                    name: BracketReference.rparen,
+                    optional: true
+                },
+                target: {
+                    name: BracketReference.target
+                },
+                text: {
+                    name: BracketReference.text,
+                    optional: true
+                }
+            },
+            superTypes: [RichTextPart.$type, InlineTextPart.$type, NonBangInlineTextPart.$type]
+        },
+        CodeSnippet: {
+            name: CodeSnippet.$type,
+            properties: {
+                raw: {
+                    name: CodeSnippet.raw
+                }
+            },
+            superTypes: [BlockElement.$type, BodyElement.$type]
+        },
+        CommentModel: {
+            name: CommentModel.$type,
+            properties: {
+                references: {
+                    name: CommentModel.references,
+                    defaultValue: [],
+                    optional: true
+                }
+            },
+            superTypes: []
+        },
+        CommentReference: {
+            name: CommentReference.$type,
+            properties: {
+                target: {
+                    name: CommentReference.target
+                }
+            },
+            superTypes: []
+        },
+        CommentReferenceTarget: {
+            name: CommentReferenceTarget.$type,
+            properties: {
+            },
+            superTypes: []
+        },
+        FileReference: {
+            name: FileReference.$type,
+            properties: {
+                file: {
+                    name: FileReference.file
+                }
+            },
+            superTypes: [ReferenceTarget.$type]
+        },
+        FileSymbolReference: {
+            name: FileSymbolReference.$type,
+            properties: {
+                file: {
+                    name: FileSymbolReference.file
+                },
+                symbols: {
+                    name: FileSymbolReference.symbols,
+                    defaultValue: []
+                }
+            },
+            superTypes: [ReferenceTarget.$type]
+        },
+        FromImport: {
+            name: FromImport.$type,
+            properties: {
+                path: {
+                    name: FromImport.path
+                },
+                specifiers: {
+                    name: FromImport.specifiers,
+                    defaultValue: []
+                }
+            },
+            superTypes: [Import.$type]
+        },
+        FromImportSpecifier: {
+            name: FromImportSpecifier.$type,
+            properties: {
+                alias: {
+                    name: FromImportSpecifier.alias,
+                    optional: true
+                },
+                idea: {
+                    name: FromImportSpecifier.idea,
+                    referenceType: IdeaDeclaration.$type
+                }
+            },
+            superTypes: []
+        },
+        Idea: {
+            name: Idea.$type,
+            properties: {
+                elements: {
+                    name: Idea.elements,
+                    defaultValue: [],
+                    optional: true
+                },
+                name: {
+                    name: Idea.name
+                }
+            },
+            superTypes: [IdeaDeclaration.$type, TopLevelElement.$type]
+        },
+        IdeaDeclaration: {
+            name: IdeaDeclaration.$type,
+            properties: {
+            },
+            superTypes: []
+        },
+        IdeaSet: {
+            name: IdeaSet.$type,
+            properties: {
+                members: {
+                    name: IdeaSet.members,
+                    defaultValue: [],
+                    referenceType: IdeaDeclaration.$type
+                },
+                name: {
+                    name: IdeaSet.name
+                }
+            },
+            superTypes: [TopLevelElement.$type]
+        },
+        Import: {
+            name: Import.$type,
+            properties: {
+            },
+            superTypes: []
+        },
+        InlineTextPart: {
+            name: InlineTextPart.$type,
+            properties: {
+                inlineCode: {
+                    name: InlineTextPart.inlineCode,
+                    optional: true
+                },
+                text: {
+                    name: InlineTextPart.text,
+                    optional: true
+                }
+            },
+            superTypes: []
+        },
+        ListItem: {
+            name: ListItem.$type,
+            properties: {
+            },
+            superTypes: []
+        },
+        ListItemBody: {
+            name: ListItemBody.$type,
+            properties: {
+                content: {
+                    name: ListItemBody.content,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        ListValue: {
+            name: ListValue.$type,
+            properties: {
+                items: {
+                    name: ListValue.items,
+                    defaultValue: []
+                }
+            },
+            superTypes: [AttributeValue.$type]
+        },
+        LocalCommentReference: {
+            name: LocalCommentReference.$type,
+            properties: {
+                idea: {
+                    name: LocalCommentReference.idea
+                }
+            },
+            superTypes: [CommentReferenceTarget.$type]
+        },
+        LocalReference: {
+            name: LocalReference.$type,
+            properties: {
+                idea: {
+                    name: LocalReference.idea,
+                    referenceType: IdeaDeclaration.$type
+                }
+            },
+            superTypes: [ReferenceTarget.$type]
+        },
+        MarkdownLink: {
+            name: MarkdownLink.$type,
+            properties: {
+                inlineCode: {
+                    name: MarkdownLink.inlineCode,
+                    optional: true
+                },
+                lparen: {
+                    name: MarkdownLink.lparen,
+                    optional: true
+                },
+                raw: {
+                    name: MarkdownLink.raw
+                },
+                rparen: {
+                    name: MarkdownLink.rparen,
+                    optional: true
+                },
+                text: {
+                    name: MarkdownLink.text,
+                    optional: true
+                }
+            },
+            superTypes: [InlineTextPart.$type, RichTextPart.$type, NonBangInlineTextPart.$type]
+        },
+        Model: {
+            name: Model.$type,
+            properties: {
+                elements: {
+                    name: Model.elements,
+                    defaultValue: [],
+                    optional: true
+                },
+                imports: {
+                    name: Model.imports,
+                    defaultValue: [],
+                    optional: true
+                }
+            },
+            superTypes: []
+        },
+        NamedBlockListItem: {
+            name: NamedBlockListItem.$type,
+            properties: {
+                elements: {
+                    name: NamedBlockListItem.elements,
+                    defaultValue: [],
+                    optional: true
+                },
+                name: {
+                    name: NamedBlockListItem.name
+                }
+            },
+            superTypes: [ListItem.$type]
+        },
+        NamedList: {
+            name: NamedList.$type,
+            properties: {
+                items: {
+                    name: NamedList.items,
+                    defaultValue: []
+                },
+                label: {
+                    name: NamedList.label
+                }
+            },
+            superTypes: [BlockElement.$type, BodyElement.$type]
+        },
+        NamespaceImport: {
+            name: NamespaceImport.$type,
+            properties: {
+                alias: {
+                    name: NamespaceImport.alias,
+                    optional: true
+                },
+                path: {
+                    name: NamespaceImport.path
+                }
+            },
+            superTypes: [Import.$type]
+        },
+        NestedList: {
+            name: NestedList.$type,
+            properties: {
+                items: {
+                    name: NestedList.items,
+                    defaultValue: []
+                }
+            },
+            superTypes: [BlockElement.$type, BodyElement.$type, ListItem.$type]
+        },
+        NonBangInlineTextPart: {
+            name: NonBangInlineTextPart.$type,
+            properties: {
+                inlineCode: {
+                    name: NonBangInlineTextPart.inlineCode,
+                    optional: true
+                },
+                text: {
+                    name: NonBangInlineTextPart.text,
+                    optional: true
+                }
+            },
+            superTypes: []
+        },
+        OneLinerBody: {
+            name: OneLinerBody.$type,
+            properties: {
+                content: {
+                    name: OneLinerBody.content,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        OneLinerIdea: {
+            name: OneLinerIdea.$type,
+            properties: {
+                body: {
+                    name: OneLinerIdea.body,
+                    optional: true
+                },
+                name: {
+                    name: OneLinerIdea.name
+                }
+            },
+            superTypes: [IdeaDeclaration.$type, TopLevelElement.$type]
+        },
+        OneLinerListItem: {
+            name: OneLinerListItem.$type,
+            properties: {
+                body: {
+                    name: OneLinerListItem.body
+                }
+            },
+            superTypes: [ListItem.$type]
+        },
+        QualifiedCommentReference: {
+            name: QualifiedCommentReference.$type,
+            properties: {
+                idea: {
+                    name: QualifiedCommentReference.idea
+                },
+                path: {
+                    name: QualifiedCommentReference.path
+                }
+            },
+            superTypes: [CommentReferenceTarget.$type]
+        },
+        QualifiedImport: {
+            name: QualifiedImport.$type,
+            properties: {
+                alias: {
+                    name: QualifiedImport.alias,
+                    optional: true
+                },
+                idea: {
+                    name: QualifiedImport.idea,
+                    referenceType: IdeaDeclaration.$type
+                },
+                ideaset: {
+                    name: QualifiedImport.ideaset
+                },
+                path: {
+                    name: QualifiedImport.path
+                }
+            },
+            superTypes: [Import.$type]
+        },
+        QualifiedReference: {
+            name: QualifiedReference.$type,
+            properties: {
+                idea: {
+                    name: QualifiedReference.idea,
+                    referenceType: IdeaDeclaration.$type
+                },
+                ideaset: {
+                    name: QualifiedReference.ideaset,
+                    referenceType: IdeaSet.$type,
+                    optional: true
+                },
+                path: {
+                    name: QualifiedReference.path,
+                    referenceType: Import.$type,
+                    optional: true
+                },
+                qualifier: {
+                    name: QualifiedReference.qualifier,
+                    referenceType: Import.$type,
+                    optional: true
+                }
+            },
+            superTypes: [ReferenceTarget.$type]
+        },
+        ReferenceTarget: {
+            name: ReferenceTarget.$type,
+            properties: {
+            },
+            superTypes: []
+        },
+        RichTextPart: {
+            name: RichTextPart.$type,
+            properties: {
+                inlineCode: {
+                    name: RichTextPart.inlineCode,
+                    optional: true
+                },
+                lparen: {
+                    name: RichTextPart.lparen,
+                    optional: true
+                },
+                rparen: {
+                    name: RichTextPart.rparen,
+                    optional: true
+                },
+                text: {
+                    name: RichTextPart.text,
+                    optional: true
+                }
+            },
+            superTypes: []
+        },
+        ScalarValue: {
+            name: ScalarValue.$type,
+            properties: {
+                parts: {
+                    name: ScalarValue.parts,
+                    defaultValue: []
+                }
+            },
+            superTypes: [AttributeValue.$type]
+        },
+        TopLevelElement: {
+            name: TopLevelElement.$type,
+            properties: {
+            },
+            superTypes: []
+        },
+        WikiLink: {
+            name: WikiLink.$type,
+            properties: {
+                alias: {
+                    name: WikiLink.alias,
+                    defaultValue: [],
+                    optional: true
+                },
+                inlineCode: {
+                    name: WikiLink.inlineCode,
+                    optional: true
+                },
+                lparen: {
+                    name: WikiLink.lparen,
+                    optional: true
+                },
+                rparen: {
+                    name: WikiLink.rparen,
+                    optional: true
+                },
+                target: {
+                    name: WikiLink.target
+                },
+                text: {
+                    name: WikiLink.text,
+                    optional: true
+                }
+            },
+            superTypes: [InlineTextPart.$type, NonBangInlineTextPart.$type, RichTextPart.$type]
+        }
+    } as const satisfies langium.AstMetaData
+}
+
+export const reflection = new ReqlanAstReflection();