// automatically generated

// ReSharper disable MemberCanBeProtected.Global
// ReSharper disable MemberCanBePrivate.Global
#pragma warning disable CS8603
#pragma warning disable CS8600
#pragma warning disable CS8509

using System.CodeDom.Compiler;
namespace meowlang.parser;

[GeneratedCode("meow-visitorgenerator", "1")]
public class MeowModelVisitor<T>
{

    public T? TryVisit(ModelBase? m)
    {
        return m == null ? default : Visit(m);
    }

    public T Visit(ModelBase m)
    {
        try {
            switch(m)
            {

                case ArrayAccessExpressionModel x: return VisitArrayAccessExpression(x);
                case ArrayConstructorExpressionModel x: return VisitArrayConstructorExpression(x);
                case ArrayTypeModel x: return VisitArrayType(x);
                case AssignmentExpressionModel x: return VisitAssignmentExpression(x);
                case AttributeModel x: return VisitAttribute(x);
                case BinaryOperationExpressionModel x: return VisitBinaryOperationExpression(x);
                case BlockExpressionModel x: return VisitBlockExpression(x);
                case BoolLiteralModel x: return VisitBoolLiteral(x);
                case BreakStatementModel x: return VisitBreakStatement(x);
                case CharacterLiteralModel x: return VisitCharacterLiteral(x);
                case ConstantDeclarationStatementModel x: return VisitConstantDeclarationStatement(x);
                case ConstraintDeclarationModel x: return VisitConstraintDeclaration(x);
                case ConstraintModel x: return VisitConstraint(x);
                case ContinueStatementModel x: return VisitContinueStatement(x);
                case EmbedConstraintRuleModel x: return VisitEmbedConstraintRule(x);
                case EnumConstructorExpressionModel x: return VisitEnumConstructorExpression(x);
                case EnumDeclarationModel x: return VisitEnumDeclaration(x);
                case EnumMemberModel x: return VisitEnumMember(x);
                case EnumTypeModel x: return VisitEnumType(x);
                case ExpressionStatementModel x: return VisitExpressionStatement(x);
                case ForLoopStatementModel x: return VisitForLoopStatement(x);
                case FunctionCallExpressionModel x: return VisitFunctionCallExpression(x);
                case FunctionConstraintRuleModel x: return VisitFunctionConstraintRule(x);
                case FunctionModel x: return VisitFunction(x);
                case FunctionParameterModel x: return VisitFunctionParameter(x);
                case IdentifierAttributeValueModel x: return VisitIdentifierAttributeValue(x);
                case IdentifierNameModel x: return VisitIdentifierName(x);
                case IfExpressionModel x: return VisitIfExpression(x);
                case ImportModel x: return VisitImport(x);
                case InfiniteLoopStatementModel x: return VisitInfiniteLoopStatement(x);
                case LiteralAttributeValueModel x: return VisitLiteralAttributeValue(x);
                case LiteralExpressionModel x: return VisitLiteralExpression(x);
                case Model x: return Visit(x);
                case NameExpressionModel x: return VisitNameExpression(x);
                case NumericLiteralModel x: return VisitNumericLiteral(x);
                case ParenthesisExpressionModel x: return VisitParenthesisExpression(x);
                case PatternModel x: return VisitPattern(x);
                case PointerDereferenceExpressionModel x: return VisitPointerDereferenceExpression(x);
                case PointerReferenceExpressionModel x: return VisitPointerReferenceExpression(x);
                case PointerTypeReferenceModel x: return VisitPointerTypeReference(x);
                case ReturnStatementModel x: return VisitReturnStatement(x);
                case SliceTypeModel x: return VisitSliceType(x);
                case StringLiteralModel x: return VisitStringLiteral(x);
                case StructAccessExpressionModel x: return VisitStructAccessExpression(x);
                case StructConstructorExpressionModel x: return VisitStructConstructorExpression(x);
                case StructConstructorMemberModel x: return VisitStructConstructorMember(x);
                case StructDeclarationModel x: return VisitStructDeclaration(x);
                case StructMemberModel x: return VisitStructMember(x);
                case StructTypeModel x: return VisitStructType(x);
                case SwitchExpressionModel x: return VisitSwitchExpression(x);
                case TopLevelStatementModel x: return VisitTopLevelStatement(x);
                case TupleConstructorExpressionModel x: return VisitTupleConstructorExpression(x);
                case TupleDeclarationModel x: return VisitTupleDeclaration(x);
                case TupleTypeModel x: return VisitTupleType(x);
                case TypeAliasModel x: return VisitTypeAlias(x);
                case TypeNameModel x: return VisitTypeName(x);
                case TypeParameterModel x: return VisitTypeParameter(x);
                case UnaryOperationExpressionModel x: return VisitUnaryOperationExpression(x);
                case VariableDeclarationStatementModel x: return VisitVariableDeclarationStatement(x);
                case WhileLoopStatementModel x: return VisitWhileLoopStatement(x);
            }
        } catch(Exception e)
        {
            if (e is MeowModelVisitorException) throw;
            throw new MeowModelVisitorException(m, e);
        }
        return default;
    }

