CppSharp/src/CppParser/Bindings/CLI/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(::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((::CppSharp::CppParser::AST::Declaration*) native.ToPointer());
}

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

CppSharp::Parser::AST::Declaration::Declaration(CppSharp::Parser::AST::DeclarationKind kind)
{
    __ownsNativeInstance = true;
    auto __arg0 = (::CppSharp::CppParser::AST::DeclarationKind)kind;
    NativePtr = new ::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 = *(::CppSharp::CppParser::AST::Declaration*)_0->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::Declaration(__arg0);
}

CppSharp::Parser::AST::PreprocessedEntity^ CppSharp::Parser::AST::Declaration::GetPreprocessedEntities(unsigned int i)
{
    auto __ret = ((::CppSharp::CppParser::AST::Declaration*)NativePtr)->getPreprocessedEntities(i);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::PreprocessedEntity((::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 = (::CppSharp::CppParser::AST::PreprocessedEntity*)s->NativePtr;
    ((::CppSharp::CppParser::AST::Declaration*)NativePtr)->addPreprocessedEntities(__arg0);
}

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

CppSharp::Parser::AST::Declaration^ CppSharp::Parser::AST::Declaration::GetRedeclarations(unsigned int i)
{
    auto __ret = ((::CppSharp::CppParser::AST::Declaration*)NativePtr)->getRedeclarations(i);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Declaration((::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 = (::CppSharp::CppParser::AST::Declaration*)s->NativePtr;
    ((::CppSharp::CppParser::AST::Declaration*)NativePtr)->addRedeclarations(__arg0);
}

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

CppSharp::Parser::AST::Declaration::operator CppSharp::Parser::AST::Declaration^(CppSharp::Parser::AST::DeclarationKind kind)
{
    auto __arg0 = (::CppSharp::CppParser::AST::DeclarationKind)kind;
    auto __ret = (::CppSharp::CppParser::AST::Declaration) __arg0;
    auto ____ret = new ::CppSharp::CppParser::AST::Declaration(__ret);
    return (____ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)____ret);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void CppSharp::Parser::AST::Declaration::Name::set(System::String^ value)
{
    ((::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>(((::CppSharp::CppParser::AST::Declaration*)NativePtr)->USR);
}

void CppSharp::Parser::AST::Declaration::USR::set(System::String^ value)
{
    ((::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>(((::CppSharp::CppParser::AST::Declaration*)NativePtr)->debugText);
}

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

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

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

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

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

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

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

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

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

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

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

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

void CppSharp::Parser::AST::Declaration::DefinitionOrder::set(unsigned int value)
{
    ((::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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::Declaration*)NativePtr)->PreprocessedEntities)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::PreprocessedEntity((::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 = (::CppSharp::CppParser::AST::PreprocessedEntity*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::Declaration*)NativePtr)->Redeclarations)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Declaration((::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 = (::CppSharp::CppParser::AST::Declaration*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::CppSharp::CppParser::AST::Declaration*)NativePtr)->Redeclarations = _tmpvalue;
}

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

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

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

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

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

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

CppSharp::Parser::AST::DeclarationContext::DeclarationContext(::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((::CppSharp::CppParser::AST::DeclarationContext*) native.ToPointer());
}

CppSharp::Parser::AST::DeclarationContext::~DeclarationContext()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (::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 = (::CppSharp::CppParser::AST::DeclarationKind)kind;
    NativePtr = new ::CppSharp::CppParser::AST::DeclarationContext(__arg0);
}

CppSharp::Parser::AST::Namespace^ CppSharp::Parser::AST::DeclarationContext::GetNamespaces(unsigned int i)
{
    auto __ret = ((::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->getNamespaces(i);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Namespace((::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 = (::CppSharp::CppParser::AST::Namespace*)s->NativePtr;
    ((::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->addNamespaces(__arg0);
}

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

CppSharp::Parser::AST::Enumeration^ CppSharp::Parser::AST::DeclarationContext::GetEnums(unsigned int i)
{
    auto __ret = ((::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->getEnums(i);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Enumeration((::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 = (::CppSharp::CppParser::AST::Enumeration*)s->NativePtr;
    ((::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->addEnums(__arg0);
}

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

CppSharp::Parser::AST::Function^ CppSharp::Parser::AST::DeclarationContext::GetFunctions(unsigned int i)
{
    auto __ret = ((::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->getFunctions(i);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Function((::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 = (::CppSharp::CppParser::AST::Function*)s->NativePtr;
    ((::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->addFunctions(__arg0);
}

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

CppSharp::Parser::AST::Class^ CppSharp::Parser::AST::DeclarationContext::GetClasses(unsigned int i)
{
    auto __ret = ((::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->getClasses(i);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::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 = (::CppSharp::CppParser::AST::Class*)s->NativePtr;
    ((::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->addClasses(__arg0);
}

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

CppSharp::Parser::AST::Template^ CppSharp::Parser::AST::DeclarationContext::GetTemplates(unsigned int i)
{
    auto __ret = ((::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->getTemplates(i);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Template((::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 = (::CppSharp::CppParser::AST::Template*)s->NativePtr;
    ((::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->addTemplates(__arg0);
}

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

CppSharp::Parser::AST::TypedefDecl^ CppSharp::Parser::AST::DeclarationContext::GetTypedefs(unsigned int i)
{
    auto __ret = ((::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->getTypedefs(i);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::TypedefDecl((::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 = (::CppSharp::CppParser::AST::TypedefDecl*)s->NativePtr;
    ((::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->addTypedefs(__arg0);
}

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

CppSharp::Parser::AST::TypeAlias^ CppSharp::Parser::AST::DeclarationContext::GetTypeAliases(unsigned int i)
{
    auto __ret = ((::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->getTypeAliases(i);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::TypeAlias((::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 = (::CppSharp::CppParser::AST::TypeAlias*)s->NativePtr;
    ((::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->addTypeAliases(__arg0);
}

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

CppSharp::Parser::AST::Variable^ CppSharp::Parser::AST::DeclarationContext::GetVariables(unsigned int i)
{
    auto __ret = ((::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->getVariables(i);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Variable((::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 = (::CppSharp::CppParser::AST::Variable*)s->NativePtr;
    ((::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->addVariables(__arg0);
}

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

CppSharp::Parser::AST::Friend^ CppSharp::Parser::AST::DeclarationContext::GetFriends(unsigned int i)
{
    auto __ret = ((::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->getFriends(i);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Friend((::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 = (::CppSharp::CppParser::AST::Friend*)s->NativePtr;
    ((::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->addFriends(__arg0);
}

void CppSharp::Parser::AST::DeclarationContext::ClearFriends()
{
    ((::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 = *(::CppSharp::CppParser::AST::DeclarationContext*)_0->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::DeclarationContext(__arg0);
}

CppSharp::Parser::AST::DeclarationContext::operator CppSharp::Parser::AST::DeclarationContext^(CppSharp::Parser::AST::DeclarationKind kind)
{
    auto __arg0 = (::CppSharp::CppParser::AST::DeclarationKind)kind;
    auto __ret = (::CppSharp::CppParser::AST::DeclarationContext) __arg0;
    auto ____ret = new ::CppSharp::CppParser::AST::DeclarationContext(__ret);
    return (____ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::DeclarationContext((::CppSharp::CppParser::AST::DeclarationContext*)____ret);
}

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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->Namespaces)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Namespace((::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 = (::CppSharp::CppParser::AST::Namespace*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->Enums)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Enumeration((::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 = (::CppSharp::CppParser::AST::Enumeration*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->Functions)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Function((::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 = (::CppSharp::CppParser::AST::Function*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->Classes)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::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 = (::CppSharp::CppParser::AST::Class*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->Templates)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Template((::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 = (::CppSharp::CppParser::AST::Template*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->Typedefs)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::TypedefDecl((::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 = (::CppSharp::CppParser::AST::TypedefDecl*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->TypeAliases)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::TypeAlias((::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 = (::CppSharp::CppParser::AST::TypeAlias*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->Variables)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Variable((::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 = (::CppSharp::CppParser::AST::Variable*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->Friends)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Friend((::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 = (::CppSharp::CppParser::AST::Friend*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::CppSharp::CppParser::AST::DeclarationContext*)NativePtr)->Friends = _tmpvalue;
}

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

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

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

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

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

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

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

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

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

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

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

CppSharp::Parser::AST::TypedefNameDecl::TypedefNameDecl(::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((::CppSharp::CppParser::AST::TypedefNameDecl*) native.ToPointer());
}

CppSharp::Parser::AST::TypedefNameDecl::~TypedefNameDecl()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (::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 = (::CppSharp::CppParser::AST::DeclarationKind)kind;
    NativePtr = new ::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 = *(::CppSharp::CppParser::AST::TypedefNameDecl*)_0->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::TypedefNameDecl(__arg0);
}

CppSharp::Parser::AST::TypedefNameDecl::operator CppSharp::Parser::AST::TypedefNameDecl^(CppSharp::Parser::AST::DeclarationKind kind)
{
    auto __arg0 = (::CppSharp::CppParser::AST::DeclarationKind)kind;
    auto __ret = (::CppSharp::CppParser::AST::TypedefNameDecl) __arg0;
    auto ____ret = new ::CppSharp::CppParser::AST::TypedefNameDecl(__ret);
    return (____ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::TypedefNameDecl((::CppSharp::CppParser::AST::TypedefNameDecl*)____ret);
}

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

void CppSharp::Parser::AST::TypedefNameDecl::QualifiedType::set(CppSharp::Parser::AST::QualifiedType^ value)
{
    ((::CppSharp::CppParser::AST::TypedefNameDecl*)NativePtr)->qualifiedType = *(::CppSharp::CppParser::AST::QualifiedType*)value->NativePtr;
}

CppSharp::Parser::AST::TypedefDecl::TypedefDecl(::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((::CppSharp::CppParser::AST::TypedefDecl*) native.ToPointer());
}

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

CppSharp::Parser::AST::TypedefDecl::TypedefDecl()
    : CppSharp::Parser::AST::TypedefNameDecl((::CppSharp::CppParser::AST::TypedefNameDecl*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new ::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 = *(::CppSharp::CppParser::AST::TypedefDecl*)_0->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::TypedefDecl(__arg0);
}

CppSharp::Parser::AST::TypeAlias::TypeAlias(::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((::CppSharp::CppParser::AST::TypeAlias*) native.ToPointer());
}

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

CppSharp::Parser::AST::TypeAlias::TypeAlias()
    : CppSharp::Parser::AST::TypedefNameDecl((::CppSharp::CppParser::AST::TypedefNameDecl*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new ::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 = *(::CppSharp::CppParser::AST::TypeAlias*)_0->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::TypeAlias(__arg0);
}

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

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

CppSharp::Parser::AST::Friend::Friend(::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((::CppSharp::CppParser::AST::Friend*) native.ToPointer());
}

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

CppSharp::Parser::AST::Friend::Friend()
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new ::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 = *(::CppSharp::CppParser::AST::Friend*)_0->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::Friend(__arg0);
}

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

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

CppSharp::Parser::AST::StatementObsolete::StatementObsolete(::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((::CppSharp::CppParser::AST::StatementObsolete*) native.ToPointer());
}

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 = (::CppSharp::CppParser::AST::StatementClassObsolete)Class;
    auto __arg2 = (::CppSharp::CppParser::AST::Declaration*)decl->NativePtr;
    NativePtr = new ::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 = *(::CppSharp::CppParser::AST::StatementObsolete*)_0->NativePtr;
    NativePtr = new ::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 = (::CppSharp::CppParser::AST::StatementObsolete*)object.ToPointer();
}

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

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

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

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

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

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

CppSharp::Parser::AST::ExpressionObsolete::ExpressionObsolete(::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((::CppSharp::CppParser::AST::ExpressionObsolete*) native.ToPointer());
}

CppSharp::Parser::AST::ExpressionObsolete::~ExpressionObsolete()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (::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 = (::CppSharp::CppParser::AST::StatementClassObsolete)Class;
    auto __arg2 = (::CppSharp::CppParser::AST::Declaration*)decl->NativePtr;
    NativePtr = new ::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 = *(::CppSharp::CppParser::AST::ExpressionObsolete*)_0->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::ExpressionObsolete(__arg0);
}

CppSharp::Parser::AST::BinaryOperatorObsolete::BinaryOperatorObsolete(::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((::CppSharp::CppParser::AST::BinaryOperatorObsolete*) native.ToPointer());
}

CppSharp::Parser::AST::BinaryOperatorObsolete::~BinaryOperatorObsolete()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (::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 = (::CppSharp::CppParser::AST::ExpressionObsolete*)lhs->NativePtr;
    auto __arg2 = (::CppSharp::CppParser::AST::ExpressionObsolete*)rhs->NativePtr;
    auto __arg3 = clix::marshalString<clix::E_UTF8>(opcodeStr);
    NativePtr = new ::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 = *(::CppSharp::CppParser::AST::BinaryOperatorObsolete*)_0->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::BinaryOperatorObsolete(__arg0);
}

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

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

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

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

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

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

CppSharp::Parser::AST::CallExprObsolete::CallExprObsolete(::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((::CppSharp::CppParser::AST::CallExprObsolete*) native.ToPointer());
}

CppSharp::Parser::AST::CallExprObsolete::~CallExprObsolete()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (::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 = (::CppSharp::CppParser::AST::Declaration*)decl->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::CallExprObsolete(__arg0, __arg1);
}

CppSharp::Parser::AST::ExpressionObsolete^ CppSharp::Parser::AST::CallExprObsolete::GetArguments(unsigned int i)
{
    auto __ret = ((::CppSharp::CppParser::AST::CallExprObsolete*)NativePtr)->getArguments(i);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::ExpressionObsolete((::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 = (::CppSharp::CppParser::AST::ExpressionObsolete*)s->NativePtr;
    ((::CppSharp::CppParser::AST::CallExprObsolete*)NativePtr)->addArguments(__arg0);
}

void CppSharp::Parser::AST::CallExprObsolete::ClearArguments()
{
    ((::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 = *(::CppSharp::CppParser::AST::CallExprObsolete*)_0->NativePtr;
    NativePtr = new ::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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::CallExprObsolete*)NativePtr)->Arguments)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::ExpressionObsolete((::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 = (::CppSharp::CppParser::AST::ExpressionObsolete*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::CppSharp::CppParser::AST::CallExprObsolete*)NativePtr)->Arguments = _tmpvalue;
}

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

CppSharp::Parser::AST::CXXConstructExprObsolete::CXXConstructExprObsolete(::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((::CppSharp::CppParser::AST::CXXConstructExprObsolete*) native.ToPointer());
}

CppSharp::Parser::AST::CXXConstructExprObsolete::~CXXConstructExprObsolete()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (::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 = (::CppSharp::CppParser::AST::Declaration*)decl->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::CXXConstructExprObsolete(__arg0, __arg1);
}

CppSharp::Parser::AST::ExpressionObsolete^ CppSharp::Parser::AST::CXXConstructExprObsolete::GetArguments(unsigned int i)
{
    auto __ret = ((::CppSharp::CppParser::AST::CXXConstructExprObsolete*)NativePtr)->getArguments(i);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::ExpressionObsolete((::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 = (::CppSharp::CppParser::AST::ExpressionObsolete*)s->NativePtr;
    ((::CppSharp::CppParser::AST::CXXConstructExprObsolete*)NativePtr)->addArguments(__arg0);
}

void CppSharp::Parser::AST::CXXConstructExprObsolete::ClearArguments()
{
    ((::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 = *(::CppSharp::CppParser::AST::CXXConstructExprObsolete*)_0->NativePtr;
    NativePtr = new ::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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::CXXConstructExprObsolete*)NativePtr)->Arguments)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::ExpressionObsolete((::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 = (::CppSharp::CppParser::AST::ExpressionObsolete*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::CppSharp::CppParser::AST::CXXConstructExprObsolete*)NativePtr)->Arguments = _tmpvalue;
}

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

CppSharp::Parser::AST::Parameter::Parameter(::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((::CppSharp::CppParser::AST::Parameter*) native.ToPointer());
}

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

CppSharp::Parser::AST::Parameter::Parameter()
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new ::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 = *(::CppSharp::CppParser::AST::Parameter*)_0->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::Parameter(__arg0);
}

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

void CppSharp::Parser::AST::Parameter::QualifiedType::set(CppSharp::Parser::AST::QualifiedType^ value)
{
    ((::CppSharp::CppParser::AST::Parameter*)NativePtr)->qualifiedType = *(::CppSharp::CppParser::AST::QualifiedType*)value->NativePtr;
}

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

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

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

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

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

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

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

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

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

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

CppSharp::Parser::AST::Function::Function(::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((::CppSharp::CppParser::AST::Function*) native.ToPointer());
}

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

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

CppSharp::Parser::AST::Parameter^ CppSharp::Parser::AST::Function::GetParameters(unsigned int i)
{
    auto __ret = ((::CppSharp::CppParser::AST::Function*)NativePtr)->getParameters(i);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Parameter((::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 = (::CppSharp::CppParser::AST::Parameter*)s->NativePtr;
    ((::CppSharp::CppParser::AST::Function*)NativePtr)->addParameters(__arg0);
}

void CppSharp::Parser::AST::Function::ClearParameters()
{
    ((::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 = *(::CppSharp::CppParser::AST::Function*)_0->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::Function(__arg0);
}

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

void CppSharp::Parser::AST::Function::ReturnType::set(CppSharp::Parser::AST::QualifiedType^ value)
{
    ((::CppSharp::CppParser::AST::Function*)NativePtr)->returnType = *(::CppSharp::CppParser::AST::QualifiedType*)value->NativePtr;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void CppSharp::Parser::AST::Function::Mangled::set(System::String^ value)
{
    ((::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>(((::CppSharp::CppParser::AST::Function*)NativePtr)->signature);
}

void CppSharp::Parser::AST::Function::Signature::set(System::String^ value)
{
    ((::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>(((::CppSharp::CppParser::AST::Function*)NativePtr)->body);
}

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

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

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

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

void CppSharp::Parser::AST::Function::CallingConvention::set(CppSharp::Parser::AST::CallingConvention value)
{
    ((::CppSharp::CppParser::AST::Function*)NativePtr)->callingConvention = (::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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::Function*)NativePtr)->Parameters)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Parameter((::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 = (::CppSharp::CppParser::AST::Parameter*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::CppSharp::CppParser::AST::Function*)NativePtr)->Parameters = _tmpvalue;
}

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

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

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

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

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

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

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

CppSharp::Parser::AST::Method::Method(::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((::CppSharp::CppParser::AST::Method*) native.ToPointer());
}

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

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

CppSharp::Parser::AST::Method^ CppSharp::Parser::AST::Method::GetOverriddenMethods(unsigned int i)
{
    auto __ret = ((::CppSharp::CppParser::AST::Method*)NativePtr)->getOverriddenMethods(i);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Method((::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 = (::CppSharp::CppParser::AST::Method*)s->NativePtr;
    ((::CppSharp::CppParser::AST::Method*)NativePtr)->addOverriddenMethods(__arg0);
}

void CppSharp::Parser::AST::Method::ClearOverriddenMethods()
{
    ((::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 = *(::CppSharp::CppParser::AST::Method*)_0->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::Method(__arg0);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void CppSharp::Parser::AST::Method::ConversionType::set(CppSharp::Parser::AST::QualifiedType^ value)
{
    ((::CppSharp::CppParser::AST::Method*)NativePtr)->conversionType = *(::CppSharp::CppParser::AST::QualifiedType*)value->NativePtr;
}

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

void CppSharp::Parser::AST::Method::RefQualifier::set(CppSharp::Parser::AST::RefQualifierKind value)
{
    ((::CppSharp::CppParser::AST::Method*)NativePtr)->refQualifier = (::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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::Method*)NativePtr)->OverriddenMethods)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Method((::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 = (::CppSharp::CppParser::AST::Method*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::CppSharp::CppParser::AST::Method*)NativePtr)->OverriddenMethods = _tmpvalue;
}

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

CppSharp::Parser::AST::Enumeration::Item::Item(::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((::CppSharp::CppParser::AST::Enumeration::Item*) native.ToPointer());
}

CppSharp::Parser::AST::Enumeration::Item::~Item()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (::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 ::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 = *(::CppSharp::CppParser::AST::Enumeration::Item*)_0->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::Enumeration::Item(__arg0);
}

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

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

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

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

CppSharp::Parser::AST::Enumeration::Enumeration(::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((::CppSharp::CppParser::AST::Enumeration*) native.ToPointer());
}

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

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

CppSharp::Parser::AST::Enumeration::Item^ CppSharp::Parser::AST::Enumeration::GetItems(unsigned int i)
{
    auto __ret = ((::CppSharp::CppParser::AST::Enumeration*)NativePtr)->getItems(i);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Enumeration::Item((::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 = (::CppSharp::CppParser::AST::Enumeration::Item*)s->NativePtr;
    ((::CppSharp::CppParser::AST::Enumeration*)NativePtr)->addItems(__arg0);
}

void CppSharp::Parser::AST::Enumeration::ClearItems()
{
    ((::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 = ((::CppSharp::CppParser::AST::Enumeration*)NativePtr)->FindItemByName(__arg0);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Enumeration::Item((::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 = *(::CppSharp::CppParser::AST::Enumeration*)_0->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::Enumeration(__arg0);
}

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

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

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

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

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

void CppSharp::Parser::AST::Enumeration::BuiltinType::set(CppSharp::Parser::AST::BuiltinType^ value)
{
    ((::CppSharp::CppParser::AST::Enumeration*)NativePtr)->builtinType = (::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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::Enumeration*)NativePtr)->Items)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Enumeration::Item((::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 = (::CppSharp::CppParser::AST::Enumeration::Item*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::CppSharp::CppParser::AST::Enumeration*)NativePtr)->Items = _tmpvalue;
}

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

CppSharp::Parser::AST::Variable::Variable(::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((::CppSharp::CppParser::AST::Variable*) native.ToPointer());
}

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

CppSharp::Parser::AST::Variable::Variable()
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new ::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 = *(::CppSharp::CppParser::AST::Variable*)_0->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::Variable(__arg0);
}

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

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

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

void CppSharp::Parser::AST::Variable::QualifiedType::set(CppSharp::Parser::AST::QualifiedType^ value)
{
    ((::CppSharp::CppParser::AST::Variable*)NativePtr)->qualifiedType = *(::CppSharp::CppParser::AST::QualifiedType*)value->NativePtr;
}

CppSharp::Parser::AST::BaseClassSpecifier::BaseClassSpecifier(::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((::CppSharp::CppParser::AST::BaseClassSpecifier*) native.ToPointer());
}

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

CppSharp::Parser::AST::BaseClassSpecifier::BaseClassSpecifier()
{
    __ownsNativeInstance = true;
    NativePtr = new ::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 = *(::CppSharp::CppParser::AST::BaseClassSpecifier*)_0->NativePtr;
    NativePtr = new ::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 = (::CppSharp::CppParser::AST::BaseClassSpecifier*)object.ToPointer();
}

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

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

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

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

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

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

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

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

CppSharp::Parser::AST::Field::Field(::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((::CppSharp::CppParser::AST::Field*) native.ToPointer());
}

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

CppSharp::Parser::AST::Field::Field()
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new ::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 = *(::CppSharp::CppParser::AST::Field*)_0->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::Field(__arg0);
}

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

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

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

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

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

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

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

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

CppSharp::Parser::AST::AccessSpecifierDecl::AccessSpecifierDecl(::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((::CppSharp::CppParser::AST::AccessSpecifierDecl*) native.ToPointer());
}

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

CppSharp::Parser::AST::AccessSpecifierDecl::AccessSpecifierDecl()
    : CppSharp::Parser::AST::Declaration((::CppSharp::CppParser::AST::Declaration*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new ::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 = *(::CppSharp::CppParser::AST::AccessSpecifierDecl*)_0->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::AccessSpecifierDecl(__arg0);
}

CppSharp::Parser::AST::VTableComponent::VTableComponent(::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((::CppSharp::CppParser::AST::VTableComponent*) native.ToPointer());
}

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

CppSharp::Parser::AST::VTableComponent::VTableComponent()
{
    __ownsNativeInstance = true;
    NativePtr = new ::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 = *(::CppSharp::CppParser::AST::VTableComponent*)_0->NativePtr;
    NativePtr = new ::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 = (::CppSharp::CppParser::AST::VTableComponent*)object.ToPointer();
}

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

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

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

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

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

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

CppSharp::Parser::AST::VTableLayout::VTableLayout(::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((::CppSharp::CppParser::AST::VTableLayout*) native.ToPointer());
}

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

CppSharp::Parser::AST::VTableLayout::VTableLayout()
{
    __ownsNativeInstance = true;
    NativePtr = new ::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 = *(::CppSharp::CppParser::AST::VTableLayout*)_0->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::VTableLayout(__arg0);
}

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

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 = *(::CppSharp::CppParser::AST::VTableComponent*)s->NativePtr;
    ((::CppSharp::CppParser::AST::VTableLayout*)NativePtr)->addComponents(__arg0);
}

void CppSharp::Parser::AST::VTableLayout::ClearComponents()
{
    ((::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 = (::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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::VTableLayout*)NativePtr)->Components)
    {
        auto ___element = new ::CppSharp::CppParser::AST::VTableComponent(_element);
        auto _marshalElement = (___element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::VTableComponent((::CppSharp::CppParser::AST::VTableComponent*)___element);
        _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)
    {
        auto _marshalElement = *(::CppSharp::CppParser::AST::VTableComponent*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::CppSharp::CppParser::AST::VTableLayout*)NativePtr)->Components = _tmpvalue;
}

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

CppSharp::Parser::AST::VFTableInfo::VFTableInfo(::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((::CppSharp::CppParser::AST::VFTableInfo*) native.ToPointer());
}

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

CppSharp::Parser::AST::VFTableInfo::VFTableInfo()
{
    __ownsNativeInstance = true;
    NativePtr = new ::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 = *(::CppSharp::CppParser::AST::VFTableInfo*)_0->NativePtr;
    NativePtr = new ::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 = (::CppSharp::CppParser::AST::VFTableInfo*)object.ToPointer();
}

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

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

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

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

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

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

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

void CppSharp::Parser::AST::VFTableInfo::Layout::set(CppSharp::Parser::AST::VTableLayout^ value)
{
    ((::CppSharp::CppParser::AST::VFTableInfo*)NativePtr)->layout = *(::CppSharp::CppParser::AST::VTableLayout*)value->NativePtr;
}

CppSharp::Parser::AST::LayoutField::LayoutField(::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((::CppSharp::CppParser::AST::LayoutField*) native.ToPointer());
}

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

CppSharp::Parser::AST::LayoutField::LayoutField()
{
    __ownsNativeInstance = true;
    NativePtr = new ::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 = *(::CppSharp::CppParser::AST::LayoutField*)other->NativePtr;
    NativePtr = new ::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 = (::CppSharp::CppParser::AST::LayoutField*)object.ToPointer();
}

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

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

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

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

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

void CppSharp::Parser::AST::LayoutField::QualifiedType::set(CppSharp::Parser::AST::QualifiedType^ value)
{
    ((::CppSharp::CppParser::AST::LayoutField*)NativePtr)->qualifiedType = *(::CppSharp::CppParser::AST::QualifiedType*)value->NativePtr;
}

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

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

CppSharp::Parser::AST::LayoutBase::LayoutBase(::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((::CppSharp::CppParser::AST::LayoutBase*) native.ToPointer());
}

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

CppSharp::Parser::AST::LayoutBase::LayoutBase()
{
    __ownsNativeInstance = true;
    NativePtr = new ::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 = *(::CppSharp::CppParser::AST::LayoutBase*)other->NativePtr;
    NativePtr = new ::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 = (::CppSharp::CppParser::AST::LayoutBase*)object.ToPointer();
}

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

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

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

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

CppSharp::Parser::AST::ClassLayout::ClassLayout(::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((::CppSharp::CppParser::AST::ClassLayout*) native.ToPointer());
}

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

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

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

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 = *(::CppSharp::CppParser::AST::VFTableInfo*)s->NativePtr;
    ((::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->addVFTables(__arg0);
}

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

CppSharp::Parser::AST::LayoutField^ CppSharp::Parser::AST::ClassLayout::GetFields(unsigned int i)
{
    auto __ret = ((::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->getFields(i);
    auto ____ret = new ::CppSharp::CppParser::AST::LayoutField(__ret);
    return (____ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::LayoutField((::CppSharp::CppParser::AST::LayoutField*)____ret);
}

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 = *(::CppSharp::CppParser::AST::LayoutField*)s->NativePtr;
    ((::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->addFields(__arg0);
}

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

CppSharp::Parser::AST::LayoutBase^ CppSharp::Parser::AST::ClassLayout::GetBases(unsigned int i)
{
    auto __ret = ((::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->getBases(i);
    auto ____ret = new ::CppSharp::CppParser::AST::LayoutBase(__ret);
    return (____ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::LayoutBase((::CppSharp::CppParser::AST::LayoutBase*)____ret);
}

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 = *(::CppSharp::CppParser::AST::LayoutBase*)s->NativePtr;
    ((::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->addBases(__arg0);
}

void CppSharp::Parser::AST::ClassLayout::ClearBases()
{
    ((::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 = *(::CppSharp::CppParser::AST::ClassLayout*)_0->NativePtr;
    NativePtr = new ::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 = (::CppSharp::CppParser::AST::ClassLayout*)object.ToPointer();
}

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

void CppSharp::Parser::AST::ClassLayout::ABI::set(CppSharp::Parser::AST::CppAbi value)
{
    ((::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->ABI = (::CppSharp::CppParser::AST::CppAbi)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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->VFTables)
    {
        auto ___element = new ::CppSharp::CppParser::AST::VFTableInfo(_element);
        auto _marshalElement = (___element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::VFTableInfo((::CppSharp::CppParser::AST::VFTableInfo*)___element);
        _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)
    {
        auto _marshalElement = *(::CppSharp::CppParser::AST::VFTableInfo*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->VFTables = _tmpvalue;
}

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

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

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

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

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

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

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

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

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

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

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

void CppSharp::Parser::AST::ClassLayout::DataSize::set(int value)
{
    ((::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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->Fields)
    {
        auto ___element = new ::CppSharp::CppParser::AST::LayoutField(_element);
        auto _marshalElement = (___element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::LayoutField((::CppSharp::CppParser::AST::LayoutField*)___element);
        _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)
    {
        auto _marshalElement = *(::CppSharp::CppParser::AST::LayoutField*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->Bases)
    {
        auto ___element = new ::CppSharp::CppParser::AST::LayoutBase(_element);
        auto _marshalElement = (___element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::LayoutBase((::CppSharp::CppParser::AST::LayoutBase*)___element);
        _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)
    {
        auto _marshalElement = *(::CppSharp::CppParser::AST::LayoutBase*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::CppSharp::CppParser::AST::ClassLayout*)NativePtr)->Bases = _tmpvalue;
}

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

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

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

CppSharp::Parser::AST::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((::CppSharp::CppParser::AST::Class*) native.ToPointer());
}

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

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

CppSharp::Parser::AST::BaseClassSpecifier^ CppSharp::Parser::AST::Class::GetBases(unsigned int i)
{
    auto __ret = ((::CppSharp::CppParser::AST::Class*)NativePtr)->getBases(i);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::BaseClassSpecifier((::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 = (::CppSharp::CppParser::AST::BaseClassSpecifier*)s->NativePtr;
    ((::CppSharp::CppParser::AST::Class*)NativePtr)->addBases(__arg0);
}

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

CppSharp::Parser::AST::Field^ CppSharp::Parser::AST::Class::GetFields(unsigned int i)
{
    auto __ret = ((::CppSharp::CppParser::AST::Class*)NativePtr)->getFields(i);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Field((::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 = (::CppSharp::CppParser::AST::Field*)s->NativePtr;
    ((::CppSharp::CppParser::AST::Class*)NativePtr)->addFields(__arg0);
}

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

CppSharp::Parser::AST::Method^ CppSharp::Parser::AST::Class::GetMethods(unsigned int i)
{
    auto __ret = ((::CppSharp::CppParser::AST::Class*)NativePtr)->getMethods(i);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Method((::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 = (::CppSharp::CppParser::AST::Method*)s->NativePtr;
    ((::CppSharp::CppParser::AST::Class*)NativePtr)->addMethods(__arg0);
}

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

CppSharp::Parser::AST::AccessSpecifierDecl^ CppSharp::Parser::AST::Class::GetSpecifiers(unsigned int i)
{
    auto __ret = ((::CppSharp::CppParser::AST::Class*)NativePtr)->getSpecifiers(i);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::AccessSpecifierDecl((::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 = (::CppSharp::CppParser::AST::AccessSpecifierDecl*)s->NativePtr;
    ((::CppSharp::CppParser::AST::Class*)NativePtr)->addSpecifiers(__arg0);
}

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

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 = *(::CppSharp::CppParser::AST::Class*)_0->NativePtr;
    NativePtr = new ::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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::Class*)NativePtr)->Bases)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::BaseClassSpecifier((::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 = (::CppSharp::CppParser::AST::BaseClassSpecifier*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::Class*)NativePtr)->Fields)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Field((::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 = (::CppSharp::CppParser::AST::Field*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::Class*)NativePtr)->Methods)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Method((::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 = (::CppSharp::CppParser::AST::Method*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::Class*)NativePtr)->Specifiers)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::AccessSpecifierDecl((::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 = (::CppSharp::CppParser::AST::AccessSpecifierDecl*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::CppSharp::CppParser::AST::Class*)NativePtr)->Specifiers = _tmpvalue;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

CppSharp::Parser::AST::Template::Template(::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((::CppSharp::CppParser::AST::Template*) native.ToPointer());
}

CppSharp::Parser::AST::Template::~Template()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (::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 = (::CppSharp::CppParser::AST::DeclarationKind)kind;
    NativePtr = new ::CppSharp::CppParser::AST::Template(__arg0);
}

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

CppSharp::Parser::AST::Declaration^ CppSharp::Parser::AST::Template::GetParameters(unsigned int i)
{
    auto __ret = ((::CppSharp::CppParser::AST::Template*)NativePtr)->getParameters(i);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Declaration((::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 = (::CppSharp::CppParser::AST::Declaration*)s->NativePtr;
    ((::CppSharp::CppParser::AST::Template*)NativePtr)->addParameters(__arg0);
}

void CppSharp::Parser::AST::Template::ClearParameters()
{
    ((::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 = *(::CppSharp::CppParser::AST::Template*)_0->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::Template(__arg0);
}

CppSharp::Parser::AST::Template::operator CppSharp::Parser::AST::Template^(CppSharp::Parser::AST::DeclarationKind kind)
{
    auto __arg0 = (::CppSharp::CppParser::AST::DeclarationKind)kind;
    auto __ret = (::CppSharp::CppParser::AST::Template) __arg0;
    auto ____ret = new ::CppSharp::CppParser::AST::Template(__ret);
    return (____ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)____ret);
}

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

void CppSharp::Parser::AST::Template::TemplatedDecl::set(CppSharp::Parser::AST::Declaration^ value)
{
    ((::CppSharp::CppParser::AST::Template*)NativePtr)->TemplatedDecl = (::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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::Template*)NativePtr)->Parameters)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Declaration((::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 = (::CppSharp::CppParser::AST::Declaration*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::CppSharp::CppParser::AST::Template*)NativePtr)->Parameters = _tmpvalue;
}

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

CppSharp::Parser::AST::TypeAliasTemplate::TypeAliasTemplate(::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((::CppSharp::CppParser::AST::TypeAliasTemplate*) native.ToPointer());
}

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

CppSharp::Parser::AST::TypeAliasTemplate::TypeAliasTemplate()
    : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new ::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 = *(::CppSharp::CppParser::AST::TypeAliasTemplate*)_0->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::TypeAliasTemplate(__arg0);
}

CppSharp::Parser::AST::TemplateParameter::TemplateParameter(::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((::CppSharp::CppParser::AST::TemplateParameter*) native.ToPointer());
}

CppSharp::Parser::AST::TemplateParameter::~TemplateParameter()
{
    if (NativePtr)
    {
        auto __nativePtr = NativePtr;
        NativePtr = 0;
        delete (::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 = (::CppSharp::CppParser::AST::DeclarationKind)kind;
    NativePtr = new ::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 = *(::CppSharp::CppParser::AST::TemplateParameter*)_0->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::TemplateParameter(__arg0);
}

CppSharp::Parser::AST::TemplateParameter::operator CppSharp::Parser::AST::TemplateParameter^(CppSharp::Parser::AST::DeclarationKind kind)
{
    auto __arg0 = (::CppSharp::CppParser::AST::DeclarationKind)kind;
    auto __ret = (::CppSharp::CppParser::AST::TemplateParameter) __arg0;
    auto ____ret = new ::CppSharp::CppParser::AST::TemplateParameter(__ret);
    return (____ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::TemplateParameter((::CppSharp::CppParser::AST::TemplateParameter*)____ret);
}

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

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

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

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

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

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

CppSharp::Parser::AST::TemplateTemplateParameter::TemplateTemplateParameter(::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((::CppSharp::CppParser::AST::TemplateTemplateParameter*) native.ToPointer());
}

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

CppSharp::Parser::AST::TemplateTemplateParameter::TemplateTemplateParameter()
    : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new ::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 = *(::CppSharp::CppParser::AST::TemplateTemplateParameter*)_0->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::TemplateTemplateParameter(__arg0);
}

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

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

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

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

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

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

CppSharp::Parser::AST::TypeTemplateParameter::TypeTemplateParameter(::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((::CppSharp::CppParser::AST::TypeTemplateParameter*) native.ToPointer());
}

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

CppSharp::Parser::AST::TypeTemplateParameter::TypeTemplateParameter()
    : CppSharp::Parser::AST::TemplateParameter((::CppSharp::CppParser::AST::TemplateParameter*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new ::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 = *(::CppSharp::CppParser::AST::TypeTemplateParameter*)_0->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::TypeTemplateParameter(__arg0);
}

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

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

CppSharp::Parser::AST::NonTypeTemplateParameter::NonTypeTemplateParameter(::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((::CppSharp::CppParser::AST::NonTypeTemplateParameter*) native.ToPointer());
}

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

CppSharp::Parser::AST::NonTypeTemplateParameter::NonTypeTemplateParameter()
    : CppSharp::Parser::AST::TemplateParameter((::CppSharp::CppParser::AST::TemplateParameter*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new ::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 = *(::CppSharp::CppParser::AST::NonTypeTemplateParameter*)_0->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::NonTypeTemplateParameter(__arg0);
}

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

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

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

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

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

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

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

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

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

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

CppSharp::Parser::AST::ClassTemplate::ClassTemplate(::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((::CppSharp::CppParser::AST::ClassTemplate*) native.ToPointer());
}

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

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

CppSharp::Parser::AST::ClassTemplateSpecialization^ CppSharp::Parser::AST::ClassTemplate::GetSpecializations(unsigned int i)
{
    auto __ret = ((::CppSharp::CppParser::AST::ClassTemplate*)NativePtr)->getSpecializations(i);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::ClassTemplateSpecialization((::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 = (::CppSharp::CppParser::AST::ClassTemplateSpecialization*)s->NativePtr;
    ((::CppSharp::CppParser::AST::ClassTemplate*)NativePtr)->addSpecializations(__arg0);
}

void CppSharp::Parser::AST::ClassTemplate::ClearSpecializations()
{
    ((::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 = ((::CppSharp::CppParser::AST::ClassTemplate*)NativePtr)->FindSpecialization(__arg0);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::ClassTemplateSpecialization((::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 = ((::CppSharp::CppParser::AST::ClassTemplate*)NativePtr)->FindPartialSpecialization(__arg0);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::ClassTemplatePartialSpecialization((::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 = *(::CppSharp::CppParser::AST::ClassTemplate*)_0->NativePtr;
    NativePtr = new ::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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::ClassTemplate*)NativePtr)->Specializations)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::ClassTemplateSpecialization((::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 = (::CppSharp::CppParser::AST::ClassTemplateSpecialization*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::CppSharp::CppParser::AST::ClassTemplate*)NativePtr)->Specializations = _tmpvalue;
}

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

CppSharp::Parser::AST::ClassTemplateSpecialization::ClassTemplateSpecialization(::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((::CppSharp::CppParser::AST::ClassTemplateSpecialization*) native.ToPointer());
}

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

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

CppSharp::Parser::AST::TemplateArgument^ CppSharp::Parser::AST::ClassTemplateSpecialization::GetArguments(unsigned int i)
{
    auto __ret = ((::CppSharp::CppParser::AST::ClassTemplateSpecialization*)NativePtr)->getArguments(i);
    auto ____ret = new ::CppSharp::CppParser::AST::TemplateArgument(__ret);
    return (____ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::TemplateArgument((::CppSharp::CppParser::AST::TemplateArgument*)____ret);
}

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 = *(::CppSharp::CppParser::AST::TemplateArgument*)s->NativePtr;
    ((::CppSharp::CppParser::AST::ClassTemplateSpecialization*)NativePtr)->addArguments(__arg0);
}

void CppSharp::Parser::AST::ClassTemplateSpecialization::ClearArguments()
{
    ((::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 = *(::CppSharp::CppParser::AST::ClassTemplateSpecialization*)_0->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::ClassTemplateSpecialization(__arg0);
}

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

void CppSharp::Parser::AST::ClassTemplateSpecialization::TemplatedDecl::set(CppSharp::Parser::AST::ClassTemplate^ value)
{
    ((::CppSharp::CppParser::AST::ClassTemplateSpecialization*)NativePtr)->templatedDecl = (::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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::ClassTemplateSpecialization*)NativePtr)->Arguments)
    {
        auto ___element = new ::CppSharp::CppParser::AST::TemplateArgument(_element);
        auto _marshalElement = (___element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::TemplateArgument((::CppSharp::CppParser::AST::TemplateArgument*)___element);
        _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)
    {
        auto _marshalElement = *(::CppSharp::CppParser::AST::TemplateArgument*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::CppSharp::CppParser::AST::ClassTemplateSpecialization*)NativePtr)->Arguments = _tmpvalue;
}

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

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

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

CppSharp::Parser::AST::ClassTemplatePartialSpecialization::ClassTemplatePartialSpecialization(::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((::CppSharp::CppParser::AST::ClassTemplatePartialSpecialization*) native.ToPointer());
}

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

CppSharp::Parser::AST::ClassTemplatePartialSpecialization::ClassTemplatePartialSpecialization()
    : CppSharp::Parser::AST::ClassTemplateSpecialization((::CppSharp::CppParser::AST::ClassTemplateSpecialization*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new ::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 = *(::CppSharp::CppParser::AST::ClassTemplatePartialSpecialization*)_0->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::ClassTemplatePartialSpecialization(__arg0);
}

CppSharp::Parser::AST::FunctionTemplate::FunctionTemplate(::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((::CppSharp::CppParser::AST::FunctionTemplate*) native.ToPointer());
}

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

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

CppSharp::Parser::AST::FunctionTemplateSpecialization^ CppSharp::Parser::AST::FunctionTemplate::GetSpecializations(unsigned int i)
{
    auto __ret = ((::CppSharp::CppParser::AST::FunctionTemplate*)NativePtr)->getSpecializations(i);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::FunctionTemplateSpecialization((::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 = (::CppSharp::CppParser::AST::FunctionTemplateSpecialization*)s->NativePtr;
    ((::CppSharp::CppParser::AST::FunctionTemplate*)NativePtr)->addSpecializations(__arg0);
}

void CppSharp::Parser::AST::FunctionTemplate::ClearSpecializations()
{
    ((::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 = ((::CppSharp::CppParser::AST::FunctionTemplate*)NativePtr)->FindSpecialization(__arg0);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::FunctionTemplateSpecialization((::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 = *(::CppSharp::CppParser::AST::FunctionTemplate*)_0->NativePtr;
    NativePtr = new ::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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::FunctionTemplate*)NativePtr)->Specializations)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::FunctionTemplateSpecialization((::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 = (::CppSharp::CppParser::AST::FunctionTemplateSpecialization*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::CppSharp::CppParser::AST::FunctionTemplate*)NativePtr)->Specializations = _tmpvalue;
}

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

CppSharp::Parser::AST::FunctionTemplateSpecialization::FunctionTemplateSpecialization(::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((::CppSharp::CppParser::AST::FunctionTemplateSpecialization*) native.ToPointer());
}

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

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

CppSharp::Parser::AST::TemplateArgument^ CppSharp::Parser::AST::FunctionTemplateSpecialization::GetArguments(unsigned int i)
{
    auto __ret = ((::CppSharp::CppParser::AST::FunctionTemplateSpecialization*)NativePtr)->getArguments(i);
    auto ____ret = new ::CppSharp::CppParser::AST::TemplateArgument(__ret);
    return (____ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::TemplateArgument((::CppSharp::CppParser::AST::TemplateArgument*)____ret);
}

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 = *(::CppSharp::CppParser::AST::TemplateArgument*)s->NativePtr;
    ((::CppSharp::CppParser::AST::FunctionTemplateSpecialization*)NativePtr)->addArguments(__arg0);
}

void CppSharp::Parser::AST::FunctionTemplateSpecialization::ClearArguments()
{
    ((::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 = *(::CppSharp::CppParser::AST::FunctionTemplateSpecialization*)_0->NativePtr;
    NativePtr = new ::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 = (::CppSharp::CppParser::AST::FunctionTemplateSpecialization*)object.ToPointer();
}

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

void CppSharp::Parser::AST::FunctionTemplateSpecialization::Template::set(CppSharp::Parser::AST::FunctionTemplate^ value)
{
    ((::CppSharp::CppParser::AST::FunctionTemplateSpecialization*)NativePtr)->_template = (::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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::FunctionTemplateSpecialization*)NativePtr)->Arguments)
    {
        auto ___element = new ::CppSharp::CppParser::AST::TemplateArgument(_element);
        auto _marshalElement = (___element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::TemplateArgument((::CppSharp::CppParser::AST::TemplateArgument*)___element);
        _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)
    {
        auto _marshalElement = *(::CppSharp::CppParser::AST::TemplateArgument*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::CppSharp::CppParser::AST::FunctionTemplateSpecialization*)NativePtr)->Arguments = _tmpvalue;
}

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

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

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

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

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

CppSharp::Parser::AST::VarTemplate::VarTemplate(::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((::CppSharp::CppParser::AST::VarTemplate*) native.ToPointer());
}

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

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

CppSharp::Parser::AST::VarTemplateSpecialization^ CppSharp::Parser::AST::VarTemplate::GetSpecializations(unsigned int i)
{
    auto __ret = ((::CppSharp::CppParser::AST::VarTemplate*)NativePtr)->getSpecializations(i);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::VarTemplateSpecialization((::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 = (::CppSharp::CppParser::AST::VarTemplateSpecialization*)s->NativePtr;
    ((::CppSharp::CppParser::AST::VarTemplate*)NativePtr)->addSpecializations(__arg0);
}

void CppSharp::Parser::AST::VarTemplate::ClearSpecializations()
{
    ((::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 = ((::CppSharp::CppParser::AST::VarTemplate*)NativePtr)->FindSpecialization(__arg0);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::VarTemplateSpecialization((::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 = ((::CppSharp::CppParser::AST::VarTemplate*)NativePtr)->FindPartialSpecialization(__arg0);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::VarTemplatePartialSpecialization((::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 = *(::CppSharp::CppParser::AST::VarTemplate*)_0->NativePtr;
    NativePtr = new ::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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::VarTemplate*)NativePtr)->Specializations)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::VarTemplateSpecialization((::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 = (::CppSharp::CppParser::AST::VarTemplateSpecialization*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::CppSharp::CppParser::AST::VarTemplate*)NativePtr)->Specializations = _tmpvalue;
}

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

CppSharp::Parser::AST::VarTemplateSpecialization::VarTemplateSpecialization(::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((::CppSharp::CppParser::AST::VarTemplateSpecialization*) native.ToPointer());
}

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

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

CppSharp::Parser::AST::TemplateArgument^ CppSharp::Parser::AST::VarTemplateSpecialization::GetArguments(unsigned int i)
{
    auto __ret = ((::CppSharp::CppParser::AST::VarTemplateSpecialization*)NativePtr)->getArguments(i);
    auto ____ret = new ::CppSharp::CppParser::AST::TemplateArgument(__ret);
    return (____ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::TemplateArgument((::CppSharp::CppParser::AST::TemplateArgument*)____ret);
}

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 = *(::CppSharp::CppParser::AST::TemplateArgument*)s->NativePtr;
    ((::CppSharp::CppParser::AST::VarTemplateSpecialization*)NativePtr)->addArguments(__arg0);
}

void CppSharp::Parser::AST::VarTemplateSpecialization::ClearArguments()
{
    ((::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 = *(::CppSharp::CppParser::AST::VarTemplateSpecialization*)_0->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::VarTemplateSpecialization(__arg0);
}

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

void CppSharp::Parser::AST::VarTemplateSpecialization::TemplatedDecl::set(CppSharp::Parser::AST::VarTemplate^ value)
{
    ((::CppSharp::CppParser::AST::VarTemplateSpecialization*)NativePtr)->templatedDecl = (::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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::VarTemplateSpecialization*)NativePtr)->Arguments)
    {
        auto ___element = new ::CppSharp::CppParser::AST::TemplateArgument(_element);
        auto _marshalElement = (___element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::TemplateArgument((::CppSharp::CppParser::AST::TemplateArgument*)___element);
        _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)
    {
        auto _marshalElement = *(::CppSharp::CppParser::AST::TemplateArgument*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::CppSharp::CppParser::AST::VarTemplateSpecialization*)NativePtr)->Arguments = _tmpvalue;
}

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

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

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

CppSharp::Parser::AST::VarTemplatePartialSpecialization::VarTemplatePartialSpecialization(::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((::CppSharp::CppParser::AST::VarTemplatePartialSpecialization*) native.ToPointer());
}

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

CppSharp::Parser::AST::VarTemplatePartialSpecialization::VarTemplatePartialSpecialization()
    : CppSharp::Parser::AST::VarTemplateSpecialization((::CppSharp::CppParser::AST::VarTemplateSpecialization*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new ::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 = *(::CppSharp::CppParser::AST::VarTemplatePartialSpecialization*)_0->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::VarTemplatePartialSpecialization(__arg0);
}

CppSharp::Parser::AST::Namespace::Namespace(::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((::CppSharp::CppParser::AST::Namespace*) native.ToPointer());
}

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

CppSharp::Parser::AST::Namespace::Namespace()
    : CppSharp::Parser::AST::DeclarationContext((::CppSharp::CppParser::AST::DeclarationContext*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new ::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 = *(::CppSharp::CppParser::AST::Namespace*)_0->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::Namespace(__arg0);
}

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

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

CppSharp::Parser::AST::PreprocessedEntity::PreprocessedEntity(::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((::CppSharp::CppParser::AST::PreprocessedEntity*) native.ToPointer());
}

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

CppSharp::Parser::AST::PreprocessedEntity::PreprocessedEntity()
{
    __ownsNativeInstance = true;
    NativePtr = new ::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 = *(::CppSharp::CppParser::AST::PreprocessedEntity*)_0->NativePtr;
    NativePtr = new ::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 = (::CppSharp::CppParser::AST::PreprocessedEntity*)object.ToPointer();
}

CppSharp::Parser::AST::MacroLocation CppSharp::Parser::AST::PreprocessedEntity::MacroLocation::get()
{
    return (CppSharp::Parser::AST::MacroLocation)((::CppSharp::CppParser::AST::PreprocessedEntity*)NativePtr)->macroLocation;
}

void CppSharp::Parser::AST::PreprocessedEntity::MacroLocation::set(CppSharp::Parser::AST::MacroLocation value)
{
    ((::CppSharp::CppParser::AST::PreprocessedEntity*)NativePtr)->macroLocation = (::CppSharp::CppParser::AST::MacroLocation)value;
}

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

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

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

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

CppSharp::Parser::AST::MacroDefinition::MacroDefinition(::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((::CppSharp::CppParser::AST::MacroDefinition*) native.ToPointer());
}

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

CppSharp::Parser::AST::MacroDefinition::MacroDefinition()
    : CppSharp::Parser::AST::PreprocessedEntity((::CppSharp::CppParser::AST::PreprocessedEntity*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new ::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 = *(::CppSharp::CppParser::AST::MacroDefinition*)_0->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::MacroDefinition(__arg0);
}

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

void CppSharp::Parser::AST::MacroDefinition::Name::set(System::String^ value)
{
    ((::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>(((::CppSharp::CppParser::AST::MacroDefinition*)NativePtr)->expression);
}

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

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

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

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

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

CppSharp::Parser::AST::MacroExpansion::MacroExpansion(::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((::CppSharp::CppParser::AST::MacroExpansion*) native.ToPointer());
}

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

CppSharp::Parser::AST::MacroExpansion::MacroExpansion()
    : CppSharp::Parser::AST::PreprocessedEntity((::CppSharp::CppParser::AST::PreprocessedEntity*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new ::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 = *(::CppSharp::CppParser::AST::MacroExpansion*)_0->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::MacroExpansion(__arg0);
}

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

void CppSharp::Parser::AST::MacroExpansion::Name::set(System::String^ value)
{
    ((::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>(((::CppSharp::CppParser::AST::MacroExpansion*)NativePtr)->text);
}

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

CppSharp::Parser::AST::MacroDefinition^ CppSharp::Parser::AST::MacroExpansion::Definition::get()
{
    return (((::CppSharp::CppParser::AST::MacroExpansion*)NativePtr)->definition == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::MacroDefinition((::CppSharp::CppParser::AST::MacroDefinition*)((::CppSharp::CppParser::AST::MacroExpansion*)NativePtr)->definition);
}

void CppSharp::Parser::AST::MacroExpansion::Definition::set(CppSharp::Parser::AST::MacroDefinition^ value)
{
    ((::CppSharp::CppParser::AST::MacroExpansion*)NativePtr)->definition = (::CppSharp::CppParser::AST::MacroDefinition*)value->NativePtr;
}

CppSharp::Parser::AST::TranslationUnit::TranslationUnit(::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((::CppSharp::CppParser::AST::TranslationUnit*) native.ToPointer());
}

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

CppSharp::Parser::AST::TranslationUnit::TranslationUnit()
    : CppSharp::Parser::AST::Namespace((::CppSharp::CppParser::AST::Namespace*)nullptr)
{
    __ownsNativeInstance = true;
    NativePtr = new ::CppSharp::CppParser::AST::TranslationUnit();
}

CppSharp::Parser::AST::MacroDefinition^ CppSharp::Parser::AST::TranslationUnit::GetMacros(unsigned int i)
{
    auto __ret = ((::CppSharp::CppParser::AST::TranslationUnit*)NativePtr)->getMacros(i);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::MacroDefinition((::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 = (::CppSharp::CppParser::AST::MacroDefinition*)s->NativePtr;
    ((::CppSharp::CppParser::AST::TranslationUnit*)NativePtr)->addMacros(__arg0);
}

void CppSharp::Parser::AST::TranslationUnit::ClearMacros()
{
    ((::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 = *(::CppSharp::CppParser::AST::TranslationUnit*)_0->NativePtr;
    NativePtr = new ::CppSharp::CppParser::AST::TranslationUnit(__arg0);
}

System::String^ CppSharp::Parser::AST::TranslationUnit::FileName::get()
{
    return clix::marshalString<clix::E_UTF8>(((::CppSharp::CppParser::AST::TranslationUnit*)NativePtr)->fileName);
}

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

bool CppSharp::Parser::AST::TranslationUnit::IsSystemHeader::get()
{
    return ((::CppSharp::CppParser::AST::TranslationUnit*)NativePtr)->isSystemHeader;
}

void CppSharp::Parser::AST::TranslationUnit::IsSystemHeader::set(bool value)
{
    ((::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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::TranslationUnit*)NativePtr)->Macros)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::MacroDefinition((::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 = (::CppSharp::CppParser::AST::MacroDefinition*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::CppSharp::CppParser::AST::TranslationUnit*)NativePtr)->Macros = _tmpvalue;
}

unsigned int CppSharp::Parser::AST::TranslationUnit::MacrosCount::get()
{
    auto __ret = ((::CppSharp::CppParser::AST::TranslationUnit*)NativePtr)->getMacrosCount();
    return __ret;
}

CppSharp::Parser::AST::ASTContext::ASTContext(::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((::CppSharp::CppParser::AST::ASTContext*) native.ToPointer());
}

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

CppSharp::Parser::AST::ASTContext::ASTContext()
{
    __ownsNativeInstance = true;
    NativePtr = new ::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 = ((::CppSharp::CppParser::AST::ASTContext*)NativePtr)->FindOrCreateModule(__arg0);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::TranslationUnit((::CppSharp::CppParser::AST::TranslationUnit*)__ret);
}

CppSharp::Parser::AST::TranslationUnit^ CppSharp::Parser::AST::ASTContext::GetTranslationUnits(unsigned int i)
{
    auto __ret = ((::CppSharp::CppParser::AST::ASTContext*)NativePtr)->getTranslationUnits(i);
    if (__ret == nullptr) return nullptr;
    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::TranslationUnit((::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 = (::CppSharp::CppParser::AST::TranslationUnit*)s->NativePtr;
    ((::CppSharp::CppParser::AST::ASTContext*)NativePtr)->addTranslationUnits(__arg0);
}

void CppSharp::Parser::AST::ASTContext::ClearTranslationUnits()
{
    ((::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 = *(::CppSharp::CppParser::AST::ASTContext*)_0->NativePtr;
    NativePtr = new ::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 = (::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^>();
    for(auto _element : ((::CppSharp::CppParser::AST::ASTContext*)NativePtr)->TranslationUnits)
    {
        auto _marshalElement = (_element == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::TranslationUnit((::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 = (::CppSharp::CppParser::AST::TranslationUnit*)_element->NativePtr;
        _tmpvalue.push_back(_marshalElement);
    }
    ((::CppSharp::CppParser::AST::ASTContext*)NativePtr)->TranslationUnits = _tmpvalue;
}

unsigned int CppSharp::Parser::AST::ASTContext::TranslationUnitsCount::get()
{
    auto __ret = ((::CppSharp::CppParser::AST::ASTContext*)NativePtr)->getTranslationUnitsCount();
    return __ret;
}