// Part of the LLVM Project, under the Apache License v2.0 with LLVM
// Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

// AUTO GENERATED FILE, DO NOT EDIT.
//
// Generated by `package:ffigen`.
import 'dart:ffi' as ffi;

/// Holds bindings to LibClang.
class Clang {
  /// Holds the Dynamic library.
  final ffi.DynamicLibrary _dylib;

  /// The symbols are looked up in [dynamicLibrary].
  Clang(ffi.DynamicLibrary dynamicLibrary) : _dylib = dynamicLibrary;

  /// Provides a shared context for creating translation units.
  ///
  /// It provides two options:
  ///
  /// - excludeDeclarationsFromPCH: When non-zero, allows enumeration of "local"
  /// declarations (when loading any new translation units). A "local" declaration
  /// is one that belongs in the translation unit itself and not in a precompiled
  /// header that was used by the translation unit. If zero, all declarations
  /// will be enumerated.
  ///
  /// Here is an example:
  ///
  /// \code
  /// // excludeDeclsFromPCH = 1, displayDiagnostics=1
  /// Idx = clang_createIndex(1, 1);
  ///
  /// // IndexTest.pch was produced with the following command:
  /// // "clang -x c IndexTest.h -emit-ast -o IndexTest.pch"
  /// TU = clang_createTranslationUnit(Idx, "IndexTest.pch");
  ///
  /// // This will load all the symbols from 'IndexTest.pch'
  /// clang_visitChildren(clang_getTranslationUnitCursor(TU),
  /// TranslationUnitVisitor, 0);
  /// clang_disposeTranslationUnit(TU);
  ///
  /// // This will load all the symbols from 'IndexTest.c', excluding symbols
  /// // from 'IndexTest.pch'.
  /// char *args[] = { "-Xclang", "-include-pch=IndexTest.pch" };
  /// TU = clang_createTranslationUnitFromSourceFile(Idx, "IndexTest.c", 2, args,
  /// 0, 0);
  /// clang_visitChildren(clang_getTranslationUnitCursor(TU),
  /// TranslationUnitVisitor, 0);
  /// clang_disposeTranslationUnit(TU);
  /// \endcode
  ///
  /// This process of creating the 'pch', loading it separately, and using it (via
  /// -include-pch) allows 'excludeDeclsFromPCH' to remove redundant callbacks
  /// (which gives the indexer the same performance benefit as the compiler).
  ffi.Pointer<ffi.Void> clang_createIndex(
    int excludeDeclarationsFromPCH,
    int displayDiagnostics,
  ) {
    _clang_createIndex ??=
        _dylib.lookupFunction<_c_clang_createIndex, _dart_clang_createIndex>(
            'clang_createIndex');
    return _clang_createIndex(
      excludeDeclarationsFromPCH,
      displayDiagnostics,
    );
  }

  _dart_clang_createIndex _clang_createIndex;

  /// Destroy the given index.
  ///
  /// The index must not be destroyed until all of the translation units created
  /// within that index have been destroyed.
  void clang_disposeIndex(
    ffi.Pointer<ffi.Void> index,
  ) {
    _clang_disposeIndex ??=
        _dylib.lookupFunction<_c_clang_disposeIndex, _dart_clang_disposeIndex>(
            'clang_disposeIndex');
    return _clang_disposeIndex(
      index,
    );
  }

  _dart_clang_disposeIndex _clang_disposeIndex;

  /// Determine the number of diagnostics produced for the given
  /// translation unit.
  int clang_getNumDiagnostics(
    ffi.Pointer<CXTranslationUnitImpl> Unit,
  ) {
    _clang_getNumDiagnostics ??= _dylib.lookupFunction<
        _c_clang_getNumDiagnostics,
        _dart_clang_getNumDiagnostics>('clang_getNumDiagnostics');
    return _clang_getNumDiagnostics(
      Unit,
    );
  }

  _dart_clang_getNumDiagnostics _clang_getNumDiagnostics;

  /// Retrieve a diagnostic associated with the given translation unit.
  ///
  /// \param Unit the translation unit to query.
  /// \param Index the zero-based diagnostic number to retrieve.
  ///
  /// \returns the requested diagnostic. This diagnostic must be freed
  /// via a call to \c clang_disposeDiagnostic().
  ffi.Pointer<ffi.Void> clang_getDiagnostic(
    ffi.Pointer<CXTranslationUnitImpl> Unit,
    int Index,
  ) {
    _clang_getDiagnostic ??= _dylib.lookupFunction<_c_clang_getDiagnostic,
        _dart_clang_getDiagnostic>('clang_getDiagnostic');
    return _clang_getDiagnostic(
      Unit,
      Index,
    );
  }

  _dart_clang_getDiagnostic _clang_getDiagnostic;

  /// Destroy a diagnostic.
  void clang_disposeDiagnostic(
    ffi.Pointer<ffi.Void> Diagnostic,
  ) {
    _clang_disposeDiagnostic ??= _dylib.lookupFunction<
        _c_clang_disposeDiagnostic,
        _dart_clang_disposeDiagnostic>('clang_disposeDiagnostic');
    return _clang_disposeDiagnostic(
      Diagnostic,
    );
  }

  _dart_clang_disposeDiagnostic _clang_disposeDiagnostic;

  /// Same as \c clang_parseTranslationUnit2, but returns
  /// the \c CXTranslationUnit instead of an error code.  In case of an error this
  /// routine returns a \c NULL \c CXTranslationUnit, without further detailed
  /// error codes.
  ffi.Pointer<CXTranslationUnitImpl> clang_parseTranslationUnit(
    ffi.Pointer<ffi.Void> CIdx,
    ffi.Pointer<ffi.Int8> source_filename,
    ffi.Pointer<ffi.Pointer<ffi.Int8>> command_line_args,
    int num_command_line_args,
    ffi.Pointer<CXUnsavedFile> unsaved_files,
    int num_unsaved_files,
    int options,
  ) {
    _clang_parseTranslationUnit ??= _dylib.lookupFunction<
        _c_clang_parseTranslationUnit,
        _dart_clang_parseTranslationUnit>('clang_parseTranslationUnit');
    return _clang_parseTranslationUnit(
      CIdx,
      source_filename,
      command_line_args,
      num_command_line_args,
      unsaved_files,
      num_unsaved_files,
      options,
    );
  }

  _dart_clang_parseTranslationUnit _clang_parseTranslationUnit;

  /// Destroy the specified CXTranslationUnit object.
  void clang_disposeTranslationUnit(
    ffi.Pointer<CXTranslationUnitImpl> arg0,
  ) {
    _clang_disposeTranslationUnit ??= _dylib.lookupFunction<
        _c_clang_disposeTranslationUnit,
        _dart_clang_disposeTranslationUnit>('clang_disposeTranslationUnit');
    return _clang_disposeTranslationUnit(
      arg0,
    );
  }

  _dart_clang_disposeTranslationUnit _clang_disposeTranslationUnit;

  /// Returns the kind of the evaluated result.
  int clang_EvalResult_getKind(
    ffi.Pointer<ffi.Void> E,
  ) {
    _clang_EvalResult_getKind ??= _dylib.lookupFunction<
        _c_clang_EvalResult_getKind,
        _dart_clang_EvalResult_getKind>('clang_EvalResult_getKind');
    return _clang_EvalResult_getKind(
      E,
    );
  }

  _dart_clang_EvalResult_getKind _clang_EvalResult_getKind;

  /// Returns the evaluation result as integer if the
  /// kind is Int.
  int clang_EvalResult_getAsInt(
    ffi.Pointer<ffi.Void> E,
  ) {
    _clang_EvalResult_getAsInt ??= _dylib.lookupFunction<
        _c_clang_EvalResult_getAsInt,
        _dart_clang_EvalResult_getAsInt>('clang_EvalResult_getAsInt');
    return _clang_EvalResult_getAsInt(
      E,
    );
  }

  _dart_clang_EvalResult_getAsInt _clang_EvalResult_getAsInt;

  /// Returns the evaluation result as a long long integer if the
  /// kind is Int. This prevents overflows that may happen if the result is
  /// returned with clang_EvalResult_getAsInt.
  int clang_EvalResult_getAsLongLong(
    ffi.Pointer<ffi.Void> E,
  ) {
    _clang_EvalResult_getAsLongLong ??= _dylib.lookupFunction<
        _c_clang_EvalResult_getAsLongLong,
        _dart_clang_EvalResult_getAsLongLong>('clang_EvalResult_getAsLongLong');
    return _clang_EvalResult_getAsLongLong(
      E,
    );
  }

  _dart_clang_EvalResult_getAsLongLong _clang_EvalResult_getAsLongLong;

  /// Returns the evaluation result as double if the
  /// kind is double.
  double clang_EvalResult_getAsDouble(
    ffi.Pointer<ffi.Void> E,
  ) {
    _clang_EvalResult_getAsDouble ??= _dylib.lookupFunction<
        _c_clang_EvalResult_getAsDouble,
        _dart_clang_EvalResult_getAsDouble>('clang_EvalResult_getAsDouble');
    return _clang_EvalResult_getAsDouble(
      E,
    );
  }

  _dart_clang_EvalResult_getAsDouble _clang_EvalResult_getAsDouble;

  /// Returns the evaluation result as a constant string if the
  /// kind is other than Int or float. User must not free this pointer,
  /// instead call clang_EvalResult_dispose on the CXEvalResult returned
  /// by clang_Cursor_Evaluate.
  ffi.Pointer<ffi.Int8> clang_EvalResult_getAsStr(
    ffi.Pointer<ffi.Void> E,
  ) {
    _clang_EvalResult_getAsStr ??= _dylib.lookupFunction<
        _c_clang_EvalResult_getAsStr,
        _dart_clang_EvalResult_getAsStr>('clang_EvalResult_getAsStr');
    return _clang_EvalResult_getAsStr(
      E,
    );
  }

  _dart_clang_EvalResult_getAsStr _clang_EvalResult_getAsStr;

  /// Disposes the created Eval memory.
  void clang_EvalResult_dispose(
    ffi.Pointer<ffi.Void> E,
  ) {
    _clang_EvalResult_dispose ??= _dylib.lookupFunction<
        _c_clang_EvalResult_dispose,
        _dart_clang_EvalResult_dispose>('clang_EvalResult_dispose');
    return _clang_EvalResult_dispose(
      E,
    );
  }

  _dart_clang_EvalResult_dispose _clang_EvalResult_dispose;

  ffi.Pointer<ffi.Int8> clang_getCString_wrap(
    ffi.Pointer<CXString> string,
  ) {
    _clang_getCString_wrap ??= _dylib.lookupFunction<_c_clang_getCString_wrap,
        _dart_clang_getCString_wrap>('clang_getCString_wrap');
    return _clang_getCString_wrap(
      string,
    );
  }

  _dart_clang_getCString_wrap _clang_getCString_wrap;

  void clang_disposeString_wrap(
    ffi.Pointer<CXString> string,
  ) {
    _clang_disposeString_wrap ??= _dylib.lookupFunction<
        _c_clang_disposeString_wrap,
        _dart_clang_disposeString_wrap>('clang_disposeString_wrap');
    return _clang_disposeString_wrap(
      string,
    );
  }

  _dart_clang_disposeString_wrap _clang_disposeString_wrap;

  int clang_getCursorKind_wrap(
    ffi.Pointer<CXCursor> cursor,
  ) {
    _clang_getCursorKind_wrap ??= _dylib.lookupFunction<
        _c_clang_getCursorKind_wrap,
        _dart_clang_getCursorKind_wrap>('clang_getCursorKind_wrap');
    return _clang_getCursorKind_wrap(
      cursor,
    );
  }

  _dart_clang_getCursorKind_wrap _clang_getCursorKind_wrap;

  ffi.Pointer<CXString> clang_getCursorKindSpelling_wrap(
    int kind,
  ) {
    _clang_getCursorKindSpelling_wrap ??= _dylib.lookupFunction<
            _c_clang_getCursorKindSpelling_wrap,
            _dart_clang_getCursorKindSpelling_wrap>(
        'clang_getCursorKindSpelling_wrap');
    return _clang_getCursorKindSpelling_wrap(
      kind,
    );
  }

  _dart_clang_getCursorKindSpelling_wrap _clang_getCursorKindSpelling_wrap;

  ffi.Pointer<CXType> clang_getCursorType_wrap(
    ffi.Pointer<CXCursor> cursor,
  ) {
    _clang_getCursorType_wrap ??= _dylib.lookupFunction<
        _c_clang_getCursorType_wrap,
        _dart_clang_getCursorType_wrap>('clang_getCursorType_wrap');
    return _clang_getCursorType_wrap(
      cursor,
    );
  }

