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

/* eslint-disable */
import type { AstNode, Reference, ReferenceInfo, TypeMetaData } from 'langium';
import { AbstractAstReflection } from 'langium';

export const SnakeskinTerminals = {
    FUNC_PREFIX: /(?<=\n\s*)\(\)\s*=>\s/,
    TEXT: /(?<=[\n\r]+\s+)(?!=+=|\/\*)[^\-\s<:?].*?(?=\r?\n)/s,
    COMMA: /,/,
    JS_EXPR: /JS Object, will be overwritten in the TokenBuilder/,
    ATTR_VAL_ML: /(?<==\s*).+?(?=\s+\.\s+|\s+\|\s+)/s,
    EXPR_TILL_EOL: /(?<=\s(return|=|if|for|throw|unless|- target|\?) ).+?(?=\r?\n)/,
    FROM: /from/,
    DASHED_ID: /[_a-zA-Z\-][\w\-]*?(?=-\w)[\-\w]+/,
    AS: /(?<=\s)as(?=\s)/,
    ASYNC: /(?<=\s)async(?=\s)/,
    ID: /[_a-zA-Z][\w]*/,
    ATTR_KEY: /(((((((?<!<\s*|\()\@[\w:\-\[\]]*)|(\@\[[\w:\-\(\)\.]*?\]))|(-[\w\-]*))|([_a-zA-Z\-][\w\-]*?(?=-\w)[\-\w]+))|([_a-zA-Z][\w]*))(\$\{.+?\})?((?=\s*=\s*|\.|\s)))/,
    AT: /@/,
    STRING: /"(\\.|[^"\\])*"|'(\\.|[^'\\])*'/,
    MACRO: /%\w+%/,
    INTERPOLATION: /\$\{.+?\}/,
    INDENT: /:synthetic-indent:/,
    DEDENT: /:synthetic-dedent:/,
    AMPERSAND_NL: /(?<=\s)&(?=[\r\n]+)/,
    DOT_NL: /(?<=\n\s+)\.(?=[\r\n]+)/,
    CLASS_NAME: /[_a-z\-&][\w\-&]*/,
    DOT: /\./,
    L_PAREN: /\(/,
    R_PAREN: /\)/,
    L_BRAC: /\[/,
    R_BRAC: /\]/,
    PIPE: /\|/,
    EXC: /!/,
    COLON: /:/,
    WS: /[ \t]+/,
    ML_COMMENT: /\/\*[\s\S]*?\*\//,
    SL_COMMENT: /\/\/\/[^\n\r]*/,
    NEW_LINE: /[\r\n]+/,
};

export type SnakeskinTerminalNames = keyof typeof SnakeskinTerminals;

export type SnakeskinKeywordNames = 
    | "#"
    | "&+"
    | "*"
    | "+="
    | "-"
    | "->"
    | "<"
    | "<!"
    | "="
    | "=>"
    | ">"
    | "?"
    | "@@ignore"
    | "block"
    | "break"
    | "catch"
    | "continue"
    | "doctype"
    | "else"
    | "eval"
    | "extends"
    | "finally"
    | "for"
    | "forEach"
    | "forIn"
    | "head"
    | "if"
    | "import"
    | "include"
    | "interface"
    | "namespace"
    | "placeholder"
    | "putIn"
    | "return"
    | "super"
    | "switch"
    | "target"
    | "template"
    | "throw"
    | "try"
    | "unless"
    | "with";

export type SnakeskinTokenNames = SnakeskinTerminalNames | SnakeskinKeywordNames;

export type AttrKey = string;

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

export type AttrVal = string;

export function isAttrVal(item: unknown): item is AttrVal {
    return (typeof item === 'string' && (/(?<=\s(return|=|if|for|throw|unless|- target|\?) ).+?(?=\r?\n)/.test(item) || /[_a-zA-Z][\w]*/.test(item) || /"(\\.|[^"\\])*"|'(\\.|[^'\\])*'/.test(item) || /[_a-zA-Z\-][\w\-]*?(?=-\w)[\-\w]+/.test(item) || /(?<==\s*).+?(?=\s+\.\s+|\s+\|\s+)/s.test(item) || /(?<=[\n\r]+\s+)(?!=+=|\/\*)[^\-\s<:?].*?(?=\r?\n)/s.test(item)));
}

export type ClassName = string;

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

