Decl.cpp

// ----------------------------------------------------------------------------
// <auto-generated>
// This is autogenerated code by CppSharp.
// Do not edit this file or all your changes will be lost after re-generation.
// </auto-generated>
// ----------------------------------------------------------------------------
#include "Decl.h"
#include "AST.h"
#include "Expr.h"
#include "Stmt.h"
#include "Types.h"

using namespace System;
using namespace System::Runtime::InteropServices;

CppSharp::Parser::AST::Declaration::Declaration(class ::CppSharp::CppParser::AST::Declaration* native)
    : __ownsNativeInstance(false)
{
    NativePtr = native;
}

CppSharp::Parser::AST::Declaration^ CppSharp::Parser::AST::Declaration::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::Declaration((class ::CppSharp::CppParser::AST::Declaration*) native.ToPointer());
}

CppSharp::Parser::AST::Declaration::Declaration(class ::CppSharp::CppParser::AST::Declaration* native, bool ownNativeInstance)
    : __ownsNativeInstance(ownNativeInstance)
{
    NativePtr = native;
}

CppSharp::Parser::AST::Declaration^ CppSharp::Parser::AST::Declaration::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::Declaration((class ::CppSharp::CppParser::AST::Declaration*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::Declaration::~Declaration()
{
    delete NativePtr;
}

CppSharp::Parser::AST::Declaration::Declaration(CppSharp::Parser::AST::DeclarationKind kind)
{
    __ownsNativeInstance = true;
    auto __arg0 = (enum ::CppSharp::CppParser::AST::DeclarationKind)kind;
    NativePtr = new class ::CppSharp::CppParser::AST::Declaration(__arg0);
}

CppSharp::Parser::AST::Declaration::Declaration(CppSharp::Parser::AST::Declaration^ _0)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::Declaration*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::Declaration(__arg0);
}

CppSharp::Parser::AST::PreprocessedEntity^ CppSharp::Parser::AST::Declaration::GetPreprocessedEntities(unsigned int i)
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::Declaration*)NativePtr)->getPreprocessedEntities(i);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::PreprocessedEntity((class ::CppSharp::CppParser::AST::PreprocessedEntity*)___ret);
}

void CppSharp::Parser::AST::Declaration::AddPreprocessedEntities(CppSharp::Parser::AST::PreprocessedEntity^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto __arg0 = (class ::CppSharp::CppParser::AST::PreprocessedEntity*)s->NativePtr;
    ((class ::CppSharp::CppParser::AST::Declaration*)NativePtr)->addPreprocessedEntities(__arg0);
}

void CppSharp::Parser::AST::Declaration::ClearPreprocessedEntities()
{
    ((class ::CppSharp::CppParser::AST::Declaration*)NativePtr)->clearPreprocessedEntities();
}

CppSharp::Parser::AST::Declaration^ CppSharp::Parser::AST::Declaration::GetRedeclarations(unsigned int i)
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::Declaration*)NativePtr)->getRedeclarations(i);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Declaration((class ::CppSharp::CppParser::AST::Declaration*)___ret);
}

void CppSharp::Parser::AST::Declaration::AddRedeclarations(CppSharp::Parser::AST::Declaration^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto __arg0 = (class ::CppSharp::CppParser::AST::Declaration*)s->NativePtr;
    ((class ::CppSharp::CppParser::AST::Declaration*)NativePtr)->addRedeclarations(__arg0);
}

void CppSharp::Parser::AST::Declaration::ClearRedeclarations()
{
    ((class ::CppSharp::CppParser::AST::Declaration*)NativePtr)->clearRedeclarations();
}

CppSharp::Parser::AST::Declaration::operator CppSharp::Parser::AST::Declaration^(CppSharp::Parser::AST::DeclarationKind kind)
{
    auto __arg0 = (enum ::CppSharp::CppParser::AST::DeclarationKind)kind;
    auto ___ret = (::CppSharp::CppParser::AST::Declaration) __arg0;
    auto _____ret = new class ::CppSharp::CppParser::AST::Declaration(___ret);
    return (_____ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Declaration((class ::CppSharp::CppParser::AST::Declaration*)_____ret, true);
}

::System::IntPtr CppSharp::Parser::AST::Declaration::__Instance::get()
{
    return ::System::IntPtr(NativePtr);
}

void CppSharp::Parser::AST::Declaration::__Instance::set(::System::IntPtr object)
{
    NativePtr = (class ::CppSharp::CppParser::AST::Declaration*)object.ToPointer();
}

CppSharp::Parser::AST::DeclarationKind CppSharp::Parser::AST::Declaration::Kind::get()
{
    return (CppSharp::Parser::AST::DeclarationKind)NativePtr->kind;
}

void CppSharp::Parser::AST::Declaration::Kind::set(CppSharp::Parser::AST::DeclarationKind value)
{
    ((class ::CppSharp::CppParser::AST::Declaration*)NativePtr)->kind = (enum ::CppSharp::CppParser::AST::DeclarationKind)value;
}

int CppSharp::Parser::AST::Declaration::AlignAs::get()
{
    return NativePtr->alignAs;
}

void CppSharp::Parser::AST::Declaration::AlignAs::set(int value)
{
    ((class ::CppSharp::CppParser::AST::Declaration*)NativePtr)->alignAs = value;
}

int CppSharp::Parser::AST::Declaration::MaxFieldAlignment::get()
{
    return NativePtr->maxFieldAlignment;
}

void CppSharp::Parser::AST::Declaration::MaxFieldAlignment::set(int value)
{
    ((class ::CppSharp::CppParser::AST::Declaration*)NativePtr)->maxFieldAlignment = value;
}

CppSharp::Parser::AST::AccessSpecifier CppSharp::Parser::AST::Declaration::Access::get()
{
    return (CppSharp::Parser::AST::AccessSpecifier)NativePtr->access;
}

void CppSharp::Parser::AST::Declaration::Access::set(CppSharp::Parser::AST::AccessSpecifier value)
{
    ((class ::CppSharp::CppParser::AST::Declaration*)NativePtr)->access = (enum ::CppSharp::CppParser::AST::AccessSpecifier)value;
}

CppSharp::Parser::AST::DeclarationContext^ CppSharp::Parser::AST::Declaration::Namespace::get()
{
    return (NativePtr->_namespace == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::DeclarationContext((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr->_namespace);
}

void CppSharp::Parser::AST::Declaration::Namespace::set(CppSharp::Parser::AST::DeclarationContext^ value)
{
    ((class ::CppSharp::CppParser::AST::Declaration*)NativePtr)->_namespace = (class ::CppSharp::CppParser::AST::DeclarationContext*)value->NativePtr;
}

CppSharp::Parser::SourceLocation CppSharp::Parser::AST::Declaration::Location::get()
{
    return ::CppSharp::Parser::SourceLocation((struct ::CppSharp::CppParser::SourceLocation*)&NativePtr->location);
}

void CppSharp::Parser::AST::Declaration::Location::set(CppSharp::Parser::SourceLocation value)
{
    auto _marshal0 = ::CppSharp::CppParser::SourceLocation();
    _marshal0.ID = value.ID;
    ((class ::CppSharp::CppParser::AST::Declaration*)NativePtr)->location = _marshal0;
}

int CppSharp::Parser::AST::Declaration::LineNumberStart::get()
{
    return NativePtr->lineNumberStart;
}

void CppSharp::Parser::AST::Declaration::LineNumberStart::set(int value)
{
    ((class ::CppSharp::CppParser::AST::Declaration*)NativePtr)->lineNumberStart = value;
}

int CppSharp::Parser::AST::Declaration::LineNumberEnd::get()
{
    return NativePtr->lineNumberEnd;
}

void CppSharp::Parser::AST::Declaration::LineNumberEnd::set(int value)
{
    ((class ::CppSharp::CppParser::AST::Declaration*)NativePtr)->lineNumberEnd = value;
}

::System::String^ CppSharp::Parser::AST::Declaration::Name::get()
{
    return clix::marshalString<clix::E_UTF8>(NativePtr->name);
}

void CppSharp::Parser::AST::Declaration::Name::set(::System::String^ value)
{
    ((class ::CppSharp::CppParser::AST::Declaration*)NativePtr)->name = clix::marshalString<clix::E_UTF8>(value);
}

::System::String^ CppSharp::Parser::AST::Declaration::USR::get()
{
    return clix::marshalString<clix::E_UTF8>(NativePtr->USR);
}

void CppSharp::Parser::AST::Declaration::USR::set(::System::String^ value)
{
    ((class ::CppSharp::CppParser::AST::Declaration*)NativePtr)->USR = clix::marshalString<clix::E_UTF8>(value);
}

::System::String^ CppSharp::Parser::AST::Declaration::DebugText::get()
{
    return clix::marshalString<clix::E_UTF8>(NativePtr->debugText);
}

void CppSharp::Parser::AST::Declaration::DebugText::set(::System::String^ value)
{
    ((class ::CppSharp::CppParser::AST::Declaration*)NativePtr)->debugText = clix::marshalString<clix::E_UTF8>(value);
}

bool CppSharp::Parser::AST::Declaration::IsIncomplete::get()
{
    return NativePtr->isIncomplete;
}

void CppSharp::Parser::AST::Declaration::IsIncomplete::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Declaration*)NativePtr)->isIncomplete = value;
}

bool CppSharp::Parser::AST::Declaration::IsDependent::get()
{
    return NativePtr->isDependent;
}

void CppSharp::Parser::AST::Declaration::IsDependent::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Declaration*)NativePtr)->isDependent = value;
}

bool CppSharp::Parser::AST::Declaration::IsImplicit::get()
{
    return NativePtr->isImplicit;
}

void CppSharp::Parser::AST::Declaration::IsImplicit::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Declaration*)NativePtr)->isImplicit = value;
}

bool CppSharp::Parser::AST::Declaration::IsInvalid::get()
{
    return NativePtr->isInvalid;
}

void CppSharp::Parser::AST::Declaration::IsInvalid::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Declaration*)NativePtr)->isInvalid = value;
}

bool CppSharp::Parser::AST::Declaration::IsDeprecated::get()
{
    return NativePtr->isDeprecated;
}

void CppSharp::Parser::AST::Declaration::IsDeprecated::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Declaration*)NativePtr)->isDeprecated = value;
}

CppSharp::Parser::AST::Declaration^ CppSharp::Parser::AST::Declaration::CompleteDeclaration::get()
{
    return (NativePtr->completeDeclaration == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Declaration((class ::CppSharp::CppParser::AST::Declaration*)NativePtr->completeDeclaration);
}

void CppSharp::Parser::AST::Declaration::CompleteDeclaration::set(CppSharp::Parser::AST::Declaration^ value)
{
    ((class ::CppSharp::CppParser::AST::Declaration*)NativePtr)->completeDeclaration = (class ::CppSharp::CppParser::AST::Declaration*)value->NativePtr;
}

unsigned int CppSharp::Parser::AST::Declaration::DefinitionOrder::get()
{
    return NativePtr->definitionOrder;
}

void CppSharp::Parser::AST::Declaration::DefinitionOrder::set(unsigned int value)
{
    ((class ::CppSharp::CppParser::AST::Declaration*)NativePtr)->definitionOrder = value;
}

::System::Collections::Generic::List<CppSharp::Parser::AST::PreprocessedEntity^>^ CppSharp::Parser::AST::Declaration::PreprocessedEntities::get()
{
    auto _tmp__PreprocessedEntities = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::PreprocessedEntity^>();
    auto __list0 = NativePtr->PreprocessedEntities;
    for(auto _element : __list0)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::PreprocessedEntity((class ::CppSharp::CppParser::AST::PreprocessedEntity*)_element);
        _tmp__PreprocessedEntities->Add(_marshalElement);
    }
    return _tmp__PreprocessedEntities;
}

void CppSharp::Parser::AST::Declaration::PreprocessedEntities::set(::System::Collections::Generic::List<CppSharp::Parser::AST::PreprocessedEntity^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::PreprocessedEntity*>();
    for each(CppSharp::Parser::AST::PreprocessedEntity^ _element in value)
    {
        auto _marshalElement = (class ::CppSharp::CppParser::AST::PreprocessedEntity*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((class ::CppSharp::CppParser::AST::Declaration*)NativePtr)->PreprocessedEntities = _tmpvalue;
}

::System::Collections::Generic::List<CppSharp::Parser::AST::Declaration^>^ CppSharp::Parser::AST::Declaration::Redeclarations::get()
{
    auto _tmp__Redeclarations = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::Declaration^>();
    auto __list0 = NativePtr->Redeclarations;
    for(auto _element : __list0)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Declaration((class ::CppSharp::CppParser::AST::Declaration*)_element);
        _tmp__Redeclarations->Add(_marshalElement);
    }
    return _tmp__Redeclarations;
}

void CppSharp::Parser::AST::Declaration::Redeclarations::set(::System::Collections::Generic::List<CppSharp::Parser::AST::Declaration^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::Declaration*>();
    for each(CppSharp::Parser::AST::Declaration^ _element in value)
    {
        auto _marshalElement = (class ::CppSharp::CppParser::AST::Declaration*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((class ::CppSharp::CppParser::AST::Declaration*)NativePtr)->Redeclarations = _tmpvalue;
}

::System::IntPtr CppSharp::Parser::AST::Declaration::OriginalPtr::get()
{
    return ::System::IntPtr(NativePtr->originalPtr);
}

void CppSharp::Parser::AST::Declaration::OriginalPtr::set(::System::IntPtr value)
{
    ((class ::CppSharp::CppParser::AST::Declaration*)NativePtr)->originalPtr = (void*)value;
}

CppSharp::Parser::AST::RawComment^ CppSharp::Parser::AST::Declaration::Comment::get()
{
    return (NativePtr->comment == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::RawComment((class ::CppSharp::CppParser::AST::RawComment*)NativePtr->comment);
}

void CppSharp::Parser::AST::Declaration::Comment::set(CppSharp::Parser::AST::RawComment^ value)
{
    ((class ::CppSharp::CppParser::AST::Declaration*)NativePtr)->comment = (class ::CppSharp::CppParser::AST::RawComment*)value->NativePtr;
}

unsigned int CppSharp::Parser::AST::Declaration::PreprocessedEntitiesCount::get()
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::Declaration*)NativePtr)->getPreprocessedEntitiesCount();
    return ___ret;
}

unsigned int CppSharp::Parser::AST::Declaration::RedeclarationsCount::get()
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::Declaration*)NativePtr)->getRedeclarationsCount();
    return ___ret;
}

CppSharp::Parser::AST::DeclarationContext::DeclarationContext(class ::CppSharp::CppParser::AST::DeclarationContext* native)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)native)
{
}

CppSharp::Parser::AST::DeclarationContext^ CppSharp::Parser::AST::DeclarationContext::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::DeclarationContext((class ::CppSharp::CppParser::AST::DeclarationContext*) native.ToPointer());
}

CppSharp::Parser::AST::DeclarationContext::DeclarationContext(class ::CppSharp::CppParser::AST::DeclarationContext* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::DeclarationContext^ CppSharp::Parser::AST::DeclarationContext::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::DeclarationContext((class ::CppSharp::CppParser::AST::DeclarationContext*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::DeclarationContext::~DeclarationContext()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::DeclarationContext*) __nativePtr;
    }
}

CppSharp::Parser::AST::DeclarationContext::DeclarationContext(CppSharp::Parser::AST::DeclarationKind kind)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)nullptr)
{
    __ownsNativeInstance = true;
    auto __arg0 = (enum ::CppSharp::CppParser::AST::DeclarationKind)kind;
    NativePtr = new class ::CppSharp::CppParser::AST::DeclarationContext(__arg0);
}

CppSharp::Parser::AST::Namespace^ CppSharp::Parser::AST::DeclarationContext::GetNamespaces(unsigned int i)
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->getNamespaces(i);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Namespace((class ::CppSharp::CppParser::AST::Namespace*)___ret);
}

void CppSharp::Parser::AST::DeclarationContext::AddNamespaces(CppSharp::Parser::AST::Namespace^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto __arg0 = (class ::CppSharp::CppParser::AST::Namespace*)s->NativePtr;
    ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->addNamespaces(__arg0);
}

void CppSharp::Parser::AST::DeclarationContext::ClearNamespaces()
{
    ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->clearNamespaces();
}

CppSharp::Parser::AST::Enumeration^ CppSharp::Parser::AST::DeclarationContext::GetEnums(unsigned int i)
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->getEnums(i);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Enumeration((class ::CppSharp::CppParser::AST::Enumeration*)___ret);
}

void CppSharp::Parser::AST::DeclarationContext::AddEnums(CppSharp::Parser::AST::Enumeration^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto __arg0 = (class ::CppSharp::CppParser::AST::Enumeration*)s->NativePtr;
    ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->addEnums(__arg0);
}

void CppSharp::Parser::AST::DeclarationContext::ClearEnums()
{
    ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->clearEnums();
}

CppSharp::Parser::AST::Function^ CppSharp::Parser::AST::DeclarationContext::GetFunctions(unsigned int i)
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->getFunctions(i);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Function((class ::CppSharp::CppParser::AST::Function*)___ret);
}

void CppSharp::Parser::AST::DeclarationContext::AddFunctions(CppSharp::Parser::AST::Function^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto __arg0 = (class ::CppSharp::CppParser::AST::Function*)s->NativePtr;
    ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->addFunctions(__arg0);
}

void CppSharp::Parser::AST::DeclarationContext::ClearFunctions()
{
    ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->clearFunctions();
}

CppSharp::Parser::AST::Class^ CppSharp::Parser::AST::DeclarationContext::GetClasses(unsigned int i)
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->getClasses(i);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Class((class ::CppSharp::CppParser::AST::Class*)___ret);
}

void CppSharp::Parser::AST::DeclarationContext::AddClasses(CppSharp::Parser::AST::Class^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto __arg0 = (class ::CppSharp::CppParser::AST::Class*)s->NativePtr;
    ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->addClasses(__arg0);
}

void CppSharp::Parser::AST::DeclarationContext::ClearClasses()
{
    ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->clearClasses();
}

CppSharp::Parser::AST::Template^ CppSharp::Parser::AST::DeclarationContext::GetTemplates(unsigned int i)
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->getTemplates(i);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Template((class ::CppSharp::CppParser::AST::Template*)___ret);
}

void CppSharp::Parser::AST::DeclarationContext::AddTemplates(CppSharp::Parser::AST::Template^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto __arg0 = (class ::CppSharp::CppParser::AST::Template*)s->NativePtr;
    ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->addTemplates(__arg0);
}

void CppSharp::Parser::AST::DeclarationContext::ClearTemplates()
{
    ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->clearTemplates();
}

CppSharp::Parser::AST::TypedefDecl^ CppSharp::Parser::AST::DeclarationContext::GetTypedefs(unsigned int i)
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->getTypedefs(i);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::TypedefDecl((class ::CppSharp::CppParser::AST::TypedefDecl*)___ret);
}

void CppSharp::Parser::AST::DeclarationContext::AddTypedefs(CppSharp::Parser::AST::TypedefDecl^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto __arg0 = (class ::CppSharp::CppParser::AST::TypedefDecl*)s->NativePtr;
    ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->addTypedefs(__arg0);
}

void CppSharp::Parser::AST::DeclarationContext::ClearTypedefs()
{
    ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->clearTypedefs();
}

CppSharp::Parser::AST::TypeAlias^ CppSharp::Parser::AST::DeclarationContext::GetTypeAliases(unsigned int i)
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->getTypeAliases(i);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::TypeAlias((class ::CppSharp::CppParser::AST::TypeAlias*)___ret);
}

void CppSharp::Parser::AST::DeclarationContext::AddTypeAliases(CppSharp::Parser::AST::TypeAlias^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto __arg0 = (class ::CppSharp::CppParser::AST::TypeAlias*)s->NativePtr;
    ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->addTypeAliases(__arg0);
}

void CppSharp::Parser::AST::DeclarationContext::ClearTypeAliases()
{
    ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->clearTypeAliases();
}

CppSharp::Parser::AST::Variable^ CppSharp::Parser::AST::DeclarationContext::GetVariables(unsigned int i)
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->getVariables(i);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Variable((class ::CppSharp::CppParser::AST::Variable*)___ret);
}

void CppSharp::Parser::AST::DeclarationContext::AddVariables(CppSharp::Parser::AST::Variable^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto __arg0 = (class ::CppSharp::CppParser::AST::Variable*)s->NativePtr;
    ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->addVariables(__arg0);
}

void CppSharp::Parser::AST::DeclarationContext::ClearVariables()
{
    ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->clearVariables();
}

CppSharp::Parser::AST::Friend^ CppSharp::Parser::AST::DeclarationContext::GetFriends(unsigned int i)
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->getFriends(i);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Friend((class ::CppSharp::CppParser::AST::Friend*)___ret);
}

void CppSharp::Parser::AST::DeclarationContext::AddFriends(CppSharp::Parser::AST::Friend^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto __arg0 = (class ::CppSharp::CppParser::AST::Friend*)s->NativePtr;
    ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->addFriends(__arg0);
}

void CppSharp::Parser::AST::DeclarationContext::ClearFriends()
{
    ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->clearFriends();
}

CppSharp::Parser::AST::DeclarationContext::DeclarationContext(CppSharp::Parser::AST::DeclarationContext^ _0)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::DeclarationContext*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::DeclarationContext(__arg0);
}

CppSharp::Parser::AST::DeclarationContext::operator CppSharp::Parser::AST::DeclarationContext^(CppSharp::Parser::AST::DeclarationKind kind)
{
    auto __arg0 = (enum ::CppSharp::CppParser::AST::DeclarationKind)kind;
    auto ___ret = (::CppSharp::CppParser::AST::DeclarationContext) __arg0;
    auto _____ret = new class ::CppSharp::CppParser::AST::DeclarationContext(___ret);
    return (_____ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::DeclarationContext((class ::CppSharp::CppParser::AST::DeclarationContext*)_____ret, true);
}

::System::Collections::Generic::List<CppSharp::Parser::AST::Namespace^>^ CppSharp::Parser::AST::DeclarationContext::Namespaces::get()
{
    auto _tmp__Namespaces = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::Namespace^>();
    auto __list0 = ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->Namespaces;
    for(auto _element : __list0)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Namespace((class ::CppSharp::CppParser::AST::Namespace*)_element);
        _tmp__Namespaces->Add(_marshalElement);
    }
    return _tmp__Namespaces;
}

void CppSharp::Parser::AST::DeclarationContext::Namespaces::set(::System::Collections::Generic::List<CppSharp::Parser::AST::Namespace^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::Namespace*>();
    for each(CppSharp::Parser::AST::Namespace^ _element in value)
    {
        auto _marshalElement = (class ::CppSharp::CppParser::AST::Namespace*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->Namespaces = _tmpvalue;
}

::System::Collections::Generic::List<CppSharp::Parser::AST::Enumeration^>^ CppSharp::Parser::AST::DeclarationContext::Enums::get()
{
    auto _tmp__Enums = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::Enumeration^>();
    auto __list0 = ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->Enums;
    for(auto _element : __list0)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Enumeration((class ::CppSharp::CppParser::AST::Enumeration*)_element);
        _tmp__Enums->Add(_marshalElement);
    }
    return _tmp__Enums;
}

void CppSharp::Parser::AST::DeclarationContext::Enums::set(::System::Collections::Generic::List<CppSharp::Parser::AST::Enumeration^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::Enumeration*>();
    for each(CppSharp::Parser::AST::Enumeration^ _element in value)
    {
        auto _marshalElement = (class ::CppSharp::CppParser::AST::Enumeration*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->Enums = _tmpvalue;
}

::System::Collections::Generic::List<CppSharp::Parser::AST::Function^>^ CppSharp::Parser::AST::DeclarationContext::Functions::get()
{
    auto _tmp__Functions = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::Function^>();
    auto __list0 = ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->Functions;
    for(auto _element : __list0)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Function((class ::CppSharp::CppParser::AST::Function*)_element);
        _tmp__Functions->Add(_marshalElement);
    }
    return _tmp__Functions;
}

void CppSharp::Parser::AST::DeclarationContext::Functions::set(::System::Collections::Generic::List<CppSharp::Parser::AST::Function^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::Function*>();
    for each(CppSharp::Parser::AST::Function^ _element in value)
    {
        auto _marshalElement = (class ::CppSharp::CppParser::AST::Function*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->Functions = _tmpvalue;
}

::System::Collections::Generic::List<CppSharp::Parser::AST::Class^>^ CppSharp::Parser::AST::DeclarationContext::Classes::get()
{
    auto _tmp__Classes = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::Class^>();
    auto __list0 = ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->Classes;
    for(auto _element : __list0)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Class((class ::CppSharp::CppParser::AST::Class*)_element);
        _tmp__Classes->Add(_marshalElement);
    }
    return _tmp__Classes;
}

void CppSharp::Parser::AST::DeclarationContext::Classes::set(::System::Collections::Generic::List<CppSharp::Parser::AST::Class^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::Class*>();
    for each(CppSharp::Parser::AST::Class^ _element in value)
    {
        auto _marshalElement = (class ::CppSharp::CppParser::AST::Class*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->Classes = _tmpvalue;
}

::System::Collections::Generic::List<CppSharp::Parser::AST::Template^>^ CppSharp::Parser::AST::DeclarationContext::Templates::get()
{
    auto _tmp__Templates = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::Template^>();
    auto __list0 = ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->Templates;
    for(auto _element : __list0)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Template((class ::CppSharp::CppParser::AST::Template*)_element);
        _tmp__Templates->Add(_marshalElement);
    }
    return _tmp__Templates;
}

void CppSharp::Parser::AST::DeclarationContext::Templates::set(::System::Collections::Generic::List<CppSharp::Parser::AST::Template^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::Template*>();
    for each(CppSharp::Parser::AST::Template^ _element in value)
    {
        auto _marshalElement = (class ::CppSharp::CppParser::AST::Template*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->Templates = _tmpvalue;
}

::System::Collections::Generic::List<CppSharp::Parser::AST::TypedefDecl^>^ CppSharp::Parser::AST::DeclarationContext::Typedefs::get()
{
    auto _tmp__Typedefs = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::TypedefDecl^>();
    auto __list0 = ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->Typedefs;
    for(auto _element : __list0)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::TypedefDecl((class ::CppSharp::CppParser::AST::TypedefDecl*)_element);
        _tmp__Typedefs->Add(_marshalElement);
    }
    return _tmp__Typedefs;
}

void CppSharp::Parser::AST::DeclarationContext::Typedefs::set(::System::Collections::Generic::List<CppSharp::Parser::AST::TypedefDecl^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::TypedefDecl*>();
    for each(CppSharp::Parser::AST::TypedefDecl^ _element in value)
    {
        auto _marshalElement = (class ::CppSharp::CppParser::AST::TypedefDecl*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->Typedefs = _tmpvalue;
}

::System::Collections::Generic::List<CppSharp::Parser::AST::TypeAlias^>^ CppSharp::Parser::AST::DeclarationContext::TypeAliases::get()
{
    auto _tmp__TypeAliases = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::TypeAlias^>();
    auto __list0 = ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->TypeAliases;
    for(auto _element : __list0)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::TypeAlias((class ::CppSharp::CppParser::AST::TypeAlias*)_element);
        _tmp__TypeAliases->Add(_marshalElement);
    }
    return _tmp__TypeAliases;
}

void CppSharp::Parser::AST::DeclarationContext::TypeAliases::set(::System::Collections::Generic::List<CppSharp::Parser::AST::TypeAlias^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::TypeAlias*>();
    for each(CppSharp::Parser::AST::TypeAlias^ _element in value)
    {
        auto _marshalElement = (class ::CppSharp::CppParser::AST::TypeAlias*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->TypeAliases = _tmpvalue;
}

::System::Collections::Generic::List<CppSharp::Parser::AST::Variable^>^ CppSharp::Parser::AST::DeclarationContext::Variables::get()
{
    auto _tmp__Variables = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::Variable^>();
    auto __list0 = ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->Variables;
    for(auto _element : __list0)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Variable((class ::CppSharp::CppParser::AST::Variable*)_element);
        _tmp__Variables->Add(_marshalElement);
    }
    return _tmp__Variables;
}

void CppSharp::Parser::AST::DeclarationContext::Variables::set(::System::Collections::Generic::List<CppSharp::Parser::AST::Variable^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::Variable*>();
    for each(CppSharp::Parser::AST::Variable^ _element in value)
    {
        auto _marshalElement = (class ::CppSharp::CppParser::AST::Variable*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->Variables = _tmpvalue;
}

::System::Collections::Generic::List<CppSharp::Parser::AST::Friend^>^ CppSharp::Parser::AST::DeclarationContext::Friends::get()
{
    auto _tmp__Friends = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::Friend^>();
    auto __list0 = ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->Friends;
    for(auto _element : __list0)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Friend((class ::CppSharp::CppParser::AST::Friend*)_element);
        _tmp__Friends->Add(_marshalElement);
    }
    return _tmp__Friends;
}

void CppSharp::Parser::AST::DeclarationContext::Friends::set(::System::Collections::Generic::List<CppSharp::Parser::AST::Friend^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::Friend*>();
    for each(CppSharp::Parser::AST::Friend^ _element in value)
    {
        auto _marshalElement = (class ::CppSharp::CppParser::AST::Friend*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->Friends = _tmpvalue;
}

bool CppSharp::Parser::AST::DeclarationContext::IsAnonymous::get()
{
    return ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->isAnonymous;
}

void CppSharp::Parser::AST::DeclarationContext::IsAnonymous::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->isAnonymous = value;
}

unsigned int CppSharp::Parser::AST::DeclarationContext::NamespacesCount::get()
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->getNamespacesCount();
    return ___ret;
}

unsigned int CppSharp::Parser::AST::DeclarationContext::EnumsCount::get()
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->getEnumsCount();
    return ___ret;
}

unsigned int CppSharp::Parser::AST::DeclarationContext::FunctionsCount::get()
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->getFunctionsCount();
    return ___ret;
}

unsigned int CppSharp::Parser::AST::DeclarationContext::ClassesCount::get()
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->getClassesCount();
    return ___ret;
}

unsigned int CppSharp::Parser::AST::DeclarationContext::TemplatesCount::get()
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->getTemplatesCount();
    return ___ret;
}

unsigned int CppSharp::Parser::AST::DeclarationContext::TypedefsCount::get()
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->getTypedefsCount();
    return ___ret;
}

unsigned int CppSharp::Parser::AST::DeclarationContext::TypeAliasesCount::get()
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->getTypeAliasesCount();
    return ___ret;
}

unsigned int CppSharp::Parser::AST::DeclarationContext::VariablesCount::get()
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->getVariablesCount();
    return ___ret;
}

unsigned int CppSharp::Parser::AST::DeclarationContext::FriendsCount::get()
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->getFriendsCount();
    return ___ret;
}