  _dart_clang_getCursorType_wrap _clang_getCursorType_wrap;

  ffi.Pointer<CXString> clang_getTypeSpelling_wrap(
    ffi.Pointer<CXType> type,
  ) {
    _clang_getTypeSpelling_wrap ??= _dylib.lookupFunction<
        _c_clang_getTypeSpelling_wrap,
        _dart_clang_getTypeSpelling_wrap>('clang_getTypeSpelling_wrap');
    return _clang_getTypeSpelling_wrap(
      type,
    );
  }

  _dart_clang_getTypeSpelling_wrap _clang_getTypeSpelling_wrap;

  ffi.Pointer<CXString> clang_getTypeKindSpelling_wrap(
    int typeKind,
  ) {
    _clang_getTypeKindSpelling_wrap ??= _dylib.lookupFunction<
        _c_clang_getTypeKindSpelling_wrap,
        _dart_clang_getTypeKindSpelling_wrap>('clang_getTypeKindSpelling_wrap');
    return _clang_getTypeKindSpelling_wrap(
      typeKind,
    );
  }

  _dart_clang_getTypeKindSpelling_wrap _clang_getTypeKindSpelling_wrap;

  ffi.Pointer<CXType> clang_getResultType_wrap(
    ffi.Pointer<CXType> functionType,
  ) {
    _clang_getResultType_wrap ??= _dylib.lookupFunction<
        _c_clang_getResultType_wrap,
        _dart_clang_getResultType_wrap>('clang_getResultType_wrap');
    return _clang_getResultType_wrap(
      functionType,
    );
  }

  _dart_clang_getResultType_wrap _clang_getResultType_wrap;

  ffi.Pointer<CXType> clang_getPointeeType_wrap(
    ffi.Pointer<CXType> pointerType,
  ) {
    _clang_getPointeeType_wrap ??= _dylib.lookupFunction<
        _c_clang_getPointeeType_wrap,
        _dart_clang_getPointeeType_wrap>('clang_getPointeeType_wrap');
    return _clang_getPointeeType_wrap(
      pointerType,
    );
  }

  _dart_clang_getPointeeType_wrap _clang_getPointeeType_wrap;

  ffi.Pointer<CXType> clang_getCanonicalType_wrap(
    ffi.Pointer<CXType> typerefType,
  ) {
    _clang_getCanonicalType_wrap ??= _dylib.lookupFunction<
        _c_clang_getCanonicalType_wrap,
        _dart_clang_getCanonicalType_wrap>('clang_getCanonicalType_wrap');
    return _clang_getCanonicalType_wrap(
      typerefType,
    );
  }

  _dart_clang_getCanonicalType_wrap _clang_getCanonicalType_wrap;

  ffi.Pointer<CXType> clang_Type_getNamedType_wrap(
    ffi.Pointer<CXType> elaboratedType,
  ) {
    _clang_Type_getNamedType_wrap ??= _dylib.lookupFunction<
        _c_clang_Type_getNamedType_wrap,
        _dart_clang_Type_getNamedType_wrap>('clang_Type_getNamedType_wrap');
    return _clang_Type_getNamedType_wrap(
      elaboratedType,
    );
  }

  _dart_clang_Type_getNamedType_wrap _clang_Type_getNamedType_wrap;

  ffi.Pointer<CXCursor> clang_getTypeDeclaration_wrap(
    ffi.Pointer<CXType> cxtype,
  ) {
    _clang_getTypeDeclaration_wrap ??= _dylib.lookupFunction<
        _c_clang_getTypeDeclaration_wrap,
        _dart_clang_getTypeDeclaration_wrap>('clang_getTypeDeclaration_wrap');
    return _clang_getTypeDeclaration_wrap(
      cxtype,
    );
  }

  _dart_clang_getTypeDeclaration_wrap _clang_getTypeDeclaration_wrap;

  ffi.Pointer<CXType> clang_getTypedefDeclUnderlyingType_wrap(
    ffi.Pointer<CXCursor> cxcursor,
  ) {
    _clang_getTypedefDeclUnderlyingType_wrap ??= _dylib.lookupFunction<
            _c_clang_getTypedefDeclUnderlyingType_wrap,
            _dart_clang_getTypedefDeclUnderlyingType_wrap>(
        'clang_getTypedefDeclUnderlyingType_wrap');
    return _clang_getTypedefDeclUnderlyingType_wrap(
      cxcursor,
    );
  }

  _dart_clang_getTypedefDeclUnderlyingType_wrap
      _clang_getTypedefDeclUnderlyingType_wrap;

  /// The name of parameter, struct, typedef.
  ffi.Pointer<CXString> clang_getCursorSpelling_wrap(
    ffi.Pointer<CXCursor> cursor,
  ) {
    _clang_getCursorSpelling_wrap ??= _dylib.lookupFunction<
        _c_clang_getCursorSpelling_wrap,
        _dart_clang_getCursorSpelling_wrap>('clang_getCursorSpelling_wrap');
    return _clang_getCursorSpelling_wrap(
      cursor,
    );
  }

  _dart_clang_getCursorSpelling_wrap _clang_getCursorSpelling_wrap;

  ffi.Pointer<CXCursor> clang_getTranslationUnitCursor_wrap(
    ffi.Pointer<CXTranslationUnitImpl> tu,
  ) {
    _clang_getTranslationUnitCursor_wrap ??= _dylib.lookupFunction<
            _c_clang_getTranslationUnitCursor_wrap,
            _dart_clang_getTranslationUnitCursor_wrap>(
        'clang_getTranslationUnitCursor_wrap');
    return _clang_getTranslationUnitCursor_wrap(
      tu,
    );
  }

  _dart_clang_getTranslationUnitCursor_wrap
      _clang_getTranslationUnitCursor_wrap;

  ffi.Pointer<CXString> clang_formatDiagnostic_wrap(
    ffi.Pointer<ffi.Void> diag,
    int opts,
  ) {
    _clang_formatDiagnostic_wrap ??= _dylib.lookupFunction<
        _c_clang_formatDiagnostic_wrap,
        _dart_clang_formatDiagnostic_wrap>('clang_formatDiagnostic_wrap');
    return _clang_formatDiagnostic_wrap(
      diag,
      opts,
    );
  }

  _dart_clang_formatDiagnostic_wrap _clang_formatDiagnostic_wrap;

  /// Visitor is a function pointer with parameters having pointers to cxcursor
  /// instead of cxcursor by default.
  int clang_visitChildren_wrap(
    ffi.Pointer<CXCursor> parent,
    ffi.Pointer<ffi.NativeFunction<ModifiedCXCursorVisitor>> _modifiedVisitor,
    int uid,
  ) {
    _clang_visitChildren_wrap ??= _dylib.lookupFunction<
        _c_clang_visitChildren_wrap,
        _dart_clang_visitChildren_wrap>('clang_visitChildren_wrap');
    return _clang_visitChildren_wrap(
      parent,
      _modifiedVisitor,
      uid,
    );
  }

  _dart_clang_visitChildren_wrap _clang_visitChildren_wrap;

  int clang_Cursor_getNumArguments_wrap(
    ffi.Pointer<CXCursor> cursor,
  ) {
    _clang_Cursor_getNumArguments_wrap ??= _dylib.lookupFunction<
            _c_clang_Cursor_getNumArguments_wrap,
            _dart_clang_Cursor_getNumArguments_wrap>(
        'clang_Cursor_getNumArguments_wrap');
    return _clang_Cursor_getNumArguments_wrap(
      cursor,
    );
  }

  _dart_clang_Cursor_getNumArguments_wrap _clang_Cursor_getNumArguments_wrap;

  ffi.Pointer<CXCursor> clang_Cursor_getArgument_wrap(
    ffi.Pointer<CXCursor> cursor,
    int i,
  ) {
    _clang_Cursor_getArgument_wrap ??= _dylib.lookupFunction<
        _c_clang_Cursor_getArgument_wrap,
        _dart_clang_Cursor_getArgument_wrap>('clang_Cursor_getArgument_wrap');
    return _clang_Cursor_getArgument_wrap(
      cursor,
      i,
    );
  }

  _dart_clang_Cursor_getArgument_wrap _clang_Cursor_getArgument_wrap;

  int clang_getNumArgTypes_wrap(
    ffi.Pointer<CXType> cxtype,
  ) {
    _clang_getNumArgTypes_wrap ??= _dylib.lookupFunction<
        _c_clang_getNumArgTypes_wrap,
        _dart_clang_getNumArgTypes_wrap>('clang_getNumArgTypes_wrap');
    return _clang_getNumArgTypes_wrap(
      cxtype,
    );
  }

  _dart_clang_getNumArgTypes_wrap _clang_getNumArgTypes_wrap;

  ffi.Pointer<CXType> clang_getArgType_wrap(
    ffi.Pointer<CXType> cxtype,
    int i,
  ) {
    _clang_getArgType_wrap ??= _dylib.lookupFunction<_c_clang_getArgType_wrap,
        _dart_clang_getArgType_wrap>('clang_getArgType_wrap');
    return _clang_getArgType_wrap(
      cxtype,
      i,
    );
  }

  _dart_clang_getArgType_wrap _clang_getArgType_wrap;

  int clang_getEnumConstantDeclValue_wrap(
    ffi.Pointer<CXCursor> cursor,
  ) {
    _clang_getEnumConstantDeclValue_wrap ??= _dylib.lookupFunction<
            _c_clang_getEnumConstantDeclValue_wrap,
            _dart_clang_getEnumConstantDeclValue_wrap>(
        'clang_getEnumConstantDeclValue_wrap');
    return _clang_getEnumConstantDeclValue_wrap(
      cursor,
    );
  }

  _dart_clang_getEnumConstantDeclValue_wrap
      _clang_getEnumConstantDeclValue_wrap;

  /// Returns non-zero if the ranges are the same, zero if they differ.
  int clang_equalRanges_wrap(
    ffi.Pointer<CXSourceRange> c1,
    ffi.Pointer<CXSourceRange> c2,
  ) {
    _clang_equalRanges_wrap ??= _dylib.lookupFunction<_c_clang_equalRanges_wrap,
        _dart_clang_equalRanges_wrap>('clang_equalRanges_wrap');
    return _clang_equalRanges_wrap(
      c1,
      c2,
    );
  }

  _dart_clang_equalRanges_wrap _clang_equalRanges_wrap;

  /// Returns the comment range.
  ffi.Pointer<CXSourceRange> clang_Cursor_getCommentRange_wrap(
    ffi.Pointer<CXCursor> cursor,
  ) {
    _clang_Cursor_getCommentRange_wrap ??= _dylib.lookupFunction<
            _c_clang_Cursor_getCommentRange_wrap,
            _dart_clang_Cursor_getCommentRange_wrap>(
        'clang_Cursor_getCommentRange_wrap');
    return _clang_Cursor_getCommentRange_wrap(
      cursor,
    );
  }

  _dart_clang_Cursor_getCommentRange_wrap _clang_Cursor_getCommentRange_wrap;

  /// Returns the raw comment.
  ffi.Pointer<CXString> clang_Cursor_getRawCommentText_wrap(
    ffi.Pointer<CXCursor> cursor,
  ) {
    _clang_Cursor_getRawCommentText_wrap ??= _dylib.lookupFunction<
            _c_clang_Cursor_getRawCommentText_wrap,
            _dart_clang_Cursor_getRawCommentText_wrap>(
        'clang_Cursor_getRawCommentText_wrap');
    return _clang_Cursor_getRawCommentText_wrap(
      cursor,
    );
  }

  _dart_clang_Cursor_getRawCommentText_wrap
      _clang_Cursor_getRawCommentText_wrap;

  /// Returns the first paragraph of doxygen doc comment.
  ffi.Pointer<CXString> clang_Cursor_getBriefCommentText_wrap(
    ffi.Pointer<CXCursor> cursor,
  ) {
    _clang_Cursor_getBriefCommentText_wrap ??= _dylib.lookupFunction<
            _c_clang_Cursor_getBriefCommentText_wrap,
            _dart_clang_Cursor_getBriefCommentText_wrap>(
        'clang_Cursor_getBriefCommentText_wrap');
    return _clang_Cursor_getBriefCommentText_wrap(
      cursor,
    );
  }

  _dart_clang_Cursor_getBriefCommentText_wrap
      _clang_Cursor_getBriefCommentText_wrap;

  ffi.Pointer<CXSourceLocation> clang_getCursorLocation_wrap(
    ffi.Pointer<CXCursor> cursor,
  ) {
    _clang_getCursorLocation_wrap ??= _dylib.lookupFunction<
        _c_clang_getCursorLocation_wrap,
        _dart_clang_getCursorLocation_wrap>('clang_getCursorLocation_wrap');
    return _clang_getCursorLocation_wrap(
      cursor,
    );
  }