export type Directive = Block | Break | Call | Catch | Comment | Const | Continue | Decorator | DocType | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Global | Head | If | Ignore | IgnoreAllWhitespace | Import | Include | Namespace | Output | Placeholder | PutIn | Return | Super | Switch | Tag | Target | Template | Throw | Try | Unless | Var | Void | With;

export const Directive = 'Directive';

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

export type DottedID = string;

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

export type TagName = string;

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

export interface Attribute extends AstNode {
    readonly $container: Tag;
    readonly $type: 'Attribute';
    key: AttrKey;
    modifiers: Array<string>;
    value?: AttrVal;
}

export const Attribute = 'Attribute';

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

export interface Block extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'Block';
    body: Array<Directive>;
    container?: Reference<Template>;
    name: string;
    params: Array<Parameter>;
}

export const Block = 'Block';

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

export interface Break extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'Break';
}

export const Break = 'Break';

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

export interface Call extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'Call';
    body: Array<Directive>;
    value: string;
}

export const Call = 'Call';

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

export interface Case extends AstNode {
    readonly $container: Switch;
    readonly $type: 'Case';
    body: Array<Directive>;
    expr: string;
}

export const Case = 'Case';

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

export interface Catch extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'Catch';
    body: Array<Directive>;
    name: string;
}

export const Catch = 'Catch';

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

export interface Class extends AstNode {
    readonly $container: Class | Tag;
    readonly $type: 'Class';
    names: Array<Class | ClassName>;
    nonSticky: boolean;
}

export const Class = 'Class';

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

export interface Comment extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'Comment';
    text: string;
}

export const Comment = 'Comment';

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

export interface Const extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'Const';
    initialValue: AttrVal;
    name: string;
}

export const Const = 'Const';

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

export interface Continue extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'Continue';
}

export const Continue = 'Continue';

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

export interface Decorator extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'Decorator';
    args: Array<string>;
    funcName: string;
    global: boolean;
}

export const Decorator = 'Decorator';

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

export interface DocType extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'DocType';
    name?: string;
}

export const DocType = 'DocType';

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

export interface Else extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'Else';
    body: Array<Directive>;
}

export const Else = 'Else';

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

export interface ElseIf extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'ElseIf';
    body: Array<Directive>;
    condition: string;
}

export const ElseIf = 'ElseIf';

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

export interface ElseUnless extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'ElseUnless';
    body: Array<Directive>;
    condition: string;
}

export const ElseUnless = 'ElseUnless';

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

export interface Eval extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'Eval';
    body: Array<Directive>;
}

export const Eval = 'Eval';

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

export interface Finally extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'Finally';
    body: Array<Directive>;
}

export const Finally = 'Finally';

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

export interface For extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'For';
    body: Array<Directive>;
    loop: string;
}

export const For = 'For';

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

export interface ForEach extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'ForEach';
    body: Array<Directive>;
    collection: string;
    idx?: string;
    name: string;
}

export const ForEach = 'ForEach';

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

export interface ForIn extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'ForIn';
    body: Array<Directive>;
    collection: string;
    idx?: string;
    name: string;
}

export const ForIn = 'ForIn';

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

export interface Func extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'Func';
    body: Array<Directive>;
    params: Array<string>;
}

export const Func = 'Func';

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

export interface Global extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'Global';
    initialValue: AttrVal;
    name: string;
}

export const Global = 'Global';

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

export interface Head extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'Head';
    body: Array<Directive>;
}

export const Head = 'Head';

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

export interface If extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'If';
    body: Array<Directive>;
    condition: DottedID | string;
}

export const If = 'If';

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

export interface Ignore extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'Ignore';
}

export const Ignore = 'Ignore';

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

export interface IgnoreAllWhitespace extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'IgnoreAllWhitespace';
    body: Array<Directive>;
}

export const IgnoreAllWhitespace = 'IgnoreAllWhitespace';

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

export interface Import extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'Import';
    name: string;
    path: string;
}

export const Import = 'Import';

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

export interface Include extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'Include';
    filters: Array<string>;
    path: string;
    renderAs?: 'interface' | 'placeholder';
}

export const Include = 'Include';

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

export interface Module extends AstNode {
    readonly $type: 'Module';
    directives: Array<Directive>;
}

export const Module = 'Module';

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

export interface Namespace extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'Namespace';
    name: ReferencePath;
}

export const Namespace = 'Namespace';

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

export interface Output extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'Output';
    text: string;
}

export const Output = 'Output';

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