CppSharp::Parser::AST::TypedefNameDecl::TypedefNameDecl(class ::CppSharp::CppParser::AST::TypedefNameDecl* native)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)native)
{
}

CppSharp::Parser::AST::TypedefNameDecl^ CppSharp::Parser::AST::TypedefNameDecl::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::TypedefNameDecl((class ::CppSharp::CppParser::AST::TypedefNameDecl*) native.ToPointer());
}

CppSharp::Parser::AST::TypedefNameDecl::TypedefNameDecl(class ::CppSharp::CppParser::AST::TypedefNameDecl* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::TypedefNameDecl^ CppSharp::Parser::AST::TypedefNameDecl::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::TypedefNameDecl((class ::CppSharp::CppParser::AST::TypedefNameDecl*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::TypedefNameDecl::~TypedefNameDecl()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::TypedefNameDecl*) __nativePtr;
    }
}

CppSharp::Parser::AST::TypedefNameDecl::TypedefNameDecl(CppSharp::Parser::AST::DeclarationKind kind)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)nullptr)
{
    __ownsNativeInstance = true;
    auto __arg0 = (enum ::CppSharp::CppParser::AST::DeclarationKind)kind;
    NativePtr = new class ::CppSharp::CppParser::AST::TypedefNameDecl(__arg0);
}

CppSharp::Parser::AST::TypedefNameDecl::TypedefNameDecl(CppSharp::Parser::AST::TypedefNameDecl^ _0)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::TypedefNameDecl*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::TypedefNameDecl(__arg0);
}

CppSharp::Parser::AST::TypedefNameDecl::operator CppSharp::Parser::AST::TypedefNameDecl^(CppSharp::Parser::AST::DeclarationKind kind)
{
    auto __arg0 = (enum ::CppSharp::CppParser::AST::DeclarationKind)kind;
    auto ___ret = (::CppSharp::CppParser::AST::TypedefNameDecl) __arg0;
    auto _____ret = new class ::CppSharp::CppParser::AST::TypedefNameDecl(___ret);
    return (_____ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::TypedefNameDecl((class ::CppSharp::CppParser::AST::TypedefNameDecl*)_____ret, true);
}

CppSharp::Parser::AST::QualifiedType^ CppSharp::Parser::AST::TypedefNameDecl::QualifiedType::get()
{
    return (&((class ::CppSharp::CppParser::AST::TypedefNameDecl*)NativePtr)->qualifiedType == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::QualifiedType((struct ::CppSharp::CppParser::AST::QualifiedType*)&((class ::CppSharp::CppParser::AST::TypedefNameDecl*)NativePtr)->qualifiedType);
}

void CppSharp::Parser::AST::TypedefNameDecl::QualifiedType::set(CppSharp::Parser::AST::QualifiedType^ value)
{
    if (ReferenceEquals(value, nullptr))
        throw gcnew ::System::ArgumentNullException("value", "Cannot be null because it is passed by value.");
    ((class ::CppSharp::CppParser::AST::TypedefNameDecl*)NativePtr)->qualifiedType = *(struct ::CppSharp::CppParser::AST::QualifiedType*)value->NativePtr;
}

CppSharp::Parser::AST::TypedefDecl::TypedefDecl(class ::CppSharp::CppParser::AST::TypedefDecl* native)
    : CppSharp::Parser::AST::TypedefNameDecl((::CppSharp::CppParser::AST::TypedefNameDecl*)native)
{
}

CppSharp::Parser::AST::TypedefDecl^ CppSharp::Parser::AST::TypedefDecl::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::TypedefDecl((class ::CppSharp::CppParser::AST::TypedefDecl*) native.ToPointer());
}

CppSharp::Parser::AST::TypedefDecl::TypedefDecl(class ::CppSharp::CppParser::AST::TypedefDecl* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::TypedefNameDecl((::CppSharp::CppParser::AST::TypedefNameDecl*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::TypedefDecl^ CppSharp::Parser::AST::TypedefDecl::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::TypedefDecl((class ::CppSharp::CppParser::AST::TypedefDecl*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::TypedefDecl::~TypedefDecl()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::TypedefDecl*) __nativePtr;
    }
}

CppSharp::Parser::AST::TypedefDecl::TypedefDecl()
    : CppSharp::Parser::AST::TypedefNameDecl((::CppSharp::CppParser::AST::TypedefNameDecl*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::TypedefDecl();
}

CppSharp::Parser::AST::TypedefDecl::TypedefDecl(CppSharp::Parser::AST::TypedefDecl^ _0)
    : CppSharp::Parser::AST::TypedefNameDecl((::CppSharp::CppParser::AST::TypedefNameDecl*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::TypedefDecl*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::TypedefDecl(__arg0);
}

CppSharp::Parser::AST::TypeAlias::TypeAlias(class ::CppSharp::CppParser::AST::TypeAlias* native)
    : CppSharp::Parser::AST::TypedefNameDecl((::CppSharp::CppParser::AST::TypedefNameDecl*)native)
{
}

CppSharp::Parser::AST::TypeAlias^ CppSharp::Parser::AST::TypeAlias::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::TypeAlias((class ::CppSharp::CppParser::AST::TypeAlias*) native.ToPointer());
}

CppSharp::Parser::AST::TypeAlias::TypeAlias(class ::CppSharp::CppParser::AST::TypeAlias* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::TypedefNameDecl((::CppSharp::CppParser::AST::TypedefNameDecl*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::TypeAlias^ CppSharp::Parser::AST::TypeAlias::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::TypeAlias((class ::CppSharp::CppParser::AST::TypeAlias*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::TypeAlias::~TypeAlias()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::TypeAlias*) __nativePtr;
    }
}

CppSharp::Parser::AST::TypeAlias::TypeAlias()
    : CppSharp::Parser::AST::TypedefNameDecl((::CppSharp::CppParser::AST::TypedefNameDecl*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::TypeAlias();
}

CppSharp::Parser::AST::TypeAlias::TypeAlias(CppSharp::Parser::AST::TypeAlias^ _0)
    : CppSharp::Parser::AST::TypedefNameDecl((::CppSharp::CppParser::AST::TypedefNameDecl*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::TypeAlias*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::TypeAlias(__arg0);
}

CppSharp::Parser::AST::TypeAliasTemplate^ CppSharp::Parser::AST::TypeAlias::DescribedAliasTemplate::get()
{
    return (((class ::CppSharp::CppParser::AST::TypeAlias*)NativePtr)->describedAliasTemplate == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::TypeAliasTemplate((class ::CppSharp::CppParser::AST::TypeAliasTemplate*)((class ::CppSharp::CppParser::AST::TypeAlias*)NativePtr)->describedAliasTemplate);
}

void CppSharp::Parser::AST::TypeAlias::DescribedAliasTemplate::set(CppSharp::Parser::AST::TypeAliasTemplate^ value)
{
    ((class ::CppSharp::CppParser::AST::TypeAlias*)NativePtr)->describedAliasTemplate = (class ::CppSharp::CppParser::AST::TypeAliasTemplate*)value->NativePtr;
}

CppSharp::Parser::AST::Friend::Friend(class ::CppSharp::CppParser::AST::Friend* native)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)native)
{
}

CppSharp::Parser::AST::Friend^ CppSharp::Parser::AST::Friend::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::Friend((class ::CppSharp::CppParser::AST::Friend*) native.ToPointer());
}

CppSharp::Parser::AST::Friend::Friend(class ::CppSharp::CppParser::AST::Friend* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::Friend^ CppSharp::Parser::AST::Friend::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::Friend((class ::CppSharp::CppParser::AST::Friend*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::Friend::~Friend()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::Friend*) __nativePtr;
    }
}

CppSharp::Parser::AST::Friend::Friend()
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::Friend();
}

CppSharp::Parser::AST::Friend::Friend(CppSharp::Parser::AST::Friend^ _0)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::Friend*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::Friend(__arg0);
}

CppSharp::Parser::AST::Declaration^ CppSharp::Parser::AST::Friend::Declaration::get()
{
    return (((class ::CppSharp::CppParser::AST::Friend*)NativePtr)->declaration == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Declaration((class ::CppSharp::CppParser::AST::Declaration*)((class ::CppSharp::CppParser::AST::Friend*)NativePtr)->declaration);
}

void CppSharp::Parser::AST::Friend::Declaration::set(CppSharp::Parser::AST::Declaration^ value)
{
    ((class ::CppSharp::CppParser::AST::Friend*)NativePtr)->declaration = (class ::CppSharp::CppParser::AST::Declaration*)value->NativePtr;
}

CppSharp::Parser::AST::StatementObsolete::StatementObsolete(class ::CppSharp::CppParser::AST::StatementObsolete* native)
    : __ownsNativeInstance(false)
{
    NativePtr = native;
}

CppSharp::Parser::AST::StatementObsolete^ CppSharp::Parser::AST::StatementObsolete::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::StatementObsolete((class ::CppSharp::CppParser::AST::StatementObsolete*) native.ToPointer());
}

CppSharp::Parser::AST::StatementObsolete::StatementObsolete(class ::CppSharp::CppParser::AST::StatementObsolete* native, bool ownNativeInstance)
    : __ownsNativeInstance(ownNativeInstance)
{
    NativePtr = native;
}

CppSharp::Parser::AST::StatementObsolete^ CppSharp::Parser::AST::StatementObsolete::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::StatementObsolete((class ::CppSharp::CppParser::AST::StatementObsolete*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::StatementObsolete::~StatementObsolete()
{
    delete NativePtr;
}

CppSharp::Parser::AST::StatementObsolete::StatementObsolete(::System::String^ str, CppSharp::Parser::AST::StatementClassObsolete Class, CppSharp::Parser::AST::Declaration^ decl)
{
    __ownsNativeInstance = true;
    auto __arg0 = clix::marshalString<clix::E_UTF8>(str);
    auto __arg1 = (enum ::CppSharp::CppParser::AST::StatementClassObsolete)Class;
    auto __arg2 = (class ::CppSharp::CppParser::AST::Declaration*)decl->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::StatementObsolete(__arg0, __arg1, __arg2);
}

CppSharp::Parser::AST::StatementObsolete::StatementObsolete(CppSharp::Parser::AST::StatementObsolete^ _0)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::StatementObsolete*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::StatementObsolete(__arg0);
}

::System::IntPtr CppSharp::Parser::AST::StatementObsolete::__Instance::get()
{
    return ::System::IntPtr(NativePtr);
}

void CppSharp::Parser::AST::StatementObsolete::__Instance::set(::System::IntPtr object)
{
    NativePtr = (class ::CppSharp::CppParser::AST::StatementObsolete*)object.ToPointer();
}

CppSharp::Parser::AST::StatementClassObsolete CppSharp::Parser::AST::StatementObsolete::Class::get()
{
    return (CppSharp::Parser::AST::StatementClassObsolete)NativePtr->_class;
}

void CppSharp::Parser::AST::StatementObsolete::Class::set(CppSharp::Parser::AST::StatementClassObsolete value)
{
    ((class ::CppSharp::CppParser::AST::StatementObsolete*)NativePtr)->_class = (enum ::CppSharp::CppParser::AST::StatementClassObsolete)value;
}

CppSharp::Parser::AST::Declaration^ CppSharp::Parser::AST::StatementObsolete::Decl::get()
{
    return (NativePtr->decl == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Declaration((class ::CppSharp::CppParser::AST::Declaration*)NativePtr->decl);
}

void CppSharp::Parser::AST::StatementObsolete::Decl::set(CppSharp::Parser::AST::Declaration^ value)
{
    ((class ::CppSharp::CppParser::AST::StatementObsolete*)NativePtr)->decl = (class ::CppSharp::CppParser::AST::Declaration*)value->NativePtr;
}

::System::String^ CppSharp::Parser::AST::StatementObsolete::String::get()
{
    return clix::marshalString<clix::E_UTF8>(NativePtr->string);
}

void CppSharp::Parser::AST::StatementObsolete::String::set(::System::String^ value)
{
    ((class ::CppSharp::CppParser::AST::StatementObsolete*)NativePtr)->string = clix::marshalString<clix::E_UTF8>(value);
}

CppSharp::Parser::AST::ExpressionObsolete::ExpressionObsolete(class ::CppSharp::CppParser::AST::ExpressionObsolete* native)
    : CppSharp::Parser::AST::StatementObsolete((::CppSharp::CppParser::AST::StatementObsolete*)native)
{
}

CppSharp::Parser::AST::ExpressionObsolete^ CppSharp::Parser::AST::ExpressionObsolete::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::ExpressionObsolete((class ::CppSharp::CppParser::AST::ExpressionObsolete*) native.ToPointer());
}

CppSharp::Parser::AST::ExpressionObsolete::ExpressionObsolete(class ::CppSharp::CppParser::AST::ExpressionObsolete* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::StatementObsolete((::CppSharp::CppParser::AST::StatementObsolete*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::ExpressionObsolete^ CppSharp::Parser::AST::ExpressionObsolete::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::ExpressionObsolete((class ::CppSharp::CppParser::AST::ExpressionObsolete*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::ExpressionObsolete::~ExpressionObsolete()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::ExpressionObsolete*) __nativePtr;
    }
}

CppSharp::Parser::AST::ExpressionObsolete::ExpressionObsolete(::System::String^ str, CppSharp::Parser::AST::StatementClassObsolete Class, CppSharp::Parser::AST::Declaration^ decl)
    : CppSharp::Parser::AST::StatementObsolete((::CppSharp::CppParser::AST::StatementObsolete*)nullptr)
{
    __ownsNativeInstance = true;
    auto __arg0 = clix::marshalString<clix::E_UTF8>(str);
    auto __arg1 = (enum ::CppSharp::CppParser::AST::StatementClassObsolete)Class;
    auto __arg2 = (class ::CppSharp::CppParser::AST::Declaration*)decl->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::ExpressionObsolete(__arg0, __arg1, __arg2);
}

CppSharp::Parser::AST::ExpressionObsolete::ExpressionObsolete(CppSharp::Parser::AST::ExpressionObsolete^ _0)
    : CppSharp::Parser::AST::StatementObsolete((::CppSharp::CppParser::AST::StatementObsolete*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::ExpressionObsolete*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::ExpressionObsolete(__arg0);
}

CppSharp::Parser::AST::BinaryOperatorObsolete::BinaryOperatorObsolete(class ::CppSharp::CppParser::AST::BinaryOperatorObsolete* native)
    : CppSharp::Parser::AST::ExpressionObsolete((::CppSharp::CppParser::AST::ExpressionObsolete*)native)
{
}

CppSharp::Parser::AST::BinaryOperatorObsolete^ CppSharp::Parser::AST::BinaryOperatorObsolete::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::BinaryOperatorObsolete((class ::CppSharp::CppParser::AST::BinaryOperatorObsolete*) native.ToPointer());
}

CppSharp::Parser::AST::BinaryOperatorObsolete::BinaryOperatorObsolete(class ::CppSharp::CppParser::AST::BinaryOperatorObsolete* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::ExpressionObsolete((::CppSharp::CppParser::AST::ExpressionObsolete*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::BinaryOperatorObsolete^ CppSharp::Parser::AST::BinaryOperatorObsolete::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::BinaryOperatorObsolete((class ::CppSharp::CppParser::AST::BinaryOperatorObsolete*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::BinaryOperatorObsolete::~BinaryOperatorObsolete()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::BinaryOperatorObsolete*) __nativePtr;
    }
}

CppSharp::Parser::AST::BinaryOperatorObsolete::BinaryOperatorObsolete(::System::String^ str, CppSharp::Parser::AST::ExpressionObsolete^ lhs, CppSharp::Parser::AST::ExpressionObsolete^ rhs, ::System::String^ opcodeStr)
    : CppSharp::Parser::AST::ExpressionObsolete((::CppSharp::CppParser::AST::ExpressionObsolete*)nullptr)
{
    __ownsNativeInstance = true;
    auto __arg0 = clix::marshalString<clix::E_UTF8>(str);
    auto __arg1 = (class ::CppSharp::CppParser::AST::ExpressionObsolete*)lhs->NativePtr;
    auto __arg2 = (class ::CppSharp::CppParser::AST::ExpressionObsolete*)rhs->NativePtr;
    auto __arg3 = clix::marshalString<clix::E_UTF8>(opcodeStr);
    NativePtr = new class ::CppSharp::CppParser::AST::BinaryOperatorObsolete(__arg0, __arg1, __arg2, __arg3);
}

CppSharp::Parser::AST::BinaryOperatorObsolete::BinaryOperatorObsolete(CppSharp::Parser::AST::BinaryOperatorObsolete^ _0)
    : CppSharp::Parser::AST::ExpressionObsolete((::CppSharp::CppParser::AST::ExpressionObsolete*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::BinaryOperatorObsolete*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::BinaryOperatorObsolete(__arg0);
}

CppSharp::Parser::AST::ExpressionObsolete^ CppSharp::Parser::AST::BinaryOperatorObsolete::LHS::get()
{
    return (((class ::CppSharp::CppParser::AST::BinaryOperatorObsolete*)NativePtr)->LHS == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::ExpressionObsolete((class ::CppSharp::CppParser::AST::ExpressionObsolete*)((class ::CppSharp::CppParser::AST::BinaryOperatorObsolete*)NativePtr)->LHS);
}

void CppSharp::Parser::AST::BinaryOperatorObsolete::LHS::set(CppSharp::Parser::AST::ExpressionObsolete^ value)
{
    ((class ::CppSharp::CppParser::AST::BinaryOperatorObsolete*)NativePtr)->LHS = (class ::CppSharp::CppParser::AST::ExpressionObsolete*)value->NativePtr;
}

CppSharp::Parser::AST::ExpressionObsolete^ CppSharp::Parser::AST::BinaryOperatorObsolete::RHS::get()
{
    return (((class ::CppSharp::CppParser::AST::BinaryOperatorObsolete*)NativePtr)->RHS == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::ExpressionObsolete((class ::CppSharp::CppParser::AST::ExpressionObsolete*)((class ::CppSharp::CppParser::AST::BinaryOperatorObsolete*)NativePtr)->RHS);
}

void CppSharp::Parser::AST::BinaryOperatorObsolete::RHS::set(CppSharp::Parser::AST::ExpressionObsolete^ value)
{
    ((class ::CppSharp::CppParser::AST::BinaryOperatorObsolete*)NativePtr)->RHS = (class ::CppSharp::CppParser::AST::ExpressionObsolete*)value->NativePtr;
}

::System::String^ CppSharp::Parser::AST::BinaryOperatorObsolete::OpcodeStr::get()
{
    return clix::marshalString<clix::E_UTF8>(((class ::CppSharp::CppParser::AST::BinaryOperatorObsolete*)NativePtr)->opcodeStr);
}

void CppSharp::Parser::AST::BinaryOperatorObsolete::OpcodeStr::set(::System::String^ value)
{
    ((class ::CppSharp::CppParser::AST::BinaryOperatorObsolete*)NativePtr)->opcodeStr = clix::marshalString<clix::E_UTF8>(value);
}

CppSharp::Parser::AST::CallExprObsolete::CallExprObsolete(class ::CppSharp::CppParser::AST::CallExprObsolete* native)
    : CppSharp::Parser::AST::ExpressionObsolete((::CppSharp::CppParser::AST::ExpressionObsolete*)native)
{
}

CppSharp::Parser::AST::CallExprObsolete^ CppSharp::Parser::AST::CallExprObsolete::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::CallExprObsolete((class ::CppSharp::CppParser::AST::CallExprObsolete*) native.ToPointer());
}

CppSharp::Parser::AST::CallExprObsolete::CallExprObsolete(class ::CppSharp::CppParser::AST::CallExprObsolete* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::ExpressionObsolete((::CppSharp::CppParser::AST::ExpressionObsolete*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::CallExprObsolete^ CppSharp::Parser::AST::CallExprObsolete::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::CallExprObsolete((class ::CppSharp::CppParser::AST::CallExprObsolete*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::CallExprObsolete::~CallExprObsolete()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::CallExprObsolete*) __nativePtr;
    }
}

CppSharp::Parser::AST::CallExprObsolete::CallExprObsolete(::System::String^ str, CppSharp::Parser::AST::Declaration^ decl)
    : CppSharp::Parser::AST::ExpressionObsolete((::CppSharp::CppParser::AST::ExpressionObsolete*)nullptr)
{
    __ownsNativeInstance = true;
    auto __arg0 = clix::marshalString<clix::E_UTF8>(str);
    auto __arg1 = (class ::CppSharp::CppParser::AST::Declaration*)decl->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::CallExprObsolete(__arg0, __arg1);
}

CppSharp::Parser::AST::ExpressionObsolete^ CppSharp::Parser::AST::CallExprObsolete::GetArguments(unsigned int i)
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::CallExprObsolete*)NativePtr)->getArguments(i);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::ExpressionObsolete((class ::CppSharp::CppParser::AST::ExpressionObsolete*)___ret);
}

void CppSharp::Parser::AST::CallExprObsolete::AddArguments(CppSharp::Parser::AST::ExpressionObsolete^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto __arg0 = (class ::CppSharp::CppParser::AST::ExpressionObsolete*)s->NativePtr;
    ((class ::CppSharp::CppParser::AST::CallExprObsolete*)NativePtr)->addArguments(__arg0);
}

void CppSharp::Parser::AST::CallExprObsolete::ClearArguments()
{
    ((class ::CppSharp::CppParser::AST::CallExprObsolete*)NativePtr)->clearArguments();
}

CppSharp::Parser::AST::CallExprObsolete::CallExprObsolete(CppSharp::Parser::AST::CallExprObsolete^ _0)
    : CppSharp::Parser::AST::ExpressionObsolete((::CppSharp::CppParser::AST::ExpressionObsolete*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::CallExprObsolete*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::CallExprObsolete(__arg0);
}

::System::Collections::Generic::List<CppSharp::Parser::AST::ExpressionObsolete^>^ CppSharp::Parser::AST::CallExprObsolete::Arguments::get()
{
    auto _tmp__Arguments = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::ExpressionObsolete^>();
    auto __list0 = ((class ::CppSharp::CppParser::AST::CallExprObsolete*)NativePtr)->Arguments;
    for(auto _element : __list0)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::ExpressionObsolete((class ::CppSharp::CppParser::AST::ExpressionObsolete*)_element);
        _tmp__Arguments->Add(_marshalElement);
    }
    return _tmp__Arguments;
}

void CppSharp::Parser::AST::CallExprObsolete::Arguments::set(::System::Collections::Generic::List<CppSharp::Parser::AST::ExpressionObsolete^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::ExpressionObsolete*>();
    for each(CppSharp::Parser::AST::ExpressionObsolete^ _element in value)
    {
        auto _marshalElement = (class ::CppSharp::CppParser::AST::ExpressionObsolete*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((class ::CppSharp::CppParser::AST::CallExprObsolete*)NativePtr)->Arguments = _tmpvalue;
}

unsigned int CppSharp::Parser::AST::CallExprObsolete::ArgumentsCount::get()
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::CallExprObsolete*)NativePtr)->getArgumentsCount();
    return ___ret;
}

CppSharp::Parser::AST::CXXConstructExprObsolete::CXXConstructExprObsolete(class ::CppSharp::CppParser::AST::CXXConstructExprObsolete* native)
    : CppSharp::Parser::AST::ExpressionObsolete((::CppSharp::CppParser::AST::ExpressionObsolete*)native)
{
}

CppSharp::Parser::AST::CXXConstructExprObsolete^ CppSharp::Parser::AST::CXXConstructExprObsolete::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::CXXConstructExprObsolete((class ::CppSharp::CppParser::AST::CXXConstructExprObsolete*) native.ToPointer());
}

CppSharp::Parser::AST::CXXConstructExprObsolete::CXXConstructExprObsolete(class ::CppSharp::CppParser::AST::CXXConstructExprObsolete* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::ExpressionObsolete((::CppSharp::CppParser::AST::ExpressionObsolete*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::CXXConstructExprObsolete^ CppSharp::Parser::AST::CXXConstructExprObsolete::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::CXXConstructExprObsolete((class ::CppSharp::CppParser::AST::CXXConstructExprObsolete*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::CXXConstructExprObsolete::~CXXConstructExprObsolete()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::CXXConstructExprObsolete*) __nativePtr;
    }
}

CppSharp::Parser::AST::CXXConstructExprObsolete::CXXConstructExprObsolete(::System::String^ str, CppSharp::Parser::AST::Declaration^ decl)
    : CppSharp::Parser::AST::ExpressionObsolete((::CppSharp::CppParser::AST::ExpressionObsolete*)nullptr)
{
    __ownsNativeInstance = true;
    auto __arg0 = clix::marshalString<clix::E_UTF8>(str);
    auto __arg1 = (class ::CppSharp::CppParser::AST::Declaration*)decl->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::CXXConstructExprObsolete(__arg0, __arg1);
}

CppSharp::Parser::AST::ExpressionObsolete^ CppSharp::Parser::AST::CXXConstructExprObsolete::GetArguments(unsigned int i)
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::CXXConstructExprObsolete*)NativePtr)->getArguments(i);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::ExpressionObsolete((class ::CppSharp::CppParser::AST::ExpressionObsolete*)___ret);
}

void CppSharp::Parser::AST::CXXConstructExprObsolete::AddArguments(CppSharp::Parser::AST::ExpressionObsolete^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto __arg0 = (class ::CppSharp::CppParser::AST::ExpressionObsolete*)s->NativePtr;
    ((class ::CppSharp::CppParser::AST::CXXConstructExprObsolete*)NativePtr)->addArguments(__arg0);
}

void CppSharp::Parser::AST::CXXConstructExprObsolete::ClearArguments()
{
    ((class ::CppSharp::CppParser::AST::CXXConstructExprObsolete*)NativePtr)->clearArguments();
}

CppSharp::Parser::AST::CXXConstructExprObsolete::CXXConstructExprObsolete(CppSharp::Parser::AST::CXXConstructExprObsolete^ _0)
    : CppSharp::Parser::AST::ExpressionObsolete((::CppSharp::CppParser::AST::ExpressionObsolete*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::CXXConstructExprObsolete*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::CXXConstructExprObsolete(__arg0);
}

::System::Collections::Generic::List<CppSharp::Parser::AST::ExpressionObsolete^>^ CppSharp::Parser::AST::CXXConstructExprObsolete::Arguments::get()
{
    auto _tmp__Arguments = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::ExpressionObsolete^>();
    auto __list0 = ((class ::CppSharp::CppParser::AST::CXXConstructExprObsolete*)NativePtr)->Arguments;
    for(auto _element : __list0)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::ExpressionObsolete((class ::CppSharp::CppParser::AST::ExpressionObsolete*)_element);
        _tmp__Arguments->Add(_marshalElement);
    }
    return _tmp__Arguments;
}

void CppSharp::Parser::AST::CXXConstructExprObsolete::Arguments::set(::System::Collections::Generic::List<CppSharp::Parser::AST::ExpressionObsolete^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::ExpressionObsolete*>();
    for each(CppSharp::Parser::AST::ExpressionObsolete^ _element in value)
    {
        auto _marshalElement = (class ::CppSharp::CppParser::AST::ExpressionObsolete*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((class ::CppSharp::CppParser::AST::CXXConstructExprObsolete*)NativePtr)->Arguments = _tmpvalue;
}

unsigned int CppSharp::Parser::AST::CXXConstructExprObsolete::ArgumentsCount::get()
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::CXXConstructExprObsolete*)NativePtr)->getArgumentsCount();
    return ___ret;
}

CppSharp::Parser::AST::Parameter::Parameter(class ::CppSharp::CppParser::AST::Parameter* native)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)native)
{
}

CppSharp::Parser::AST::Parameter^ CppSharp::Parser::AST::Parameter::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::Parameter((class ::CppSharp::CppParser::AST::Parameter*) native.ToPointer());
}

CppSharp::Parser::AST::Parameter::Parameter(class ::CppSharp::CppParser::AST::Parameter* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::Parameter^ CppSharp::Parser::AST::Parameter::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::Parameter((class ::CppSharp::CppParser::AST::Parameter*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::Parameter::~Parameter()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::Parameter*) __nativePtr;
    }
}

CppSharp::Parser::AST::Parameter::Parameter()
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::Parameter();
}

CppSharp::Parser::AST::Parameter::Parameter(CppSharp::Parser::AST::Parameter^ _0)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::Parameter*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::Parameter(__arg0);
}

CppSharp::Parser::AST::QualifiedType^ CppSharp::Parser::AST::Parameter::QualifiedType::get()
{
    return (&((class ::CppSharp::CppParser::AST::Parameter*)NativePtr)->qualifiedType == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::QualifiedType((struct ::CppSharp::CppParser::AST::QualifiedType*)&((class ::CppSharp::CppParser::AST::Parameter*)NativePtr)->qualifiedType);
}

void CppSharp::Parser::AST::Parameter::QualifiedType::set(CppSharp::Parser::AST::QualifiedType^ value)
{
    if (ReferenceEquals(value, nullptr))
        throw gcnew ::System::ArgumentNullException("value", "Cannot be null because it is passed by value.");
    ((class ::CppSharp::CppParser::AST::Parameter*)NativePtr)->qualifiedType = *(struct ::CppSharp::CppParser::AST::QualifiedType*)value->NativePtr;
}

bool CppSharp::Parser::AST::Parameter::IsIndirect::get()
{
    return ((class ::CppSharp::CppParser::AST::Parameter*)NativePtr)->isIndirect;
}

void CppSharp::Parser::AST::Parameter::IsIndirect::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Parameter*)NativePtr)->isIndirect = value;
}

