#nullable enable
namespace Parser
{
    public class FileSyntaxNode : SyntaxNode
    {
        private SyntaxNode? _statementList;

        internal FileSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken EndOfFile
        {
            get { return new SyntaxToken(this, ((Parser.Internal.FileSyntaxNode)_green)._endOfFile, this.GetChildPosition(1)); }
        }

        public SyntaxNodeOrTokenList StatementList
        {
            get
            {
                var red = this.GetRed(ref this._statementList!, 0);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("statementList cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 0: return GetRed(ref _statementList!, 0);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitFile(this);
        }

    }

    public class FunctionDeclarationSyntaxNode : StatementSyntaxNode
    {
        private SyntaxNode? _outputDescription;
        private SyntaxNode? _inputDescription;
        private SyntaxNode? _commas;
        private SyntaxNode? _body;
        private SyntaxNode? _endKeyword;

        internal FunctionDeclarationSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken FunctionKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.FunctionDeclarationSyntaxNode)_green)._functionKeyword, this.GetChildPosition(0)); }
        }

        public SyntaxToken Name
        {
            get { return new SyntaxToken(this, ((Parser.Internal.FunctionDeclarationSyntaxNode)_green)._name, this.GetChildPosition(2)); }
        }

        public FunctionOutputDescriptionSyntaxNode? OutputDescription
        {
            get
            {
                var red = this.GetRed(ref this._outputDescription, 1);
                if (red != null)
                    return (FunctionOutputDescriptionSyntaxNode)red;

                return default(FunctionOutputDescriptionSyntaxNode);
            }
        }

        public FunctionInputDescriptionSyntaxNode? InputDescription
        {
            get
            {
                var red = this.GetRed(ref this._inputDescription, 3);
                if (red != null)
                    return (FunctionInputDescriptionSyntaxNode)red;

                return default(FunctionInputDescriptionSyntaxNode);
            }
        }

        public SyntaxNodeOrTokenList Commas
        {
            get
            {
                var red = this.GetRed(ref this._commas!, 4);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("commas cannot be null");
            }
        }

        public SyntaxNodeOrTokenList Body
        {
            get
            {
                var red = this.GetRed(ref this._body!, 5);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("body cannot be null");
            }
        }

        public EndKeywordSyntaxNode? EndKeyword
        {
            get
            {
                var red = this.GetRed(ref this._endKeyword, 6);
                if (red != null)
                    return (EndKeywordSyntaxNode)red;

                return default(EndKeywordSyntaxNode);
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _outputDescription, 1);
                case 3: return GetRed(ref _inputDescription, 3);
                case 4: return GetRed(ref _commas!, 4);
                case 5: return GetRed(ref _body!, 5);
                case 6: return GetRed(ref _endKeyword, 6);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitFunctionDeclaration(this);
        }

    }

    public class FunctionOutputDescriptionSyntaxNode : SyntaxNode
    {
        private SyntaxNode? _outputList;

        internal FunctionOutputDescriptionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken AssignmentSign
        {
            get { return new SyntaxToken(this, ((Parser.Internal.FunctionOutputDescriptionSyntaxNode)_green)._assignmentSign, this.GetChildPosition(1)); }
        }

        public SyntaxNodeOrTokenList OutputList
        {
            get
            {
                var red = this.GetRed(ref this._outputList!, 0);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("outputList cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 0: return GetRed(ref _outputList!, 0);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitFunctionOutputDescription(this);
        }

    }

    public class FunctionInputDescriptionSyntaxNode : SyntaxNode
    {
        private SyntaxNode? _parameterList;

        internal FunctionInputDescriptionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken OpeningBracket
        {
            get { return new SyntaxToken(this, ((Parser.Internal.FunctionInputDescriptionSyntaxNode)_green)._openingBracket, this.GetChildPosition(0)); }
        }

        public SyntaxToken ClosingBracket
        {
            get { return new SyntaxToken(this, ((Parser.Internal.FunctionInputDescriptionSyntaxNode)_green)._closingBracket, this.GetChildPosition(2)); }
        }

        public SyntaxNodeOrTokenList ParameterList
        {
            get
            {
                var red = this.GetRed(ref this._parameterList!, 1);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("parameterList cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _parameterList!, 1);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitFunctionInputDescription(this);
        }

    }

    public class SwitchStatementSyntaxNode : StatementSyntaxNode
    {
        private SyntaxNode? _switchExpression;
        private SyntaxNode? _optionalCommas;
        private SyntaxNode? _cases;

        internal SwitchStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken SwitchKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.SwitchStatementSyntaxNode)_green)._switchKeyword, this.GetChildPosition(0)); }
        }

        public SyntaxToken EndKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.SwitchStatementSyntaxNode)_green)._endKeyword, this.GetChildPosition(4)); }
        }

        public ExpressionSyntaxNode SwitchExpression
        {
            get
            {
                var red = this.GetRed(ref this._switchExpression!, 1);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                throw new System.Exception("switchExpression cannot be null");
            }
        }

        public SyntaxNodeOrTokenList OptionalCommas
        {
            get
            {
                var red = this.GetRed(ref this._optionalCommas!, 2);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("optionalCommas cannot be null");
            }
        }

        public SyntaxNodeOrTokenList Cases
        {
            get
            {
                var red = this.GetRed(ref this._cases!, 3);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("cases cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _switchExpression!, 1);
                case 2: return GetRed(ref _optionalCommas!, 2);
                case 3: return GetRed(ref _cases!, 3);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitSwitchStatement(this);
        }

    }

    public class SwitchCaseSyntaxNode : SyntaxNode
    {
        private SyntaxNode? _caseIdentifier;
        private SyntaxNode? _optionalCommas;
        private SyntaxNode? _body;

        internal SwitchCaseSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken CaseKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.SwitchCaseSyntaxNode)_green)._caseKeyword, this.GetChildPosition(0)); }
        }

        public ExpressionSyntaxNode CaseIdentifier
        {
            get
            {
                var red = this.GetRed(ref this._caseIdentifier!, 1);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                throw new System.Exception("caseIdentifier cannot be null");
            }
        }

        public SyntaxNodeOrTokenList OptionalCommas
        {
            get
            {
                var red = this.GetRed(ref this._optionalCommas!, 2);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("optionalCommas cannot be null");
            }
        }

        public SyntaxNodeOrTokenList Body
        {
            get
            {
                var red = this.GetRed(ref this._body!, 3);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("body cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _caseIdentifier!, 1);
                case 2: return GetRed(ref _optionalCommas!, 2);
                case 3: return GetRed(ref _body!, 3);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitSwitchCase(this);
        }

    }

    public class WhileStatementSyntaxNode : StatementSyntaxNode
    {
        private SyntaxNode? _condition;
        private SyntaxNode? _optionalCommas;
        private SyntaxNode? _body;

        internal WhileStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken WhileKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.WhileStatementSyntaxNode)_green)._whileKeyword, this.GetChildPosition(0)); }
        }

        public SyntaxToken EndKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.WhileStatementSyntaxNode)_green)._endKeyword, this.GetChildPosition(4)); }
        }

        public ExpressionSyntaxNode Condition
        {
            get
            {
                var red = this.GetRed(ref this._condition!, 1);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                throw new System.Exception("condition cannot be null");
            }
        }

        public SyntaxNodeOrTokenList OptionalCommas
        {
            get
            {
                var red = this.GetRed(ref this._optionalCommas!, 2);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("optionalCommas cannot be null");
            }
        }

        public SyntaxNodeOrTokenList Body
        {
            get
            {
                var red = this.GetRed(ref this._body!, 3);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("body cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _condition!, 1);
                case 2: return GetRed(ref _optionalCommas!, 2);
                case 3: return GetRed(ref _body!, 3);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitWhileStatement(this);
        }

    }

    public class ElseifClause : SyntaxNode
    {
        private SyntaxNode? _condition;
        private SyntaxNode? _optionalCommas;
        private SyntaxNode? _body;

        internal ElseifClause(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken ElseifKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.ElseifClause)_green)._elseifKeyword, this.GetChildPosition(0)); }
        }

        public ExpressionSyntaxNode Condition
        {
            get
            {
                var red = this.GetRed(ref this._condition!, 1);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                throw new System.Exception("condition cannot be null");
            }
        }

        public SyntaxNodeOrTokenList OptionalCommas
        {
            get
            {
                var red = this.GetRed(ref this._optionalCommas!, 2);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("optionalCommas cannot be null");
            }
        }

        public SyntaxNodeOrTokenList Body
        {
            get
            {
                var red = this.GetRed(ref this._body!, 3);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("body cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _condition!, 1);
                case 2: return GetRed(ref _optionalCommas!, 2);
                case 3: return GetRed(ref _body!, 3);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitElseifClause(this);
        }

    }

    public class ElseClause : SyntaxNode
    {
        private SyntaxNode? _body;

        internal ElseClause(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken ElseKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.ElseClause)_green)._elseKeyword, this.GetChildPosition(0)); }
        }

        public SyntaxNodeOrTokenList Body
        {
            get
            {
                var red = this.GetRed(ref this._body!, 1);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("body cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _body!, 1);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitElseClause(this);
        }

    }

    public class IfStatementSyntaxNode : StatementSyntaxNode
    {
        private SyntaxNode? _condition;
        private SyntaxNode? _optionalCommas;
        private SyntaxNode? _body;
        private SyntaxNode? _elseifClauses;
        private SyntaxNode? _elseClause;

        internal IfStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken IfKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.IfStatementSyntaxNode)_green)._ifKeyword, this.GetChildPosition(0)); }
        }

        public SyntaxToken EndKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.IfStatementSyntaxNode)_green)._endKeyword, this.GetChildPosition(6)); }
        }

        public ExpressionSyntaxNode Condition
        {
            get
            {
                var red = this.GetRed(ref this._condition!, 1);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                throw new System.Exception("condition cannot be null");
            }
        }

        public SyntaxNodeOrTokenList OptionalCommas
        {
            get
            {
                var red = this.GetRed(ref this._optionalCommas!, 2);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("optionalCommas cannot be null");
            }
        }

        public SyntaxNodeOrTokenList Body
        {
            get
            {
                var red = this.GetRed(ref this._body!, 3);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("body cannot be null");
            }
        }

        public SyntaxNodeOrTokenList ElseifClauses
        {
            get
            {
                var red = this.GetRed(ref this._elseifClauses!, 4);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("elseifClauses cannot be null");
            }
        }

        public ElseClause? ElseClause
        {
            get
            {
                var red = this.GetRed(ref this._elseClause, 5);
                if (red != null)
                    return (ElseClause)red;

                return default(ElseClause);
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _condition!, 1);
                case 2: return GetRed(ref _optionalCommas!, 2);
                case 3: return GetRed(ref _body!, 3);
                case 4: return GetRed(ref _elseifClauses!, 4);
                case 5: return GetRed(ref _elseClause, 5);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitIfStatement(this);
        }

    }

    public class ForStatementSyntaxNode : StatementSyntaxNode
    {
        private SyntaxNode? _assignment;
        private SyntaxNode? _optionalCommas;
        private SyntaxNode? _body;

        internal ForStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken ForKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.ForStatementSyntaxNode)_green)._forKeyword, this.GetChildPosition(0)); }
        }

        public SyntaxToken EndKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.ForStatementSyntaxNode)_green)._endKeyword, this.GetChildPosition(4)); }
        }

        public AssignmentExpressionSyntaxNode Assignment
        {
            get
            {
                var red = this.GetRed(ref this._assignment!, 1);
                if (red != null)
                    return (AssignmentExpressionSyntaxNode)red;

                throw new System.Exception("assignment cannot be null");
            }
        }

        public SyntaxNodeOrTokenList OptionalCommas
        {
            get
            {
                var red = this.GetRed(ref this._optionalCommas!, 2);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("optionalCommas cannot be null");
            }
        }

        public SyntaxNodeOrTokenList Body
        {
            get
            {
                var red = this.GetRed(ref this._body!, 3);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("body cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _assignment!, 1);
                case 2: return GetRed(ref _optionalCommas!, 2);
                case 3: return GetRed(ref _body!, 3);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitForStatement(this);
        }

    }

    public class AssignmentExpressionSyntaxNode : ExpressionSyntaxNode
    {
        private SyntaxNode? _lhs;
        private SyntaxNode? _rhs;

        internal AssignmentExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken AssignmentSign
        {
            get { return new SyntaxToken(this, ((Parser.Internal.AssignmentExpressionSyntaxNode)_green)._assignmentSign, this.GetChildPosition(1)); }
        }

        public ExpressionSyntaxNode Lhs
        {
            get
            {
                var red = this.GetRed(ref this._lhs!, 0);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                throw new System.Exception("lhs cannot be null");
            }
        }

        public ExpressionSyntaxNode Rhs
        {
            get
            {
                var red = this.GetRed(ref this._rhs!, 2);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                throw new System.Exception("rhs cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 0: return GetRed(ref _lhs!, 0);
                case 2: return GetRed(ref _rhs!, 2);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitAssignmentExpression(this);
        }

    }

    public class CatchClauseSyntaxNode : SyntaxNode
    {
        private SyntaxNode? _catchBody;

        internal CatchClauseSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken CatchKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.CatchClauseSyntaxNode)_green)._catchKeyword, this.GetChildPosition(0)); }
        }

        public SyntaxNodeOrTokenList CatchBody
        {
            get
            {
                var red = this.GetRed(ref this._catchBody!, 1);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("catchBody cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _catchBody!, 1);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitCatchClause(this);
        }

    }

    public class TryCatchStatementSyntaxNode : StatementSyntaxNode
    {
        private SyntaxNode? _tryBody;
        private SyntaxNode? _catchClause;

        internal TryCatchStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken TryKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.TryCatchStatementSyntaxNode)_green)._tryKeyword, this.GetChildPosition(0)); }
        }

        public SyntaxToken EndKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.TryCatchStatementSyntaxNode)_green)._endKeyword, this.GetChildPosition(3)); }
        }

        public SyntaxNodeOrTokenList TryBody
        {
            get
            {
                var red = this.GetRed(ref this._tryBody!, 1);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("tryBody cannot be null");
            }
        }

        public CatchClauseSyntaxNode? CatchClause
        {
            get
            {
                var red = this.GetRed(ref this._catchClause, 2);
                if (red != null)
                    return (CatchClauseSyntaxNode)red;

                return default(CatchClauseSyntaxNode);
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _tryBody!, 1);
                case 2: return GetRed(ref _catchClause, 2);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitTryCatchStatement(this);
        }

    }

    public class ExpressionStatementSyntaxNode : StatementSyntaxNode
    {
        private SyntaxNode? _expression;

        internal ExpressionStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }


        public ExpressionSyntaxNode Expression
        {
            get
            {
                var red = this.GetRed(ref this._expression!, 0);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                throw new System.Exception("expression cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 0: return GetRed(ref _expression!, 0);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitExpressionStatement(this);
        }

    }

    public class EmptyStatementSyntaxNode : StatementSyntaxNode
    {

        internal EmptyStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken Semicolon
        {
            get { return new SyntaxToken(this, ((Parser.Internal.EmptyStatementSyntaxNode)_green)._semicolon, this.GetChildPosition(0)); }
        }


        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitEmptyStatement(this);
        }

    }

    public class EmptyExpressionSyntaxNode : ExpressionSyntaxNode
    {

        internal EmptyExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }



        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitEmptyExpression(this);
        }

    }

    public class UnaryPrefixOperationExpressionSyntaxNode : ExpressionSyntaxNode
    {
        private SyntaxNode? _operand;

        internal UnaryPrefixOperationExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken Operation
        {
            get { return new SyntaxToken(this, ((Parser.Internal.UnaryPrefixOperationExpressionSyntaxNode)_green)._operation, this.GetChildPosition(0)); }
        }

        public ExpressionSyntaxNode Operand
        {
            get
            {
                var red = this.GetRed(ref this._operand!, 1);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                throw new System.Exception("operand cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _operand!, 1);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitUnaryPrefixOperationExpression(this);
        }

    }

    public class CompoundNameSyntaxNode : ExpressionSyntaxNode
    {
        private SyntaxNode? _nodes;

        internal CompoundNameSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }


        public SyntaxNodeOrTokenList Nodes
        {
            get
            {
                var red = this.GetRed(ref this._nodes!, 0);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("nodes cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 0: return GetRed(ref _nodes!, 0);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitCompoundName(this);
        }

    }

    public class NamedFunctionHandleSyntaxNode : FunctionHandleSyntaxNode
    {
        private SyntaxNode? _functionName;

        internal NamedFunctionHandleSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken AtSign
        {
            get { return new SyntaxToken(this, ((Parser.Internal.NamedFunctionHandleSyntaxNode)_green)._atSign, this.GetChildPosition(0)); }
        }

        public CompoundNameSyntaxNode FunctionName
        {
            get
            {
                var red = this.GetRed(ref this._functionName!, 1);
                if (red != null)
                    return (CompoundNameSyntaxNode)red;

                throw new System.Exception("functionName cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _functionName!, 1);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitNamedFunctionHandle(this);
        }

    }

    public class LambdaSyntaxNode : FunctionHandleSyntaxNode
    {
        private SyntaxNode? _input;
        private SyntaxNode? _body;

        internal LambdaSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken AtSign
        {
            get { return new SyntaxToken(this, ((Parser.Internal.LambdaSyntaxNode)_green)._atSign, this.GetChildPosition(0)); }
        }

        public FunctionInputDescriptionSyntaxNode Input
        {
            get
            {
                var red = this.GetRed(ref this._input!, 1);
                if (red != null)
                    return (FunctionInputDescriptionSyntaxNode)red;

                throw new System.Exception("input cannot be null");
            }
        }

        public ExpressionSyntaxNode Body
        {
            get
            {
                var red = this.GetRed(ref this._body!, 2);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                throw new System.Exception("body cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _input!, 1);
                case 2: return GetRed(ref _body!, 2);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitLambda(this);
        }

    }

    public class BinaryOperationExpressionSyntaxNode : ExpressionSyntaxNode
    {
        private SyntaxNode? _lhs;
        private SyntaxNode? _rhs;

        internal BinaryOperationExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken Operation
        {
            get { return new SyntaxToken(this, ((Parser.Internal.BinaryOperationExpressionSyntaxNode)_green)._operation, this.GetChildPosition(1)); }
        }

        public ExpressionSyntaxNode Lhs
        {
            get
            {
                var red = this.GetRed(ref this._lhs!, 0);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                throw new System.Exception("lhs cannot be null");
            }
        }

        public ExpressionSyntaxNode Rhs
        {
            get
            {
                var red = this.GetRed(ref this._rhs!, 2);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                throw new System.Exception("rhs cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 0: return GetRed(ref _lhs!, 0);
                case 2: return GetRed(ref _rhs!, 2);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitBinaryOperationExpression(this);
        }

    }

    public class IdentifierNameSyntaxNode : ExpressionSyntaxNode
    {

        internal IdentifierNameSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken Name
        {
            get { return new SyntaxToken(this, ((Parser.Internal.IdentifierNameSyntaxNode)_green)._name, this.GetChildPosition(0)); }
        }


        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitIdentifierName(this);
        }

    }

    public class NumberLiteralSyntaxNode : ExpressionSyntaxNode
    {

        internal NumberLiteralSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken Number
        {
            get { return new SyntaxToken(this, ((Parser.Internal.NumberLiteralSyntaxNode)_green)._number, this.GetChildPosition(0)); }
        }


        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitNumberLiteral(this);
        }

    }

    public class StringLiteralSyntaxNode : ExpressionSyntaxNode
    {

        internal StringLiteralSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken StringToken
        {
            get { return new SyntaxToken(this, ((Parser.Internal.StringLiteralSyntaxNode)_green)._stringToken, this.GetChildPosition(0)); }
        }


        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitStringLiteral(this);
        }

    }

    public class DoubleQuotedStringLiteralSyntaxNode : ExpressionSyntaxNode
    {

        internal DoubleQuotedStringLiteralSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken StringToken
        {
            get { return new SyntaxToken(this, ((Parser.Internal.DoubleQuotedStringLiteralSyntaxNode)_green)._stringToken, this.GetChildPosition(0)); }
        }


        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitDoubleQuotedStringLiteral(this);
        }

    }

    public class UnquotedStringLiteralSyntaxNode : ExpressionSyntaxNode
    {

        internal UnquotedStringLiteralSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken StringToken
        {
            get { return new SyntaxToken(this, ((Parser.Internal.UnquotedStringLiteralSyntaxNode)_green)._stringToken, this.GetChildPosition(0)); }
        }


        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitUnquotedStringLiteral(this);
        }

    }

    public class ArrayLiteralExpressionSyntaxNode : ExpressionSyntaxNode
    {
        private SyntaxNode? _nodes;

        internal ArrayLiteralExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken OpeningSquareBracket
        {
            get { return new SyntaxToken(this, ((Parser.Internal.ArrayLiteralExpressionSyntaxNode)_green)._openingSquareBracket, this.GetChildPosition(0)); }
        }

        public SyntaxToken ClosingSquareBracket
        {
            get { return new SyntaxToken(this, ((Parser.Internal.ArrayLiteralExpressionSyntaxNode)_green)._closingSquareBracket, this.GetChildPosition(2)); }
        }

        public SyntaxNodeOrTokenList Nodes
        {
            get
            {
                var red = this.GetRed(ref this._nodes!, 1);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("nodes cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _nodes!, 1);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitArrayLiteralExpression(this);
        }

    }

    public class CellArrayLiteralExpressionSyntaxNode : ExpressionSyntaxNode
    {
        private SyntaxNode? _nodes;

        internal CellArrayLiteralExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken OpeningBrace
        {
            get { return new SyntaxToken(this, ((Parser.Internal.CellArrayLiteralExpressionSyntaxNode)_green)._openingBrace, this.GetChildPosition(0)); }
        }

        public SyntaxToken ClosingBrace
        {
            get { return new SyntaxToken(this, ((Parser.Internal.CellArrayLiteralExpressionSyntaxNode)_green)._closingBrace, this.GetChildPosition(2)); }
        }

        public SyntaxNodeOrTokenList Nodes
        {
            get
            {
                var red = this.GetRed(ref this._nodes!, 1);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("nodes cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _nodes!, 1);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitCellArrayLiteralExpression(this);
        }

    }

    public class ParenthesizedExpressionSyntaxNode : ExpressionSyntaxNode
    {
        private SyntaxNode? _expression;

        internal ParenthesizedExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken OpeningBracket
        {
            get { return new SyntaxToken(this, ((Parser.Internal.ParenthesizedExpressionSyntaxNode)_green)._openingBracket, this.GetChildPosition(0)); }
        }

        public SyntaxToken ClosingBracket
        {
            get { return new SyntaxToken(this, ((Parser.Internal.ParenthesizedExpressionSyntaxNode)_green)._closingBracket, this.GetChildPosition(2)); }
        }

        public ExpressionSyntaxNode Expression
        {
            get
            {
                var red = this.GetRed(ref this._expression!, 1);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                throw new System.Exception("expression cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _expression!, 1);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitParenthesizedExpression(this);
        }

    }

    public class CellArrayElementAccessExpressionSyntaxNode : ExpressionSyntaxNode
    {
        private SyntaxNode? _expression;
        private SyntaxNode? _nodes;

        internal CellArrayElementAccessExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken OpeningBrace
        {
            get { return new SyntaxToken(this, ((Parser.Internal.CellArrayElementAccessExpressionSyntaxNode)_green)._openingBrace, this.GetChildPosition(1)); }
        }

        public SyntaxToken ClosingBrace
        {
            get { return new SyntaxToken(this, ((Parser.Internal.CellArrayElementAccessExpressionSyntaxNode)_green)._closingBrace, this.GetChildPosition(3)); }
        }

        public ExpressionSyntaxNode Expression
        {
            get
            {
                var red = this.GetRed(ref this._expression!, 0);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                throw new System.Exception("expression cannot be null");
            }
        }

        public SyntaxNodeOrTokenList Nodes
        {
            get
            {
                var red = this.GetRed(ref this._nodes!, 2);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("nodes cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 0: return GetRed(ref _expression!, 0);
                case 2: return GetRed(ref _nodes!, 2);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitCellArrayElementAccessExpression(this);
        }

    }

    public class FunctionCallExpressionSyntaxNode : ExpressionSyntaxNode
    {
        private SyntaxNode? _functionName;
        private SyntaxNode? _nodes;

        internal FunctionCallExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken OpeningBracket
        {
            get { return new SyntaxToken(this, ((Parser.Internal.FunctionCallExpressionSyntaxNode)_green)._openingBracket, this.GetChildPosition(1)); }
        }

        public SyntaxToken ClosingBracket
        {
            get { return new SyntaxToken(this, ((Parser.Internal.FunctionCallExpressionSyntaxNode)_green)._closingBracket, this.GetChildPosition(3)); }
        }

        public ExpressionSyntaxNode FunctionName
        {
            get
            {
                var red = this.GetRed(ref this._functionName!, 0);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                throw new System.Exception("functionName cannot be null");
            }
        }

        public SyntaxNodeOrTokenList Nodes
        {
            get
            {
                var red = this.GetRed(ref this._nodes!, 2);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("nodes cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 0: return GetRed(ref _functionName!, 0);
                case 2: return GetRed(ref _nodes!, 2);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitFunctionCallExpression(this);
        }

    }

    public class MemberAccessSyntaxNode : ExpressionSyntaxNode
    {
        private SyntaxNode? _leftOperand;
        private SyntaxNode? _rightOperand;

        internal MemberAccessSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken Dot
        {
            get { return new SyntaxToken(this, ((Parser.Internal.MemberAccessSyntaxNode)_green)._dot, this.GetChildPosition(1)); }
        }

        public SyntaxNode LeftOperand
        {
            get
            {
                var red = this.GetRed(ref this._leftOperand!, 0);
                if (red != null)
                    return (SyntaxNode)red;

                throw new System.Exception("leftOperand cannot be null");
            }
        }

        public SyntaxNode RightOperand
        {
            get
            {
                var red = this.GetRed(ref this._rightOperand!, 2);
                if (red != null)
                    return (SyntaxNode)red;

                throw new System.Exception("rightOperand cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 0: return GetRed(ref _leftOperand!, 0);
                case 2: return GetRed(ref _rightOperand!, 2);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitMemberAccess(this);
        }

    }

    public class UnaryPostixOperationExpressionSyntaxNode : ExpressionSyntaxNode
    {
        private SyntaxNode? _operand;

        internal UnaryPostixOperationExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken Operation
        {
            get { return new SyntaxToken(this, ((Parser.Internal.UnaryPostixOperationExpressionSyntaxNode)_green)._operation, this.GetChildPosition(1)); }
        }

        public ExpressionSyntaxNode Operand
        {
            get
            {
                var red = this.GetRed(ref this._operand!, 0);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                throw new System.Exception("operand cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 0: return GetRed(ref _operand!, 0);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitUnaryPostixOperationExpression(this);
        }

    }

    public class IndirectMemberAccessSyntaxNode : ExpressionSyntaxNode
    {
        private SyntaxNode? _expression;

        internal IndirectMemberAccessSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken OpeningBracket
        {
            get { return new SyntaxToken(this, ((Parser.Internal.IndirectMemberAccessSyntaxNode)_green)._openingBracket, this.GetChildPosition(0)); }
        }

        public SyntaxToken ClosingBracket
        {
            get { return new SyntaxToken(this, ((Parser.Internal.IndirectMemberAccessSyntaxNode)_green)._closingBracket, this.GetChildPosition(2)); }
        }

        public ExpressionSyntaxNode Expression
        {
            get
            {
                var red = this.GetRed(ref this._expression!, 1);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                throw new System.Exception("expression cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _expression!, 1);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitIndirectMemberAccess(this);
        }

    }

    public class CommandExpressionSyntaxNode : ExpressionSyntaxNode
    {
        private SyntaxNode? _commandName;
        private SyntaxNode? _arguments;

        internal CommandExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }


        public IdentifierNameSyntaxNode CommandName
        {
            get
            {
                var red = this.GetRed(ref this._commandName!, 0);
                if (red != null)
                    return (IdentifierNameSyntaxNode)red;

                throw new System.Exception("commandName cannot be null");
            }
        }

        public SyntaxNodeOrTokenList Arguments
        {
            get
            {
                var red = this.GetRed(ref this._arguments!, 1);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("arguments cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 0: return GetRed(ref _commandName!, 0);
                case 1: return GetRed(ref _arguments!, 1);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitCommandExpression(this);
        }

    }

    public class BaseClassInvokationSyntaxNode : ExpressionSyntaxNode
    {
        private SyntaxNode? _methodName;
        private SyntaxNode? _baseClassNameAndArguments;

        internal BaseClassInvokationSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken AtSign
        {
            get { return new SyntaxToken(this, ((Parser.Internal.BaseClassInvokationSyntaxNode)_green)._atSign, this.GetChildPosition(1)); }
        }

        public ExpressionSyntaxNode MethodName
        {
            get
            {
                var red = this.GetRed(ref this._methodName!, 0);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                throw new System.Exception("methodName cannot be null");
            }
        }

        public ExpressionSyntaxNode BaseClassNameAndArguments
        {
            get
            {
                var red = this.GetRed(ref this._baseClassNameAndArguments!, 2);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                throw new System.Exception("baseClassNameAndArguments cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 0: return GetRed(ref _methodName!, 0);
                case 2: return GetRed(ref _baseClassNameAndArguments!, 2);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitBaseClassInvokation(this);
        }

    }

    public class AttributeAssignmentSyntaxNode : SyntaxNode
    {
        private SyntaxNode? _value;

        internal AttributeAssignmentSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken AssignmentSign
        {
            get { return new SyntaxToken(this, ((Parser.Internal.AttributeAssignmentSyntaxNode)_green)._assignmentSign, this.GetChildPosition(0)); }
        }

        public ExpressionSyntaxNode Value
        {
            get
            {
                var red = this.GetRed(ref this._value!, 1);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                throw new System.Exception("value cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _value!, 1);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitAttributeAssignment(this);
        }

    }

    public class AttributeSyntaxNode : SyntaxNode
    {
        private SyntaxNode? _name;
        private SyntaxNode? _assignment;

        internal AttributeSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }


        public IdentifierNameSyntaxNode Name
        {
            get
            {
                var red = this.GetRed(ref this._name!, 0);
                if (red != null)
                    return (IdentifierNameSyntaxNode)red;

                throw new System.Exception("name cannot be null");
            }
        }

        public AttributeAssignmentSyntaxNode? Assignment
        {
            get
            {
                var red = this.GetRed(ref this._assignment, 1);
                if (red != null)
                    return (AttributeAssignmentSyntaxNode)red;

                return default(AttributeAssignmentSyntaxNode);
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 0: return GetRed(ref _name!, 0);
                case 1: return GetRed(ref _assignment, 1);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitAttribute(this);
        }

    }

    public class AttributeListSyntaxNode : SyntaxNode
    {
        private SyntaxNode? _nodes;

        internal AttributeListSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken OpeningBracket
        {
            get { return new SyntaxToken(this, ((Parser.Internal.AttributeListSyntaxNode)_green)._openingBracket, this.GetChildPosition(0)); }
        }

        public SyntaxToken ClosingBracket
        {
            get { return new SyntaxToken(this, ((Parser.Internal.AttributeListSyntaxNode)_green)._closingBracket, this.GetChildPosition(2)); }
        }

        public SyntaxNodeOrTokenList Nodes
        {
            get
            {
                var red = this.GetRed(ref this._nodes!, 1);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("nodes cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _nodes!, 1);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitAttributeList(this);
        }

    }

    public class MethodDefinitionSyntaxNode : MethodDeclarationSyntaxNode
    {
        private SyntaxNode? _outputDescription;
        private SyntaxNode? _name;
        private SyntaxNode? _inputDescription;
        private SyntaxNode? _commas;
        private SyntaxNode? _body;
        private SyntaxNode? _endKeyword;

        internal MethodDefinitionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken FunctionKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.MethodDefinitionSyntaxNode)_green)._functionKeyword, this.GetChildPosition(0)); }
        }

        public FunctionOutputDescriptionSyntaxNode? OutputDescription
        {
            get
            {
                var red = this.GetRed(ref this._outputDescription, 1);
                if (red != null)
                    return (FunctionOutputDescriptionSyntaxNode)red;

                return default(FunctionOutputDescriptionSyntaxNode);
            }
        }

        public CompoundNameSyntaxNode Name
        {
            get
            {
                var red = this.GetRed(ref this._name!, 2);
                if (red != null)
                    return (CompoundNameSyntaxNode)red;

                throw new System.Exception("name cannot be null");
            }
        }

        public FunctionInputDescriptionSyntaxNode? InputDescription
        {
            get
            {
                var red = this.GetRed(ref this._inputDescription, 3);
                if (red != null)
                    return (FunctionInputDescriptionSyntaxNode)red;

                return default(FunctionInputDescriptionSyntaxNode);
            }
        }

        public SyntaxNodeOrTokenList Commas
        {
            get
            {
                var red = this.GetRed(ref this._commas!, 4);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("commas cannot be null");
            }
        }

        public SyntaxNodeOrTokenList Body
        {
            get
            {
                var red = this.GetRed(ref this._body!, 5);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("body cannot be null");
            }
        }

        public EndKeywordSyntaxNode? EndKeyword
        {
            get
            {
                var red = this.GetRed(ref this._endKeyword, 6);
                if (red != null)
                    return (EndKeywordSyntaxNode)red;

                return default(EndKeywordSyntaxNode);
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _outputDescription, 1);
                case 2: return GetRed(ref _name!, 2);
                case 3: return GetRed(ref _inputDescription, 3);
                case 4: return GetRed(ref _commas!, 4);
                case 5: return GetRed(ref _body!, 5);
                case 6: return GetRed(ref _endKeyword, 6);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitMethodDefinition(this);
        }

    }

    public class AbstractMethodDeclarationSyntaxNode : MethodDeclarationSyntaxNode
    {
        private SyntaxNode? _outputDescription;
        private SyntaxNode? _name;
        private SyntaxNode? _inputDescription;

        internal AbstractMethodDeclarationSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }


        public FunctionOutputDescriptionSyntaxNode? OutputDescription
        {
            get
            {
                var red = this.GetRed(ref this._outputDescription, 0);
                if (red != null)
                    return (FunctionOutputDescriptionSyntaxNode)red;

                return default(FunctionOutputDescriptionSyntaxNode);
            }
        }

        public CompoundNameSyntaxNode Name
        {
            get
            {
                var red = this.GetRed(ref this._name!, 1);
                if (red != null)
                    return (CompoundNameSyntaxNode)red;

                throw new System.Exception("name cannot be null");
            }
        }

        public FunctionInputDescriptionSyntaxNode? InputDescription
        {
            get
            {
                var red = this.GetRed(ref this._inputDescription, 2);
                if (red != null)
                    return (FunctionInputDescriptionSyntaxNode)red;

                return default(FunctionInputDescriptionSyntaxNode);
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 0: return GetRed(ref _outputDescription, 0);
                case 1: return GetRed(ref _name!, 1);
                case 2: return GetRed(ref _inputDescription, 2);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitAbstractMethodDeclaration(this);
        }

    }

    public class MethodsListSyntaxNode : SyntaxNode
    {
        private SyntaxNode? _attributes;
        private SyntaxNode? _methods;

        internal MethodsListSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken MethodsKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.MethodsListSyntaxNode)_green)._methodsKeyword, this.GetChildPosition(0)); }
        }

        public SyntaxToken EndKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.MethodsListSyntaxNode)_green)._endKeyword, this.GetChildPosition(3)); }
        }

        public AttributeListSyntaxNode? Attributes
        {
            get
            {
                var red = this.GetRed(ref this._attributes, 1);
                if (red != null)
                    return (AttributeListSyntaxNode)red;

                return default(AttributeListSyntaxNode);
            }
        }

        public SyntaxNodeOrTokenList Methods
        {
            get
            {
                var red = this.GetRed(ref this._methods!, 2);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("methods cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _attributes, 1);
                case 2: return GetRed(ref _methods!, 2);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitMethodsList(this);
        }

    }

    public class PropertiesListSyntaxNode : SyntaxNode
    {
        private SyntaxNode? _attributes;
        private SyntaxNode? _properties;

        internal PropertiesListSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken PropertiesKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.PropertiesListSyntaxNode)_green)._propertiesKeyword, this.GetChildPosition(0)); }
        }

        public SyntaxToken EndKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.PropertiesListSyntaxNode)_green)._endKeyword, this.GetChildPosition(3)); }
        }

        public AttributeListSyntaxNode? Attributes
        {
            get
            {
                var red = this.GetRed(ref this._attributes, 1);
                if (red != null)
                    return (AttributeListSyntaxNode)red;

                return default(AttributeListSyntaxNode);
            }
        }

        public SyntaxNodeOrTokenList Properties
        {
            get
            {
                var red = this.GetRed(ref this._properties!, 2);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("properties cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _attributes, 1);
                case 2: return GetRed(ref _properties!, 2);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitPropertiesList(this);
        }

    }

    public class BaseClassListSyntaxNode : SyntaxNode
    {
        private SyntaxNode? _baseClasses;

        internal BaseClassListSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken LessSign
        {
            get { return new SyntaxToken(this, ((Parser.Internal.BaseClassListSyntaxNode)_green)._lessSign, this.GetChildPosition(0)); }
        }

        public SyntaxNodeOrTokenList BaseClasses
        {
            get
            {
                var red = this.GetRed(ref this._baseClasses!, 1);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("baseClasses cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _baseClasses!, 1);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitBaseClassList(this);
        }

    }

    public class ClassDeclarationSyntaxNode : StatementSyntaxNode
    {
        private SyntaxNode? _attributes;
        private SyntaxNode? _className;
        private SyntaxNode? _baseClassList;
        private SyntaxNode? _nodes;

        internal ClassDeclarationSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken ClassdefKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.ClassDeclarationSyntaxNode)_green)._classdefKeyword, this.GetChildPosition(0)); }
        }

        public SyntaxToken EndKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.ClassDeclarationSyntaxNode)_green)._endKeyword, this.GetChildPosition(5)); }
        }

        public AttributeListSyntaxNode? Attributes
        {
            get
            {
                var red = this.GetRed(ref this._attributes, 1);
                if (red != null)
                    return (AttributeListSyntaxNode)red;

                return default(AttributeListSyntaxNode);
            }
        }

        public IdentifierNameSyntaxNode ClassName
        {
            get
            {
                var red = this.GetRed(ref this._className!, 2);
                if (red != null)
                    return (IdentifierNameSyntaxNode)red;

                throw new System.Exception("className cannot be null");
            }
        }

        public BaseClassListSyntaxNode? BaseClassList
        {
            get
            {
                var red = this.GetRed(ref this._baseClassList, 3);
                if (red != null)
                    return (BaseClassListSyntaxNode)red;

                return default(BaseClassListSyntaxNode);
            }
        }

        public SyntaxNodeOrTokenList Nodes
        {
            get
            {
                var red = this.GetRed(ref this._nodes!, 4);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("nodes cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _attributes, 1);
                case 2: return GetRed(ref _className!, 2);
                case 3: return GetRed(ref _baseClassList, 3);
                case 4: return GetRed(ref _nodes!, 4);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitClassDeclaration(this);
        }

    }

    public class EnumerationItemValueSyntaxNode : SyntaxNode
    {
        private SyntaxNode? _values;

        internal EnumerationItemValueSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken OpeningBracket
        {
            get { return new SyntaxToken(this, ((Parser.Internal.EnumerationItemValueSyntaxNode)_green)._openingBracket, this.GetChildPosition(0)); }
        }

        public SyntaxToken ClosingBracket
        {
            get { return new SyntaxToken(this, ((Parser.Internal.EnumerationItemValueSyntaxNode)_green)._closingBracket, this.GetChildPosition(2)); }
        }

        public SyntaxNodeOrTokenList Values
        {
            get
            {
                var red = this.GetRed(ref this._values!, 1);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("values cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _values!, 1);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitEnumerationItemValue(this);
        }

    }

    public class EnumerationItemSyntaxNode : SyntaxNode
    {
        private SyntaxNode? _name;
        private SyntaxNode? _values;
        private SyntaxNode? _commas;

        internal EnumerationItemSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }


        public IdentifierNameSyntaxNode Name
        {
            get
            {
                var red = this.GetRed(ref this._name!, 0);
                if (red != null)
                    return (IdentifierNameSyntaxNode)red;

                throw new System.Exception("name cannot be null");
            }
        }

        public EnumerationItemValueSyntaxNode? Values
        {
            get
            {
                var red = this.GetRed(ref this._values, 1);
                if (red != null)
                    return (EnumerationItemValueSyntaxNode)red;

                return default(EnumerationItemValueSyntaxNode);
            }
        }

        public SyntaxNodeOrTokenList Commas
        {
            get
            {
                var red = this.GetRed(ref this._commas!, 2);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("commas cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 0: return GetRed(ref _name!, 0);
                case 1: return GetRed(ref _values, 1);
                case 2: return GetRed(ref _commas!, 2);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitEnumerationItem(this);
        }

    }

    public class EnumerationListSyntaxNode : SyntaxNode
    {
        private SyntaxNode? _attributes;
        private SyntaxNode? _items;

        internal EnumerationListSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken EnumerationKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.EnumerationListSyntaxNode)_green)._enumerationKeyword, this.GetChildPosition(0)); }
        }

        public SyntaxToken EndKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.EnumerationListSyntaxNode)_green)._endKeyword, this.GetChildPosition(3)); }
        }

        public AttributeListSyntaxNode? Attributes
        {
            get
            {
                var red = this.GetRed(ref this._attributes, 1);
                if (red != null)
                    return (AttributeListSyntaxNode)red;

                return default(AttributeListSyntaxNode);
            }
        }

        public SyntaxNodeOrTokenList Items
        {
            get
            {
                var red = this.GetRed(ref this._items!, 2);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("items cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _attributes, 1);
                case 2: return GetRed(ref _items!, 2);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitEnumerationList(this);
        }

    }

    public class EventsListSyntaxNode : SyntaxNode
    {
        private SyntaxNode? _attributes;
        private SyntaxNode? _events;

        internal EventsListSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken EventsKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.EventsListSyntaxNode)_green)._eventsKeyword, this.GetChildPosition(0)); }
        }

        public SyntaxToken EndKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.EventsListSyntaxNode)_green)._endKeyword, this.GetChildPosition(3)); }
        }

        public AttributeListSyntaxNode? Attributes
        {
            get
            {
                var red = this.GetRed(ref this._attributes, 1);
                if (red != null)
                    return (AttributeListSyntaxNode)red;

                return default(AttributeListSyntaxNode);
            }
        }

        public SyntaxNodeOrTokenList Events
        {
            get
            {
                var red = this.GetRed(ref this._events!, 2);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                throw new System.Exception("events cannot be null");
            }
        }

        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _attributes, 1);
                case 2: return GetRed(ref _events!, 2);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitEventsList(this);
        }

    }

    public class EndKeywordSyntaxNode : SyntaxNode
    {

        internal EndKeywordSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken EndKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.EndKeywordSyntaxNode)_green)._endKeyword, this.GetChildPosition(0)); }
        }


        internal override SyntaxNode? GetNode(int i)
        {
            switch (i)
            {
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitEndKeyword(this);
        }

    }
}