export interface Parameter extends AstNode {
    readonly $container: Block | Placeholder | Template;
    readonly $type: 'Parameter';
    defaultValue?: string;
    name: string;
    usesWith: boolean;
}

export const Parameter = 'Parameter';

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

export interface Placeholder extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'Placeholder';
    body: Array<Directive>;
    extends?: ReferencePath;
    extendsWith: boolean;
    name: string;
    params: Array<Parameter>;
}

export const Placeholder = 'Placeholder';

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

export interface PutIn extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'PutIn';
    body: Array<Directive>;
    name: string;
}

export const PutIn = 'PutIn';

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

export interface ReferencePath extends AstNode {
    readonly $container: Namespace | Placeholder | ReferencePath | Template | With;
    readonly $type: 'ReferencePath';
    filters: Array<string>;
    name: string;
    next?: ReferencePath;
}

export const ReferencePath = 'ReferencePath';

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

export interface Return extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'Return';
    expr: string;
}

export const Return = 'Return';

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

export interface Super extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'Super';
}

export const Super = 'Super';

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

export interface Switch extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'Switch';
    cases: Array<Case>;
    expr: string;
}

export const Switch = 'Switch';

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

export interface Tag extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'Tag';
    attrs: Array<Attribute>;
    body: Array<Directive>;
    classes: Array<Class>;
    id?: string;
    tagName: '?' | TagName | string;
}

export const Tag = 'Tag';

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

export interface Target extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'Target';
    body: Array<Directive>;
    name?: string;
    value: string;
}

export const Target = 'Target';

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

export interface Template extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'Template';
    async: boolean;
    body: Array<Directive>;
    extends?: ReferencePath;
    extendsWith: boolean;
    name: string;
    params: Array<Parameter>;
}

export const Template = 'Template';

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

export interface Throw extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'Throw';
    name: string;
}

export const Throw = 'Throw';

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

export interface Try extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'Try';
    body: Array<Directive>;
}

export const Try = 'Try';

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

export interface Unless extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'Unless';
    body: Array<Directive>;
    condition: string;
}

export const Unless = 'Unless';

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

export interface Var extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'Var';
    body: Array<Directive>;
    initialValue?: AttrVal;
    name: string;
}

export const Var = 'Var';

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

export interface Void extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'Void';
    content: string;
}

export const Void = 'Void';

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

export interface With extends AstNode {
    readonly $container: Block | Call | Case | Catch | Else | ElseIf | ElseUnless | Eval | Finally | For | ForEach | ForIn | Func | Head | If | IgnoreAllWhitespace | Module | Placeholder | PutIn | Tag | Target | Template | Try | Unless | Var;
    readonly $type: 'With';
    name: ReferencePath;
}

export const With = 'With';

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

export type SnakeskinAstType = {
    Attribute: Attribute
    Block: Block
    Break: Break
    Call: Call
    Case: Case
    Catch: Catch
    Class: Class
    Comment: Comment
    Const: Const
    Continue: Continue
    Decorator: Decorator
    Directive: Directive
    DocType: DocType
    Else: Else
    ElseIf: ElseIf
    ElseUnless: ElseUnless
    Eval: Eval
    Finally: Finally
    For: For
    ForEach: ForEach
    ForIn: ForIn
    Func: Func
    Global: Global
    Head: Head
    If: If
    Ignore: Ignore
    IgnoreAllWhitespace: IgnoreAllWhitespace
    Import: Import
    Include: Include
    Module: Module
    Namespace: Namespace
    Output: Output
    Parameter: Parameter
    Placeholder: Placeholder
    PutIn: PutIn
    ReferencePath: ReferencePath
    Return: Return
    Super: Super
    Switch: Switch
    Tag: Tag
    Target: Target
    Template: Template
    Throw: Throw
    Try: Try
    Unless: Unless
    Var: Var
    Void: Void
    With: With
}

export class SnakeskinAstReflection extends AbstractAstReflection {

    getAllTypes(): string[] {
        return [Attribute, Block, Break, Call, Case, Catch, Class, Comment, Const, Continue, Decorator, Directive, DocType, Else, ElseIf, ElseUnless, Eval, Finally, For, ForEach, ForIn, Func, Global, Head, If, Ignore, IgnoreAllWhitespace, Import, Include, Module, Namespace, Output, Parameter, Placeholder, PutIn, ReferencePath, Return, Super, Switch, Tag, Target, Template, Throw, Try, Unless, Var, Void, With];
    }