bool CppSharp::Parser::AST::Parameter::HasDefaultValue::get()
{
    return ((class ::CppSharp::CppParser::AST::Parameter*)NativePtr)->hasDefaultValue;
}

void CppSharp::Parser::AST::Parameter::HasDefaultValue::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Parameter*)NativePtr)->hasDefaultValue = value;
}

unsigned int CppSharp::Parser::AST::Parameter::Index::get()
{
    return ((class ::CppSharp::CppParser::AST::Parameter*)NativePtr)->index;
}

void CppSharp::Parser::AST::Parameter::Index::set(unsigned int value)
{
    ((class ::CppSharp::CppParser::AST::Parameter*)NativePtr)->index = value;
}

CppSharp::Parser::AST::ExpressionObsolete^ CppSharp::Parser::AST::Parameter::DefaultArgument::get()
{
    return (((class ::CppSharp::CppParser::AST::Parameter*)NativePtr)->defaultArgument == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::ExpressionObsolete((class ::CppSharp::CppParser::AST::ExpressionObsolete*)((class ::CppSharp::CppParser::AST::Parameter*)NativePtr)->defaultArgument);
}

void CppSharp::Parser::AST::Parameter::DefaultArgument::set(CppSharp::Parser::AST::ExpressionObsolete^ value)
{
    ((class ::CppSharp::CppParser::AST::Parameter*)NativePtr)->defaultArgument = (class ::CppSharp::CppParser::AST::ExpressionObsolete*)value->NativePtr;
}

CppSharp::Parser::AST::Expr^ CppSharp::Parser::AST::Parameter::DefaultValue::get()
{
    return (((class ::CppSharp::CppParser::AST::Parameter*)NativePtr)->defaultValue == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Expr((class ::CppSharp::CppParser::AST::Expr*)((class ::CppSharp::CppParser::AST::Parameter*)NativePtr)->defaultValue);
}

void CppSharp::Parser::AST::Parameter::DefaultValue::set(CppSharp::Parser::AST::Expr^ value)
{
    ((class ::CppSharp::CppParser::AST::Parameter*)NativePtr)->defaultValue = (class ::CppSharp::CppParser::AST::Expr*)value->NativePtr;
}

CppSharp::Parser::AST::Function::Function(class ::CppSharp::CppParser::AST::Function* native)
    : CppSharp::Parser::AST::DeclarationContext((::CppSharp::CppParser::AST::DeclarationContext*)native)
{
}

CppSharp::Parser::AST::Function^ CppSharp::Parser::AST::Function::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::Function((class ::CppSharp::CppParser::AST::Function*) native.ToPointer());
}

CppSharp::Parser::AST::Function::Function(class ::CppSharp::CppParser::AST::Function* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::DeclarationContext((::CppSharp::CppParser::AST::DeclarationContext*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::Function^ CppSharp::Parser::AST::Function::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::Function((class ::CppSharp::CppParser::AST::Function*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::Function::~Function()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::Function*) __nativePtr;
    }
}

CppSharp::Parser::AST::Function::Function()
    : CppSharp::Parser::AST::DeclarationContext((::CppSharp::CppParser::AST::DeclarationContext*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::Function();
}

CppSharp::Parser::AST::Parameter^ CppSharp::Parser::AST::Function::GetParameters(unsigned int i)
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->getParameters(i);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Parameter((class ::CppSharp::CppParser::AST::Parameter*)___ret);
}

void CppSharp::Parser::AST::Function::AddParameters(CppSharp::Parser::AST::Parameter^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto __arg0 = (class ::CppSharp::CppParser::AST::Parameter*)s->NativePtr;
    ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->addParameters(__arg0);
}

void CppSharp::Parser::AST::Function::ClearParameters()
{
    ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->clearParameters();
}

CppSharp::Parser::AST::Function::Function(CppSharp::Parser::AST::Function^ _0)
    : CppSharp::Parser::AST::DeclarationContext((::CppSharp::CppParser::AST::DeclarationContext*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::Function*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::Function(__arg0);
}

CppSharp::Parser::AST::QualifiedType^ CppSharp::Parser::AST::Function::ReturnType::get()
{
    return (&((class ::CppSharp::CppParser::AST::Function*)NativePtr)->returnType == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::QualifiedType((struct ::CppSharp::CppParser::AST::QualifiedType*)&((class ::CppSharp::CppParser::AST::Function*)NativePtr)->returnType);
}

void CppSharp::Parser::AST::Function::ReturnType::set(CppSharp::Parser::AST::QualifiedType^ value)
{
    if (ReferenceEquals(value, nullptr))
        throw gcnew ::System::ArgumentNullException("value", "Cannot be null because it is passed by value.");
    ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->returnType = *(struct ::CppSharp::CppParser::AST::QualifiedType*)value->NativePtr;
}

bool CppSharp::Parser::AST::Function::IsReturnIndirect::get()
{
    return ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->isReturnIndirect;
}

void CppSharp::Parser::AST::Function::IsReturnIndirect::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->isReturnIndirect = value;
}

bool CppSharp::Parser::AST::Function::HasThisReturn::get()
{
    return ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->hasThisReturn;
}

void CppSharp::Parser::AST::Function::HasThisReturn::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->hasThisReturn = value;
}

bool CppSharp::Parser::AST::Function::IsConstExpr::get()
{
    return ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->isConstExpr;
}

void CppSharp::Parser::AST::Function::IsConstExpr::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->isConstExpr = value;
}

bool CppSharp::Parser::AST::Function::IsVariadic::get()
{
    return ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->isVariadic;
}

void CppSharp::Parser::AST::Function::IsVariadic::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->isVariadic = value;
}

bool CppSharp::Parser::AST::Function::IsInline::get()
{
    return ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->isInline;
}

void CppSharp::Parser::AST::Function::IsInline::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->isInline = value;
}

bool CppSharp::Parser::AST::Function::IsPure::get()
{
    return ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->isPure;
}

void CppSharp::Parser::AST::Function::IsPure::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->isPure = value;
}

bool CppSharp::Parser::AST::Function::IsDeleted::get()
{
    return ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->isDeleted;
}

void CppSharp::Parser::AST::Function::IsDeleted::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->isDeleted = value;
}

bool CppSharp::Parser::AST::Function::IsDefaulted::get()
{
    return ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->isDefaulted;
}

void CppSharp::Parser::AST::Function::IsDefaulted::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->isDefaulted = value;
}

CppSharp::Parser::AST::FriendKind CppSharp::Parser::AST::Function::FriendKind::get()
{
    return (CppSharp::Parser::AST::FriendKind)((class ::CppSharp::CppParser::AST::Function*)NativePtr)->friendKind;
}

void CppSharp::Parser::AST::Function::FriendKind::set(CppSharp::Parser::AST::FriendKind value)
{
    ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->friendKind = (enum ::CppSharp::CppParser::AST::FriendKind)value;
}

CppSharp::Parser::AST::CXXOperatorKind CppSharp::Parser::AST::Function::OperatorKind::get()
{
    return (CppSharp::Parser::AST::CXXOperatorKind)((class ::CppSharp::CppParser::AST::Function*)NativePtr)->operatorKind;
}

void CppSharp::Parser::AST::Function::OperatorKind::set(CppSharp::Parser::AST::CXXOperatorKind value)
{
    ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->operatorKind = (enum ::CppSharp::CppParser::AST::CXXOperatorKind)value;
}

::System::String^ CppSharp::Parser::AST::Function::Mangled::get()
{
    return clix::marshalString<clix::E_UTF8>(((class ::CppSharp::CppParser::AST::Function*)NativePtr)->mangled);
}

void CppSharp::Parser::AST::Function::Mangled::set(::System::String^ value)
{
    ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->mangled = clix::marshalString<clix::E_UTF8>(value);
}

::System::String^ CppSharp::Parser::AST::Function::Signature::get()
{
    return clix::marshalString<clix::E_UTF8>(((class ::CppSharp::CppParser::AST::Function*)NativePtr)->signature);
}

void CppSharp::Parser::AST::Function::Signature::set(::System::String^ value)
{
    ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->signature = clix::marshalString<clix::E_UTF8>(value);
}

::System::String^ CppSharp::Parser::AST::Function::Body::get()
{
    return clix::marshalString<clix::E_UTF8>(((class ::CppSharp::CppParser::AST::Function*)NativePtr)->body);
}

void CppSharp::Parser::AST::Function::Body::set(::System::String^ value)
{
    ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->body = clix::marshalString<clix::E_UTF8>(value);
}

CppSharp::Parser::AST::Stmt^ CppSharp::Parser::AST::Function::BodyStmt::get()
{
    return (((class ::CppSharp::CppParser::AST::Function*)NativePtr)->bodyStmt == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Stmt((class ::CppSharp::CppParser::AST::Stmt*)((class ::CppSharp::CppParser::AST::Function*)NativePtr)->bodyStmt);
}

void CppSharp::Parser::AST::Function::BodyStmt::set(CppSharp::Parser::AST::Stmt^ value)
{
    ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->bodyStmt = (class ::CppSharp::CppParser::AST::Stmt*)value->NativePtr;
}

CppSharp::Parser::AST::CallingConvention CppSharp::Parser::AST::Function::CallingConvention::get()
{
    return (CppSharp::Parser::AST::CallingConvention)((class ::CppSharp::CppParser::AST::Function*)NativePtr)->callingConvention;
}

void CppSharp::Parser::AST::Function::CallingConvention::set(CppSharp::Parser::AST::CallingConvention value)
{
    ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->callingConvention = (enum ::CppSharp::CppParser::AST::CallingConvention)value;
}

::System::Collections::Generic::List<CppSharp::Parser::AST::Parameter^>^ CppSharp::Parser::AST::Function::Parameters::get()
{
    auto _tmp__Parameters = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::Parameter^>();
    auto __list0 = ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->Parameters;
    for(auto _element : __list0)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Parameter((class ::CppSharp::CppParser::AST::Parameter*)_element);
        _tmp__Parameters->Add(_marshalElement);
    }
    return _tmp__Parameters;
}

void CppSharp::Parser::AST::Function::Parameters::set(::System::Collections::Generic::List<CppSharp::Parser::AST::Parameter^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::Parameter*>();
    for each(CppSharp::Parser::AST::Parameter^ _element in value)
    {
        auto _marshalElement = (class ::CppSharp::CppParser::AST::Parameter*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->Parameters = _tmpvalue;
}

CppSharp::Parser::AST::FunctionTemplateSpecialization^ CppSharp::Parser::AST::Function::SpecializationInfo::get()
{
    return (((class ::CppSharp::CppParser::AST::Function*)NativePtr)->specializationInfo == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::FunctionTemplateSpecialization((class ::CppSharp::CppParser::AST::FunctionTemplateSpecialization*)((class ::CppSharp::CppParser::AST::Function*)NativePtr)->specializationInfo);
}

void CppSharp::Parser::AST::Function::SpecializationInfo::set(CppSharp::Parser::AST::FunctionTemplateSpecialization^ value)
{
    ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->specializationInfo = (class ::CppSharp::CppParser::AST::FunctionTemplateSpecialization*)value->NativePtr;
}

CppSharp::Parser::AST::Function^ CppSharp::Parser::AST::Function::InstantiatedFrom::get()
{
    return (((class ::CppSharp::CppParser::AST::Function*)NativePtr)->instantiatedFrom == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Function((class ::CppSharp::CppParser::AST::Function*)((class ::CppSharp::CppParser::AST::Function*)NativePtr)->instantiatedFrom);
}

void CppSharp::Parser::AST::Function::InstantiatedFrom::set(CppSharp::Parser::AST::Function^ value)
{
    ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->instantiatedFrom = (class ::CppSharp::CppParser::AST::Function*)value->NativePtr;
}

CppSharp::Parser::AST::QualifiedType^ CppSharp::Parser::AST::Function::QualifiedType::get()
{
    return (&((class ::CppSharp::CppParser::AST::Function*)NativePtr)->qualifiedType == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::QualifiedType((struct ::CppSharp::CppParser::AST::QualifiedType*)&((class ::CppSharp::CppParser::AST::Function*)NativePtr)->qualifiedType);
}

void CppSharp::Parser::AST::Function::QualifiedType::set(CppSharp::Parser::AST::QualifiedType^ value)
{
    if (ReferenceEquals(value, nullptr))
        throw gcnew ::System::ArgumentNullException("value", "Cannot be null because it is passed by value.");
    ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->qualifiedType = *(struct ::CppSharp::CppParser::AST::QualifiedType*)value->NativePtr;
}

unsigned int CppSharp::Parser::AST::Function::ParametersCount::get()
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::Function*)NativePtr)->getParametersCount();
    return ___ret;
}

CppSharp::Parser::AST::Method::Method(class ::CppSharp::CppParser::AST::Method* native)
    : CppSharp::Parser::AST::Function((::CppSharp::CppParser::AST::Function*)native)
{
}

CppSharp::Parser::AST::Method^ CppSharp::Parser::AST::Method::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::Method((class ::CppSharp::CppParser::AST::Method*) native.ToPointer());
}

CppSharp::Parser::AST::Method::Method(class ::CppSharp::CppParser::AST::Method* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::Function((::CppSharp::CppParser::AST::Function*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::Method^ CppSharp::Parser::AST::Method::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::Method((class ::CppSharp::CppParser::AST::Method*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::Method::~Method()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::Method*) __nativePtr;
    }
}

CppSharp::Parser::AST::Method::Method()
    : CppSharp::Parser::AST::Function((::CppSharp::CppParser::AST::Function*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::Method();
}

CppSharp::Parser::AST::Method^ CppSharp::Parser::AST::Method::GetOverriddenMethods(unsigned int i)
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::Method*)NativePtr)->getOverriddenMethods(i);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Method((class ::CppSharp::CppParser::AST::Method*)___ret);
}

void CppSharp::Parser::AST::Method::AddOverriddenMethods(CppSharp::Parser::AST::Method^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto __arg0 = (class ::CppSharp::CppParser::AST::Method*)s->NativePtr;
    ((class ::CppSharp::CppParser::AST::Method*)NativePtr)->addOverriddenMethods(__arg0);
}

void CppSharp::Parser::AST::Method::ClearOverriddenMethods()
{
    ((class ::CppSharp::CppParser::AST::Method*)NativePtr)->clearOverriddenMethods();
}

CppSharp::Parser::AST::Method::Method(CppSharp::Parser::AST::Method^ _0)
    : CppSharp::Parser::AST::Function((::CppSharp::CppParser::AST::Function*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::Method*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::Method(__arg0);
}

bool CppSharp::Parser::AST::Method::IsVirtual::get()
{
    return ((class ::CppSharp::CppParser::AST::Method*)NativePtr)->isVirtual;
}

void CppSharp::Parser::AST::Method::IsVirtual::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Method*)NativePtr)->isVirtual = value;
}

bool CppSharp::Parser::AST::Method::IsStatic::get()
{
    return ((class ::CppSharp::CppParser::AST::Method*)NativePtr)->isStatic;
}

void CppSharp::Parser::AST::Method::IsStatic::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Method*)NativePtr)->isStatic = value;
}

bool CppSharp::Parser::AST::Method::IsConst::get()
{
    return ((class ::CppSharp::CppParser::AST::Method*)NativePtr)->isConst;
}

void CppSharp::Parser::AST::Method::IsConst::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Method*)NativePtr)->isConst = value;
}

bool CppSharp::Parser::AST::Method::IsExplicit::get()
{
    return ((class ::CppSharp::CppParser::AST::Method*)NativePtr)->isExplicit;
}

void CppSharp::Parser::AST::Method::IsExplicit::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Method*)NativePtr)->isExplicit = value;
}

bool CppSharp::Parser::AST::Method::IsVolatile::get()
{
    return ((class ::CppSharp::CppParser::AST::Method*)NativePtr)->isVolatile;
}

void CppSharp::Parser::AST::Method::IsVolatile::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Method*)NativePtr)->isVolatile = value;
}

CppSharp::Parser::AST::CXXMethodKind CppSharp::Parser::AST::Method::MethodKind::get()
{
    return (CppSharp::Parser::AST::CXXMethodKind)((class ::CppSharp::CppParser::AST::Method*)NativePtr)->methodKind;
}

void CppSharp::Parser::AST::Method::MethodKind::set(CppSharp::Parser::AST::CXXMethodKind value)
{
    ((class ::CppSharp::CppParser::AST::Method*)NativePtr)->methodKind = (enum ::CppSharp::CppParser::AST::CXXMethodKind)value;
}

bool CppSharp::Parser::AST::Method::IsDefaultConstructor::get()
{
    return ((class ::CppSharp::CppParser::AST::Method*)NativePtr)->isDefaultConstructor;
}

void CppSharp::Parser::AST::Method::IsDefaultConstructor::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Method*)NativePtr)->isDefaultConstructor = value;
}

bool CppSharp::Parser::AST::Method::IsCopyConstructor::get()
{
    return ((class ::CppSharp::CppParser::AST::Method*)NativePtr)->isCopyConstructor;
}

void CppSharp::Parser::AST::Method::IsCopyConstructor::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Method*)NativePtr)->isCopyConstructor = value;
}

bool CppSharp::Parser::AST::Method::IsMoveConstructor::get()
{
    return ((class ::CppSharp::CppParser::AST::Method*)NativePtr)->isMoveConstructor;
}

void CppSharp::Parser::AST::Method::IsMoveConstructor::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Method*)NativePtr)->isMoveConstructor = value;
}

CppSharp::Parser::AST::QualifiedType^ CppSharp::Parser::AST::Method::ConversionType::get()
{
    return (&((class ::CppSharp::CppParser::AST::Method*)NativePtr)->conversionType == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::QualifiedType((struct ::CppSharp::CppParser::AST::QualifiedType*)&((class ::CppSharp::CppParser::AST::Method*)NativePtr)->conversionType);
}

void CppSharp::Parser::AST::Method::ConversionType::set(CppSharp::Parser::AST::QualifiedType^ value)
{
    if (ReferenceEquals(value, nullptr))
        throw gcnew ::System::ArgumentNullException("value", "Cannot be null because it is passed by value.");
    ((class ::CppSharp::CppParser::AST::Method*)NativePtr)->conversionType = *(struct ::CppSharp::CppParser::AST::QualifiedType*)value->NativePtr;
}

CppSharp::Parser::AST::RefQualifierKind CppSharp::Parser::AST::Method::RefQualifier::get()
{
    return (CppSharp::Parser::AST::RefQualifierKind)((class ::CppSharp::CppParser::AST::Method*)NativePtr)->refQualifier;
}

void CppSharp::Parser::AST::Method::RefQualifier::set(CppSharp::Parser::AST::RefQualifierKind value)
{
    ((class ::CppSharp::CppParser::AST::Method*)NativePtr)->refQualifier = (enum ::CppSharp::CppParser::AST::RefQualifierKind)value;
}

::System::Collections::Generic::List<CppSharp::Parser::AST::Method^>^ CppSharp::Parser::AST::Method::OverriddenMethods::get()
{
    auto _tmp__OverriddenMethods = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::Method^>();
    auto __list0 = ((class ::CppSharp::CppParser::AST::Method*)NativePtr)->OverriddenMethods;
    for(auto _element : __list0)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Method((class ::CppSharp::CppParser::AST::Method*)_element);
        _tmp__OverriddenMethods->Add(_marshalElement);
    }
    return _tmp__OverriddenMethods;
}

void CppSharp::Parser::AST::Method::OverriddenMethods::set(::System::Collections::Generic::List<CppSharp::Parser::AST::Method^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::Method*>();
    for each(CppSharp::Parser::AST::Method^ _element in value)
    {
        auto _marshalElement = (class ::CppSharp::CppParser::AST::Method*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((class ::CppSharp::CppParser::AST::Method*)NativePtr)->OverriddenMethods = _tmpvalue;
}

unsigned int CppSharp::Parser::AST::Method::OverriddenMethodsCount::get()
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::Method*)NativePtr)->getOverriddenMethodsCount();
    return ___ret;
}

CppSharp::Parser::AST::Enumeration::Item::Item(class ::CppSharp::CppParser::AST::Enumeration::Item* native)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)native)
{
}

CppSharp::Parser::AST::Enumeration::Item^ CppSharp::Parser::AST::Enumeration::Item::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::Enumeration::Item((class ::CppSharp::CppParser::AST::Enumeration::Item*) native.ToPointer());
}

CppSharp::Parser::AST::Enumeration::Item::Item(class ::CppSharp::CppParser::AST::Enumeration::Item* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::Enumeration::Item^ CppSharp::Parser::AST::Enumeration::Item::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::Enumeration::Item((class ::CppSharp::CppParser::AST::Enumeration::Item*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::Enumeration::Item::~Item()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::Enumeration::Item*) __nativePtr;
    }
}

CppSharp::Parser::AST::Enumeration::Item::Item()
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::Enumeration::Item();
}

CppSharp::Parser::AST::Enumeration::Item::Item(CppSharp::Parser::AST::Enumeration::Item^ _0)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::Enumeration::Item*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::Enumeration::Item(__arg0);
}

::System::String^ CppSharp::Parser::AST::Enumeration::Item::Expression::get()
{
    return clix::marshalString<clix::E_UTF8>(((class ::CppSharp::CppParser::AST::Enumeration::Item*)NativePtr)->expression);
}

void CppSharp::Parser::AST::Enumeration::Item::Expression::set(::System::String^ value)
{
    ((class ::CppSharp::CppParser::AST::Enumeration::Item*)NativePtr)->expression = clix::marshalString<clix::E_UTF8>(value);
}

unsigned long long CppSharp::Parser::AST::Enumeration::Item::Value::get()
{
    return ((class ::CppSharp::CppParser::AST::Enumeration::Item*)NativePtr)->value;
}

void CppSharp::Parser::AST::Enumeration::Item::Value::set(unsigned long long value)
{
    ((class ::CppSharp::CppParser::AST::Enumeration::Item*)NativePtr)->value = (::uint64_t)value;
}

CppSharp::Parser::AST::Enumeration::Enumeration(class ::CppSharp::CppParser::AST::Enumeration* native)
    : CppSharp::Parser::AST::DeclarationContext((::CppSharp::CppParser::AST::DeclarationContext*)native)
{
}

CppSharp::Parser::AST::Enumeration^ CppSharp::Parser::AST::Enumeration::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::Enumeration((class ::CppSharp::CppParser::AST::Enumeration*) native.ToPointer());
}