  _dart_clang_getCursorLocation_wrap _clang_getCursorLocation_wrap;

  void clang_getFileLocation_wrap(
    ffi.Pointer<CXSourceLocation> location,
    ffi.Pointer<ffi.Pointer<ffi.Void>> file,
    ffi.Pointer<ffi.Uint32> line,
    ffi.Pointer<ffi.Uint32> column,
    ffi.Pointer<ffi.Uint32> offset,
  ) {
    _clang_getFileLocation_wrap ??= _dylib.lookupFunction<
        _c_clang_getFileLocation_wrap,
        _dart_clang_getFileLocation_wrap>('clang_getFileLocation_wrap');
    return _clang_getFileLocation_wrap(
      location,
      file,
      line,
      column,
      offset,
    );
  }

  _dart_clang_getFileLocation_wrap _clang_getFileLocation_wrap;

  ffi.Pointer<CXString> clang_getFileName_wrap(
    ffi.Pointer<ffi.Void> SFile,
  ) {
    _clang_getFileName_wrap ??= _dylib.lookupFunction<_c_clang_getFileName_wrap,
        _dart_clang_getFileName_wrap>('clang_getFileName_wrap');
    return _clang_getFileName_wrap(
      SFile,
    );
  }

  _dart_clang_getFileName_wrap _clang_getFileName_wrap;

  int clang_getNumElements_wrap(
    ffi.Pointer<CXType> cxtype,
  ) {
    _clang_getNumElements_wrap ??= _dylib.lookupFunction<
        _c_clang_getNumElements_wrap,
        _dart_clang_getNumElements_wrap>('clang_getNumElements_wrap');
    return _clang_getNumElements_wrap(
      cxtype,
    );
  }

  _dart_clang_getNumElements_wrap _clang_getNumElements_wrap;

  ffi.Pointer<CXType> clang_getArrayElementType_wrap(
    ffi.Pointer<CXType> cxtype,
  ) {
    _clang_getArrayElementType_wrap ??= _dylib.lookupFunction<
        _c_clang_getArrayElementType_wrap,
        _dart_clang_getArrayElementType_wrap>('clang_getArrayElementType_wrap');
    return _clang_getArrayElementType_wrap(
      cxtype,
    );
  }

  _dart_clang_getArrayElementType_wrap _clang_getArrayElementType_wrap;

  int clang_Cursor_isMacroFunctionLike_wrap(
    ffi.Pointer<CXCursor> cursor,
  ) {
    _clang_Cursor_isMacroFunctionLike_wrap ??= _dylib.lookupFunction<
            _c_clang_Cursor_isMacroFunctionLike_wrap,
            _dart_clang_Cursor_isMacroFunctionLike_wrap>(
        'clang_Cursor_isMacroFunctionLike_wrap');
    return _clang_Cursor_isMacroFunctionLike_wrap(
      cursor,
    );
  }

  _dart_clang_Cursor_isMacroFunctionLike_wrap
      _clang_Cursor_isMacroFunctionLike_wrap;

  int clang_Cursor_isMacroBuiltin_wrap(
    ffi.Pointer<CXCursor> cursor,
  ) {
    _clang_Cursor_isMacroBuiltin_wrap ??= _dylib.lookupFunction<
            _c_clang_Cursor_isMacroBuiltin_wrap,
            _dart_clang_Cursor_isMacroBuiltin_wrap>(
        'clang_Cursor_isMacroBuiltin_wrap');
    return _clang_Cursor_isMacroBuiltin_wrap(
      cursor,
    );
  }

  _dart_clang_Cursor_isMacroBuiltin_wrap _clang_Cursor_isMacroBuiltin_wrap;

  ffi.Pointer<ffi.Void> clang_Cursor_Evaluate_wrap(
    ffi.Pointer<CXCursor> cursor,
  ) {
    _clang_Cursor_Evaluate_wrap ??= _dylib.lookupFunction<
        _c_clang_Cursor_Evaluate_wrap,
        _dart_clang_Cursor_Evaluate_wrap>('clang_Cursor_Evaluate_wrap');
    return _clang_Cursor_Evaluate_wrap(
      cursor,
    );
  }

  _dart_clang_Cursor_Evaluate_wrap _clang_Cursor_Evaluate_wrap;

  int clang_Cursor_isAnonymous_wrap(
    ffi.Pointer<CXCursor> cursor,
  ) {
    _clang_Cursor_isAnonymous_wrap ??= _dylib.lookupFunction<
        _c_clang_Cursor_isAnonymous_wrap,
        _dart_clang_Cursor_isAnonymous_wrap>('clang_Cursor_isAnonymous_wrap');
    return _clang_Cursor_isAnonymous_wrap(
      cursor,
    );
  }

  _dart_clang_Cursor_isAnonymous_wrap _clang_Cursor_isAnonymous_wrap;

  int clang_Cursor_isAnonymousRecordDecl_wrap(
    ffi.Pointer<CXCursor> cursor,
  ) {
    _clang_Cursor_isAnonymousRecordDecl_wrap ??= _dylib.lookupFunction<
            _c_clang_Cursor_isAnonymousRecordDecl_wrap,
            _dart_clang_Cursor_isAnonymousRecordDecl_wrap>(
        'clang_Cursor_isAnonymousRecordDecl_wrap');
    return _clang_Cursor_isAnonymousRecordDecl_wrap(
      cursor,
    );
  }

  _dart_clang_Cursor_isAnonymousRecordDecl_wrap
      _clang_Cursor_isAnonymousRecordDecl_wrap;

  ffi.Pointer<CXString> clang_getCursorUSR_wrap(
    ffi.Pointer<CXCursor> cursor,
  ) {
    _clang_getCursorUSR_wrap ??= _dylib.lookupFunction<
        _c_clang_getCursorUSR_wrap,
        _dart_clang_getCursorUSR_wrap>('clang_getCursorUSR_wrap');
    return _clang_getCursorUSR_wrap(
      cursor,
    );
  }

  _dart_clang_getCursorUSR_wrap _clang_getCursorUSR_wrap;

  int clang_getFieldDeclBitWidth_wrap(
    ffi.Pointer<CXCursor> cursor,
  ) {
    _clang_getFieldDeclBitWidth_wrap ??= _dylib.lookupFunction<
            _c_clang_getFieldDeclBitWidth_wrap,
            _dart_clang_getFieldDeclBitWidth_wrap>(
        'clang_getFieldDeclBitWidth_wrap');
    return _clang_getFieldDeclBitWidth_wrap(
      cursor,
    );
  }

  _dart_clang_getFieldDeclBitWidth_wrap _clang_getFieldDeclBitWidth_wrap;
}

/// A character string.
///
/// The \c CXString type is used to return strings from the interface when
/// the ownership of that string might differ from one call to the next.
/// Use \c clang_getCString() to retrieve the string data and, once finished
/// with the string data, call \c clang_disposeString() to free the string.
class CXString extends ffi.Struct {
  ffi.Pointer<ffi.Void> data;

  @ffi.Uint32()
  int private_flags;
}

class CXTranslationUnitImpl extends ffi.Struct {}

/// Provides the contents of a file that has not yet been saved to disk.
///
/// Each CXUnsavedFile instance provides the name of a file on the
/// system along with the current contents of that file that have not
/// yet been saved to disk.
class CXUnsavedFile extends ffi.Struct {
  /// The file whose contents have not yet been saved.
  ///
  /// This file must already exist in the file system.
  ffi.Pointer<ffi.Int8> Filename;

  /// A buffer containing the unsaved contents of this file.
  ffi.Pointer<ffi.Int8> Contents;

  /// The length of the unsaved contents of this buffer.
  @ffi.Uint64()
  int Length;
}

/// Identifies a specific source location within a translation
/// unit.
///
/// Use clang_getExpansionLocation() or clang_getSpellingLocation()
/// to map a source location to a particular file, line, and column.
class CXSourceLocation extends ffi.Struct {
  ffi.Pointer<ffi.Void> _unique_ptr_data_item_0;
  ffi.Pointer<ffi.Void> _unique_ptr_data_item_1;

  /// Helper for array `ptr_data`.
  ArrayHelper_CXSourceLocation_ptr_data_level0 get ptr_data =>
      ArrayHelper_CXSourceLocation_ptr_data_level0(this, [2], 0, 0);
  @ffi.Uint32()
  int int_data;
}

/// Helper for array `ptr_data` in struct `CXSourceLocation`.
class ArrayHelper_CXSourceLocation_ptr_data_level0 {
  final CXSourceLocation _struct;
  final List<int> dimensions;
  final int level;
  final int _absoluteIndex;
  int get length => dimensions[level];
  ArrayHelper_CXSourceLocation_ptr_data_level0(
      this._struct, this.dimensions, this.level, this._absoluteIndex);
  void _checkBounds(int index) {
    if (index >= length || index < 0) {
      throw RangeError(
          'Dimension $level: index not in range 0..${length} exclusive.');
    }
  }

  ffi.Pointer<ffi.Void> operator [](int index) {
    _checkBounds(index);
    switch (_absoluteIndex + index) {
      case 0:
        return _struct._unique_ptr_data_item_0;
      case 1:
        return _struct._unique_ptr_data_item_1;
      default:
        throw Exception('Invalid Array Helper generated.');
    }
  }

  void operator []=(int index, ffi.Pointer<ffi.Void> value) {
    _checkBounds(index);
    switch (_absoluteIndex + index) {
      case 0:
        _struct._unique_ptr_data_item_0 = value;
        break;
      case 1:
        _struct._unique_ptr_data_item_1 = value;
        break;
      default:
        throw Exception('Invalid Array Helper generated.');
    }
  }
}

/// Identifies a half-open character range in the source code.
///
/// Use clang_getRangeStart() and clang_getRangeEnd() to retrieve the
/// starting and end locations from a source range, respectively.
class CXSourceRange extends ffi.Struct {
  ffi.Pointer<ffi.Void> _unique_ptr_data_item_0;
  ffi.Pointer<ffi.Void> _unique_ptr_data_item_1;

  /// Helper for array `ptr_data`.
  ArrayHelper_CXSourceRange_ptr_data_level0 get ptr_data =>
      ArrayHelper_CXSourceRange_ptr_data_level0(this, [2], 0, 0);
  @ffi.Uint32()
  int begin_int_data;

  @ffi.Uint32()
  int end_int_data;
}

/// Helper for array `ptr_data` in struct `CXSourceRange`.
class ArrayHelper_CXSourceRange_ptr_data_level0 {
  final CXSourceRange _struct;
  final List<int> dimensions;
  final int level;
  final int _absoluteIndex;
  int get length => dimensions[level];
  ArrayHelper_CXSourceRange_ptr_data_level0(
      this._struct, this.dimensions, this.level, this._absoluteIndex);
  void _checkBounds(int index) {
    if (index >= length || index < 0) {
      throw RangeError(
          'Dimension $level: index not in range 0..${length} exclusive.');
    }
  }

  ffi.Pointer<ffi.Void> operator [](int index) {
    _checkBounds(index);
    switch (_absoluteIndex + index) {
      case 0:
        return _struct._unique_ptr_data_item_0;
      case 1:
        return _struct._unique_ptr_data_item_1;
      default:
        throw Exception('Invalid Array Helper generated.');
    }
  }

  void operator []=(int index, ffi.Pointer<ffi.Void> value) {
    _checkBounds(index);
    switch (_absoluteIndex + index) {
      case 0:
        _struct._unique_ptr_data_item_0 = value;
        break;
      case 1:
        _struct._unique_ptr_data_item_1 = value;
        break;
      default:
        throw Exception('Invalid Array Helper generated.');
    }
  }
}

/// Options to control the display of diagnostics.
///
/// The values in this enum are meant to be combined to customize the
/// behavior of \c clang_formatDiagnostic().
abstract class CXDiagnosticDisplayOptions {
  /// Display the source-location information where the
  /// diagnostic was located.
  ///
  /// When set, diagnostics will be prefixed by the file, line, and
  /// (optionally) column to which the diagnostic refers. For example,
  ///
  /// \code
  /// test.c:28: warning: extra tokens at end of #endif directive
  /// \endcode
  ///
  /// This option corresponds to the clang flag \c -fshow-source-location.
  static const int CXDiagnostic_DisplaySourceLocation = 1;

  /// If displaying the source-location information of the
  /// diagnostic, also include the column number.
  ///
  /// This option corresponds to the clang flag \c -fshow-column.
  static const int CXDiagnostic_DisplayColumn = 2;