    public virtual T VisitArrayAccessExpression(ArrayAccessExpressionModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitArrayConstructorExpression(ArrayConstructorExpressionModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitArrayType(ArrayTypeModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitAssignmentExpression(AssignmentExpressionModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitAttribute(AttributeModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitBinaryOperationExpression(BinaryOperationExpressionModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitBlockExpression(BlockExpressionModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitBoolLiteral(BoolLiteralModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitBreakStatement(BreakStatementModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitCharacterLiteral(CharacterLiteralModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitConstantDeclarationStatement(ConstantDeclarationStatementModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitConstraintDeclaration(ConstraintDeclarationModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitConstraint(ConstraintModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitContinueStatement(ContinueStatementModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitEmbedConstraintRule(EmbedConstraintRuleModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitEnumConstructorExpression(EnumConstructorExpressionModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitEnumDeclaration(EnumDeclarationModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitEnumMember(EnumMemberModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitEnumType(EnumTypeModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitExpressionStatement(ExpressionStatementModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitForLoopStatement(ForLoopStatementModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitFunctionCallExpression(FunctionCallExpressionModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitFunctionConstraintRule(FunctionConstraintRuleModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitFunction(FunctionModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitFunctionParameter(FunctionParameterModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitIdentifierAttributeValue(IdentifierAttributeValueModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitIdentifierName(IdentifierNameModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitIfExpression(IfExpressionModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitImport(ImportModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitInfiniteLoopStatement(InfiniteLoopStatementModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitLiteralAttributeValue(LiteralAttributeValueModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitLiteralExpression(LiteralExpressionModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T Visit(Model m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitNameExpression(NameExpressionModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitNumericLiteral(NumericLiteralModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitParenthesisExpression(ParenthesisExpressionModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitPattern(PatternModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitPointerDereferenceExpression(PointerDereferenceExpressionModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitPointerReferenceExpression(PointerReferenceExpressionModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitPointerTypeReference(PointerTypeReferenceModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitReturnStatement(ReturnStatementModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitSliceType(SliceTypeModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitStringLiteral(StringLiteralModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitStructAccessExpression(StructAccessExpressionModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitStructConstructorExpression(StructConstructorExpressionModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitStructConstructorMember(StructConstructorMemberModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitStructDeclaration(StructDeclarationModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitStructMember(StructMemberModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitStructType(StructTypeModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitSwitchExpression(SwitchExpressionModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitTopLevelStatement(TopLevelStatementModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitTupleConstructorExpression(TupleConstructorExpressionModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitTupleDeclaration(TupleDeclarationModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitTupleType(TupleTypeModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitTypeAlias(TypeAliasModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitTypeName(TypeNameModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitTypeParameter(TypeParameterModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitUnaryOperationExpression(UnaryOperationExpressionModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitVariableDeclarationStatement(VariableDeclarationStatementModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

    public virtual T VisitWhileLoopStatement(WhileLoopStatementModel m)
    {
        T result = default;
        foreach (var modelBase in m.GetChildren())
        {
            result = Visit(modelBase);
        }

        return result;
    }

}

[GeneratedCode("meow-visitorgenerator", "1")]
public class MeowModelVisitor
{
    public void Visit(ModelBase m)
    {
        try {
            switch(m)
            {

                case ArrayAccessExpressionModel x: VisitArrayAccessExpression(x); break;
                case ArrayConstructorExpressionModel x: VisitArrayConstructorExpression(x); break;
                case ArrayTypeModel x: VisitArrayType(x); break;
                case AssignmentExpressionModel x: VisitAssignmentExpression(x); break;
                case AttributeModel x: VisitAttribute(x); break;
                case BinaryOperationExpressionModel x: VisitBinaryOperationExpression(x); break;
                case BlockExpressionModel x: VisitBlockExpression(x); break;
                case BoolLiteralModel x: VisitBoolLiteral(x); break;
                case BreakStatementModel x: VisitBreakStatement(x); break;
                case CharacterLiteralModel x: VisitCharacterLiteral(x); break;
                case ConstantDeclarationStatementModel x: VisitConstantDeclarationStatement(x); break;
                case ConstraintDeclarationModel x: VisitConstraintDeclaration(x); break;
                case ConstraintModel x: VisitConstraint(x); break;
                case ContinueStatementModel x: VisitContinueStatement(x); break;
                case EmbedConstraintRuleModel x: VisitEmbedConstraintRule(x); break;
                case EnumConstructorExpressionModel x: VisitEnumConstructorExpression(x); break;
                case EnumDeclarationModel x: VisitEnumDeclaration(x); break;
                case EnumMemberModel x: VisitEnumMember(x); break;
                case EnumTypeModel x: VisitEnumType(x); break;
                case ExpressionStatementModel x: VisitExpressionStatement(x); break;
                case ForLoopStatementModel x: VisitForLoopStatement(x); break;
                case FunctionCallExpressionModel x: VisitFunctionCallExpression(x); break;
                case FunctionConstraintRuleModel x: VisitFunctionConstraintRule(x); break;
                case FunctionModel x: VisitFunction(x); break;
                case FunctionParameterModel x: VisitFunctionParameter(x); break;
                case IdentifierAttributeValueModel x: VisitIdentifierAttributeValue(x); break;
                case IdentifierNameModel x: VisitIdentifierName(x); break;
                case IfExpressionModel x: VisitIfExpression(x); break;
                case ImportModel x: VisitImport(x); break;
                case InfiniteLoopStatementModel x: VisitInfiniteLoopStatement(x); break;
                case LiteralAttributeValueModel x: VisitLiteralAttributeValue(x); break;
                case LiteralExpressionModel x: VisitLiteralExpression(x); break;
                case Model x: Visit(x); break;
                case NameExpressionModel x: VisitNameExpression(x); break;
                case NumericLiteralModel x: VisitNumericLiteral(x); break;
                case ParenthesisExpressionModel x: VisitParenthesisExpression(x); break;
                case PatternModel x: VisitPattern(x); break;
                case PointerDereferenceExpressionModel x: VisitPointerDereferenceExpression(x); break;
                case PointerReferenceExpressionModel x: VisitPointerReferenceExpression(x); break;
                case PointerTypeReferenceModel x: VisitPointerTypeReference(x); break;
                case ReturnStatementModel x: VisitReturnStatement(x); break;
                case SliceTypeModel x: VisitSliceType(x); break;
                case StringLiteralModel x: VisitStringLiteral(x); break;
                case StructAccessExpressionModel x: VisitStructAccessExpression(x); break;
                case StructConstructorExpressionModel x: VisitStructConstructorExpression(x); break;
                case StructConstructorMemberModel x: VisitStructConstructorMember(x); break;
                case StructDeclarationModel x: VisitStructDeclaration(x); break;
                case StructMemberModel x: VisitStructMember(x); break;
                case StructTypeModel x: VisitStructType(x); break;
                case SwitchExpressionModel x: VisitSwitchExpression(x); break;
                case TopLevelStatementModel x: VisitTopLevelStatement(x); break;
                case TupleConstructorExpressionModel x: VisitTupleConstructorExpression(x); break;
                case TupleDeclarationModel x: VisitTupleDeclaration(x); break;
                case TupleTypeModel x: VisitTupleType(x); break;
                case TypeAliasModel x: VisitTypeAlias(x); break;
                case TypeNameModel x: VisitTypeName(x); break;
                case TypeParameterModel x: VisitTypeParameter(x); break;
                case UnaryOperationExpressionModel x: VisitUnaryOperationExpression(x); break;
                case VariableDeclarationStatementModel x: VisitVariableDeclarationStatement(x); break;
                case WhileLoopStatementModel x: VisitWhileLoopStatement(x); break;
            }
        } catch(Exception e) {
            throw new MeowModelVisitorException(m, e);
        }
    }

    public virtual void VisitArrayAccessExpression(ArrayAccessExpressionModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitArrayConstructorExpression(ArrayConstructorExpressionModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitArrayType(ArrayTypeModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitAssignmentExpression(AssignmentExpressionModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitAttribute(AttributeModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitBinaryOperationExpression(BinaryOperationExpressionModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitBlockExpression(BlockExpressionModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitBoolLiteral(BoolLiteralModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitBreakStatement(BreakStatementModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitCharacterLiteral(CharacterLiteralModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitConstantDeclarationStatement(ConstantDeclarationStatementModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitConstraintDeclaration(ConstraintDeclarationModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitConstraint(ConstraintModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitContinueStatement(ContinueStatementModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitEmbedConstraintRule(EmbedConstraintRuleModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitEnumConstructorExpression(EnumConstructorExpressionModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitEnumDeclaration(EnumDeclarationModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitEnumMember(EnumMemberModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitEnumType(EnumTypeModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitExpressionStatement(ExpressionStatementModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitForLoopStatement(ForLoopStatementModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitFunctionCallExpression(FunctionCallExpressionModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitFunctionConstraintRule(FunctionConstraintRuleModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitFunction(FunctionModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitFunctionParameter(FunctionParameterModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitIdentifierAttributeValue(IdentifierAttributeValueModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitIdentifierName(IdentifierNameModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitIfExpression(IfExpressionModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitImport(ImportModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitInfiniteLoopStatement(InfiniteLoopStatementModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitLiteralAttributeValue(LiteralAttributeValueModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitLiteralExpression(LiteralExpressionModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void Visit(Model m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitNameExpression(NameExpressionModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitNumericLiteral(NumericLiteralModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitParenthesisExpression(ParenthesisExpressionModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitPattern(PatternModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitPointerDereferenceExpression(PointerDereferenceExpressionModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitPointerReferenceExpression(PointerReferenceExpressionModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitPointerTypeReference(PointerTypeReferenceModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitReturnStatement(ReturnStatementModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitSliceType(SliceTypeModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitStringLiteral(StringLiteralModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitStructAccessExpression(StructAccessExpressionModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitStructConstructorExpression(StructConstructorExpressionModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitStructConstructorMember(StructConstructorMemberModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitStructDeclaration(StructDeclarationModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitStructMember(StructMemberModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitStructType(StructTypeModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitSwitchExpression(SwitchExpressionModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitTopLevelStatement(TopLevelStatementModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitTupleConstructorExpression(TupleConstructorExpressionModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitTupleDeclaration(TupleDeclarationModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitTupleType(TupleTypeModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitTypeAlias(TypeAliasModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitTypeName(TypeNameModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitTypeParameter(TypeParameterModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitUnaryOperationExpression(UnaryOperationExpressionModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitVariableDeclarationStatement(VariableDeclarationStatementModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

    public virtual void VisitWhileLoopStatement(WhileLoopStatementModel m)
    {
        foreach (var modelBase in m.GetChildren())
        {
            Visit(modelBase);
        }
    }

}