//----------------------------------------------------------------------------
// This is autogenerated code by CppSharp.
// Do not edit this file or all your changes will be lost after re-generation.
//----------------------------------------------------------------------------
using System;
using System.Runtime.InteropServices;
using System.Security;

namespace CppSharp
{
    namespace Parser
    {
        namespace AST
        {
            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 CppAbi
            {
                Itanium = 0,
                Microsoft = 1,
                ARM = 2
            }

            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,
                Int8 = 4,
                Char = 4,
                UInt8 = 5,
                UChar = 5,
                Int16 = 6,
                UInt16 = 7,
                Int32 = 8,
                UInt32 = 9,
                Int64 = 10,
                UInt64 = 11,
                Float = 12,
                Double = 13,
                IntPtr = 14
            }

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

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

            public unsafe partial class Type : IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 1)]
                public struct Internal
                {
                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0Type@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr Type0(global::System.IntPtr instance, global::System.IntPtr _0);
                }

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

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 0; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal Type(Type.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal Type(Type.Internal native)
                    : this(&native)
                {
                }

                internal Type(global::System.IntPtr native)
                {
                    __Instance = native;
                }

                public Type()
                {
                    __Instance = Marshal.AllocHGlobal(1);
                }

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

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

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

                    [FieldOffset(1)]
                    public bool IsVolatile;

                    [FieldOffset(2)]
                    public bool IsRestrict;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0TypeQualifiers@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr TypeQualifiers0(global::System.IntPtr instance, global::System.IntPtr _0);
                }

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

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 3; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal TypeQualifiers(TypeQualifiers.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal TypeQualifiers(TypeQualifiers.Internal native)
                    : this(&native)
                {
                }

                internal TypeQualifiers(global::System.IntPtr native)
                {
                    __Instance = native;
                }

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

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

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

                public bool IsConst
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->IsConst;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->IsConst = value;
                    }
                }

                public bool IsVolatile
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->IsVolatile;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->IsVolatile = value;
                    }
                }

                public bool IsRestrict
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->IsRestrict;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->IsRestrict = value;
                    }
                }
            }

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

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

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0QualifiedType@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr QualifiedType0(global::System.IntPtr instance, global::System.IntPtr _0);
                }

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

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 8; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal QualifiedType(QualifiedType.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal QualifiedType(QualifiedType.Internal native)
                    : this(&native)
                {
                }

                internal QualifiedType(global::System.IntPtr native)
                {
                    __Instance = native;
                }

                public QualifiedType()
                {
                    __Instance = Marshal.AllocHGlobal(8);
                }

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

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

                public CppSharp.Parser.AST.Type Type
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->Type);
                        return new CppSharp.Parser.AST.Type(__copy);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Type = value.__Instance;
                    }
                }

                public CppSharp.Parser.AST.TypeQualifiers Qualifiers
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->Qualifiers);
                        var __instance = Marshal.AllocHGlobal(3);
                        CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__copy), new UIntPtr(3));
                        return new CppSharp.Parser.AST.TypeQualifiers(__instance);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Qualifiers = *(CppSharp.Parser.AST.TypeQualifiers.Internal*)value.__Instance;
                    }
                }
            }

            public unsafe partial class TagType : CppSharp.Parser.AST.Type, IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 4)]
                public new struct Internal
                {
                    [FieldOffset(0)]
                    public global::System.IntPtr Declaration;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0TagType@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr TagType1(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 4; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal TagType(TagType.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal TagType(TagType.Internal native)
                    : this(&native)
                {
                }

                internal TagType(global::System.IntPtr native)
                    : base(native)
                {
                }

                public TagType()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(4);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.Declaration Declaration
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->Declaration);
                        return new CppSharp.Parser.AST.Declaration(__copy);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Declaration = value.__Instance;
                    }
                }
            }

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

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

                    [FieldOffset(12)]
                    public int Size;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0ArrayType@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr ArrayType1(global::System.IntPtr instance, global::System.IntPtr _0);
                }

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

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 16; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal ArrayType(ArrayType.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal ArrayType(ArrayType.Internal native)
                    : this(&native)
                {
                }

                internal ArrayType(global::System.IntPtr native)
                    : base(native)
                {
                }

                public ArrayType()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(16);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.QualifiedType QualifiedType
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->QualifiedType);
                        var __instance = Marshal.AllocHGlobal(8);
                        CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__copy), new UIntPtr(8));
                        return new CppSharp.Parser.AST.QualifiedType(__instance);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->QualifiedType = *(CppSharp.Parser.AST.QualifiedType.Internal*)value.__Instance;
                    }
                }

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

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->SizeType = value;
                    }
                }

                public int Size
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->Size;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Size = value;
                    }
                }
            }

            public unsafe partial class FunctionType : CppSharp.Parser.AST.Type, IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 24)]
                public new struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.QualifiedType.Internal ReturnType;

                    [FieldOffset(8)]
                    public Std.Vector Parameters;

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

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0FunctionType@AST@CppParser@CppSharp@@QAE@XZ")]
                    public static extern global::System.IntPtr FunctionType1(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0FunctionType@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr FunctionType2(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 24; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal FunctionType(FunctionType.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal FunctionType(FunctionType.Internal native)
                    : this(&native)
                {
                }

                internal FunctionType(global::System.IntPtr native)
                    : base(native)
                {
                }

                public FunctionType()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(24);
                    Internal.FunctionType1(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.QualifiedType ReturnType
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->ReturnType);
                        var __instance = Marshal.AllocHGlobal(8);
                        CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__copy), new UIntPtr(8));
                        return new CppSharp.Parser.AST.QualifiedType(__instance);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->ReturnType = *(CppSharp.Parser.AST.QualifiedType.Internal*)value.__Instance;
                    }
                }

                public Std.Vector<CppSharp.Parser.AST.Parameter> Parameters
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return new Std.Vector<CppSharp.Parser.AST.Parameter>(__ptr->Parameters);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Parameters = value.Internal;
                    }
                }

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

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->CallingConvention = value;
                    }
                }
            }

            public unsafe partial class PointerType : CppSharp.Parser.AST.Type, IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 12)]
                public new struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.QualifiedType.Internal QualifiedPointee;

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

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0PointerType@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr PointerType1(global::System.IntPtr instance, global::System.IntPtr _0);
                }

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

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 12; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal PointerType(PointerType.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal PointerType(PointerType.Internal native)
                    : this(&native)
                {
                }

                internal PointerType(global::System.IntPtr native)
                    : base(native)
                {
                }

                public PointerType()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(12);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.QualifiedType QualifiedPointee
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->QualifiedPointee);
                        var __instance = Marshal.AllocHGlobal(8);
                        CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__copy), new UIntPtr(8));
                        return new CppSharp.Parser.AST.QualifiedType(__instance);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->QualifiedPointee = *(CppSharp.Parser.AST.QualifiedType.Internal*)value.__Instance;
                    }
                }

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

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Modifier = value;
                    }
                }
            }

            public unsafe partial class MemberPointerType : CppSharp.Parser.AST.Type, IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 8)]
                public new struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.QualifiedType.Internal Pointee;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0MemberPointerType@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr MemberPointerType1(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 8; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal MemberPointerType(MemberPointerType.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal MemberPointerType(MemberPointerType.Internal native)
                    : this(&native)
                {
                }

                internal MemberPointerType(global::System.IntPtr native)
                    : base(native)
                {
                }

                public MemberPointerType()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(8);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.QualifiedType Pointee
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->Pointee);
                        var __instance = Marshal.AllocHGlobal(8);
                        CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__copy), new UIntPtr(8));
                        return new CppSharp.Parser.AST.QualifiedType(__instance);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Pointee = *(CppSharp.Parser.AST.QualifiedType.Internal*)value.__Instance;
                    }
                }
            }

            public unsafe partial class TypedefType : CppSharp.Parser.AST.Type, IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 4)]
                public new struct Internal
                {
                    [FieldOffset(0)]
                    public global::System.IntPtr Declaration;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0TypedefType@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr TypedefType1(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 4; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal TypedefType(TypedefType.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal TypedefType(TypedefType.Internal native)
                    : this(&native)
                {
                }

                internal TypedefType(global::System.IntPtr native)
                    : base(native)
                {
                }

                public TypedefType()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(4);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.TypedefDecl Declaration
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->Declaration);
                        return new CppSharp.Parser.AST.TypedefDecl(__copy);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Declaration = value.__Instance;
                    }
                }
            }

            public unsafe partial class DecayedType : CppSharp.Parser.AST.Type, IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 24)]
                public new struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.QualifiedType.Internal Decayed;

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

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

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0DecayedType@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr DecayedType1(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 24; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal DecayedType(DecayedType.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal DecayedType(DecayedType.Internal native)
                    : this(&native)
                {
                }

                internal DecayedType(global::System.IntPtr native)
                    : base(native)
                {
                }

                public DecayedType()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(24);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.QualifiedType Decayed
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->Decayed);
                        var __instance = Marshal.AllocHGlobal(8);
                        CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__copy), new UIntPtr(8));
                        return new CppSharp.Parser.AST.QualifiedType(__instance);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Decayed = *(CppSharp.Parser.AST.QualifiedType.Internal*)value.__Instance;
                    }
                }

                public CppSharp.Parser.AST.QualifiedType Original
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->Original);
                        var __instance = Marshal.AllocHGlobal(8);
                        CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__copy), new UIntPtr(8));
                        return new CppSharp.Parser.AST.QualifiedType(__instance);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Original = *(CppSharp.Parser.AST.QualifiedType.Internal*)value.__Instance;
                    }
                }

                public CppSharp.Parser.AST.QualifiedType Pointee
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->Pointee);
                        var __instance = Marshal.AllocHGlobal(8);
                        CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__copy), new UIntPtr(8));
                        return new CppSharp.Parser.AST.QualifiedType(__instance);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Pointee = *(CppSharp.Parser.AST.QualifiedType.Internal*)value.__Instance;
                    }
                }
            }

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

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

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

                    [FieldOffset(16)]
                    public int Integral;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0TemplateArgument@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr TemplateArgument1(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; }

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 20; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal TemplateArgument(TemplateArgument.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal TemplateArgument(TemplateArgument.Internal native)
                    : this(&native)
                {
                }

                internal TemplateArgument(global::System.IntPtr native)
                {
                    __Instance = native;
                }

                public TemplateArgument()
                {
                    __Instance = Marshal.AllocHGlobal(20);
                }

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

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

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

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Kind = value;
                    }
                }

                public CppSharp.Parser.AST.QualifiedType Type
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->Type);
                        var __instance = Marshal.AllocHGlobal(8);
                        CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__copy), new UIntPtr(8));
                        return new CppSharp.Parser.AST.QualifiedType(__instance);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Type = *(CppSharp.Parser.AST.QualifiedType.Internal*)value.__Instance;
                    }
                }

                public CppSharp.Parser.AST.Declaration Declaration
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->Declaration);
                        return new CppSharp.Parser.AST.Declaration(__copy);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Declaration = value.__Instance;
                    }
                }

                public int Integral
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->Integral;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Integral = value;
                    }
                }
            }

            public unsafe partial class TemplateSpecializationType : CppSharp.Parser.AST.Type, IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 20)]
                public new struct Internal
                {
                    [FieldOffset(0)]
                    public Std.Vector Arguments;

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

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

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0TemplateSpecializationType@AST@CppParser@CppSharp@@QAE@XZ")]
                    public static extern global::System.IntPtr TemplateSpecializationType1(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0TemplateSpecializationType@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr TemplateSpecializationType2(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 20; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal TemplateSpecializationType(TemplateSpecializationType.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal TemplateSpecializationType(TemplateSpecializationType.Internal native)
                    : this(&native)
                {
                }

                internal TemplateSpecializationType(global::System.IntPtr native)
                    : base(native)
                {
                }

                public TemplateSpecializationType()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(20);
                    Internal.TemplateSpecializationType1(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }

                public Std.Vector<CppSharp.Parser.AST.TemplateArgument> Arguments
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return new Std.Vector<CppSharp.Parser.AST.TemplateArgument>(__ptr->Arguments);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Arguments = value.Internal;
                    }
                }

                public CppSharp.Parser.AST.Template Template
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->Template);
                        return new CppSharp.Parser.AST.Template(__copy);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Template = value.__Instance;
                    }
                }

                public CppSharp.Parser.AST.Type Desugared
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->Desugared);
                        return new CppSharp.Parser.AST.Type(__copy);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Desugared = value.__Instance;
                    }
                }
            }

            public unsafe partial class TemplateParameter : IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 24)]
                public struct Internal
                {
                    [FieldOffset(0)]
                    public Std.String Name;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0TemplateParameter@AST@CppParser@CppSharp@@QAE@XZ")]
                    public static extern global::System.IntPtr TemplateParameter1(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0TemplateParameter@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr TemplateParameter2(global::System.IntPtr instance, global::System.IntPtr _0);
                }

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

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 24; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal TemplateParameter(TemplateParameter.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal TemplateParameter(TemplateParameter.Internal native)
                    : this(&native)
                {
                }

                internal TemplateParameter(global::System.IntPtr native)
                {
                    __Instance = native;
                }

                public TemplateParameter()
                {
                    __Instance = Marshal.AllocHGlobal(24);
                    Internal.TemplateParameter1(__Instance);
                }

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

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

                public Std.String Name
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->Name;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Name = new Std.String();
                    }
                }
            }

            public unsafe partial class TemplateParameterType : CppSharp.Parser.AST.Type, IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 24)]
                public new struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.TemplateParameter.Internal Parameter;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0TemplateParameterType@AST@CppParser@CppSharp@@QAE@XZ")]
                    public static extern global::System.IntPtr TemplateParameterType0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0TemplateParameterType@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr TemplateParameterType1(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 24; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal TemplateParameterType(TemplateParameterType.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal TemplateParameterType(TemplateParameterType.Internal native)
                    : this(&native)
                {
                }

                internal TemplateParameterType(global::System.IntPtr native)
                    : base(native)
                {
                }

                public TemplateParameterType()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(24);
                    Internal.TemplateParameterType0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.TemplateParameter Parameter
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->Parameter);
                        var __instance = Marshal.AllocHGlobal(24);
                        CppSharp.Parser.AST.TemplateParameter.Internal.TemplateParameter2(__instance, new global::System.IntPtr(&__copy));
                        return new CppSharp.Parser.AST.TemplateParameter(__instance);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Parameter = *(CppSharp.Parser.AST.TemplateParameter.Internal*)value.__Instance;
                    }
                }
            }

            public unsafe partial class TemplateParameterSubstitutionType : CppSharp.Parser.AST.Type, IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 8)]
                public new struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.QualifiedType.Internal Replacement;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0TemplateParameterSubstitutionType@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr TemplateParameterSubstitutionType1(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 8; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal TemplateParameterSubstitutionType(TemplateParameterSubstitutionType.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal TemplateParameterSubstitutionType(TemplateParameterSubstitutionType.Internal native)
                    : this(&native)
                {
                }

                internal TemplateParameterSubstitutionType(global::System.IntPtr native)
                    : base(native)
                {
                }

                public TemplateParameterSubstitutionType()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(8);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.QualifiedType Replacement
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->Replacement);
                        var __instance = Marshal.AllocHGlobal(8);
                        CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__copy), new UIntPtr(8));
                        return new CppSharp.Parser.AST.QualifiedType(__instance);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Replacement = *(CppSharp.Parser.AST.QualifiedType.Internal*)value.__Instance;
                    }
                }
            }

            public unsafe partial class InjectedClassNameType : CppSharp.Parser.AST.Type, IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 28)]
                public new struct Internal
                {
                    [FieldOffset(4)]
                    public CppSharp.Parser.AST.TemplateSpecializationType.Internal TemplateSpecialization;

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

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0InjectedClassNameType@AST@CppParser@CppSharp@@QAE@XZ")]
                    public static extern global::System.IntPtr InjectedClassNameType0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0InjectedClassNameType@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr InjectedClassNameType1(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 28; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal InjectedClassNameType(InjectedClassNameType.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal InjectedClassNameType(InjectedClassNameType.Internal native)
                    : this(&native)
                {
                }

                internal InjectedClassNameType(global::System.IntPtr native)
                    : base(native)
                {
                }

                public InjectedClassNameType()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(28);
                    Internal.InjectedClassNameType0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.TemplateSpecializationType TemplateSpecialization
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->TemplateSpecialization);
                        var __instance = Marshal.AllocHGlobal(20);
                        CppSharp.Parser.AST.TemplateSpecializationType.Internal.TemplateSpecializationType2(__instance, new global::System.IntPtr(&__copy));
                        return new CppSharp.Parser.AST.TemplateSpecializationType(__instance);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->TemplateSpecialization = *(CppSharp.Parser.AST.TemplateSpecializationType.Internal*)value.__Instance;
                    }
                }

                public CppSharp.Parser.AST.Class Class
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->Class);
                        return new CppSharp.Parser.AST.Class(__copy);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Class = value.__Instance;
                    }
                }
            }

            public unsafe partial class DependentNameType : CppSharp.Parser.AST.Type, IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 1)]
                public new struct Internal
                {
                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0DependentNameType@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr DependentNameType1(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 0; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal DependentNameType(DependentNameType.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal DependentNameType(DependentNameType.Internal native)
                    : this(&native)
                {
                }

                internal DependentNameType(global::System.IntPtr native)
                    : base(native)
                {
                }

                public DependentNameType()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(1);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }
            }

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

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0BuiltinType@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr BuiltinType1(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 4; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal BuiltinType(BuiltinType.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal BuiltinType(BuiltinType.Internal native)
                    : this(&native)
                {
                }

                internal BuiltinType(global::System.IntPtr native)
                    : base(native)
                {
                }

                public BuiltinType()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(4);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }

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

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Type = value;
                    }
                }
            }

            public unsafe partial class RawComment : IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 56)]
                public struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.RawCommentKind Kind;

                    [FieldOffset(4)]
                    public Std.String Text;

                    [FieldOffset(28)]
                    public Std.String BriefText;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0RawComment@AST@CppParser@CppSharp@@QAE@XZ")]
                    public static extern global::System.IntPtr RawComment1(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0RawComment@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr RawComment2(global::System.IntPtr instance, global::System.IntPtr _0);
                }

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

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 56; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal RawComment(RawComment.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal RawComment(RawComment.Internal native)
                    : this(&native)
                {
                }

                internal RawComment(global::System.IntPtr native)
                {
                    __Instance = native;
                }

                public RawComment()
                {
                    __Instance = Marshal.AllocHGlobal(56);
                    Internal.RawComment1(__Instance);
                }

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

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

                public CppSharp.Parser.AST.RawCommentKind Kind
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->Kind;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Kind = value;
                    }
                }

                public Std.String Text
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->Text;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Text = new Std.String();
                    }
                }

                public Std.String BriefText
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->BriefText;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->BriefText = new Std.String();
                    }
                }
            }

            public unsafe partial class VTableComponent : IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 12)]
                public 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 = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0VTableComponent@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr VTableComponent1(global::System.IntPtr instance, global::System.IntPtr _0);
                }

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

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 12; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal VTableComponent(VTableComponent.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal VTableComponent(VTableComponent.Internal native)
                    : this(&native)
                {
                }

                internal VTableComponent(global::System.IntPtr native)
                {
                    __Instance = native;
                }

                public VTableComponent()
                {
                    __Instance = Marshal.AllocHGlobal(12);
                }

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

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

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

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Kind = value;
                    }
                }

                public uint Offset
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->Offset;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Offset = value;
                    }
                }

                public CppSharp.Parser.AST.Declaration Declaration
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->Declaration);
                        return new CppSharp.Parser.AST.Declaration(__copy);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Declaration = value.__Instance;
                    }
                }
            }

            public unsafe partial class VTableLayout : IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 12)]
                public struct Internal
                {
                    [FieldOffset(0)]
                    public Std.Vector Components;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0VTableLayout@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr VTableLayout1(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0VTableLayout@AST@CppParser@CppSharp@@QAE@XZ")]
                    public static extern global::System.IntPtr VTableLayout2(global::System.IntPtr instance);
                }

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

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 12; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal VTableLayout(VTableLayout.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal VTableLayout(VTableLayout.Internal native)
                    : this(&native)
                {
                }

                internal VTableLayout(global::System.IntPtr native)
                {
                    __Instance = native;
                }

                public VTableLayout()
                {
                    __Instance = Marshal.AllocHGlobal(12);
                    Internal.VTableLayout2(__Instance);
                }

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

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

                public Std.Vector<CppSharp.Parser.AST.VTableComponent> Components
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return new Std.Vector<CppSharp.Parser.AST.VTableComponent>(__ptr->Components);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Components = value.Internal;
                    }
                }
            }

            public unsafe partial class VFTableInfo : IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 32)]
                public 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 = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0VFTableInfo@AST@CppParser@CppSharp@@QAE@XZ")]
                    public static extern global::System.IntPtr VFTableInfo0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0VFTableInfo@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr VFTableInfo1(global::System.IntPtr instance, global::System.IntPtr _0);
                }

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

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 32; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal VFTableInfo(VFTableInfo.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal VFTableInfo(VFTableInfo.Internal native)
                    : this(&native)
                {
                }

                internal VFTableInfo(global::System.IntPtr native)
                {
                    __Instance = native;
                }

                public VFTableInfo()
                {
                    __Instance = Marshal.AllocHGlobal(32);
                    Internal.VFTableInfo0(__Instance);
                }

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

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

                public ulong VBTableIndex
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->VBTableIndex;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->VBTableIndex = value;
                    }
                }

                public uint VFPtrOffset
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->VFPtrOffset;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->VFPtrOffset = value;
                    }
                }

                public uint VFPtrFullOffset
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->VFPtrFullOffset;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->VFPtrFullOffset = value;
                    }
                }

                public CppSharp.Parser.AST.VTableLayout Layout
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->Layout);
                        var __instance = Marshal.AllocHGlobal(12);
                        CppSharp.Parser.AST.VTableLayout.Internal.VTableLayout1(__instance, new global::System.IntPtr(&__copy));
                        return new CppSharp.Parser.AST.VTableLayout(__instance);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Layout = *(CppSharp.Parser.AST.VTableLayout.Internal*)value.__Instance;
                    }
                }
            }

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

                    [FieldOffset(4)]
                    public Std.Vector VFTables;

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

                    [FieldOffset(28)]
                    public bool HasOwnVFPtr;

                    [FieldOffset(32)]
                    public int VBPtrOffset;

                    [FieldOffset(36)]
                    public int Alignment;

                    [FieldOffset(40)]
                    public int Size;

                    [FieldOffset(44)]
                    public int DataSize;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0ClassLayout@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr ClassLayout1(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0ClassLayout@AST@CppParser@CppSharp@@QAE@XZ")]
                    public static extern global::System.IntPtr ClassLayout2(global::System.IntPtr instance);
                }

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

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 48; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal ClassLayout(ClassLayout.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal ClassLayout(ClassLayout.Internal native)
                    : this(&native)
                {
                }

                internal ClassLayout(global::System.IntPtr native)
                {
                    __Instance = native;
                }

                public ClassLayout()
                {
                    __Instance = Marshal.AllocHGlobal(48);
                    Internal.ClassLayout2(__Instance);
                }

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

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

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

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->ABI = value;
                    }
                }

                public Std.Vector<CppSharp.Parser.AST.VFTableInfo> VFTables
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return new Std.Vector<CppSharp.Parser.AST.VFTableInfo>(__ptr->VFTables);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->VFTables = value.Internal;
                    }
                }

                public CppSharp.Parser.AST.VTableLayout Layout
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->Layout);
                        var __instance = Marshal.AllocHGlobal(12);
                        CppSharp.Parser.AST.VTableLayout.Internal.VTableLayout1(__instance, new global::System.IntPtr(&__copy));
                        return new CppSharp.Parser.AST.VTableLayout(__instance);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Layout = *(CppSharp.Parser.AST.VTableLayout.Internal*)value.__Instance;
                    }
                }

                public bool HasOwnVFPtr
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->HasOwnVFPtr;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->HasOwnVFPtr = value;
                    }
                }

                public int VBPtrOffset
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->VBPtrOffset;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->VBPtrOffset = value;
                    }
                }

                public int Alignment
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->Alignment;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Alignment = value;
                    }
                }

                public int Size
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->Size;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Size = value;
                    }
                }

                public int DataSize
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->DataSize;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->DataSize = value;
                    }
                }
            }

            public unsafe partial class Declaration : IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 88)]
                public struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.AccessSpecifier Access;

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

                    [FieldOffset(8)]
                    public Std.String Name;

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

                    [FieldOffset(36)]
                    public Std.String DebugText;

                    [FieldOffset(60)]
                    public bool IsIncomplete;

                    [FieldOffset(61)]
                    public bool IsDependent;

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

                    [FieldOffset(68)]
                    public uint DefinitionOrder;

                    [FieldOffset(72)]
                    public Std.Vector PreprocessedEntities;

                    [FieldOffset(84)]
                    public void* OriginalPtr;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0Declaration@AST@CppParser@CppSharp@@QAE@XZ")]
                    public static extern global::System.IntPtr Declaration0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0Declaration@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr Declaration2(global::System.IntPtr instance, global::System.IntPtr _0);
                }

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

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 88; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal Declaration(Declaration.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal Declaration(Declaration.Internal native)
                    : this(&native)
                {
                }

                internal Declaration(global::System.IntPtr native)
                {
                    __Instance = native;
                }

                public Declaration()
                {
                    __Instance = Marshal.AllocHGlobal(88);
                    Internal.Declaration0(__Instance);
                }

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

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

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

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Access = value;
                    }
                }

                public CppSharp.Parser.AST.DeclarationContext _Namespace
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->_Namespace);
                        return new CppSharp.Parser.AST.DeclarationContext(__copy);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->_Namespace = value.__Instance;
                    }
                }

                public Std.String Name
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->Name;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Name = new Std.String();
                    }
                }

                public CppSharp.Parser.AST.RawComment Comment
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->Comment);
                        return new CppSharp.Parser.AST.RawComment(__copy);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Comment = value.__Instance;
                    }
                }

                public Std.String DebugText
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->DebugText;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->DebugText = new Std.String();
                    }
                }

                public bool IsIncomplete
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->IsIncomplete;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->IsIncomplete = value;
                    }
                }

                public bool IsDependent
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->IsDependent;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->IsDependent = value;
                    }
                }

                public CppSharp.Parser.AST.Declaration CompleteDeclaration
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->CompleteDeclaration);
                        return new CppSharp.Parser.AST.Declaration(__copy);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->CompleteDeclaration = value.__Instance;
                    }
                }

                public uint DefinitionOrder
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->DefinitionOrder;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->DefinitionOrder = value;
                    }
                }

                public Std.Vector<CppSharp.Parser.AST.PreprocessedEntity> PreprocessedEntities
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return new Std.Vector<CppSharp.Parser.AST.PreprocessedEntity>(__ptr->PreprocessedEntities);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->PreprocessedEntities = value.Internal;
                    }
                }

                public void* OriginalPtr
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->OriginalPtr;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->OriginalPtr = value;
                    }
                }
            }

            public unsafe partial class DeclarationContext : CppSharp.Parser.AST.Declaration, IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 180)]
                public new struct Internal
                {
                    [FieldOffset(88)]
                    public Std.Vector Namespaces;

                    [FieldOffset(100)]
                    public Std.Vector Enums;

                    [FieldOffset(112)]
                    public Std.Vector Functions;

                    [FieldOffset(124)]
                    public Std.Vector Classes;

                    [FieldOffset(136)]
                    public Std.Vector Templates;

                    [FieldOffset(148)]
                    public Std.Vector Typedefs;

                    [FieldOffset(160)]
                    public Std.Vector Variables;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0DeclarationContext@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr DeclarationContext1(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0DeclarationContext@AST@CppParser@CppSharp@@QAE@XZ")]
                    public static extern global::System.IntPtr DeclarationContext2(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="?FindAnonymous@DeclarationContext@AST@CppParser@CppSharp@@QAEPAUDeclaration@234@_K@Z")]
                    public static extern global::System.IntPtr FindAnonymous0(global::System.IntPtr instance, ulong key);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="?FindNamespace@DeclarationContext@AST@CppParser@CppSharp@@QAEPAUNamespace@234@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@Z")]
                    public static extern global::System.IntPtr FindNamespace0(global::System.IntPtr instance, Std.String Name);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="?FindNamespace@DeclarationContext@AST@CppParser@CppSharp@@QAEPAUNamespace@234@ABV?$vector@V?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@V?$allocator@V?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@2@@std@@@Z")]
                    public static extern global::System.IntPtr FindNamespace1(global::System.IntPtr instance, Std.Vector _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="?FindCreateNamespace@DeclarationContext@AST@CppParser@CppSharp@@QAEPAUNamespace@234@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@Z")]
                    public static extern global::System.IntPtr FindCreateNamespace0(global::System.IntPtr instance, Std.String Name);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="?CreateClass@DeclarationContext@AST@CppParser@CppSharp@@QAEPAUClass@234@V?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@_N@Z")]
                    public static extern global::System.IntPtr CreateClass0(global::System.IntPtr instance, Std.String Name, bool IsComplete);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="?FindClass@DeclarationContext@AST@CppParser@CppSharp@@QAEPAUClass@234@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@Z")]
                    public static extern global::System.IntPtr FindClass0(global::System.IntPtr instance, Std.String Name);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="?FindClass@DeclarationContext@AST@CppParser@CppSharp@@QAEPAUClass@234@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@_N1@Z")]
                    public static extern global::System.IntPtr FindClass1(global::System.IntPtr instance, Std.String Name, bool IsComplete, bool Create);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="?FindEnum@DeclarationContext@AST@CppParser@CppSharp@@QAEPAUEnumeration@234@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@_N@Z")]
                    public static extern global::System.IntPtr FindEnum0(global::System.IntPtr instance, Std.String Name, bool Create);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="?FindFunction@DeclarationContext@AST@CppParser@CppSharp@@QAEPAUFunction@234@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@_N@Z")]
                    public static extern global::System.IntPtr FindFunction0(global::System.IntPtr instance, Std.String Name, bool Create);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="?FindTypedef@DeclarationContext@AST@CppParser@CppSharp@@QAEPAUTypedefDecl@234@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@_N@Z")]
                    public static extern global::System.IntPtr FindTypedef0(global::System.IntPtr instance, Std.String Name, bool Create);
                }

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 180; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal DeclarationContext(DeclarationContext.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal DeclarationContext(DeclarationContext.Internal native)
                    : this(&native)
                {
                }

                internal DeclarationContext(global::System.IntPtr native)
                    : base(native)
                {
                }

                public DeclarationContext()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(180);
                    Internal.DeclarationContext2(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.Declaration FindAnonymous(ulong key)
                {
                    var arg0 = key;
                    var __ret = Internal.FindAnonymous0(__Instance, arg0);
                    if (__ret == global::System.IntPtr.Zero) return null;
                    return new CppSharp.Parser.AST.Declaration(__ret);
                }

                public CppSharp.Parser.AST.Namespace FindNamespace(Std.String Name)
                {
                    var arg0 = new Std.String();
                    var __ret = Internal.FindNamespace0(__Instance, arg0);
                    if (__ret == global::System.IntPtr.Zero) return null;
                    return new CppSharp.Parser.AST.Namespace(__ret);
                }

                public CppSharp.Parser.AST.Namespace FindNamespace(Std.Vector<Std.String> _0)
                {
                    var arg0 = _0.Internal;
                    var __ret = Internal.FindNamespace1(__Instance, arg0);
                    if (__ret == global::System.IntPtr.Zero) return null;
                    return new CppSharp.Parser.AST.Namespace(__ret);
                }

                public CppSharp.Parser.AST.Namespace FindCreateNamespace(Std.String Name)
                {
                    var arg0 = new Std.String();
                    var __ret = Internal.FindCreateNamespace0(__Instance, arg0);
                    if (__ret == global::System.IntPtr.Zero) return null;
                    return new CppSharp.Parser.AST.Namespace(__ret);
                }

                public CppSharp.Parser.AST.Class CreateClass(Std.String Name, bool IsComplete)
                {
                    var arg0 = new Std.String();
                    var __ret = Internal.CreateClass0(__Instance, arg0, IsComplete);
                    if (__ret == global::System.IntPtr.Zero) return null;
                    return new CppSharp.Parser.AST.Class(__ret);
                }

                public CppSharp.Parser.AST.Class FindClass(Std.String Name)
                {
                    var arg0 = new Std.String();
                    var __ret = Internal.FindClass0(__Instance, arg0);
                    if (__ret == global::System.IntPtr.Zero) return null;
                    return new CppSharp.Parser.AST.Class(__ret);
                }

                public CppSharp.Parser.AST.Class FindClass(Std.String Name, bool IsComplete, bool Create)
                {
                    var arg0 = new Std.String();
                    var __ret = Internal.FindClass1(__Instance, arg0, IsComplete, Create);
                    if (__ret == global::System.IntPtr.Zero) return null;
                    return new CppSharp.Parser.AST.Class(__ret);
                }

                public CppSharp.Parser.AST.Enumeration FindEnum(Std.String Name, bool Create)
                {
                    var arg0 = new Std.String();
                    var __ret = Internal.FindEnum0(__Instance, arg0, Create);
                    if (__ret == global::System.IntPtr.Zero) return null;
                    return new CppSharp.Parser.AST.Enumeration(__ret);
                }

                public CppSharp.Parser.AST.Function FindFunction(Std.String Name, bool Create)
                {
                    var arg0 = new Std.String();
                    var __ret = Internal.FindFunction0(__Instance, arg0, Create);
                    if (__ret == global::System.IntPtr.Zero) return null;
                    return new CppSharp.Parser.AST.Function(__ret);
                }

                public CppSharp.Parser.AST.TypedefDecl FindTypedef(Std.String Name, bool Create)
                {
                    var arg0 = new Std.String();
                    var __ret = Internal.FindTypedef0(__Instance, arg0, Create);
                    if (__ret == global::System.IntPtr.Zero) return null;
                    return new CppSharp.Parser.AST.TypedefDecl(__ret);
                }

                public Std.Vector<CppSharp.Parser.AST.Namespace> Namespaces
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return new Std.Vector<CppSharp.Parser.AST.Namespace>(__ptr->Namespaces);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Namespaces = value.Internal;
                    }
                }

                public Std.Vector<CppSharp.Parser.AST.Enumeration> Enums
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return new Std.Vector<CppSharp.Parser.AST.Enumeration>(__ptr->Enums);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Enums = value.Internal;
                    }
                }

                public Std.Vector<CppSharp.Parser.AST.Function> Functions
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return new Std.Vector<CppSharp.Parser.AST.Function>(__ptr->Functions);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Functions = value.Internal;
                    }
                }

                public Std.Vector<CppSharp.Parser.AST.Class> Classes
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return new Std.Vector<CppSharp.Parser.AST.Class>(__ptr->Classes);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Classes = value.Internal;
                    }
                }

                public Std.Vector<CppSharp.Parser.AST.Template> Templates
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return new Std.Vector<CppSharp.Parser.AST.Template>(__ptr->Templates);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Templates = value.Internal;
                    }
                }

                public Std.Vector<CppSharp.Parser.AST.TypedefDecl> Typedefs
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return new Std.Vector<CppSharp.Parser.AST.TypedefDecl>(__ptr->Typedefs);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Typedefs = value.Internal;
                    }
                }

                public Std.Vector<CppSharp.Parser.AST.Variable> Variables
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return new Std.Vector<CppSharp.Parser.AST.Variable>(__ptr->Variables);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Variables = value.Internal;
                    }
                }
            }

            public unsafe partial class TypedefDecl : CppSharp.Parser.AST.Declaration, IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 96)]
                public new struct Internal
                {
                    [FieldOffset(88)]
                    public CppSharp.Parser.AST.QualifiedType.Internal QualifiedType;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0TypedefDecl@AST@CppParser@CppSharp@@QAE@XZ")]
                    public static extern global::System.IntPtr TypedefDecl0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0TypedefDecl@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr TypedefDecl1(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 96; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal TypedefDecl(TypedefDecl.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal TypedefDecl(TypedefDecl.Internal native)
                    : this(&native)
                {
                }

                internal TypedefDecl(global::System.IntPtr native)
                    : base(native)
                {
                }

                public TypedefDecl()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(96);
                    Internal.TypedefDecl0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.QualifiedType QualifiedType
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->QualifiedType);
                        var __instance = Marshal.AllocHGlobal(8);
                        CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__copy), new UIntPtr(8));
                        return new CppSharp.Parser.AST.QualifiedType(__instance);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->QualifiedType = *(CppSharp.Parser.AST.QualifiedType.Internal*)value.__Instance;
                    }
                }
            }

            public unsafe partial class Parameter : CppSharp.Parser.AST.Declaration, IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 100)]
                public new struct Internal
                {
                    [FieldOffset(88)]
                    public CppSharp.Parser.AST.QualifiedType.Internal QualifiedType;

                    [FieldOffset(96)]
                    public bool IsIndirect;

                    [FieldOffset(97)]
                    public bool HasDefaultValue;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0Parameter@AST@CppParser@CppSharp@@QAE@XZ")]
                    public static extern global::System.IntPtr Parameter0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0Parameter@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr Parameter1(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 100; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal Parameter(Parameter.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal Parameter(Parameter.Internal native)
                    : this(&native)
                {
                }

                internal Parameter(global::System.IntPtr native)
                    : base(native)
                {
                }

                public Parameter()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(100);
                    Internal.Parameter0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.QualifiedType QualifiedType
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->QualifiedType);
                        var __instance = Marshal.AllocHGlobal(8);
                        CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__copy), new UIntPtr(8));
                        return new CppSharp.Parser.AST.QualifiedType(__instance);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->QualifiedType = *(CppSharp.Parser.AST.QualifiedType.Internal*)value.__Instance;
                    }
                }

                public bool IsIndirect
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->IsIndirect;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->IsIndirect = value;
                    }
                }

                public bool HasDefaultValue
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->HasDefaultValue;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->HasDefaultValue = value;
                    }
                }
            }

            public unsafe partial class Function : CppSharp.Parser.AST.Declaration, IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 172)]
                public new struct Internal
                {
                    [FieldOffset(88)]
                    public CppSharp.Parser.AST.QualifiedType.Internal ReturnType;

                    [FieldOffset(96)]
                    public bool IsReturnIndirect;

                    [FieldOffset(97)]
                    public bool IsVariadic;

                    [FieldOffset(98)]
                    public bool IsInline;

                    [FieldOffset(99)]
                    public bool IsPure;

                    [FieldOffset(100)]
                    public bool IsDeleted;

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

                    [FieldOffset(108)]
                    public Std.String Mangled;

                    [FieldOffset(132)]
                    public Std.String Signature;

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

                    [FieldOffset(160)]
                    public Std.Vector Parameters;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0Function@AST@CppParser@CppSharp@@QAE@XZ")]
                    public static extern global::System.IntPtr Function0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0Function@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr Function2(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 172; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal Function(Function.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal Function(Function.Internal native)
                    : this(&native)
                {
                }

                internal Function(global::System.IntPtr native)
                    : base(native)
                {
                }

                public Function()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(172);
                    Internal.Function0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.QualifiedType ReturnType
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->ReturnType);
                        var __instance = Marshal.AllocHGlobal(8);
                        CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__copy), new UIntPtr(8));
                        return new CppSharp.Parser.AST.QualifiedType(__instance);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->ReturnType = *(CppSharp.Parser.AST.QualifiedType.Internal*)value.__Instance;
                    }
                }

                public bool IsReturnIndirect
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->IsReturnIndirect;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->IsReturnIndirect = value;
                    }
                }

                public bool IsVariadic
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->IsVariadic;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->IsVariadic = value;
                    }
                }

                public bool IsInline
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->IsInline;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->IsInline = value;
                    }
                }

                public bool IsPure
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->IsPure;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->IsPure = value;
                    }
                }

                public bool IsDeleted
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->IsDeleted;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->IsDeleted = value;
                    }
                }

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

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->OperatorKind = value;
                    }
                }

                public Std.String Mangled
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->Mangled;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Mangled = new Std.String();
                    }
                }

                public Std.String Signature
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->Signature;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Signature = new Std.String();
                    }
                }

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

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->CallingConvention = value;
                    }
                }

                public Std.Vector<CppSharp.Parser.AST.Parameter> Parameters
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return new Std.Vector<CppSharp.Parser.AST.Parameter>(__ptr->Parameters);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Parameters = value.Internal;
                    }
                }
            }

            public unsafe partial class Method : CppSharp.Parser.AST.Function, IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 192)]
                public new struct Internal
                {
                    [FieldOffset(172)]
                    public global::System.IntPtr AccessDecl;

                    [FieldOffset(176)]
                    public bool IsVirtual;

                    [FieldOffset(177)]
                    public bool IsStatic;

                    [FieldOffset(178)]
                    public bool IsConst;

                    [FieldOffset(179)]
                    public bool IsImplicit;

                    [FieldOffset(180)]
                    public bool IsOverride;

                    [FieldOffset(184)]
                    public CppSharp.Parser.AST.CXXMethodKind Kind;

                    [FieldOffset(188)]
                    public bool IsDefaultConstructor;

                    [FieldOffset(189)]
                    public bool IsCopyConstructor;

                    [FieldOffset(190)]
                    public bool IsMoveConstructor;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0Method@AST@CppParser@CppSharp@@QAE@XZ")]
                    public static extern global::System.IntPtr Method0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0Method@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr Method1(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 192; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal Method(Method.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal Method(Method.Internal native)
                    : this(&native)
                {
                }

                internal Method(global::System.IntPtr native)
                    : base(native)
                {
                }

                public Method()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(192);
                    Internal.Method0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.AccessSpecifierDecl AccessDecl
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->AccessDecl);
                        return new CppSharp.Parser.AST.AccessSpecifierDecl(__copy);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->AccessDecl = value.__Instance;
                    }
                }

                public bool IsVirtual
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->IsVirtual;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->IsVirtual = value;
                    }
                }

                public bool IsStatic
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->IsStatic;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->IsStatic = value;
                    }
                }

                public bool IsConst
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->IsConst;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->IsConst = value;
                    }
                }

                public bool IsImplicit
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->IsImplicit;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->IsImplicit = value;
                    }
                }

                public bool IsOverride
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->IsOverride;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->IsOverride = value;
                    }
                }

                public CppSharp.Parser.AST.CXXMethodKind Kind
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->Kind;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Kind = value;
                    }
                }

                public bool IsDefaultConstructor
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->IsDefaultConstructor;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->IsDefaultConstructor = value;
                    }
                }

                public bool IsCopyConstructor
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->IsCopyConstructor;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->IsCopyConstructor = value;
                    }
                }

                public bool IsMoveConstructor
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->IsMoveConstructor;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->IsMoveConstructor = value;
                    }
                }
            }

            public unsafe partial class Enumeration : CppSharp.Parser.AST.Declaration, IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 112)]
                public new struct Internal
                {
                    [FieldOffset(88)]
                    public CppSharp.Parser.AST.Enumeration.EnumModifiers Modifiers;

                    [FieldOffset(92)]
                    public global::System.IntPtr Type;

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

                    [FieldOffset(100)]
                    public Std.Vector Items;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0Enumeration@AST@CppParser@CppSharp@@QAE@XZ")]
                    public static extern global::System.IntPtr Enumeration1(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0Enumeration@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr Enumeration2(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                [Flags]
                public enum EnumModifiers
                {
                    Anonymous = 1,
                    Scoped = 2,
                    Flags = 4
                }

                public unsafe partial class Item : CppSharp.Parser.AST.Declaration, IDisposable, CppSharp.Runtime.ICppMarshal
                {
                    [StructLayout(LayoutKind.Explicit, Size = 168)]
                    public new struct Internal
                    {
                        [FieldOffset(88)]
                        public Std.String Name;

                        [FieldOffset(112)]
                        public Std.String Expression;

                        [FieldOffset(136)]
                        public Std.String Comment;

                        [FieldOffset(160)]
                        public ulong Value;

                        [SuppressUnmanagedCodeSecurity]
                        [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                            EntryPoint="??0Item@Enumeration@AST@CppParser@CppSharp@@QAE@XZ")]
                        public static extern global::System.IntPtr Item1(global::System.IntPtr instance);

                        [SuppressUnmanagedCodeSecurity]
                        [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                            EntryPoint="??0Item@Enumeration@AST@CppParser@CppSharp@@QAE@ABU01234@@Z")]
                        public static extern global::System.IntPtr Item2(global::System.IntPtr instance, global::System.IntPtr _0);
                    }

                    int CppSharp.Runtime.ICppMarshal.NativeDataSize
                    {
                        get { return 168; }
                    }

                    void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                    {
                    }

                    void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                    {
                    }

                    internal Item(Item.Internal* native)
                        : this(new global::System.IntPtr(native))
                    {
                    }

                    internal Item(Item.Internal native)
                        : this(&native)
                    {
                    }

                    internal Item(global::System.IntPtr native)
                        : base(native)
                    {
                    }

                    public Item()
                        : this(IntPtr.Zero)
                    {
                        __Instance = Marshal.AllocHGlobal(168);
                        Internal.Item1(__Instance);
                    }

                    protected override void Dispose(bool disposing)
                    {
                        base.Dispose(disposing);
                    }

                    public Std.String Name
                    {
                        get
                        {
                            var __ptr = (Internal*)__Instance.ToPointer();
                            return __ptr->Name;
                        }

                        set
                        {
                            var __ptr = (Internal*)__Instance.ToPointer();
                            __ptr->Name = new Std.String();
                        }
                    }

                    public Std.String Expression
                    {
                        get
                        {
                            var __ptr = (Internal*)__Instance.ToPointer();
                            return __ptr->Expression;
                        }

                        set
                        {
                            var __ptr = (Internal*)__Instance.ToPointer();
                            __ptr->Expression = new Std.String();
                        }
                    }

                    public Std.String Comment
                    {
                        get
                        {
                            var __ptr = (Internal*)__Instance.ToPointer();
                            return __ptr->Comment;
                        }

                        set
                        {
                            var __ptr = (Internal*)__Instance.ToPointer();
                            __ptr->Comment = new Std.String();
                        }
                    }

                    public ulong Value
                    {
                        get
                        {
                            var __ptr = (Internal*)__Instance.ToPointer();
                            return __ptr->Value;
                        }

                        set
                        {
                            var __ptr = (Internal*)__Instance.ToPointer();
                            __ptr->Value = value;
                        }
                    }
                }

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 112; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal Enumeration(Enumeration.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal Enumeration(Enumeration.Internal native)
                    : this(&native)
                {
                }

                internal Enumeration(global::System.IntPtr native)
                    : base(native)
                {
                }

                public Enumeration()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(112);
                    Internal.Enumeration1(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.Enumeration.EnumModifiers Modifiers
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->Modifiers;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Modifiers = value;
                    }
                }

                public CppSharp.Parser.AST.Type Type
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->Type);
                        return new CppSharp.Parser.AST.Type(__copy);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Type = value.__Instance;
                    }
                }

                public CppSharp.Parser.AST.BuiltinType BuiltinType
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->BuiltinType);
                        return new CppSharp.Parser.AST.BuiltinType(__copy);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->BuiltinType = value.__Instance;
                    }
                }

                public Std.Vector<CppSharp.Parser.AST.Enumeration.Item> Items
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return new Std.Vector<CppSharp.Parser.AST.Enumeration.Item>(__ptr->Items);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Items = value.Internal;
                    }
                }
            }

            public unsafe partial class Variable : CppSharp.Parser.AST.Declaration, IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 120)]
                public new struct Internal
                {
                    [FieldOffset(88)]
                    public Std.String Mangled;

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

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0Variable@AST@CppParser@CppSharp@@QAE@XZ")]
                    public static extern global::System.IntPtr Variable1(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0Variable@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr Variable2(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 120; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal Variable(Variable.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal Variable(Variable.Internal native)
                    : this(&native)
                {
                }

                internal Variable(global::System.IntPtr native)
                    : base(native)
                {
                }

                public Variable()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(120);
                    Internal.Variable1(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }

                public Std.String Mangled
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->Mangled;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Mangled = new Std.String();
                    }
                }

                public CppSharp.Parser.AST.QualifiedType QualifiedType
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->QualifiedType);
                        var __instance = Marshal.AllocHGlobal(8);
                        CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__copy), new UIntPtr(8));
                        return new CppSharp.Parser.AST.QualifiedType(__instance);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->QualifiedType = *(CppSharp.Parser.AST.QualifiedType.Internal*)value.__Instance;
                    }
                }
            }

            public unsafe partial class BaseClassSpecifier : IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 12)]
                public struct Internal
                {
                    [FieldOffset(0)]
                    public CppSharp.Parser.AST.AccessSpecifier Access;

                    [FieldOffset(4)]
                    public bool IsVirtual;

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

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0BaseClassSpecifier@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr BaseClassSpecifier1(global::System.IntPtr instance, global::System.IntPtr _0);
                }

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

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 12; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal BaseClassSpecifier(BaseClassSpecifier.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal BaseClassSpecifier(BaseClassSpecifier.Internal native)
                    : this(&native)
                {
                }

                internal BaseClassSpecifier(global::System.IntPtr native)
                {
                    __Instance = native;
                }

                public BaseClassSpecifier()
                {
                    __Instance = Marshal.AllocHGlobal(12);
                }

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

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

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

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Access = value;
                    }
                }

                public bool IsVirtual
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->IsVirtual;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->IsVirtual = value;
                    }
                }

                public CppSharp.Parser.AST.Type Type
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->Type);
                        return new CppSharp.Parser.AST.Type(__copy);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Type = value.__Instance;
                    }
                }
            }

            public unsafe partial class Field : CppSharp.Parser.AST.Declaration, IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 108)]
                public new struct Internal
                {
                    [FieldOffset(88)]
                    public CppSharp.Parser.AST.QualifiedType.Internal QualifiedType;

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

                    [FieldOffset(100)]
                    public uint Offset;

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

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0Field@AST@CppParser@CppSharp@@QAE@XZ")]
                    public static extern global::System.IntPtr Field0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0Field@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr Field1(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 108; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal Field(Field.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal Field(Field.Internal native)
                    : this(&native)
                {
                }

                internal Field(global::System.IntPtr native)
                    : base(native)
                {
                }

                public Field()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(108);
                    Internal.Field0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.QualifiedType QualifiedType
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->QualifiedType);
                        var __instance = Marshal.AllocHGlobal(8);
                        CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__copy), new UIntPtr(8));
                        return new CppSharp.Parser.AST.QualifiedType(__instance);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->QualifiedType = *(CppSharp.Parser.AST.QualifiedType.Internal*)value.__Instance;
                    }
                }

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

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Access = value;
                    }
                }

                public uint Offset
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->Offset;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Offset = value;
                    }
                }

                public CppSharp.Parser.AST.Class Class
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->Class);
                        return new CppSharp.Parser.AST.Class(__copy);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Class = value.__Instance;
                    }
                }
            }

            public unsafe partial class AccessSpecifierDecl : CppSharp.Parser.AST.Declaration, IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 88)]
                public new struct Internal
                {
                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0AccessSpecifierDecl@AST@CppParser@CppSharp@@QAE@XZ")]
                    public static extern global::System.IntPtr AccessSpecifierDecl0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0AccessSpecifierDecl@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr AccessSpecifierDecl1(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 88; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal AccessSpecifierDecl(AccessSpecifierDecl.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal AccessSpecifierDecl(AccessSpecifierDecl.Internal native)
                    : this(&native)
                {
                }

                internal AccessSpecifierDecl(global::System.IntPtr native)
                    : base(native)
                {
                }

                public AccessSpecifierDecl()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(88);
                    Internal.AccessSpecifierDecl0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }
            }

            public unsafe partial class Class : CppSharp.Parser.AST.DeclarationContext, IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 284)]
                public new struct Internal
                {
                    [FieldOffset(180)]
                    public Std.Vector Bases;

                    [FieldOffset(192)]
                    public Std.Vector Fields;

                    [FieldOffset(204)]
                    public Std.Vector Methods;

                    [FieldOffset(216)]
                    public Std.Vector Specifiers;

                    [FieldOffset(228)]
                    public bool IsPOD;

                    [FieldOffset(229)]
                    public bool IsAbstract;

                    [FieldOffset(230)]
                    public bool IsUnion;

                    [FieldOffset(231)]
                    public bool IsDynamic;

                    [FieldOffset(232)]
                    public bool IsPolymorphic;

                    [FieldOffset(233)]
                    public bool HasNonTrivialDefaultConstructor;

                    [FieldOffset(234)]
                    public bool HasNonTrivialCopyConstructor;

                    [FieldOffset(236)]
                    public CppSharp.Parser.AST.ClassLayout.Internal Layout;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0Class@AST@CppParser@CppSharp@@QAE@XZ")]
                    public static extern global::System.IntPtr Class1(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0Class@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr Class2(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 284; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal Class(Class.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal Class(Class.Internal native)
                    : this(&native)
                {
                }

                internal Class(global::System.IntPtr native)
                    : base(native)
                {
                }

                public Class()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(284);
                    Internal.Class1(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }

                public Std.Vector<CppSharp.Parser.AST.BaseClassSpecifier> Bases
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return new Std.Vector<CppSharp.Parser.AST.BaseClassSpecifier>(__ptr->Bases);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Bases = value.Internal;
                    }
                }

                public Std.Vector<CppSharp.Parser.AST.Field> Fields
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return new Std.Vector<CppSharp.Parser.AST.Field>(__ptr->Fields);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Fields = value.Internal;
                    }
                }

                public Std.Vector<CppSharp.Parser.AST.Method> Methods
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return new Std.Vector<CppSharp.Parser.AST.Method>(__ptr->Methods);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Methods = value.Internal;
                    }
                }

                public Std.Vector<CppSharp.Parser.AST.AccessSpecifierDecl> Specifiers
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return new Std.Vector<CppSharp.Parser.AST.AccessSpecifierDecl>(__ptr->Specifiers);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Specifiers = value.Internal;
                    }
                }

                public bool IsPOD
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->IsPOD;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->IsPOD = value;
                    }
                }

                public bool IsAbstract
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->IsAbstract;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->IsAbstract = value;
                    }
                }

                public bool IsUnion
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->IsUnion;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->IsUnion = value;
                    }
                }

                public bool IsDynamic
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->IsDynamic;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->IsDynamic = value;
                    }
                }

                public bool IsPolymorphic
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->IsPolymorphic;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->IsPolymorphic = value;
                    }
                }

                public bool HasNonTrivialDefaultConstructor
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->HasNonTrivialDefaultConstructor;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->HasNonTrivialDefaultConstructor = value;
                    }
                }

                public bool HasNonTrivialCopyConstructor
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->HasNonTrivialCopyConstructor;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->HasNonTrivialCopyConstructor = value;
                    }
                }

                public CppSharp.Parser.AST.ClassLayout Layout
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->Layout);
                        var __instance = Marshal.AllocHGlobal(48);
                        CppSharp.Parser.AST.ClassLayout.Internal.ClassLayout1(__instance, new global::System.IntPtr(&__copy));
                        return new CppSharp.Parser.AST.ClassLayout(__instance);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Layout = *(CppSharp.Parser.AST.ClassLayout.Internal*)value.__Instance;
                    }
                }
            }

            public unsafe partial class Template : CppSharp.Parser.AST.Declaration, IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 104)]
                public new struct Internal
                {
                    [FieldOffset(88)]
                    public global::System.IntPtr TemplatedDecl;

                    [FieldOffset(92)]
                    public Std.Vector Parameters;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0Template@AST@CppParser@CppSharp@@QAE@XZ")]
                    public static extern global::System.IntPtr Template1(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0Template@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr Template2(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 104; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal Template(Template.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal Template(Template.Internal native)
                    : this(&native)
                {
                }

                internal Template(global::System.IntPtr native)
                    : base(native)
                {
                }

                public Template()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(104);
                    Internal.Template1(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.Declaration TemplatedDecl
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->TemplatedDecl);
                        return new CppSharp.Parser.AST.Declaration(__copy);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->TemplatedDecl = value.__Instance;
                    }
                }

                public Std.Vector<CppSharp.Parser.AST.TemplateParameter> Parameters
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return new Std.Vector<CppSharp.Parser.AST.TemplateParameter>(__ptr->Parameters);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Parameters = value.Internal;
                    }
                }
            }

            public unsafe partial class ClassTemplate : CppSharp.Parser.AST.Template, IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 104)]
                public new struct Internal
                {
                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0ClassTemplate@AST@CppParser@CppSharp@@QAE@XZ")]
                    public static extern global::System.IntPtr ClassTemplate0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0ClassTemplate@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr ClassTemplate1(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 104; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal ClassTemplate(ClassTemplate.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal ClassTemplate(ClassTemplate.Internal native)
                    : this(&native)
                {
                }

                internal ClassTemplate(global::System.IntPtr native)
                    : base(native)
                {
                }

                public ClassTemplate()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(104);
                    Internal.ClassTemplate0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }
            }

            public unsafe partial class ClassTemplateSpecialization : CppSharp.Parser.AST.Declaration, IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 88)]
                public new struct Internal
                {
                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0ClassTemplateSpecialization@AST@CppParser@CppSharp@@QAE@XZ")]
                    public static extern global::System.IntPtr ClassTemplateSpecialization0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0ClassTemplateSpecialization@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr ClassTemplateSpecialization1(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 88; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal ClassTemplateSpecialization(ClassTemplateSpecialization.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal ClassTemplateSpecialization(ClassTemplateSpecialization.Internal native)
                    : this(&native)
                {
                }

                internal ClassTemplateSpecialization(global::System.IntPtr native)
                    : base(native)
                {
                }

                public ClassTemplateSpecialization()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(88);
                    Internal.ClassTemplateSpecialization0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }
            }

            public unsafe partial class ClassTemplatePartialSpecialization : CppSharp.Parser.AST.Declaration, IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 88)]
                public new struct Internal
                {
                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0ClassTemplatePartialSpecialization@AST@CppParser@CppSharp@@QAE@XZ")]
                    public static extern global::System.IntPtr ClassTemplatePartialSpecialization0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0ClassTemplatePartialSpecialization@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr ClassTemplatePartialSpecialization1(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 88; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal ClassTemplatePartialSpecialization(ClassTemplatePartialSpecialization.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal ClassTemplatePartialSpecialization(ClassTemplatePartialSpecialization.Internal native)
                    : this(&native)
                {
                }

                internal ClassTemplatePartialSpecialization(global::System.IntPtr native)
                    : base(native)
                {
                }

                public ClassTemplatePartialSpecialization()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(88);
                    Internal.ClassTemplatePartialSpecialization0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }
            }

            public unsafe partial class FunctionTemplate : CppSharp.Parser.AST.Template, IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 104)]
                public new struct Internal
                {
                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0FunctionTemplate@AST@CppParser@CppSharp@@QAE@XZ")]
                    public static extern global::System.IntPtr FunctionTemplate0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0FunctionTemplate@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr FunctionTemplate1(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 104; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal FunctionTemplate(FunctionTemplate.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal FunctionTemplate(FunctionTemplate.Internal native)
                    : this(&native)
                {
                }

                internal FunctionTemplate(global::System.IntPtr native)
                    : base(native)
                {
                }

                public FunctionTemplate()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(104);
                    Internal.FunctionTemplate0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }
            }

            public unsafe partial class Namespace : CppSharp.Parser.AST.DeclarationContext, IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 180)]
                public new struct Internal
                {
                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0Namespace@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr Namespace1(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0Namespace@AST@CppParser@CppSharp@@QAE@XZ")]
                    public static extern global::System.IntPtr Namespace2(global::System.IntPtr instance);
                }

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 180; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal Namespace(Namespace.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal Namespace(Namespace.Internal native)
                    : this(&native)
                {
                }

                internal Namespace(global::System.IntPtr native)
                    : base(native)
                {
                }

                public Namespace()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(180);
                    Internal.Namespace2(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }
            }

            public unsafe partial class PreprocessedEntity : CppSharp.Parser.AST.Declaration, IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 92)]
                public new struct Internal
                {
                    [FieldOffset(88)]
                    public CppSharp.Parser.AST.MacroLocation Location;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0PreprocessedEntity@AST@CppParser@CppSharp@@QAE@XZ")]
                    public static extern global::System.IntPtr PreprocessedEntity0(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0PreprocessedEntity@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr PreprocessedEntity2(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 92; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal PreprocessedEntity(PreprocessedEntity.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal PreprocessedEntity(PreprocessedEntity.Internal native)
                    : this(&native)
                {
                }

                internal PreprocessedEntity(global::System.IntPtr native)
                    : base(native)
                {
                }

                public PreprocessedEntity()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(92);
                    Internal.PreprocessedEntity0(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }

                public CppSharp.Parser.AST.MacroLocation Location
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->Location;
                    }

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

            public unsafe partial class MacroDefinition : CppSharp.Parser.AST.PreprocessedEntity, IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 116)]
                public new struct Internal
                {
                    [FieldOffset(92)]
                    public Std.String Expression;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0MacroDefinition@AST@CppParser@CppSharp@@QAE@XZ")]
                    public static extern global::System.IntPtr MacroDefinition1(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0MacroDefinition@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr MacroDefinition2(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 116; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal MacroDefinition(MacroDefinition.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal MacroDefinition(MacroDefinition.Internal native)
                    : this(&native)
                {
                }

                internal MacroDefinition(global::System.IntPtr native)
                    : base(native)
                {
                }

                public MacroDefinition()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(116);
                    Internal.MacroDefinition1(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }

                public Std.String Expression
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->Expression;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Expression = new Std.String();
                    }
                }
            }

            public unsafe partial class MacroExpansion : CppSharp.Parser.AST.PreprocessedEntity, IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 120)]
                public new struct Internal
                {
                    [FieldOffset(92)]
                    public Std.String Text;

                    [FieldOffset(116)]
                    public global::System.IntPtr Definition;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0MacroExpansion@AST@CppParser@CppSharp@@QAE@XZ")]
                    public static extern global::System.IntPtr MacroExpansion1(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0MacroExpansion@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr MacroExpansion2(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 120; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal MacroExpansion(MacroExpansion.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal MacroExpansion(MacroExpansion.Internal native)
                    : this(&native)
                {
                }

                internal MacroExpansion(global::System.IntPtr native)
                    : base(native)
                {
                }

                public MacroExpansion()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(120);
                    Internal.MacroExpansion1(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }

                public Std.String Text
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->Text;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Text = new Std.String();
                    }
                }

                public CppSharp.Parser.AST.MacroDefinition Definition
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        var __copy = new global::System.IntPtr(&__ptr->Definition);
                        return new CppSharp.Parser.AST.MacroDefinition(__copy);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Definition = value.__Instance;
                    }
                }
            }

            public unsafe partial class TranslationUnit : CppSharp.Parser.AST.Namespace, IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 232)]
                public new struct Internal
                {
                    [FieldOffset(180)]
                    public Std.String FileName;

                    [FieldOffset(204)]
                    public bool IsSystemHeader;

                    [FieldOffset(208)]
                    public Std.Vector Namespaces;

                    [FieldOffset(220)]
                    public Std.Vector Macros;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0TranslationUnit@AST@CppParser@CppSharp@@QAE@XZ")]
                    public static extern global::System.IntPtr TranslationUnit1(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0TranslationUnit@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr TranslationUnit2(global::System.IntPtr instance, global::System.IntPtr _0);
                }

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 232; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal TranslationUnit(TranslationUnit.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal TranslationUnit(TranslationUnit.Internal native)
                    : this(&native)
                {
                }

                internal TranslationUnit(global::System.IntPtr native)
                    : base(native)
                {
                }

                public TranslationUnit()
                    : this(IntPtr.Zero)
                {
                    __Instance = Marshal.AllocHGlobal(232);
                    Internal.TranslationUnit1(__Instance);
                }

                protected override void Dispose(bool disposing)
                {
                    base.Dispose(disposing);
                }

                public Std.String FileName
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->FileName;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->FileName = new Std.String();
                    }
                }

                public bool IsSystemHeader
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->IsSystemHeader;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->IsSystemHeader = value;
                    }
                }

                public Std.Vector<CppSharp.Parser.AST.Namespace> Namespaces
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return new Std.Vector<CppSharp.Parser.AST.Namespace>(__ptr->Namespaces);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Namespaces = value.Internal;
                    }
                }

                public Std.Vector<CppSharp.Parser.AST.MacroDefinition> Macros
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return new Std.Vector<CppSharp.Parser.AST.MacroDefinition>(__ptr->Macros);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Macros = value.Internal;
                    }
                }
            }

            public unsafe partial class NativeLibrary : IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 36)]
                public struct Internal
                {
                    [FieldOffset(0)]
                    public Std.String FileName;

                    [FieldOffset(24)]
                    public Std.Vector Symbols;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0NativeLibrary@AST@CppParser@CppSharp@@QAE@XZ")]
                    public static extern global::System.IntPtr NativeLibrary1(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0NativeLibrary@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr NativeLibrary2(global::System.IntPtr instance, global::System.IntPtr _0);
                }

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

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 36; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal NativeLibrary(NativeLibrary.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal NativeLibrary(NativeLibrary.Internal native)
                    : this(&native)
                {
                }

                internal NativeLibrary(global::System.IntPtr native)
                {
                    __Instance = native;
                }

                public NativeLibrary()
                {
                    __Instance = Marshal.AllocHGlobal(36);
                    Internal.NativeLibrary1(__Instance);
                }

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

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

                public Std.String FileName
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return __ptr->FileName;
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->FileName = new Std.String();
                    }
                }

                public Std.Vector<Std.String> Symbols
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return new Std.Vector<Std.String>(__ptr->Symbols);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->Symbols = value.Internal;
                    }
                }
            }

            public unsafe partial class ASTContext : IDisposable, CppSharp.Runtime.ICppMarshal
            {
                [StructLayout(LayoutKind.Explicit, Size = 12)]
                public struct Internal
                {
                    [FieldOffset(0)]
                    public Std.Vector TranslationUnits;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0ASTContext@AST@CppParser@CppSharp@@QAE@XZ")]
                    public static extern global::System.IntPtr ASTContext1(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="??0ASTContext@AST@CppParser@CppSharp@@QAE@ABU0123@@Z")]
                    public static extern global::System.IntPtr ASTContext2(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("CppSharp.CppParser.dll", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
                        EntryPoint="?FindOrCreateModule@ASTContext@AST@CppParser@CppSharp@@QAEPAUTranslationUnit@234@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@Z")]
                    public static extern global::System.IntPtr FindOrCreateModule0(global::System.IntPtr instance, Std.String File);
                }

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

                int CppSharp.Runtime.ICppMarshal.NativeDataSize
                {
                    get { return 12; }
                }

                void CppSharp.Runtime.ICppMarshal.MarshalManagedToNative(global::System.IntPtr instance)
                {
                }

                void CppSharp.Runtime.ICppMarshal.MarshalNativeToManaged(global::System.IntPtr instance)
                {
                }

                internal ASTContext(ASTContext.Internal* native)
                    : this(new global::System.IntPtr(native))
                {
                }

                internal ASTContext(ASTContext.Internal native)
                    : this(&native)
                {
                }

                internal ASTContext(global::System.IntPtr native)
                {
                    __Instance = native;
                }

                public ASTContext()
                {
                    __Instance = Marshal.AllocHGlobal(12);
                    Internal.ASTContext1(__Instance);
                }

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

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

                public CppSharp.Parser.AST.TranslationUnit FindOrCreateModule(Std.String File)
                {
                    var arg0 = new Std.String();
                    var __ret = Internal.FindOrCreateModule0(__Instance, arg0);
                    if (__ret == global::System.IntPtr.Zero) return null;
                    return new CppSharp.Parser.AST.TranslationUnit(__ret);
                }

                public Std.Vector<CppSharp.Parser.AST.TranslationUnit> TranslationUnits
                {
                    get
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        return new Std.Vector<CppSharp.Parser.AST.TranslationUnit>(__ptr->TranslationUnits);
                    }

                    set
                    {
                        var __ptr = (Internal*)__Instance.ToPointer();
                        __ptr->TranslationUnits = value.Internal;
                    }
                }
            }
        }
    }
}