  /// If displaying the source-location information of the
  /// diagnostic, also include information about source ranges in a
  /// machine-parsable format.
  ///
  /// This option corresponds to the clang flag
  /// \c -fdiagnostics-print-source-range-info.
  static const int CXDiagnostic_DisplaySourceRanges = 4;

  /// Display the option name associated with this diagnostic, if any.
  ///
  /// The option name displayed (e.g., -Wconversion) will be placed in brackets
  /// after the diagnostic text. This option corresponds to the clang flag
  /// \c -fdiagnostics-show-option.
  static const int CXDiagnostic_DisplayOption = 8;

  /// Display the category number associated with this diagnostic, if any.
  ///
  /// The category number is displayed within brackets after the diagnostic text.
  /// This option corresponds to the clang flag
  /// \c -fdiagnostics-show-category=id.
  static const int CXDiagnostic_DisplayCategoryId = 16;

  /// Display the category name associated with this diagnostic, if any.
  ///
  /// The category name is displayed within brackets after the diagnostic text.
  /// This option corresponds to the clang flag
  /// \c -fdiagnostics-show-category=name.
  static const int CXDiagnostic_DisplayCategoryName = 32;
}

/// Flags that control the creation of translation units.
///
/// The enumerators in this enumeration type are meant to be bitwise
/// ORed together to specify which options should be used when
/// constructing the translation unit.
abstract class CXTranslationUnit_Flags {
  /// Used to indicate that no special translation-unit options are
  /// needed.
  static const int CXTranslationUnit_None = 0;

  /// Used to indicate that the parser should construct a "detailed"
  /// preprocessing record, including all macro definitions and instantiations.
  ///
  /// Constructing a detailed preprocessing record requires more memory
  /// and time to parse, since the information contained in the record
  /// is usually not retained. However, it can be useful for
  /// applications that require more detailed information about the
  /// behavior of the preprocessor.
  static const int CXTranslationUnit_DetailedPreprocessingRecord = 1;

  /// Used to indicate that the translation unit is incomplete.
  ///
  /// When a translation unit is considered "incomplete", semantic
  /// analysis that is typically performed at the end of the
  /// translation unit will be suppressed. For example, this suppresses
  /// the completion of tentative declarations in C and of
  /// instantiation of implicitly-instantiation function templates in
  /// C++. This option is typically used when parsing a header with the
  /// intent of producing a precompiled header.
  static const int CXTranslationUnit_Incomplete = 2;

  /// Used to indicate that the translation unit should be built with an
  /// implicit precompiled header for the preamble.
  ///
  /// An implicit precompiled header is used as an optimization when a
  /// particular translation unit is likely to be reparsed many times
  /// when the sources aren't changing that often. In this case, an
  /// implicit precompiled header will be built containing all of the
  /// initial includes at the top of the main file (what we refer to as
  /// the "preamble" of the file). In subsequent parses, if the
  /// preamble or the files in it have not changed, \c
  /// clang_reparseTranslationUnit() will re-use the implicit
  /// precompiled header to improve parsing performance.
  static const int CXTranslationUnit_PrecompiledPreamble = 4;

  /// Used to indicate that the translation unit should cache some
  /// code-completion results with each reparse of the source file.
  ///
  /// Caching of code-completion results is a performance optimization that
  /// introduces some overhead to reparsing but improves the performance of
  /// code-completion operations.
  static const int CXTranslationUnit_CacheCompletionResults = 8;

  /// Used to indicate that the translation unit will be serialized with
  /// \c clang_saveTranslationUnit.
  ///
  /// This option is typically used when parsing a header with the intent of
  /// producing a precompiled header.
  static const int CXTranslationUnit_ForSerialization = 16;

  /// DEPRECATED: Enabled chained precompiled preambles in C++.
  ///
  /// Note: this is a *temporary* option that is available only while
  /// we are testing C++ precompiled preamble support. It is deprecated.
  static const int CXTranslationUnit_CXXChainedPCH = 32;

  /// Used to indicate that function/method bodies should be skipped while
  /// parsing.
  ///
  /// This option can be used to search for declarations/definitions while
  /// ignoring the usages.
  static const int CXTranslationUnit_SkipFunctionBodies = 64;

  /// Used to indicate that brief documentation comments should be
  /// included into the set of code completions returned from this translation
  /// unit.
  static const int CXTranslationUnit_IncludeBriefCommentsInCodeCompletion = 128;

  /// Used to indicate that the precompiled preamble should be created on
  /// the first parse. Otherwise it will be created on the first reparse. This
  /// trades runtime on the first parse (serializing the preamble takes time) for
  /// reduced runtime on the second parse (can now reuse the preamble).
  static const int CXTranslationUnit_CreatePreambleOnFirstParse = 256;

  /// Do not stop processing when fatal errors are encountered.
  ///
  /// When fatal errors are encountered while parsing a translation unit,
  /// semantic analysis is typically stopped early when compiling code. A common
  /// source for fatal errors are unresolvable include files. For the
  /// purposes of an IDE, this is undesirable behavior and as much information
  /// as possible should be reported. Use this flag to enable this behavior.
  static const int CXTranslationUnit_KeepGoing = 512;

  /// Sets the preprocessor in a mode for parsing a single file only.
  static const int CXTranslationUnit_SingleFileParse = 1024;

  /// Used in combination with CXTranslationUnit_SkipFunctionBodies to
  /// constrain the skipping of function bodies to the preamble.
  ///
  /// The function bodies of the main file are not skipped.
  static const int CXTranslationUnit_LimitSkipFunctionBodiesToPreamble = 2048;

  /// Used to indicate that attributed types should be included in CXType.
  static const int CXTranslationUnit_IncludeAttributedTypes = 4096;

  /// Used to indicate that implicit attributes should be visited.
  static const int CXTranslationUnit_VisitImplicitAttributes = 8192;

  /// Used to indicate that non-errors from included files should be ignored.
  ///
  /// If set, clang_getDiagnosticSetFromTU() will not report e.g. warnings from
  /// included files anymore. This speeds up clang_getDiagnosticSetFromTU() for
  /// the case where these warnings are not of interest, as for an IDE for
  /// example, which typically shows only the diagnostics in the main file.
  static const int CXTranslationUnit_IgnoreNonErrorsFromIncludedFiles = 16384;

  /// Tells the preprocessor not to skip excluded conditional blocks.
  static const int CXTranslationUnit_RetainExcludedConditionalBlocks = 32768;
}

/// Describes the kind of entity that a cursor refers to.
abstract class CXCursorKind {
  /// A declaration whose specific kind is not exposed via this
  /// interface.
  ///
  /// Unexposed declarations have the same operations as any other kind
  /// of declaration; one can extract their location information,
  /// spelling, find their definitions, etc. However, the specific kind
  /// of the declaration is not reported.
  static const int CXCursor_UnexposedDecl = 1;

  /// A C or C++ struct.
  static const int CXCursor_StructDecl = 2;

  /// A C or C++ union.
  static const int CXCursor_UnionDecl = 3;

  /// A C++ class.
  static const int CXCursor_ClassDecl = 4;

  /// An enumeration.
  static const int CXCursor_EnumDecl = 5;

  /// A field (in C) or non-static data member (in C++) in a
  /// struct, union, or C++ class.
  static const int CXCursor_FieldDecl = 6;

  /// An enumerator constant.
  static const int CXCursor_EnumConstantDecl = 7;

  /// A function.
  static const int CXCursor_FunctionDecl = 8;

  /// A variable.
  static const int CXCursor_VarDecl = 9;

  /// A function or method parameter.
  static const int CXCursor_ParmDecl = 10;

  /// An Objective-C \@interface.
  static const int CXCursor_ObjCInterfaceDecl = 11;

  /// An Objective-C \@interface for a category.
  static const int CXCursor_ObjCCategoryDecl = 12;

  /// An Objective-C \@protocol declaration.
  static const int CXCursor_ObjCProtocolDecl = 13;

  /// An Objective-C \@property declaration.
  static const int CXCursor_ObjCPropertyDecl = 14;

  /// An Objective-C instance variable.
  static const int CXCursor_ObjCIvarDecl = 15;

  /// An Objective-C instance method.
  static const int CXCursor_ObjCInstanceMethodDecl = 16;

  /// An Objective-C class method.
  static const int CXCursor_ObjCClassMethodDecl = 17;

  /// An Objective-C \@implementation.
  static const int CXCursor_ObjCImplementationDecl = 18;

  /// An Objective-C \@implementation for a category.
  static const int CXCursor_ObjCCategoryImplDecl = 19;

  /// A typedef.
  static const int CXCursor_TypedefDecl = 20;

  /// A C++ class method.
  static const int CXCursor_CXXMethod = 21;

  /// A C++ namespace.
  static const int CXCursor_Namespace = 22;

  /// A linkage specification, e.g. 'extern "C"'.
  static const int CXCursor_LinkageSpec = 23;

  /// A C++ constructor.
  static const int CXCursor_Constructor = 24;

  /// A C++ destructor.
  static const int CXCursor_Destructor = 25;

  /// A C++ conversion function.
  static const int CXCursor_ConversionFunction = 26;

  /// A C++ template type parameter.
  static const int CXCursor_TemplateTypeParameter = 27;

  /// A C++ non-type template parameter.
  static const int CXCursor_NonTypeTemplateParameter = 28;

  /// A C++ template template parameter.
  static const int CXCursor_TemplateTemplateParameter = 29;

  /// A C++ function template.
  static const int CXCursor_FunctionTemplate = 30;

  /// A C++ class template.
  static const int CXCursor_ClassTemplate = 31;

  /// A C++ class template partial specialization.
  static const int CXCursor_ClassTemplatePartialSpecialization = 32;

  /// A C++ namespace alias declaration.
  static const int CXCursor_NamespaceAlias = 33;

  /// A C++ using directive.
  static const int CXCursor_UsingDirective = 34;

  /// A C++ using declaration.
  static const int CXCursor_UsingDeclaration = 35;

  /// A C++ alias declaration
  static const int CXCursor_TypeAliasDecl = 36;

  /// An Objective-C \@synthesize definition.
  static const int CXCursor_ObjCSynthesizeDecl = 37;

  /// An Objective-C \@dynamic definition.
  static const int CXCursor_ObjCDynamicDecl = 38;

  /// An access specifier.
  static const int CXCursor_CXXAccessSpecifier = 39;
  static const int CXCursor_FirstDecl = 1;
  static const int CXCursor_LastDecl = 39;
  static const int CXCursor_FirstRef = 40;
  static const int CXCursor_ObjCSuperClassRef = 40;
  static const int CXCursor_ObjCProtocolRef = 41;
  static const int CXCursor_ObjCClassRef = 42;

  /// A reference to a type declaration.
  ///
  /// A type reference occurs anywhere where a type is named but not
  /// declared. For example, given:
  ///
  /// \code
  /// typedef unsigned size_type;
  /// size_type size;
  /// \endcode
  ///
  /// The typedef is a declaration of size_type (CXCursor_TypedefDecl),
  /// while the type of the variable "size" is referenced. The cursor
  /// referenced by the type of size is the typedef for size_type.
  static const int CXCursor_TypeRef = 43;
  static const int CXCursor_CXXBaseSpecifier = 44;

  /// A reference to a class template, function template, template
  /// template parameter, or class template partial specialization.
  static const int CXCursor_TemplateRef = 45;

  /// A reference to a namespace or namespace alias.
  static const int CXCursor_NamespaceRef = 46;

  /// A reference to a member of a struct, union, or class that occurs in
  /// some non-expression context, e.g., a designated initializer.
  static const int CXCursor_MemberRef = 47;

  /// A reference to a labeled statement.
  ///
  /// This cursor kind is used to describe the jump to "start_over" in the
  /// goto statement in the following example:
  ///
  /// \code
  /// start_over:
  /// ++counter;
  ///
  /// goto start_over;
  /// \endcode
  ///
  /// A label reference cursor refers to a label statement.
  static const int CXCursor_LabelRef = 48;

  /// A reference to a set of overloaded functions or function templates
  /// that has not yet been resolved to a specific function or function template.
  ///
  /// An overloaded declaration reference cursor occurs in C++ templates where
  /// a dependent name refers to a function. For example:
  ///
  /// \code
  /// template<typename T> void swap(T&, T&);
  ///
  /// struct X { ... };
  /// void swap(X&, X&);
  ///
  /// template<typename T>
  /// void reverse(T* first, T* last) {
  /// while (first < last - 1) {
  /// swap(*first, *--last);
  /// ++first;
  /// }
  /// }
  ///
  /// struct Y { };
  /// void swap(Y&, Y&);
  /// \endcode
  ///
  /// Here, the identifier "swap" is associated with an overloaded declaration
  /// reference. In the template definition, "swap" refers to either of the two
  /// "swap" functions declared above, so both results will be available. At
  /// instantiation time, "swap" may also refer to other functions found via
  /// argument-dependent lookup (e.g., the "swap" function at the end of the
  /// example).
  ///
  /// The functions \c clang_getNumOverloadedDecls() and
  /// \c clang_getOverloadedDecl() can be used to retrieve the definitions
  /// referenced by this cursor.
  static const int CXCursor_OverloadedDeclRef = 49;

