text:
using System;
using System.Runtime.InteropServices;
using System.Security;

namespace CppSharp
{
    namespace Parser
    {
        namespace AST
        {
            public enum TypeKind
            {
                Tag = 0,
                Array = 1,
                Function = 2,
                Pointer = 3,
                MemberPointer = 4,
                Typedef = 5,
                Attributed = 6,
                Decayed = 7,
                TemplateSpecialization = 8,
                TemplateParameter = 9,
                TemplateParameterSubstitution = 10,
                InjectedClassName = 11,
                DependentName = 12,
                PackExpansion = 13,
                Builtin = 14
            }

            public enum DeclarationKind
            {
                DeclarationContext = 0,
                Typedef = 1,
                Parameter = 2,
                Function = 3,
                Method = 4,
                Enumeration = 5,
                EnumerationItem = 6,
                Variable = 7,
                Field = 8,
                AccessSpecifier = 9,
                Class = 10,
                Template = 11,
                ClassTemplate = 12,
                ClassTemplateSpecialization = 13,
                ClassTemplatePartialSpecialization = 14,
                FunctionTemplate = 15,
                Namespace = 16,
                PreprocessedEntity = 17,
                MacroDefinition = 18,
                MacroExpansion = 19,
                TranslationUnit = 20,
                Friend = 21
            }

            public enum AccessSpecifier
            {
                Private = 0,
                Protected = 1,
                Public = 2
            }

            public enum CXXMethodKind
            {
                Normal = 0,
                Constructor = 1,
                Destructor = 2,
                Conversion = 3,
                Operator = 4,
                UsingDirective = 5
            }

            public enum CXXOperatorKind
            {
                None = 0,
                New = 1,
                Delete = 2,
                Array_New = 3,
                Array_Delete = 4,
                Plus = 5,
                Minus = 6,
                Star = 7,
                Slash = 8,
                Percent = 9,
                Caret = 10,
                Amp = 11,
                Pipe = 12,
                Tilde = 13,
                Exclaim = 14,
                Equal = 15,
                Less = 16,
                Greater = 17,
                PlusEqual = 18,
                MinusEqual = 19,
                StarEqual = 20,
                SlashEqual = 21,
                PercentEqual = 22,
                CaretEqual = 23,
                AmpEqual = 24,
                PipeEqual = 25,
                LessLess = 26,
                GreaterGreater = 27,
                LessLessEqual = 28,
                GreaterGreaterEqual = 29,
                EqualEqual = 30,
                ExclaimEqual = 31,
                LessEqual = 32,
                GreaterEqual = 33,
                AmpAmp = 34,
                PipePipe = 35,
                PlusPlus = 36,
                MinusMinus = 37,
                Comma = 38,
                ArrowStar = 39,
                Arrow = 40,
                Call = 41,
                Subscript = 42,
                Conditional = 43
            }

            public enum CallingConvention
            {
                Default = 0,
                C = 1,
                StdCall = 2,
                ThisCall = 3,
                FastCall = 4,
                Unknown = 5
            }

            public enum StatementClass
            {
                Any = 0,
                BinaryOperator = 1,
                DeclRefExprClass = 2,
                CXXConstructExprClass = 3,
                CXXOperatorCallExpr = 4,
                ImplicitCastExpr = 5,
                ExplicitCastExpr = 6
            }

            public enum TemplateSpecializationKind
            {
                Undeclared = 0,
                ImplicitInstantiation = 1,
                ExplicitSpecialization = 2,
                ExplicitInstantiationDeclaration = 3,
                ExplicitInstantiationDefinition = 4
            }

            public enum CppAbi
            {
                Itanium = 0,
                Microsoft = 1,
                ARM = 2,
                iOS = 3,
                iOS64 = 4
            }

            public enum VTableComponentKind
            {
                VCallOffset = 0,
                VBaseOffset = 1,
                OffsetToTop = 2,
                RTTI = 3,
                FunctionPointer = 4,
                CompleteDtorPointer = 5,
                DeletingDtorPointer = 6,
                UnusedFunctionPointer = 7
            }

            public enum PrimitiveType
            {
                Null = 0,
                Void = 1,
                Bool = 2,
                WideChar = 3,
                Char = 4,
                UChar = 5,
                Short = 6,
                UShort = 7,
                Int = 8,
                UInt = 9,
                Long = 10,
                ULong = 11,
                LongLong = 12,
                ULongLong = 13,
                Float = 14,
                Double = 15,
                IntPtr = 16
            }

            public enum RawCommentKind
            {
                Invalid = 0,
                OrdinaryBCPL = 1,
                OrdinaryC = 2,
                BCPLSlash = 3,
                BCPLExcl = 4,
                JavaDoc = 5,
                Qt = 6,
                Merged = 7
            }

            public enum CommentKind
            {
                FullComment = 0
            }

            public enum MacroLocation
            {
                Unknown = 0,
                ClassHead = 1,
                ClassBody = 2,
                FunctionHead = 3,
                FunctionParameters = 4,
                FunctionBody = 5
            }

            public enum ArchType
            {
                UnknownArch = 0,
                x86 = 1,
                x86_64 = 2
            }

            public unsafe partial class Type : IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 8)]
                public partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.TypeKind Kind;

                    [FieldOffset(4)]
                    public bool IsDependent;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST4TypeC2ENS1_8TypeKindE")]
                    internal static extern void ctor_0(global::System.IntPtr instance, CppSharp.Parser.AST.TypeKind kind);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST4TypeC2ERKS2_")]
                    internal static extern void cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                public global::System.IntPtr __Instance { get; protected set; }

                private readonly bool __ownsNativeInstance;

                public static Type __CreateInstance(global::System.IntPtr native)
                {
                    return new Type((Type.Internal*) native);
                }

                public static Type __CreateInstance(Type.Internal native)
                {
                    return new Type(native);
                }

                private static Type.Internal* __CopyValue(Type.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(8);
                    CppSharp.Parser.AST.Type.Internal.cctor_1(ret, new global::System.IntPtr(&native));
                    return (Type.Internal*) ret;
                }

                private Type(Type.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected Type(Type.Internal* native, bool isInternalImpl = false)
                {
                    __Instance = new global::System.IntPtr(native);
                }

                public Type(CppSharp.Parser.AST.TypeKind kind)
                {
                    __Instance = Marshal.AllocHGlobal(8);
                    __ownsNativeInstance = true;
                    var arg0 = kind;
                    Internal.ctor_0(__Instance, arg0);
                }

                public void Dispose()
                {
                    Dispose(disposing: true);
                    GC.SuppressFinalize(this);
                }

                protected virtual void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                }

                public CppSharp.Parser.AST.TypeKind Kind
                {
                    get
                    {
                        return ((Internal*) __Instance)->Kind;
                    }

                    set
                    {
                        ((Internal*) __Instance)->Kind = value;
                    }
                }