CppSharp::Parser::AST::Enumeration::Enumeration(class ::CppSharp::CppParser::AST::Enumeration* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::DeclarationContext((::CppSharp::CppParser::AST::DeclarationContext*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::Enumeration^ CppSharp::Parser::AST::Enumeration::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::Enumeration((class ::CppSharp::CppParser::AST::Enumeration*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::Enumeration::~Enumeration()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::Enumeration*) __nativePtr;
    }
}

CppSharp::Parser::AST::Enumeration::Enumeration()
    : CppSharp::Parser::AST::DeclarationContext((::CppSharp::CppParser::AST::DeclarationContext*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::Enumeration();
}

CppSharp::Parser::AST::Enumeration::Item^ CppSharp::Parser::AST::Enumeration::GetItems(unsigned int i)
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::Enumeration*)NativePtr)->getItems(i);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Enumeration::Item((class ::CppSharp::CppParser::AST::Enumeration::Item*)___ret);
}

void CppSharp::Parser::AST::Enumeration::AddItems(CppSharp::Parser::AST::Enumeration::Item^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto __arg0 = (class ::CppSharp::CppParser::AST::Enumeration::Item*)s->NativePtr;
    ((class ::CppSharp::CppParser::AST::Enumeration*)NativePtr)->addItems(__arg0);
}

void CppSharp::Parser::AST::Enumeration::ClearItems()
{
    ((class ::CppSharp::CppParser::AST::Enumeration*)NativePtr)->clearItems();
}

CppSharp::Parser::AST::Enumeration::Item^ CppSharp::Parser::AST::Enumeration::FindItemByName(::System::String^ Name)
{
    auto __arg0 = clix::marshalString<clix::E_UTF8>(Name);
    auto ___ret = ((class ::CppSharp::CppParser::AST::Enumeration*)NativePtr)->FindItemByName(__arg0);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Enumeration::Item((class ::CppSharp::CppParser::AST::Enumeration::Item*)___ret);
}

CppSharp::Parser::AST::Enumeration::Enumeration(CppSharp::Parser::AST::Enumeration^ _0)
    : CppSharp::Parser::AST::DeclarationContext((::CppSharp::CppParser::AST::DeclarationContext*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::Enumeration*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::Enumeration(__arg0);
}

CppSharp::Parser::AST::Enumeration::EnumModifiers CppSharp::Parser::AST::Enumeration::Modifiers::get()
{
    return (CppSharp::Parser::AST::Enumeration::EnumModifiers)((class ::CppSharp::CppParser::AST::Enumeration*)NativePtr)->modifiers;
}

void CppSharp::Parser::AST::Enumeration::Modifiers::set(CppSharp::Parser::AST::Enumeration::EnumModifiers value)
{
    ((class ::CppSharp::CppParser::AST::Enumeration*)NativePtr)->modifiers = (enum ::CppSharp::CppParser::AST::Enumeration::EnumModifiers)value;
}

CppSharp::Parser::AST::Type^ CppSharp::Parser::AST::Enumeration::Type::get()
{
    return (((class ::CppSharp::CppParser::AST::Enumeration*)NativePtr)->type == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Type((class ::CppSharp::CppParser::AST::Type*)((class ::CppSharp::CppParser::AST::Enumeration*)NativePtr)->type);
}

void CppSharp::Parser::AST::Enumeration::Type::set(CppSharp::Parser::AST::Type^ value)
{
    ((class ::CppSharp::CppParser::AST::Enumeration*)NativePtr)->type = (class ::CppSharp::CppParser::AST::Type*)value->NativePtr;
}

CppSharp::Parser::AST::BuiltinType^ CppSharp::Parser::AST::Enumeration::BuiltinType::get()
{
    return (((class ::CppSharp::CppParser::AST::Enumeration*)NativePtr)->builtinType == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::BuiltinType((class ::CppSharp::CppParser::AST::BuiltinType*)((class ::CppSharp::CppParser::AST::Enumeration*)NativePtr)->builtinType);
}

void CppSharp::Parser::AST::Enumeration::BuiltinType::set(CppSharp::Parser::AST::BuiltinType^ value)
{
    ((class ::CppSharp::CppParser::AST::Enumeration*)NativePtr)->builtinType = (class ::CppSharp::CppParser::AST::BuiltinType*)value->NativePtr;
}

::System::Collections::Generic::List<CppSharp::Parser::AST::Enumeration::Item^>^ CppSharp::Parser::AST::Enumeration::Items::get()
{
    auto _tmp__Items = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::Enumeration::Item^>();
    auto __list0 = ((class ::CppSharp::CppParser::AST::Enumeration*)NativePtr)->Items;
    for(auto _element : __list0)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Enumeration::Item((class ::CppSharp::CppParser::AST::Enumeration::Item*)_element);
        _tmp__Items->Add(_marshalElement);
    }
    return _tmp__Items;
}

void CppSharp::Parser::AST::Enumeration::Items::set(::System::Collections::Generic::List<CppSharp::Parser::AST::Enumeration::Item^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::Enumeration::Item*>();
    for each(CppSharp::Parser::AST::Enumeration::Item^ _element in value)
    {
        auto _marshalElement = (class ::CppSharp::CppParser::AST::Enumeration::Item*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((class ::CppSharp::CppParser::AST::Enumeration*)NativePtr)->Items = _tmpvalue;
}

unsigned int CppSharp::Parser::AST::Enumeration::ItemsCount::get()
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::Enumeration*)NativePtr)->getItemsCount();
    return ___ret;
}

CppSharp::Parser::AST::Variable::Variable(class ::CppSharp::CppParser::AST::Variable* native)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)native)
{
}

CppSharp::Parser::AST::Variable^ CppSharp::Parser::AST::Variable::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::Variable((class ::CppSharp::CppParser::AST::Variable*) native.ToPointer());
}

CppSharp::Parser::AST::Variable::Variable(class ::CppSharp::CppParser::AST::Variable* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::Variable^ CppSharp::Parser::AST::Variable::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::Variable((class ::CppSharp::CppParser::AST::Variable*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::Variable::~Variable()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::Variable*) __nativePtr;
    }
}

CppSharp::Parser::AST::Variable::Variable()
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::Variable();
}

CppSharp::Parser::AST::Variable::Variable(CppSharp::Parser::AST::Variable^ _0)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::Variable*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::Variable(__arg0);
}

bool CppSharp::Parser::AST::Variable::IsConstExpr::get()
{
    return ((class ::CppSharp::CppParser::AST::Variable*)NativePtr)->isConstExpr;
}

void CppSharp::Parser::AST::Variable::IsConstExpr::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Variable*)NativePtr)->isConstExpr = value;
}

::System::String^ CppSharp::Parser::AST::Variable::Mangled::get()
{
    return clix::marshalString<clix::E_UTF8>(((class ::CppSharp::CppParser::AST::Variable*)NativePtr)->mangled);
}

void CppSharp::Parser::AST::Variable::Mangled::set(::System::String^ value)
{
    ((class ::CppSharp::CppParser::AST::Variable*)NativePtr)->mangled = clix::marshalString<clix::E_UTF8>(value);
}

CppSharp::Parser::AST::QualifiedType^ CppSharp::Parser::AST::Variable::QualifiedType::get()
{
    return (&((class ::CppSharp::CppParser::AST::Variable*)NativePtr)->qualifiedType == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::QualifiedType((struct ::CppSharp::CppParser::AST::QualifiedType*)&((class ::CppSharp::CppParser::AST::Variable*)NativePtr)->qualifiedType);
}

void CppSharp::Parser::AST::Variable::QualifiedType::set(CppSharp::Parser::AST::QualifiedType^ value)
{
    if (ReferenceEquals(value, nullptr))
        throw gcnew ::System::ArgumentNullException("value", "Cannot be null because it is passed by value.");
    ((class ::CppSharp::CppParser::AST::Variable*)NativePtr)->qualifiedType = *(struct ::CppSharp::CppParser::AST::QualifiedType*)value->NativePtr;
}

CppSharp::Parser::AST::ExpressionObsolete^ CppSharp::Parser::AST::Variable::Initializer::get()
{
    return (((class ::CppSharp::CppParser::AST::Variable*)NativePtr)->initializer == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::ExpressionObsolete((class ::CppSharp::CppParser::AST::ExpressionObsolete*)((class ::CppSharp::CppParser::AST::Variable*)NativePtr)->initializer);
}

void CppSharp::Parser::AST::Variable::Initializer::set(CppSharp::Parser::AST::ExpressionObsolete^ value)
{
    ((class ::CppSharp::CppParser::AST::Variable*)NativePtr)->initializer = (class ::CppSharp::CppParser::AST::ExpressionObsolete*)value->NativePtr;
}

CppSharp::Parser::AST::BaseClassSpecifier::BaseClassSpecifier(struct ::CppSharp::CppParser::AST::BaseClassSpecifier* native)
    : __ownsNativeInstance(false)
{
    NativePtr = native;
}

CppSharp::Parser::AST::BaseClassSpecifier^ CppSharp::Parser::AST::BaseClassSpecifier::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::BaseClassSpecifier((struct ::CppSharp::CppParser::AST::BaseClassSpecifier*) native.ToPointer());
}

CppSharp::Parser::AST::BaseClassSpecifier::BaseClassSpecifier(struct ::CppSharp::CppParser::AST::BaseClassSpecifier* native, bool ownNativeInstance)
    : __ownsNativeInstance(ownNativeInstance)
{
    NativePtr = native;
}

CppSharp::Parser::AST::BaseClassSpecifier^ CppSharp::Parser::AST::BaseClassSpecifier::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::BaseClassSpecifier((struct ::CppSharp::CppParser::AST::BaseClassSpecifier*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::BaseClassSpecifier::~BaseClassSpecifier()
{
    delete NativePtr;
}

CppSharp::Parser::AST::BaseClassSpecifier::BaseClassSpecifier()
{
    __ownsNativeInstance = true;
    NativePtr = new struct ::CppSharp::CppParser::AST::BaseClassSpecifier();
}

CppSharp::Parser::AST::BaseClassSpecifier::BaseClassSpecifier(CppSharp::Parser::AST::BaseClassSpecifier^ _0)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(struct ::CppSharp::CppParser::AST::BaseClassSpecifier*)_0->NativePtr;
    NativePtr = new struct ::CppSharp::CppParser::AST::BaseClassSpecifier(__arg0);
}

::System::IntPtr CppSharp::Parser::AST::BaseClassSpecifier::__Instance::get()
{
    return ::System::IntPtr(NativePtr);
}

void CppSharp::Parser::AST::BaseClassSpecifier::__Instance::set(::System::IntPtr object)
{
    NativePtr = (struct ::CppSharp::CppParser::AST::BaseClassSpecifier*)object.ToPointer();
}

CppSharp::Parser::AST::AccessSpecifier CppSharp::Parser::AST::BaseClassSpecifier::Access::get()
{
    return (CppSharp::Parser::AST::AccessSpecifier)NativePtr->access;
}

void CppSharp::Parser::AST::BaseClassSpecifier::Access::set(CppSharp::Parser::AST::AccessSpecifier value)
{
    ((struct ::CppSharp::CppParser::AST::BaseClassSpecifier*)NativePtr)->access = (enum ::CppSharp::CppParser::AST::AccessSpecifier)value;
}

bool CppSharp::Parser::AST::BaseClassSpecifier::IsVirtual::get()
{
    return NativePtr->isVirtual;
}

void CppSharp::Parser::AST::BaseClassSpecifier::IsVirtual::set(bool value)
{
    ((struct ::CppSharp::CppParser::AST::BaseClassSpecifier*)NativePtr)->isVirtual = value;
}

CppSharp::Parser::AST::Type^ CppSharp::Parser::AST::BaseClassSpecifier::Type::get()
{
    return (NativePtr->type == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Type((class ::CppSharp::CppParser::AST::Type*)NativePtr->type);
}

void CppSharp::Parser::AST::BaseClassSpecifier::Type::set(CppSharp::Parser::AST::Type^ value)
{
    ((struct ::CppSharp::CppParser::AST::BaseClassSpecifier*)NativePtr)->type = (class ::CppSharp::CppParser::AST::Type*)value->NativePtr;
}

int CppSharp::Parser::AST::BaseClassSpecifier::Offset::get()
{
    return NativePtr->offset;
}

void CppSharp::Parser::AST::BaseClassSpecifier::Offset::set(int value)
{
    ((struct ::CppSharp::CppParser::AST::BaseClassSpecifier*)NativePtr)->offset = value;
}

CppSharp::Parser::AST::Field::Field(class ::CppSharp::CppParser::AST::Field* native)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)native)
{
}

CppSharp::Parser::AST::Field^ CppSharp::Parser::AST::Field::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::Field((class ::CppSharp::CppParser::AST::Field*) native.ToPointer());
}

CppSharp::Parser::AST::Field::Field(class ::CppSharp::CppParser::AST::Field* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::Field^ CppSharp::Parser::AST::Field::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::Field((class ::CppSharp::CppParser::AST::Field*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::Field::~Field()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::Field*) __nativePtr;
    }
}

CppSharp::Parser::AST::Field::Field()
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::Field();
}

CppSharp::Parser::AST::Field::Field(CppSharp::Parser::AST::Field^ _0)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::Field*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::Field(__arg0);
}

CppSharp::Parser::AST::QualifiedType^ CppSharp::Parser::AST::Field::QualifiedType::get()
{
    return (&((class ::CppSharp::CppParser::AST::Field*)NativePtr)->qualifiedType == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::QualifiedType((struct ::CppSharp::CppParser::AST::QualifiedType*)&((class ::CppSharp::CppParser::AST::Field*)NativePtr)->qualifiedType);
}

void CppSharp::Parser::AST::Field::QualifiedType::set(CppSharp::Parser::AST::QualifiedType^ value)
{
    if (ReferenceEquals(value, nullptr))
        throw gcnew ::System::ArgumentNullException("value", "Cannot be null because it is passed by value.");
    ((class ::CppSharp::CppParser::AST::Field*)NativePtr)->qualifiedType = *(struct ::CppSharp::CppParser::AST::QualifiedType*)value->NativePtr;
}

CppSharp::Parser::AST::Class^ CppSharp::Parser::AST::Field::Class::get()
{
    return (((class ::CppSharp::CppParser::AST::Field*)NativePtr)->_class == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Class((class ::CppSharp::CppParser::AST::Class*)((class ::CppSharp::CppParser::AST::Field*)NativePtr)->_class);
}

void CppSharp::Parser::AST::Field::Class::set(CppSharp::Parser::AST::Class^ value)
{
    ((class ::CppSharp::CppParser::AST::Field*)NativePtr)->_class = (class ::CppSharp::CppParser::AST::Class*)value->NativePtr;
}

bool CppSharp::Parser::AST::Field::IsBitField::get()
{
    return ((class ::CppSharp::CppParser::AST::Field*)NativePtr)->isBitField;
}

void CppSharp::Parser::AST::Field::IsBitField::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Field*)NativePtr)->isBitField = value;
}

unsigned int CppSharp::Parser::AST::Field::BitWidth::get()
{
    return ((class ::CppSharp::CppParser::AST::Field*)NativePtr)->bitWidth;
}

void CppSharp::Parser::AST::Field::BitWidth::set(unsigned int value)
{
    ((class ::CppSharp::CppParser::AST::Field*)NativePtr)->bitWidth = value;
}

CppSharp::Parser::AST::AccessSpecifierDecl::AccessSpecifierDecl(class ::CppSharp::CppParser::AST::AccessSpecifierDecl* native)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)native)
{
}

CppSharp::Parser::AST::AccessSpecifierDecl^ CppSharp::Parser::AST::AccessSpecifierDecl::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::AccessSpecifierDecl((class ::CppSharp::CppParser::AST::AccessSpecifierDecl*) native.ToPointer());
}

CppSharp::Parser::AST::AccessSpecifierDecl::AccessSpecifierDecl(class ::CppSharp::CppParser::AST::AccessSpecifierDecl* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::AccessSpecifierDecl^ CppSharp::Parser::AST::AccessSpecifierDecl::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::AccessSpecifierDecl((class ::CppSharp::CppParser::AST::AccessSpecifierDecl*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::AccessSpecifierDecl::~AccessSpecifierDecl()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::AccessSpecifierDecl*) __nativePtr;
    }
}

CppSharp::Parser::AST::AccessSpecifierDecl::AccessSpecifierDecl()
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::AccessSpecifierDecl();
}

CppSharp::Parser::AST::AccessSpecifierDecl::AccessSpecifierDecl(CppSharp::Parser::AST::AccessSpecifierDecl^ _0)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::AccessSpecifierDecl*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::AccessSpecifierDecl(__arg0);
}

CppSharp::Parser::AST::DeclarationName::DeclarationName(class ::CppSharp::CppParser::AST::DeclarationName* native)
    : __ownsNativeInstance(false)
{
    NativePtr = native;
}

CppSharp::Parser::AST::DeclarationName^ CppSharp::Parser::AST::DeclarationName::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::DeclarationName((class ::CppSharp::CppParser::AST::DeclarationName*) native.ToPointer());
}

CppSharp::Parser::AST::DeclarationName::DeclarationName(class ::CppSharp::CppParser::AST::DeclarationName* native, bool ownNativeInstance)
    : __ownsNativeInstance(ownNativeInstance)
{
    NativePtr = native;
}

CppSharp::Parser::AST::DeclarationName^ CppSharp::Parser::AST::DeclarationName::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::DeclarationName((class ::CppSharp::CppParser::AST::DeclarationName*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::DeclarationName::~DeclarationName()
{
    delete NativePtr;
}

CppSharp::Parser::AST::DeclarationName::DeclarationName(CppSharp::Parser::AST::DeclarationName^ _0)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::DeclarationName*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::DeclarationName(__arg0);
}

CppSharp::Parser::AST::DeclarationName::DeclarationName()
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::DeclarationName();
}

::System::IntPtr CppSharp::Parser::AST::DeclarationName::__Instance::get()
{
    return ::System::IntPtr(NativePtr);
}

void CppSharp::Parser::AST::DeclarationName::__Instance::set(::System::IntPtr object)
{
    NativePtr = (class ::CppSharp::CppParser::AST::DeclarationName*)object.ToPointer();
}

CppSharp::Parser::AST::DeclarationNameKind CppSharp::Parser::AST::DeclarationName::Kind::get()
{
    return (CppSharp::Parser::AST::DeclarationNameKind)NativePtr->kind;
}

void CppSharp::Parser::AST::DeclarationName::Kind::set(CppSharp::Parser::AST::DeclarationNameKind value)
{
    ((class ::CppSharp::CppParser::AST::DeclarationName*)NativePtr)->kind = (enum ::CppSharp::CppParser::AST::DeclarationNameKind)value;
}

::System::String^ CppSharp::Parser::AST::DeclarationName::Identifier::get()
{
    return clix::marshalString<clix::E_UTF8>(NativePtr->identifier);
}

void CppSharp::Parser::AST::DeclarationName::Identifier::set(::System::String^ value)
{
    ((class ::CppSharp::CppParser::AST::DeclarationName*)NativePtr)->identifier = clix::marshalString<clix::E_UTF8>(value);
}

CppSharp::Parser::AST::Using::Using(class ::CppSharp::CppParser::AST::Using* native)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)native)
{
}

CppSharp::Parser::AST::Using^ CppSharp::Parser::AST::Using::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::Using((class ::CppSharp::CppParser::AST::Using*) native.ToPointer());
}

CppSharp::Parser::AST::Using::Using(class ::CppSharp::CppParser::AST::Using* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::Using^ CppSharp::Parser::AST::Using::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::Using((class ::CppSharp::CppParser::AST::Using*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::Using::~Using()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::Using*) __nativePtr;
    }
}

CppSharp::Parser::AST::Using::Using()
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::Using();
}

CppSharp::Parser::AST::Using::Using(CppSharp::Parser::AST::Using^ _0)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::Using*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::Using(__arg0);
}

CppSharp::Parser::AST::DeclarationName^ CppSharp::Parser::AST::Using::Name::get()
{
    return (&((class ::CppSharp::CppParser::AST::Using*)NativePtr)->name == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::DeclarationName((class ::CppSharp::CppParser::AST::DeclarationName*)&((class ::CppSharp::CppParser::AST::Using*)NativePtr)->name);
}

void CppSharp::Parser::AST::Using::Name::set(CppSharp::Parser::AST::DeclarationName^ value)
{
    if (ReferenceEquals(value, nullptr))
        throw gcnew ::System::ArgumentNullException("value", "Cannot be null because it is passed by value.");
    ((class ::CppSharp::CppParser::AST::Using*)NativePtr)->name = *(class ::CppSharp::CppParser::AST::DeclarationName*)value->NativePtr;
}

CppSharp::Parser::AST::VTableComponent::VTableComponent(struct ::CppSharp::CppParser::AST::VTableComponent* native)
    : __ownsNativeInstance(false)
{
    NativePtr = native;
}

CppSharp::Parser::AST::VTableComponent^ CppSharp::Parser::AST::VTableComponent::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::VTableComponent((struct ::CppSharp::CppParser::AST::VTableComponent*) native.ToPointer());
}

CppSharp::Parser::AST::VTableComponent::VTableComponent(struct ::CppSharp::CppParser::AST::VTableComponent* native, bool ownNativeInstance)
    : __ownsNativeInstance(ownNativeInstance)
{
    NativePtr = native;
}