  /// A reference to a variable that occurs in some non-expression
  /// context, e.g., a C++ lambda capture list.
  static const int CXCursor_VariableRef = 50;
  static const int CXCursor_LastRef = 50;
  static const int CXCursor_FirstInvalid = 70;
  static const int CXCursor_InvalidFile = 70;
  static const int CXCursor_NoDeclFound = 71;
  static const int CXCursor_NotImplemented = 72;
  static const int CXCursor_InvalidCode = 73;
  static const int CXCursor_LastInvalid = 73;
  static const int CXCursor_FirstExpr = 100;

  /// An expression whose specific kind is not exposed via this
  /// interface.
  ///
  /// Unexposed expressions have the same operations as any other kind
  /// of expression; one can extract their location information,
  /// spelling, children, etc. However, the specific kind of the
  /// expression is not reported.
  static const int CXCursor_UnexposedExpr = 100;

  /// An expression that refers to some value declaration, such
  /// as a function, variable, or enumerator.
  static const int CXCursor_DeclRefExpr = 101;

  /// An expression that refers to a member of a struct, union,
  /// class, Objective-C class, etc.
  static const int CXCursor_MemberRefExpr = 102;

  /// An expression that calls a function.
  static const int CXCursor_CallExpr = 103;

  /// An expression that sends a message to an Objective-C
  /// object or class.
  static const int CXCursor_ObjCMessageExpr = 104;

  /// An expression that represents a block literal.
  static const int CXCursor_BlockExpr = 105;

  /// An integer literal.
  static const int CXCursor_IntegerLiteral = 106;

  /// A floating point number literal.
  static const int CXCursor_FloatingLiteral = 107;

  /// An imaginary number literal.
  static const int CXCursor_ImaginaryLiteral = 108;

  /// A string literal.
  static const int CXCursor_StringLiteral = 109;

  /// A character literal.
  static const int CXCursor_CharacterLiteral = 110;

  /// A parenthesized expression, e.g. "(1)".
  ///
  /// This AST node is only formed if full location information is requested.
  static const int CXCursor_ParenExpr = 111;

  /// This represents the unary-expression's (except sizeof and
  /// alignof).
  static const int CXCursor_UnaryOperator = 112;

  /// [C99 6.5.2.1] Array Subscripting.
  static const int CXCursor_ArraySubscriptExpr = 113;

  /// A builtin binary operation expression such as "x + y" or
  /// "x <= y".
  static const int CXCursor_BinaryOperator = 114;

  /// Compound assignment such as "+=".
  static const int CXCursor_CompoundAssignOperator = 115;

  /// The ?: ternary operator.
  static const int CXCursor_ConditionalOperator = 116;

  /// An explicit cast in C (C99 6.5.4) or a C-style cast in C++
  /// (C++ [expr.cast]), which uses the syntax (Type)expr.
  ///
  /// For example: (int)f.
  static const int CXCursor_CStyleCastExpr = 117;

  /// [C99 6.5.2.5]
  static const int CXCursor_CompoundLiteralExpr = 118;

  /// Describes an C or C++ initializer list.
  static const int CXCursor_InitListExpr = 119;

  /// The GNU address of label extension, representing &&label.
  static const int CXCursor_AddrLabelExpr = 120;

  /// This is the GNU Statement Expression extension: ({int X=4; X;})
  static const int CXCursor_StmtExpr = 121;

  /// Represents a C11 generic selection.
  static const int CXCursor_GenericSelectionExpr = 122;

  /// Implements the GNU __null extension, which is a name for a null
  /// pointer constant that has integral type (e.g., int or long) and is the same
  /// size and alignment as a pointer.
  ///
  /// The __null extension is typically only used by system headers, which define
  /// NULL as __null in C++ rather than using 0 (which is an integer that may not
  /// match the size of a pointer).
  static const int CXCursor_GNUNullExpr = 123;

  /// C++'s static_cast<> expression.
  static const int CXCursor_CXXStaticCastExpr = 124;

  /// C++'s dynamic_cast<> expression.
  static const int CXCursor_CXXDynamicCastExpr = 125;

  /// C++'s reinterpret_cast<> expression.
  static const int CXCursor_CXXReinterpretCastExpr = 126;

  /// C++'s const_cast<> expression.
  static const int CXCursor_CXXConstCastExpr = 127;

  /// Represents an explicit C++ type conversion that uses "functional"
  /// notion (C++ [expr.type.conv]).
  ///
  /// Example:
  /// \code
  /// x = int(0.5);
  /// \endcode
  static const int CXCursor_CXXFunctionalCastExpr = 128;

  /// A C++ typeid expression (C++ [expr.typeid]).
  static const int CXCursor_CXXTypeidExpr = 129;

  /// [C++ 2.13.5] C++ Boolean Literal.
  static const int CXCursor_CXXBoolLiteralExpr = 130;

  /// [C++0x 2.14.7] C++ Pointer Literal.
  static const int CXCursor_CXXNullPtrLiteralExpr = 131;

  /// Represents the "this" expression in C++
  static const int CXCursor_CXXThisExpr = 132;

  /// [C++ 15] C++ Throw Expression.
  ///
  /// This handles 'throw' and 'throw' assignment-expression. When
  /// assignment-expression isn't present, Op will be null.
  static const int CXCursor_CXXThrowExpr = 133;

  /// A new expression for memory allocation and constructor calls, e.g:
  /// "new CXXNewExpr(foo)".
  static const int CXCursor_CXXNewExpr = 134;

  /// A delete expression for memory deallocation and destructor calls,
  /// e.g. "delete[] pArray".
  static const int CXCursor_CXXDeleteExpr = 135;

  /// A unary expression. (noexcept, sizeof, or other traits)
  static const int CXCursor_UnaryExpr = 136;

  /// An Objective-C string literal i.e. @"foo".
  static const int CXCursor_ObjCStringLiteral = 137;

  /// An Objective-C \@encode expression.
  static const int CXCursor_ObjCEncodeExpr = 138;

  /// An Objective-C \@selector expression.
  static const int CXCursor_ObjCSelectorExpr = 139;

  /// An Objective-C \@protocol expression.
  static const int CXCursor_ObjCProtocolExpr = 140;

  /// An Objective-C "bridged" cast expression, which casts between
  /// Objective-C pointers and C pointers, transferring ownership in the process.
  ///
  /// \code
  /// NSString *str = (__bridge_transfer NSString *)CFCreateString();
  /// \endcode
  static const int CXCursor_ObjCBridgedCastExpr = 141;

  /// Represents a C++0x pack expansion that produces a sequence of
  /// expressions.
  ///
  /// A pack expansion expression contains a pattern (which itself is an
  /// expression) followed by an ellipsis. For example:
  ///
  /// \code
  /// template<typename F, typename ...Types>
  /// void forward(F f, Types &&...args) {
  /// f(static_cast<Types&&>(args)...);
  /// }
  /// \endcode
  static const int CXCursor_PackExpansionExpr = 142;

  /// Represents an expression that computes the length of a parameter
  /// pack.
  ///
  /// \code
  /// template<typename ...Types>
  /// struct count {
  /// static const unsigned value = sizeof...(Types);
  /// };
  /// \endcode
  static const int CXCursor_SizeOfPackExpr = 143;
  static const int CXCursor_LambdaExpr = 144;

  /// Objective-c Boolean Literal.
  static const int CXCursor_ObjCBoolLiteralExpr = 145;

  /// Represents the "self" expression in an Objective-C method.
  static const int CXCursor_ObjCSelfExpr = 146;

  /// OpenMP 4.0 [2.4, Array Section].
  static const int CXCursor_OMPArraySectionExpr = 147;

  /// Represents an @available(...) check.
  static const int CXCursor_ObjCAvailabilityCheckExpr = 148;

  /// Fixed point literal
  static const int CXCursor_FixedPointLiteral = 149;
  static const int CXCursor_LastExpr = 149;
  static const int CXCursor_FirstStmt = 200;

  /// A statement whose specific kind is not exposed via this
  /// interface.
  ///
  /// Unexposed statements have the same operations as any other kind of
  /// statement; one can extract their location information, spelling,
  /// children, etc. However, the specific kind of the statement is not
  /// reported.
  static const int CXCursor_UnexposedStmt = 200;

  /// A labelled statement in a function.
  ///
  /// This cursor kind is used to describe the "start_over:" label statement in
  /// the following example:
  ///
  /// \code
  /// start_over:
  /// ++counter;
  /// \endcode
  static const int CXCursor_LabelStmt = 201;

  /// A group of statements like { stmt stmt }.
  ///
  /// This cursor kind is used to describe compound statements, e.g. function
  /// bodies.
  static const int CXCursor_CompoundStmt = 202;

  /// A case statement.
  static const int CXCursor_CaseStmt = 203;

  /// A default statement.
  static const int CXCursor_DefaultStmt = 204;

  /// An if statement
  static const int CXCursor_IfStmt = 205;

  /// A switch statement.
  static const int CXCursor_SwitchStmt = 206;

  /// A while statement.
  static const int CXCursor_WhileStmt = 207;

  /// A do statement.
  static const int CXCursor_DoStmt = 208;

  /// A for statement.
  static const int CXCursor_ForStmt = 209;

  /// A goto statement.
  static const int CXCursor_GotoStmt = 210;

  /// An indirect goto statement.
  static const int CXCursor_IndirectGotoStmt = 211;

  /// A continue statement.
  static const int CXCursor_ContinueStmt = 212;

  /// A break statement.
  static const int CXCursor_BreakStmt = 213;

  /// A return statement.
  static const int CXCursor_ReturnStmt = 214;

  /// A GCC inline assembly statement extension.
  static const int CXCursor_GCCAsmStmt = 215;
  static const int CXCursor_AsmStmt = 215;

  /// Objective-C's overall \@try-\@catch-\@finally statement.
  static const int CXCursor_ObjCAtTryStmt = 216;

  /// Objective-C's \@catch statement.
  static const int CXCursor_ObjCAtCatchStmt = 217;

  /// Objective-C's \@finally statement.
  static const int CXCursor_ObjCAtFinallyStmt = 218;

  /// Objective-C's \@throw statement.
  static const int CXCursor_ObjCAtThrowStmt = 219;

  /// Objective-C's \@synchronized statement.
  static const int CXCursor_ObjCAtSynchronizedStmt = 220;

  /// Objective-C's autorelease pool statement.
  static const int CXCursor_ObjCAutoreleasePoolStmt = 221;

  /// Objective-C's collection statement.
  static const int CXCursor_ObjCForCollectionStmt = 222;

  /// C++'s catch statement.
  static const int CXCursor_CXXCatchStmt = 223;

  /// C++'s try statement.
  static const int CXCursor_CXXTryStmt = 224;

  /// C++'s for (* : *) statement.
  static const int CXCursor_CXXForRangeStmt = 225;

  /// Windows Structured Exception Handling's try statement.
  static const int CXCursor_SEHTryStmt = 226;

  /// Windows Structured Exception Handling's except statement.
  static const int CXCursor_SEHExceptStmt = 227;

  /// Windows Structured Exception Handling's finally statement.
  static const int CXCursor_SEHFinallyStmt = 228;

  /// A MS inline assembly statement extension.
  static const int CXCursor_MSAsmStmt = 229;

  /// The null statement ";": C99 6.8.3p3.
  ///
  /// This cursor kind is used to describe the null statement.
  static const int CXCursor_NullStmt = 230;

  /// Adaptor class for mixing declarations with statements and
  /// expressions.
  static const int CXCursor_DeclStmt = 231;

  /// OpenMP parallel directive.
  static const int CXCursor_OMPParallelDirective = 232;

  /// OpenMP SIMD directive.
  static const int CXCursor_OMPSimdDirective = 233;

  /// OpenMP for directive.
  static const int CXCursor_OMPForDirective = 234;

  /// OpenMP sections directive.
  static const int CXCursor_OMPSectionsDirective = 235;

  /// OpenMP section directive.
  static const int CXCursor_OMPSectionDirective = 236;

  /// OpenMP single directive.
  static const int CXCursor_OMPSingleDirective = 237;