                public bool IsDependent
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsDependent;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsDependent = value;
                    }
                }
            }

            public unsafe partial class TypeQualifiers : IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 3)]
                public partial struct Internal
                {
                    [FieldOffset(0)]
                    public bool IsConst;

                    [FieldOffset(1)]
                    public bool IsVolatile;

                    [FieldOffset(2)]
                    public bool IsRestrict;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST14TypeQualifiersC2ERKS2_")]
                    internal static extern void cctor_0(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                public global::System.IntPtr __Instance { get; protected set; }

                private readonly bool __ownsNativeInstance;

                public static TypeQualifiers __CreateInstance(global::System.IntPtr native)
                {
                    return new TypeQualifiers((TypeQualifiers.Internal*) native);
                }

                public static TypeQualifiers __CreateInstance(TypeQualifiers.Internal native)
                {
                    return new TypeQualifiers(native);
                }

                private static TypeQualifiers.Internal* __CopyValue(TypeQualifiers.Internal native)
                {
                    var ret = (TypeQualifiers.Internal*) Marshal.AllocHGlobal(3);
                    *ret = native;
                    return ret;
                }

                private TypeQualifiers(TypeQualifiers.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected TypeQualifiers(TypeQualifiers.Internal* native, bool isInternalImpl = false)
                {
                    __Instance = new global::System.IntPtr(native);
                }

                public TypeQualifiers()
                {
                    __Instance = Marshal.AllocHGlobal(3);
                    __ownsNativeInstance = true;
                }

                public void Dispose()
                {
                    Dispose(disposing: true);
                    GC.SuppressFinalize(this);
                }

                protected virtual void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                }

                public bool IsConst
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsConst;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsConst = value;
                    }
                }

                public bool IsVolatile
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsVolatile;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsVolatile = value;
                    }
                }

                public bool IsRestrict
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsRestrict;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsRestrict = value;
                    }
                }
            }

            public unsafe partial class QualifiedType : IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 16)]
                public partial struct Internal
                {
                    [FieldOffset(0)]
                    public global::System.IntPtr Type;

                    [FieldOffset(8)]
                    public CppSharp.Parser.AST.TypeQualifiers.Internal Qualifiers;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST13QualifiedTypeC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST13QualifiedTypeC2ERKS2_")]
                    internal static extern void cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                public global::System.IntPtr __Instance { get; protected set; }

                private readonly bool __ownsNativeInstance;

                public static QualifiedType __CreateInstance(global::System.IntPtr native)
                {
                    return new QualifiedType((QualifiedType.Internal*) native);
                }

                public static QualifiedType __CreateInstance(QualifiedType.Internal native)
                {
                    return new QualifiedType(native);
                }

                private static QualifiedType.Internal* __CopyValue(QualifiedType.Internal native)
                {
                    var ret = (QualifiedType.Internal*) Marshal.AllocHGlobal(16);
                    *ret = native;
                    return ret;
                }

                private QualifiedType(QualifiedType.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected QualifiedType(QualifiedType.Internal* native, bool isInternalImpl = false)
                {
                    __Instance = new global::System.IntPtr(native);
                }

                public QualifiedType()
                {
                    __Instance = Marshal.AllocHGlobal(16);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                public void Dispose()
                {
                    Dispose(disposing: true);
                    GC.SuppressFinalize(this);
                }

                protected virtual void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                }

                public CppSharp.Parser.AST.Type Type
                {
                    get
                    {
                        return (((Internal*) __Instance)->Type == IntPtr.Zero) ? null : CppSharp.Parser.AST.Type.__CreateInstance(((Internal*) __Instance)->Type);
                    }

                    set
                    {
                        ((Internal*) __Instance)->Type = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
                    }
                }

                public CppSharp.Parser.AST.TypeQualifiers Qualifiers
                {
                    get
                    {
                        return CppSharp.Parser.AST.TypeQualifiers.__CreateInstance(((Internal*) __Instance)->Qualifiers);
                    }

                    set
                    {
                        ((Internal*) __Instance)->Qualifiers = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.TypeQualifiers.Internal() : *(CppSharp.Parser.AST.TypeQualifiers.Internal*) (value.__Instance);
                    }
                }
            }

            public unsafe partial class TagType : CppSharp.Parser.AST.Type, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 16)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.TypeKind Kind;

                    [FieldOffset(4)]
                    public bool IsDependent;

                    [FieldOffset(8)]
                    public global::System.IntPtr Declaration;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST7TagTypeC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST7TagTypeC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                private readonly bool __ownsNativeInstance;

                public static new TagType __CreateInstance(global::System.IntPtr native)
                {
                    return new TagType((TagType.Internal*) native);
                }

                public static TagType __CreateInstance(TagType.Internal native)
                {
                    return new TagType(native);
                }

                private static TagType.Internal* __CopyValue(TagType.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(16);
                    CppSharp.Parser.AST.TagType.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (TagType.Internal*) ret;
                }

                private TagType(TagType.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected TagType(TagType.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.Type.Internal*) native)
                {
                }

                public TagType()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(16);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.Declaration Declaration
                {
                    get
                    {
                        return (((Internal*) __Instance)->Declaration == IntPtr.Zero) ? null : CppSharp.Parser.AST.Declaration.__CreateInstance(((Internal*) __Instance)->Declaration);
                    }

                    set
                    {
                        ((Internal*) __Instance)->Declaration = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
                    }
                }
            }

            public unsafe partial class ArrayType : CppSharp.Parser.AST.Type, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 40)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.TypeKind Kind;

                    [FieldOffset(4)]
                    public bool IsDependent;

                    [FieldOffset(8)]
                    public CppSharp.Parser.AST.QualifiedType.Internal QualifiedType;

                    [FieldOffset(24)]
                    public CppSharp.Parser.AST.ArrayType.ArraySize SizeType;

                    [FieldOffset(32)]
                    public long Size;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST9ArrayTypeC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST9ArrayTypeC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                public enum ArraySize
                {
                    Constant = 0,
                    Variable = 1,
                    Dependent = 2,
                    Incomplete = 3
                }

                private readonly bool __ownsNativeInstance;

                public static new ArrayType __CreateInstance(global::System.IntPtr native)
                {
                    return new ArrayType((ArrayType.Internal*) native);
                }

                public static ArrayType __CreateInstance(ArrayType.Internal native)
                {
                    return new ArrayType(native);
                }

                private static ArrayType.Internal* __CopyValue(ArrayType.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(40);
                    CppSharp.Parser.AST.ArrayType.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (ArrayType.Internal*) ret;
                }

                private ArrayType(ArrayType.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected ArrayType(ArrayType.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.Type.Internal*) native)
                {
                }

                public ArrayType()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(40);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.QualifiedType QualifiedType
                {
                    get
                    {
                        return CppSharp.Parser.AST.QualifiedType.__CreateInstance(((Internal*) __Instance)->QualifiedType);
                    }

                    set
                    {
                        ((Internal*) __Instance)->QualifiedType = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance);
                    }
                }

                public CppSharp.Parser.AST.ArrayType.ArraySize SizeType
                {
                    get
                    {
                        return ((Internal*) __Instance)->SizeType;
                    }

                    set
                    {
                        ((Internal*) __Instance)->SizeType = value;
                    }
                }

                public long Size
                {
                    get
                    {
                        return ((Internal*) __Instance)->Size;
                    }

                    set
                    {
                        ((Internal*) __Instance)->Size = value;
                    }
                }
            }

            public unsafe partial class FunctionType : CppSharp.Parser.AST.Type, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 56)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.TypeKind Kind;

                    [FieldOffset(4)]
                    public bool IsDependent;

                    [FieldOffset(8)]
                    public CppSharp.Parser.AST.QualifiedType.Internal ReturnType;

                    [FieldOffset(24)]
                    public CppSharp.Parser.AST.CallingConvention CallingConvention;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST12FunctionTypeC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST12FunctionTypeC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST12FunctionTypeD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST12FunctionType13getParametersEj")]
                    internal static extern global::System.IntPtr getParameters_0(global::System.IntPtr instance, uint i);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST12FunctionType13addParametersERPNS1_9ParameterE")]
                    internal static extern void addParameters_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST12FunctionType15clearParametersEv")]
                    internal static extern void clearParameters_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST12FunctionType18getParametersCountEv")]
                    internal static extern uint getParametersCount_0(global::System.IntPtr instance);
                }

                private readonly bool __ownsNativeInstance;

                public static new FunctionType __CreateInstance(global::System.IntPtr native)
                {
                    return new FunctionType((FunctionType.Internal*) native);
                }

                public static FunctionType __CreateInstance(FunctionType.Internal native)
                {
                    return new FunctionType(native);
                }

                private static FunctionType.Internal* __CopyValue(FunctionType.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(56);
                    CppSharp.Parser.AST.FunctionType.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (FunctionType.Internal*) ret;
                }

                private FunctionType(FunctionType.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected FunctionType(FunctionType.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.Type.Internal*) native)
                {
                }

                public FunctionType()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(56);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.Parameter getParameters(uint i)
                {
                    var __ret = Internal.getParameters_0(__Instance, i);
                    if (__ret == global::System.IntPtr.Zero) return null;
                    return (__ret == IntPtr.Zero) ? null : CppSharp.Parser.AST.Parameter.__CreateInstance(__ret);
                }

                public void addParameters(CppSharp.Parser.AST.Parameter s)
                {
                    var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance;
                    Internal.addParameters_0(__Instance, arg0);
                }

                public void clearParameters()
                {
                    Internal.clearParameters_0(__Instance);
                }

                public uint ParametersCount
                {
                    get
                    {
                        var __ret = Internal.getParametersCount_0(__Instance);
                        return __ret;
                    }
                }

                public CppSharp.Parser.AST.QualifiedType ReturnType
                {
                    get
                    {
                        return CppSharp.Parser.AST.QualifiedType.__CreateInstance(((Internal*) __Instance)->ReturnType);
                    }

                    set
                    {
                        ((Internal*) __Instance)->ReturnType = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance);
                    }
                }

                public CppSharp.Parser.AST.CallingConvention CallingConvention
                {
                    get
                    {
                        return ((Internal*) __Instance)->CallingConvention;
                    }

                    set
                    {
                        ((Internal*) __Instance)->CallingConvention = value;
                    }
                }
            }

            public unsafe partial class PointerType : CppSharp.Parser.AST.Type, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 32)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.TypeKind Kind;

                    [FieldOffset(4)]
                    public bool IsDependent;

                    [FieldOffset(8)]
                    public CppSharp.Parser.AST.QualifiedType.Internal QualifiedPointee;

                    [FieldOffset(24)]
                    public CppSharp.Parser.AST.PointerType.TypeModifier Modifier;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11PointerTypeC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11PointerTypeC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                public enum TypeModifier
                {
                    Value = 0,
                    Pointer = 1,
                    LVReference = 2,
                    RVReference = 3
                }

                private readonly bool __ownsNativeInstance;

                public static new PointerType __CreateInstance(global::System.IntPtr native)
                {
                    return new PointerType((PointerType.Internal*) native);
                }

                public static PointerType __CreateInstance(PointerType.Internal native)
                {
                    return new PointerType(native);
                }

                private static PointerType.Internal* __CopyValue(PointerType.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(32);
                    CppSharp.Parser.AST.PointerType.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (PointerType.Internal*) ret;
                }

                private PointerType(PointerType.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected PointerType(PointerType.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.Type.Internal*) native)
                {
                }

                public PointerType()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(32);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.QualifiedType QualifiedPointee
                {
                    get
                    {
                        return CppSharp.Parser.AST.QualifiedType.__CreateInstance(((Internal*) __Instance)->QualifiedPointee);
                    }

                    set
                    {
                        ((Internal*) __Instance)->QualifiedPointee = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance);
                    }
                }

                public CppSharp.Parser.AST.PointerType.TypeModifier Modifier
                {
                    get
                    {
                        return ((Internal*) __Instance)->Modifier;
                    }

                    set
                    {
                        ((Internal*) __Instance)->Modifier = value;
                    }
                }
            }

            public unsafe partial class MemberPointerType : CppSharp.Parser.AST.Type, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 24)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.TypeKind Kind;

                    [FieldOffset(4)]
                    public bool IsDependent;

                    [FieldOffset(8)]
                    public CppSharp.Parser.AST.QualifiedType.Internal Pointee;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST17MemberPointerTypeC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST17MemberPointerTypeC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                private readonly bool __ownsNativeInstance;

                public static new MemberPointerType __CreateInstance(global::System.IntPtr native)
                {
                    return new MemberPointerType((MemberPointerType.Internal*) native);
                }

                public static MemberPointerType __CreateInstance(MemberPointerType.Internal native)
                {
                    return new MemberPointerType(native);
                }

                private static MemberPointerType.Internal* __CopyValue(MemberPointerType.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(24);
                    CppSharp.Parser.AST.MemberPointerType.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (MemberPointerType.Internal*) ret;
                }

                private MemberPointerType(MemberPointerType.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected MemberPointerType(MemberPointerType.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.Type.Internal*) native)
                {
                }

                public MemberPointerType()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(24);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.QualifiedType Pointee
                {
                    get
                    {
                        return CppSharp.Parser.AST.QualifiedType.__CreateInstance(((Internal*) __Instance)->Pointee);
                    }

                    set
                    {
                        ((Internal*) __Instance)->Pointee = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance);
                    }
                }
            }

            public unsafe partial class TypedefType : CppSharp.Parser.AST.Type, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 16)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.TypeKind Kind;

                    [FieldOffset(4)]
                    public bool IsDependent;

                    [FieldOffset(8)]
                    public global::System.IntPtr Declaration;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11TypedefTypeC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11TypedefTypeC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                private readonly bool __ownsNativeInstance;

                public static new TypedefType __CreateInstance(global::System.IntPtr native)
                {
                    return new TypedefType((TypedefType.Internal*) native);
                }

                public static TypedefType __CreateInstance(TypedefType.Internal native)
                {
                    return new TypedefType(native);
                }

                private static TypedefType.Internal* __CopyValue(TypedefType.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(16);
                    CppSharp.Parser.AST.TypedefType.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (TypedefType.Internal*) ret;
                }

                private TypedefType(TypedefType.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected TypedefType(TypedefType.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.Type.Internal*) native)
                {
                }

                public TypedefType()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(16);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.TypedefDecl Declaration
                {
                    get
                    {
                        return (((Internal*) __Instance)->Declaration == IntPtr.Zero) ? null : CppSharp.Parser.AST.TypedefDecl.__CreateInstance(((Internal*) __Instance)->Declaration);
                    }

                    set
                    {
                        ((Internal*) __Instance)->Declaration = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
                    }
                }
            }

            public unsafe partial class AttributedType : CppSharp.Parser.AST.Type, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 40)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.TypeKind Kind;

                    [FieldOffset(4)]
                    public bool IsDependent;

                    [FieldOffset(8)]
                    public CppSharp.Parser.AST.QualifiedType.Internal Modified;

                    [FieldOffset(24)]
                    public CppSharp.Parser.AST.QualifiedType.Internal Equivalent;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST14AttributedTypeC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST14AttributedTypeC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                private readonly bool __ownsNativeInstance;

                public static new AttributedType __CreateInstance(global::System.IntPtr native)
                {
                    return new AttributedType((AttributedType.Internal*) native);
                }

                public static AttributedType __CreateInstance(AttributedType.Internal native)
                {
                    return new AttributedType(native);
                }

                private static AttributedType.Internal* __CopyValue(AttributedType.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(40);
                    CppSharp.Parser.AST.AttributedType.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (AttributedType.Internal*) ret;
                }

                private AttributedType(AttributedType.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected AttributedType(AttributedType.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.Type.Internal*) native)
                {
                }

                public AttributedType()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(40);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.QualifiedType Modified
                {
                    get
                    {
                        return CppSharp.Parser.AST.QualifiedType.__CreateInstance(((Internal*) __Instance)->Modified);
                    }

                    set
                    {
                        ((Internal*) __Instance)->Modified = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance);
                    }
                }

                public CppSharp.Parser.AST.QualifiedType Equivalent
                {
                    get
                    {
                        return CppSharp.Parser.AST.QualifiedType.__CreateInstance(((Internal*) __Instance)->Equivalent);
                    }

                    set
                    {
                        ((Internal*) __Instance)->Equivalent = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance);
                    }
                }
            }

            public unsafe partial class DecayedType : CppSharp.Parser.AST.Type, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 56)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.TypeKind Kind;

                    [FieldOffset(4)]
                    public bool IsDependent;

                    [FieldOffset(8)]
                    public CppSharp.Parser.AST.QualifiedType.Internal Decayed;

                    [FieldOffset(24)]
                    public CppSharp.Parser.AST.QualifiedType.Internal Original;

                    [FieldOffset(40)]
                    public CppSharp.Parser.AST.QualifiedType.Internal Pointee;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11DecayedTypeC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11DecayedTypeC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                private readonly bool __ownsNativeInstance;

                public static new DecayedType __CreateInstance(global::System.IntPtr native)
                {
                    return new DecayedType((DecayedType.Internal*) native);
                }

                public static DecayedType __CreateInstance(DecayedType.Internal native)
                {
                    return new DecayedType(native);
                }

                private static DecayedType.Internal* __CopyValue(DecayedType.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(56);
                    CppSharp.Parser.AST.DecayedType.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (DecayedType.Internal*) ret;
                }

                private DecayedType(DecayedType.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected DecayedType(DecayedType.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.Type.Internal*) native)
                {
                }

                public DecayedType()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(56);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.QualifiedType Decayed
                {
                    get
                    {
                        return CppSharp.Parser.AST.QualifiedType.__CreateInstance(((Internal*) __Instance)->Decayed);
                    }

                    set
                    {
                        ((Internal*) __Instance)->Decayed = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance);
                    }
                }

                public CppSharp.Parser.AST.QualifiedType Original
                {
                    get
                    {
                        return CppSharp.Parser.AST.QualifiedType.__CreateInstance(((Internal*) __Instance)->Original);
                    }

                    set
                    {
                        ((Internal*) __Instance)->Original = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance);
                    }
                }

                public CppSharp.Parser.AST.QualifiedType Pointee
                {
                    get
                    {
                        return CppSharp.Parser.AST.QualifiedType.__CreateInstance(((Internal*) __Instance)->Pointee);
                    }

                    set
                    {
                        ((Internal*) __Instance)->Pointee = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance);
                    }
                }
            }

            public unsafe partial class TemplateArgument : IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 40)]
                public partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.TemplateArgument.ArgumentKind Kind;

                    [FieldOffset(8)]
                    public CppSharp.Parser.AST.QualifiedType.Internal Type;

                    [FieldOffset(24)]
                    public global::System.IntPtr Declaration;

                    [FieldOffset(32)]
                    public long Integral;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST16TemplateArgumentC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST16TemplateArgumentC2ERKS2_")]
                    internal static extern void cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                public enum ArgumentKind
                {
                    Type = 0,
                    Declaration = 1,
                    NullPtr = 2,
                    Integral = 3,
                    Template = 4,
                    TemplateExpansion = 5,
                    Expression = 6,
                    Pack = 7
                }

                public global::System.IntPtr __Instance { get; protected set; }

                private readonly bool __ownsNativeInstance;

                public static TemplateArgument __CreateInstance(global::System.IntPtr native)
                {
                    return new TemplateArgument((TemplateArgument.Internal*) native);
                }

                public static TemplateArgument __CreateInstance(TemplateArgument.Internal native)
                {
                    return new TemplateArgument(native);
                }

                private static TemplateArgument.Internal* __CopyValue(TemplateArgument.Internal native)
                {
                    var ret = (TemplateArgument.Internal*) Marshal.AllocHGlobal(40);
                    *ret = native;
                    return ret;
                }

                private TemplateArgument(TemplateArgument.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected TemplateArgument(TemplateArgument.Internal* native, bool isInternalImpl = false)
                {
                    __Instance = new global::System.IntPtr(native);
                }

                public TemplateArgument()
                {
                    __Instance = Marshal.AllocHGlobal(40);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                public void Dispose()
                {
                    Dispose(disposing: true);
                    GC.SuppressFinalize(this);
                }

                protected virtual void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                }

                public CppSharp.Parser.AST.TemplateArgument.ArgumentKind Kind
                {
                    get
                    {
                        return ((Internal*) __Instance)->Kind;
                    }

                    set
                    {
                        ((Internal*) __Instance)->Kind = value;
                    }
                }

                public CppSharp.Parser.AST.QualifiedType Type
                {
                    get
                    {
                        return CppSharp.Parser.AST.QualifiedType.__CreateInstance(((Internal*) __Instance)->Type);
                    }

                    set
                    {
                        ((Internal*) __Instance)->Type = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance);
                    }
                }

                public CppSharp.Parser.AST.Declaration Declaration
                {
                    get
                    {
                        return (((Internal*) __Instance)->Declaration == IntPtr.Zero) ? null : CppSharp.Parser.AST.Declaration.__CreateInstance(((Internal*) __Instance)->Declaration);
                    }

                    set
                    {
                        ((Internal*) __Instance)->Declaration = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
                    }
                }

                public long Integral
                {
                    get
                    {
                        return ((Internal*) __Instance)->Integral;
                    }

                    set
                    {
                        ((Internal*) __Instance)->Integral = value;
                    }
                }
            }

            public unsafe partial class TemplateSpecializationType : CppSharp.Parser.AST.Type, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 48)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.TypeKind Kind;

                    [FieldOffset(4)]
                    public bool IsDependent;

                    [FieldOffset(32)]
                    public global::System.IntPtr Template;

                    [FieldOffset(40)]
                    public global::System.IntPtr Desugared;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST26TemplateSpecializationTypeC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST26TemplateSpecializationTypeC2ERKS2_")]
                    internal static extern void cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST26TemplateSpecializationTypeD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST26TemplateSpecializationType12getArgumentsEj")]
                    internal static extern void getArguments_0(global::System.IntPtr @return, global::System.IntPtr instance, uint i);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST26TemplateSpecializationType12addArgumentsERNS1_16TemplateArgumentE")]
                    internal static extern void addArguments_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST26TemplateSpecializationType14clearArgumentsEv")]
                    internal static extern void clearArguments_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST26TemplateSpecializationType17getArgumentsCountEv")]
                    internal static extern uint getArgumentsCount_0(global::System.IntPtr instance);
                }

                private readonly bool __ownsNativeInstance;

                public static new TemplateSpecializationType __CreateInstance(global::System.IntPtr native)
                {
                    return new TemplateSpecializationType((TemplateSpecializationType.Internal*) native);
                }

                public static TemplateSpecializationType __CreateInstance(TemplateSpecializationType.Internal native)
                {
                    return new TemplateSpecializationType(native);
                }

                private static TemplateSpecializationType.Internal* __CopyValue(TemplateSpecializationType.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(48);
                    CppSharp.Parser.AST.TemplateSpecializationType.Internal.cctor_1(ret, new global::System.IntPtr(&native));
                    return (TemplateSpecializationType.Internal*) ret;
                }

                private TemplateSpecializationType(TemplateSpecializationType.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected TemplateSpecializationType(TemplateSpecializationType.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.Type.Internal*) native)
                {
                }

                public TemplateSpecializationType()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(48);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.TemplateArgument getArguments(uint i)
                {
                    var __ret = new CppSharp.Parser.AST.TemplateArgument.Internal();
                    Internal.getArguments_0(new IntPtr(&__ret), __Instance, i);
                    return CppSharp.Parser.AST.TemplateArgument.__CreateInstance(__ret);
                }

                public void addArguments(CppSharp.Parser.AST.TemplateArgument s)
                {
                    var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance;
                    Internal.addArguments_0(__Instance, arg0);
                }

                public void clearArguments()
                {
                    Internal.clearArguments_0(__Instance);
                }

                public uint ArgumentsCount
                {
                    get
                    {
                        var __ret = Internal.getArgumentsCount_0(__Instance);
                        return __ret;
                    }
                }

                public CppSharp.Parser.AST.Template Template
                {
                    get
                    {
                        return (((Internal*) __Instance)->Template == IntPtr.Zero) ? null : CppSharp.Parser.AST.Template.__CreateInstance(((Internal*) __Instance)->Template);
                    }

                    set
                    {
                        ((Internal*) __Instance)->Template = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
                    }
                }

                public CppSharp.Parser.AST.Type Desugared
                {
                    get
                    {
                        return (((Internal*) __Instance)->Desugared == IntPtr.Zero) ? null : CppSharp.Parser.AST.Type.__CreateInstance(((Internal*) __Instance)->Desugared);
                    }

                    set
                    {
                        ((Internal*) __Instance)->Desugared = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
                    }
                }
            }

            public unsafe partial class TemplateParameter : IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 32)]
                public partial struct Internal
                {
                    [FieldOffset(24)]
                    public bool IsTypeParameter;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST17TemplateParameterC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST17TemplateParameterC2ERKS2_")]
                    internal static extern void cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST17TemplateParameterD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZNK8CppSharp9CppParser3AST17TemplateParametereqERKS2_")]
                    [return: MarshalAsAttribute(UnmanagedType.I1)]
                    internal static extern bool OperatorEqualEqual_0(global::System.IntPtr instance, global::System.IntPtr param);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST17TemplateParameter7getNameEv")]
                    internal static extern global::System.IntPtr getName_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST17TemplateParameter7setNameEPKc")]
                    internal static extern void setName_0(global::System.IntPtr instance, global::System.IntPtr s);
                }

                public global::System.IntPtr __Instance { get; protected set; }

                private readonly bool __ownsNativeInstance;

                public static TemplateParameter __CreateInstance(global::System.IntPtr native)
                {
                    return new TemplateParameter((TemplateParameter.Internal*) native);
                }

                public static TemplateParameter __CreateInstance(TemplateParameter.Internal native)
                {
                    return new TemplateParameter(native);
                }

                private static TemplateParameter.Internal* __CopyValue(TemplateParameter.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(32);
                    CppSharp.Parser.AST.TemplateParameter.Internal.cctor_1(ret, new global::System.IntPtr(&native));
                    return (TemplateParameter.Internal*) ret;
                }

                private TemplateParameter(TemplateParameter.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected TemplateParameter(TemplateParameter.Internal* native, bool isInternalImpl = false)
                {
                    __Instance = new global::System.IntPtr(native);
                }

                public TemplateParameter()
                {
                    __Instance = Marshal.AllocHGlobal(32);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                public void Dispose()
                {
                    Dispose(disposing: true);
                    GC.SuppressFinalize(this);
                }

                protected virtual void Dispose(bool disposing)
                {
                    Internal.dtor_0(__Instance);
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                }

                public static bool operator !=(CppSharp.Parser.AST.TemplateParameter __op, CppSharp.Parser.AST.TemplateParameter param)
                {
                    return !(__op == param);
                }

                public static bool operator ==(CppSharp.Parser.AST.TemplateParameter __op, CppSharp.Parser.AST.TemplateParameter param)
                {
                    bool __opNull = ReferenceEquals(__op, null);
                    bool paramNull = ReferenceEquals(param, null);
                    if (__opNull || paramNull)
                        return __opNull && paramNull;
                    var arg0 = __op.__Instance;
                    var arg1 = param.__Instance;
                    var __ret = Internal.OperatorEqualEqual_0(arg0, arg1);
                    return __ret;
                }

                public override bool Equals(object obj)
                {
                    return this == obj as TemplateParameter;
                }

                public string Name
                {
                    get
                    {
                        var __ret = Internal.getName_0(__Instance);
                        if (__ret == global::System.IntPtr.Zero) return null;
                        return Marshal.PtrToStringAnsi(__ret);
                    }

                    set
                    {
                        var arg0 = Marshal.StringToHGlobalAnsi(value);
                        Internal.setName_0(__Instance, arg0);
                        Marshal.FreeHGlobal(arg0);
                    }
                }

                public bool IsTypeParameter
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsTypeParameter;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsTypeParameter = value;
                    }
                }
            }

            public unsafe partial class TemplateParameterType : CppSharp.Parser.AST.Type, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 56)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.TypeKind Kind;

                    [FieldOffset(4)]
                    public bool IsDependent;

                    [FieldOffset(8)]
                    public CppSharp.Parser.AST.TemplateParameter.Internal Parameter;

                    [FieldOffset(40)]
                    public uint Depth;

                    [FieldOffset(44)]
                    public uint Index;

                    [FieldOffset(48)]
                    public bool IsParameterPack;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST21TemplateParameterTypeC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST21TemplateParameterTypeC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST21TemplateParameterTypeD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);
                }

                private readonly bool __ownsNativeInstance;

                public static new TemplateParameterType __CreateInstance(global::System.IntPtr native)
                {
                    return new TemplateParameterType((TemplateParameterType.Internal*) native);
                }

                public static TemplateParameterType __CreateInstance(TemplateParameterType.Internal native)
                {
                    return new TemplateParameterType(native);
                }

                private static TemplateParameterType.Internal* __CopyValue(TemplateParameterType.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(56);
                    CppSharp.Parser.AST.TemplateParameterType.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (TemplateParameterType.Internal*) ret;
                }

                private TemplateParameterType(TemplateParameterType.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected TemplateParameterType(TemplateParameterType.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.Type.Internal*) native)
                {
                }

                public TemplateParameterType()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(56);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.TemplateParameter Parameter
                {
                    get
                    {
                        return CppSharp.Parser.AST.TemplateParameter.__CreateInstance(((Internal*) __Instance)->Parameter);
                    }

                    set
                    {
                        ((Internal*) __Instance)->Parameter = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.TemplateParameter.Internal() : *(CppSharp.Parser.AST.TemplateParameter.Internal*) (value.__Instance);
                    }
                }

                public uint Depth
                {
                    get
                    {
                        return ((Internal*) __Instance)->Depth;
                    }

                    set
                    {
                        ((Internal*) __Instance)->Depth = value;
                    }
                }

                public uint Index
                {
                    get
                    {
                        return ((Internal*) __Instance)->Index;
                    }

                    set
                    {
                        ((Internal*) __Instance)->Index = value;
                    }
                }

                public bool IsParameterPack
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsParameterPack;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsParameterPack = value;
                    }
                }
            }

            public unsafe partial class TemplateParameterSubstitutionType : CppSharp.Parser.AST.Type, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 24)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.TypeKind Kind;

                    [FieldOffset(4)]
                    public bool IsDependent;

                    [FieldOffset(8)]
                    public CppSharp.Parser.AST.QualifiedType.Internal Replacement;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST33TemplateParameterSubstitutionTypeC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST33TemplateParameterSubstitutionTypeC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                private readonly bool __ownsNativeInstance;

                public static new TemplateParameterSubstitutionType __CreateInstance(global::System.IntPtr native)
                {
                    return new TemplateParameterSubstitutionType((TemplateParameterSubstitutionType.Internal*) native);
                }

                public static TemplateParameterSubstitutionType __CreateInstance(TemplateParameterSubstitutionType.Internal native)
                {
                    return new TemplateParameterSubstitutionType(native);
                }

                private static TemplateParameterSubstitutionType.Internal* __CopyValue(TemplateParameterSubstitutionType.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(24);
                    CppSharp.Parser.AST.TemplateParameterSubstitutionType.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (TemplateParameterSubstitutionType.Internal*) ret;
                }

                private TemplateParameterSubstitutionType(TemplateParameterSubstitutionType.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected TemplateParameterSubstitutionType(TemplateParameterSubstitutionType.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.Type.Internal*) native)
                {
                }

                public TemplateParameterSubstitutionType()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(24);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.QualifiedType Replacement
                {
                    get
                    {
                        return CppSharp.Parser.AST.QualifiedType.__CreateInstance(((Internal*) __Instance)->Replacement);
                    }

                    set
                    {
                        ((Internal*) __Instance)->Replacement = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance);
                    }
                }
            }

            public unsafe partial class InjectedClassNameType : CppSharp.Parser.AST.Type, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 24)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.TypeKind Kind;

                    [FieldOffset(4)]
                    public bool IsDependent;

                    [FieldOffset(8)]
                    public global::System.IntPtr TemplateSpecialization;

                    [FieldOffset(16)]
                    public global::System.IntPtr Class;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST21InjectedClassNameTypeC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST21InjectedClassNameTypeC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                private readonly bool __ownsNativeInstance;

                public static new InjectedClassNameType __CreateInstance(global::System.IntPtr native)
                {
                    return new InjectedClassNameType((InjectedClassNameType.Internal*) native);
                }

                public static InjectedClassNameType __CreateInstance(InjectedClassNameType.Internal native)
                {
                    return new InjectedClassNameType(native);
                }

                private static InjectedClassNameType.Internal* __CopyValue(InjectedClassNameType.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(24);
                    CppSharp.Parser.AST.InjectedClassNameType.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (InjectedClassNameType.Internal*) ret;
                }

                private InjectedClassNameType(InjectedClassNameType.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected InjectedClassNameType(InjectedClassNameType.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.Type.Internal*) native)
                {
                }

                public InjectedClassNameType()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(24);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.TemplateSpecializationType TemplateSpecialization
                {
                    get
                    {
                        return (((Internal*) __Instance)->TemplateSpecialization == IntPtr.Zero) ? null : CppSharp.Parser.AST.TemplateSpecializationType.__CreateInstance(((Internal*) __Instance)->TemplateSpecialization);
                    }

                    set
                    {
                        ((Internal*) __Instance)->TemplateSpecialization = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
                    }
                }

                public CppSharp.Parser.AST.Class Class
                {
                    get
                    {
                        return (((Internal*) __Instance)->Class == IntPtr.Zero) ? null : CppSharp.Parser.AST.Class.__CreateInstance(((Internal*) __Instance)->Class);
                    }

                    set
                    {
                        ((Internal*) __Instance)->Class = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
                    }
                }
            }

            public unsafe partial class DependentNameType : CppSharp.Parser.AST.Type, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 8)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.TypeKind Kind;

                    [FieldOffset(4)]
                    public bool IsDependent;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST17DependentNameTypeC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST17DependentNameTypeC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                private readonly bool __ownsNativeInstance;

                public static new DependentNameType __CreateInstance(global::System.IntPtr native)
                {
                    return new DependentNameType((DependentNameType.Internal*) native);
                }

                public static DependentNameType __CreateInstance(DependentNameType.Internal native)
                {
                    return new DependentNameType(native);
                }

                private static DependentNameType.Internal* __CopyValue(DependentNameType.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(8);
                    CppSharp.Parser.AST.DependentNameType.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (DependentNameType.Internal*) ret;
                }

                private DependentNameType(DependentNameType.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected DependentNameType(DependentNameType.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.Type.Internal*) native)
                {
                }

                public DependentNameType()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(8);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }
            }

            public unsafe partial class PackExpansionType : CppSharp.Parser.AST.Type, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 8)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.TypeKind Kind;

                    [FieldOffset(4)]
                    public bool IsDependent;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST17PackExpansionTypeC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST17PackExpansionTypeC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                private readonly bool __ownsNativeInstance;

                public static new PackExpansionType __CreateInstance(global::System.IntPtr native)
                {
                    return new PackExpansionType((PackExpansionType.Internal*) native);
                }

                public static PackExpansionType __CreateInstance(PackExpansionType.Internal native)
                {
                    return new PackExpansionType(native);
                }

                private static PackExpansionType.Internal* __CopyValue(PackExpansionType.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(8);
                    CppSharp.Parser.AST.PackExpansionType.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (PackExpansionType.Internal*) ret;
                }

                private PackExpansionType(PackExpansionType.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected PackExpansionType(PackExpansionType.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.Type.Internal*) native)
                {
                }

                public PackExpansionType()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(8);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }
            }

            public unsafe partial class BuiltinType : CppSharp.Parser.AST.Type, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 12)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.TypeKind Kind;

                    [FieldOffset(4)]
                    public bool IsDependent;

                    [FieldOffset(8)]
                    public CppSharp.Parser.AST.PrimitiveType Type;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11BuiltinTypeC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11BuiltinTypeC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                private readonly bool __ownsNativeInstance;

                public static new BuiltinType __CreateInstance(global::System.IntPtr native)
                {
                    return new BuiltinType((BuiltinType.Internal*) native);
                }

                public static BuiltinType __CreateInstance(BuiltinType.Internal native)
                {
                    return new BuiltinType(native);
                }

                private static BuiltinType.Internal* __CopyValue(BuiltinType.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(12);
                    CppSharp.Parser.AST.BuiltinType.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (BuiltinType.Internal*) ret;
                }

                private BuiltinType(BuiltinType.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected BuiltinType(BuiltinType.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.Type.Internal*) native)
                {
                }

                public BuiltinType()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(12);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.PrimitiveType Type
                {
                    get
                    {
                        return ((Internal*) __Instance)->Type;
                    }

                    set
                    {
                        ((Internal*) __Instance)->Type = value;
                    }
                }
            }

            public unsafe partial class VTableComponent : IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 16)]
                public partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.VTableComponentKind Kind;

                    [FieldOffset(4)]
                    public uint Offset;

                    [FieldOffset(8)]
                    public global::System.IntPtr Declaration;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST15VTableComponentC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST15VTableComponentC2ERKS2_")]
                    internal static extern void cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                public global::System.IntPtr __Instance { get; protected set; }

                private readonly bool __ownsNativeInstance;

                public static VTableComponent __CreateInstance(global::System.IntPtr native)
                {
                    return new VTableComponent((VTableComponent.Internal*) native);
                }

                public static VTableComponent __CreateInstance(VTableComponent.Internal native)
                {
                    return new VTableComponent(native);
                }

                private static VTableComponent.Internal* __CopyValue(VTableComponent.Internal native)
                {
                    var ret = (VTableComponent.Internal*) Marshal.AllocHGlobal(16);
                    *ret = native;
                    return ret;
                }

                private VTableComponent(VTableComponent.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected VTableComponent(VTableComponent.Internal* native, bool isInternalImpl = false)
                {
                    __Instance = new global::System.IntPtr(native);
                }

                public VTableComponent()
                {
                    __Instance = Marshal.AllocHGlobal(16);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                public void Dispose()
                {
                    Dispose(disposing: true);
                    GC.SuppressFinalize(this);
                }

                protected virtual void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                }

                public CppSharp.Parser.AST.VTableComponentKind Kind
                {
                    get
                    {
                        return ((Internal*) __Instance)->Kind;
                    }

                    set
                    {
                        ((Internal*) __Instance)->Kind = value;
                    }
                }

                public uint Offset
                {
                    get
                    {
                        return ((Internal*) __Instance)->Offset;
                    }

                    set
                    {
                        ((Internal*) __Instance)->Offset = value;
                    }
                }

                public CppSharp.Parser.AST.Declaration Declaration
                {
                    get
                    {
                        return (((Internal*) __Instance)->Declaration == IntPtr.Zero) ? null : CppSharp.Parser.AST.Declaration.__CreateInstance(((Internal*) __Instance)->Declaration);
                    }

                    set
                    {
                        ((Internal*) __Instance)->Declaration = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
                    }
                }
            }

            public unsafe partial class VTableLayout : IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 24)]
                public partial struct Internal
                {
                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST12VTableLayoutC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST12VTableLayoutC2ERKS2_")]
                    internal static extern void cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST12VTableLayoutD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST12VTableLayout13getComponentsEj")]
                    internal static extern CppSharp.Parser.AST.VTableComponent.Internal getComponents_0(global::System.IntPtr instance, uint i);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST12VTableLayout13addComponentsERNS1_15VTableComponentE")]
                    internal static extern void addComponents_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST12VTableLayout15clearComponentsEv")]
                    internal static extern void clearComponents_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST12VTableLayout18getComponentsCountEv")]
                    internal static extern uint getComponentsCount_0(global::System.IntPtr instance);
                }

                public global::System.IntPtr __Instance { get; protected set; }

                private readonly bool __ownsNativeInstance;

                public static VTableLayout __CreateInstance(global::System.IntPtr native)
                {
                    return new VTableLayout((VTableLayout.Internal*) native);
                }

                public static VTableLayout __CreateInstance(VTableLayout.Internal native)
                {
                    return new VTableLayout(native);
                }

                private static VTableLayout.Internal* __CopyValue(VTableLayout.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(24);
                    CppSharp.Parser.AST.VTableLayout.Internal.cctor_1(ret, new global::System.IntPtr(&native));
                    return (VTableLayout.Internal*) ret;
                }

                private VTableLayout(VTableLayout.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected VTableLayout(VTableLayout.Internal* native, bool isInternalImpl = false)
                {
                    __Instance = new global::System.IntPtr(native);
                }

                public VTableLayout()
                {
                    __Instance = Marshal.AllocHGlobal(24);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                public void Dispose()
                {
                    Dispose(disposing: true);
                    GC.SuppressFinalize(this);
                }

                protected virtual void Dispose(bool disposing)
                {
                    Internal.dtor_0(__Instance);
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                }

                public CppSharp.Parser.AST.VTableComponent getComponents(uint i)
                {
                    var __ret = Internal.getComponents_0(__Instance, i);
                    return CppSharp.Parser.AST.VTableComponent.__CreateInstance(__ret);
                }

                public void addComponents(CppSharp.Parser.AST.VTableComponent s)
                {
                    var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance;
                    Internal.addComponents_0(__Instance, arg0);
                }

                public void clearComponents()
                {
                    Internal.clearComponents_0(__Instance);
                }

                public uint ComponentsCount
                {
                    get
                    {
                        var __ret = Internal.getComponentsCount_0(__Instance);
                        return __ret;
                    }
                }
            }

            public unsafe partial class VFTableInfo : IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 40)]
                public partial struct Internal
                {
                    [FieldOffset(0)]
                    public ulong VBTableIndex;

                    [FieldOffset(8)]
                    public uint VFPtrOffset;

                    [FieldOffset(12)]
                    public uint VFPtrFullOffset;

                    [FieldOffset(16)]
                    public CppSharp.Parser.AST.VTableLayout.Internal Layout;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11VFTableInfoC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11VFTableInfoC2ERKS2_")]
                    internal static extern void cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11VFTableInfoD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);
                }

                public global::System.IntPtr __Instance { get; protected set; }

                private readonly bool __ownsNativeInstance;

                public static VFTableInfo __CreateInstance(global::System.IntPtr native)
                {
                    return new VFTableInfo((VFTableInfo.Internal*) native);
                }

                public static VFTableInfo __CreateInstance(VFTableInfo.Internal native)
                {
                    return new VFTableInfo(native);
                }

                private static VFTableInfo.Internal* __CopyValue(VFTableInfo.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(40);
                    CppSharp.Parser.AST.VFTableInfo.Internal.cctor_1(ret, new global::System.IntPtr(&native));
                    return (VFTableInfo.Internal*) ret;
                }

                private VFTableInfo(VFTableInfo.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected VFTableInfo(VFTableInfo.Internal* native, bool isInternalImpl = false)
                {
                    __Instance = new global::System.IntPtr(native);
                }

                public VFTableInfo()
                {
                    __Instance = Marshal.AllocHGlobal(40);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                public void Dispose()
                {
                    Dispose(disposing: true);
                    GC.SuppressFinalize(this);
                }

                protected virtual void Dispose(bool disposing)
                {
                    Internal.dtor_0(__Instance);
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                }

                public ulong VBTableIndex
                {
                    get
                    {
                        return ((Internal*) __Instance)->VBTableIndex;
                    }

                    set
                    {
                        ((Internal*) __Instance)->VBTableIndex = value;
                    }
                }

                public uint VFPtrOffset
                {
                    get
                    {
                        return ((Internal*) __Instance)->VFPtrOffset;
                    }

                    set
                    {
                        ((Internal*) __Instance)->VFPtrOffset = value;
                    }
                }

                public uint VFPtrFullOffset
                {
                    get
                    {
                        return ((Internal*) __Instance)->VFPtrFullOffset;
                    }

                    set
                    {
                        ((Internal*) __Instance)->VFPtrFullOffset = value;
                    }
                }

                public CppSharp.Parser.AST.VTableLayout Layout
                {
                    get
                    {
                        return CppSharp.Parser.AST.VTableLayout.__CreateInstance(((Internal*) __Instance)->Layout);
                    }

                    set
                    {
                        ((Internal*) __Instance)->Layout = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.VTableLayout.Internal() : *(CppSharp.Parser.AST.VTableLayout.Internal*) (value.__Instance);
                    }
                }
            }

            public unsafe partial class ClassLayout : IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 88)]
                public partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.CppAbi ABI;

                    [FieldOffset(32)]
                    public CppSharp.Parser.AST.VTableLayout.Internal Layout;

                    [FieldOffset(56)]
                    public bool HasOwnVFPtr;

                    [FieldOffset(64)]
                    public long VBPtrOffset;

                    [FieldOffset(72)]
                    public int Alignment;

                    [FieldOffset(76)]
                    public int Size;

                    [FieldOffset(80)]
                    public int DataSize;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11ClassLayoutC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11ClassLayoutC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11ClassLayoutD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11ClassLayout11getVFTablesEj")]
                    internal static extern void getVFTables_0(global::System.IntPtr @return, global::System.IntPtr instance, uint i);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11ClassLayout11addVFTablesERNS1_11VFTableInfoE")]
                    internal static extern void addVFTables_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11ClassLayout13clearVFTablesEv")]
                    internal static extern void clearVFTables_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11ClassLayout16getVFTablesCountEv")]
                    internal static extern uint getVFTablesCount_0(global::System.IntPtr instance);
                }

                public global::System.IntPtr __Instance { get; protected set; }

                private readonly bool __ownsNativeInstance;

                public static ClassLayout __CreateInstance(global::System.IntPtr native)
                {
                    return new ClassLayout((ClassLayout.Internal*) native);
                }

                public static ClassLayout __CreateInstance(ClassLayout.Internal native)
                {
                    return new ClassLayout(native);
                }

                private static ClassLayout.Internal* __CopyValue(ClassLayout.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(88);
                    CppSharp.Parser.AST.ClassLayout.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (ClassLayout.Internal*) ret;
                }

                private ClassLayout(ClassLayout.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected ClassLayout(ClassLayout.Internal* native, bool isInternalImpl = false)
                {
                    __Instance = new global::System.IntPtr(native);
                }

                public ClassLayout()
                {
                    __Instance = Marshal.AllocHGlobal(88);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                public void Dispose()
                {
                    Dispose(disposing: true);
                    GC.SuppressFinalize(this);
                }

                protected virtual void Dispose(bool disposing)
                {
                    Internal.dtor_0(__Instance);
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                }

                public CppSharp.Parser.AST.VFTableInfo getVFTables(uint i)
                {
                    var __ret = new CppSharp.Parser.AST.VFTableInfo.Internal();
                    Internal.getVFTables_0(new IntPtr(&__ret), __Instance, i);
                    return CppSharp.Parser.AST.VFTableInfo.__CreateInstance(__ret);
                }

                public void addVFTables(CppSharp.Parser.AST.VFTableInfo s)
                {
                    var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance;
                    Internal.addVFTables_0(__Instance, arg0);
                }

                public void clearVFTables()
                {
                    Internal.clearVFTables_0(__Instance);
                }

                public uint VFTablesCount
                {
                    get
                    {
                        var __ret = Internal.getVFTablesCount_0(__Instance);
                        return __ret;
                    }
                }

                public CppSharp.Parser.AST.CppAbi ABI
                {
                    get
                    {
                        return ((Internal*) __Instance)->ABI;
                    }

                    set
                    {
                        ((Internal*) __Instance)->ABI = value;
                    }
                }

                public CppSharp.Parser.AST.VTableLayout Layout
                {
                    get
                    {
                        return CppSharp.Parser.AST.VTableLayout.__CreateInstance(((Internal*) __Instance)->Layout);
                    }

                    set
                    {
                        ((Internal*) __Instance)->Layout = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.VTableLayout.Internal() : *(CppSharp.Parser.AST.VTableLayout.Internal*) (value.__Instance);
                    }
                }

                public bool HasOwnVFPtr
                {
                    get
                    {
                        return ((Internal*) __Instance)->HasOwnVFPtr;
                    }

                    set
                    {
                        ((Internal*) __Instance)->HasOwnVFPtr = value;
                    }
                }

                public long VBPtrOffset
                {
                    get
                    {
                        return ((Internal*) __Instance)->VBPtrOffset;
                    }

                    set
                    {
                        ((Internal*) __Instance)->VBPtrOffset = value;
                    }
                }

                public int Alignment
                {
                    get
                    {
                        return ((Internal*) __Instance)->Alignment;
                    }

                    set
                    {
                        ((Internal*) __Instance)->Alignment = value;
                    }
                }

                public int Size
                {
                    get
                    {
                        return ((Internal*) __Instance)->Size;
                    }

                    set
                    {
                        ((Internal*) __Instance)->Size = value;
                    }
                }

                public int DataSize
                {
                    get
                    {
                        return ((Internal*) __Instance)->DataSize;
                    }

                    set
                    {
                        ((Internal*) __Instance)->DataSize = value;
                    }
                }
            }

            public unsafe partial class Declaration : IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 168)]
                public partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.DeclarationKind Kind;

                    [FieldOffset(4)]
                    public CppSharp.Parser.AST.AccessSpecifier Access;

                    [FieldOffset(8)]
                    public global::System.IntPtr _Namespace;

                    [FieldOffset(16)]
                    public CppSharp.Parser.SourceLocation.Internal Location;

                    [FieldOffset(20)]
                    public int LineNumberStart;

                    [FieldOffset(24)]
                    public int LineNumberEnd;

                    [FieldOffset(56)]
                    public global::System.IntPtr Comment;

                    [FieldOffset(88)]
                    public bool IsIncomplete;

                    [FieldOffset(89)]
                    public bool IsDependent;

                    [FieldOffset(96)]
                    public global::System.IntPtr CompleteDeclaration;

                    [FieldOffset(104)]
                    public uint DefinitionOrder;

                    [FieldOffset(136)]
                    public global::System.IntPtr OriginalPtr;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11DeclarationC2ENS1_15DeclarationKindE")]
                    internal static extern void ctor_0(global::System.IntPtr instance, CppSharp.Parser.AST.DeclarationKind kind);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11DeclarationC2ERKS2_")]
                    internal static extern void cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11DeclarationD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11Declaration23getPreprocessedEntitiesEj")]
                    internal static extern global::System.IntPtr getPreprocessedEntities_0(global::System.IntPtr instance, uint i);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11Declaration23addPreprocessedEntitiesERPNS1_18PreprocessedEntityE")]
                    internal static extern void addPreprocessedEntities_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11Declaration25clearPreprocessedEntitiesEv")]
                    internal static extern void clearPreprocessedEntities_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11Declaration7getNameEv")]
                    internal static extern global::System.IntPtr getName_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11Declaration7setNameEPKc")]
                    internal static extern void setName_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11Declaration12getDebugTextEv")]
                    internal static extern global::System.IntPtr getDebugText_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11Declaration12setDebugTextEPKc")]
                    internal static extern void setDebugText_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11Declaration28getPreprocessedEntitiesCountEv")]
                    internal static extern uint getPreprocessedEntitiesCount_0(global::System.IntPtr instance);
                }

                public global::System.IntPtr __Instance { get; protected set; }

                private readonly bool __ownsNativeInstance;

                public static Declaration __CreateInstance(global::System.IntPtr native)
                {
                    return new Declaration((Declaration.Internal*) native);
                }

                public static Declaration __CreateInstance(Declaration.Internal native)
                {
                    return new Declaration(native);
                }

                private static Declaration.Internal* __CopyValue(Declaration.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(168);
                    CppSharp.Parser.AST.Declaration.Internal.cctor_1(ret, new global::System.IntPtr(&native));
                    return (Declaration.Internal*) ret;
                }

                private Declaration(Declaration.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected Declaration(Declaration.Internal* native, bool isInternalImpl = false)
                {
                    __Instance = new global::System.IntPtr(native);
                }

                public Declaration(CppSharp.Parser.AST.DeclarationKind kind)
                {
                    __Instance = Marshal.AllocHGlobal(168);
                    __ownsNativeInstance = true;
                    var arg0 = kind;
                    Internal.ctor_0(__Instance, arg0);
                }

                public void Dispose()
                {
                    Dispose(disposing: true);
                    GC.SuppressFinalize(this);
                }

                protected virtual void Dispose(bool disposing)
                {
                    Internal.dtor_0(__Instance);
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                }

                public CppSharp.Parser.AST.PreprocessedEntity getPreprocessedEntities(uint i)
                {
                    var __ret = Internal.getPreprocessedEntities_0(__Instance, i);
                    if (__ret == global::System.IntPtr.Zero) return null;
                    return (__ret == IntPtr.Zero) ? null : CppSharp.Parser.AST.PreprocessedEntity.__CreateInstance(__ret);
                }

                public void addPreprocessedEntities(CppSharp.Parser.AST.PreprocessedEntity s)
                {
                    var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance;
                    Internal.addPreprocessedEntities_0(__Instance, arg0);
                }

                public void clearPreprocessedEntities()
                {
                    Internal.clearPreprocessedEntities_0(__Instance);
                }

                public string Name
                {
                    get
                    {
                        var __ret = Internal.getName_0(__Instance);
                        if (__ret == global::System.IntPtr.Zero) return null;
                        return Marshal.PtrToStringAnsi(__ret);
                    }

                    set
                    {
                        var arg0 = Marshal.StringToHGlobalAnsi(value);
                        Internal.setName_0(__Instance, arg0);
                        Marshal.FreeHGlobal(arg0);
                    }
                }

                public string DebugText
                {
                    get
                    {
                        var __ret = Internal.getDebugText_0(__Instance);
                        if (__ret == global::System.IntPtr.Zero) return null;
                        return Marshal.PtrToStringAnsi(__ret);
                    }

                    set
                    {
                        var arg0 = Marshal.StringToHGlobalAnsi(value);
                        Internal.setDebugText_0(__Instance, arg0);
                        Marshal.FreeHGlobal(arg0);
                    }
                }

                public uint PreprocessedEntitiesCount
                {
                    get
                    {
                        var __ret = Internal.getPreprocessedEntitiesCount_0(__Instance);
                        return __ret;
                    }
                }

                public CppSharp.Parser.AST.DeclarationKind Kind
                {
                    get
                    {
                        return ((Internal*) __Instance)->Kind;
                    }

                    set
                    {
                        ((Internal*) __Instance)->Kind = value;
                    }
                }

                public CppSharp.Parser.AST.AccessSpecifier Access
                {
                    get
                    {
                        return ((Internal*) __Instance)->Access;
                    }

                    set
                    {
                        ((Internal*) __Instance)->Access = value;
                    }
                }

                public CppSharp.Parser.AST.DeclarationContext _Namespace
                {
                    get
                    {
                        return (((Internal*) __Instance)->_Namespace == IntPtr.Zero) ? null : CppSharp.Parser.AST.DeclarationContext.__CreateInstance(((Internal*) __Instance)->_Namespace);
                    }

                    set
                    {
                        ((Internal*) __Instance)->_Namespace = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
                    }
                }

                public CppSharp.Parser.SourceLocation Location
                {
                    get
                    {
                        return CppSharp.Parser.SourceLocation.__CreateInstance(((Internal*) __Instance)->Location);
                    }

                    set
                    {
                        ((Internal*) __Instance)->Location = value.__Instance;
                    }
                }

                public int LineNumberStart
                {
                    get
                    {
                        return ((Internal*) __Instance)->LineNumberStart;
                    }

                    set
                    {
                        ((Internal*) __Instance)->LineNumberStart = value;
                    }
                }

                public int LineNumberEnd
                {
                    get
                    {
                        return ((Internal*) __Instance)->LineNumberEnd;
                    }

                    set
                    {
                        ((Internal*) __Instance)->LineNumberEnd = value;
                    }
                }

                public CppSharp.Parser.AST.RawComment Comment
                {
                    get
                    {
                        return (((Internal*) __Instance)->Comment == IntPtr.Zero) ? null : CppSharp.Parser.AST.RawComment.__CreateInstance(((Internal*) __Instance)->Comment);
                    }

                    set
                    {
                        ((Internal*) __Instance)->Comment = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
                    }
                }

                public bool IsIncomplete
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsIncomplete;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsIncomplete = value;
                    }
                }

                public bool IsDependent
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsDependent;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsDependent = value;
                    }
                }

                public CppSharp.Parser.AST.Declaration CompleteDeclaration
                {
                    get
                    {
                        return (((Internal*) __Instance)->CompleteDeclaration == IntPtr.Zero) ? null : CppSharp.Parser.AST.Declaration.__CreateInstance(((Internal*) __Instance)->CompleteDeclaration);
                    }

                    set
                    {
                        ((Internal*) __Instance)->CompleteDeclaration = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
                    }
                }

                public uint DefinitionOrder
                {
                    get
                    {
                        return ((Internal*) __Instance)->DefinitionOrder;
                    }

                    set
                    {
                        ((Internal*) __Instance)->DefinitionOrder = value;
                    }
                }

                public global::System.IntPtr OriginalPtr
                {
                    get
                    {
                        return ((Internal*) __Instance)->OriginalPtr;
                    }

                    set
                    {
                        ((Internal*) __Instance)->OriginalPtr = value;
                    }
                }
            }

            public unsafe partial class DeclarationContext : CppSharp.Parser.AST.Declaration, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 392)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.DeclarationKind Kind;

                    [FieldOffset(4)]
                    public CppSharp.Parser.AST.AccessSpecifier Access;

                    [FieldOffset(8)]
                    public global::System.IntPtr _Namespace;

                    [FieldOffset(16)]
                    public CppSharp.Parser.SourceLocation.Internal Location;

                    [FieldOffset(20)]
                    public int LineNumberStart;

                    [FieldOffset(24)]
                    public int LineNumberEnd;

                    [FieldOffset(56)]
                    public global::System.IntPtr Comment;

                    [FieldOffset(88)]
                    public bool IsIncomplete;

                    [FieldOffset(89)]
                    public bool IsDependent;

                    [FieldOffset(96)]
                    public global::System.IntPtr CompleteDeclaration;

                    [FieldOffset(104)]
                    public uint DefinitionOrder;

                    [FieldOffset(136)]
                    public global::System.IntPtr OriginalPtr;

                    [FieldOffset(384)]
                    public bool IsAnonymous;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContextC2ENS1_15DeclarationKindE")]
                    internal static extern void ctor_0(global::System.IntPtr instance, CppSharp.Parser.AST.DeclarationKind kind);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContextC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContextD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext13getNamespacesEj")]
                    internal static extern global::System.IntPtr getNamespaces_0(global::System.IntPtr instance, uint i);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext13addNamespacesERPNS1_9NamespaceE")]
                    internal static extern void addNamespaces_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext15clearNamespacesEv")]
                    internal static extern void clearNamespaces_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext8getEnumsEj")]
                    internal static extern global::System.IntPtr getEnums_0(global::System.IntPtr instance, uint i);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext8addEnumsERPNS1_11EnumerationE")]
                    internal static extern void addEnums_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext10clearEnumsEv")]
                    internal static extern void clearEnums_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext12getFunctionsEj")]
                    internal static extern global::System.IntPtr getFunctions_0(global::System.IntPtr instance, uint i);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext12addFunctionsERPNS1_8FunctionE")]
                    internal static extern void addFunctions_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext14clearFunctionsEv")]
                    internal static extern void clearFunctions_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext10getClassesEj")]
                    internal static extern global::System.IntPtr getClasses_0(global::System.IntPtr instance, uint i);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext10addClassesERPNS1_5ClassE")]
                    internal static extern void addClasses_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext12clearClassesEv")]
                    internal static extern void clearClasses_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext12getTemplatesEj")]
                    internal static extern global::System.IntPtr getTemplates_0(global::System.IntPtr instance, uint i);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext12addTemplatesERPNS1_8TemplateE")]
                    internal static extern void addTemplates_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext14clearTemplatesEv")]
                    internal static extern void clearTemplates_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext11getTypedefsEj")]
                    internal static extern global::System.IntPtr getTypedefs_0(global::System.IntPtr instance, uint i);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext11addTypedefsERPNS1_11TypedefDeclE")]
                    internal static extern void addTypedefs_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext13clearTypedefsEv")]
                    internal static extern void clearTypedefs_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext12getVariablesEj")]
                    internal static extern global::System.IntPtr getVariables_0(global::System.IntPtr instance, uint i);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext12addVariablesERPNS1_8VariableE")]
                    internal static extern void addVariables_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext14clearVariablesEv")]
                    internal static extern void clearVariables_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext10getFriendsEj")]
                    internal static extern global::System.IntPtr getFriends_0(global::System.IntPtr instance, uint i);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext10addFriendsERPNS1_6FriendE")]
                    internal static extern void addFriends_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext12clearFriendsEv")]
                    internal static extern void clearFriends_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext18getNamespacesCountEv")]
                    internal static extern uint getNamespacesCount_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext13getEnumsCountEv")]
                    internal static extern uint getEnumsCount_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext17getFunctionsCountEv")]
                    internal static extern uint getFunctionsCount_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext15getClassesCountEv")]
                    internal static extern uint getClassesCount_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext17getTemplatesCountEv")]
                    internal static extern uint getTemplatesCount_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext16getTypedefsCountEv")]
                    internal static extern uint getTypedefsCount_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext17getVariablesCountEv")]
                    internal static extern uint getVariablesCount_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext15getFriendsCountEv")]
                    internal static extern uint getFriendsCount_0(global::System.IntPtr instance);
                }

                private readonly bool __ownsNativeInstance;

                public static new DeclarationContext __CreateInstance(global::System.IntPtr native)
                {
                    return new DeclarationContext((DeclarationContext.Internal*) native);
                }

                public static DeclarationContext __CreateInstance(DeclarationContext.Internal native)
                {
                    return new DeclarationContext(native);
                }

                private static DeclarationContext.Internal* __CopyValue(DeclarationContext.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(392);
                    CppSharp.Parser.AST.DeclarationContext.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (DeclarationContext.Internal*) ret;
                }

                private DeclarationContext(DeclarationContext.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected DeclarationContext(DeclarationContext.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.Declaration.Internal*) native)
                {
                }

                public DeclarationContext(CppSharp.Parser.AST.DeclarationKind kind)
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(392);
                    __ownsNativeInstance = true;
                    var arg0 = kind;
                    Internal.ctor_0(__Instance, arg0);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.Namespace getNamespaces(uint i)
                {
                    var __ret = Internal.getNamespaces_0(__Instance, i);
                    if (__ret == global::System.IntPtr.Zero) return null;
                    return (__ret == IntPtr.Zero) ? null : CppSharp.Parser.AST.Namespace.__CreateInstance(__ret);
                }

                public void addNamespaces(CppSharp.Parser.AST.Namespace s)
                {
                    var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance;
                    Internal.addNamespaces_0(__Instance, arg0);
                }

                public void clearNamespaces()
                {
                    Internal.clearNamespaces_0(__Instance);
                }

                public CppSharp.Parser.AST.Enumeration getEnums(uint i)
                {
                    var __ret = Internal.getEnums_0(__Instance, i);
                    if (__ret == global::System.IntPtr.Zero) return null;
                    return (__ret == IntPtr.Zero) ? null : CppSharp.Parser.AST.Enumeration.__CreateInstance(__ret);
                }

                public void addEnums(CppSharp.Parser.AST.Enumeration s)
                {
                    var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance;
                    Internal.addEnums_0(__Instance, arg0);
                }

                public void clearEnums()
                {
                    Internal.clearEnums_0(__Instance);
                }

                public CppSharp.Parser.AST.Function getFunctions(uint i)
                {
                    var __ret = Internal.getFunctions_0(__Instance, i);
                    if (__ret == global::System.IntPtr.Zero) return null;
                    return (__ret == IntPtr.Zero) ? null : CppSharp.Parser.AST.Function.__CreateInstance(__ret);
                }

                public void addFunctions(CppSharp.Parser.AST.Function s)
                {
                    var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance;
                    Internal.addFunctions_0(__Instance, arg0);
                }

                public void clearFunctions()
                {
                    Internal.clearFunctions_0(__Instance);
                }

                public CppSharp.Parser.AST.Class getClasses(uint i)
                {
                    var __ret = Internal.getClasses_0(__Instance, i);
                    if (__ret == global::System.IntPtr.Zero) return null;
                    return (__ret == IntPtr.Zero) ? null : CppSharp.Parser.AST.Class.__CreateInstance(__ret);
                }

                public void addClasses(CppSharp.Parser.AST.Class s)
                {
                    var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance;
                    Internal.addClasses_0(__Instance, arg0);
                }

                public void clearClasses()
                {
                    Internal.clearClasses_0(__Instance);
                }

                public CppSharp.Parser.AST.Template getTemplates(uint i)
                {
                    var __ret = Internal.getTemplates_0(__Instance, i);
                    if (__ret == global::System.IntPtr.Zero) return null;
                    return (__ret == IntPtr.Zero) ? null : CppSharp.Parser.AST.Template.__CreateInstance(__ret);
                }

                public void addTemplates(CppSharp.Parser.AST.Template s)
                {
                    var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance;
                    Internal.addTemplates_0(__Instance, arg0);
                }

                public void clearTemplates()
                {
                    Internal.clearTemplates_0(__Instance);
                }

                public CppSharp.Parser.AST.TypedefDecl getTypedefs(uint i)
                {
                    var __ret = Internal.getTypedefs_0(__Instance, i);
                    if (__ret == global::System.IntPtr.Zero) return null;
                    return (__ret == IntPtr.Zero) ? null : CppSharp.Parser.AST.TypedefDecl.__CreateInstance(__ret);
                }

                public void addTypedefs(CppSharp.Parser.AST.TypedefDecl s)
                {
                    var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance;
                    Internal.addTypedefs_0(__Instance, arg0);
                }

                public void clearTypedefs()
                {
                    Internal.clearTypedefs_0(__Instance);
                }

                public CppSharp.Parser.AST.Variable getVariables(uint i)
                {
                    var __ret = Internal.getVariables_0(__Instance, i);
                    if (__ret == global::System.IntPtr.Zero) return null;
                    return (__ret == IntPtr.Zero) ? null : CppSharp.Parser.AST.Variable.__CreateInstance(__ret);
                }

                public void addVariables(CppSharp.Parser.AST.Variable s)
                {
                    var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance;
                    Internal.addVariables_0(__Instance, arg0);
                }

                public void clearVariables()
                {
                    Internal.clearVariables_0(__Instance);
                }

                public CppSharp.Parser.AST.Friend getFriends(uint i)
                {
                    var __ret = Internal.getFriends_0(__Instance, i);
                    if (__ret == global::System.IntPtr.Zero) return null;
                    return (__ret == IntPtr.Zero) ? null : CppSharp.Parser.AST.Friend.__CreateInstance(__ret);
                }

                public void addFriends(CppSharp.Parser.AST.Friend s)
                {
                    var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance;
                    Internal.addFriends_0(__Instance, arg0);
                }

                public void clearFriends()
                {
                    Internal.clearFriends_0(__Instance);
                }

                public uint NamespacesCount
                {
                    get
                    {
                        var __ret = Internal.getNamespacesCount_0(__Instance);
                        return __ret;
                    }
                }

                public uint EnumsCount
                {
                    get
                    {
                        var __ret = Internal.getEnumsCount_0(__Instance);
                        return __ret;
                    }
                }

                public uint FunctionsCount
                {
                    get
                    {
                        var __ret = Internal.getFunctionsCount_0(__Instance);
                        return __ret;
                    }
                }

                public uint ClassesCount
                {
                    get
                    {
                        var __ret = Internal.getClassesCount_0(__Instance);
                        return __ret;
                    }
                }

                public uint TemplatesCount
                {
                    get
                    {
                        var __ret = Internal.getTemplatesCount_0(__Instance);
                        return __ret;
                    }
                }

                public uint TypedefsCount
                {
                    get
                    {
                        var __ret = Internal.getTypedefsCount_0(__Instance);
                        return __ret;
                    }
                }

                public uint VariablesCount
                {
                    get
                    {
                        var __ret = Internal.getVariablesCount_0(__Instance);
                        return __ret;
                    }
                }

                public uint FriendsCount
                {
                    get
                    {
                        var __ret = Internal.getFriendsCount_0(__Instance);
                        return __ret;
                    }
                }

                public bool IsAnonymous
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsAnonymous;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsAnonymous = value;
                    }
                }
            }

            public unsafe partial class TypedefDecl : CppSharp.Parser.AST.Declaration, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 184)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.DeclarationKind Kind;

                    [FieldOffset(4)]
                    public CppSharp.Parser.AST.AccessSpecifier Access;

                    [FieldOffset(8)]
                    public global::System.IntPtr _Namespace;

                    [FieldOffset(16)]
                    public CppSharp.Parser.SourceLocation.Internal Location;

                    [FieldOffset(20)]
                    public int LineNumberStart;

                    [FieldOffset(24)]
                    public int LineNumberEnd;

                    [FieldOffset(56)]
                    public global::System.IntPtr Comment;

                    [FieldOffset(88)]
                    public bool IsIncomplete;

                    [FieldOffset(89)]
                    public bool IsDependent;

                    [FieldOffset(96)]
                    public global::System.IntPtr CompleteDeclaration;

                    [FieldOffset(104)]
                    public uint DefinitionOrder;

                    [FieldOffset(136)]
                    public global::System.IntPtr OriginalPtr;

                    [FieldOffset(168)]
                    public CppSharp.Parser.AST.QualifiedType.Internal QualifiedType;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11TypedefDeclC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11TypedefDeclC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11TypedefDeclD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);
                }

                private readonly bool __ownsNativeInstance;

                public static new TypedefDecl __CreateInstance(global::System.IntPtr native)
                {
                    return new TypedefDecl((TypedefDecl.Internal*) native);
                }

                public static TypedefDecl __CreateInstance(TypedefDecl.Internal native)
                {
                    return new TypedefDecl(native);
                }

                private static TypedefDecl.Internal* __CopyValue(TypedefDecl.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(184);
                    CppSharp.Parser.AST.TypedefDecl.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (TypedefDecl.Internal*) ret;
                }

                private TypedefDecl(TypedefDecl.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected TypedefDecl(TypedefDecl.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.Declaration.Internal*) native)
                {
                }

                public TypedefDecl()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(184);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.QualifiedType QualifiedType
                {
                    get
                    {
                        return CppSharp.Parser.AST.QualifiedType.__CreateInstance(((Internal*) __Instance)->QualifiedType);
                    }

                    set
                    {
                        ((Internal*) __Instance)->QualifiedType = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance);
                    }
                }
            }

            public unsafe partial class Friend : CppSharp.Parser.AST.Declaration, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 176)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.DeclarationKind Kind;

                    [FieldOffset(4)]
                    public CppSharp.Parser.AST.AccessSpecifier Access;

                    [FieldOffset(8)]
                    public global::System.IntPtr _Namespace;

                    [FieldOffset(16)]
                    public CppSharp.Parser.SourceLocation.Internal Location;

                    [FieldOffset(20)]
                    public int LineNumberStart;

                    [FieldOffset(24)]
                    public int LineNumberEnd;

                    [FieldOffset(56)]
                    public global::System.IntPtr Comment;

                    [FieldOffset(88)]
                    public bool IsIncomplete;

                    [FieldOffset(89)]
                    public bool IsDependent;

                    [FieldOffset(96)]
                    public global::System.IntPtr CompleteDeclaration;

                    [FieldOffset(104)]
                    public uint DefinitionOrder;

                    [FieldOffset(136)]
                    public global::System.IntPtr OriginalPtr;

                    [FieldOffset(168)]
                    public global::System.IntPtr Declaration;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST6FriendC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST6FriendC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST6FriendD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);
                }

                private readonly bool __ownsNativeInstance;

                public static new Friend __CreateInstance(global::System.IntPtr native)
                {
                    return new Friend((Friend.Internal*) native);
                }

                public static Friend __CreateInstance(Friend.Internal native)
                {
                    return new Friend(native);
                }

                private static Friend.Internal* __CopyValue(Friend.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(176);
                    CppSharp.Parser.AST.Friend.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (Friend.Internal*) ret;
                }

                private Friend(Friend.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected Friend(Friend.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.Declaration.Internal*) native)
                {
                }

                public Friend()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(176);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.Declaration Declaration
                {
                    get
                    {
                        return (((Internal*) __Instance)->Declaration == IntPtr.Zero) ? null : CppSharp.Parser.AST.Declaration.__CreateInstance(((Internal*) __Instance)->Declaration);
                    }

                    set
                    {
                        ((Internal*) __Instance)->Declaration = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
                    }
                }
            }

            public unsafe partial class Statement : IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 40)]
                public partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.StatementClass Class;

                    [FieldOffset(8)]
                    public global::System.IntPtr Decl;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST9StatementC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST9StatementD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST9Statement9getStringEv")]
                    internal static extern global::System.IntPtr getString_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST9Statement9setStringEPKc")]
                    internal static extern void setString_0(global::System.IntPtr instance, global::System.IntPtr s);
                }

                public global::System.IntPtr __Instance { get; protected set; }

                private readonly bool __ownsNativeInstance;

                public static Statement __CreateInstance(global::System.IntPtr native)
                {
                    return new Statement((Statement.Internal*) native);
                }

                public static Statement __CreateInstance(Statement.Internal native)
                {
                    return new Statement(native);
                }

                private static Statement.Internal* __CopyValue(Statement.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(40);
                    CppSharp.Parser.AST.Statement.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (Statement.Internal*) ret;
                }

                private Statement(Statement.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected Statement(Statement.Internal* native, bool isInternalImpl = false)
                {
                    __Instance = new global::System.IntPtr(native);
                }

                public void Dispose()
                {
                    Dispose(disposing: true);
                    GC.SuppressFinalize(this);
                }

                protected virtual void Dispose(bool disposing)
                {
                    Internal.dtor_0(__Instance);
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                }

                public string String
                {
                    get
                    {
                        var __ret = Internal.getString_0(__Instance);
                        if (__ret == global::System.IntPtr.Zero) return null;
                        return Marshal.PtrToStringAnsi(__ret);
                    }

                    set
                    {
                        var arg0 = Marshal.StringToHGlobalAnsi(value);
                        Internal.setString_0(__Instance, arg0);
                        Marshal.FreeHGlobal(arg0);
                    }
                }

                public CppSharp.Parser.AST.StatementClass Class
                {
                    get
                    {
                        return ((Internal*) __Instance)->Class;
                    }

                    set
                    {
                        ((Internal*) __Instance)->Class = value;
                    }
                }

                public CppSharp.Parser.AST.Declaration Decl
                {
                    get
                    {
                        return (((Internal*) __Instance)->Decl == IntPtr.Zero) ? null : CppSharp.Parser.AST.Declaration.__CreateInstance(((Internal*) __Instance)->Decl);
                    }

                    set
                    {
                        ((Internal*) __Instance)->Decl = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
                    }
                }
            }

            public unsafe partial class Expression : CppSharp.Parser.AST.Statement, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 48)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.StatementClass Class;

                    [FieldOffset(8)]
                    public global::System.IntPtr Decl;

                    [FieldOffset(40)]
                    public global::System.IntPtr Subexpression;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST10ExpressionC2ERKS2_")]
                    internal static extern void cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST10ExpressionD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);
                }

                private readonly bool __ownsNativeInstance;

                public static new Expression __CreateInstance(global::System.IntPtr native)
                {
                    return new Expression((Expression.Internal*) native);
                }

                public static Expression __CreateInstance(Expression.Internal native)
                {
                    return new Expression(native);
                }

                private static Expression.Internal* __CopyValue(Expression.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(48);
                    CppSharp.Parser.AST.Expression.Internal.cctor_1(ret, new global::System.IntPtr(&native));
                    return (Expression.Internal*) ret;
                }

                private Expression(Expression.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected Expression(Expression.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.Statement.Internal*) native)
                {
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.Expression Subexpression
                {
                    get
                    {
                        return (((Internal*) __Instance)->Subexpression == IntPtr.Zero) ? null : CppSharp.Parser.AST.Expression.__CreateInstance(((Internal*) __Instance)->Subexpression);
                    }

                    set
                    {
                        ((Internal*) __Instance)->Subexpression = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
                    }
                }
            }

            public unsafe partial class Parameter : CppSharp.Parser.AST.Declaration, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 200)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.DeclarationKind Kind;

                    [FieldOffset(4)]
                    public CppSharp.Parser.AST.AccessSpecifier Access;

                    [FieldOffset(8)]
                    public global::System.IntPtr _Namespace;

                    [FieldOffset(16)]
                    public CppSharp.Parser.SourceLocation.Internal Location;

                    [FieldOffset(20)]
                    public int LineNumberStart;

                    [FieldOffset(24)]
                    public int LineNumberEnd;

                    [FieldOffset(56)]
                    public global::System.IntPtr Comment;

                    [FieldOffset(88)]
                    public bool IsIncomplete;

                    [FieldOffset(89)]
                    public bool IsDependent;

                    [FieldOffset(96)]
                    public global::System.IntPtr CompleteDeclaration;

                    [FieldOffset(104)]
                    public uint DefinitionOrder;

                    [FieldOffset(136)]
                    public global::System.IntPtr OriginalPtr;

                    [FieldOffset(168)]
                    public CppSharp.Parser.AST.QualifiedType.Internal QualifiedType;

                    [FieldOffset(184)]
                    public bool IsIndirect;

                    [FieldOffset(185)]
                    public bool HasDefaultValue;

                    [FieldOffset(188)]
                    public uint Index;

                    [FieldOffset(192)]
                    public global::System.IntPtr DefaultArgument;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST9ParameterC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST9ParameterC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST9ParameterD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);
                }

                private readonly bool __ownsNativeInstance;

                public static new Parameter __CreateInstance(global::System.IntPtr native)
                {
                    return new Parameter((Parameter.Internal*) native);
                }

                public static Parameter __CreateInstance(Parameter.Internal native)
                {
                    return new Parameter(native);
                }

                private static Parameter.Internal* __CopyValue(Parameter.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(200);
                    CppSharp.Parser.AST.Parameter.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (Parameter.Internal*) ret;
                }

                private Parameter(Parameter.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected Parameter(Parameter.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.Declaration.Internal*) native)
                {
                }

                public Parameter()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(200);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.QualifiedType QualifiedType
                {
                    get
                    {
                        return CppSharp.Parser.AST.QualifiedType.__CreateInstance(((Internal*) __Instance)->QualifiedType);
                    }

                    set
                    {
                        ((Internal*) __Instance)->QualifiedType = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance);
                    }
                }

                public bool IsIndirect
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsIndirect;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsIndirect = value;
                    }
                }

                public bool HasDefaultValue
                {
                    get
                    {
                        return ((Internal*) __Instance)->HasDefaultValue;
                    }

                    set
                    {
                        ((Internal*) __Instance)->HasDefaultValue = value;
                    }
                }

                public uint Index
                {
                    get
                    {
                        return ((Internal*) __Instance)->Index;
                    }

                    set
                    {
                        ((Internal*) __Instance)->Index = value;
                    }
                }

                public CppSharp.Parser.AST.Expression DefaultArgument
                {
                    get
                    {
                        return (((Internal*) __Instance)->DefaultArgument == IntPtr.Zero) ? null : CppSharp.Parser.AST.Expression.__CreateInstance(((Internal*) __Instance)->DefaultArgument);
                    }

                    set
                    {
                        ((Internal*) __Instance)->DefaultArgument = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
                    }
                }
            }

            public unsafe partial class Function : CppSharp.Parser.AST.Declaration, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 288)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.DeclarationKind Kind;

                    [FieldOffset(4)]
                    public CppSharp.Parser.AST.AccessSpecifier Access;

                    [FieldOffset(8)]
                    public global::System.IntPtr _Namespace;

                    [FieldOffset(16)]
                    public CppSharp.Parser.SourceLocation.Internal Location;

                    [FieldOffset(20)]
                    public int LineNumberStart;

                    [FieldOffset(24)]
                    public int LineNumberEnd;

                    [FieldOffset(56)]
                    public global::System.IntPtr Comment;

                    [FieldOffset(88)]
                    public bool IsIncomplete;

                    [FieldOffset(89)]
                    public bool IsDependent;

                    [FieldOffset(96)]
                    public global::System.IntPtr CompleteDeclaration;

                    [FieldOffset(104)]
                    public uint DefinitionOrder;

                    [FieldOffset(136)]
                    public global::System.IntPtr OriginalPtr;

                    [FieldOffset(168)]
                    public CppSharp.Parser.AST.QualifiedType.Internal ReturnType;

                    [FieldOffset(184)]
                    public bool IsReturnIndirect;

                    [FieldOffset(185)]
                    public bool HasThisReturn;

                    [FieldOffset(186)]
                    public bool IsVariadic;

                    [FieldOffset(187)]
                    public bool IsInline;

                    [FieldOffset(188)]
                    public bool IsPure;

                    [FieldOffset(189)]
                    public bool IsDeleted;

                    [FieldOffset(192)]
                    public CppSharp.Parser.AST.CXXOperatorKind OperatorKind;

                    [FieldOffset(248)]
                    public CppSharp.Parser.AST.CallingConvention CallingConvention;

                    [FieldOffset(280)]
                    public global::System.IntPtr SpecializationInfo;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST8FunctionC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST8FunctionC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST8FunctionD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST8Function13getParametersEj")]
                    internal static extern global::System.IntPtr getParameters_0(global::System.IntPtr instance, uint i);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST8Function13addParametersERPNS1_9ParameterE")]
                    internal static extern void addParameters_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST8Function15clearParametersEv")]
                    internal static extern void clearParameters_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST8Function10getMangledEv")]
                    internal static extern global::System.IntPtr getMangled_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST8Function10setMangledEPKc")]
                    internal static extern void setMangled_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST8Function12getSignatureEv")]
                    internal static extern global::System.IntPtr getSignature_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST8Function12setSignatureEPKc")]
                    internal static extern void setSignature_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST8Function18getParametersCountEv")]
                    internal static extern uint getParametersCount_0(global::System.IntPtr instance);
                }

                private readonly bool __ownsNativeInstance;

                public static new Function __CreateInstance(global::System.IntPtr native)
                {
                    return new Function((Function.Internal*) native);
                }

                public static Function __CreateInstance(Function.Internal native)
                {
                    return new Function(native);
                }

                private static Function.Internal* __CopyValue(Function.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(288);
                    CppSharp.Parser.AST.Function.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (Function.Internal*) ret;
                }

                private Function(Function.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected Function(Function.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.Declaration.Internal*) native)
                {
                }

                public Function()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(288);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.Parameter getParameters(uint i)
                {
                    var __ret = Internal.getParameters_0(__Instance, i);
                    if (__ret == global::System.IntPtr.Zero) return null;
                    return (__ret == IntPtr.Zero) ? null : CppSharp.Parser.AST.Parameter.__CreateInstance(__ret);
                }

                public void addParameters(CppSharp.Parser.AST.Parameter s)
                {
                    var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance;
                    Internal.addParameters_0(__Instance, arg0);
                }

                public void clearParameters()
                {
                    Internal.clearParameters_0(__Instance);
                }

                public string Mangled
                {
                    get
                    {
                        var __ret = Internal.getMangled_0(__Instance);
                        if (__ret == global::System.IntPtr.Zero) return null;
                        return Marshal.PtrToStringAnsi(__ret);
                    }

                    set
                    {
                        var arg0 = Marshal.StringToHGlobalAnsi(value);
                        Internal.setMangled_0(__Instance, arg0);
                        Marshal.FreeHGlobal(arg0);
                    }
                }

                public string Signature
                {
                    get
                    {
                        var __ret = Internal.getSignature_0(__Instance);
                        if (__ret == global::System.IntPtr.Zero) return null;
                        return Marshal.PtrToStringAnsi(__ret);
                    }

                    set
                    {
                        var arg0 = Marshal.StringToHGlobalAnsi(value);
                        Internal.setSignature_0(__Instance, arg0);
                        Marshal.FreeHGlobal(arg0);
                    }
                }

                public uint ParametersCount
                {
                    get
                    {
                        var __ret = Internal.getParametersCount_0(__Instance);
                        return __ret;
                    }
                }

                public CppSharp.Parser.AST.QualifiedType ReturnType
                {
                    get
                    {
                        return CppSharp.Parser.AST.QualifiedType.__CreateInstance(((Internal*) __Instance)->ReturnType);
                    }

                    set
                    {
                        ((Internal*) __Instance)->ReturnType = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance);
                    }
                }

                public bool IsReturnIndirect
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsReturnIndirect;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsReturnIndirect = value;
                    }
                }

                public bool HasThisReturn
                {
                    get
                    {
                        return ((Internal*) __Instance)->HasThisReturn;
                    }

                    set
                    {
                        ((Internal*) __Instance)->HasThisReturn = value;
                    }
                }

                public bool IsVariadic
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsVariadic;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsVariadic = value;
                    }
                }

                public bool IsInline
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsInline;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsInline = value;
                    }
                }

                public bool IsPure
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsPure;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsPure = value;
                    }
                }

                public bool IsDeleted
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsDeleted;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsDeleted = value;
                    }
                }

                public CppSharp.Parser.AST.CXXOperatorKind OperatorKind
                {
                    get
                    {
                        return ((Internal*) __Instance)->OperatorKind;
                    }

                    set
                    {
                        ((Internal*) __Instance)->OperatorKind = value;
                    }
                }

                public CppSharp.Parser.AST.CallingConvention CallingConvention
                {
                    get
                    {
                        return ((Internal*) __Instance)->CallingConvention;
                    }

                    set
                    {
                        ((Internal*) __Instance)->CallingConvention = value;
                    }
                }

                public CppSharp.Parser.AST.FunctionTemplateSpecialization SpecializationInfo
                {
                    get
                    {
                        return (((Internal*) __Instance)->SpecializationInfo == IntPtr.Zero) ? null : CppSharp.Parser.AST.FunctionTemplateSpecialization.__CreateInstance(((Internal*) __Instance)->SpecializationInfo);
                    }

                    set
                    {
                        ((Internal*) __Instance)->SpecializationInfo = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
                    }
                }
            }

            public unsafe partial class Method : CppSharp.Parser.AST.Function, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 328)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.DeclarationKind Kind;

                    [FieldOffset(4)]
                    public CppSharp.Parser.AST.AccessSpecifier Access;

                    [FieldOffset(8)]
                    public global::System.IntPtr _Namespace;

                    [FieldOffset(16)]
                    public CppSharp.Parser.SourceLocation.Internal Location;

                    [FieldOffset(20)]
                    public int LineNumberStart;

                    [FieldOffset(24)]
                    public int LineNumberEnd;

                    [FieldOffset(56)]
                    public global::System.IntPtr Comment;

                    [FieldOffset(88)]
                    public bool IsIncomplete;

                    [FieldOffset(89)]
                    public bool IsDependent;

                    [FieldOffset(96)]
                    public global::System.IntPtr CompleteDeclaration;

                    [FieldOffset(104)]
                    public uint DefinitionOrder;

                    [FieldOffset(136)]
                    public global::System.IntPtr OriginalPtr;

                    [FieldOffset(168)]
                    public CppSharp.Parser.AST.QualifiedType.Internal ReturnType;

                    [FieldOffset(184)]
                    public bool IsReturnIndirect;

                    [FieldOffset(185)]
                    public bool HasThisReturn;

                    [FieldOffset(186)]
                    public bool IsVariadic;

                    [FieldOffset(187)]
                    public bool IsInline;

                    [FieldOffset(188)]
                    public bool IsPure;

                    [FieldOffset(189)]
                    public bool IsDeleted;

                    [FieldOffset(192)]
                    public CppSharp.Parser.AST.CXXOperatorKind OperatorKind;

                    [FieldOffset(248)]
                    public CppSharp.Parser.AST.CallingConvention CallingConvention;

                    [FieldOffset(280)]
                    public global::System.IntPtr SpecializationInfo;

                    [FieldOffset(288)]
                    public global::System.IntPtr AccessDecl;

                    [FieldOffset(296)]
                    public bool IsVirtual;

                    [FieldOffset(297)]
                    public bool IsStatic;

                    [FieldOffset(298)]
                    public bool IsConst;

                    [FieldOffset(299)]
                    public bool IsImplicit;

                    [FieldOffset(300)]
                    public bool IsExplicit;

                    [FieldOffset(301)]
                    public bool IsOverride;

                    [FieldOffset(304)]
                    public CppSharp.Parser.AST.CXXMethodKind MethodKind;

                    [FieldOffset(308)]
                    public bool IsDefaultConstructor;

                    [FieldOffset(309)]
                    public bool IsCopyConstructor;

                    [FieldOffset(310)]
                    public bool IsMoveConstructor;

                    [FieldOffset(312)]
                    public CppSharp.Parser.AST.QualifiedType.Internal ConversionType;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST6MethodC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST6MethodC2ERKS2_")]
                    internal static extern void cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST6MethodD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);
                }

                private readonly bool __ownsNativeInstance;

                public static new Method __CreateInstance(global::System.IntPtr native)
                {
                    return new Method((Method.Internal*) native);
                }

                public static Method __CreateInstance(Method.Internal native)
                {
                    return new Method(native);
                }

                private static Method.Internal* __CopyValue(Method.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(328);
                    CppSharp.Parser.AST.Method.Internal.cctor_1(ret, new global::System.IntPtr(&native));
                    return (Method.Internal*) ret;
                }

                private Method(Method.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected Method(Method.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.Function.Internal*) native)
                {
                }

                public Method()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(328);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.AccessSpecifierDecl AccessDecl
                {
                    get
                    {
                        return (((Internal*) __Instance)->AccessDecl == IntPtr.Zero) ? null : CppSharp.Parser.AST.AccessSpecifierDecl.__CreateInstance(((Internal*) __Instance)->AccessDecl);
                    }

                    set
                    {
                        ((Internal*) __Instance)->AccessDecl = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
                    }
                }

                public bool IsVirtual
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsVirtual;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsVirtual = value;
                    }
                }

                public bool IsStatic
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsStatic;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsStatic = value;
                    }
                }

                public bool IsConst
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsConst;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsConst = value;
                    }
                }

                public bool IsImplicit
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsImplicit;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsImplicit = value;
                    }
                }

                public bool IsExplicit
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsExplicit;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsExplicit = value;
                    }
                }

                public bool IsOverride
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsOverride;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsOverride = value;
                    }
                }

                public CppSharp.Parser.AST.CXXMethodKind MethodKind
                {
                    get
                    {
                        return ((Internal*) __Instance)->MethodKind;
                    }

                    set
                    {
                        ((Internal*) __Instance)->MethodKind = value;
                    }
                }

                public bool IsDefaultConstructor
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsDefaultConstructor;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsDefaultConstructor = value;
                    }
                }

                public bool IsCopyConstructor
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsCopyConstructor;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsCopyConstructor = value;
                    }
                }

                public bool IsMoveConstructor
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsMoveConstructor;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsMoveConstructor = value;
                    }
                }

                public CppSharp.Parser.AST.QualifiedType ConversionType
                {
                    get
                    {
                        return CppSharp.Parser.AST.QualifiedType.__CreateInstance(((Internal*) __Instance)->ConversionType);
                    }

                    set
                    {
                        ((Internal*) __Instance)->ConversionType = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance);
                    }
                }
            }

            public unsafe partial class Enumeration : CppSharp.Parser.AST.DeclarationContext, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 432)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.DeclarationKind Kind;

                    [FieldOffset(4)]
                    public CppSharp.Parser.AST.AccessSpecifier Access;

                    [FieldOffset(8)]
                    public global::System.IntPtr _Namespace;

                    [FieldOffset(16)]
                    public CppSharp.Parser.SourceLocation.Internal Location;

                    [FieldOffset(20)]
                    public int LineNumberStart;

                    [FieldOffset(24)]
                    public int LineNumberEnd;

                    [FieldOffset(56)]
                    public global::System.IntPtr Comment;

                    [FieldOffset(88)]
                    public bool IsIncomplete;

                    [FieldOffset(89)]
                    public bool IsDependent;

                    [FieldOffset(96)]
                    public global::System.IntPtr CompleteDeclaration;

                    [FieldOffset(104)]
                    public uint DefinitionOrder;

                    [FieldOffset(136)]
                    public global::System.IntPtr OriginalPtr;

                    [FieldOffset(384)]
                    public bool IsAnonymous;

                    [FieldOffset(388)]
                    public CppSharp.Parser.AST.Enumeration.EnumModifiers Modifiers;

                    [FieldOffset(392)]
                    public global::System.IntPtr Type;

                    [FieldOffset(400)]
                    public global::System.IntPtr BuiltinType;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11EnumerationC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11EnumerationC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11EnumerationD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11Enumeration8getItemsEj")]
                    internal static extern void getItems_0(global::System.IntPtr @return, global::System.IntPtr instance, uint i);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11Enumeration8addItemsERNS2_4ItemE")]
                    internal static extern void addItems_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11Enumeration10clearItemsEv")]
                    internal static extern void clearItems_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11Enumeration13getItemsCountEv")]
                    internal static extern uint getItemsCount_0(global::System.IntPtr instance);
                }

                [Flags]
                public enum EnumModifiers
                {
                    Anonymous = 1,
                    Scoped = 2,
                    Flags = 4
                }

                public unsafe partial class Item : CppSharp.Parser.AST.Declaration, IDisposable
                {
                    [StructLayout(LayoutKind.Explicit, Size = 200)]
                    public new partial struct Internal
                    {
                        [FieldOffset(0)]
                        public CppSharp.Parser.AST.DeclarationKind Kind;

                        [FieldOffset(4)]
                        public CppSharp.Parser.AST.AccessSpecifier Access;

                        [FieldOffset(8)]
                        public global::System.IntPtr _Namespace;

                        [FieldOffset(16)]
                        public CppSharp.Parser.SourceLocation.Internal Location;

                        [FieldOffset(20)]
                        public int LineNumberStart;

                        [FieldOffset(24)]
                        public int LineNumberEnd;

                        [FieldOffset(56)]
                        public global::System.IntPtr Comment;

                        [FieldOffset(88)]
                        public bool IsIncomplete;

                        [FieldOffset(89)]
                        public bool IsDependent;

                        [FieldOffset(96)]
                        public global::System.IntPtr CompleteDeclaration;

                        [FieldOffset(104)]
                        public uint DefinitionOrder;

                        [FieldOffset(136)]
                        public global::System.IntPtr OriginalPtr;

                        [FieldOffset(192)]
                        public ulong Value;

                        [SuppressUnmanagedCodeSecurity]
                        [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                            EntryPoint="_ZN8CppSharp9CppParser3AST11Enumeration4ItemC2Ev")]
                        internal static extern void ctor_0(global::System.IntPtr instance);

                        [SuppressUnmanagedCodeSecurity]
                        [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                            EntryPoint="_ZN8CppSharp9CppParser3AST11Enumeration4ItemC2ERKS3_")]
                        internal static extern void cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);

                        [SuppressUnmanagedCodeSecurity]
                        [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                            EntryPoint="_ZN8CppSharp9CppParser3AST11Enumeration4ItemD2Ev")]
                        internal static extern void dtor_0(global::System.IntPtr instance);

                        [SuppressUnmanagedCodeSecurity]
                        [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                            EntryPoint="_ZN8CppSharp9CppParser3AST11Enumeration4Item13getExpressionEv")]
                        internal static extern global::System.IntPtr getExpression_0(global::System.IntPtr instance);

                        [SuppressUnmanagedCodeSecurity]
                        [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                            EntryPoint="_ZN8CppSharp9CppParser3AST11Enumeration4Item13setExpressionEPKc")]
                        internal static extern void setExpression_0(global::System.IntPtr instance, global::System.IntPtr s);
                    }

                    private readonly bool __ownsNativeInstance;

                    public static new Item __CreateInstance(global::System.IntPtr native)
                    {
                        return new Item((Item.Internal*) native);
                    }

                    public static Item __CreateInstance(Item.Internal native)
                    {
                        return new Item(native);
                    }

                    private static Item.Internal* __CopyValue(Item.Internal native)
                    {
                        var ret = Marshal.AllocHGlobal(200);
                        CppSharp.Parser.AST.Enumeration.Item.Internal.cctor_1(ret, new global::System.IntPtr(&native));
                        return (Item.Internal*) ret;
                    }

                    private Item(Item.Internal native)
                        : this(__CopyValue(native))
                    {
                        __ownsNativeInstance = true;
                    }

                    protected Item(Item.Internal* native, bool isInternalImpl = false)
                        : base((CppSharp.Parser.AST.Declaration.Internal*) native)
                    {
                    }

                    public Item()
                        : this((Internal*) null)
                    {
                        __Instance = Marshal.AllocHGlobal(200);
                        __ownsNativeInstance = true;
                        Internal.ctor_0(__Instance);
                    }

                    protected override void Dispose(bool disposing)
                    {
                        if (__ownsNativeInstance)
                        {
                            Marshal.FreeHGlobal(__Instance);
                        }
                        base.Dispose(disposing);
                    }

                    public string Expression
                    {
                        get
                        {
                            var __ret = Internal.getExpression_0(__Instance);
                            if (__ret == global::System.IntPtr.Zero) return null;
                            return Marshal.PtrToStringAnsi(__ret);
                        }

                        set
                        {
                            var arg0 = Marshal.StringToHGlobalAnsi(value);
                            Internal.setExpression_0(__Instance, arg0);
                            Marshal.FreeHGlobal(arg0);
                        }
                    }

                    public ulong Value
                    {
                        get
                        {
                            return ((Internal*) __Instance)->Value;
                        }

                        set
                        {
                            ((Internal*) __Instance)->Value = value;
                        }
                    }
                }

                private readonly bool __ownsNativeInstance;

                public static new Enumeration __CreateInstance(global::System.IntPtr native)
                {
                    return new Enumeration((Enumeration.Internal*) native);
                }

                public static Enumeration __CreateInstance(Enumeration.Internal native)
                {
                    return new Enumeration(native);
                }

                private static Enumeration.Internal* __CopyValue(Enumeration.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(432);
                    CppSharp.Parser.AST.Enumeration.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (Enumeration.Internal*) ret;
                }

                private Enumeration(Enumeration.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected Enumeration(Enumeration.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.DeclarationContext.Internal*) native)
                {
                }

                public Enumeration()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(432);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.Enumeration.Item getItems(uint i)
                {
                    var __ret = new CppSharp.Parser.AST.Enumeration.Item.Internal();
                    Internal.getItems_0(new IntPtr(&__ret), __Instance, i);
                    return CppSharp.Parser.AST.Enumeration.Item.__CreateInstance(__ret);
                }

                public void addItems(CppSharp.Parser.AST.Enumeration.Item s)
                {
                    var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance;
                    Internal.addItems_0(__Instance, arg0);
                }

                public void clearItems()
                {
                    Internal.clearItems_0(__Instance);
                }

                public uint ItemsCount
                {
                    get
                    {
                        var __ret = Internal.getItemsCount_0(__Instance);
                        return __ret;
                    }
                }

                public CppSharp.Parser.AST.Enumeration.EnumModifiers Modifiers
                {
                    get
                    {
                        return ((Internal*) __Instance)->Modifiers;
                    }

                    set
                    {
                        ((Internal*) __Instance)->Modifiers = value;
                    }
                }

                public CppSharp.Parser.AST.Type Type
                {
                    get
                    {
                        return (((Internal*) __Instance)->Type == IntPtr.Zero) ? null : CppSharp.Parser.AST.Type.__CreateInstance(((Internal*) __Instance)->Type);
                    }

                    set
                    {
                        ((Internal*) __Instance)->Type = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
                    }
                }

                public CppSharp.Parser.AST.BuiltinType BuiltinType
                {
                    get
                    {
                        return (((Internal*) __Instance)->BuiltinType == IntPtr.Zero) ? null : CppSharp.Parser.AST.BuiltinType.__CreateInstance(((Internal*) __Instance)->BuiltinType);
                    }

                    set
                    {
                        ((Internal*) __Instance)->BuiltinType = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
                    }
                }
            }

            public unsafe partial class Variable : CppSharp.Parser.AST.Declaration, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 208)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.DeclarationKind Kind;

                    [FieldOffset(4)]
                    public CppSharp.Parser.AST.AccessSpecifier Access;

                    [FieldOffset(8)]
                    public global::System.IntPtr _Namespace;

                    [FieldOffset(16)]
                    public CppSharp.Parser.SourceLocation.Internal Location;

                    [FieldOffset(20)]
                    public int LineNumberStart;

                    [FieldOffset(24)]
                    public int LineNumberEnd;

                    [FieldOffset(56)]
                    public global::System.IntPtr Comment;

                    [FieldOffset(88)]
                    public bool IsIncomplete;

                    [FieldOffset(89)]
                    public bool IsDependent;

                    [FieldOffset(96)]
                    public global::System.IntPtr CompleteDeclaration;

                    [FieldOffset(104)]
                    public uint DefinitionOrder;

                    [FieldOffset(136)]
                    public global::System.IntPtr OriginalPtr;

                    [FieldOffset(192)]
                    public CppSharp.Parser.AST.QualifiedType.Internal QualifiedType;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST8VariableC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST8VariableC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST8VariableD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST8Variable10getMangledEv")]
                    internal static extern global::System.IntPtr getMangled_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST8Variable10setMangledEPKc")]
                    internal static extern void setMangled_0(global::System.IntPtr instance, global::System.IntPtr s);
                }

                private readonly bool __ownsNativeInstance;

                public static new Variable __CreateInstance(global::System.IntPtr native)
                {
                    return new Variable((Variable.Internal*) native);
                }

                public static Variable __CreateInstance(Variable.Internal native)
                {
                    return new Variable(native);
                }

                private static Variable.Internal* __CopyValue(Variable.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(208);
                    CppSharp.Parser.AST.Variable.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (Variable.Internal*) ret;
                }

                private Variable(Variable.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected Variable(Variable.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.Declaration.Internal*) native)
                {
                }

                public Variable()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(208);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public string Mangled
                {
                    get
                    {
                        var __ret = Internal.getMangled_0(__Instance);
                        if (__ret == global::System.IntPtr.Zero) return null;
                        return Marshal.PtrToStringAnsi(__ret);
                    }

                    set
                    {
                        var arg0 = Marshal.StringToHGlobalAnsi(value);
                        Internal.setMangled_0(__Instance, arg0);
                        Marshal.FreeHGlobal(arg0);
                    }
                }

                public CppSharp.Parser.AST.QualifiedType QualifiedType
                {
                    get
                    {
                        return CppSharp.Parser.AST.QualifiedType.__CreateInstance(((Internal*) __Instance)->QualifiedType);
                    }

                    set
                    {
                        ((Internal*) __Instance)->QualifiedType = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance);
                    }
                }
            }

            public unsafe partial class BaseClassSpecifier : IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 24)]
                public partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.AccessSpecifier Access;

                    [FieldOffset(4)]
                    public bool IsVirtual;

                    [FieldOffset(8)]
                    public global::System.IntPtr Type;

                    [FieldOffset(16)]
                    public int Offset;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18BaseClassSpecifierC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18BaseClassSpecifierC2ERKS2_")]
                    internal static extern void cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                public global::System.IntPtr __Instance { get; protected set; }

                private readonly bool __ownsNativeInstance;

                public static BaseClassSpecifier __CreateInstance(global::System.IntPtr native)
                {
                    return new BaseClassSpecifier((BaseClassSpecifier.Internal*) native);
                }

                public static BaseClassSpecifier __CreateInstance(BaseClassSpecifier.Internal native)
                {
                    return new BaseClassSpecifier(native);
                }

                private static BaseClassSpecifier.Internal* __CopyValue(BaseClassSpecifier.Internal native)
                {
                    var ret = (BaseClassSpecifier.Internal*) Marshal.AllocHGlobal(24);
                    *ret = native;
                    return ret;
                }

                private BaseClassSpecifier(BaseClassSpecifier.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected BaseClassSpecifier(BaseClassSpecifier.Internal* native, bool isInternalImpl = false)
                {
                    __Instance = new global::System.IntPtr(native);
                }

                public BaseClassSpecifier()
                {
                    __Instance = Marshal.AllocHGlobal(24);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                public void Dispose()
                {
                    Dispose(disposing: true);
                    GC.SuppressFinalize(this);
                }

                protected virtual void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                }

                public CppSharp.Parser.AST.AccessSpecifier Access
                {
                    get
                    {
                        return ((Internal*) __Instance)->Access;
                    }

                    set
                    {
                        ((Internal*) __Instance)->Access = value;
                    }
                }

                public bool IsVirtual
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsVirtual;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsVirtual = value;
                    }
                }

                public CppSharp.Parser.AST.Type Type
                {
                    get
                    {
                        return (((Internal*) __Instance)->Type == IntPtr.Zero) ? null : CppSharp.Parser.AST.Type.__CreateInstance(((Internal*) __Instance)->Type);
                    }

                    set
                    {
                        ((Internal*) __Instance)->Type = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
                    }
                }

                public int Offset
                {
                    get
                    {
                        return ((Internal*) __Instance)->Offset;
                    }

                    set
                    {
                        ((Internal*) __Instance)->Offset = value;
                    }
                }
            }

            public unsafe partial class Field : CppSharp.Parser.AST.Declaration, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 208)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.DeclarationKind Kind;

                    [FieldOffset(4)]
                    public CppSharp.Parser.AST.AccessSpecifier Access;

                    [FieldOffset(8)]
                    public global::System.IntPtr _Namespace;

                    [FieldOffset(16)]
                    public CppSharp.Parser.SourceLocation.Internal Location;

                    [FieldOffset(20)]
                    public int LineNumberStart;

                    [FieldOffset(24)]
                    public int LineNumberEnd;

                    [FieldOffset(56)]
                    public global::System.IntPtr Comment;

                    [FieldOffset(88)]
                    public bool IsIncomplete;

                    [FieldOffset(89)]
                    public bool IsDependent;

                    [FieldOffset(96)]
                    public global::System.IntPtr CompleteDeclaration;

                    [FieldOffset(104)]
                    public uint DefinitionOrder;

                    [FieldOffset(136)]
                    public global::System.IntPtr OriginalPtr;

                    [FieldOffset(168)]
                    public CppSharp.Parser.AST.QualifiedType.Internal QualifiedType;

                    [FieldOffset(184)]
                    public uint Offset;

                    [FieldOffset(192)]
                    public global::System.IntPtr Class;

                    [FieldOffset(200)]
                    public bool IsBitField;

                    [FieldOffset(204)]
                    public uint BitWidth;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST5FieldC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST5FieldC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST5FieldD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);
                }

                private readonly bool __ownsNativeInstance;

                public static new Field __CreateInstance(global::System.IntPtr native)
                {
                    return new Field((Field.Internal*) native);
                }

                public static Field __CreateInstance(Field.Internal native)
                {
                    return new Field(native);
                }

                private static Field.Internal* __CopyValue(Field.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(208);
                    CppSharp.Parser.AST.Field.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (Field.Internal*) ret;
                }

                private Field(Field.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected Field(Field.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.Declaration.Internal*) native)
                {
                }

                public Field()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(208);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.QualifiedType QualifiedType
                {
                    get
                    {
                        return CppSharp.Parser.AST.QualifiedType.__CreateInstance(((Internal*) __Instance)->QualifiedType);
                    }

                    set
                    {
                        ((Internal*) __Instance)->QualifiedType = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance);
                    }
                }

                public uint Offset
                {
                    get
                    {
                        return ((Internal*) __Instance)->Offset;
                    }

                    set
                    {
                        ((Internal*) __Instance)->Offset = value;
                    }
                }

                public CppSharp.Parser.AST.Class Class
                {
                    get
                    {
                        return (((Internal*) __Instance)->Class == IntPtr.Zero) ? null : CppSharp.Parser.AST.Class.__CreateInstance(((Internal*) __Instance)->Class);
                    }

                    set
                    {
                        ((Internal*) __Instance)->Class = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
                    }
                }

                public bool IsBitField
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsBitField;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsBitField = value;
                    }
                }

                public uint BitWidth
                {
                    get
                    {
                        return ((Internal*) __Instance)->BitWidth;
                    }

                    set
                    {
                        ((Internal*) __Instance)->BitWidth = value;
                    }
                }
            }

            public unsafe partial class AccessSpecifierDecl : CppSharp.Parser.AST.Declaration, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 168)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.DeclarationKind Kind;

                    [FieldOffset(4)]
                    public CppSharp.Parser.AST.AccessSpecifier Access;

                    [FieldOffset(8)]
                    public global::System.IntPtr _Namespace;

                    [FieldOffset(16)]
                    public CppSharp.Parser.SourceLocation.Internal Location;

                    [FieldOffset(20)]
                    public int LineNumberStart;

                    [FieldOffset(24)]
                    public int LineNumberEnd;

                    [FieldOffset(56)]
                    public global::System.IntPtr Comment;

                    [FieldOffset(88)]
                    public bool IsIncomplete;

                    [FieldOffset(89)]
                    public bool IsDependent;

                    [FieldOffset(96)]
                    public global::System.IntPtr CompleteDeclaration;

                    [FieldOffset(104)]
                    public uint DefinitionOrder;

                    [FieldOffset(136)]
                    public global::System.IntPtr OriginalPtr;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST19AccessSpecifierDeclC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST19AccessSpecifierDeclC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST19AccessSpecifierDeclD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);
                }

                private readonly bool __ownsNativeInstance;

                public static new AccessSpecifierDecl __CreateInstance(global::System.IntPtr native)
                {
                    return new AccessSpecifierDecl((AccessSpecifierDecl.Internal*) native);
                }

                public static AccessSpecifierDecl __CreateInstance(AccessSpecifierDecl.Internal native)
                {
                    return new AccessSpecifierDecl(native);
                }

                private static AccessSpecifierDecl.Internal* __CopyValue(AccessSpecifierDecl.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(168);
                    CppSharp.Parser.AST.AccessSpecifierDecl.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (AccessSpecifierDecl.Internal*) ret;
                }

                private AccessSpecifierDecl(AccessSpecifierDecl.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected AccessSpecifierDecl(AccessSpecifierDecl.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.Declaration.Internal*) native)
                {
                }

                public AccessSpecifierDecl()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(168);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }
            }

            public unsafe partial class Class : CppSharp.Parser.AST.DeclarationContext, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 512)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.DeclarationKind Kind;

                    [FieldOffset(4)]
                    public CppSharp.Parser.AST.AccessSpecifier Access;

                    [FieldOffset(8)]
                    public global::System.IntPtr _Namespace;

                    [FieldOffset(16)]
                    public CppSharp.Parser.SourceLocation.Internal Location;

                    [FieldOffset(20)]
                    public int LineNumberStart;

                    [FieldOffset(24)]
                    public int LineNumberEnd;

                    [FieldOffset(56)]
                    public global::System.IntPtr Comment;

                    [FieldOffset(88)]
                    public bool IsIncomplete;

                    [FieldOffset(89)]
                    public bool IsDependent;

                    [FieldOffset(96)]
                    public global::System.IntPtr CompleteDeclaration;

                    [FieldOffset(104)]
                    public uint DefinitionOrder;

                    [FieldOffset(136)]
                    public global::System.IntPtr OriginalPtr;

                    [FieldOffset(384)]
                    public bool IsAnonymous;

                    [FieldOffset(488)]
                    public bool IsPOD;

                    [FieldOffset(489)]
                    public bool IsAbstract;

                    [FieldOffset(490)]
                    public bool IsUnion;

                    [FieldOffset(491)]
                    public bool IsDynamic;

                    [FieldOffset(492)]
                    public bool IsPolymorphic;

                    [FieldOffset(493)]
                    public bool HasNonTrivialDefaultConstructor;

                    [FieldOffset(494)]
                    public bool HasNonTrivialCopyConstructor;

                    [FieldOffset(495)]
                    public bool HasNonTrivialDestructor;

                    [FieldOffset(496)]
                    public bool IsExternCContext;

                    [FieldOffset(504)]
                    public global::System.IntPtr Layout;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST5ClassC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST5ClassC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST5ClassD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST5Class8getBasesEj")]
                    internal static extern global::System.IntPtr getBases_0(global::System.IntPtr instance, uint i);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST5Class8addBasesERPNS1_18BaseClassSpecifierE")]
                    internal static extern void addBases_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST5Class10clearBasesEv")]
                    internal static extern void clearBases_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST5Class9getFieldsEj")]
                    internal static extern global::System.IntPtr getFields_0(global::System.IntPtr instance, uint i);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST5Class9addFieldsERPNS1_5FieldE")]
                    internal static extern void addFields_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST5Class11clearFieldsEv")]
                    internal static extern void clearFields_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST5Class10getMethodsEj")]
                    internal static extern global::System.IntPtr getMethods_0(global::System.IntPtr instance, uint i);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST5Class10addMethodsERPNS1_6MethodE")]
                    internal static extern void addMethods_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST5Class12clearMethodsEv")]
                    internal static extern void clearMethods_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST5Class13getSpecifiersEj")]
                    internal static extern global::System.IntPtr getSpecifiers_0(global::System.IntPtr instance, uint i);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST5Class13addSpecifiersERPNS1_19AccessSpecifierDeclE")]
                    internal static extern void addSpecifiers_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST5Class15clearSpecifiersEv")]
                    internal static extern void clearSpecifiers_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST5Class13getBasesCountEv")]
                    internal static extern uint getBasesCount_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST5Class14getFieldsCountEv")]
                    internal static extern uint getFieldsCount_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST5Class15getMethodsCountEv")]
                    internal static extern uint getMethodsCount_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST5Class18getSpecifiersCountEv")]
                    internal static extern uint getSpecifiersCount_0(global::System.IntPtr instance);
                }

                private readonly bool __ownsNativeInstance;

                public static new Class __CreateInstance(global::System.IntPtr native)
                {
                    return new Class((Class.Internal*) native);
                }

                public static Class __CreateInstance(Class.Internal native)
                {
                    return new Class(native);
                }

                private static Class.Internal* __CopyValue(Class.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(512);
                    CppSharp.Parser.AST.Class.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (Class.Internal*) ret;
                }

                private Class(Class.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected Class(Class.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.DeclarationContext.Internal*) native)
                {
                }

                public Class()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(512);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.BaseClassSpecifier getBases(uint i)
                {
                    var __ret = Internal.getBases_0(__Instance, i);
                    if (__ret == global::System.IntPtr.Zero) return null;
                    return (__ret == IntPtr.Zero) ? null : CppSharp.Parser.AST.BaseClassSpecifier.__CreateInstance(__ret);
                }

                public void addBases(CppSharp.Parser.AST.BaseClassSpecifier s)
                {
                    var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance;
                    Internal.addBases_0(__Instance, arg0);
                }

                public void clearBases()
                {
                    Internal.clearBases_0(__Instance);
                }

                public CppSharp.Parser.AST.Field getFields(uint i)
                {
                    var __ret = Internal.getFields_0(__Instance, i);
                    if (__ret == global::System.IntPtr.Zero) return null;
                    return (__ret == IntPtr.Zero) ? null : CppSharp.Parser.AST.Field.__CreateInstance(__ret);
                }

                public void addFields(CppSharp.Parser.AST.Field s)
                {
                    var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance;
                    Internal.addFields_0(__Instance, arg0);
                }

                public void clearFields()
                {
                    Internal.clearFields_0(__Instance);
                }

                public CppSharp.Parser.AST.Method getMethods(uint i)
                {
                    var __ret = Internal.getMethods_0(__Instance, i);
                    if (__ret == global::System.IntPtr.Zero) return null;
                    return (__ret == IntPtr.Zero) ? null : CppSharp.Parser.AST.Method.__CreateInstance(__ret);
                }

                public void addMethods(CppSharp.Parser.AST.Method s)
                {
                    var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance;
                    Internal.addMethods_0(__Instance, arg0);
                }

                public void clearMethods()
                {
                    Internal.clearMethods_0(__Instance);
                }

                public CppSharp.Parser.AST.AccessSpecifierDecl getSpecifiers(uint i)
                {
                    var __ret = Internal.getSpecifiers_0(__Instance, i);
                    if (__ret == global::System.IntPtr.Zero) return null;
                    return (__ret == IntPtr.Zero) ? null : CppSharp.Parser.AST.AccessSpecifierDecl.__CreateInstance(__ret);
                }

                public void addSpecifiers(CppSharp.Parser.AST.AccessSpecifierDecl s)
                {
                    var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance;
                    Internal.addSpecifiers_0(__Instance, arg0);
                }

                public void clearSpecifiers()
                {
                    Internal.clearSpecifiers_0(__Instance);
                }

                public uint BasesCount
                {
                    get
                    {
                        var __ret = Internal.getBasesCount_0(__Instance);
                        return __ret;
                    }
                }

                public uint FieldsCount
                {
                    get
                    {
                        var __ret = Internal.getFieldsCount_0(__Instance);
                        return __ret;
                    }
                }

                public uint MethodsCount
                {
                    get
                    {
                        var __ret = Internal.getMethodsCount_0(__Instance);
                        return __ret;
                    }
                }

                public uint SpecifiersCount
                {
                    get
                    {
                        var __ret = Internal.getSpecifiersCount_0(__Instance);
                        return __ret;
                    }
                }

                public bool IsPOD
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsPOD;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsPOD = value;
                    }
                }

                public bool IsAbstract
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsAbstract;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsAbstract = value;
                    }
                }

                public bool IsUnion
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsUnion;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsUnion = value;
                    }
                }

                public bool IsDynamic
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsDynamic;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsDynamic = value;
                    }
                }

                public bool IsPolymorphic
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsPolymorphic;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsPolymorphic = value;
                    }
                }

                public bool HasNonTrivialDefaultConstructor
                {
                    get
                    {
                        return ((Internal*) __Instance)->HasNonTrivialDefaultConstructor;
                    }

                    set
                    {
                        ((Internal*) __Instance)->HasNonTrivialDefaultConstructor = value;
                    }
                }

                public bool HasNonTrivialCopyConstructor
                {
                    get
                    {
                        return ((Internal*) __Instance)->HasNonTrivialCopyConstructor;
                    }

                    set
                    {
                        ((Internal*) __Instance)->HasNonTrivialCopyConstructor = value;
                    }
                }

                public bool HasNonTrivialDestructor
                {
                    get
                    {
                        return ((Internal*) __Instance)->HasNonTrivialDestructor;
                    }

                    set
                    {
                        ((Internal*) __Instance)->HasNonTrivialDestructor = value;
                    }
                }

                public bool IsExternCContext
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsExternCContext;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsExternCContext = value;
                    }
                }

                public CppSharp.Parser.AST.ClassLayout Layout
                {
                    get
                    {
                        return (((Internal*) __Instance)->Layout == IntPtr.Zero) ? null : CppSharp.Parser.AST.ClassLayout.__CreateInstance(((Internal*) __Instance)->Layout);
                    }

                    set
                    {
                        ((Internal*) __Instance)->Layout = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
                    }
                }
            }

            public unsafe partial class Template : CppSharp.Parser.AST.Declaration, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 200)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.DeclarationKind Kind;

                    [FieldOffset(4)]
                    public CppSharp.Parser.AST.AccessSpecifier Access;

                    [FieldOffset(8)]
                    public global::System.IntPtr _Namespace;

                    [FieldOffset(16)]
                    public CppSharp.Parser.SourceLocation.Internal Location;

                    [FieldOffset(20)]
                    public int LineNumberStart;

                    [FieldOffset(24)]
                    public int LineNumberEnd;

                    [FieldOffset(56)]
                    public global::System.IntPtr Comment;

                    [FieldOffset(88)]
                    public bool IsIncomplete;

                    [FieldOffset(89)]
                    public bool IsDependent;

                    [FieldOffset(96)]
                    public global::System.IntPtr CompleteDeclaration;

                    [FieldOffset(104)]
                    public uint DefinitionOrder;

                    [FieldOffset(136)]
                    public global::System.IntPtr OriginalPtr;

                    [FieldOffset(168)]
                    public global::System.IntPtr TemplatedDecl;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST8TemplateC2ENS1_15DeclarationKindE")]
                    internal static extern void ctor_0(global::System.IntPtr instance, CppSharp.Parser.AST.DeclarationKind kind);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST8TemplateC2Ev")]
                    internal static extern void ctor_1(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST8TemplateC2ERKS2_")]
                    internal static extern void cctor_3(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST8TemplateD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST8Template13getParametersEj")]
                    internal static extern void getParameters_0(global::System.IntPtr @return, global::System.IntPtr instance, uint i);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST8Template13addParametersERNS1_17TemplateParameterE")]
                    internal static extern void addParameters_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST8Template15clearParametersEv")]
                    internal static extern void clearParameters_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST8Template18getParametersCountEv")]
                    internal static extern uint getParametersCount_0(global::System.IntPtr instance);
                }

                private readonly bool __ownsNativeInstance;

                public static new Template __CreateInstance(global::System.IntPtr native)
                {
                    return new Template((Template.Internal*) native);
                }

                public static Template __CreateInstance(Template.Internal native)
                {
                    return new Template(native);
                }

                private static Template.Internal* __CopyValue(Template.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(200);
                    CppSharp.Parser.AST.Template.Internal.cctor_3(ret, new global::System.IntPtr(&native));
                    return (Template.Internal*) ret;
                }

                private Template(Template.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected Template(Template.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.Declaration.Internal*) native)
                {
                }

                public Template(CppSharp.Parser.AST.DeclarationKind kind)
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(200);
                    __ownsNativeInstance = true;
                    var arg0 = kind;
                    Internal.ctor_0(__Instance, arg0);
                }

                public Template()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(200);
                    __ownsNativeInstance = true;
                    Internal.ctor_1(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.TemplateParameter getParameters(uint i)
                {
                    var __ret = new CppSharp.Parser.AST.TemplateParameter.Internal();
                    Internal.getParameters_0(new IntPtr(&__ret), __Instance, i);
                    return CppSharp.Parser.AST.TemplateParameter.__CreateInstance(__ret);
                }

                public void addParameters(CppSharp.Parser.AST.TemplateParameter s)
                {
                    var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance;
                    Internal.addParameters_0(__Instance, arg0);
                }

                public void clearParameters()
                {
                    Internal.clearParameters_0(__Instance);
                }

                public uint ParametersCount
                {
                    get
                    {
                        var __ret = Internal.getParametersCount_0(__Instance);
                        return __ret;
                    }
                }

                public CppSharp.Parser.AST.Declaration TemplatedDecl
                {
                    get
                    {
                        return (((Internal*) __Instance)->TemplatedDecl == IntPtr.Zero) ? null : CppSharp.Parser.AST.Declaration.__CreateInstance(((Internal*) __Instance)->TemplatedDecl);
                    }

                    set
                    {
                        ((Internal*) __Instance)->TemplatedDecl = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
                    }
                }
            }

            public unsafe partial class ClassTemplate : CppSharp.Parser.AST.Template, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 224)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.DeclarationKind Kind;

                    [FieldOffset(4)]
                    public CppSharp.Parser.AST.AccessSpecifier Access;

                    [FieldOffset(8)]
                    public global::System.IntPtr _Namespace;

                    [FieldOffset(16)]
                    public CppSharp.Parser.SourceLocation.Internal Location;

                    [FieldOffset(20)]
                    public int LineNumberStart;

                    [FieldOffset(24)]
                    public int LineNumberEnd;

                    [FieldOffset(56)]
                    public global::System.IntPtr Comment;

                    [FieldOffset(88)]
                    public bool IsIncomplete;

                    [FieldOffset(89)]
                    public bool IsDependent;

                    [FieldOffset(96)]
                    public global::System.IntPtr CompleteDeclaration;

                    [FieldOffset(104)]
                    public uint DefinitionOrder;

                    [FieldOffset(136)]
                    public global::System.IntPtr OriginalPtr;

                    [FieldOffset(168)]
                    public global::System.IntPtr TemplatedDecl;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST13ClassTemplateC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST13ClassTemplateC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST13ClassTemplateD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST13ClassTemplate18getSpecializationsEj")]
                    internal static extern global::System.IntPtr getSpecializations_0(global::System.IntPtr instance, uint i);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST13ClassTemplate18addSpecializationsERPNS1_27ClassTemplateSpecializationE")]
                    internal static extern void addSpecializations_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST13ClassTemplate20clearSpecializationsEv")]
                    internal static extern void clearSpecializations_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST13ClassTemplate23getSpecializationsCountEv")]
                    internal static extern uint getSpecializationsCount_0(global::System.IntPtr instance);
                }

                private readonly bool __ownsNativeInstance;

                public static new ClassTemplate __CreateInstance(global::System.IntPtr native)
                {
                    return new ClassTemplate((ClassTemplate.Internal*) native);
                }

                public static ClassTemplate __CreateInstance(ClassTemplate.Internal native)
                {
                    return new ClassTemplate(native);
                }

                private static ClassTemplate.Internal* __CopyValue(ClassTemplate.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(224);
                    CppSharp.Parser.AST.ClassTemplate.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (ClassTemplate.Internal*) ret;
                }

                private ClassTemplate(ClassTemplate.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected ClassTemplate(ClassTemplate.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.Template.Internal*) native)
                {
                }

                public ClassTemplate()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(224);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.ClassTemplateSpecialization getSpecializations(uint i)
                {
                    var __ret = Internal.getSpecializations_0(__Instance, i);
                    if (__ret == global::System.IntPtr.Zero) return null;
                    return (__ret == IntPtr.Zero) ? null : CppSharp.Parser.AST.ClassTemplateSpecialization.__CreateInstance(__ret);
                }

                public void addSpecializations(CppSharp.Parser.AST.ClassTemplateSpecialization s)
                {
                    var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance;
                    Internal.addSpecializations_0(__Instance, arg0);
                }

                public void clearSpecializations()
                {
                    Internal.clearSpecializations_0(__Instance);
                }

                public uint SpecializationsCount
                {
                    get
                    {
                        var __ret = Internal.getSpecializationsCount_0(__Instance);
                        return __ret;
                    }
                }
            }

            public unsafe partial class ClassTemplateSpecialization : CppSharp.Parser.AST.Class, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 552)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.DeclarationKind Kind;

                    [FieldOffset(4)]
                    public CppSharp.Parser.AST.AccessSpecifier Access;

                    [FieldOffset(8)]
                    public global::System.IntPtr _Namespace;

                    [FieldOffset(16)]
                    public CppSharp.Parser.SourceLocation.Internal Location;

                    [FieldOffset(20)]
                    public int LineNumberStart;

                    [FieldOffset(24)]
                    public int LineNumberEnd;

                    [FieldOffset(56)]
                    public global::System.IntPtr Comment;

                    [FieldOffset(88)]
                    public bool IsIncomplete;

                    [FieldOffset(89)]
                    public bool IsDependent;

                    [FieldOffset(96)]
                    public global::System.IntPtr CompleteDeclaration;

                    [FieldOffset(104)]
                    public uint DefinitionOrder;

                    [FieldOffset(136)]
                    public global::System.IntPtr OriginalPtr;

                    [FieldOffset(384)]
                    public bool IsAnonymous;

                    [FieldOffset(488)]
                    public bool IsPOD;

                    [FieldOffset(489)]
                    public bool IsAbstract;

                    [FieldOffset(490)]
                    public bool IsUnion;

                    [FieldOffset(491)]
                    public bool IsDynamic;

                    [FieldOffset(492)]
                    public bool IsPolymorphic;

                    [FieldOffset(493)]
                    public bool HasNonTrivialDefaultConstructor;

                    [FieldOffset(494)]
                    public bool HasNonTrivialCopyConstructor;

                    [FieldOffset(495)]
                    public bool HasNonTrivialDestructor;

                    [FieldOffset(496)]
                    public bool IsExternCContext;

                    [FieldOffset(504)]
                    public global::System.IntPtr Layout;

                    [FieldOffset(512)]
                    public global::System.IntPtr TemplatedDecl;

                    [FieldOffset(544)]
                    public CppSharp.Parser.AST.TemplateSpecializationKind SpecializationKind;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST27ClassTemplateSpecializationC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST27ClassTemplateSpecializationC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST27ClassTemplateSpecializationD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST27ClassTemplateSpecialization12getArgumentsEj")]
                    internal static extern void getArguments_0(global::System.IntPtr @return, global::System.IntPtr instance, uint i);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST27ClassTemplateSpecialization12addArgumentsERNS1_16TemplateArgumentE")]
                    internal static extern void addArguments_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST27ClassTemplateSpecialization14clearArgumentsEv")]
                    internal static extern void clearArguments_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST27ClassTemplateSpecialization17getArgumentsCountEv")]
                    internal static extern uint getArgumentsCount_0(global::System.IntPtr instance);
                }

                private readonly bool __ownsNativeInstance;

                public static new ClassTemplateSpecialization __CreateInstance(global::System.IntPtr native)
                {
                    return new ClassTemplateSpecialization((ClassTemplateSpecialization.Internal*) native);
                }

                public static ClassTemplateSpecialization __CreateInstance(ClassTemplateSpecialization.Internal native)
                {
                    return new ClassTemplateSpecialization(native);
                }

                private static ClassTemplateSpecialization.Internal* __CopyValue(ClassTemplateSpecialization.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(552);
                    CppSharp.Parser.AST.ClassTemplateSpecialization.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (ClassTemplateSpecialization.Internal*) ret;
                }

                private ClassTemplateSpecialization(ClassTemplateSpecialization.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected ClassTemplateSpecialization(ClassTemplateSpecialization.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.Class.Internal*) native)
                {
                }

                public ClassTemplateSpecialization()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(552);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.TemplateArgument getArguments(uint i)
                {
                    var __ret = new CppSharp.Parser.AST.TemplateArgument.Internal();
                    Internal.getArguments_0(new IntPtr(&__ret), __Instance, i);
                    return CppSharp.Parser.AST.TemplateArgument.__CreateInstance(__ret);
                }

                public void addArguments(CppSharp.Parser.AST.TemplateArgument s)
                {
                    var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance;
                    Internal.addArguments_0(__Instance, arg0);
                }

                public void clearArguments()
                {
                    Internal.clearArguments_0(__Instance);
                }

                public uint ArgumentsCount
                {
                    get
                    {
                        var __ret = Internal.getArgumentsCount_0(__Instance);
                        return __ret;
                    }
                }

                public CppSharp.Parser.AST.ClassTemplate TemplatedDecl
                {
                    get
                    {
                        return (((Internal*) __Instance)->TemplatedDecl == IntPtr.Zero) ? null : CppSharp.Parser.AST.ClassTemplate.__CreateInstance(((Internal*) __Instance)->TemplatedDecl);
                    }

                    set
                    {
                        ((Internal*) __Instance)->TemplatedDecl = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
                    }
                }

                public CppSharp.Parser.AST.TemplateSpecializationKind SpecializationKind
                {
                    get
                    {
                        return ((Internal*) __Instance)->SpecializationKind;
                    }

                    set
                    {
                        ((Internal*) __Instance)->SpecializationKind = value;
                    }
                }
            }

            public unsafe partial class ClassTemplatePartialSpecialization : CppSharp.Parser.AST.ClassTemplateSpecialization, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 552)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.DeclarationKind Kind;

                    [FieldOffset(4)]
                    public CppSharp.Parser.AST.AccessSpecifier Access;

                    [FieldOffset(8)]
                    public global::System.IntPtr _Namespace;

                    [FieldOffset(16)]
                    public CppSharp.Parser.SourceLocation.Internal Location;

                    [FieldOffset(20)]
                    public int LineNumberStart;

                    [FieldOffset(24)]
                    public int LineNumberEnd;

                    [FieldOffset(56)]
                    public global::System.IntPtr Comment;

                    [FieldOffset(88)]
                    public bool IsIncomplete;

                    [FieldOffset(89)]
                    public bool IsDependent;

                    [FieldOffset(96)]
                    public global::System.IntPtr CompleteDeclaration;

                    [FieldOffset(104)]
                    public uint DefinitionOrder;

                    [FieldOffset(136)]
                    public global::System.IntPtr OriginalPtr;

                    [FieldOffset(384)]
                    public bool IsAnonymous;

                    [FieldOffset(488)]
                    public bool IsPOD;

                    [FieldOffset(489)]
                    public bool IsAbstract;

                    [FieldOffset(490)]
                    public bool IsUnion;

                    [FieldOffset(491)]
                    public bool IsDynamic;

                    [FieldOffset(492)]
                    public bool IsPolymorphic;

                    [FieldOffset(493)]
                    public bool HasNonTrivialDefaultConstructor;

                    [FieldOffset(494)]
                    public bool HasNonTrivialCopyConstructor;

                    [FieldOffset(495)]
                    public bool HasNonTrivialDestructor;

                    [FieldOffset(496)]
                    public bool IsExternCContext;

                    [FieldOffset(504)]
                    public global::System.IntPtr Layout;

                    [FieldOffset(512)]
                    public global::System.IntPtr TemplatedDecl;

                    [FieldOffset(544)]
                    public CppSharp.Parser.AST.TemplateSpecializationKind SpecializationKind;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST34ClassTemplatePartialSpecializationC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST34ClassTemplatePartialSpecializationC2ERKS2_")]
                    internal static extern void cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST34ClassTemplatePartialSpecializationD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);
                }

                private readonly bool __ownsNativeInstance;

                public static new ClassTemplatePartialSpecialization __CreateInstance(global::System.IntPtr native)
                {
                    return new ClassTemplatePartialSpecialization((ClassTemplatePartialSpecialization.Internal*) native);
                }

                public static ClassTemplatePartialSpecialization __CreateInstance(ClassTemplatePartialSpecialization.Internal native)
                {
                    return new ClassTemplatePartialSpecialization(native);
                }

                private static ClassTemplatePartialSpecialization.Internal* __CopyValue(ClassTemplatePartialSpecialization.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(552);
                    CppSharp.Parser.AST.ClassTemplatePartialSpecialization.Internal.cctor_1(ret, new global::System.IntPtr(&native));
                    return (ClassTemplatePartialSpecialization.Internal*) ret;
                }

                private ClassTemplatePartialSpecialization(ClassTemplatePartialSpecialization.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected ClassTemplatePartialSpecialization(ClassTemplatePartialSpecialization.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.ClassTemplateSpecialization.Internal*) native)
                {
                }

                public ClassTemplatePartialSpecialization()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(552);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }
            }

            public unsafe partial class FunctionTemplate : CppSharp.Parser.AST.Template, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 224)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.DeclarationKind Kind;

                    [FieldOffset(4)]
                    public CppSharp.Parser.AST.AccessSpecifier Access;

                    [FieldOffset(8)]
                    public global::System.IntPtr _Namespace;

                    [FieldOffset(16)]
                    public CppSharp.Parser.SourceLocation.Internal Location;

                    [FieldOffset(20)]
                    public int LineNumberStart;

                    [FieldOffset(24)]
                    public int LineNumberEnd;

                    [FieldOffset(56)]
                    public global::System.IntPtr Comment;

                    [FieldOffset(88)]
                    public bool IsIncomplete;

                    [FieldOffset(89)]
                    public bool IsDependent;

                    [FieldOffset(96)]
                    public global::System.IntPtr CompleteDeclaration;

                    [FieldOffset(104)]
                    public uint DefinitionOrder;

                    [FieldOffset(136)]
                    public global::System.IntPtr OriginalPtr;

                    [FieldOffset(168)]
                    public global::System.IntPtr TemplatedDecl;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST16FunctionTemplateC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST16FunctionTemplateC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST16FunctionTemplateD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST16FunctionTemplate18getSpecializationsEj")]
                    internal static extern global::System.IntPtr getSpecializations_0(global::System.IntPtr instance, uint i);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST16FunctionTemplate18addSpecializationsERPNS1_30FunctionTemplateSpecializationE")]
                    internal static extern void addSpecializations_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST16FunctionTemplate20clearSpecializationsEv")]
                    internal static extern void clearSpecializations_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST16FunctionTemplate23getSpecializationsCountEv")]
                    internal static extern uint getSpecializationsCount_0(global::System.IntPtr instance);
                }

                private readonly bool __ownsNativeInstance;

                public static new FunctionTemplate __CreateInstance(global::System.IntPtr native)
                {
                    return new FunctionTemplate((FunctionTemplate.Internal*) native);
                }

                public static FunctionTemplate __CreateInstance(FunctionTemplate.Internal native)
                {
                    return new FunctionTemplate(native);
                }

                private static FunctionTemplate.Internal* __CopyValue(FunctionTemplate.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(224);
                    CppSharp.Parser.AST.FunctionTemplate.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (FunctionTemplate.Internal*) ret;
                }

                private FunctionTemplate(FunctionTemplate.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected FunctionTemplate(FunctionTemplate.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.Template.Internal*) native)
                {
                }

                public FunctionTemplate()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(224);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.FunctionTemplateSpecialization getSpecializations(uint i)
                {
                    var __ret = Internal.getSpecializations_0(__Instance, i);
                    if (__ret == global::System.IntPtr.Zero) return null;
                    return (__ret == IntPtr.Zero) ? null : CppSharp.Parser.AST.FunctionTemplateSpecialization.__CreateInstance(__ret);
                }

                public void addSpecializations(CppSharp.Parser.AST.FunctionTemplateSpecialization s)
                {
                    var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance;
                    Internal.addSpecializations_0(__Instance, arg0);
                }

                public void clearSpecializations()
                {
                    Internal.clearSpecializations_0(__Instance);
                }

                public uint SpecializationsCount
                {
                    get
                    {
                        var __ret = Internal.getSpecializationsCount_0(__Instance);
                        return __ret;
                    }
                }
            }

            public unsafe partial class FunctionTemplateSpecialization : IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 48)]
                public partial struct Internal
                {
                    [FieldOffset(0)]
                    public global::System.IntPtr Template;

                    [FieldOffset(32)]
                    public global::System.IntPtr SpecializedFunction;

                    [FieldOffset(40)]
                    public CppSharp.Parser.AST.TemplateSpecializationKind SpecializationKind;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST30FunctionTemplateSpecializationC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST30FunctionTemplateSpecializationC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST30FunctionTemplateSpecializationD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST30FunctionTemplateSpecialization12getArgumentsEj")]
                    internal static extern void getArguments_0(global::System.IntPtr @return, global::System.IntPtr instance, uint i);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST30FunctionTemplateSpecialization12addArgumentsERNS1_16TemplateArgumentE")]
                    internal static extern void addArguments_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST30FunctionTemplateSpecialization14clearArgumentsEv")]
                    internal static extern void clearArguments_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST30FunctionTemplateSpecialization17getArgumentsCountEv")]
                    internal static extern uint getArgumentsCount_0(global::System.IntPtr instance);
                }

                public global::System.IntPtr __Instance { get; protected set; }

                private readonly bool __ownsNativeInstance;

                public static FunctionTemplateSpecialization __CreateInstance(global::System.IntPtr native)
                {
                    return new FunctionTemplateSpecialization((FunctionTemplateSpecialization.Internal*) native);
                }

                public static FunctionTemplateSpecialization __CreateInstance(FunctionTemplateSpecialization.Internal native)
                {
                    return new FunctionTemplateSpecialization(native);
                }

                private static FunctionTemplateSpecialization.Internal* __CopyValue(FunctionTemplateSpecialization.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(48);
                    CppSharp.Parser.AST.FunctionTemplateSpecialization.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (FunctionTemplateSpecialization.Internal*) ret;
                }

                private FunctionTemplateSpecialization(FunctionTemplateSpecialization.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected FunctionTemplateSpecialization(FunctionTemplateSpecialization.Internal* native, bool isInternalImpl = false)
                {
                    __Instance = new global::System.IntPtr(native);
                }

                public FunctionTemplateSpecialization()
                {
                    __Instance = Marshal.AllocHGlobal(48);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                public void Dispose()
                {
                    Dispose(disposing: true);
                    GC.SuppressFinalize(this);
                }

                protected virtual void Dispose(bool disposing)
                {
                    Internal.dtor_0(__Instance);
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                }

                public CppSharp.Parser.AST.TemplateArgument getArguments(uint i)
                {
                    var __ret = new CppSharp.Parser.AST.TemplateArgument.Internal();
                    Internal.getArguments_0(new IntPtr(&__ret), __Instance, i);
                    return CppSharp.Parser.AST.TemplateArgument.__CreateInstance(__ret);
                }

                public void addArguments(CppSharp.Parser.AST.TemplateArgument s)
                {
                    var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance;
                    Internal.addArguments_0(__Instance, arg0);
                }

                public void clearArguments()
                {
                    Internal.clearArguments_0(__Instance);
                }

                public uint ArgumentsCount
                {
                    get
                    {
                        var __ret = Internal.getArgumentsCount_0(__Instance);
                        return __ret;
                    }
                }

                public CppSharp.Parser.AST.FunctionTemplate Template
                {
                    get
                    {
                        return (((Internal*) __Instance)->Template == IntPtr.Zero) ? null : CppSharp.Parser.AST.FunctionTemplate.__CreateInstance(((Internal*) __Instance)->Template);
                    }

                    set
                    {
                        ((Internal*) __Instance)->Template = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
                    }
                }

                public CppSharp.Parser.AST.Function SpecializedFunction
                {
                    get
                    {
                        return (((Internal*) __Instance)->SpecializedFunction == IntPtr.Zero) ? null : CppSharp.Parser.AST.Function.__CreateInstance(((Internal*) __Instance)->SpecializedFunction);
                    }

                    set
                    {
                        ((Internal*) __Instance)->SpecializedFunction = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
                    }
                }

                public CppSharp.Parser.AST.TemplateSpecializationKind SpecializationKind
                {
                    get
                    {
                        return ((Internal*) __Instance)->SpecializationKind;
                    }

                    set
                    {
                        ((Internal*) __Instance)->SpecializationKind = value;
                    }
                }
            }

            public unsafe partial class Namespace : CppSharp.Parser.AST.DeclarationContext, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 392)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.DeclarationKind Kind;

                    [FieldOffset(4)]
                    public CppSharp.Parser.AST.AccessSpecifier Access;

                    [FieldOffset(8)]
                    public global::System.IntPtr _Namespace;

                    [FieldOffset(16)]
                    public CppSharp.Parser.SourceLocation.Internal Location;

                    [FieldOffset(20)]
                    public int LineNumberStart;

                    [FieldOffset(24)]
                    public int LineNumberEnd;

                    [FieldOffset(56)]
                    public global::System.IntPtr Comment;

                    [FieldOffset(88)]
                    public bool IsIncomplete;

                    [FieldOffset(89)]
                    public bool IsDependent;

                    [FieldOffset(96)]
                    public global::System.IntPtr CompleteDeclaration;

                    [FieldOffset(104)]
                    public uint DefinitionOrder;

                    [FieldOffset(136)]
                    public global::System.IntPtr OriginalPtr;

                    [FieldOffset(384)]
                    public bool IsAnonymous;

                    [FieldOffset(385)]
                    public bool IsInline;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST9NamespaceC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST9NamespaceC2ERKS2_")]
                    internal static extern void cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST9NamespaceD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);
                }

                private readonly bool __ownsNativeInstance;

                public static new Namespace __CreateInstance(global::System.IntPtr native)
                {
                    return new Namespace((Namespace.Internal*) native);
                }

                public static Namespace __CreateInstance(Namespace.Internal native)
                {
                    return new Namespace(native);
                }

                private static Namespace.Internal* __CopyValue(Namespace.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(392);
                    CppSharp.Parser.AST.Namespace.Internal.cctor_1(ret, new global::System.IntPtr(&native));
                    return (Namespace.Internal*) ret;
                }

                private Namespace(Namespace.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected Namespace(Namespace.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.DeclarationContext.Internal*) native)
                {
                }

                public Namespace()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(392);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public bool IsInline
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsInline;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsInline = value;
                    }
                }
            }

            public unsafe partial class PreprocessedEntity : CppSharp.Parser.AST.Declaration, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 176)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.DeclarationKind Kind;

                    [FieldOffset(4)]
                    public CppSharp.Parser.AST.AccessSpecifier Access;

                    [FieldOffset(8)]
                    public global::System.IntPtr _Namespace;

                    [FieldOffset(16)]
                    public CppSharp.Parser.SourceLocation.Internal Location;

                    [FieldOffset(20)]
                    public int LineNumberStart;

                    [FieldOffset(24)]
                    public int LineNumberEnd;

                    [FieldOffset(56)]
                    public global::System.IntPtr Comment;

                    [FieldOffset(88)]
                    public bool IsIncomplete;

                    [FieldOffset(89)]
                    public bool IsDependent;

                    [FieldOffset(96)]
                    public global::System.IntPtr CompleteDeclaration;

                    [FieldOffset(104)]
                    public uint DefinitionOrder;

                    [FieldOffset(136)]
                    public global::System.IntPtr OriginalPtr;

                    [FieldOffset(168)]
                    public CppSharp.Parser.AST.MacroLocation MacroLocation;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18PreprocessedEntityC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18PreprocessedEntityC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST18PreprocessedEntityD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);
                }

                private readonly bool __ownsNativeInstance;

                public static new PreprocessedEntity __CreateInstance(global::System.IntPtr native)
                {
                    return new PreprocessedEntity((PreprocessedEntity.Internal*) native);
                }

                public static PreprocessedEntity __CreateInstance(PreprocessedEntity.Internal native)
                {
                    return new PreprocessedEntity(native);
                }

                private static PreprocessedEntity.Internal* __CopyValue(PreprocessedEntity.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(176);
                    CppSharp.Parser.AST.PreprocessedEntity.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (PreprocessedEntity.Internal*) ret;
                }

                private PreprocessedEntity(PreprocessedEntity.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected PreprocessedEntity(PreprocessedEntity.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.Declaration.Internal*) native)
                {
                }

                public PreprocessedEntity()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(176);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.MacroLocation MacroLocation
                {
                    get
                    {
                        return ((Internal*) __Instance)->MacroLocation;
                    }

                    set
                    {
                        ((Internal*) __Instance)->MacroLocation = value;
                    }
                }
            }

            public unsafe partial class MacroDefinition : CppSharp.Parser.AST.PreprocessedEntity, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 200)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.DeclarationKind Kind;

                    [FieldOffset(4)]
                    public CppSharp.Parser.AST.AccessSpecifier Access;

                    [FieldOffset(8)]
                    public global::System.IntPtr _Namespace;

                    [FieldOffset(16)]
                    public CppSharp.Parser.SourceLocation.Internal Location;

                    [FieldOffset(20)]
                    public int LineNumberStart;

                    [FieldOffset(24)]
                    public int LineNumberEnd;

                    [FieldOffset(56)]
                    public global::System.IntPtr Comment;

                    [FieldOffset(88)]
                    public bool IsIncomplete;

                    [FieldOffset(89)]
                    public bool IsDependent;

                    [FieldOffset(96)]
                    public global::System.IntPtr CompleteDeclaration;

                    [FieldOffset(104)]
                    public uint DefinitionOrder;

                    [FieldOffset(136)]
                    public global::System.IntPtr OriginalPtr;

                    [FieldOffset(168)]
                    public CppSharp.Parser.AST.MacroLocation MacroLocation;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST15MacroDefinitionC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST15MacroDefinitionC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST15MacroDefinitionD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST15MacroDefinition13getExpressionEv")]
                    internal static extern global::System.IntPtr getExpression_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST15MacroDefinition13setExpressionEPKc")]
                    internal static extern void setExpression_0(global::System.IntPtr instance, global::System.IntPtr s);
                }

                private readonly bool __ownsNativeInstance;

                public static new MacroDefinition __CreateInstance(global::System.IntPtr native)
                {
                    return new MacroDefinition((MacroDefinition.Internal*) native);
                }

                public static MacroDefinition __CreateInstance(MacroDefinition.Internal native)
                {
                    return new MacroDefinition(native);
                }

                private static MacroDefinition.Internal* __CopyValue(MacroDefinition.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(200);
                    CppSharp.Parser.AST.MacroDefinition.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (MacroDefinition.Internal*) ret;
                }

                private MacroDefinition(MacroDefinition.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected MacroDefinition(MacroDefinition.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.PreprocessedEntity.Internal*) native)
                {
                }

                public MacroDefinition()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(200);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public string Expression
                {
                    get
                    {
                        var __ret = Internal.getExpression_0(__Instance);
                        if (__ret == global::System.IntPtr.Zero) return null;
                        return Marshal.PtrToStringAnsi(__ret);
                    }

                    set
                    {
                        var arg0 = Marshal.StringToHGlobalAnsi(value);
                        Internal.setExpression_0(__Instance, arg0);
                        Marshal.FreeHGlobal(arg0);
                    }
                }
            }

            public unsafe partial class MacroExpansion : CppSharp.Parser.AST.PreprocessedEntity, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 208)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.DeclarationKind Kind;

                    [FieldOffset(4)]
                    public CppSharp.Parser.AST.AccessSpecifier Access;

                    [FieldOffset(8)]
                    public global::System.IntPtr _Namespace;

                    [FieldOffset(16)]
                    public CppSharp.Parser.SourceLocation.Internal Location;

                    [FieldOffset(20)]
                    public int LineNumberStart;

                    [FieldOffset(24)]
                    public int LineNumberEnd;

                    [FieldOffset(56)]
                    public global::System.IntPtr Comment;

                    [FieldOffset(88)]
                    public bool IsIncomplete;

                    [FieldOffset(89)]
                    public bool IsDependent;

                    [FieldOffset(96)]
                    public global::System.IntPtr CompleteDeclaration;

                    [FieldOffset(104)]
                    public uint DefinitionOrder;

                    [FieldOffset(136)]
                    public global::System.IntPtr OriginalPtr;

                    [FieldOffset(168)]
                    public CppSharp.Parser.AST.MacroLocation MacroLocation;

                    [FieldOffset(200)]
                    public global::System.IntPtr Definition;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST14MacroExpansionC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST14MacroExpansionC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST14MacroExpansionD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST14MacroExpansion7getTextEv")]
                    internal static extern global::System.IntPtr getText_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST14MacroExpansion7setTextEPKc")]
                    internal static extern void setText_0(global::System.IntPtr instance, global::System.IntPtr s);
                }

                private readonly bool __ownsNativeInstance;

                public static new MacroExpansion __CreateInstance(global::System.IntPtr native)
                {
                    return new MacroExpansion((MacroExpansion.Internal*) native);
                }

                public static MacroExpansion __CreateInstance(MacroExpansion.Internal native)
                {
                    return new MacroExpansion(native);
                }

                private static MacroExpansion.Internal* __CopyValue(MacroExpansion.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(208);
                    CppSharp.Parser.AST.MacroExpansion.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (MacroExpansion.Internal*) ret;
                }

                private MacroExpansion(MacroExpansion.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected MacroExpansion(MacroExpansion.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.PreprocessedEntity.Internal*) native)
                {
                }

                public MacroExpansion()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(208);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public string Text
                {
                    get
                    {
                        var __ret = Internal.getText_0(__Instance);
                        if (__ret == global::System.IntPtr.Zero) return null;
                        return Marshal.PtrToStringAnsi(__ret);
                    }

                    set
                    {
                        var arg0 = Marshal.StringToHGlobalAnsi(value);
                        Internal.setText_0(__Instance, arg0);
                        Marshal.FreeHGlobal(arg0);
                    }
                }

                public CppSharp.Parser.AST.MacroDefinition Definition
                {
                    get
                    {
                        return (((Internal*) __Instance)->Definition == IntPtr.Zero) ? null : CppSharp.Parser.AST.MacroDefinition.__CreateInstance(((Internal*) __Instance)->Definition);
                    }

                    set
                    {
                        ((Internal*) __Instance)->Definition = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
                    }
                }
            }

            public unsafe partial class TranslationUnit : CppSharp.Parser.AST.Namespace, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 448)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.DeclarationKind Kind;

                    [FieldOffset(4)]
                    public CppSharp.Parser.AST.AccessSpecifier Access;

                    [FieldOffset(8)]
                    public global::System.IntPtr _Namespace;

                    [FieldOffset(16)]
                    public CppSharp.Parser.SourceLocation.Internal Location;

                    [FieldOffset(20)]
                    public int LineNumberStart;

                    [FieldOffset(24)]
                    public int LineNumberEnd;

                    [FieldOffset(56)]
                    public global::System.IntPtr Comment;

                    [FieldOffset(88)]
                    public bool IsIncomplete;

                    [FieldOffset(89)]
                    public bool IsDependent;

                    [FieldOffset(96)]
                    public global::System.IntPtr CompleteDeclaration;

                    [FieldOffset(104)]
                    public uint DefinitionOrder;

                    [FieldOffset(136)]
                    public global::System.IntPtr OriginalPtr;

                    [FieldOffset(384)]
                    public bool IsAnonymous;

                    [FieldOffset(385)]
                    public bool IsInline;

                    [FieldOffset(416)]
                    public bool IsSystemHeader;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST15TranslationUnitC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST15TranslationUnitC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST15TranslationUnitD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST15TranslationUnit9getMacrosEj")]
                    internal static extern global::System.IntPtr getMacros_0(global::System.IntPtr instance, uint i);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST15TranslationUnit9addMacrosERPNS1_15MacroDefinitionE")]
                    internal static extern void addMacros_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST15TranslationUnit11clearMacrosEv")]
                    internal static extern void clearMacros_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST15TranslationUnit11getFileNameEv")]
                    internal static extern global::System.IntPtr getFileName_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST15TranslationUnit11setFileNameEPKc")]
                    internal static extern void setFileName_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST15TranslationUnit14getMacrosCountEv")]
                    internal static extern uint getMacrosCount_0(global::System.IntPtr instance);
                }

                private readonly bool __ownsNativeInstance;

                public static new TranslationUnit __CreateInstance(global::System.IntPtr native)
                {
                    return new TranslationUnit((TranslationUnit.Internal*) native);
                }

                public static TranslationUnit __CreateInstance(TranslationUnit.Internal native)
                {
                    return new TranslationUnit(native);
                }

                private static TranslationUnit.Internal* __CopyValue(TranslationUnit.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(448);
                    CppSharp.Parser.AST.TranslationUnit.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (TranslationUnit.Internal*) ret;
                }

                private TranslationUnit(TranslationUnit.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected TranslationUnit(TranslationUnit.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.Namespace.Internal*) native)
                {
                }

                public TranslationUnit()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(448);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.MacroDefinition getMacros(uint i)
                {
                    var __ret = Internal.getMacros_0(__Instance, i);
                    if (__ret == global::System.IntPtr.Zero) return null;
                    return (__ret == IntPtr.Zero) ? null : CppSharp.Parser.AST.MacroDefinition.__CreateInstance(__ret);
                }

                public void addMacros(CppSharp.Parser.AST.MacroDefinition s)
                {
                    var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance;
                    Internal.addMacros_0(__Instance, arg0);
                }

                public void clearMacros()
                {
                    Internal.clearMacros_0(__Instance);
                }

                public string FileName
                {
                    get
                    {
                        var __ret = Internal.getFileName_0(__Instance);
                        if (__ret == global::System.IntPtr.Zero) return null;
                        return Marshal.PtrToStringAnsi(__ret);
                    }

                    set
                    {
                        var arg0 = Marshal.StringToHGlobalAnsi(value);
                        Internal.setFileName_0(__Instance, arg0);
                        Marshal.FreeHGlobal(arg0);
                    }
                }

                public uint MacrosCount
                {
                    get
                    {
                        var __ret = Internal.getMacrosCount_0(__Instance);
                        return __ret;
                    }
                }

                public bool IsSystemHeader
                {
                    get
                    {
                        return ((Internal*) __Instance)->IsSystemHeader;
                    }

                    set
                    {
                        ((Internal*) __Instance)->IsSystemHeader = value;
                    }
                }
            }

            public unsafe partial class NativeLibrary : IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 80)]
                public partial struct Internal
                {
                    [FieldOffset(24)]
                    public CppSharp.Parser.AST.ArchType ArchType;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST13NativeLibraryC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST13NativeLibraryC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST13NativeLibraryD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST13NativeLibrary10getSymbolsEj")]
                    internal static extern global::System.IntPtr getSymbols_0(global::System.IntPtr instance, uint i);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST13NativeLibrary10addSymbolsEPKc")]
                    internal static extern void addSymbols_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST13NativeLibrary12clearSymbolsEv")]
                    internal static extern void clearSymbols_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST13NativeLibrary15getDependenciesEj")]
                    internal static extern global::System.IntPtr getDependencies_0(global::System.IntPtr instance, uint i);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST13NativeLibrary15addDependenciesEPKc")]
                    internal static extern void addDependencies_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST13NativeLibrary17clearDependenciesEv")]
                    internal static extern void clearDependencies_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST13NativeLibrary11getFileNameEv")]
                    internal static extern global::System.IntPtr getFileName_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST13NativeLibrary11setFileNameEPKc")]
                    internal static extern void setFileName_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST13NativeLibrary15getSymbolsCountEv")]
                    internal static extern uint getSymbolsCount_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST13NativeLibrary20getDependenciesCountEv")]
                    internal static extern uint getDependenciesCount_0(global::System.IntPtr instance);
                }

                public global::System.IntPtr __Instance { get; protected set; }

                private readonly bool __ownsNativeInstance;

                public static NativeLibrary __CreateInstance(global::System.IntPtr native)
                {
                    return new NativeLibrary((NativeLibrary.Internal*) native);
                }

                public static NativeLibrary __CreateInstance(NativeLibrary.Internal native)
                {
                    return new NativeLibrary(native);
                }

                private static NativeLibrary.Internal* __CopyValue(NativeLibrary.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(80);
                    CppSharp.Parser.AST.NativeLibrary.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (NativeLibrary.Internal*) ret;
                }

                private NativeLibrary(NativeLibrary.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected NativeLibrary(NativeLibrary.Internal* native, bool isInternalImpl = false)
                {
                    __Instance = new global::System.IntPtr(native);
                }

                public NativeLibrary()
                {
                    __Instance = Marshal.AllocHGlobal(80);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                public void Dispose()
                {
                    Dispose(disposing: true);
                    GC.SuppressFinalize(this);
                }

                protected virtual void Dispose(bool disposing)
                {
                    Internal.dtor_0(__Instance);
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                }

                public string getSymbols(uint i)
                {
                    var __ret = Internal.getSymbols_0(__Instance, i);
                    if (__ret == global::System.IntPtr.Zero) return null;
                    return Marshal.PtrToStringAnsi(__ret);
                }

                public void addSymbols(string s)
                {
                    var arg0 = Marshal.StringToHGlobalAnsi(s);
                    Internal.addSymbols_0(__Instance, arg0);
                    Marshal.FreeHGlobal(arg0);
                }

                public void clearSymbols()
                {
                    Internal.clearSymbols_0(__Instance);
                }

                public string getDependencies(uint i)
                {
                    var __ret = Internal.getDependencies_0(__Instance, i);
                    if (__ret == global::System.IntPtr.Zero) return null;
                    return Marshal.PtrToStringAnsi(__ret);
                }

                public void addDependencies(string s)
                {
                    var arg0 = Marshal.StringToHGlobalAnsi(s);
                    Internal.addDependencies_0(__Instance, arg0);
                    Marshal.FreeHGlobal(arg0);
                }

                public void clearDependencies()
                {
                    Internal.clearDependencies_0(__Instance);
                }

                public string FileName
                {
                    get
                    {
                        var __ret = Internal.getFileName_0(__Instance);
                        if (__ret == global::System.IntPtr.Zero) return null;
                        return Marshal.PtrToStringAnsi(__ret);
                    }

                    set
                    {
                        var arg0 = Marshal.StringToHGlobalAnsi(value);
                        Internal.setFileName_0(__Instance, arg0);
                        Marshal.FreeHGlobal(arg0);
                    }
                }

                public uint SymbolsCount
                {
                    get
                    {
                        var __ret = Internal.getSymbolsCount_0(__Instance);
                        return __ret;
                    }
                }

                public uint DependenciesCount
                {
                    get
                    {
                        var __ret = Internal.getDependenciesCount_0(__Instance);
                        return __ret;
                    }
                }

                public CppSharp.Parser.AST.ArchType ArchType
                {
                    get
                    {
                        return ((Internal*) __Instance)->ArchType;
                    }

                    set
                    {
                        ((Internal*) __Instance)->ArchType = value;
                    }
                }
            }

            public unsafe partial class ASTContext : IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 24)]
                public partial struct Internal
                {
                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST10ASTContextC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST10ASTContextC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST10ASTContextD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST10ASTContext19getTranslationUnitsEj")]
                    internal static extern global::System.IntPtr getTranslationUnits_0(global::System.IntPtr instance, uint i);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST10ASTContext19addTranslationUnitsERPNS1_15TranslationUnitE")]
                    internal static extern void addTranslationUnits_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST10ASTContext21clearTranslationUnitsEv")]
                    internal static extern void clearTranslationUnits_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST10ASTContext24getTranslationUnitsCountEv")]
                    internal static extern uint getTranslationUnitsCount_0(global::System.IntPtr instance);
                }

                public global::System.IntPtr __Instance { get; protected set; }

                private readonly bool __ownsNativeInstance;

                public static ASTContext __CreateInstance(global::System.IntPtr native)
                {
                    return new ASTContext((ASTContext.Internal*) native);
                }

                public static ASTContext __CreateInstance(ASTContext.Internal native)
                {
                    return new ASTContext(native);
                }

                private static ASTContext.Internal* __CopyValue(ASTContext.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(24);
                    CppSharp.Parser.AST.ASTContext.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (ASTContext.Internal*) ret;
                }

                private ASTContext(ASTContext.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected ASTContext(ASTContext.Internal* native, bool isInternalImpl = false)
                {
                    __Instance = new global::System.IntPtr(native);
                }

                public ASTContext()
                {
                    __Instance = Marshal.AllocHGlobal(24);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                public void Dispose()
                {
                    Dispose(disposing: true);
                    GC.SuppressFinalize(this);
                }

                protected virtual void Dispose(bool disposing)
                {
                    Internal.dtor_0(__Instance);
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                }

                public CppSharp.Parser.AST.TranslationUnit getTranslationUnits(uint i)
                {
                    var __ret = Internal.getTranslationUnits_0(__Instance, i);
                    if (__ret == global::System.IntPtr.Zero) return null;
                    return (__ret == IntPtr.Zero) ? null : CppSharp.Parser.AST.TranslationUnit.__CreateInstance(__ret);
                }

                public void addTranslationUnits(CppSharp.Parser.AST.TranslationUnit s)
                {
                    var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance;
                    Internal.addTranslationUnits_0(__Instance, arg0);
                }

                public void clearTranslationUnits()
                {
                    Internal.clearTranslationUnits_0(__Instance);
                }

                public uint TranslationUnitsCount
                {
                    get
                    {
                        var __ret = Internal.getTranslationUnitsCount_0(__Instance);
                        return __ret;
                    }
                }
            }

            public unsafe partial class Comment : IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 4)]
                public partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.CommentKind Kind;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST7CommentC2ENS1_11CommentKindE")]
                    internal static extern void ctor_0(global::System.IntPtr instance, CppSharp.Parser.AST.CommentKind kind);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST7CommentC2ERKS2_")]
                    internal static extern void cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                public global::System.IntPtr __Instance { get; protected set; }

                private readonly bool __ownsNativeInstance;

                public static Comment __CreateInstance(global::System.IntPtr native)
                {
                    return new Comment((Comment.Internal*) native);
                }

                public static Comment __CreateInstance(Comment.Internal native)
                {
                    return new Comment(native);
                }

                private static Comment.Internal* __CopyValue(Comment.Internal native)
                {
                    var ret = (Comment.Internal*) Marshal.AllocHGlobal(4);
                    *ret = native;
                    return ret;
                }

                private Comment(Comment.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected Comment(Comment.Internal* native, bool isInternalImpl = false)
                {
                    __Instance = new global::System.IntPtr(native);
                }

                public Comment(CppSharp.Parser.AST.CommentKind kind)
                {
                    __Instance = Marshal.AllocHGlobal(4);
                    __ownsNativeInstance = true;
                    var arg0 = kind;
                    Internal.ctor_0(__Instance, arg0);
                }

                public void Dispose()
                {
                    Dispose(disposing: true);
                    GC.SuppressFinalize(this);
                }

                protected virtual void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                }

                public CppSharp.Parser.AST.CommentKind Kind
                {
                    get
                    {
                        return ((Internal*) __Instance)->Kind;
                    }

                    set
                    {
                        ((Internal*) __Instance)->Kind = value;
                    }
                }
            }

            public unsafe partial class FullComment : CppSharp.Parser.AST.Comment, IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 4)]
                public new partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.CommentKind Kind;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11FullCommentC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST11FullCommentC2ERKS2_")]
                    internal static extern void cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                private readonly bool __ownsNativeInstance;

                public static new FullComment __CreateInstance(global::System.IntPtr native)
                {
                    return new FullComment((FullComment.Internal*) native);
                }

                public static FullComment __CreateInstance(FullComment.Internal native)
                {
                    return new FullComment(native);
                }

                private static FullComment.Internal* __CopyValue(FullComment.Internal native)
                {
                    var ret = (FullComment.Internal*) Marshal.AllocHGlobal(4);
                    *ret = native;
                    return ret;
                }

                private FullComment(FullComment.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected FullComment(FullComment.Internal* native, bool isInternalImpl = false)
                    : base((CppSharp.Parser.AST.Comment.Internal*) native)
                {
                }

                public FullComment()
                    : this((Internal*) null)
                {
                    __Instance = Marshal.AllocHGlobal(4);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                    base.Dispose(disposing);
                }
            }

            public unsafe partial class RawComment : IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 64)]
                public partial struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.RawCommentKind Kind;

                    [FieldOffset(56)]
                    public global::System.IntPtr FullCommentBlock;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST10RawCommentC2Ev")]
                    internal static extern void ctor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST10RawCommentC2ERKS2_")]
                    internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST10RawCommentD2Ev")]
                    internal static extern void dtor_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST10RawComment7getTextEv")]
                    internal static extern global::System.IntPtr getText_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST10RawComment7setTextEPKc")]
                    internal static extern void setText_0(global::System.IntPtr instance, global::System.IntPtr s);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST10RawComment12getBriefTextEv")]
                    internal static extern global::System.IntPtr getBriefText_0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="_ZN8CppSharp9CppParser3AST10RawComment12setBriefTextEPKc")]
                    internal static extern void setBriefText_0(global::System.IntPtr instance, global::System.IntPtr s);
                }

                public global::System.IntPtr __Instance { get; protected set; }

                private readonly bool __ownsNativeInstance;

                public static RawComment __CreateInstance(global::System.IntPtr native)
                {
                    return new RawComment((RawComment.Internal*) native);
                }

                public static RawComment __CreateInstance(RawComment.Internal native)
                {
                    return new RawComment(native);
                }

                private static RawComment.Internal* __CopyValue(RawComment.Internal native)
                {
                    var ret = Marshal.AllocHGlobal(64);
                    CppSharp.Parser.AST.RawComment.Internal.cctor_2(ret, new global::System.IntPtr(&native));
                    return (RawComment.Internal*) ret;
                }

                private RawComment(RawComment.Internal native)
                    : this(__CopyValue(native))
                {
                    __ownsNativeInstance = true;
                }

                protected RawComment(RawComment.Internal* native, bool isInternalImpl = false)
                {
                    __Instance = new global::System.IntPtr(native);
                }

                public RawComment()
                {
                    __Instance = Marshal.AllocHGlobal(64);
                    __ownsNativeInstance = true;
                    Internal.ctor_0(__Instance);
                }

                public void Dispose()
                {
                    Dispose(disposing: true);
                    GC.SuppressFinalize(this);
                }

                protected virtual void Dispose(bool disposing)
                {
                    Internal.dtor_0(__Instance);
                    if (__ownsNativeInstance)
                    {
                        Marshal.FreeHGlobal(__Instance);
                    }
                }

                public string Text
                {
                    get
                    {
                        var __ret = Internal.getText_0(__Instance);
                        if (__ret == global::System.IntPtr.Zero) return null;
                        return Marshal.PtrToStringAnsi(__ret);
                    }

                    set
                    {
                        var arg0 = Marshal.StringToHGlobalAnsi(value);
                        Internal.setText_0(__Instance, arg0);
                        Marshal.FreeHGlobal(arg0);
                    }
                }

                public string BriefText
                {
                    get
                    {
                        var __ret = Internal.getBriefText_0(__Instance);
                        if (__ret == global::System.IntPtr.Zero) return null;
                        return Marshal.PtrToStringAnsi(__ret);
                    }

                    set
                    {
                        var arg0 = Marshal.StringToHGlobalAnsi(value);
                        Internal.setBriefText_0(__Instance, arg0);
                        Marshal.FreeHGlobal(arg0);
                    }
                }

                public CppSharp.Parser.AST.RawCommentKind Kind
                {
                    get
                    {
                        return ((Internal*) __Instance)->Kind;
                    }

                    set
                    {
                        ((Internal*) __Instance)->Kind = value;
                    }
                }

                public CppSharp.Parser.AST.FullComment FullCommentBlock
                {
                    get
                    {
                        return (((Internal*) __Instance)->FullCommentBlock == IntPtr.Zero) ? null : CppSharp.Parser.AST.FullComment.__CreateInstance(((Internal*) __Instance)->FullCommentBlock);
                    }

                    set
                    {
                        ((Internal*) __Instance)->FullCommentBlock = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
                    }
                }
            }
        }
    }
}