CppSharp::Parser::AST::VTableComponent^ CppSharp::Parser::AST::VTableComponent::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::VTableComponent((struct ::CppSharp::CppParser::AST::VTableComponent*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::VTableComponent::~VTableComponent()
{
    delete NativePtr;
}

CppSharp::Parser::AST::VTableComponent::VTableComponent()
{
    __ownsNativeInstance = true;
    NativePtr = new struct ::CppSharp::CppParser::AST::VTableComponent();
}

CppSharp::Parser::AST::VTableComponent::VTableComponent(CppSharp::Parser::AST::VTableComponent^ _0)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(struct ::CppSharp::CppParser::AST::VTableComponent*)_0->NativePtr;
    NativePtr = new struct ::CppSharp::CppParser::AST::VTableComponent(__arg0);
}

::System::IntPtr CppSharp::Parser::AST::VTableComponent::__Instance::get()
{
    return ::System::IntPtr(NativePtr);
}

void CppSharp::Parser::AST::VTableComponent::__Instance::set(::System::IntPtr object)
{
    NativePtr = (struct ::CppSharp::CppParser::AST::VTableComponent*)object.ToPointer();
}

CppSharp::Parser::AST::VTableComponentKind CppSharp::Parser::AST::VTableComponent::Kind::get()
{
    return (CppSharp::Parser::AST::VTableComponentKind)NativePtr->kind;
}

void CppSharp::Parser::AST::VTableComponent::Kind::set(CppSharp::Parser::AST::VTableComponentKind value)
{
    ((struct ::CppSharp::CppParser::AST::VTableComponent*)NativePtr)->kind = (enum ::CppSharp::CppParser::AST::VTableComponentKind)value;
}

unsigned int CppSharp::Parser::AST::VTableComponent::Offset::get()
{
    return NativePtr->offset;
}

void CppSharp::Parser::AST::VTableComponent::Offset::set(unsigned int value)
{
    ((struct ::CppSharp::CppParser::AST::VTableComponent*)NativePtr)->offset = value;
}

CppSharp::Parser::AST::Declaration^ CppSharp::Parser::AST::VTableComponent::Declaration::get()
{
    return (NativePtr->declaration == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Declaration((class ::CppSharp::CppParser::AST::Declaration*)NativePtr->declaration);
}

void CppSharp::Parser::AST::VTableComponent::Declaration::set(CppSharp::Parser::AST::Declaration^ value)
{
    ((struct ::CppSharp::CppParser::AST::VTableComponent*)NativePtr)->declaration = (class ::CppSharp::CppParser::AST::Declaration*)value->NativePtr;
}

CppSharp::Parser::AST::VTableLayout::VTableLayout(struct ::CppSharp::CppParser::AST::VTableLayout* native)
    : __ownsNativeInstance(false)
{
    NativePtr = native;
}

CppSharp::Parser::AST::VTableLayout^ CppSharp::Parser::AST::VTableLayout::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::VTableLayout((struct ::CppSharp::CppParser::AST::VTableLayout*) native.ToPointer());
}

CppSharp::Parser::AST::VTableLayout::VTableLayout(struct ::CppSharp::CppParser::AST::VTableLayout* native, bool ownNativeInstance)
    : __ownsNativeInstance(ownNativeInstance)
{
    NativePtr = native;
}

CppSharp::Parser::AST::VTableLayout^ CppSharp::Parser::AST::VTableLayout::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::VTableLayout((struct ::CppSharp::CppParser::AST::VTableLayout*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::VTableLayout::~VTableLayout()
{
    delete NativePtr;
}

CppSharp::Parser::AST::VTableLayout::VTableLayout()
{
    __ownsNativeInstance = true;
    NativePtr = new struct ::CppSharp::CppParser::AST::VTableLayout();
}

CppSharp::Parser::AST::VTableLayout::VTableLayout(CppSharp::Parser::AST::VTableLayout^ _0)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(struct ::CppSharp::CppParser::AST::VTableLayout*)_0->NativePtr;
    NativePtr = new struct ::CppSharp::CppParser::AST::VTableLayout(__arg0);
}

CppSharp::Parser::AST::VTableComponent^ CppSharp::Parser::AST::VTableLayout::GetComponents(unsigned int i)
{
    auto ___ret = ((struct ::CppSharp::CppParser::AST::VTableLayout*)NativePtr)->getComponents(i);
    auto _____ret = new struct ::CppSharp::CppParser::AST::VTableComponent(___ret);
    return (_____ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::VTableComponent((struct ::CppSharp::CppParser::AST::VTableComponent*)_____ret, true);
}

void CppSharp::Parser::AST::VTableLayout::AddComponents(CppSharp::Parser::AST::VTableComponent^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(struct ::CppSharp::CppParser::AST::VTableComponent*)s->NativePtr;
    ((struct ::CppSharp::CppParser::AST::VTableLayout*)NativePtr)->addComponents(__arg0);
}

void CppSharp::Parser::AST::VTableLayout::ClearComponents()
{
    ((struct ::CppSharp::CppParser::AST::VTableLayout*)NativePtr)->clearComponents();
}

::System::IntPtr CppSharp::Parser::AST::VTableLayout::__Instance::get()
{
    return ::System::IntPtr(NativePtr);
}

void CppSharp::Parser::AST::VTableLayout::__Instance::set(::System::IntPtr object)
{
    NativePtr = (struct ::CppSharp::CppParser::AST::VTableLayout*)object.ToPointer();
}

::System::Collections::Generic::List<CppSharp::Parser::AST::VTableComponent^>^ CppSharp::Parser::AST::VTableLayout::Components::get()
{
    auto _tmp__Components = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::VTableComponent^>();
    auto __list0 = NativePtr->Components;
    for(auto _element : __list0)
    {
        auto ___element = new struct ::CppSharp::CppParser::AST::VTableComponent(_element);
        auto _marshalElement = (___element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::VTableComponent((struct ::CppSharp::CppParser::AST::VTableComponent*)___element, true);
        _tmp__Components->Add(_marshalElement);
    }
    return _tmp__Components;
}

void CppSharp::Parser::AST::VTableLayout::Components::set(::System::Collections::Generic::List<CppSharp::Parser::AST::VTableComponent^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::VTableComponent>();
    for each(CppSharp::Parser::AST::VTableComponent^ _element in value)
    {
        if (ReferenceEquals(_element, nullptr))
        throw gcnew ::System::ArgumentNullException("_element", "Cannot be null because it is passed by value.");
        auto _marshalElement = *(struct ::CppSharp::CppParser::AST::VTableComponent*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((struct ::CppSharp::CppParser::AST::VTableLayout*)NativePtr)->Components = _tmpvalue;
}

unsigned int CppSharp::Parser::AST::VTableLayout::ComponentsCount::get()
{
    auto ___ret = ((struct ::CppSharp::CppParser::AST::VTableLayout*)NativePtr)->getComponentsCount();
    return ___ret;
}

CppSharp::Parser::AST::VFTableInfo::VFTableInfo(struct ::CppSharp::CppParser::AST::VFTableInfo* native)
    : __ownsNativeInstance(false)
{
    NativePtr = native;
}

CppSharp::Parser::AST::VFTableInfo^ CppSharp::Parser::AST::VFTableInfo::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::VFTableInfo((struct ::CppSharp::CppParser::AST::VFTableInfo*) native.ToPointer());
}

CppSharp::Parser::AST::VFTableInfo::VFTableInfo(struct ::CppSharp::CppParser::AST::VFTableInfo* native, bool ownNativeInstance)
    : __ownsNativeInstance(ownNativeInstance)
{
    NativePtr = native;
}

CppSharp::Parser::AST::VFTableInfo^ CppSharp::Parser::AST::VFTableInfo::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::VFTableInfo((struct ::CppSharp::CppParser::AST::VFTableInfo*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::VFTableInfo::~VFTableInfo()
{
    delete NativePtr;
}

CppSharp::Parser::AST::VFTableInfo::VFTableInfo()
{
    __ownsNativeInstance = true;
    NativePtr = new struct ::CppSharp::CppParser::AST::VFTableInfo();
}

CppSharp::Parser::AST::VFTableInfo::VFTableInfo(CppSharp::Parser::AST::VFTableInfo^ _0)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(struct ::CppSharp::CppParser::AST::VFTableInfo*)_0->NativePtr;
    NativePtr = new struct ::CppSharp::CppParser::AST::VFTableInfo(__arg0);
}

::System::IntPtr CppSharp::Parser::AST::VFTableInfo::__Instance::get()
{
    return ::System::IntPtr(NativePtr);
}

void CppSharp::Parser::AST::VFTableInfo::__Instance::set(::System::IntPtr object)
{
    NativePtr = (struct ::CppSharp::CppParser::AST::VFTableInfo*)object.ToPointer();
}

unsigned long long CppSharp::Parser::AST::VFTableInfo::VBTableIndex::get()
{
    return NativePtr->VBTableIndex;
}

void CppSharp::Parser::AST::VFTableInfo::VBTableIndex::set(unsigned long long value)
{
    ((struct ::CppSharp::CppParser::AST::VFTableInfo*)NativePtr)->VBTableIndex = (::uint64_t)value;
}

unsigned int CppSharp::Parser::AST::VFTableInfo::VFPtrOffset::get()
{
    return NativePtr->VFPtrOffset;
}

void CppSharp::Parser::AST::VFTableInfo::VFPtrOffset::set(unsigned int value)
{
    ((struct ::CppSharp::CppParser::AST::VFTableInfo*)NativePtr)->VFPtrOffset = (::uint32_t)value;
}

unsigned int CppSharp::Parser::AST::VFTableInfo::VFPtrFullOffset::get()
{
    return NativePtr->VFPtrFullOffset;
}

void CppSharp::Parser::AST::VFTableInfo::VFPtrFullOffset::set(unsigned int value)
{
    ((struct ::CppSharp::CppParser::AST::VFTableInfo*)NativePtr)->VFPtrFullOffset = (::uint32_t)value;
}

CppSharp::Parser::AST::VTableLayout^ CppSharp::Parser::AST::VFTableInfo::Layout::get()
{
    return (&NativePtr->layout == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::VTableLayout((struct ::CppSharp::CppParser::AST::VTableLayout*)&NativePtr->layout);
}

void CppSharp::Parser::AST::VFTableInfo::Layout::set(CppSharp::Parser::AST::VTableLayout^ value)
{
    if (ReferenceEquals(value, nullptr))
        throw gcnew ::System::ArgumentNullException("value", "Cannot be null because it is passed by value.");
    ((struct ::CppSharp::CppParser::AST::VFTableInfo*)NativePtr)->layout = *(struct ::CppSharp::CppParser::AST::VTableLayout*)value->NativePtr;
}

CppSharp::Parser::AST::LayoutField::LayoutField(class ::CppSharp::CppParser::AST::LayoutField* native)
    : __ownsNativeInstance(false)
{
    NativePtr = native;
}

CppSharp::Parser::AST::LayoutField^ CppSharp::Parser::AST::LayoutField::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::LayoutField((class ::CppSharp::CppParser::AST::LayoutField*) native.ToPointer());
}

CppSharp::Parser::AST::LayoutField::LayoutField(class ::CppSharp::CppParser::AST::LayoutField* native, bool ownNativeInstance)
    : __ownsNativeInstance(ownNativeInstance)
{
    NativePtr = native;
}

CppSharp::Parser::AST::LayoutField^ CppSharp::Parser::AST::LayoutField::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::LayoutField((class ::CppSharp::CppParser::AST::LayoutField*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::LayoutField::~LayoutField()
{
    delete NativePtr;
}

CppSharp::Parser::AST::LayoutField::LayoutField()
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::LayoutField();
}

CppSharp::Parser::AST::LayoutField::LayoutField(CppSharp::Parser::AST::LayoutField^ other)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(other, nullptr))
        throw gcnew ::System::ArgumentNullException("other", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::LayoutField*)other->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::LayoutField(__arg0);
}

::System::IntPtr CppSharp::Parser::AST::LayoutField::__Instance::get()
{
    return ::System::IntPtr(NativePtr);
}

void CppSharp::Parser::AST::LayoutField::__Instance::set(::System::IntPtr object)
{
    NativePtr = (class ::CppSharp::CppParser::AST::LayoutField*)object.ToPointer();
}

unsigned int CppSharp::Parser::AST::LayoutField::Offset::get()
{
    return NativePtr->offset;
}

void CppSharp::Parser::AST::LayoutField::Offset::set(unsigned int value)
{
    ((class ::CppSharp::CppParser::AST::LayoutField*)NativePtr)->offset = value;
}

::System::String^ CppSharp::Parser::AST::LayoutField::Name::get()
{
    return clix::marshalString<clix::E_UTF8>(NativePtr->name);
}

void CppSharp::Parser::AST::LayoutField::Name::set(::System::String^ value)
{
    ((class ::CppSharp::CppParser::AST::LayoutField*)NativePtr)->name = clix::marshalString<clix::E_UTF8>(value);
}

CppSharp::Parser::AST::QualifiedType^ CppSharp::Parser::AST::LayoutField::QualifiedType::get()
{
    return (&NativePtr->qualifiedType == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::QualifiedType((struct ::CppSharp::CppParser::AST::QualifiedType*)&NativePtr->qualifiedType);
}

void CppSharp::Parser::AST::LayoutField::QualifiedType::set(CppSharp::Parser::AST::QualifiedType^ value)
{
    if (ReferenceEquals(value, nullptr))
        throw gcnew ::System::ArgumentNullException("value", "Cannot be null because it is passed by value.");
    ((class ::CppSharp::CppParser::AST::LayoutField*)NativePtr)->qualifiedType = *(struct ::CppSharp::CppParser::AST::QualifiedType*)value->NativePtr;
}

::System::IntPtr CppSharp::Parser::AST::LayoutField::FieldPtr::get()
{
    return ::System::IntPtr(NativePtr->fieldPtr);
}

void CppSharp::Parser::AST::LayoutField::FieldPtr::set(::System::IntPtr value)
{
    ((class ::CppSharp::CppParser::AST::LayoutField*)NativePtr)->fieldPtr = (void*)value;
}

CppSharp::Parser::AST::LayoutBase::LayoutBase(class ::CppSharp::CppParser::AST::LayoutBase* native)
    : __ownsNativeInstance(false)
{
    NativePtr = native;
}

CppSharp::Parser::AST::LayoutBase^ CppSharp::Parser::AST::LayoutBase::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::LayoutBase((class ::CppSharp::CppParser::AST::LayoutBase*) native.ToPointer());
}

CppSharp::Parser::AST::LayoutBase::LayoutBase(class ::CppSharp::CppParser::AST::LayoutBase* native, bool ownNativeInstance)
    : __ownsNativeInstance(ownNativeInstance)
{
    NativePtr = native;
}

CppSharp::Parser::AST::LayoutBase^ CppSharp::Parser::AST::LayoutBase::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::LayoutBase((class ::CppSharp::CppParser::AST::LayoutBase*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::LayoutBase::~LayoutBase()
{
    delete NativePtr;
}

CppSharp::Parser::AST::LayoutBase::LayoutBase()
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::LayoutBase();
}

CppSharp::Parser::AST::LayoutBase::LayoutBase(CppSharp::Parser::AST::LayoutBase^ other)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(other, nullptr))
        throw gcnew ::System::ArgumentNullException("other", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::LayoutBase*)other->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::LayoutBase(__arg0);
}

::System::IntPtr CppSharp::Parser::AST::LayoutBase::__Instance::get()
{
    return ::System::IntPtr(NativePtr);
}

void CppSharp::Parser::AST::LayoutBase::__Instance::set(::System::IntPtr object)
{
    NativePtr = (class ::CppSharp::CppParser::AST::LayoutBase*)object.ToPointer();
}

unsigned int CppSharp::Parser::AST::LayoutBase::Offset::get()
{
    return NativePtr->offset;
}

void CppSharp::Parser::AST::LayoutBase::Offset::set(unsigned int value)
{
    ((class ::CppSharp::CppParser::AST::LayoutBase*)NativePtr)->offset = value;
}

CppSharp::Parser::AST::Class^ CppSharp::Parser::AST::LayoutBase::Class::get()
{
    return (NativePtr->_class == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Class((class ::CppSharp::CppParser::AST::Class*)NativePtr->_class);
}

void CppSharp::Parser::AST::LayoutBase::Class::set(CppSharp::Parser::AST::Class^ value)
{
    ((class ::CppSharp::CppParser::AST::LayoutBase*)NativePtr)->_class = (class ::CppSharp::CppParser::AST::Class*)value->NativePtr;
}

CppSharp::Parser::AST::ClassLayout::ClassLayout(struct ::CppSharp::CppParser::AST::ClassLayout* native)
    : __ownsNativeInstance(false)
{
    NativePtr = native;
}

CppSharp::Parser::AST::ClassLayout^ CppSharp::Parser::AST::ClassLayout::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::ClassLayout((struct ::CppSharp::CppParser::AST::ClassLayout*) native.ToPointer());
}

CppSharp::Parser::AST::ClassLayout::ClassLayout(struct ::CppSharp::CppParser::AST::ClassLayout* native, bool ownNativeInstance)
    : __ownsNativeInstance(ownNativeInstance)
{
    NativePtr = native;
}

CppSharp::Parser::AST::ClassLayout^ CppSharp::Parser::AST::ClassLayout::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::ClassLayout((struct ::CppSharp::CppParser::AST::ClassLayout*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::ClassLayout::~ClassLayout()
{
    delete NativePtr;
}

CppSharp::Parser::AST::ClassLayout::ClassLayout()
{
    __ownsNativeInstance = true;
    NativePtr = new struct ::CppSharp::CppParser::AST::ClassLayout();
}

CppSharp::Parser::AST::VFTableInfo^ CppSharp::Parser::AST::ClassLayout::GetVFTables(unsigned int i)
{
    auto ___ret = ((struct ::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->getVFTables(i);
    auto _____ret = new struct ::CppSharp::CppParser::AST::VFTableInfo(___ret);
    return (_____ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::VFTableInfo((struct ::CppSharp::CppParser::AST::VFTableInfo*)_____ret, true);
}

void CppSharp::Parser::AST::ClassLayout::AddVFTables(CppSharp::Parser::AST::VFTableInfo^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(struct ::CppSharp::CppParser::AST::VFTableInfo*)s->NativePtr;
    ((struct ::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->addVFTables(__arg0);
}

void CppSharp::Parser::AST::ClassLayout::ClearVFTables()
{
    ((struct ::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->clearVFTables();
}

CppSharp::Parser::AST::LayoutField^ CppSharp::Parser::AST::ClassLayout::GetFields(unsigned int i)
{
    auto ___ret = ((struct ::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->getFields(i);
    auto _____ret = new class ::CppSharp::CppParser::AST::LayoutField(___ret);
    return (_____ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::LayoutField((class ::CppSharp::CppParser::AST::LayoutField*)_____ret, true);
}

void CppSharp::Parser::AST::ClassLayout::AddFields(CppSharp::Parser::AST::LayoutField^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::LayoutField*)s->NativePtr;
    ((struct ::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->addFields(__arg0);
}

void CppSharp::Parser::AST::ClassLayout::ClearFields()
{
    ((struct ::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->clearFields();
}

CppSharp::Parser::AST::LayoutBase^ CppSharp::Parser::AST::ClassLayout::GetBases(unsigned int i)
{
    auto ___ret = ((struct ::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->getBases(i);
    auto _____ret = new class ::CppSharp::CppParser::AST::LayoutBase(___ret);
    return (_____ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::LayoutBase((class ::CppSharp::CppParser::AST::LayoutBase*)_____ret, true);
}

void CppSharp::Parser::AST::ClassLayout::AddBases(CppSharp::Parser::AST::LayoutBase^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::LayoutBase*)s->NativePtr;
    ((struct ::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->addBases(__arg0);
}

void CppSharp::Parser::AST::ClassLayout::ClearBases()
{
    ((struct ::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->clearBases();
}

CppSharp::Parser::AST::ClassLayout::ClassLayout(CppSharp::Parser::AST::ClassLayout^ _0)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(struct ::CppSharp::CppParser::AST::ClassLayout*)_0->NativePtr;
    NativePtr = new struct ::CppSharp::CppParser::AST::ClassLayout(__arg0);
}

::System::IntPtr CppSharp::Parser::AST::ClassLayout::__Instance::get()
{
    return ::System::IntPtr(NativePtr);
}

void CppSharp::Parser::AST::ClassLayout::__Instance::set(::System::IntPtr object)
{
    NativePtr = (struct ::CppSharp::CppParser::AST::ClassLayout*)object.ToPointer();
}

CppSharp::Parser::AST::CppAbi CppSharp::Parser::AST::ClassLayout::ABI::get()
{
    return (CppSharp::Parser::AST::CppAbi)NativePtr->ABI;
}

void CppSharp::Parser::AST::ClassLayout::ABI::set(CppSharp::Parser::AST::CppAbi value)
{
    ((struct ::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->ABI = (enum ::CppSharp::CppParser::AST::CppAbi)value;
}

CppSharp::Parser::AST::RecordArgABI CppSharp::Parser::AST::ClassLayout::ArgABI::get()
{
    return (CppSharp::Parser::AST::RecordArgABI)NativePtr->argABI;
}

void CppSharp::Parser::AST::ClassLayout::ArgABI::set(CppSharp::Parser::AST::RecordArgABI value)
{
    ((struct ::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->argABI = (enum ::CppSharp::CppParser::AST::RecordArgABI)value;
}

::System::Collections::Generic::List<CppSharp::Parser::AST::VFTableInfo^>^ CppSharp::Parser::AST::ClassLayout::VFTables::get()
{
    auto _tmp__VFTables = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::VFTableInfo^>();
    auto __list0 = NativePtr->VFTables;
    for(auto _element : __list0)
    {
        auto ___element = new struct ::CppSharp::CppParser::AST::VFTableInfo(_element);
        auto _marshalElement = (___element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::VFTableInfo((struct ::CppSharp::CppParser::AST::VFTableInfo*)___element, true);
        _tmp__VFTables->Add(_marshalElement);
    }
    return _tmp__VFTables;
}

void CppSharp::Parser::AST::ClassLayout::VFTables::set(::System::Collections::Generic::List<CppSharp::Parser::AST::VFTableInfo^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::VFTableInfo>();
    for each(CppSharp::Parser::AST::VFTableInfo^ _element in value)
    {
        if (ReferenceEquals(_element, nullptr))
        throw gcnew ::System::ArgumentNullException("_element", "Cannot be null because it is passed by value.");
        auto _marshalElement = *(struct ::CppSharp::CppParser::AST::VFTableInfo*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((struct ::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->VFTables = _tmpvalue;
}

CppSharp::Parser::AST::VTableLayout^ CppSharp::Parser::AST::ClassLayout::Layout::get()
{
    return (&NativePtr->layout == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::VTableLayout((struct ::CppSharp::CppParser::AST::VTableLayout*)&NativePtr->layout);
}

void CppSharp::Parser::AST::ClassLayout::Layout::set(CppSharp::Parser::AST::VTableLayout^ value)
{
    if (ReferenceEquals(value, nullptr))
        throw gcnew ::System::ArgumentNullException("value", "Cannot be null because it is passed by value.");
    ((struct ::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->layout = *(struct ::CppSharp::CppParser::AST::VTableLayout*)value->NativePtr;
}

bool CppSharp::Parser::AST::ClassLayout::HasOwnVFPtr::get()
{
    return NativePtr->hasOwnVFPtr;
}

void CppSharp::Parser::AST::ClassLayout::HasOwnVFPtr::set(bool value)
{
    ((struct ::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->hasOwnVFPtr = value;
}

long CppSharp::Parser::AST::ClassLayout::VBPtrOffset::get()
{
    return NativePtr->VBPtrOffset;
}

void CppSharp::Parser::AST::ClassLayout::VBPtrOffset::set(long value)
{
    ((struct ::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->VBPtrOffset = value;
}

int CppSharp::Parser::AST::ClassLayout::Alignment::get()
{
    return NativePtr->alignment;
}

void CppSharp::Parser::AST::ClassLayout::Alignment::set(int value)
{
    ((struct ::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->alignment = value;
}

int CppSharp::Parser::AST::ClassLayout::Size::get()
{
    return NativePtr->size;
}

void CppSharp::Parser::AST::ClassLayout::Size::set(int value)
{
    ((struct ::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->size = value;
}

int CppSharp::Parser::AST::ClassLayout::DataSize::get()
{
    return NativePtr->dataSize;
}

void CppSharp::Parser::AST::ClassLayout::DataSize::set(int value)
{
    ((struct ::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->dataSize = value;
}

::System::Collections::Generic::List<CppSharp::Parser::AST::LayoutField^>^ CppSharp::Parser::AST::ClassLayout::Fields::get()
{
    auto _tmp__Fields = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::LayoutField^>();
    auto __list0 = NativePtr->Fields;
    for(auto _element : __list0)
    {
        auto ___element = new class ::CppSharp::CppParser::AST::LayoutField(_element);
        auto _marshalElement = (___element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::LayoutField((class ::CppSharp::CppParser::AST::LayoutField*)___element, true);
        _tmp__Fields->Add(_marshalElement);
    }
    return _tmp__Fields;
}

void CppSharp::Parser::AST::ClassLayout::Fields::set(::System::Collections::Generic::List<CppSharp::Parser::AST::LayoutField^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::LayoutField>();
    for each(CppSharp::Parser::AST::LayoutField^ _element in value)
    {
        if (ReferenceEquals(_element, nullptr))
        throw gcnew ::System::ArgumentNullException("_element", "Cannot be null because it is passed by value.");
        auto _marshalElement = *(class ::CppSharp::CppParser::AST::LayoutField*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((struct ::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->Fields = _tmpvalue;
}

::System::Collections::Generic::List<CppSharp::Parser::AST::LayoutBase^>^ CppSharp::Parser::AST::ClassLayout::Bases::get()
{
    auto _tmp__Bases = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::LayoutBase^>();
    auto __list0 = NativePtr->Bases;
    for(auto _element : __list0)
    {
        auto ___element = new class ::CppSharp::CppParser::AST::LayoutBase(_element);
        auto _marshalElement = (___element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::LayoutBase((class ::CppSharp::CppParser::AST::LayoutBase*)___element, true);
        _tmp__Bases->Add(_marshalElement);
    }
    return _tmp__Bases;
}

void CppSharp::Parser::AST::ClassLayout::Bases::set(::System::Collections::Generic::List<CppSharp::Parser::AST::LayoutBase^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::LayoutBase>();
    for each(CppSharp::Parser::AST::LayoutBase^ _element in value)
    {
        if (ReferenceEquals(_element, nullptr))
        throw gcnew ::System::ArgumentNullException("_element", "Cannot be null because it is passed by value.");
        auto _marshalElement = *(class ::CppSharp::CppParser::AST::LayoutBase*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((struct ::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->Bases = _tmpvalue;
}

unsigned int CppSharp::Parser::AST::ClassLayout::VFTablesCount::get()
{
    auto ___ret = ((struct ::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->getVFTablesCount();
    return ___ret;
}

unsigned int CppSharp::Parser::AST::ClassLayout::FieldsCount::get()
{
    auto ___ret = ((struct ::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->getFieldsCount();
    return ___ret;
}

unsigned int CppSharp::Parser::AST::ClassLayout::BasesCount::get()
{
    auto ___ret = ((struct ::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->getBasesCount();
    return ___ret;
}

CppSharp::Parser::AST::Class::Class(class ::CppSharp::CppParser::AST::Class* native)
    : CppSharp::Parser::AST::DeclarationContext((::CppSharp::CppParser::AST::DeclarationContext*)native)
{
}

CppSharp::Parser::AST::Class^ CppSharp::Parser::AST::Class::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::Class((class ::CppSharp::CppParser::AST::Class*) native.ToPointer());
}

CppSharp::Parser::AST::Class::Class(class ::CppSharp::CppParser::AST::Class* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::DeclarationContext((::CppSharp::CppParser::AST::DeclarationContext*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::Class^ CppSharp::Parser::AST::Class::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::Class((class ::CppSharp::CppParser::AST::Class*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::Class::~Class()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::Class*) __nativePtr;
    }
}

CppSharp::Parser::AST::Class::Class()
    : CppSharp::Parser::AST::DeclarationContext((::CppSharp::CppParser::AST::DeclarationContext*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::Class();
}

CppSharp::Parser::AST::BaseClassSpecifier^ CppSharp::Parser::AST::Class::GetBases(unsigned int i)
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->getBases(i);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::BaseClassSpecifier((struct ::CppSharp::CppParser::AST::BaseClassSpecifier*)___ret);
}

void CppSharp::Parser::AST::Class::AddBases(CppSharp::Parser::AST::BaseClassSpecifier^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto __arg0 = (struct ::CppSharp::CppParser::AST::BaseClassSpecifier*)s->NativePtr;
    ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->addBases(__arg0);
}

void CppSharp::Parser::AST::Class::ClearBases()
{
    ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->clearBases();
}

CppSharp::Parser::AST::Field^ CppSharp::Parser::AST::Class::GetFields(unsigned int i)
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->getFields(i);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Field((class ::CppSharp::CppParser::AST::Field*)___ret);
}

void CppSharp::Parser::AST::Class::AddFields(CppSharp::Parser::AST::Field^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto __arg0 = (class ::CppSharp::CppParser::AST::Field*)s->NativePtr;
    ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->addFields(__arg0);
}

void CppSharp::Parser::AST::Class::ClearFields()
{
    ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->clearFields();
}

CppSharp::Parser::AST::Method^ CppSharp::Parser::AST::Class::GetMethods(unsigned int i)
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->getMethods(i);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Method((class ::CppSharp::CppParser::AST::Method*)___ret);
}

void CppSharp::Parser::AST::Class::AddMethods(CppSharp::Parser::AST::Method^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto __arg0 = (class ::CppSharp::CppParser::AST::Method*)s->NativePtr;
    ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->addMethods(__arg0);
}

void CppSharp::Parser::AST::Class::ClearMethods()
{
    ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->clearMethods();
}

CppSharp::Parser::AST::AccessSpecifierDecl^ CppSharp::Parser::AST::Class::GetSpecifiers(unsigned int i)
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->getSpecifiers(i);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::AccessSpecifierDecl((class ::CppSharp::CppParser::AST::AccessSpecifierDecl*)___ret);
}

void CppSharp::Parser::AST::Class::AddSpecifiers(CppSharp::Parser::AST::AccessSpecifierDecl^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto __arg0 = (class ::CppSharp::CppParser::AST::AccessSpecifierDecl*)s->NativePtr;
    ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->addSpecifiers(__arg0);
}

void CppSharp::Parser::AST::Class::ClearSpecifiers()
{
    ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->clearSpecifiers();
}

CppSharp::Parser::AST::Using^ CppSharp::Parser::AST::Class::GetUsings(unsigned int i)
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->getUsings(i);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Using((class ::CppSharp::CppParser::AST::Using*)___ret);
}

void CppSharp::Parser::AST::Class::AddUsings(CppSharp::Parser::AST::Using^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto __arg0 = (class ::CppSharp::CppParser::AST::Using*)s->NativePtr;
    ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->addUsings(__arg0);
}

void CppSharp::Parser::AST::Class::ClearUsings()
{
    ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->clearUsings();
}

CppSharp::Parser::AST::Class::Class(CppSharp::Parser::AST::Class^ _0)
    : CppSharp::Parser::AST::DeclarationContext((::CppSharp::CppParser::AST::DeclarationContext*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::Class*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::Class(__arg0);
}

::System::Collections::Generic::List<CppSharp::Parser::AST::BaseClassSpecifier^>^ CppSharp::Parser::AST::Class::Bases::get()
{
    auto _tmp__Bases = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::BaseClassSpecifier^>();
    auto __list0 = ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->Bases;
    for(auto _element : __list0)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::BaseClassSpecifier((struct ::CppSharp::CppParser::AST::BaseClassSpecifier*)_element);
        _tmp__Bases->Add(_marshalElement);
    }
    return _tmp__Bases;
}

void CppSharp::Parser::AST::Class::Bases::set(::System::Collections::Generic::List<CppSharp::Parser::AST::BaseClassSpecifier^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::BaseClassSpecifier*>();
    for each(CppSharp::Parser::AST::BaseClassSpecifier^ _element in value)
    {
        auto _marshalElement = (struct ::CppSharp::CppParser::AST::BaseClassSpecifier*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->Bases = _tmpvalue;
}

::System::Collections::Generic::List<CppSharp::Parser::AST::Field^>^ CppSharp::Parser::AST::Class::Fields::get()
{
    auto _tmp__Fields = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::Field^>();
    auto __list0 = ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->Fields;
    for(auto _element : __list0)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Field((class ::CppSharp::CppParser::AST::Field*)_element);
        _tmp__Fields->Add(_marshalElement);
    }
    return _tmp__Fields;
}

void CppSharp::Parser::AST::Class::Fields::set(::System::Collections::Generic::List<CppSharp::Parser::AST::Field^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::Field*>();
    for each(CppSharp::Parser::AST::Field^ _element in value)
    {
        auto _marshalElement = (class ::CppSharp::CppParser::AST::Field*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->Fields = _tmpvalue;
}

::System::Collections::Generic::List<CppSharp::Parser::AST::Method^>^ CppSharp::Parser::AST::Class::Methods::get()
{
    auto _tmp__Methods = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::Method^>();
    auto __list0 = ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->Methods;
    for(auto _element : __list0)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Method((class ::CppSharp::CppParser::AST::Method*)_element);
        _tmp__Methods->Add(_marshalElement);
    }
    return _tmp__Methods;
}

void CppSharp::Parser::AST::Class::Methods::set(::System::Collections::Generic::List<CppSharp::Parser::AST::Method^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::Method*>();
    for each(CppSharp::Parser::AST::Method^ _element in value)
    {
        auto _marshalElement = (class ::CppSharp::CppParser::AST::Method*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->Methods = _tmpvalue;
}

::System::Collections::Generic::List<CppSharp::Parser::AST::AccessSpecifierDecl^>^ CppSharp::Parser::AST::Class::Specifiers::get()
{
    auto _tmp__Specifiers = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::AccessSpecifierDecl^>();
    auto __list0 = ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->Specifiers;
    for(auto _element : __list0)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::AccessSpecifierDecl((class ::CppSharp::CppParser::AST::AccessSpecifierDecl*)_element);
        _tmp__Specifiers->Add(_marshalElement);
    }
    return _tmp__Specifiers;
}

void CppSharp::Parser::AST::Class::Specifiers::set(::System::Collections::Generic::List<CppSharp::Parser::AST::AccessSpecifierDecl^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::AccessSpecifierDecl*>();
    for each(CppSharp::Parser::AST::AccessSpecifierDecl^ _element in value)
    {
        auto _marshalElement = (class ::CppSharp::CppParser::AST::AccessSpecifierDecl*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->Specifiers = _tmpvalue;
}

::System::Collections::Generic::List<CppSharp::Parser::AST::Using^>^ CppSharp::Parser::AST::Class::Usings::get()
{
    auto _tmp__Usings = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::Using^>();
    auto __list0 = ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->Usings;
    for(auto _element : __list0)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Using((class ::CppSharp::CppParser::AST::Using*)_element);
        _tmp__Usings->Add(_marshalElement);
    }
    return _tmp__Usings;
}

void CppSharp::Parser::AST::Class::Usings::set(::System::Collections::Generic::List<CppSharp::Parser::AST::Using^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::Using*>();
    for each(CppSharp::Parser::AST::Using^ _element in value)
    {
        auto _marshalElement = (class ::CppSharp::CppParser::AST::Using*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->Usings = _tmpvalue;
}

bool CppSharp::Parser::AST::Class::IsPOD::get()
{
    return ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->isPOD;
}

void CppSharp::Parser::AST::Class::IsPOD::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->isPOD = value;
}

bool CppSharp::Parser::AST::Class::IsAbstract::get()
{
    return ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->isAbstract;
}

void CppSharp::Parser::AST::Class::IsAbstract::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->isAbstract = value;
}

bool CppSharp::Parser::AST::Class::IsUnion::get()
{
    return ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->isUnion;
}

void CppSharp::Parser::AST::Class::IsUnion::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->isUnion = value;
}

bool CppSharp::Parser::AST::Class::IsDynamic::get()
{
    return ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->isDynamic;
}

void CppSharp::Parser::AST::Class::IsDynamic::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->isDynamic = value;
}

bool CppSharp::Parser::AST::Class::IsPolymorphic::get()
{
    return ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->isPolymorphic;
}

void CppSharp::Parser::AST::Class::IsPolymorphic::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->isPolymorphic = value;
}

bool CppSharp::Parser::AST::Class::HasNonTrivialDefaultConstructor::get()
{
    return ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->hasNonTrivialDefaultConstructor;
}

void CppSharp::Parser::AST::Class::HasNonTrivialDefaultConstructor::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->hasNonTrivialDefaultConstructor = value;
}

bool CppSharp::Parser::AST::Class::HasNonTrivialCopyConstructor::get()
{
    return ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->hasNonTrivialCopyConstructor;
}

void CppSharp::Parser::AST::Class::HasNonTrivialCopyConstructor::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->hasNonTrivialCopyConstructor = value;
}

bool CppSharp::Parser::AST::Class::HasNonTrivialDestructor::get()
{
    return ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->hasNonTrivialDestructor;
}

void CppSharp::Parser::AST::Class::HasNonTrivialDestructor::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->hasNonTrivialDestructor = value;
}

bool CppSharp::Parser::AST::Class::IsExternCContext::get()
{
    return ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->isExternCContext;
}

void CppSharp::Parser::AST::Class::IsExternCContext::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->isExternCContext = value;
}

bool CppSharp::Parser::AST::Class::IsInjected::get()
{
    return ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->isInjected;
}

void CppSharp::Parser::AST::Class::IsInjected::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->isInjected = value;
}

CppSharp::Parser::AST::TagKind CppSharp::Parser::AST::Class::TagKind::get()
{
    return (CppSharp::Parser::AST::TagKind)((class ::CppSharp::CppParser::AST::Class*)NativePtr)->tagKind;
}

void CppSharp::Parser::AST::Class::TagKind::set(CppSharp::Parser::AST::TagKind value)
{
    ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->tagKind = (enum ::CppSharp::CppParser::AST::TagKind)value;
}

CppSharp::Parser::AST::ClassLayout^ CppSharp::Parser::AST::Class::Layout::get()
{
    return (((class ::CppSharp::CppParser::AST::Class*)NativePtr)->layout == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::ClassLayout((struct ::CppSharp::CppParser::AST::ClassLayout*)((class ::CppSharp::CppParser::AST::Class*)NativePtr)->layout);
}

void CppSharp::Parser::AST::Class::Layout::set(CppSharp::Parser::AST::ClassLayout^ value)
{
    ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->layout = (struct ::CppSharp::CppParser::AST::ClassLayout*)value->NativePtr;
}

unsigned int CppSharp::Parser::AST::Class::BasesCount::get()
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->getBasesCount();
    return ___ret;
}

unsigned int CppSharp::Parser::AST::Class::FieldsCount::get()
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->getFieldsCount();
    return ___ret;
}

unsigned int CppSharp::Parser::AST::Class::MethodsCount::get()
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->getMethodsCount();
    return ___ret;
}

unsigned int CppSharp::Parser::AST::Class::SpecifiersCount::get()
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->getSpecifiersCount();
    return ___ret;
}

unsigned int CppSharp::Parser::AST::Class::UsingsCount::get()
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::Class*)NativePtr)->getUsingsCount();
    return ___ret;
}

CppSharp::Parser::AST::Template::Template(class ::CppSharp::CppParser::AST::Template* native)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)native)
{
}

CppSharp::Parser::AST::Template^ CppSharp::Parser::AST::Template::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::Template((class ::CppSharp::CppParser::AST::Template*) native.ToPointer());
}

CppSharp::Parser::AST::Template::Template(class ::CppSharp::CppParser::AST::Template* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::Template^ CppSharp::Parser::AST::Template::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::Template((class ::CppSharp::CppParser::AST::Template*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::Template::~Template()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::Template*) __nativePtr;
    }
}

CppSharp::Parser::AST::Template::Template(CppSharp::Parser::AST::DeclarationKind kind)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)nullptr)
{
    __ownsNativeInstance = true;
    auto __arg0 = (enum ::CppSharp::CppParser::AST::DeclarationKind)kind;
    NativePtr = new class ::CppSharp::CppParser::AST::Template(__arg0);
}

CppSharp::Parser::AST::Template::Template()
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::Template();
}

CppSharp::Parser::AST::Declaration^ CppSharp::Parser::AST::Template::GetParameters(unsigned int i)
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::Template*)NativePtr)->getParameters(i);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Declaration((class ::CppSharp::CppParser::AST::Declaration*)___ret);
}

void CppSharp::Parser::AST::Template::AddParameters(CppSharp::Parser::AST::Declaration^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto __arg0 = (class ::CppSharp::CppParser::AST::Declaration*)s->NativePtr;
    ((class ::CppSharp::CppParser::AST::Template*)NativePtr)->addParameters(__arg0);
}

void CppSharp::Parser::AST::Template::ClearParameters()
{
    ((class ::CppSharp::CppParser::AST::Template*)NativePtr)->clearParameters();
}

CppSharp::Parser::AST::Template::Template(CppSharp::Parser::AST::Template^ _0)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::Template*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::Template(__arg0);
}

CppSharp::Parser::AST::Template::operator CppSharp::Parser::AST::Template^(CppSharp::Parser::AST::DeclarationKind kind)
{
    auto __arg0 = (enum ::CppSharp::CppParser::AST::DeclarationKind)kind;
    auto ___ret = (::CppSharp::CppParser::AST::Template) __arg0;
    auto _____ret = new class ::CppSharp::CppParser::AST::Template(___ret);
    return (_____ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Template((class ::CppSharp::CppParser::AST::Template*)_____ret, true);
}

CppSharp::Parser::AST::Declaration^ CppSharp::Parser::AST::Template::TemplatedDecl::get()
{
    return (((class ::CppSharp::CppParser::AST::Template*)NativePtr)->TemplatedDecl == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Declaration((class ::CppSharp::CppParser::AST::Declaration*)((class ::CppSharp::CppParser::AST::Template*)NativePtr)->TemplatedDecl);
}

void CppSharp::Parser::AST::Template::TemplatedDecl::set(CppSharp::Parser::AST::Declaration^ value)
{
    ((class ::CppSharp::CppParser::AST::Template*)NativePtr)->TemplatedDecl = (class ::CppSharp::CppParser::AST::Declaration*)value->NativePtr;
}

::System::Collections::Generic::List<CppSharp::Parser::AST::Declaration^>^ CppSharp::Parser::AST::Template::Parameters::get()
{
    auto _tmp__Parameters = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::Declaration^>();
    auto __list0 = ((class ::CppSharp::CppParser::AST::Template*)NativePtr)->Parameters;
    for(auto _element : __list0)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Declaration((class ::CppSharp::CppParser::AST::Declaration*)_element);
        _tmp__Parameters->Add(_marshalElement);
    }
    return _tmp__Parameters;
}

void CppSharp::Parser::AST::Template::Parameters::set(::System::Collections::Generic::List<CppSharp::Parser::AST::Declaration^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::Declaration*>();
    for each(CppSharp::Parser::AST::Declaration^ _element in value)
    {
        auto _marshalElement = (class ::CppSharp::CppParser::AST::Declaration*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((class ::CppSharp::CppParser::AST::Template*)NativePtr)->Parameters = _tmpvalue;
}

unsigned int CppSharp::Parser::AST::Template::ParametersCount::get()
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::Template*)NativePtr)->getParametersCount();
    return ___ret;
}

CppSharp::Parser::AST::TypeAliasTemplate::TypeAliasTemplate(class ::CppSharp::CppParser::AST::TypeAliasTemplate* native)
    : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)native)
{
}

CppSharp::Parser::AST::TypeAliasTemplate^ CppSharp::Parser::AST::TypeAliasTemplate::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::TypeAliasTemplate((class ::CppSharp::CppParser::AST::TypeAliasTemplate*) native.ToPointer());
}

CppSharp::Parser::AST::TypeAliasTemplate::TypeAliasTemplate(class ::CppSharp::CppParser::AST::TypeAliasTemplate* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::TypeAliasTemplate^ CppSharp::Parser::AST::TypeAliasTemplate::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::TypeAliasTemplate((class ::CppSharp::CppParser::AST::TypeAliasTemplate*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::TypeAliasTemplate::~TypeAliasTemplate()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::TypeAliasTemplate*) __nativePtr;
    }
}

CppSharp::Parser::AST::TypeAliasTemplate::TypeAliasTemplate()
    : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::TypeAliasTemplate();
}

CppSharp::Parser::AST::TypeAliasTemplate::TypeAliasTemplate(CppSharp::Parser::AST::TypeAliasTemplate^ _0)
    : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::TypeAliasTemplate*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::TypeAliasTemplate(__arg0);
}

CppSharp::Parser::AST::TemplateParameter::TemplateParameter(class ::CppSharp::CppParser::AST::TemplateParameter* native)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)native)
{
}

CppSharp::Parser::AST::TemplateParameter^ CppSharp::Parser::AST::TemplateParameter::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::TemplateParameter((class ::CppSharp::CppParser::AST::TemplateParameter*) native.ToPointer());
}

CppSharp::Parser::AST::TemplateParameter::TemplateParameter(class ::CppSharp::CppParser::AST::TemplateParameter* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::TemplateParameter^ CppSharp::Parser::AST::TemplateParameter::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::TemplateParameter((class ::CppSharp::CppParser::AST::TemplateParameter*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::TemplateParameter::~TemplateParameter()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::TemplateParameter*) __nativePtr;
    }
}

CppSharp::Parser::AST::TemplateParameter::TemplateParameter(CppSharp::Parser::AST::DeclarationKind kind)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)nullptr)
{
    __ownsNativeInstance = true;
    auto __arg0 = (enum ::CppSharp::CppParser::AST::DeclarationKind)kind;
    NativePtr = new class ::CppSharp::CppParser::AST::TemplateParameter(__arg0);
}

CppSharp::Parser::AST::TemplateParameter::TemplateParameter(CppSharp::Parser::AST::TemplateParameter^ _0)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::TemplateParameter*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::TemplateParameter(__arg0);
}

CppSharp::Parser::AST::TemplateParameter::operator CppSharp::Parser::AST::TemplateParameter^(CppSharp::Parser::AST::DeclarationKind kind)
{
    auto __arg0 = (enum ::CppSharp::CppParser::AST::DeclarationKind)kind;
    auto ___ret = (::CppSharp::CppParser::AST::TemplateParameter) __arg0;
    auto _____ret = new class ::CppSharp::CppParser::AST::TemplateParameter(___ret);
    return (_____ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::TemplateParameter((class ::CppSharp::CppParser::AST::TemplateParameter*)_____ret, true);
}

unsigned int CppSharp::Parser::AST::TemplateParameter::Depth::get()
{
    return ((class ::CppSharp::CppParser::AST::TemplateParameter*)NativePtr)->depth;
}

void CppSharp::Parser::AST::TemplateParameter::Depth::set(unsigned int value)
{
    ((class ::CppSharp::CppParser::AST::TemplateParameter*)NativePtr)->depth = value;
}

unsigned int CppSharp::Parser::AST::TemplateParameter::Index::get()
{
    return ((class ::CppSharp::CppParser::AST::TemplateParameter*)NativePtr)->index;
}

void CppSharp::Parser::AST::TemplateParameter::Index::set(unsigned int value)
{
    ((class ::CppSharp::CppParser::AST::TemplateParameter*)NativePtr)->index = value;
}

bool CppSharp::Parser::AST::TemplateParameter::IsParameterPack::get()
{
    return ((class ::CppSharp::CppParser::AST::TemplateParameter*)NativePtr)->isParameterPack;
}

void CppSharp::Parser::AST::TemplateParameter::IsParameterPack::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::TemplateParameter*)NativePtr)->isParameterPack = value;
}

CppSharp::Parser::AST::TemplateTemplateParameter::TemplateTemplateParameter(class ::CppSharp::CppParser::AST::TemplateTemplateParameter* native)
    : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)native)
{
}

CppSharp::Parser::AST::TemplateTemplateParameter^ CppSharp::Parser::AST::TemplateTemplateParameter::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::TemplateTemplateParameter((class ::CppSharp::CppParser::AST::TemplateTemplateParameter*) native.ToPointer());
}

CppSharp::Parser::AST::TemplateTemplateParameter::TemplateTemplateParameter(class ::CppSharp::CppParser::AST::TemplateTemplateParameter* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::TemplateTemplateParameter^ CppSharp::Parser::AST::TemplateTemplateParameter::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::TemplateTemplateParameter((class ::CppSharp::CppParser::AST::TemplateTemplateParameter*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::TemplateTemplateParameter::~TemplateTemplateParameter()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::TemplateTemplateParameter*) __nativePtr;
    }
}

CppSharp::Parser::AST::TemplateTemplateParameter::TemplateTemplateParameter()
    : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::TemplateTemplateParameter();
}

CppSharp::Parser::AST::TemplateTemplateParameter::TemplateTemplateParameter(CppSharp::Parser::AST::TemplateTemplateParameter^ _0)
    : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::TemplateTemplateParameter*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::TemplateTemplateParameter(__arg0);
}

bool CppSharp::Parser::AST::TemplateTemplateParameter::IsParameterPack::get()
{
    return ((class ::CppSharp::CppParser::AST::TemplateTemplateParameter*)NativePtr)->isParameterPack;
}

void CppSharp::Parser::AST::TemplateTemplateParameter::IsParameterPack::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::TemplateTemplateParameter*)NativePtr)->isParameterPack = value;
}

bool CppSharp::Parser::AST::TemplateTemplateParameter::IsPackExpansion::get()
{
    return ((class ::CppSharp::CppParser::AST::TemplateTemplateParameter*)NativePtr)->isPackExpansion;
}

void CppSharp::Parser::AST::TemplateTemplateParameter::IsPackExpansion::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::TemplateTemplateParameter*)NativePtr)->isPackExpansion = value;
}

bool CppSharp::Parser::AST::TemplateTemplateParameter::IsExpandedParameterPack::get()
{
    return ((class ::CppSharp::CppParser::AST::TemplateTemplateParameter*)NativePtr)->isExpandedParameterPack;
}

void CppSharp::Parser::AST::TemplateTemplateParameter::IsExpandedParameterPack::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::TemplateTemplateParameter*)NativePtr)->isExpandedParameterPack = value;
}

CppSharp::Parser::AST::TypeTemplateParameter::TypeTemplateParameter(class ::CppSharp::CppParser::AST::TypeTemplateParameter* native)
    : CppSharp::Parser::AST::TemplateParameter((::CppSharp::CppParser::AST::TemplateParameter*)native)
{
}

CppSharp::Parser::AST::TypeTemplateParameter^ CppSharp::Parser::AST::TypeTemplateParameter::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::TypeTemplateParameter((class ::CppSharp::CppParser::AST::TypeTemplateParameter*) native.ToPointer());
}

CppSharp::Parser::AST::TypeTemplateParameter::TypeTemplateParameter(class ::CppSharp::CppParser::AST::TypeTemplateParameter* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::TemplateParameter((::CppSharp::CppParser::AST::TemplateParameter*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::TypeTemplateParameter^ CppSharp::Parser::AST::TypeTemplateParameter::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::TypeTemplateParameter((class ::CppSharp::CppParser::AST::TypeTemplateParameter*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::TypeTemplateParameter::~TypeTemplateParameter()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::TypeTemplateParameter*) __nativePtr;
    }
}

CppSharp::Parser::AST::TypeTemplateParameter::TypeTemplateParameter()
    : CppSharp::Parser::AST::TemplateParameter((::CppSharp::CppParser::AST::TemplateParameter*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::TypeTemplateParameter();
}

CppSharp::Parser::AST::TypeTemplateParameter::TypeTemplateParameter(CppSharp::Parser::AST::TypeTemplateParameter^ _0)
    : CppSharp::Parser::AST::TemplateParameter((::CppSharp::CppParser::AST::TemplateParameter*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::TypeTemplateParameter*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::TypeTemplateParameter(__arg0);
}

CppSharp::Parser::AST::QualifiedType^ CppSharp::Parser::AST::TypeTemplateParameter::DefaultArgument::get()
{
    return (&((class ::CppSharp::CppParser::AST::TypeTemplateParameter*)NativePtr)->defaultArgument == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::QualifiedType((struct ::CppSharp::CppParser::AST::QualifiedType*)&((class ::CppSharp::CppParser::AST::TypeTemplateParameter*)NativePtr)->defaultArgument);
}

void CppSharp::Parser::AST::TypeTemplateParameter::DefaultArgument::set(CppSharp::Parser::AST::QualifiedType^ value)
{
    if (ReferenceEquals(value, nullptr))
        throw gcnew ::System::ArgumentNullException("value", "Cannot be null because it is passed by value.");
    ((class ::CppSharp::CppParser::AST::TypeTemplateParameter*)NativePtr)->defaultArgument = *(struct ::CppSharp::CppParser::AST::QualifiedType*)value->NativePtr;
}

CppSharp::Parser::AST::NonTypeTemplateParameter::NonTypeTemplateParameter(class ::CppSharp::CppParser::AST::NonTypeTemplateParameter* native)
    : CppSharp::Parser::AST::TemplateParameter((::CppSharp::CppParser::AST::TemplateParameter*)native)
{
}

CppSharp::Parser::AST::NonTypeTemplateParameter^ CppSharp::Parser::AST::NonTypeTemplateParameter::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::NonTypeTemplateParameter((class ::CppSharp::CppParser::AST::NonTypeTemplateParameter*) native.ToPointer());
}

CppSharp::Parser::AST::NonTypeTemplateParameter::NonTypeTemplateParameter(class ::CppSharp::CppParser::AST::NonTypeTemplateParameter* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::TemplateParameter((::CppSharp::CppParser::AST::TemplateParameter*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::NonTypeTemplateParameter^ CppSharp::Parser::AST::NonTypeTemplateParameter::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::NonTypeTemplateParameter((class ::CppSharp::CppParser::AST::NonTypeTemplateParameter*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::NonTypeTemplateParameter::~NonTypeTemplateParameter()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::NonTypeTemplateParameter*) __nativePtr;
    }
}

CppSharp::Parser::AST::NonTypeTemplateParameter::NonTypeTemplateParameter()
    : CppSharp::Parser::AST::TemplateParameter((::CppSharp::CppParser::AST::TemplateParameter*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::NonTypeTemplateParameter();
}

CppSharp::Parser::AST::NonTypeTemplateParameter::NonTypeTemplateParameter(CppSharp::Parser::AST::NonTypeTemplateParameter^ _0)
    : CppSharp::Parser::AST::TemplateParameter((::CppSharp::CppParser::AST::TemplateParameter*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::NonTypeTemplateParameter*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::NonTypeTemplateParameter(__arg0);
}

CppSharp::Parser::AST::ExpressionObsolete^ CppSharp::Parser::AST::NonTypeTemplateParameter::DefaultArgument::get()
{
    return (((class ::CppSharp::CppParser::AST::NonTypeTemplateParameter*)NativePtr)->defaultArgument == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::ExpressionObsolete((class ::CppSharp::CppParser::AST::ExpressionObsolete*)((class ::CppSharp::CppParser::AST::NonTypeTemplateParameter*)NativePtr)->defaultArgument);
}

void CppSharp::Parser::AST::NonTypeTemplateParameter::DefaultArgument::set(CppSharp::Parser::AST::ExpressionObsolete^ value)
{
    ((class ::CppSharp::CppParser::AST::NonTypeTemplateParameter*)NativePtr)->defaultArgument = (class ::CppSharp::CppParser::AST::ExpressionObsolete*)value->NativePtr;
}

CppSharp::Parser::AST::Expr^ CppSharp::Parser::AST::NonTypeTemplateParameter::DefaultArgumentNew::get()
{
    return (((class ::CppSharp::CppParser::AST::NonTypeTemplateParameter*)NativePtr)->defaultArgumentNew == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Expr((class ::CppSharp::CppParser::AST::Expr*)((class ::CppSharp::CppParser::AST::NonTypeTemplateParameter*)NativePtr)->defaultArgumentNew);
}

void CppSharp::Parser::AST::NonTypeTemplateParameter::DefaultArgumentNew::set(CppSharp::Parser::AST::Expr^ value)
{
    ((class ::CppSharp::CppParser::AST::NonTypeTemplateParameter*)NativePtr)->defaultArgumentNew = (class ::CppSharp::CppParser::AST::Expr*)value->NativePtr;
}

unsigned int CppSharp::Parser::AST::NonTypeTemplateParameter::Position::get()
{
    return ((class ::CppSharp::CppParser::AST::NonTypeTemplateParameter*)NativePtr)->position;
}

void CppSharp::Parser::AST::NonTypeTemplateParameter::Position::set(unsigned int value)
{
    ((class ::CppSharp::CppParser::AST::NonTypeTemplateParameter*)NativePtr)->position = value;
}

bool CppSharp::Parser::AST::NonTypeTemplateParameter::IsPackExpansion::get()
{
    return ((class ::CppSharp::CppParser::AST::NonTypeTemplateParameter*)NativePtr)->isPackExpansion;
}

void CppSharp::Parser::AST::NonTypeTemplateParameter::IsPackExpansion::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::NonTypeTemplateParameter*)NativePtr)->isPackExpansion = value;
}

bool CppSharp::Parser::AST::NonTypeTemplateParameter::IsExpandedParameterPack::get()
{
    return ((class ::CppSharp::CppParser::AST::NonTypeTemplateParameter*)NativePtr)->isExpandedParameterPack;
}

void CppSharp::Parser::AST::NonTypeTemplateParameter::IsExpandedParameterPack::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::NonTypeTemplateParameter*)NativePtr)->isExpandedParameterPack = value;
}

CppSharp::Parser::AST::QualifiedType^ CppSharp::Parser::AST::NonTypeTemplateParameter::Type::get()
{
    return (&((class ::CppSharp::CppParser::AST::NonTypeTemplateParameter*)NativePtr)->type == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::QualifiedType((struct ::CppSharp::CppParser::AST::QualifiedType*)&((class ::CppSharp::CppParser::AST::NonTypeTemplateParameter*)NativePtr)->type);
}

void CppSharp::Parser::AST::NonTypeTemplateParameter::Type::set(CppSharp::Parser::AST::QualifiedType^ value)
{
    if (ReferenceEquals(value, nullptr))
        throw gcnew ::System::ArgumentNullException("value", "Cannot be null because it is passed by value.");
    ((class ::CppSharp::CppParser::AST::NonTypeTemplateParameter*)NativePtr)->type = *(struct ::CppSharp::CppParser::AST::QualifiedType*)value->NativePtr;
}

CppSharp::Parser::AST::ClassTemplate::ClassTemplate(class ::CppSharp::CppParser::AST::ClassTemplate* native)
    : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)native)
{
}

CppSharp::Parser::AST::ClassTemplate^ CppSharp::Parser::AST::ClassTemplate::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::ClassTemplate((class ::CppSharp::CppParser::AST::ClassTemplate*) native.ToPointer());
}

CppSharp::Parser::AST::ClassTemplate::ClassTemplate(class ::CppSharp::CppParser::AST::ClassTemplate* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::ClassTemplate^ CppSharp::Parser::AST::ClassTemplate::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::ClassTemplate((class ::CppSharp::CppParser::AST::ClassTemplate*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::ClassTemplate::~ClassTemplate()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::ClassTemplate*) __nativePtr;
    }
}

CppSharp::Parser::AST::ClassTemplate::ClassTemplate()
    : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::ClassTemplate();
}

CppSharp::Parser::AST::ClassTemplateSpecialization^ CppSharp::Parser::AST::ClassTemplate::GetSpecializations(unsigned int i)
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::ClassTemplate*)NativePtr)->getSpecializations(i);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::ClassTemplateSpecialization((class ::CppSharp::CppParser::AST::ClassTemplateSpecialization*)___ret);
}

void CppSharp::Parser::AST::ClassTemplate::AddSpecializations(CppSharp::Parser::AST::ClassTemplateSpecialization^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto __arg0 = (class ::CppSharp::CppParser::AST::ClassTemplateSpecialization*)s->NativePtr;
    ((class ::CppSharp::CppParser::AST::ClassTemplate*)NativePtr)->addSpecializations(__arg0);
}

void CppSharp::Parser::AST::ClassTemplate::ClearSpecializations()
{
    ((class ::CppSharp::CppParser::AST::ClassTemplate*)NativePtr)->clearSpecializations();
}

CppSharp::Parser::AST::ClassTemplateSpecialization^ CppSharp::Parser::AST::ClassTemplate::FindSpecialization(::System::String^ usr)
{
    auto __arg0 = clix::marshalString<clix::E_UTF8>(usr);
    auto ___ret = ((class ::CppSharp::CppParser::AST::ClassTemplate*)NativePtr)->FindSpecialization(__arg0);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::ClassTemplateSpecialization((class ::CppSharp::CppParser::AST::ClassTemplateSpecialization*)___ret);
}

CppSharp::Parser::AST::ClassTemplatePartialSpecialization^ CppSharp::Parser::AST::ClassTemplate::FindPartialSpecialization(::System::String^ usr)
{
    auto __arg0 = clix::marshalString<clix::E_UTF8>(usr);
    auto ___ret = ((class ::CppSharp::CppParser::AST::ClassTemplate*)NativePtr)->FindPartialSpecialization(__arg0);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::ClassTemplatePartialSpecialization((class ::CppSharp::CppParser::AST::ClassTemplatePartialSpecialization*)___ret);
}

CppSharp::Parser::AST::ClassTemplate::ClassTemplate(CppSharp::Parser::AST::ClassTemplate^ _0)
    : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::ClassTemplate*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::ClassTemplate(__arg0);
}

::System::Collections::Generic::List<CppSharp::Parser::AST::ClassTemplateSpecialization^>^ CppSharp::Parser::AST::ClassTemplate::Specializations::get()
{
    auto _tmp__Specializations = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::ClassTemplateSpecialization^>();
    auto __list0 = ((class ::CppSharp::CppParser::AST::ClassTemplate*)NativePtr)->Specializations;
    for(auto _element : __list0)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::ClassTemplateSpecialization((class ::CppSharp::CppParser::AST::ClassTemplateSpecialization*)_element);
        _tmp__Specializations->Add(_marshalElement);
    }
    return _tmp__Specializations;
}

void CppSharp::Parser::AST::ClassTemplate::Specializations::set(::System::Collections::Generic::List<CppSharp::Parser::AST::ClassTemplateSpecialization^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::ClassTemplateSpecialization*>();
    for each(CppSharp::Parser::AST::ClassTemplateSpecialization^ _element in value)
    {
        auto _marshalElement = (class ::CppSharp::CppParser::AST::ClassTemplateSpecialization*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((class ::CppSharp::CppParser::AST::ClassTemplate*)NativePtr)->Specializations = _tmpvalue;
}

unsigned int CppSharp::Parser::AST::ClassTemplate::SpecializationsCount::get()
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::ClassTemplate*)NativePtr)->getSpecializationsCount();
    return ___ret;
}

CppSharp::Parser::AST::ClassTemplateSpecialization::ClassTemplateSpecialization(class ::CppSharp::CppParser::AST::ClassTemplateSpecialization* native)
    : CppSharp::Parser::AST::Class((::CppSharp::CppParser::AST::Class*)native)
{
}

CppSharp::Parser::AST::ClassTemplateSpecialization^ CppSharp::Parser::AST::ClassTemplateSpecialization::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::ClassTemplateSpecialization((class ::CppSharp::CppParser::AST::ClassTemplateSpecialization*) native.ToPointer());
}

CppSharp::Parser::AST::ClassTemplateSpecialization::ClassTemplateSpecialization(class ::CppSharp::CppParser::AST::ClassTemplateSpecialization* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::Class((::CppSharp::CppParser::AST::Class*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::ClassTemplateSpecialization^ CppSharp::Parser::AST::ClassTemplateSpecialization::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::ClassTemplateSpecialization((class ::CppSharp::CppParser::AST::ClassTemplateSpecialization*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::ClassTemplateSpecialization::~ClassTemplateSpecialization()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::ClassTemplateSpecialization*) __nativePtr;
    }
}

CppSharp::Parser::AST::ClassTemplateSpecialization::ClassTemplateSpecialization()
    : CppSharp::Parser::AST::Class((::CppSharp::CppParser::AST::Class*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::ClassTemplateSpecialization();
}

CppSharp::Parser::AST::TemplateArgument^ CppSharp::Parser::AST::ClassTemplateSpecialization::GetArguments(unsigned int i)
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::ClassTemplateSpecialization*)NativePtr)->getArguments(i);
    auto _____ret = new struct ::CppSharp::CppParser::AST::TemplateArgument(___ret);
    return (_____ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::TemplateArgument((struct ::CppSharp::CppParser::AST::TemplateArgument*)_____ret, true);
}

void CppSharp::Parser::AST::ClassTemplateSpecialization::AddArguments(CppSharp::Parser::AST::TemplateArgument^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(struct ::CppSharp::CppParser::AST::TemplateArgument*)s->NativePtr;
    ((class ::CppSharp::CppParser::AST::ClassTemplateSpecialization*)NativePtr)->addArguments(__arg0);
}

void CppSharp::Parser::AST::ClassTemplateSpecialization::ClearArguments()
{
    ((class ::CppSharp::CppParser::AST::ClassTemplateSpecialization*)NativePtr)->clearArguments();
}

CppSharp::Parser::AST::ClassTemplateSpecialization::ClassTemplateSpecialization(CppSharp::Parser::AST::ClassTemplateSpecialization^ _0)
    : CppSharp::Parser::AST::Class((::CppSharp::CppParser::AST::Class*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::ClassTemplateSpecialization*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::ClassTemplateSpecialization(__arg0);
}

CppSharp::Parser::AST::ClassTemplate^ CppSharp::Parser::AST::ClassTemplateSpecialization::TemplatedDecl::get()
{
    return (((class ::CppSharp::CppParser::AST::ClassTemplateSpecialization*)NativePtr)->templatedDecl == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::ClassTemplate((class ::CppSharp::CppParser::AST::ClassTemplate*)((class ::CppSharp::CppParser::AST::ClassTemplateSpecialization*)NativePtr)->templatedDecl);
}

void CppSharp::Parser::AST::ClassTemplateSpecialization::TemplatedDecl::set(CppSharp::Parser::AST::ClassTemplate^ value)
{
    ((class ::CppSharp::CppParser::AST::ClassTemplateSpecialization*)NativePtr)->templatedDecl = (class ::CppSharp::CppParser::AST::ClassTemplate*)value->NativePtr;
}

::System::Collections::Generic::List<CppSharp::Parser::AST::TemplateArgument^>^ CppSharp::Parser::AST::ClassTemplateSpecialization::Arguments::get()
{
    auto _tmp__Arguments = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::TemplateArgument^>();
    auto __list0 = ((class ::CppSharp::CppParser::AST::ClassTemplateSpecialization*)NativePtr)->Arguments;
    for(auto _element : __list0)
    {
        auto ___element = new struct ::CppSharp::CppParser::AST::TemplateArgument(_element);
        auto _marshalElement = (___element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::TemplateArgument((struct ::CppSharp::CppParser::AST::TemplateArgument*)___element, true);
        _tmp__Arguments->Add(_marshalElement);
    }
    return _tmp__Arguments;
}

void CppSharp::Parser::AST::ClassTemplateSpecialization::Arguments::set(::System::Collections::Generic::List<CppSharp::Parser::AST::TemplateArgument^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::TemplateArgument>();
    for each(CppSharp::Parser::AST::TemplateArgument^ _element in value)
    {
        if (ReferenceEquals(_element, nullptr))
        throw gcnew ::System::ArgumentNullException("_element", "Cannot be null because it is passed by value.");
        auto _marshalElement = *(struct ::CppSharp::CppParser::AST::TemplateArgument*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((class ::CppSharp::CppParser::AST::ClassTemplateSpecialization*)NativePtr)->Arguments = _tmpvalue;
}

CppSharp::Parser::AST::TemplateSpecializationKind CppSharp::Parser::AST::ClassTemplateSpecialization::SpecializationKind::get()
{
    return (CppSharp::Parser::AST::TemplateSpecializationKind)((class ::CppSharp::CppParser::AST::ClassTemplateSpecialization*)NativePtr)->specializationKind;
}

void CppSharp::Parser::AST::ClassTemplateSpecialization::SpecializationKind::set(CppSharp::Parser::AST::TemplateSpecializationKind value)
{
    ((class ::CppSharp::CppParser::AST::ClassTemplateSpecialization*)NativePtr)->specializationKind = (enum ::CppSharp::CppParser::AST::TemplateSpecializationKind)value;
}

unsigned int CppSharp::Parser::AST::ClassTemplateSpecialization::ArgumentsCount::get()
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::ClassTemplateSpecialization*)NativePtr)->getArgumentsCount();
    return ___ret;
}

CppSharp::Parser::AST::ClassTemplatePartialSpecialization::ClassTemplatePartialSpecialization(class ::CppSharp::CppParser::AST::ClassTemplatePartialSpecialization* native)
    : CppSharp::Parser::AST::ClassTemplateSpecialization((::CppSharp::CppParser::AST::ClassTemplateSpecialization*)native)
{
}

CppSharp::Parser::AST::ClassTemplatePartialSpecialization^ CppSharp::Parser::AST::ClassTemplatePartialSpecialization::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::ClassTemplatePartialSpecialization((class ::CppSharp::CppParser::AST::ClassTemplatePartialSpecialization*) native.ToPointer());
}

CppSharp::Parser::AST::ClassTemplatePartialSpecialization::ClassTemplatePartialSpecialization(class ::CppSharp::CppParser::AST::ClassTemplatePartialSpecialization* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::ClassTemplateSpecialization((::CppSharp::CppParser::AST::ClassTemplateSpecialization*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::ClassTemplatePartialSpecialization^ CppSharp::Parser::AST::ClassTemplatePartialSpecialization::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::ClassTemplatePartialSpecialization((class ::CppSharp::CppParser::AST::ClassTemplatePartialSpecialization*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::ClassTemplatePartialSpecialization::~ClassTemplatePartialSpecialization()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::ClassTemplatePartialSpecialization*) __nativePtr;
    }
}

CppSharp::Parser::AST::ClassTemplatePartialSpecialization::ClassTemplatePartialSpecialization()
    : CppSharp::Parser::AST::ClassTemplateSpecialization((::CppSharp::CppParser::AST::ClassTemplateSpecialization*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::ClassTemplatePartialSpecialization();
}

CppSharp::Parser::AST::ClassTemplatePartialSpecialization::ClassTemplatePartialSpecialization(CppSharp::Parser::AST::ClassTemplatePartialSpecialization^ _0)
    : CppSharp::Parser::AST::ClassTemplateSpecialization((::CppSharp::CppParser::AST::ClassTemplateSpecialization*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::ClassTemplatePartialSpecialization*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::ClassTemplatePartialSpecialization(__arg0);
}

CppSharp::Parser::AST::FunctionTemplate::FunctionTemplate(class ::CppSharp::CppParser::AST::FunctionTemplate* native)
    : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)native)
{
}

CppSharp::Parser::AST::FunctionTemplate^ CppSharp::Parser::AST::FunctionTemplate::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::FunctionTemplate((class ::CppSharp::CppParser::AST::FunctionTemplate*) native.ToPointer());
}

CppSharp::Parser::AST::FunctionTemplate::FunctionTemplate(class ::CppSharp::CppParser::AST::FunctionTemplate* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::FunctionTemplate^ CppSharp::Parser::AST::FunctionTemplate::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::FunctionTemplate((class ::CppSharp::CppParser::AST::FunctionTemplate*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::FunctionTemplate::~FunctionTemplate()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::FunctionTemplate*) __nativePtr;
    }
}

CppSharp::Parser::AST::FunctionTemplate::FunctionTemplate()
    : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::FunctionTemplate();
}

CppSharp::Parser::AST::FunctionTemplateSpecialization^ CppSharp::Parser::AST::FunctionTemplate::GetSpecializations(unsigned int i)
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::FunctionTemplate*)NativePtr)->getSpecializations(i);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::FunctionTemplateSpecialization((class ::CppSharp::CppParser::AST::FunctionTemplateSpecialization*)___ret);
}

void CppSharp::Parser::AST::FunctionTemplate::AddSpecializations(CppSharp::Parser::AST::FunctionTemplateSpecialization^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto __arg0 = (class ::CppSharp::CppParser::AST::FunctionTemplateSpecialization*)s->NativePtr;
    ((class ::CppSharp::CppParser::AST::FunctionTemplate*)NativePtr)->addSpecializations(__arg0);
}

void CppSharp::Parser::AST::FunctionTemplate::ClearSpecializations()
{
    ((class ::CppSharp::CppParser::AST::FunctionTemplate*)NativePtr)->clearSpecializations();
}

CppSharp::Parser::AST::FunctionTemplateSpecialization^ CppSharp::Parser::AST::FunctionTemplate::FindSpecialization(::System::String^ usr)
{
    auto __arg0 = clix::marshalString<clix::E_UTF8>(usr);
    auto ___ret = ((class ::CppSharp::CppParser::AST::FunctionTemplate*)NativePtr)->FindSpecialization(__arg0);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::FunctionTemplateSpecialization((class ::CppSharp::CppParser::AST::FunctionTemplateSpecialization*)___ret);
}

CppSharp::Parser::AST::FunctionTemplate::FunctionTemplate(CppSharp::Parser::AST::FunctionTemplate^ _0)
    : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::FunctionTemplate*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::FunctionTemplate(__arg0);
}

::System::Collections::Generic::List<CppSharp::Parser::AST::FunctionTemplateSpecialization^>^ CppSharp::Parser::AST::FunctionTemplate::Specializations::get()
{
    auto _tmp__Specializations = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::FunctionTemplateSpecialization^>();
    auto __list0 = ((class ::CppSharp::CppParser::AST::FunctionTemplate*)NativePtr)->Specializations;
    for(auto _element : __list0)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::FunctionTemplateSpecialization((class ::CppSharp::CppParser::AST::FunctionTemplateSpecialization*)_element);
        _tmp__Specializations->Add(_marshalElement);
    }
    return _tmp__Specializations;
}

void CppSharp::Parser::AST::FunctionTemplate::Specializations::set(::System::Collections::Generic::List<CppSharp::Parser::AST::FunctionTemplateSpecialization^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::FunctionTemplateSpecialization*>();
    for each(CppSharp::Parser::AST::FunctionTemplateSpecialization^ _element in value)
    {
        auto _marshalElement = (class ::CppSharp::CppParser::AST::FunctionTemplateSpecialization*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((class ::CppSharp::CppParser::AST::FunctionTemplate*)NativePtr)->Specializations = _tmpvalue;
}

unsigned int CppSharp::Parser::AST::FunctionTemplate::SpecializationsCount::get()
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::FunctionTemplate*)NativePtr)->getSpecializationsCount();
    return ___ret;
}

CppSharp::Parser::AST::FunctionTemplateSpecialization::FunctionTemplateSpecialization(class ::CppSharp::CppParser::AST::FunctionTemplateSpecialization* native)
    : __ownsNativeInstance(false)
{
    NativePtr = native;
}

CppSharp::Parser::AST::FunctionTemplateSpecialization^ CppSharp::Parser::AST::FunctionTemplateSpecialization::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::FunctionTemplateSpecialization((class ::CppSharp::CppParser::AST::FunctionTemplateSpecialization*) native.ToPointer());
}