  /// OpenMP parallel for directive.
  static const int CXCursor_OMPParallelForDirective = 238;

  /// OpenMP parallel sections directive.
  static const int CXCursor_OMPParallelSectionsDirective = 239;

  /// OpenMP task directive.
  static const int CXCursor_OMPTaskDirective = 240;

  /// OpenMP master directive.
  static const int CXCursor_OMPMasterDirective = 241;

  /// OpenMP critical directive.
  static const int CXCursor_OMPCriticalDirective = 242;

  /// OpenMP taskyield directive.
  static const int CXCursor_OMPTaskyieldDirective = 243;

  /// OpenMP barrier directive.
  static const int CXCursor_OMPBarrierDirective = 244;

  /// OpenMP taskwait directive.
  static const int CXCursor_OMPTaskwaitDirective = 245;

  /// OpenMP flush directive.
  static const int CXCursor_OMPFlushDirective = 246;

  /// Windows Structured Exception Handling's leave statement.
  static const int CXCursor_SEHLeaveStmt = 247;

  /// OpenMP ordered directive.
  static const int CXCursor_OMPOrderedDirective = 248;

  /// OpenMP atomic directive.
  static const int CXCursor_OMPAtomicDirective = 249;

  /// OpenMP for SIMD directive.
  static const int CXCursor_OMPForSimdDirective = 250;

  /// OpenMP parallel for SIMD directive.
  static const int CXCursor_OMPParallelForSimdDirective = 251;

  /// OpenMP target directive.
  static const int CXCursor_OMPTargetDirective = 252;

  /// OpenMP teams directive.
  static const int CXCursor_OMPTeamsDirective = 253;

  /// OpenMP taskgroup directive.
  static const int CXCursor_OMPTaskgroupDirective = 254;

  /// OpenMP cancellation point directive.
  static const int CXCursor_OMPCancellationPointDirective = 255;

  /// OpenMP cancel directive.
  static const int CXCursor_OMPCancelDirective = 256;

  /// OpenMP target data directive.
  static const int CXCursor_OMPTargetDataDirective = 257;

  /// OpenMP taskloop directive.
  static const int CXCursor_OMPTaskLoopDirective = 258;

  /// OpenMP taskloop simd directive.
  static const int CXCursor_OMPTaskLoopSimdDirective = 259;

  /// OpenMP distribute directive.
  static const int CXCursor_OMPDistributeDirective = 260;

  /// OpenMP target enter data directive.
  static const int CXCursor_OMPTargetEnterDataDirective = 261;

  /// OpenMP target exit data directive.
  static const int CXCursor_OMPTargetExitDataDirective = 262;

  /// OpenMP target parallel directive.
  static const int CXCursor_OMPTargetParallelDirective = 263;

  /// OpenMP target parallel for directive.
  static const int CXCursor_OMPTargetParallelForDirective = 264;

  /// OpenMP target update directive.
  static const int CXCursor_OMPTargetUpdateDirective = 265;

  /// OpenMP distribute parallel for directive.
  static const int CXCursor_OMPDistributeParallelForDirective = 266;

  /// OpenMP distribute parallel for simd directive.
  static const int CXCursor_OMPDistributeParallelForSimdDirective = 267;

  /// OpenMP distribute simd directive.
  static const int CXCursor_OMPDistributeSimdDirective = 268;

  /// OpenMP target parallel for simd directive.
  static const int CXCursor_OMPTargetParallelForSimdDirective = 269;

  /// OpenMP target simd directive.
  static const int CXCursor_OMPTargetSimdDirective = 270;

  /// OpenMP teams distribute directive.
  static const int CXCursor_OMPTeamsDistributeDirective = 271;

  /// OpenMP teams distribute simd directive.
  static const int CXCursor_OMPTeamsDistributeSimdDirective = 272;

  /// OpenMP teams distribute parallel for simd directive.
  static const int CXCursor_OMPTeamsDistributeParallelForSimdDirective = 273;

  /// OpenMP teams distribute parallel for directive.
  static const int CXCursor_OMPTeamsDistributeParallelForDirective = 274;

  /// OpenMP target teams directive.
  static const int CXCursor_OMPTargetTeamsDirective = 275;

  /// OpenMP target teams distribute directive.
  static const int CXCursor_OMPTargetTeamsDistributeDirective = 276;

  /// OpenMP target teams distribute parallel for directive.
  static const int CXCursor_OMPTargetTeamsDistributeParallelForDirective = 277;

  /// OpenMP target teams distribute parallel for simd directive.
  static const int CXCursor_OMPTargetTeamsDistributeParallelForSimdDirective =
      278;

  /// OpenMP target teams distribute simd directive.
  static const int CXCursor_OMPTargetTeamsDistributeSimdDirective = 279;

  /// C++2a std::bit_cast expression.
  static const int CXCursor_BuiltinBitCastExpr = 280;

  /// OpenMP master taskloop directive.
  static const int CXCursor_OMPMasterTaskLoopDirective = 281;

  /// OpenMP parallel master taskloop directive.
  static const int CXCursor_OMPParallelMasterTaskLoopDirective = 282;

  /// OpenMP master taskloop simd directive.
  static const int CXCursor_OMPMasterTaskLoopSimdDirective = 283;

  /// OpenMP parallel master taskloop simd directive.
  static const int CXCursor_OMPParallelMasterTaskLoopSimdDirective = 284;

  /// OpenMP parallel master directive.
  static const int CXCursor_OMPParallelMasterDirective = 285;
  static const int CXCursor_LastStmt = 285;

  /// Cursor that represents the translation unit itself.
  ///
  /// The translation unit cursor exists primarily to act as the root
  /// cursor for traversing the contents of a translation unit.
  static const int CXCursor_TranslationUnit = 300;
  static const int CXCursor_FirstAttr = 400;

  /// An attribute whose specific kind is not exposed via this
  /// interface.
  static const int CXCursor_UnexposedAttr = 400;
  static const int CXCursor_IBActionAttr = 401;
  static const int CXCursor_IBOutletAttr = 402;
  static const int CXCursor_IBOutletCollectionAttr = 403;
  static const int CXCursor_CXXFinalAttr = 404;
  static const int CXCursor_CXXOverrideAttr = 405;
  static const int CXCursor_AnnotateAttr = 406;
  static const int CXCursor_AsmLabelAttr = 407;
  static const int CXCursor_PackedAttr = 408;
  static const int CXCursor_PureAttr = 409;
  static const int CXCursor_ConstAttr = 410;
  static const int CXCursor_NoDuplicateAttr = 411;
  static const int CXCursor_CUDAConstantAttr = 412;
  static const int CXCursor_CUDADeviceAttr = 413;
  static const int CXCursor_CUDAGlobalAttr = 414;
  static const int CXCursor_CUDAHostAttr = 415;
  static const int CXCursor_CUDASharedAttr = 416;
  static const int CXCursor_VisibilityAttr = 417;
  static const int CXCursor_DLLExport = 418;
  static const int CXCursor_DLLImport = 419;
  static const int CXCursor_NSReturnsRetained = 420;
  static const int CXCursor_NSReturnsNotRetained = 421;
  static const int CXCursor_NSReturnsAutoreleased = 422;
  static const int CXCursor_NSConsumesSelf = 423;
  static const int CXCursor_NSConsumed = 424;
  static const int CXCursor_ObjCException = 425;
  static const int CXCursor_ObjCNSObject = 426;
  static const int CXCursor_ObjCIndependentClass = 427;
  static const int CXCursor_ObjCPreciseLifetime = 428;
  static const int CXCursor_ObjCReturnsInnerPointer = 429;
  static const int CXCursor_ObjCRequiresSuper = 430;
  static const int CXCursor_ObjCRootClass = 431;
  static const int CXCursor_ObjCSubclassingRestricted = 432;
  static const int CXCursor_ObjCExplicitProtocolImpl = 433;
  static const int CXCursor_ObjCDesignatedInitializer = 434;
  static const int CXCursor_ObjCRuntimeVisible = 435;
  static const int CXCursor_ObjCBoxable = 436;
  static const int CXCursor_FlagEnum = 437;
  static const int CXCursor_ConvergentAttr = 438;
  static const int CXCursor_WarnUnusedAttr = 439;
  static const int CXCursor_WarnUnusedResultAttr = 440;
  static const int CXCursor_AlignedAttr = 441;
  static const int CXCursor_LastAttr = 441;
  static const int CXCursor_PreprocessingDirective = 500;
  static const int CXCursor_MacroDefinition = 501;
  static const int CXCursor_MacroExpansion = 502;
  static const int CXCursor_MacroInstantiation = 502;
  static const int CXCursor_InclusionDirective = 503;
  static const int CXCursor_FirstPreprocessing = 500;
  static const int CXCursor_LastPreprocessing = 503;

  /// A module import declaration.
  static const int CXCursor_ModuleImportDecl = 600;
  static const int CXCursor_TypeAliasTemplateDecl = 601;

  /// A static_assert or _Static_assert node
  static const int CXCursor_StaticAssert = 602;

  /// a friend declaration.
  static const int CXCursor_FriendDecl = 603;
  static const int CXCursor_FirstExtraDecl = 600;
  static const int CXCursor_LastExtraDecl = 603;

  /// A code completion overload candidate.
  static const int CXCursor_OverloadCandidate = 700;
}

/// A cursor representing some element in the abstract syntax tree for
/// a translation unit.
///
/// The cursor abstraction unifies the different kinds of entities in a
/// program--declaration, statements, expressions, references to declarations,
/// etc.--under a single "cursor" abstraction with a common set of operations.
/// Common operation for a cursor include: getting the physical location in
/// a source file where the cursor points, getting the name associated with a
/// cursor, and retrieving cursors for any child nodes of a particular cursor.
///
/// Cursors can be produced in two specific ways.
/// clang_getTranslationUnitCursor() produces a cursor for a translation unit,
/// from which one can use clang_visitChildren() to explore the rest of the
/// translation unit. clang_getCursor() maps from a physical source location
/// to the entity that resides at that location, allowing one to map from the
/// source code into the AST.
class CXCursor extends ffi.Struct {
  @ffi.Int32()
  int kind;

  @ffi.Int32()
  int xdata;

  ffi.Pointer<ffi.Void> _unique_data_item_0;
  ffi.Pointer<ffi.Void> _unique_data_item_1;
  ffi.Pointer<ffi.Void> _unique_data_item_2;

  /// Helper for array `data`.
  ArrayHelper_CXCursor_data_level0 get data =>
      ArrayHelper_CXCursor_data_level0(this, [3], 0, 0);
}

/// Helper for array `data` in struct `CXCursor`.
class ArrayHelper_CXCursor_data_level0 {
  final CXCursor _struct;
  final List<int> dimensions;
  final int level;
  final int _absoluteIndex;
  int get length => dimensions[level];
  ArrayHelper_CXCursor_data_level0(
      this._struct, this.dimensions, this.level, this._absoluteIndex);
  void _checkBounds(int index) {
    if (index >= length || index < 0) {
      throw RangeError(
          'Dimension $level: index not in range 0..${length} exclusive.');
    }
  }

  ffi.Pointer<ffi.Void> operator [](int index) {
    _checkBounds(index);
    switch (_absoluteIndex + index) {
      case 0:
        return _struct._unique_data_item_0;
      case 1:
        return _struct._unique_data_item_1;
      case 2:
        return _struct._unique_data_item_2;
      default:
        throw Exception('Invalid Array Helper generated.');
    }
  }

  void operator []=(int index, ffi.Pointer<ffi.Void> value) {
    _checkBounds(index);
    switch (_absoluteIndex + index) {
      case 0:
        _struct._unique_data_item_0 = value;
        break;
      case 1:
        _struct._unique_data_item_1 = value;
        break;
      case 2:
        _struct._unique_data_item_2 = value;
        break;
      default:
        throw Exception('Invalid Array Helper generated.');
    }
  }
}

/// Describes the kind of type
abstract class CXTypeKind {
  /// Represents an invalid type (e.g., where no type is available).
  static const int CXType_Invalid = 0;