    protected override computeIsSubtype(subtype: string, supertype: string): boolean {
        switch (subtype) {
            case Block:
            case Break:
            case Call:
            case Catch:
            case Comment:
            case Const:
            case Continue:
            case Decorator:
            case DocType:
            case Else:
            case ElseIf:
            case ElseUnless:
            case Eval:
            case Finally:
            case For:
            case ForEach:
            case ForIn:
            case Func:
            case Global:
            case Head:
            case If:
            case Ignore:
            case IgnoreAllWhitespace:
            case Import:
            case Include:
            case Namespace:
            case Output:
            case Placeholder:
            case PutIn:
            case Return:
            case Super:
            case Switch:
            case Tag:
            case Target:
            case Template:
            case Throw:
            case Try:
            case Unless:
            case Var:
            case Void:
            case With: {
                return this.isSubtype(Directive, supertype);
            }
            default: {
                return false;
            }
        }
    }

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

    getTypeMetaData(type: string): TypeMetaData {
        switch (type) {
            case Attribute: {
                return {
                    name: Attribute,
                    properties: [
                        { name: 'key' },
                        { name: 'modifiers', defaultValue: [] },
                        { name: 'value' }
                    ]
                };
            }
            case Block: {
                return {
                    name: Block,
                    properties: [
                        { name: 'body', defaultValue: [] },
                        { name: 'container' },
                        { name: 'name' },
                        { name: 'params', defaultValue: [] }
                    ]
                };
            }
            case Call: {
                return {
                    name: Call,
                    properties: [
                        { name: 'body', defaultValue: [] },
                        { name: 'value' }
                    ]
                };
            }
            case Case: {
                return {
                    name: Case,
                    properties: [
                        { name: 'body', defaultValue: [] },
                        { name: 'expr' }
                    ]
                };
            }
            case Catch: {
                return {
                    name: Catch,
                    properties: [
                        { name: 'body', defaultValue: [] },
                        { name: 'name' }
                    ]
                };
            }
            case Class: {
                return {
                    name: Class,
                    properties: [
                        { name: 'names', defaultValue: [] },
                        { name: 'nonSticky', defaultValue: false }
                    ]
                };
            }
            case Comment: {
                return {
                    name: Comment,
                    properties: [
                        { name: 'text' }
                    ]
                };
            }
            case Const: {
                return {
                    name: Const,
                    properties: [
                        { name: 'initialValue' },
                        { name: 'name' }
                    ]
                };
            }
            case Decorator: {
                return {
                    name: Decorator,
                    properties: [
                        { name: 'args', defaultValue: [] },
                        { name: 'funcName' },
                        { name: 'global', defaultValue: false }
                    ]
                };
            }
            case DocType: {
                return {
                    name: DocType,
                    properties: [
                        { name: 'name' }
                    ]
                };
            }
            case Else: {
                return {
                    name: Else,
                    properties: [
                        { name: 'body', defaultValue: [] }
                    ]
                };
            }
            case ElseIf: {
                return {
                    name: ElseIf,
                    properties: [
                        { name: 'body', defaultValue: [] },
                        { name: 'condition' }
                    ]
                };
            }
            case ElseUnless: {
                return {
                    name: ElseUnless,
                    properties: [
                        { name: 'body', defaultValue: [] },
                        { name: 'condition' }
                    ]
                };
            }
            case Eval: {
                return {
                    name: Eval,
                    properties: [
                        { name: 'body', defaultValue: [] }
                    ]
                };
            }
            case Finally: {
                return {
                    name: Finally,
                    properties: [
                        { name: 'body', defaultValue: [] }
                    ]
                };
            }
            case For: {
                return {
                    name: For,
                    properties: [
                        { name: 'body', defaultValue: [] },
                        { name: 'loop' }
                    ]
                };
            }
            case ForEach: {
                return {
                    name: ForEach,
                    properties: [
                        { name: 'body', defaultValue: [] },
                        { name: 'collection' },
                        { name: 'idx' },
                        { name: 'name' }
                    ]
                };
            }
            case ForIn: {
                return {
                    name: ForIn,
                    properties: [
                        { name: 'body', defaultValue: [] },
                        { name: 'collection' },
                        { name: 'idx' },
                        { name: 'name' }
                    ]
                };
            }
            case Func: {
                return {
                    name: Func,
                    properties: [
                        { name: 'body', defaultValue: [] },
                        { name: 'params', defaultValue: [] }
                    ]
                };
            }
            case Global: {
                return {
                    name: Global,
                    properties: [
                        { name: 'initialValue' },
                        { name: 'name' }
                    ]
                };
            }
            case Head: {
                return {
                    name: Head,
                    properties: [
                        { name: 'body', defaultValue: [] }
                    ]
                };
            }
            case If: {
                return {
                    name: If,
                    properties: [
                        { name: 'body', defaultValue: [] },
                        { name: 'condition' }
                    ]
                };
            }
            case IgnoreAllWhitespace: {
                return {
                    name: IgnoreAllWhitespace,
                    properties: [
                        { name: 'body', defaultValue: [] }
                    ]
                };
            }
            case Import: {
                return {
                    name: Import,
                    properties: [
                        { name: 'name' },
                        { name: 'path' }
                    ]
                };
            }
            case Include: {
                return {
                    name: Include,
                    properties: [
                        { name: 'filters', defaultValue: [] },
                        { name: 'path' },
                        { name: 'renderAs' }
                    ]
                };
            }
            case Module: {
                return {
                    name: Module,
                    properties: [
                        { name: 'directives', defaultValue: [] }
                    ]
                };
            }
            case Namespace: {
                return {
                    name: Namespace,
                    properties: [
                        { name: 'name' }
                    ]
                };
            }
            case Output: {
                return {
                    name: Output,
                    properties: [
                        { name: 'text' }
                    ]
                };
            }
            case Parameter: {
                return {
                    name: Parameter,
                    properties: [
                        { name: 'defaultValue' },
                        { name: 'name' },
                        { name: 'usesWith', defaultValue: false }
                    ]
                };
            }
            case Placeholder: {
                return {
                    name: Placeholder,
                    properties: [
                        { name: 'body', defaultValue: [] },
                        { name: 'extends' },
                        { name: 'extendsWith', defaultValue: false },
                        { name: 'name' },
                        { name: 'params', defaultValue: [] }
                    ]
                };
            }
            case PutIn: {
                return {
                    name: PutIn,
                    properties: [
                        { name: 'body', defaultValue: [] },
                        { name: 'name' }
                    ]
                };
            }
            case ReferencePath: {
                return {
                    name: ReferencePath,
                    properties: [
                        { name: 'filters', defaultValue: [] },
                        { name: 'name' },
                        { name: 'next' }
                    ]
                };
            }
            case Return: {
                return {
                    name: Return,
                    properties: [
                        { name: 'expr' }
                    ]
                };
            }
            case Switch: {
                return {
                    name: Switch,
                    properties: [
                        { name: 'cases', defaultValue: [] },
                        { name: 'expr' }
                    ]
                };
            }
            case Tag: {
                return {
                    name: Tag,
                    properties: [
                        { name: 'attrs', defaultValue: [] },
                        { name: 'body', defaultValue: [] },
                        { name: 'classes', defaultValue: [] },
                        { name: 'id' },
                        { name: 'tagName' }
                    ]
                };
            }
            case Target: {
                return {
                    name: Target,
                    properties: [
                        { name: 'body', defaultValue: [] },
                        { name: 'name' },
                        { name: 'value' }
                    ]
                };
            }
            case Template: {
                return {
                    name: Template,
                    properties: [
                        { name: 'async', defaultValue: false },
                        { name: 'body', defaultValue: [] },
                        { name: 'extends' },
                        { name: 'extendsWith', defaultValue: false },
                        { name: 'name' },
                        { name: 'params', defaultValue: [] }
                    ]
                };
            }
            case Throw: {
                return {
                    name: Throw,
                    properties: [
                        { name: 'name' }
                    ]
                };
            }
            case Try: {
                return {
                    name: Try,
                    properties: [
                        { name: 'body', defaultValue: [] }
                    ]
                };
            }
            case Unless: {
                return {
                    name: Unless,
                    properties: [
                        { name: 'body', defaultValue: [] },
                        { name: 'condition' }
                    ]
                };
            }
            case Var: {
                return {
                    name: Var,
                    properties: [
                        { name: 'body', defaultValue: [] },
                        { name: 'initialValue' },
                        { name: 'name' }
                    ]
                };
            }
            case Void: {
                return {
                    name: Void,
                    properties: [
                        { name: 'content' }
                    ]
                };
            }
            case With: {
                return {
                    name: With,
                    properties: [
                        { name: 'name' }
                    ]
                };
            }
            default: {
                return {
                    name: type,
                    properties: []
                };
            }
        }
    }
}

export const reflection = new SnakeskinAstReflection();