CppSharp::Parser::AST::FunctionTemplateSpecialization::FunctionTemplateSpecialization(class ::CppSharp::CppParser::AST::FunctionTemplateSpecialization* native, bool ownNativeInstance)
    : __ownsNativeInstance(ownNativeInstance)
{
    NativePtr = native;
}

CppSharp::Parser::AST::FunctionTemplateSpecialization^ CppSharp::Parser::AST::FunctionTemplateSpecialization::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::FunctionTemplateSpecialization((class ::CppSharp::CppParser::AST::FunctionTemplateSpecialization*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::FunctionTemplateSpecialization::~FunctionTemplateSpecialization()
{
    delete NativePtr;
}

CppSharp::Parser::AST::FunctionTemplateSpecialization::FunctionTemplateSpecialization()
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::FunctionTemplateSpecialization();
}

CppSharp::Parser::AST::TemplateArgument^ CppSharp::Parser::AST::FunctionTemplateSpecialization::GetArguments(unsigned int i)
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::FunctionTemplateSpecialization*)NativePtr)->getArguments(i);
    auto _____ret = new struct ::CppSharp::CppParser::AST::TemplateArgument(___ret);
    return (_____ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::TemplateArgument((struct ::CppSharp::CppParser::AST::TemplateArgument*)_____ret, true);
}