  /// A type whose specific kind is not exposed via this
  /// interface.
  static const int CXType_Unexposed = 1;
  static const int CXType_Void = 2;
  static const int CXType_Bool = 3;
  static const int CXType_Char_U = 4;
  static const int CXType_UChar = 5;
  static const int CXType_Char16 = 6;
  static const int CXType_Char32 = 7;
  static const int CXType_UShort = 8;
  static const int CXType_UInt = 9;
  static const int CXType_ULong = 10;
  static const int CXType_ULongLong = 11;
  static const int CXType_UInt128 = 12;
  static const int CXType_Char_S = 13;
  static const int CXType_SChar = 14;
  static const int CXType_WChar = 15;
  static const int CXType_Short = 16;
  static const int CXType_Int = 17;
  static const int CXType_Long = 18;
  static const int CXType_LongLong = 19;
  static const int CXType_Int128 = 20;
  static const int CXType_Float = 21;
  static const int CXType_Double = 22;
  static const int CXType_LongDouble = 23;
  static const int CXType_NullPtr = 24;
  static const int CXType_Overload = 25;
  static const int CXType_Dependent = 26;
  static const int CXType_ObjCId = 27;
  static const int CXType_ObjCClass = 28;
  static const int CXType_ObjCSel = 29;
  static const int CXType_Float128 = 30;
  static const int CXType_Half = 31;
  static const int CXType_Float16 = 32;
  static const int CXType_ShortAccum = 33;
  static const int CXType_Accum = 34;
  static const int CXType_LongAccum = 35;
  static const int CXType_UShortAccum = 36;
  static const int CXType_UAccum = 37;
  static const int CXType_ULongAccum = 38;
  static const int CXType_FirstBuiltin = 2;
  static const int CXType_LastBuiltin = 38;
  static const int CXType_Complex = 100;
  static const int CXType_Pointer = 101;
  static const int CXType_BlockPointer = 102;
  static const int CXType_LValueReference = 103;
  static const int CXType_RValueReference = 104;
  static const int CXType_Record = 105;
  static const int CXType_Enum = 106;
  static const int CXType_Typedef = 107;
  static const int CXType_ObjCInterface = 108;
  static const int CXType_ObjCObjectPointer = 109;
  static const int CXType_FunctionNoProto = 110;
  static const int CXType_FunctionProto = 111;
  static const int CXType_ConstantArray = 112;
  static const int CXType_Vector = 113;
  static const int CXType_IncompleteArray = 114;
  static const int CXType_VariableArray = 115;
  static const int CXType_DependentSizedArray = 116;
  static const int CXType_MemberPointer = 117;
  static const int CXType_Auto = 118;

  /// Represents a type that was referred to using an elaborated type keyword.
  ///
  /// E.g., struct S, or via a qualified name, e.g., N::M::type, or both.
  static const int CXType_Elaborated = 119;
  static const int CXType_Pipe = 120;
  static const int CXType_OCLImage1dRO = 121;
  static const int CXType_OCLImage1dArrayRO = 122;
  static const int CXType_OCLImage1dBufferRO = 123;
  static const int CXType_OCLImage2dRO = 124;
  static const int CXType_OCLImage2dArrayRO = 125;
  static const int CXType_OCLImage2dDepthRO = 126;
  static const int CXType_OCLImage2dArrayDepthRO = 127;
  static const int CXType_OCLImage2dMSAARO = 128;
  static const int CXType_OCLImage2dArrayMSAARO = 129;
  static const int CXType_OCLImage2dMSAADepthRO = 130;
  static const int CXType_OCLImage2dArrayMSAADepthRO = 131;
  static const int CXType_OCLImage3dRO = 132;
  static const int CXType_OCLImage1dWO = 133;
  static const int CXType_OCLImage1dArrayWO = 134;
  static const int CXType_OCLImage1dBufferWO = 135;
  static const int CXType_OCLImage2dWO = 136;
  static const int CXType_OCLImage2dArrayWO = 137;
  static const int CXType_OCLImage2dDepthWO = 138;
  static const int CXType_OCLImage2dArrayDepthWO = 139;
  static const int CXType_OCLImage2dMSAAWO = 140;
  static const int CXType_OCLImage2dArrayMSAAWO = 141;
  static const int CXType_OCLImage2dMSAADepthWO = 142;
  static const int CXType_OCLImage2dArrayMSAADepthWO = 143;
  static const int CXType_OCLImage3dWO = 144;
  static const int CXType_OCLImage1dRW = 145;
  static const int CXType_OCLImage1dArrayRW = 146;
  static const int CXType_OCLImage1dBufferRW = 147;
  static const int CXType_OCLImage2dRW = 148;
  static const int CXType_OCLImage2dArrayRW = 149;
  static const int CXType_OCLImage2dDepthRW = 150;
  static const int CXType_OCLImage2dArrayDepthRW = 151;
  static const int CXType_OCLImage2dMSAARW = 152;
  static const int CXType_OCLImage2dArrayMSAARW = 153;
  static const int CXType_OCLImage2dMSAADepthRW = 154;
  static const int CXType_OCLImage2dArrayMSAADepthRW = 155;
  static const int CXType_OCLImage3dRW = 156;
  static const int CXType_OCLSampler = 157;
  static const int CXType_OCLEvent = 158;
  static const int CXType_OCLQueue = 159;
  static const int CXType_OCLReserveID = 160;
  static const int CXType_ObjCObject = 161;
  static const int CXType_ObjCTypeParam = 162;
  static const int CXType_Attributed = 163;
  static const int CXType_OCLIntelSubgroupAVCMcePayload = 164;
  static const int CXType_OCLIntelSubgroupAVCImePayload = 165;
  static const int CXType_OCLIntelSubgroupAVCRefPayload = 166;
  static const int CXType_OCLIntelSubgroupAVCSicPayload = 167;
  static const int CXType_OCLIntelSubgroupAVCMceResult = 168;
  static const int CXType_OCLIntelSubgroupAVCImeResult = 169;
  static const int CXType_OCLIntelSubgroupAVCRefResult = 170;
  static const int CXType_OCLIntelSubgroupAVCSicResult = 171;
  static const int CXType_OCLIntelSubgroupAVCImeResultSingleRefStreamout = 172;
  static const int CXType_OCLIntelSubgroupAVCImeResultDualRefStreamout = 173;
  static const int CXType_OCLIntelSubgroupAVCImeSingleRefStreamin = 174;
  static const int CXType_OCLIntelSubgroupAVCImeDualRefStreamin = 175;
  static const int CXType_ExtVector = 176;
}

/// The type of an element in the abstract syntax tree.
class CXType extends ffi.Struct {
  @ffi.Int32()
  int kind;

  ffi.Pointer<ffi.Void> _unique_data_item_0;
  ffi.Pointer<ffi.Void> _unique_data_item_1;

  /// Helper for array `data`.
  ArrayHelper_CXType_data_level0 get data =>
      ArrayHelper_CXType_data_level0(this, [2], 0, 0);
}

/// Helper for array `data` in struct `CXType`.
class ArrayHelper_CXType_data_level0 {
  final CXType _struct;
  final List<int> dimensions;
  final int level;
  final int _absoluteIndex;
  int get length => dimensions[level];
  ArrayHelper_CXType_data_level0(
      this._struct, this.dimensions, this.level, this._absoluteIndex);
  void _checkBounds(int index) {
    if (index >= length || index < 0) {
      throw RangeError(
          'Dimension $level: index not in range 0..${length} exclusive.');
    }
  }

  ffi.Pointer<ffi.Void> operator [](int index) {
    _checkBounds(index);
    switch (_absoluteIndex + index) {
      case 0:
        return _struct._unique_data_item_0;
      case 1:
        return _struct._unique_data_item_1;
      default:
        throw Exception('Invalid Array Helper generated.');
    }
  }

  void operator []=(int index, ffi.Pointer<ffi.Void> value) {
    _checkBounds(index);
    switch (_absoluteIndex + index) {
      case 0:
        _struct._unique_data_item_0 = value;
        break;
      case 1:
        _struct._unique_data_item_1 = value;
        break;
      default:
        throw Exception('Invalid Array Helper generated.');
    }
  }
}

/// Describes how the traversal of the children of a particular
/// cursor should proceed after visiting a particular child cursor.
///
/// A value of this enumeration type should be returned by each
/// \c CXCursorVisitor to indicate how clang_visitChildren() proceed.
abstract class CXChildVisitResult {
  /// Terminates the cursor traversal.
  static const int CXChildVisit_Break = 0;

  /// Continues the cursor traversal with the next sibling of
  /// the cursor just visited, without visiting its children.
  static const int CXChildVisit_Continue = 1;

  /// Recursively traverse the children of this cursor, using
  /// the same visitor and client data.
  static const int CXChildVisit_Recurse = 2;
}

abstract class CXEvalResultKind {
  static const int CXEval_Int = 1;
  static const int CXEval_Float = 2;
  static const int CXEval_ObjCStrLiteral = 3;
  static const int CXEval_StrLiteral = 4;
  static const int CXEval_CFStr = 5;
  static const int CXEval_Other = 6;
  static const int CXEval_UnExposed = 0;
}

const int CINDEX_VERSION_MAJOR = 0;

const int CINDEX_VERSION_MINOR = 59;

const int CINDEX_VERSION = 59;

const String CINDEX_VERSION_STRING = '0.59';

typedef _c_clang_createIndex = ffi.Pointer<ffi.Void> Function(
  ffi.Int32 excludeDeclarationsFromPCH,
  ffi.Int32 displayDiagnostics,
);

typedef _dart_clang_createIndex = ffi.Pointer<ffi.Void> Function(
  int excludeDeclarationsFromPCH,
  int displayDiagnostics,
);

typedef _c_clang_disposeIndex = ffi.Void Function(
  ffi.Pointer<ffi.Void> index,
);

typedef _dart_clang_disposeIndex = void Function(
  ffi.Pointer<ffi.Void> index,
);

typedef _c_clang_getNumDiagnostics = ffi.Uint32 Function(
  ffi.Pointer<CXTranslationUnitImpl> Unit,
);

typedef _dart_clang_getNumDiagnostics = int Function(
  ffi.Pointer<CXTranslationUnitImpl> Unit,
);

typedef _c_clang_getDiagnostic = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<CXTranslationUnitImpl> Unit,
  ffi.Uint32 Index,
);

typedef _dart_clang_getDiagnostic = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<CXTranslationUnitImpl> Unit,
  int Index,
);

typedef _c_clang_disposeDiagnostic = ffi.Void Function(
  ffi.Pointer<ffi.Void> Diagnostic,
);

typedef _dart_clang_disposeDiagnostic = void Function(
  ffi.Pointer<ffi.Void> Diagnostic,
);

typedef _c_clang_parseTranslationUnit = ffi.Pointer<CXTranslationUnitImpl>
    Function(
  ffi.Pointer<ffi.Void> CIdx,
  ffi.Pointer<ffi.Int8> source_filename,
  ffi.Pointer<ffi.Pointer<ffi.Int8>> command_line_args,
  ffi.Int32 num_command_line_args,
  ffi.Pointer<CXUnsavedFile> unsaved_files,
  ffi.Uint32 num_unsaved_files,
  ffi.Uint32 options,
);

typedef _dart_clang_parseTranslationUnit = ffi.Pointer<CXTranslationUnitImpl>
    Function(
  ffi.Pointer<ffi.Void> CIdx,
  ffi.Pointer<ffi.Int8> source_filename,
  ffi.Pointer<ffi.Pointer<ffi.Int8>> command_line_args,
  int num_command_line_args,
  ffi.Pointer<CXUnsavedFile> unsaved_files,
  int num_unsaved_files,
  int options,
);

typedef _c_clang_disposeTranslationUnit = ffi.Void Function(
  ffi.Pointer<CXTranslationUnitImpl> arg0,
);

typedef _dart_clang_disposeTranslationUnit = void Function(
  ffi.Pointer<CXTranslationUnitImpl> arg0,
);

typedef _c_clang_EvalResult_getKind = ffi.Int32 Function(
  ffi.Pointer<ffi.Void> E,
);

typedef _dart_clang_EvalResult_getKind = int Function(
  ffi.Pointer<ffi.Void> E,
);

typedef _c_clang_EvalResult_getAsInt = ffi.Int32 Function(
  ffi.Pointer<ffi.Void> E,
);

typedef _dart_clang_EvalResult_getAsInt = int Function(
  ffi.Pointer<ffi.Void> E,
);

typedef _c_clang_EvalResult_getAsLongLong = ffi.Int64 Function(
  ffi.Pointer<ffi.Void> E,
);

typedef _dart_clang_EvalResult_getAsLongLong = int Function(
  ffi.Pointer<ffi.Void> E,
);

typedef _c_clang_EvalResult_getAsDouble = ffi.Double Function(
  ffi.Pointer<ffi.Void> E,
);

typedef _dart_clang_EvalResult_getAsDouble = double Function(
  ffi.Pointer<ffi.Void> E,
);

typedef _c_clang_EvalResult_getAsStr = ffi.Pointer<ffi.Int8> Function(
  ffi.Pointer<ffi.Void> E,
);