void CppSharp::Parser::AST::FunctionTemplateSpecialization::AddArguments(CppSharp::Parser::AST::TemplateArgument^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(struct ::CppSharp::CppParser::AST::TemplateArgument*)s->NativePtr;
    ((class ::CppSharp::CppParser::AST::FunctionTemplateSpecialization*)NativePtr)->addArguments(__arg0);
}

void CppSharp::Parser::AST::FunctionTemplateSpecialization::ClearArguments()
{
    ((class ::CppSharp::CppParser::AST::FunctionTemplateSpecialization*)NativePtr)->clearArguments();
}

CppSharp::Parser::AST::FunctionTemplateSpecialization::FunctionTemplateSpecialization(CppSharp::Parser::AST::FunctionTemplateSpecialization^ _0)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::FunctionTemplateSpecialization*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::FunctionTemplateSpecialization(__arg0);
}

::System::IntPtr CppSharp::Parser::AST::FunctionTemplateSpecialization::__Instance::get()
{
    return ::System::IntPtr(NativePtr);
}

void CppSharp::Parser::AST::FunctionTemplateSpecialization::__Instance::set(::System::IntPtr object)
{
    NativePtr = (class ::CppSharp::CppParser::AST::FunctionTemplateSpecialization*)object.ToPointer();
}

CppSharp::Parser::AST::FunctionTemplate^ CppSharp::Parser::AST::FunctionTemplateSpecialization::Template::get()
{
    return (NativePtr->_template == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::FunctionTemplate((class ::CppSharp::CppParser::AST::FunctionTemplate*)NativePtr->_template);
}

void CppSharp::Parser::AST::FunctionTemplateSpecialization::Template::set(CppSharp::Parser::AST::FunctionTemplate^ value)
{
    ((class ::CppSharp::CppParser::AST::FunctionTemplateSpecialization*)NativePtr)->_template = (class ::CppSharp::CppParser::AST::FunctionTemplate*)value->NativePtr;
}

::System::Collections::Generic::List<CppSharp::Parser::AST::TemplateArgument^>^ CppSharp::Parser::AST::FunctionTemplateSpecialization::Arguments::get()
{
    auto _tmp__Arguments = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::TemplateArgument^>();
    auto __list0 = NativePtr->Arguments;
    for(auto _element : __list0)
    {
        auto ___element = new struct ::CppSharp::CppParser::AST::TemplateArgument(_element);
        auto _marshalElement = (___element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::TemplateArgument((struct ::CppSharp::CppParser::AST::TemplateArgument*)___element, true);
        _tmp__Arguments->Add(_marshalElement);
    }
    return _tmp__Arguments;
}

void CppSharp::Parser::AST::FunctionTemplateSpecialization::Arguments::set(::System::Collections::Generic::List<CppSharp::Parser::AST::TemplateArgument^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::TemplateArgument>();
    for each(CppSharp::Parser::AST::TemplateArgument^ _element in value)
    {
        if (ReferenceEquals(_element, nullptr))
        throw gcnew ::System::ArgumentNullException("_element", "Cannot be null because it is passed by value.");
        auto _marshalElement = *(struct ::CppSharp::CppParser::AST::TemplateArgument*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((class ::CppSharp::CppParser::AST::FunctionTemplateSpecialization*)NativePtr)->Arguments = _tmpvalue;
}

CppSharp::Parser::AST::Function^ CppSharp::Parser::AST::FunctionTemplateSpecialization::SpecializedFunction::get()
{
    return (NativePtr->specializedFunction == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::Function((class ::CppSharp::CppParser::AST::Function*)NativePtr->specializedFunction);
}

void CppSharp::Parser::AST::FunctionTemplateSpecialization::SpecializedFunction::set(CppSharp::Parser::AST::Function^ value)
{
    ((class ::CppSharp::CppParser::AST::FunctionTemplateSpecialization*)NativePtr)->specializedFunction = (class ::CppSharp::CppParser::AST::Function*)value->NativePtr;
}

CppSharp::Parser::AST::TemplateSpecializationKind CppSharp::Parser::AST::FunctionTemplateSpecialization::SpecializationKind::get()
{
    return (CppSharp::Parser::AST::TemplateSpecializationKind)NativePtr->specializationKind;
}

void CppSharp::Parser::AST::FunctionTemplateSpecialization::SpecializationKind::set(CppSharp::Parser::AST::TemplateSpecializationKind value)
{
    ((class ::CppSharp::CppParser::AST::FunctionTemplateSpecialization*)NativePtr)->specializationKind = (enum ::CppSharp::CppParser::AST::TemplateSpecializationKind)value;
}

unsigned int CppSharp::Parser::AST::FunctionTemplateSpecialization::ArgumentsCount::get()
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::FunctionTemplateSpecialization*)NativePtr)->getArgumentsCount();
    return ___ret;
}

CppSharp::Parser::AST::VarTemplate::VarTemplate(class ::CppSharp::CppParser::AST::VarTemplate* native)
    : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)native)
{
}

CppSharp::Parser::AST::VarTemplate^ CppSharp::Parser::AST::VarTemplate::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::VarTemplate((class ::CppSharp::CppParser::AST::VarTemplate*) native.ToPointer());
}

CppSharp::Parser::AST::VarTemplate::VarTemplate(class ::CppSharp::CppParser::AST::VarTemplate* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::VarTemplate^ CppSharp::Parser::AST::VarTemplate::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::VarTemplate((class ::CppSharp::CppParser::AST::VarTemplate*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::VarTemplate::~VarTemplate()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::VarTemplate*) __nativePtr;
    }
}

CppSharp::Parser::AST::VarTemplate::VarTemplate()
    : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::VarTemplate();
}

CppSharp::Parser::AST::VarTemplateSpecialization^ CppSharp::Parser::AST::VarTemplate::GetSpecializations(unsigned int i)
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::VarTemplate*)NativePtr)->getSpecializations(i);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::VarTemplateSpecialization((class ::CppSharp::CppParser::AST::VarTemplateSpecialization*)___ret);
}

void CppSharp::Parser::AST::VarTemplate::AddSpecializations(CppSharp::Parser::AST::VarTemplateSpecialization^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto __arg0 = (class ::CppSharp::CppParser::AST::VarTemplateSpecialization*)s->NativePtr;
    ((class ::CppSharp::CppParser::AST::VarTemplate*)NativePtr)->addSpecializations(__arg0);
}

void CppSharp::Parser::AST::VarTemplate::ClearSpecializations()
{
    ((class ::CppSharp::CppParser::AST::VarTemplate*)NativePtr)->clearSpecializations();
}

CppSharp::Parser::AST::VarTemplateSpecialization^ CppSharp::Parser::AST::VarTemplate::FindSpecialization(::System::String^ usr)
{
    auto __arg0 = clix::marshalString<clix::E_UTF8>(usr);
    auto ___ret = ((class ::CppSharp::CppParser::AST::VarTemplate*)NativePtr)->FindSpecialization(__arg0);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::VarTemplateSpecialization((class ::CppSharp::CppParser::AST::VarTemplateSpecialization*)___ret);
}

CppSharp::Parser::AST::VarTemplatePartialSpecialization^ CppSharp::Parser::AST::VarTemplate::FindPartialSpecialization(::System::String^ usr)
{
    auto __arg0 = clix::marshalString<clix::E_UTF8>(usr);
    auto ___ret = ((class ::CppSharp::CppParser::AST::VarTemplate*)NativePtr)->FindPartialSpecialization(__arg0);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::VarTemplatePartialSpecialization((class ::CppSharp::CppParser::AST::VarTemplatePartialSpecialization*)___ret);
}

CppSharp::Parser::AST::VarTemplate::VarTemplate(CppSharp::Parser::AST::VarTemplate^ _0)
    : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::VarTemplate*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::VarTemplate(__arg0);
}

::System::Collections::Generic::List<CppSharp::Parser::AST::VarTemplateSpecialization^>^ CppSharp::Parser::AST::VarTemplate::Specializations::get()
{
    auto _tmp__Specializations = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::VarTemplateSpecialization^>();
    auto __list0 = ((class ::CppSharp::CppParser::AST::VarTemplate*)NativePtr)->Specializations;
    for(auto _element : __list0)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::VarTemplateSpecialization((class ::CppSharp::CppParser::AST::VarTemplateSpecialization*)_element);
        _tmp__Specializations->Add(_marshalElement);
    }
    return _tmp__Specializations;
}

void CppSharp::Parser::AST::VarTemplate::Specializations::set(::System::Collections::Generic::List<CppSharp::Parser::AST::VarTemplateSpecialization^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::VarTemplateSpecialization*>();
    for each(CppSharp::Parser::AST::VarTemplateSpecialization^ _element in value)
    {
        auto _marshalElement = (class ::CppSharp::CppParser::AST::VarTemplateSpecialization*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((class ::CppSharp::CppParser::AST::VarTemplate*)NativePtr)->Specializations = _tmpvalue;
}

unsigned int CppSharp::Parser::AST::VarTemplate::SpecializationsCount::get()
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::VarTemplate*)NativePtr)->getSpecializationsCount();
    return ___ret;
}

CppSharp::Parser::AST::VarTemplateSpecialization::VarTemplateSpecialization(class ::CppSharp::CppParser::AST::VarTemplateSpecialization* native)
    : CppSharp::Parser::AST::Variable((::CppSharp::CppParser::AST::Variable*)native)
{
}

CppSharp::Parser::AST::VarTemplateSpecialization^ CppSharp::Parser::AST::VarTemplateSpecialization::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::VarTemplateSpecialization((class ::CppSharp::CppParser::AST::VarTemplateSpecialization*) native.ToPointer());
}

CppSharp::Parser::AST::VarTemplateSpecialization::VarTemplateSpecialization(class ::CppSharp::CppParser::AST::VarTemplateSpecialization* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::Variable((::CppSharp::CppParser::AST::Variable*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::VarTemplateSpecialization^ CppSharp::Parser::AST::VarTemplateSpecialization::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::VarTemplateSpecialization((class ::CppSharp::CppParser::AST::VarTemplateSpecialization*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::VarTemplateSpecialization::~VarTemplateSpecialization()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::VarTemplateSpecialization*) __nativePtr;
    }
}

CppSharp::Parser::AST::VarTemplateSpecialization::VarTemplateSpecialization()
    : CppSharp::Parser::AST::Variable((::CppSharp::CppParser::AST::Variable*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::VarTemplateSpecialization();
}

CppSharp::Parser::AST::TemplateArgument^ CppSharp::Parser::AST::VarTemplateSpecialization::GetArguments(unsigned int i)
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::VarTemplateSpecialization*)NativePtr)->getArguments(i);
    auto _____ret = new struct ::CppSharp::CppParser::AST::TemplateArgument(___ret);
    return (_____ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::TemplateArgument((struct ::CppSharp::CppParser::AST::TemplateArgument*)_____ret, true);
}

void CppSharp::Parser::AST::VarTemplateSpecialization::AddArguments(CppSharp::Parser::AST::TemplateArgument^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(struct ::CppSharp::CppParser::AST::TemplateArgument*)s->NativePtr;
    ((class ::CppSharp::CppParser::AST::VarTemplateSpecialization*)NativePtr)->addArguments(__arg0);
}

void CppSharp::Parser::AST::VarTemplateSpecialization::ClearArguments()
{
    ((class ::CppSharp::CppParser::AST::VarTemplateSpecialization*)NativePtr)->clearArguments();
}

CppSharp::Parser::AST::VarTemplateSpecialization::VarTemplateSpecialization(CppSharp::Parser::AST::VarTemplateSpecialization^ _0)
    : CppSharp::Parser::AST::Variable((::CppSharp::CppParser::AST::Variable*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::VarTemplateSpecialization*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::VarTemplateSpecialization(__arg0);
}

CppSharp::Parser::AST::VarTemplate^ CppSharp::Parser::AST::VarTemplateSpecialization::TemplatedDecl::get()
{
    return (((class ::CppSharp::CppParser::AST::VarTemplateSpecialization*)NativePtr)->templatedDecl == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::VarTemplate((class ::CppSharp::CppParser::AST::VarTemplate*)((class ::CppSharp::CppParser::AST::VarTemplateSpecialization*)NativePtr)->templatedDecl);
}

void CppSharp::Parser::AST::VarTemplateSpecialization::TemplatedDecl::set(CppSharp::Parser::AST::VarTemplate^ value)
{
    ((class ::CppSharp::CppParser::AST::VarTemplateSpecialization*)NativePtr)->templatedDecl = (class ::CppSharp::CppParser::AST::VarTemplate*)value->NativePtr;
}

::System::Collections::Generic::List<CppSharp::Parser::AST::TemplateArgument^>^ CppSharp::Parser::AST::VarTemplateSpecialization::Arguments::get()
{
    auto _tmp__Arguments = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::TemplateArgument^>();
    auto __list0 = ((class ::CppSharp::CppParser::AST::VarTemplateSpecialization*)NativePtr)->Arguments;
    for(auto _element : __list0)
    {
        auto ___element = new struct ::CppSharp::CppParser::AST::TemplateArgument(_element);
        auto _marshalElement = (___element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::TemplateArgument((struct ::CppSharp::CppParser::AST::TemplateArgument*)___element, true);
        _tmp__Arguments->Add(_marshalElement);
    }
    return _tmp__Arguments;
}

void CppSharp::Parser::AST::VarTemplateSpecialization::Arguments::set(::System::Collections::Generic::List<CppSharp::Parser::AST::TemplateArgument^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::TemplateArgument>();
    for each(CppSharp::Parser::AST::TemplateArgument^ _element in value)
    {
        if (ReferenceEquals(_element, nullptr))
        throw gcnew ::System::ArgumentNullException("_element", "Cannot be null because it is passed by value.");
        auto _marshalElement = *(struct ::CppSharp::CppParser::AST::TemplateArgument*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((class ::CppSharp::CppParser::AST::VarTemplateSpecialization*)NativePtr)->Arguments = _tmpvalue;
}

CppSharp::Parser::AST::TemplateSpecializationKind CppSharp::Parser::AST::VarTemplateSpecialization::SpecializationKind::get()
{
    return (CppSharp::Parser::AST::TemplateSpecializationKind)((class ::CppSharp::CppParser::AST::VarTemplateSpecialization*)NativePtr)->specializationKind;
}

void CppSharp::Parser::AST::VarTemplateSpecialization::SpecializationKind::set(CppSharp::Parser::AST::TemplateSpecializationKind value)
{
    ((class ::CppSharp::CppParser::AST::VarTemplateSpecialization*)NativePtr)->specializationKind = (enum ::CppSharp::CppParser::AST::TemplateSpecializationKind)value;
}

unsigned int CppSharp::Parser::AST::VarTemplateSpecialization::ArgumentsCount::get()
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::VarTemplateSpecialization*)NativePtr)->getArgumentsCount();
    return ___ret;
}

CppSharp::Parser::AST::VarTemplatePartialSpecialization::VarTemplatePartialSpecialization(class ::CppSharp::CppParser::AST::VarTemplatePartialSpecialization* native)
    : CppSharp::Parser::AST::VarTemplateSpecialization((::CppSharp::CppParser::AST::VarTemplateSpecialization*)native)
{
}

CppSharp::Parser::AST::VarTemplatePartialSpecialization^ CppSharp::Parser::AST::VarTemplatePartialSpecialization::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::VarTemplatePartialSpecialization((class ::CppSharp::CppParser::AST::VarTemplatePartialSpecialization*) native.ToPointer());
}

CppSharp::Parser::AST::VarTemplatePartialSpecialization::VarTemplatePartialSpecialization(class ::CppSharp::CppParser::AST::VarTemplatePartialSpecialization* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::VarTemplateSpecialization((::CppSharp::CppParser::AST::VarTemplateSpecialization*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::VarTemplatePartialSpecialization^ CppSharp::Parser::AST::VarTemplatePartialSpecialization::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::VarTemplatePartialSpecialization((class ::CppSharp::CppParser::AST::VarTemplatePartialSpecialization*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::VarTemplatePartialSpecialization::~VarTemplatePartialSpecialization()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::VarTemplatePartialSpecialization*) __nativePtr;
    }
}

CppSharp::Parser::AST::VarTemplatePartialSpecialization::VarTemplatePartialSpecialization()
    : CppSharp::Parser::AST::VarTemplateSpecialization((::CppSharp::CppParser::AST::VarTemplateSpecialization*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::VarTemplatePartialSpecialization();
}

CppSharp::Parser::AST::VarTemplatePartialSpecialization::VarTemplatePartialSpecialization(CppSharp::Parser::AST::VarTemplatePartialSpecialization^ _0)
    : CppSharp::Parser::AST::VarTemplateSpecialization((::CppSharp::CppParser::AST::VarTemplateSpecialization*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::VarTemplatePartialSpecialization*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::VarTemplatePartialSpecialization(__arg0);
}

CppSharp::Parser::AST::UnresolvedUsingTypename::UnresolvedUsingTypename(class ::CppSharp::CppParser::AST::UnresolvedUsingTypename* native)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)native)
{
}

CppSharp::Parser::AST::UnresolvedUsingTypename^ CppSharp::Parser::AST::UnresolvedUsingTypename::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::UnresolvedUsingTypename((class ::CppSharp::CppParser::AST::UnresolvedUsingTypename*) native.ToPointer());
}

CppSharp::Parser::AST::UnresolvedUsingTypename::UnresolvedUsingTypename(class ::CppSharp::CppParser::AST::UnresolvedUsingTypename* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::UnresolvedUsingTypename^ CppSharp::Parser::AST::UnresolvedUsingTypename::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::UnresolvedUsingTypename((class ::CppSharp::CppParser::AST::UnresolvedUsingTypename*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::UnresolvedUsingTypename::~UnresolvedUsingTypename()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::UnresolvedUsingTypename*) __nativePtr;
    }
}

CppSharp::Parser::AST::UnresolvedUsingTypename::UnresolvedUsingTypename()
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::UnresolvedUsingTypename();
}

CppSharp::Parser::AST::UnresolvedUsingTypename::UnresolvedUsingTypename(CppSharp::Parser::AST::UnresolvedUsingTypename^ _0)
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::UnresolvedUsingTypename*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::UnresolvedUsingTypename(__arg0);
}

CppSharp::Parser::AST::Namespace::Namespace(class ::CppSharp::CppParser::AST::Namespace* native)
    : CppSharp::Parser::AST::DeclarationContext((::CppSharp::CppParser::AST::DeclarationContext*)native)
{
}

CppSharp::Parser::AST::Namespace^ CppSharp::Parser::AST::Namespace::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::Namespace((class ::CppSharp::CppParser::AST::Namespace*) native.ToPointer());
}

CppSharp::Parser::AST::Namespace::Namespace(class ::CppSharp::CppParser::AST::Namespace* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::DeclarationContext((::CppSharp::CppParser::AST::DeclarationContext*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::Namespace^ CppSharp::Parser::AST::Namespace::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::Namespace((class ::CppSharp::CppParser::AST::Namespace*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::Namespace::~Namespace()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::Namespace*) __nativePtr;
    }
}

CppSharp::Parser::AST::Namespace::Namespace()
    : CppSharp::Parser::AST::DeclarationContext((::CppSharp::CppParser::AST::DeclarationContext*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::Namespace();
}

CppSharp::Parser::AST::Namespace::Namespace(CppSharp::Parser::AST::Namespace^ _0)
    : CppSharp::Parser::AST::DeclarationContext((::CppSharp::CppParser::AST::DeclarationContext*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::Namespace*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::Namespace(__arg0);
}

bool CppSharp::Parser::AST::Namespace::IsInline::get()
{
    return ((class ::CppSharp::CppParser::AST::Namespace*)NativePtr)->isInline;
}

void CppSharp::Parser::AST::Namespace::IsInline::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::Namespace*)NativePtr)->isInline = value;
}

CppSharp::Parser::AST::PreprocessedEntity::PreprocessedEntity(class ::CppSharp::CppParser::AST::PreprocessedEntity* native)
    : __ownsNativeInstance(false)
{
    NativePtr = native;
}

CppSharp::Parser::AST::PreprocessedEntity^ CppSharp::Parser::AST::PreprocessedEntity::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::PreprocessedEntity((class ::CppSharp::CppParser::AST::PreprocessedEntity*) native.ToPointer());
}

CppSharp::Parser::AST::PreprocessedEntity::PreprocessedEntity(class ::CppSharp::CppParser::AST::PreprocessedEntity* native, bool ownNativeInstance)
    : __ownsNativeInstance(ownNativeInstance)
{
    NativePtr = native;
}

CppSharp::Parser::AST::PreprocessedEntity^ CppSharp::Parser::AST::PreprocessedEntity::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::PreprocessedEntity((class ::CppSharp::CppParser::AST::PreprocessedEntity*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::PreprocessedEntity::~PreprocessedEntity()
{
    delete NativePtr;
}

CppSharp::Parser::AST::PreprocessedEntity::PreprocessedEntity()
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::PreprocessedEntity();
}

CppSharp::Parser::AST::PreprocessedEntity::PreprocessedEntity(CppSharp::Parser::AST::PreprocessedEntity^ _0)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::PreprocessedEntity*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::PreprocessedEntity(__arg0);
}

::System::IntPtr CppSharp::Parser::AST::PreprocessedEntity::__Instance::get()
{
    return ::System::IntPtr(NativePtr);
}

void CppSharp::Parser::AST::PreprocessedEntity::__Instance::set(::System::IntPtr object)
{
    NativePtr = (class ::CppSharp::CppParser::AST::PreprocessedEntity*)object.ToPointer();
}

CppSharp::Parser::AST::MacroLocation CppSharp::Parser::AST::PreprocessedEntity::MacroLocation::get()
{
    return (CppSharp::Parser::AST::MacroLocation)NativePtr->macroLocation;
}

void CppSharp::Parser::AST::PreprocessedEntity::MacroLocation::set(CppSharp::Parser::AST::MacroLocation value)
{
    ((class ::CppSharp::CppParser::AST::PreprocessedEntity*)NativePtr)->macroLocation = (enum ::CppSharp::CppParser::AST::MacroLocation)value;
}

::System::IntPtr CppSharp::Parser::AST::PreprocessedEntity::OriginalPtr::get()
{
    return ::System::IntPtr(NativePtr->originalPtr);
}

void CppSharp::Parser::AST::PreprocessedEntity::OriginalPtr::set(::System::IntPtr value)
{
    ((class ::CppSharp::CppParser::AST::PreprocessedEntity*)NativePtr)->originalPtr = (void*)value;
}

CppSharp::Parser::AST::DeclarationKind CppSharp::Parser::AST::PreprocessedEntity::Kind::get()
{
    return (CppSharp::Parser::AST::DeclarationKind)NativePtr->kind;
}

void CppSharp::Parser::AST::PreprocessedEntity::Kind::set(CppSharp::Parser::AST::DeclarationKind value)
{
    ((class ::CppSharp::CppParser::AST::PreprocessedEntity*)NativePtr)->kind = (enum ::CppSharp::CppParser::AST::DeclarationKind)value;
}

CppSharp::Parser::AST::MacroDefinition::MacroDefinition(class ::CppSharp::CppParser::AST::MacroDefinition* native)
    : CppSharp::Parser::AST::PreprocessedEntity((::CppSharp::CppParser::AST::PreprocessedEntity*)native)
{
}

CppSharp::Parser::AST::MacroDefinition^ CppSharp::Parser::AST::MacroDefinition::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::MacroDefinition((class ::CppSharp::CppParser::AST::MacroDefinition*) native.ToPointer());
}

CppSharp::Parser::AST::MacroDefinition::MacroDefinition(class ::CppSharp::CppParser::AST::MacroDefinition* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::PreprocessedEntity((::CppSharp::CppParser::AST::PreprocessedEntity*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::MacroDefinition^ CppSharp::Parser::AST::MacroDefinition::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::MacroDefinition((class ::CppSharp::CppParser::AST::MacroDefinition*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::MacroDefinition::~MacroDefinition()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::MacroDefinition*) __nativePtr;
    }
}

CppSharp::Parser::AST::MacroDefinition::MacroDefinition()
    : CppSharp::Parser::AST::PreprocessedEntity((::CppSharp::CppParser::AST::PreprocessedEntity*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::MacroDefinition();
}

CppSharp::Parser::AST::MacroDefinition::MacroDefinition(CppSharp::Parser::AST::MacroDefinition^ _0)
    : CppSharp::Parser::AST::PreprocessedEntity((::CppSharp::CppParser::AST::PreprocessedEntity*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::MacroDefinition*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::MacroDefinition(__arg0);
}

::System::String^ CppSharp::Parser::AST::MacroDefinition::Name::get()
{
    return clix::marshalString<clix::E_UTF8>(((class ::CppSharp::CppParser::AST::MacroDefinition*)NativePtr)->name);
}

void CppSharp::Parser::AST::MacroDefinition::Name::set(::System::String^ value)
{
    ((class ::CppSharp::CppParser::AST::MacroDefinition*)NativePtr)->name = clix::marshalString<clix::E_UTF8>(value);
}

::System::String^ CppSharp::Parser::AST::MacroDefinition::Expression::get()
{
    return clix::marshalString<clix::E_UTF8>(((class ::CppSharp::CppParser::AST::MacroDefinition*)NativePtr)->expression);
}

void CppSharp::Parser::AST::MacroDefinition::Expression::set(::System::String^ value)
{
    ((class ::CppSharp::CppParser::AST::MacroDefinition*)NativePtr)->expression = clix::marshalString<clix::E_UTF8>(value);
}

int CppSharp::Parser::AST::MacroDefinition::LineNumberStart::get()
{
    return ((class ::CppSharp::CppParser::AST::MacroDefinition*)NativePtr)->lineNumberStart;
}

void CppSharp::Parser::AST::MacroDefinition::LineNumberStart::set(int value)
{
    ((class ::CppSharp::CppParser::AST::MacroDefinition*)NativePtr)->lineNumberStart = value;
}

int CppSharp::Parser::AST::MacroDefinition::LineNumberEnd::get()
{
    return ((class ::CppSharp::CppParser::AST::MacroDefinition*)NativePtr)->lineNumberEnd;
}

void CppSharp::Parser::AST::MacroDefinition::LineNumberEnd::set(int value)
{
    ((class ::CppSharp::CppParser::AST::MacroDefinition*)NativePtr)->lineNumberEnd = value;
}

CppSharp::Parser::AST::MacroExpansion::MacroExpansion(class ::CppSharp::CppParser::AST::MacroExpansion* native)
    : CppSharp::Parser::AST::PreprocessedEntity((::CppSharp::CppParser::AST::PreprocessedEntity*)native)
{
}

CppSharp::Parser::AST::MacroExpansion^ CppSharp::Parser::AST::MacroExpansion::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::MacroExpansion((class ::CppSharp::CppParser::AST::MacroExpansion*) native.ToPointer());
}

CppSharp::Parser::AST::MacroExpansion::MacroExpansion(class ::CppSharp::CppParser::AST::MacroExpansion* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::PreprocessedEntity((::CppSharp::CppParser::AST::PreprocessedEntity*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::MacroExpansion^ CppSharp::Parser::AST::MacroExpansion::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::MacroExpansion((class ::CppSharp::CppParser::AST::MacroExpansion*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::MacroExpansion::~MacroExpansion()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::MacroExpansion*) __nativePtr;
    }
}

CppSharp::Parser::AST::MacroExpansion::MacroExpansion()
    : CppSharp::Parser::AST::PreprocessedEntity((::CppSharp::CppParser::AST::PreprocessedEntity*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::MacroExpansion();
}

CppSharp::Parser::AST::MacroExpansion::MacroExpansion(CppSharp::Parser::AST::MacroExpansion^ _0)
    : CppSharp::Parser::AST::PreprocessedEntity((::CppSharp::CppParser::AST::PreprocessedEntity*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::MacroExpansion*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::MacroExpansion(__arg0);
}

::System::String^ CppSharp::Parser::AST::MacroExpansion::Name::get()
{
    return clix::marshalString<clix::E_UTF8>(((class ::CppSharp::CppParser::AST::MacroExpansion*)NativePtr)->name);
}

void CppSharp::Parser::AST::MacroExpansion::Name::set(::System::String^ value)
{
    ((class ::CppSharp::CppParser::AST::MacroExpansion*)NativePtr)->name = clix::marshalString<clix::E_UTF8>(value);
}

::System::String^ CppSharp::Parser::AST::MacroExpansion::Text::get()
{
    return clix::marshalString<clix::E_UTF8>(((class ::CppSharp::CppParser::AST::MacroExpansion*)NativePtr)->text);
}

void CppSharp::Parser::AST::MacroExpansion::Text::set(::System::String^ value)
{
    ((class ::CppSharp::CppParser::AST::MacroExpansion*)NativePtr)->text = clix::marshalString<clix::E_UTF8>(value);
}

CppSharp::Parser::AST::MacroDefinition^ CppSharp::Parser::AST::MacroExpansion::Definition::get()
{
    return (((class ::CppSharp::CppParser::AST::MacroExpansion*)NativePtr)->definition == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::MacroDefinition((class ::CppSharp::CppParser::AST::MacroDefinition*)((class ::CppSharp::CppParser::AST::MacroExpansion*)NativePtr)->definition);
}

void CppSharp::Parser::AST::MacroExpansion::Definition::set(CppSharp::Parser::AST::MacroDefinition^ value)
{
    ((class ::CppSharp::CppParser::AST::MacroExpansion*)NativePtr)->definition = (class ::CppSharp::CppParser::AST::MacroDefinition*)value->NativePtr;
}

CppSharp::Parser::AST::TranslationUnit::TranslationUnit(class ::CppSharp::CppParser::AST::TranslationUnit* native)
    : CppSharp::Parser::AST::Namespace((::CppSharp::CppParser::AST::Namespace*)native)
{
}

CppSharp::Parser::AST::TranslationUnit^ CppSharp::Parser::AST::TranslationUnit::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::TranslationUnit((class ::CppSharp::CppParser::AST::TranslationUnit*) native.ToPointer());
}

CppSharp::Parser::AST::TranslationUnit::TranslationUnit(class ::CppSharp::CppParser::AST::TranslationUnit* native, bool ownNativeInstance)
    : CppSharp::Parser::AST::Namespace((::CppSharp::CppParser::AST::Namespace*)native, ownNativeInstance)
{
}

CppSharp::Parser::AST::TranslationUnit^ CppSharp::Parser::AST::TranslationUnit::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::TranslationUnit((class ::CppSharp::CppParser::AST::TranslationUnit*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::TranslationUnit::~TranslationUnit()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (class ::CppSharp::CppParser::AST::TranslationUnit*) __nativePtr;
    }
}

CppSharp::Parser::AST::TranslationUnit::TranslationUnit()
    : CppSharp::Parser::AST::Namespace((::CppSharp::CppParser::AST::Namespace*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::TranslationUnit();
}

CppSharp::Parser::AST::MacroDefinition^ CppSharp::Parser::AST::TranslationUnit::GetMacros(unsigned int i)
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::TranslationUnit*)NativePtr)->getMacros(i);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::MacroDefinition((class ::CppSharp::CppParser::AST::MacroDefinition*)___ret);
}

void CppSharp::Parser::AST::TranslationUnit::AddMacros(CppSharp::Parser::AST::MacroDefinition^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto __arg0 = (class ::CppSharp::CppParser::AST::MacroDefinition*)s->NativePtr;
    ((class ::CppSharp::CppParser::AST::TranslationUnit*)NativePtr)->addMacros(__arg0);
}

void CppSharp::Parser::AST::TranslationUnit::ClearMacros()
{
    ((class ::CppSharp::CppParser::AST::TranslationUnit*)NativePtr)->clearMacros();
}

CppSharp::Parser::AST::TranslationUnit::TranslationUnit(CppSharp::Parser::AST::TranslationUnit^ _0)
    : CppSharp::Parser::AST::Namespace((::CppSharp::CppParser::AST::Namespace*)nullptr)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::TranslationUnit*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::TranslationUnit(__arg0);
}

::System::String^ CppSharp::Parser::AST::TranslationUnit::FileName::get()
{
    return clix::marshalString<clix::E_UTF8>(((class ::CppSharp::CppParser::AST::TranslationUnit*)NativePtr)->fileName);
}

void CppSharp::Parser::AST::TranslationUnit::FileName::set(::System::String^ value)
{
    ((class ::CppSharp::CppParser::AST::TranslationUnit*)NativePtr)->fileName = clix::marshalString<clix::E_UTF8>(value);
}

bool CppSharp::Parser::AST::TranslationUnit::IsSystemHeader::get()
{
    return ((class ::CppSharp::CppParser::AST::TranslationUnit*)NativePtr)->isSystemHeader;
}

void CppSharp::Parser::AST::TranslationUnit::IsSystemHeader::set(bool value)
{
    ((class ::CppSharp::CppParser::AST::TranslationUnit*)NativePtr)->isSystemHeader = value;
}

::System::Collections::Generic::List<CppSharp::Parser::AST::MacroDefinition^>^ CppSharp::Parser::AST::TranslationUnit::Macros::get()
{
    auto _tmp__Macros = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::MacroDefinition^>();
    auto __list0 = ((class ::CppSharp::CppParser::AST::TranslationUnit*)NativePtr)->Macros;
    for(auto _element : __list0)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::MacroDefinition((class ::CppSharp::CppParser::AST::MacroDefinition*)_element);
        _tmp__Macros->Add(_marshalElement);
    }
    return _tmp__Macros;
}

void CppSharp::Parser::AST::TranslationUnit::Macros::set(::System::Collections::Generic::List<CppSharp::Parser::AST::MacroDefinition^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::MacroDefinition*>();
    for each(CppSharp::Parser::AST::MacroDefinition^ _element in value)
    {
        auto _marshalElement = (class ::CppSharp::CppParser::AST::MacroDefinition*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((class ::CppSharp::CppParser::AST::TranslationUnit*)NativePtr)->Macros = _tmpvalue;
}

unsigned int CppSharp::Parser::AST::TranslationUnit::MacrosCount::get()
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::TranslationUnit*)NativePtr)->getMacrosCount();
    return ___ret;
}

CppSharp::Parser::AST::ASTContext::ASTContext(class ::CppSharp::CppParser::AST::ASTContext* native)
    : __ownsNativeInstance(false)
{
    NativePtr = native;
}

CppSharp::Parser::AST::ASTContext^ CppSharp::Parser::AST::ASTContext::__CreateInstance(::System::IntPtr native)
{
    return gcnew ::CppSharp::Parser::AST::ASTContext((class ::CppSharp::CppParser::AST::ASTContext*) native.ToPointer());
}

CppSharp::Parser::AST::ASTContext::ASTContext(class ::CppSharp::CppParser::AST::ASTContext* native, bool ownNativeInstance)
    : __ownsNativeInstance(ownNativeInstance)
{
    NativePtr = native;
}

CppSharp::Parser::AST::ASTContext^ CppSharp::Parser::AST::ASTContext::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance)
{
    return gcnew ::CppSharp::Parser::AST::ASTContext((class ::CppSharp::CppParser::AST::ASTContext*) native.ToPointer(), __ownsNativeInstance);
}

CppSharp::Parser::AST::ASTContext::~ASTContext()
{
    delete NativePtr;
}

CppSharp::Parser::AST::ASTContext::ASTContext()
{
    __ownsNativeInstance = true;
    NativePtr = new class ::CppSharp::CppParser::AST::ASTContext();
}

CppSharp::Parser::AST::TranslationUnit^ CppSharp::Parser::AST::ASTContext::FindOrCreateModule(::System::String^ File)
{
    auto __arg0 = clix::marshalString<clix::E_UTF8>(File);
    auto ___ret = ((class ::CppSharp::CppParser::AST::ASTContext*)NativePtr)->FindOrCreateModule(__arg0);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::TranslationUnit((class ::CppSharp::CppParser::AST::TranslationUnit*)___ret);
}

CppSharp::Parser::AST::TranslationUnit^ CppSharp::Parser::AST::ASTContext::GetTranslationUnits(unsigned int i)
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::ASTContext*)NativePtr)->getTranslationUnits(i);
    if (___ret == nullptr) return nullptr;
    return (___ret == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::TranslationUnit((class ::CppSharp::CppParser::AST::TranslationUnit*)___ret);
}

void CppSharp::Parser::AST::ASTContext::AddTranslationUnits(CppSharp::Parser::AST::TranslationUnit^ s)
{
    if (ReferenceEquals(s, nullptr))
        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
    auto __arg0 = (class ::CppSharp::CppParser::AST::TranslationUnit*)s->NativePtr;
    ((class ::CppSharp::CppParser::AST::ASTContext*)NativePtr)->addTranslationUnits(__arg0);
}

void CppSharp::Parser::AST::ASTContext::ClearTranslationUnits()
{
    ((class ::CppSharp::CppParser::AST::ASTContext*)NativePtr)->clearTranslationUnits();
}

CppSharp::Parser::AST::ASTContext::ASTContext(CppSharp::Parser::AST::ASTContext^ _0)
{
    __ownsNativeInstance = true;
    if (ReferenceEquals(_0, nullptr))
        throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
    auto &__arg0 = *(class ::CppSharp::CppParser::AST::ASTContext*)_0->NativePtr;
    NativePtr = new class ::CppSharp::CppParser::AST::ASTContext(__arg0);
}

::System::IntPtr CppSharp::Parser::AST::ASTContext::__Instance::get()
{
    return ::System::IntPtr(NativePtr);
}

void CppSharp::Parser::AST::ASTContext::__Instance::set(::System::IntPtr object)
{
    NativePtr = (class ::CppSharp::CppParser::AST::ASTContext*)object.ToPointer();
}

::System::Collections::Generic::List<CppSharp::Parser::AST::TranslationUnit^>^ CppSharp::Parser::AST::ASTContext::TranslationUnits::get()
{
    auto _tmp__TranslationUnits = gcnew ::System::Collections::Generic::List<CppSharp::Parser::AST::TranslationUnit^>();
    auto __list0 = NativePtr->TranslationUnits;
    for(auto _element : __list0)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew ::CppSharp::Parser::AST::TranslationUnit((class ::CppSharp::CppParser::AST::TranslationUnit*)_element);
        _tmp__TranslationUnits->Add(_marshalElement);
    }
    return _tmp__TranslationUnits;
}

void CppSharp::Parser::AST::ASTContext::TranslationUnits::set(::System::Collections::Generic::List<CppSharp::Parser::AST::TranslationUnit^>^ value)
{
    auto _tmpvalue = std::vector<::CppSharp::CppParser::AST::TranslationUnit*>();
    for each(CppSharp::Parser::AST::TranslationUnit^ _element in value)
    {
        auto _marshalElement = (class ::CppSharp::CppParser::AST::TranslationUnit*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((class ::CppSharp::CppParser::AST::ASTContext*)NativePtr)->TranslationUnits = _tmpvalue;
}

unsigned int CppSharp::Parser::AST::ASTContext::TranslationUnitsCount::get()
{
    auto ___ret = ((class ::CppSharp::CppParser::AST::ASTContext*)NativePtr)->getTranslationUnitsCount();
    return ___ret;
}