typedef _dart_clang_EvalResult_getAsStr = ffi.Pointer<ffi.Int8> Function(
  ffi.Pointer<ffi.Void> E,
);

typedef _c_clang_EvalResult_dispose = ffi.Void Function(
  ffi.Pointer<ffi.Void> E,
);

typedef _dart_clang_EvalResult_dispose = void Function(
  ffi.Pointer<ffi.Void> E,
);

typedef _c_clang_getCString_wrap = ffi.Pointer<ffi.Int8> Function(
  ffi.Pointer<CXString> string,
);

typedef _dart_clang_getCString_wrap = ffi.Pointer<ffi.Int8> Function(
  ffi.Pointer<CXString> string,
);

typedef _c_clang_disposeString_wrap = ffi.Void Function(
  ffi.Pointer<CXString> string,
);

typedef _dart_clang_disposeString_wrap = void Function(
  ffi.Pointer<CXString> string,
);

typedef _c_clang_getCursorKind_wrap = ffi.Int32 Function(
  ffi.Pointer<CXCursor> cursor,
);

typedef _dart_clang_getCursorKind_wrap = int Function(
  ffi.Pointer<CXCursor> cursor,
);

typedef _c_clang_getCursorKindSpelling_wrap = ffi.Pointer<CXString> Function(
  ffi.Int32 kind,
);

typedef _dart_clang_getCursorKindSpelling_wrap = ffi.Pointer<CXString> Function(
  int kind,
);

typedef _c_clang_getCursorType_wrap = ffi.Pointer<CXType> Function(
  ffi.Pointer<CXCursor> cursor,
);

typedef _dart_clang_getCursorType_wrap = ffi.Pointer<CXType> Function(
  ffi.Pointer<CXCursor> cursor,
);

typedef _c_clang_getTypeSpelling_wrap = ffi.Pointer<CXString> Function(
  ffi.Pointer<CXType> type,
);

typedef _dart_clang_getTypeSpelling_wrap = ffi.Pointer<CXString> Function(
  ffi.Pointer<CXType> type,
);

typedef _c_clang_getTypeKindSpelling_wrap = ffi.Pointer<CXString> Function(
  ffi.Int32 typeKind,
);

typedef _dart_clang_getTypeKindSpelling_wrap = ffi.Pointer<CXString> Function(
  int typeKind,
);

typedef _c_clang_getResultType_wrap = ffi.Pointer<CXType> Function(
  ffi.Pointer<CXType> functionType,
);

typedef _dart_clang_getResultType_wrap = ffi.Pointer<CXType> Function(
  ffi.Pointer<CXType> functionType,
);

typedef _c_clang_getPointeeType_wrap = ffi.Pointer<CXType> Function(
  ffi.Pointer<CXType> pointerType,
);

typedef _dart_clang_getPointeeType_wrap = ffi.Pointer<CXType> Function(
  ffi.Pointer<CXType> pointerType,
);

typedef _c_clang_getCanonicalType_wrap = ffi.Pointer<CXType> Function(
  ffi.Pointer<CXType> typerefType,
);

typedef _dart_clang_getCanonicalType_wrap = ffi.Pointer<CXType> Function(
  ffi.Pointer<CXType> typerefType,
);

typedef _c_clang_Type_getNamedType_wrap = ffi.Pointer<CXType> Function(
  ffi.Pointer<CXType> elaboratedType,
);

typedef _dart_clang_Type_getNamedType_wrap = ffi.Pointer<CXType> Function(
  ffi.Pointer<CXType> elaboratedType,
);

typedef _c_clang_getTypeDeclaration_wrap = ffi.Pointer<CXCursor> Function(
  ffi.Pointer<CXType> cxtype,
);

typedef _dart_clang_getTypeDeclaration_wrap = ffi.Pointer<CXCursor> Function(
  ffi.Pointer<CXType> cxtype,
);

typedef _c_clang_getTypedefDeclUnderlyingType_wrap = ffi.Pointer<CXType>
    Function(
  ffi.Pointer<CXCursor> cxcursor,
);

typedef _dart_clang_getTypedefDeclUnderlyingType_wrap = ffi.Pointer<CXType>
    Function(
  ffi.Pointer<CXCursor> cxcursor,
);

typedef _c_clang_getCursorSpelling_wrap = ffi.Pointer<CXString> Function(
  ffi.Pointer<CXCursor> cursor,
);

typedef _dart_clang_getCursorSpelling_wrap = ffi.Pointer<CXString> Function(
  ffi.Pointer<CXCursor> cursor,
);

typedef _c_clang_getTranslationUnitCursor_wrap = ffi.Pointer<CXCursor> Function(
  ffi.Pointer<CXTranslationUnitImpl> tu,
);

typedef _dart_clang_getTranslationUnitCursor_wrap = ffi.Pointer<CXCursor>
    Function(
  ffi.Pointer<CXTranslationUnitImpl> tu,
);

typedef _c_clang_formatDiagnostic_wrap = ffi.Pointer<CXString> Function(
  ffi.Pointer<ffi.Void> diag,
  ffi.Int32 opts,
);

typedef _dart_clang_formatDiagnostic_wrap = ffi.Pointer<CXString> Function(
  ffi.Pointer<ffi.Void> diag,
  int opts,
);

typedef ModifiedCXCursorVisitor = ffi.Int32 Function(
  ffi.Pointer<CXCursor>,
  ffi.Pointer<CXCursor>,
  ffi.Pointer<ffi.Void>,
);

typedef _c_clang_visitChildren_wrap = ffi.Uint32 Function(
  ffi.Pointer<CXCursor> parent,
  ffi.Pointer<ffi.NativeFunction<ModifiedCXCursorVisitor>> _modifiedVisitor,
  ffi.Int64 uid,
);

typedef _dart_clang_visitChildren_wrap = int Function(
  ffi.Pointer<CXCursor> parent,
  ffi.Pointer<ffi.NativeFunction<ModifiedCXCursorVisitor>> _modifiedVisitor,
  int uid,
);

typedef _c_clang_Cursor_getNumArguments_wrap = ffi.Int32 Function(
  ffi.Pointer<CXCursor> cursor,
);

typedef _dart_clang_Cursor_getNumArguments_wrap = int Function(
  ffi.Pointer<CXCursor> cursor,
);

typedef _c_clang_Cursor_getArgument_wrap = ffi.Pointer<CXCursor> Function(
  ffi.Pointer<CXCursor> cursor,
  ffi.Uint32 i,
);

typedef _dart_clang_Cursor_getArgument_wrap = ffi.Pointer<CXCursor> Function(
  ffi.Pointer<CXCursor> cursor,
  int i,
);

typedef _c_clang_getNumArgTypes_wrap = ffi.Int32 Function(
  ffi.Pointer<CXType> cxtype,
);

typedef _dart_clang_getNumArgTypes_wrap = int Function(
  ffi.Pointer<CXType> cxtype,
);

typedef _c_clang_getArgType_wrap = ffi.Pointer<CXType> Function(
  ffi.Pointer<CXType> cxtype,
  ffi.Uint32 i,
);

typedef _dart_clang_getArgType_wrap = ffi.Pointer<CXType> Function(
  ffi.Pointer<CXType> cxtype,
  int i,
);

typedef _c_clang_getEnumConstantDeclValue_wrap = ffi.Int64 Function(
  ffi.Pointer<CXCursor> cursor,
);

typedef _dart_clang_getEnumConstantDeclValue_wrap = int Function(
  ffi.Pointer<CXCursor> cursor,
);

typedef _c_clang_equalRanges_wrap = ffi.Uint32 Function(
  ffi.Pointer<CXSourceRange> c1,
  ffi.Pointer<CXSourceRange> c2,
);

typedef _dart_clang_equalRanges_wrap = int Function(
  ffi.Pointer<CXSourceRange> c1,
  ffi.Pointer<CXSourceRange> c2,
);

typedef _c_clang_Cursor_getCommentRange_wrap = ffi.Pointer<CXSourceRange>
    Function(
  ffi.Pointer<CXCursor> cursor,
);

typedef _dart_clang_Cursor_getCommentRange_wrap = ffi.Pointer<CXSourceRange>
    Function(
  ffi.Pointer<CXCursor> cursor,
);

typedef _c_clang_Cursor_getRawCommentText_wrap = ffi.Pointer<CXString> Function(
  ffi.Pointer<CXCursor> cursor,
);

typedef _dart_clang_Cursor_getRawCommentText_wrap = ffi.Pointer<CXString>
    Function(
  ffi.Pointer<CXCursor> cursor,
);

typedef _c_clang_Cursor_getBriefCommentText_wrap = ffi.Pointer<CXString>
    Function(
  ffi.Pointer<CXCursor> cursor,
);

typedef _dart_clang_Cursor_getBriefCommentText_wrap = ffi.Pointer<CXString>
    Function(
  ffi.Pointer<CXCursor> cursor,
);

typedef _c_clang_getCursorLocation_wrap = ffi.Pointer<CXSourceLocation>
    Function(
  ffi.Pointer<CXCursor> cursor,
);

typedef _dart_clang_getCursorLocation_wrap = ffi.Pointer<CXSourceLocation>
    Function(
  ffi.Pointer<CXCursor> cursor,
);

typedef _c_clang_getFileLocation_wrap = ffi.Void Function(
  ffi.Pointer<CXSourceLocation> location,
  ffi.Pointer<ffi.Pointer<ffi.Void>> file,
  ffi.Pointer<ffi.Uint32> line,
  ffi.Pointer<ffi.Uint32> column,
  ffi.Pointer<ffi.Uint32> offset,
);

typedef _dart_clang_getFileLocation_wrap = void Function(
  ffi.Pointer<CXSourceLocation> location,
  ffi.Pointer<ffi.Pointer<ffi.Void>> file,
  ffi.Pointer<ffi.Uint32> line,
  ffi.Pointer<ffi.Uint32> column,
  ffi.Pointer<ffi.Uint32> offset,
);

typedef _c_clang_getFileName_wrap = ffi.Pointer<CXString> Function(
  ffi.Pointer<ffi.Void> SFile,
);

typedef _dart_clang_getFileName_wrap = ffi.Pointer<CXString> Function(
  ffi.Pointer<ffi.Void> SFile,
);

typedef _c_clang_getNumElements_wrap = ffi.Uint64 Function(
  ffi.Pointer<CXType> cxtype,
);

typedef _dart_clang_getNumElements_wrap = int Function(
  ffi.Pointer<CXType> cxtype,
);

typedef _c_clang_getArrayElementType_wrap = ffi.Pointer<CXType> Function(
  ffi.Pointer<CXType> cxtype,
);

typedef _dart_clang_getArrayElementType_wrap = ffi.Pointer<CXType> Function(
  ffi.Pointer<CXType> cxtype,
);

typedef _c_clang_Cursor_isMacroFunctionLike_wrap = ffi.Uint32 Function(
  ffi.Pointer<CXCursor> cursor,
);

typedef _dart_clang_Cursor_isMacroFunctionLike_wrap = int Function(
  ffi.Pointer<CXCursor> cursor,
);

typedef _c_clang_Cursor_isMacroBuiltin_wrap = ffi.Uint32 Function(
  ffi.Pointer<CXCursor> cursor,
);

typedef _dart_clang_Cursor_isMacroBuiltin_wrap = int Function(
  ffi.Pointer<CXCursor> cursor,
);

typedef _c_clang_Cursor_Evaluate_wrap = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<CXCursor> cursor,
);

typedef _dart_clang_Cursor_Evaluate_wrap = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<CXCursor> cursor,
);

typedef _c_clang_Cursor_isAnonymous_wrap = ffi.Uint32 Function(
  ffi.Pointer<CXCursor> cursor,
);

typedef _dart_clang_Cursor_isAnonymous_wrap = int Function(
  ffi.Pointer<CXCursor> cursor,
);

typedef _c_clang_Cursor_isAnonymousRecordDecl_wrap = ffi.Uint32 Function(
  ffi.Pointer<CXCursor> cursor,
);

typedef _dart_clang_Cursor_isAnonymousRecordDecl_wrap = int Function(
  ffi.Pointer<CXCursor> cursor,
);

typedef _c_clang_getCursorUSR_wrap = ffi.Pointer<CXString> Function(
  ffi.Pointer<CXCursor> cursor,
);

typedef _dart_clang_getCursorUSR_wrap = ffi.Pointer<CXString> Function(
  ffi.Pointer<CXCursor> cursor,
);

typedef _c_clang_getFieldDeclBitWidth_wrap = ffi.Int32 Function(
  ffi.Pointer<CXCursor> cursor,
);

typedef _dart_clang_getFieldDeclBitWidth_wrap = int Function(
  ffi.Pointer<CXCursor> cursor,
);