example/libclang-example/generated_bindings.dart

// 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 LibClang {
  /// Holds the symbol lookup function.
  final ffi.Pointer<T> Function<T extends ffi.NativeType>(String symbolName)
      _lookup;

  /// The symbols are looked up in [dynamicLibrary].
  LibClang(ffi.DynamicLibrary dynamicLibrary) : _lookup = dynamicLibrary.lookup;

  /// The symbols are looked up with [lookup].
  LibClang.fromLookup(
      ffi.Pointer<T> Function<T extends ffi.NativeType>(String symbolName)
          lookup)
      : _lookup = lookup;

  /// Retrieve the character data associated with the given string.
  ffi.Pointer<ffi.Int8> clang_getCString(
    CXString string,
  ) {
    return (_clang_getCString ??=
        _lookup<ffi.NativeFunction<_c_clang_getCString>>('clang_getCString')
            .asFunction<_dart_clang_getCString>())(
      string,
    );
  }

  _dart_clang_getCString? _clang_getCString;

  /// Free the given string.
  void clang_disposeString(
    CXString string,
  ) {
    return (_clang_disposeString ??=
        _lookup<ffi.NativeFunction<_c_clang_disposeString>>(
                'clang_disposeString')
            .asFunction<_dart_clang_disposeString>())(
      string,
    );
  }

  _dart_clang_disposeString? _clang_disposeString;

  /// Free the given string set.
  void clang_disposeStringSet(
    ffi.Pointer<CXStringSet> set_1,
  ) {
    return (_clang_disposeStringSet ??=
        _lookup<ffi.NativeFunction<_c_clang_disposeStringSet>>(
                'clang_disposeStringSet')
            .asFunction<_dart_clang_disposeStringSet>())(
      set_1,
    );
  }

  _dart_clang_disposeStringSet? _clang_disposeStringSet;

  /// 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,
  ) {
    return (_clang_createIndex ??=
        _lookup<ffi.NativeFunction<_c_clang_createIndex>>('clang_createIndex')
            .asFunction<_dart_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,
  ) {
    return (_clang_disposeIndex ??=
        _lookup<ffi.NativeFunction<_c_clang_disposeIndex>>('clang_disposeIndex')
            .asFunction<_dart_clang_disposeIndex>())(
      index,
    );
  }

  _dart_clang_disposeIndex? _clang_disposeIndex;

  /// Sets general options associated with a CXIndex.
  ///
  /// For example:
  /// \code
  /// CXIndex idx = ...;
  /// clang_CXIndex_setGlobalOptions(idx,
  /// clang_CXIndex_getGlobalOptions(idx) |
  /// CXGlobalOpt_ThreadBackgroundPriorityForIndexing);
  /// \endcode
  ///
  /// \param options A bitmask of options, a bitwise OR of CXGlobalOpt_XXX flags.
  void clang_CXIndex_setGlobalOptions(
    ffi.Pointer<ffi.Void> arg0,
    int options,
  ) {
    return (_clang_CXIndex_setGlobalOptions ??=
        _lookup<ffi.NativeFunction<_c_clang_CXIndex_setGlobalOptions>>(
                'clang_CXIndex_setGlobalOptions')
            .asFunction<_dart_clang_CXIndex_setGlobalOptions>())(
      arg0,
      options,
    );
  }

  _dart_clang_CXIndex_setGlobalOptions? _clang_CXIndex_setGlobalOptions;

  /// Gets the general options associated with a CXIndex.
  ///
  /// \returns A bitmask of options, a bitwise OR of CXGlobalOpt_XXX flags that
  /// are associated with the given CXIndex object.
  int clang_CXIndex_getGlobalOptions(
    ffi.Pointer<ffi.Void> arg0,
  ) {
    return (_clang_CXIndex_getGlobalOptions ??=
        _lookup<ffi.NativeFunction<_c_clang_CXIndex_getGlobalOptions>>(
                'clang_CXIndex_getGlobalOptions')
            .asFunction<_dart_clang_CXIndex_getGlobalOptions>())(
      arg0,
    );
  }

  _dart_clang_CXIndex_getGlobalOptions? _clang_CXIndex_getGlobalOptions;

  /// Sets the invocation emission path option in a CXIndex.
  ///
  /// The invocation emission path specifies a path which will contain log
  /// files for certain libclang invocations. A null value (default) implies that
  /// libclang invocations are not logged..
  void clang_CXIndex_setInvocationEmissionPathOption(
    ffi.Pointer<ffi.Void> arg0,
    ffi.Pointer<ffi.Int8> Path,
  ) {
    return (_clang_CXIndex_setInvocationEmissionPathOption ??= _lookup<
                ffi.NativeFunction<
                    _c_clang_CXIndex_setInvocationEmissionPathOption>>(
            'clang_CXIndex_setInvocationEmissionPathOption')
        .asFunction<_dart_clang_CXIndex_setInvocationEmissionPathOption>())(
      arg0,
      Path,
    );
  }

  _dart_clang_CXIndex_setInvocationEmissionPathOption?
      _clang_CXIndex_setInvocationEmissionPathOption;

  /// Retrieve the complete file and path name of the given file.
  CXString clang_getFileName(
    ffi.Pointer<ffi.Void> SFile,
  ) {
    return (_clang_getFileName ??=
        _lookup<ffi.NativeFunction<_c_clang_getFileName>>('clang_getFileName')
            .asFunction<_dart_clang_getFileName>())(
      SFile,
    );
  }

  _dart_clang_getFileName? _clang_getFileName;

  /// Retrieve the last modification time of the given file.
  int clang_getFileTime(
    ffi.Pointer<ffi.Void> SFile,
  ) {
    return (_clang_getFileTime ??=
        _lookup<ffi.NativeFunction<_c_clang_getFileTime>>('clang_getFileTime')
            .asFunction<_dart_clang_getFileTime>())(
      SFile,
    );
  }

  _dart_clang_getFileTime? _clang_getFileTime;

  /// Retrieve the unique ID for the given \c file.
  ///
  /// \param file the file to get the ID for.
  /// \param outID stores the returned CXFileUniqueID.
  /// \returns If there was a failure getting the unique ID, returns non-zero,
  /// otherwise returns 0.
  int clang_getFileUniqueID(
    ffi.Pointer<ffi.Void> file,
    ffi.Pointer<CXFileUniqueID> outID,
  ) {
    return (_clang_getFileUniqueID ??=
        _lookup<ffi.NativeFunction<_c_clang_getFileUniqueID>>(
                'clang_getFileUniqueID')
            .asFunction<_dart_clang_getFileUniqueID>())(
      file,
      outID,
    );
  }

  _dart_clang_getFileUniqueID? _clang_getFileUniqueID;

  /// Determine whether the given header is guarded against
  /// multiple inclusions, either with the conventional
  /// \#ifndef/\#define/\#endif macro guards or with \#pragma once.
  int clang_isFileMultipleIncludeGuarded(
    ffi.Pointer<CXTranslationUnitImpl> tu,
    ffi.Pointer<ffi.Void> file,
  ) {
    return (_clang_isFileMultipleIncludeGuarded ??=
        _lookup<ffi.NativeFunction<_c_clang_isFileMultipleIncludeGuarded>>(
                'clang_isFileMultipleIncludeGuarded')
            .asFunction<_dart_clang_isFileMultipleIncludeGuarded>())(
      tu,
      file,
    );
  }

  _dart_clang_isFileMultipleIncludeGuarded? _clang_isFileMultipleIncludeGuarded;

  /// Retrieve a file handle within the given translation unit.
  ///
  /// \param tu the translation unit
  ///
  /// \param file_name the name of the file.
  ///
  /// \returns the file handle for the named file in the translation unit \p tu,
  /// or a NULL file handle if the file was not a part of this translation unit.
  ffi.Pointer<ffi.Void> clang_getFile(
    ffi.Pointer<CXTranslationUnitImpl> tu,
    ffi.Pointer<ffi.Int8> file_name,
  ) {
    return (_clang_getFile ??=
        _lookup<ffi.NativeFunction<_c_clang_getFile>>('clang_getFile')
            .asFunction<_dart_clang_getFile>())(
      tu,
      file_name,
    );
  }

  _dart_clang_getFile? _clang_getFile;

  /// Retrieve the buffer associated with the given file.
  ///
  /// \param tu the translation unit
  ///
  /// \param file the file for which to retrieve the buffer.
  ///
  /// \param size [out] if non-NULL, will be set to the size of the buffer.
  ///
  /// \returns a pointer to the buffer in memory that holds the contents of
  /// \p file, or a NULL pointer when the file is not loaded.
  ffi.Pointer<ffi.Int8> clang_getFileContents(
    ffi.Pointer<CXTranslationUnitImpl> tu,
    ffi.Pointer<ffi.Void> file,
    ffi.Pointer<ffi.Uint64> size,
  ) {
    return (_clang_getFileContents ??=
        _lookup<ffi.NativeFunction<_c_clang_getFileContents>>(
                'clang_getFileContents')
            .asFunction<_dart_clang_getFileContents>())(
      tu,
      file,
      size,
    );
  }

  _dart_clang_getFileContents? _clang_getFileContents;

  /// Returns non-zero if the \c file1 and \c file2 point to the same file,
  /// or they are both NULL.
  int clang_File_isEqual(
    ffi.Pointer<ffi.Void> file1,
    ffi.Pointer<ffi.Void> file2,
  ) {
    return (_clang_File_isEqual ??=
        _lookup<ffi.NativeFunction<_c_clang_File_isEqual>>('clang_File_isEqual')
            .asFunction<_dart_clang_File_isEqual>())(
      file1,
      file2,
    );
  }

  _dart_clang_File_isEqual? _clang_File_isEqual;

  /// Returns the real path name of \c file.
  ///
  /// An empty string may be returned. Use \c clang_getFileName() in that case.
  CXString clang_File_tryGetRealPathName(
    ffi.Pointer<ffi.Void> file,
  ) {
    return (_clang_File_tryGetRealPathName ??=
        _lookup<ffi.NativeFunction<_c_clang_File_tryGetRealPathName>>(
                'clang_File_tryGetRealPathName')
            .asFunction<_dart_clang_File_tryGetRealPathName>())(
      file,
    );
  }

  _dart_clang_File_tryGetRealPathName? _clang_File_tryGetRealPathName;

  /// Retrieve a NULL (invalid) source location.
  CXSourceLocation clang_getNullLocation() {
    return (_clang_getNullLocation ??=
        _lookup<ffi.NativeFunction<_c_clang_getNullLocation>>(
                'clang_getNullLocation')
            .asFunction<_dart_clang_getNullLocation>())();
  }

  _dart_clang_getNullLocation? _clang_getNullLocation;

  /// Determine whether two source locations, which must refer into
  /// the same translation unit, refer to exactly the same point in the source
  /// code.
  ///
  /// \returns non-zero if the source locations refer to the same location, zero
  /// if they refer to different locations.
  int clang_equalLocations(
    CXSourceLocation loc1,
    CXSourceLocation loc2,
  ) {
    return (_clang_equalLocations ??=
        _lookup<ffi.NativeFunction<_c_clang_equalLocations>>(
                'clang_equalLocations')
            .asFunction<_dart_clang_equalLocations>())(
      loc1,
      loc2,
    );
  }

  _dart_clang_equalLocations? _clang_equalLocations;

  /// Retrieves the source location associated with a given file/line/column
  /// in a particular translation unit.
  CXSourceLocation clang_getLocation(
    ffi.Pointer<CXTranslationUnitImpl> tu,
    ffi.Pointer<ffi.Void> file,
    int line,
    int column,
  ) {
    return (_clang_getLocation ??=
        _lookup<ffi.NativeFunction<_c_clang_getLocation>>('clang_getLocation')
            .asFunction<_dart_clang_getLocation>())(
      tu,
      file,
      line,
      column,
    );
  }

  _dart_clang_getLocation? _clang_getLocation;

  /// Retrieves the source location associated with a given character offset
  /// in a particular translation unit.
  CXSourceLocation clang_getLocationForOffset(
    ffi.Pointer<CXTranslationUnitImpl> tu,
    ffi.Pointer<ffi.Void> file,
    int offset,
  ) {
    return (_clang_getLocationForOffset ??=
        _lookup<ffi.NativeFunction<_c_clang_getLocationForOffset>>(
                'clang_getLocationForOffset')
            .asFunction<_dart_clang_getLocationForOffset>())(
      tu,
      file,
      offset,
    );
  }

  _dart_clang_getLocationForOffset? _clang_getLocationForOffset;

  /// Returns non-zero if the given source location is in a system header.
  int clang_Location_isInSystemHeader(
    CXSourceLocation location,
  ) {
    return (_clang_Location_isInSystemHeader ??=
        _lookup<ffi.NativeFunction<_c_clang_Location_isInSystemHeader>>(
                'clang_Location_isInSystemHeader')
            .asFunction<_dart_clang_Location_isInSystemHeader>())(
      location,
    );
  }

  _dart_clang_Location_isInSystemHeader? _clang_Location_isInSystemHeader;

  /// Returns non-zero if the given source location is in the main file of
  /// the corresponding translation unit.
  int clang_Location_isFromMainFile(
    CXSourceLocation location,
  ) {
    return (_clang_Location_isFromMainFile ??=
        _lookup<ffi.NativeFunction<_c_clang_Location_isFromMainFile>>(
                'clang_Location_isFromMainFile')
            .asFunction<_dart_clang_Location_isFromMainFile>())(
      location,
    );
  }

  _dart_clang_Location_isFromMainFile? _clang_Location_isFromMainFile;

  /// Retrieve a NULL (invalid) source range.
  CXSourceRange clang_getNullRange() {
    return (_clang_getNullRange ??=
        _lookup<ffi.NativeFunction<_c_clang_getNullRange>>('clang_getNullRange')
            .asFunction<_dart_clang_getNullRange>())();
  }

  _dart_clang_getNullRange? _clang_getNullRange;

  /// Retrieve a source range given the beginning and ending source
  /// locations.
  CXSourceRange clang_getRange(
    CXSourceLocation begin,
    CXSourceLocation end,
  ) {
    return (_clang_getRange ??=
        _lookup<ffi.NativeFunction<_c_clang_getRange>>('clang_getRange')
            .asFunction<_dart_clang_getRange>())(
      begin,
      end,
    );
  }

  _dart_clang_getRange? _clang_getRange;

  /// Determine whether two ranges are equivalent.
  ///
  /// \returns non-zero if the ranges are the same, zero if they differ.
  int clang_equalRanges(
    CXSourceRange range1,
    CXSourceRange range2,
  ) {
    return (_clang_equalRanges ??=
        _lookup<ffi.NativeFunction<_c_clang_equalRanges>>('clang_equalRanges')
            .asFunction<_dart_clang_equalRanges>())(
      range1,
      range2,
    );
  }

  _dart_clang_equalRanges? _clang_equalRanges;

  /// Returns non-zero if \p range is null.
  int clang_Range_isNull(
    CXSourceRange range,
  ) {
    return (_clang_Range_isNull ??=
        _lookup<ffi.NativeFunction<_c_clang_Range_isNull>>('clang_Range_isNull')
            .asFunction<_dart_clang_Range_isNull>())(
      range,
    );
  }

  _dart_clang_Range_isNull? _clang_Range_isNull;

  /// Retrieve the file, line, column, and offset represented by
  /// the given source location.
  ///
  /// If the location refers into a macro expansion, retrieves the
  /// location of the macro expansion.
  ///
  /// \param location the location within a source file that will be decomposed
  /// into its parts.
  ///
  /// \param file [out] if non-NULL, will be set to the file to which the given
  /// source location points.
  ///
  /// \param line [out] if non-NULL, will be set to the line to which the given
  /// source location points.
  ///
  /// \param column [out] if non-NULL, will be set to the column to which the given
  /// source location points.
  ///
  /// \param offset [out] if non-NULL, will be set to the offset into the
  /// buffer to which the given source location points.
  void clang_getExpansionLocation(
    CXSourceLocation location,
    ffi.Pointer<ffi.Pointer<ffi.Void>> file,
    ffi.Pointer<ffi.Uint32> line,
    ffi.Pointer<ffi.Uint32> column,
    ffi.Pointer<ffi.Uint32> offset,
  ) {
    return (_clang_getExpansionLocation ??=
        _lookup<ffi.NativeFunction<_c_clang_getExpansionLocation>>(
                'clang_getExpansionLocation')
            .asFunction<_dart_clang_getExpansionLocation>())(
      location,
      file,
      line,
      column,
      offset,
    );
  }

  _dart_clang_getExpansionLocation? _clang_getExpansionLocation;

  /// Retrieve the file, line and column represented by the given source
  /// location, as specified in a # line directive.
  ///
  /// Example: given the following source code in a file somefile.c
  ///
  /// \code
  /// #123 "dummy.c" 1
  ///
  /// static int func(void)
  /// {
  /// return 0;
  /// }
  /// \endcode
  ///
  /// the location information returned by this function would be
  ///
  /// File: dummy.c Line: 124 Column: 12
  ///
  /// whereas clang_getExpansionLocation would have returned
  ///
  /// File: somefile.c Line: 3 Column: 12
  ///
  /// \param location the location within a source file that will be decomposed
  /// into its parts.
  ///
  /// \param filename [out] if non-NULL, will be set to the filename of the
  /// source location. Note that filenames returned will be for "virtual" files,
  /// which don't necessarily exist on the machine running clang - e.g. when
  /// parsing preprocessed output obtained from a different environment. If
  /// a non-NULL value is passed in, remember to dispose of the returned value
  /// using \c clang_disposeString() once you've finished with it. For an invalid
  /// source location, an empty string is returned.
  ///
  /// \param line [out] if non-NULL, will be set to the line number of the
  /// source location. For an invalid source location, zero is returned.
  ///
  /// \param column [out] if non-NULL, will be set to the column number of the
  /// source location. For an invalid source location, zero is returned.
  void clang_getPresumedLocation(
    CXSourceLocation location,
    ffi.Pointer<CXString> filename,
    ffi.Pointer<ffi.Uint32> line,
    ffi.Pointer<ffi.Uint32> column,
  ) {
    return (_clang_getPresumedLocation ??=
        _lookup<ffi.NativeFunction<_c_clang_getPresumedLocation>>(
                'clang_getPresumedLocation')
            .asFunction<_dart_clang_getPresumedLocation>())(
      location,
      filename,
      line,
      column,
    );
  }

  _dart_clang_getPresumedLocation? _clang_getPresumedLocation;

  /// Legacy API to retrieve the file, line, column, and offset represented
  /// by the given source location.
  ///
  /// This interface has been replaced by the newer interface
  /// #clang_getExpansionLocation(). See that interface's documentation for
  /// details.
  void clang_getInstantiationLocation(
    CXSourceLocation location,
    ffi.Pointer<ffi.Pointer<ffi.Void>> file,
    ffi.Pointer<ffi.Uint32> line,
    ffi.Pointer<ffi.Uint32> column,
    ffi.Pointer<ffi.Uint32> offset,
  ) {
    return (_clang_getInstantiationLocation ??=
        _lookup<ffi.NativeFunction<_c_clang_getInstantiationLocation>>(
                'clang_getInstantiationLocation')
            .asFunction<_dart_clang_getInstantiationLocation>())(
      location,
      file,
      line,
      column,
      offset,
    );
  }

  _dart_clang_getInstantiationLocation? _clang_getInstantiationLocation;

  /// Retrieve the file, line, column, and offset represented by
  /// the given source location.
  ///
  /// If the location refers into a macro instantiation, return where the
  /// location was originally spelled in the source file.
  ///
  /// \param location the location within a source file that will be decomposed
  /// into its parts.
  ///
  /// \param file [out] if non-NULL, will be set to the file to which the given
  /// source location points.
  ///
  /// \param line [out] if non-NULL, will be set to the line to which the given
  /// source location points.
  ///
  /// \param column [out] if non-NULL, will be set to the column to which the given
  /// source location points.
  ///
  /// \param offset [out] if non-NULL, will be set to the offset into the
  /// buffer to which the given source location points.
  void clang_getSpellingLocation(
    CXSourceLocation location,
    ffi.Pointer<ffi.Pointer<ffi.Void>> file,
    ffi.Pointer<ffi.Uint32> line,
    ffi.Pointer<ffi.Uint32> column,
    ffi.Pointer<ffi.Uint32> offset,
  ) {
    return (_clang_getSpellingLocation ??=
        _lookup<ffi.NativeFunction<_c_clang_getSpellingLocation>>(
                'clang_getSpellingLocation')
            .asFunction<_dart_clang_getSpellingLocation>())(
      location,
      file,
      line,
      column,
      offset,
    );
  }

  _dart_clang_getSpellingLocation? _clang_getSpellingLocation;

  /// Retrieve the file, line, column, and offset represented by
  /// the given source location.
  ///
  /// If the location refers into a macro expansion, return where the macro was
  /// expanded or where the macro argument was written, if the location points at
  /// a macro argument.
  ///
  /// \param location the location within a source file that will be decomposed
  /// into its parts.
  ///
  /// \param file [out] if non-NULL, will be set to the file to which the given
  /// source location points.
  ///
  /// \param line [out] if non-NULL, will be set to the line to which the given
  /// source location points.
  ///
  /// \param column [out] if non-NULL, will be set to the column to which the given
  /// source location points.
  ///
  /// \param offset [out] if non-NULL, will be set to the offset into the
  /// buffer to which the given source location points.
  void clang_getFileLocation(
    CXSourceLocation location,
    ffi.Pointer<ffi.Pointer<ffi.Void>> file,
    ffi.Pointer<ffi.Uint32> line,
    ffi.Pointer<ffi.Uint32> column,
    ffi.Pointer<ffi.Uint32> offset,
  ) {
    return (_clang_getFileLocation ??=
        _lookup<ffi.NativeFunction<_c_clang_getFileLocation>>(
                'clang_getFileLocation')
            .asFunction<_dart_clang_getFileLocation>())(
      location,
      file,
      line,
      column,
      offset,
    );
  }

  _dart_clang_getFileLocation? _clang_getFileLocation;

  /// Retrieve a source location representing the first character within a
  /// source range.
  CXSourceLocation clang_getRangeStart(
    CXSourceRange range,
  ) {
    return (_clang_getRangeStart ??=
        _lookup<ffi.NativeFunction<_c_clang_getRangeStart>>(
                'clang_getRangeStart')
            .asFunction<_dart_clang_getRangeStart>())(
      range,
    );
  }

  _dart_clang_getRangeStart? _clang_getRangeStart;

  /// Retrieve a source location representing the last character within a
  /// source range.
  CXSourceLocation clang_getRangeEnd(
    CXSourceRange range,
  ) {
    return (_clang_getRangeEnd ??=
        _lookup<ffi.NativeFunction<_c_clang_getRangeEnd>>('clang_getRangeEnd')
            .asFunction<_dart_clang_getRangeEnd>())(
      range,
    );
  }

  _dart_clang_getRangeEnd? _clang_getRangeEnd;

  /// Retrieve all ranges that were skipped by the preprocessor.
  ///
  /// The preprocessor will skip lines when they are surrounded by an
  /// if/ifdef/ifndef directive whose condition does not evaluate to true.
  ffi.Pointer<CXSourceRangeList> clang_getSkippedRanges(
    ffi.Pointer<CXTranslationUnitImpl> tu,
    ffi.Pointer<ffi.Void> file,
  ) {
    return (_clang_getSkippedRanges ??=
        _lookup<ffi.NativeFunction<_c_clang_getSkippedRanges>>(
                'clang_getSkippedRanges')
            .asFunction<_dart_clang_getSkippedRanges>())(
      tu,
      file,
    );
  }

  _dart_clang_getSkippedRanges? _clang_getSkippedRanges;

  /// Retrieve all ranges from all files that were skipped by the
  /// preprocessor.
  ///
  /// The preprocessor will skip lines when they are surrounded by an
  /// if/ifdef/ifndef directive whose condition does not evaluate to true.
  ffi.Pointer<CXSourceRangeList> clang_getAllSkippedRanges(
    ffi.Pointer<CXTranslationUnitImpl> tu,
  ) {
    return (_clang_getAllSkippedRanges ??=
        _lookup<ffi.NativeFunction<_c_clang_getAllSkippedRanges>>(
                'clang_getAllSkippedRanges')
            .asFunction<_dart_clang_getAllSkippedRanges>())(
      tu,
    );
  }

  _dart_clang_getAllSkippedRanges? _clang_getAllSkippedRanges;

  /// Destroy the given \c CXSourceRangeList.
  void clang_disposeSourceRangeList(
    ffi.Pointer<CXSourceRangeList> ranges,
  ) {
    return (_clang_disposeSourceRangeList ??=
        _lookup<ffi.NativeFunction<_c_clang_disposeSourceRangeList>>(
                'clang_disposeSourceRangeList')
            .asFunction<_dart_clang_disposeSourceRangeList>())(
      ranges,
    );
  }

  _dart_clang_disposeSourceRangeList? _clang_disposeSourceRangeList;

  /// Determine the number of diagnostics in a CXDiagnosticSet.
  int clang_getNumDiagnosticsInSet(
    ffi.Pointer<ffi.Void> Diags,
  ) {
    return (_clang_getNumDiagnosticsInSet ??=
        _lookup<ffi.NativeFunction<_c_clang_getNumDiagnosticsInSet>>(
                'clang_getNumDiagnosticsInSet')
            .asFunction<_dart_clang_getNumDiagnosticsInSet>())(
      Diags,
    );
  }

  _dart_clang_getNumDiagnosticsInSet? _clang_getNumDiagnosticsInSet;

  /// Retrieve a diagnostic associated with the given CXDiagnosticSet.
  ///
  /// \param Diags the CXDiagnosticSet 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_getDiagnosticInSet(
    ffi.Pointer<ffi.Void> Diags,
    int Index,
  ) {
    return (_clang_getDiagnosticInSet ??=
        _lookup<ffi.NativeFunction<_c_clang_getDiagnosticInSet>>(
                'clang_getDiagnosticInSet')
            .asFunction<_dart_clang_getDiagnosticInSet>())(
      Diags,
      Index,
    );
  }

  _dart_clang_getDiagnosticInSet? _clang_getDiagnosticInSet;

  /// Deserialize a set of diagnostics from a Clang diagnostics bitcode
  /// file.
  ///
  /// \param file The name of the file to deserialize.
  /// \param error A pointer to a enum value recording if there was a problem
  /// deserializing the diagnostics.
  /// \param errorString A pointer to a CXString for recording the error string
  /// if the file was not successfully loaded.
  ///
  /// \returns A loaded CXDiagnosticSet if successful, and NULL otherwise.  These
  /// diagnostics should be released using clang_disposeDiagnosticSet().
  ffi.Pointer<ffi.Void> clang_loadDiagnostics(
    ffi.Pointer<ffi.Int8> file,
    ffi.Pointer<ffi.Int32> error,
    ffi.Pointer<CXString> errorString,
  ) {
    return (_clang_loadDiagnostics ??=
        _lookup<ffi.NativeFunction<_c_clang_loadDiagnostics>>(
                'clang_loadDiagnostics')
            .asFunction<_dart_clang_loadDiagnostics>())(
      file,
      error,
      errorString,
    );
  }

  _dart_clang_loadDiagnostics? _clang_loadDiagnostics;

  /// Release a CXDiagnosticSet and all of its contained diagnostics.
  void clang_disposeDiagnosticSet(
    ffi.Pointer<ffi.Void> Diags,
  ) {
    return (_clang_disposeDiagnosticSet ??=
        _lookup<ffi.NativeFunction<_c_clang_disposeDiagnosticSet>>(
                'clang_disposeDiagnosticSet')
            .asFunction<_dart_clang_disposeDiagnosticSet>())(
      Diags,
    );
  }

  _dart_clang_disposeDiagnosticSet? _clang_disposeDiagnosticSet;

  /// Retrieve the child diagnostics of a CXDiagnostic.
  ///
  /// This CXDiagnosticSet does not need to be released by
  /// clang_disposeDiagnosticSet.
  ffi.Pointer<ffi.Void> clang_getChildDiagnostics(
    ffi.Pointer<ffi.Void> D,
  ) {
    return (_clang_getChildDiagnostics ??=
        _lookup<ffi.NativeFunction<_c_clang_getChildDiagnostics>>(
                'clang_getChildDiagnostics')
            .asFunction<_dart_clang_getChildDiagnostics>())(
      D,
    );
  }

  _dart_clang_getChildDiagnostics? _clang_getChildDiagnostics;

  /// Determine the number of diagnostics produced for the given
  /// translation unit.
  int clang_getNumDiagnostics(
    ffi.Pointer<CXTranslationUnitImpl> Unit,
  ) {
    return (_clang_getNumDiagnostics ??=
        _lookup<ffi.NativeFunction<_c_clang_getNumDiagnostics>>(
                'clang_getNumDiagnostics')
            .asFunction<_dart_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,
  ) {
    return (_clang_getDiagnostic ??=
        _lookup<ffi.NativeFunction<_c_clang_getDiagnostic>>(
                'clang_getDiagnostic')
            .asFunction<_dart_clang_getDiagnostic>())(
      Unit,
      Index,
    );
  }

  _dart_clang_getDiagnostic? _clang_getDiagnostic;

  /// Retrieve the complete set of diagnostics associated with a
  /// translation unit.
  ///
  /// \param Unit the translation unit to query.
  ffi.Pointer<ffi.Void> clang_getDiagnosticSetFromTU(
    ffi.Pointer<CXTranslationUnitImpl> Unit,
  ) {
    return (_clang_getDiagnosticSetFromTU ??=
        _lookup<ffi.NativeFunction<_c_clang_getDiagnosticSetFromTU>>(
                'clang_getDiagnosticSetFromTU')
            .asFunction<_dart_clang_getDiagnosticSetFromTU>())(
      Unit,
    );
  }

  _dart_clang_getDiagnosticSetFromTU? _clang_getDiagnosticSetFromTU;

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

  _dart_clang_disposeDiagnostic? _clang_disposeDiagnostic;

  /// Format the given diagnostic in a manner that is suitable for display.
  ///
  /// This routine will format the given diagnostic to a string, rendering
  /// the diagnostic according to the various options given. The
  /// \c clang_defaultDiagnosticDisplayOptions() function returns the set of
  /// options that most closely mimics the behavior of the clang compiler.
  ///
  /// \param Diagnostic The diagnostic to print.
  ///
  /// \param Options A set of options that control the diagnostic display,
  /// created by combining \c CXDiagnosticDisplayOptions values.
  ///
  /// \returns A new string containing for formatted diagnostic.
  CXString clang_formatDiagnostic(
    ffi.Pointer<ffi.Void> Diagnostic,
    int Options,
  ) {
    return (_clang_formatDiagnostic ??=
        _lookup<ffi.NativeFunction<_c_clang_formatDiagnostic>>(
                'clang_formatDiagnostic')
            .asFunction<_dart_clang_formatDiagnostic>())(
      Diagnostic,
      Options,
    );
  }

  _dart_clang_formatDiagnostic? _clang_formatDiagnostic;

  /// Retrieve the set of display options most similar to the
  /// default behavior of the clang compiler.
  ///
  /// \returns A set of display options suitable for use with \c
  /// clang_formatDiagnostic().
  int clang_defaultDiagnosticDisplayOptions() {
    return (_clang_defaultDiagnosticDisplayOptions ??=
        _lookup<ffi.NativeFunction<_c_clang_defaultDiagnosticDisplayOptions>>(
                'clang_defaultDiagnosticDisplayOptions')
            .asFunction<_dart_clang_defaultDiagnosticDisplayOptions>())();
  }

  _dart_clang_defaultDiagnosticDisplayOptions?
      _clang_defaultDiagnosticDisplayOptions;

  /// Determine the severity of the given diagnostic.
  int clang_getDiagnosticSeverity(
    ffi.Pointer<ffi.Void> arg0,
  ) {
    return (_clang_getDiagnosticSeverity ??=
        _lookup<ffi.NativeFunction<_c_clang_getDiagnosticSeverity>>(
                'clang_getDiagnosticSeverity')
            .asFunction<_dart_clang_getDiagnosticSeverity>())(
      arg0,
    );
  }

  _dart_clang_getDiagnosticSeverity? _clang_getDiagnosticSeverity;

  /// Retrieve the source location of the given diagnostic.
  ///
  /// This location is where Clang would print the caret ('^') when
  /// displaying the diagnostic on the command line.
  CXSourceLocation clang_getDiagnosticLocation(
    ffi.Pointer<ffi.Void> arg0,
  ) {
    return (_clang_getDiagnosticLocation ??=
        _lookup<ffi.NativeFunction<_c_clang_getDiagnosticLocation>>(
                'clang_getDiagnosticLocation')
            .asFunction<_dart_clang_getDiagnosticLocation>())(
      arg0,
    );
  }

  _dart_clang_getDiagnosticLocation? _clang_getDiagnosticLocation;

  /// Retrieve the text of the given diagnostic.
  CXString clang_getDiagnosticSpelling(
    ffi.Pointer<ffi.Void> arg0,
  ) {
    return (_clang_getDiagnosticSpelling ??=
        _lookup<ffi.NativeFunction<_c_clang_getDiagnosticSpelling>>(
                'clang_getDiagnosticSpelling')
            .asFunction<_dart_clang_getDiagnosticSpelling>())(
      arg0,
    );
  }

  _dart_clang_getDiagnosticSpelling? _clang_getDiagnosticSpelling;

  /// Retrieve the name of the command-line option that enabled this
  /// diagnostic.
  ///
  /// \param Diag The diagnostic to be queried.
  ///
  /// \param Disable If non-NULL, will be set to the option that disables this
  /// diagnostic (if any).
  ///
  /// \returns A string that contains the command-line option used to enable this
  /// warning, such as "-Wconversion" or "-pedantic".
  CXString clang_getDiagnosticOption(
    ffi.Pointer<ffi.Void> Diag,
    ffi.Pointer<CXString> Disable,
  ) {
    return (_clang_getDiagnosticOption ??=
        _lookup<ffi.NativeFunction<_c_clang_getDiagnosticOption>>(
                'clang_getDiagnosticOption')
            .asFunction<_dart_clang_getDiagnosticOption>())(
      Diag,
      Disable,
    );
  }

  _dart_clang_getDiagnosticOption? _clang_getDiagnosticOption;

  /// Retrieve the category number for this diagnostic.
  ///
  /// Diagnostics can be categorized into groups along with other, related
  /// diagnostics (e.g., diagnostics under the same warning flag). This routine
  /// retrieves the category number for the given diagnostic.
  ///
  /// \returns The number of the category that contains this diagnostic, or zero
  /// if this diagnostic is uncategorized.
  int clang_getDiagnosticCategory(
    ffi.Pointer<ffi.Void> arg0,
  ) {
    return (_clang_getDiagnosticCategory ??=
        _lookup<ffi.NativeFunction<_c_clang_getDiagnosticCategory>>(
                'clang_getDiagnosticCategory')
            .asFunction<_dart_clang_getDiagnosticCategory>())(
      arg0,
    );
  }

  _dart_clang_getDiagnosticCategory? _clang_getDiagnosticCategory;

  /// Retrieve the name of a particular diagnostic category.  This
  /// is now deprecated.  Use clang_getDiagnosticCategoryText()
  /// instead.
  ///
  /// \param Category A diagnostic category number, as returned by
  /// \c clang_getDiagnosticCategory().
  ///
  /// \returns The name of the given diagnostic category.
  CXString clang_getDiagnosticCategoryName(
    int Category,
  ) {
    return (_clang_getDiagnosticCategoryName ??=
        _lookup<ffi.NativeFunction<_c_clang_getDiagnosticCategoryName>>(
                'clang_getDiagnosticCategoryName')
            .asFunction<_dart_clang_getDiagnosticCategoryName>())(
      Category,
    );
  }

  _dart_clang_getDiagnosticCategoryName? _clang_getDiagnosticCategoryName;

  /// Retrieve the diagnostic category text for a given diagnostic.
  ///
  /// \returns The text of the given diagnostic category.
  CXString clang_getDiagnosticCategoryText(
    ffi.Pointer<ffi.Void> arg0,
  ) {
    return (_clang_getDiagnosticCategoryText ??=
        _lookup<ffi.NativeFunction<_c_clang_getDiagnosticCategoryText>>(
                'clang_getDiagnosticCategoryText')
            .asFunction<_dart_clang_getDiagnosticCategoryText>())(
      arg0,
    );
  }

  _dart_clang_getDiagnosticCategoryText? _clang_getDiagnosticCategoryText;

  /// Determine the number of source ranges associated with the given
  /// diagnostic.
  int clang_getDiagnosticNumRanges(
    ffi.Pointer<ffi.Void> arg0,
  ) {
    return (_clang_getDiagnosticNumRanges ??=
        _lookup<ffi.NativeFunction<_c_clang_getDiagnosticNumRanges>>(
                'clang_getDiagnosticNumRanges')
            .asFunction<_dart_clang_getDiagnosticNumRanges>())(
      arg0,
    );
  }

  _dart_clang_getDiagnosticNumRanges? _clang_getDiagnosticNumRanges;

  /// Retrieve a source range associated with the diagnostic.
  ///
  /// A diagnostic's source ranges highlight important elements in the source
  /// code. On the command line, Clang displays source ranges by
  /// underlining them with '~' characters.
  ///
  /// \param Diagnostic the diagnostic whose range is being extracted.
  ///
  /// \param Range the zero-based index specifying which range to
  ///
  /// \returns the requested source range.
  CXSourceRange clang_getDiagnosticRange(
    ffi.Pointer<ffi.Void> Diagnostic,
    int Range,
  ) {
    return (_clang_getDiagnosticRange ??=
        _lookup<ffi.NativeFunction<_c_clang_getDiagnosticRange>>(
                'clang_getDiagnosticRange')
            .asFunction<_dart_clang_getDiagnosticRange>())(
      Diagnostic,
      Range,
    );
  }

  _dart_clang_getDiagnosticRange? _clang_getDiagnosticRange;

  /// Determine the number of fix-it hints associated with the
  /// given diagnostic.
  int clang_getDiagnosticNumFixIts(
    ffi.Pointer<ffi.Void> Diagnostic,
  ) {
    return (_clang_getDiagnosticNumFixIts ??=
        _lookup<ffi.NativeFunction<_c_clang_getDiagnosticNumFixIts>>(
                'clang_getDiagnosticNumFixIts')
            .asFunction<_dart_clang_getDiagnosticNumFixIts>())(
      Diagnostic,
    );
  }

  _dart_clang_getDiagnosticNumFixIts? _clang_getDiagnosticNumFixIts;

  /// Retrieve the replacement information for a given fix-it.
  ///
  /// Fix-its are described in terms of a source range whose contents
  /// should be replaced by a string. This approach generalizes over
  /// three kinds of operations: removal of source code (the range covers
  /// the code to be removed and the replacement string is empty),
  /// replacement of source code (the range covers the code to be
  /// replaced and the replacement string provides the new code), and
  /// insertion (both the start and end of the range point at the
  /// insertion location, and the replacement string provides the text to
  /// insert).
  ///
  /// \param Diagnostic The diagnostic whose fix-its are being queried.
  ///
  /// \param FixIt The zero-based index of the fix-it.
  ///
  /// \param ReplacementRange The source range whose contents will be
  /// replaced with the returned replacement string. Note that source
  /// ranges are half-open ranges [a, b), so the source code should be
  /// replaced from a and up to (but not including) b.
  ///
  /// \returns A string containing text that should be replace the source
  /// code indicated by the \c ReplacementRange.
  CXString clang_getDiagnosticFixIt(
    ffi.Pointer<ffi.Void> Diagnostic,
    int FixIt,
    ffi.Pointer<CXSourceRange> ReplacementRange,
  ) {
    return (_clang_getDiagnosticFixIt ??=
        _lookup<ffi.NativeFunction<_c_clang_getDiagnosticFixIt>>(
                'clang_getDiagnosticFixIt')
            .asFunction<_dart_clang_getDiagnosticFixIt>())(
      Diagnostic,
      FixIt,
      ReplacementRange,
    );
  }

  _dart_clang_getDiagnosticFixIt? _clang_getDiagnosticFixIt;

  /// Get the original translation unit source file name.
  CXString clang_getTranslationUnitSpelling(
    ffi.Pointer<CXTranslationUnitImpl> CTUnit,
  ) {
    return (_clang_getTranslationUnitSpelling ??=
        _lookup<ffi.NativeFunction<_c_clang_getTranslationUnitSpelling>>(
                'clang_getTranslationUnitSpelling')
            .asFunction<_dart_clang_getTranslationUnitSpelling>())(
      CTUnit,
    );
  }

  _dart_clang_getTranslationUnitSpelling? _clang_getTranslationUnitSpelling;

  /// Return the CXTranslationUnit for a given source file and the provided
  /// command line arguments one would pass to the compiler.
  ///
  /// Note: The 'source_filename' argument is optional.  If the caller provides a
  /// NULL pointer, the name of the source file is expected to reside in the
  /// specified command line arguments.
  ///
  /// Note: When encountered in 'clang_command_line_args', the following options
  /// are ignored:
  ///
  /// '-c'
  /// '-emit-ast'
  /// '-fsyntax-only'
  /// '-o \<output file>'  (both '-o' and '\<output file>' are ignored)
  ///
  /// \param CIdx The index object with which the translation unit will be
  /// associated.
  ///
  /// \param source_filename The name of the source file to load, or NULL if the
  /// source file is included in \p clang_command_line_args.
  ///
  /// \param num_clang_command_line_args The number of command-line arguments in
  /// \p clang_command_line_args.
  ///
  /// \param clang_command_line_args The command-line arguments that would be
  /// passed to the \c clang executable if it were being invoked out-of-process.
  /// These command-line options will be parsed and will affect how the translation
  /// unit is parsed. Note that the following options are ignored: '-c',
  /// '-emit-ast', '-fsyntax-only' (which is the default), and '-o \<output file>'.
  ///
  /// \param num_unsaved_files the number of unsaved file entries in \p
  /// unsaved_files.
  ///
  /// \param unsaved_files the files that have not yet been saved to disk
  /// but may be required for code completion, including the contents of
  /// those files.  The contents and name of these files (as specified by
  /// CXUnsavedFile) are copied when necessary, so the client only needs to
  /// guarantee their validity until the call to this function returns.
  ffi.Pointer<CXTranslationUnitImpl> clang_createTranslationUnitFromSourceFile(
    ffi.Pointer<ffi.Void> CIdx,
    ffi.Pointer<ffi.Int8> source_filename,
    int num_clang_command_line_args,
    ffi.Pointer<ffi.Pointer<ffi.Int8>> clang_command_line_args,
    int num_unsaved_files,
    ffi.Pointer<CXUnsavedFile> unsaved_files,
  ) {
    return (_clang_createTranslationUnitFromSourceFile ??= _lookup<
                ffi.NativeFunction<
                    _c_clang_createTranslationUnitFromSourceFile>>(
            'clang_createTranslationUnitFromSourceFile')
        .asFunction<_dart_clang_createTranslationUnitFromSourceFile>())(
      CIdx,
      source_filename,
      num_clang_command_line_args,
      clang_command_line_args,
      num_unsaved_files,
      unsaved_files,
    );
  }

  _dart_clang_createTranslationUnitFromSourceFile?
      _clang_createTranslationUnitFromSourceFile;

  /// Same as \c clang_createTranslationUnit2, 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_createTranslationUnit(
    ffi.Pointer<ffi.Void> CIdx,
    ffi.Pointer<ffi.Int8> ast_filename,
  ) {
    return (_clang_createTranslationUnit ??=
        _lookup<ffi.NativeFunction<_c_clang_createTranslationUnit>>(
                'clang_createTranslationUnit')
            .asFunction<_dart_clang_createTranslationUnit>())(
      CIdx,
      ast_filename,
    );
  }

  _dart_clang_createTranslationUnit? _clang_createTranslationUnit;

  /// Create a translation unit from an AST file (\c -emit-ast).
  ///
  /// \param[out] out_TU A non-NULL pointer to store the created
  /// \c CXTranslationUnit.
  ///
  /// \returns Zero on success, otherwise returns an error code.
  int clang_createTranslationUnit2(
    ffi.Pointer<ffi.Void> CIdx,
    ffi.Pointer<ffi.Int8> ast_filename,
    ffi.Pointer<ffi.Pointer<CXTranslationUnitImpl>> out_TU,
  ) {
    return (_clang_createTranslationUnit2 ??=
        _lookup<ffi.NativeFunction<_c_clang_createTranslationUnit2>>(
                'clang_createTranslationUnit2')
            .asFunction<_dart_clang_createTranslationUnit2>())(
      CIdx,
      ast_filename,
      out_TU,
    );
  }

  _dart_clang_createTranslationUnit2? _clang_createTranslationUnit2;

  /// Returns the set of flags that is suitable for parsing a translation
  /// unit that is being edited.
  ///
  /// The set of flags returned provide options for \c clang_parseTranslationUnit()
  /// to indicate that the translation unit is likely to be reparsed many times,
  /// either explicitly (via \c clang_reparseTranslationUnit()) or implicitly
  /// (e.g., by code completion (\c clang_codeCompletionAt())). The returned flag
  /// set contains an unspecified set of optimizations (e.g., the precompiled
  /// preamble) geared toward improving the performance of these routines. The
  /// set of optimizations enabled may change from one version to the next.
  int clang_defaultEditingTranslationUnitOptions() {
    return (_clang_defaultEditingTranslationUnitOptions ??= _lookup<
                ffi.NativeFunction<
                    _c_clang_defaultEditingTranslationUnitOptions>>(
            'clang_defaultEditingTranslationUnitOptions')
        .asFunction<_dart_clang_defaultEditingTranslationUnitOptions>())();
  }

  _dart_clang_defaultEditingTranslationUnitOptions?
      _clang_defaultEditingTranslationUnitOptions;

  /// 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,
  ) {
    return (_clang_parseTranslationUnit ??=
        _lookup<ffi.NativeFunction<_c_clang_parseTranslationUnit>>(
                'clang_parseTranslationUnit')
            .asFunction<_dart_clang_parseTranslationUnit>())(
      CIdx,
      source_filename,
      command_line_args,
      num_command_line_args,
      unsaved_files,
      num_unsaved_files,
      options,
    );
  }

  _dart_clang_parseTranslationUnit? _clang_parseTranslationUnit;

  /// Parse the given source file and the translation unit corresponding
  /// to that file.
  ///
  /// This routine is the main entry point for the Clang C API, providing the
  /// ability to parse a source file into a translation unit that can then be
  /// queried by other functions in the API. This routine accepts a set of
  /// command-line arguments so that the compilation can be configured in the same
  /// way that the compiler is configured on the command line.
  ///
  /// \param CIdx The index object with which the translation unit will be
  /// associated.
  ///
  /// \param source_filename The name of the source file to load, or NULL if the
  /// source file is included in \c command_line_args.
  ///
  /// \param command_line_args The command-line arguments that would be
  /// passed to the \c clang executable if it were being invoked out-of-process.
  /// These command-line options will be parsed and will affect how the translation
  /// unit is parsed. Note that the following options are ignored: '-c',
  /// '-emit-ast', '-fsyntax-only' (which is the default), and '-o \<output file>'.
  ///
  /// \param num_command_line_args The number of command-line arguments in
  /// \c command_line_args.
  ///
  /// \param unsaved_files the files that have not yet been saved to disk
  /// but may be required for parsing, including the contents of
  /// those files.  The contents and name of these files (as specified by
  /// CXUnsavedFile) are copied when necessary, so the client only needs to
  /// guarantee their validity until the call to this function returns.
  ///
  /// \param num_unsaved_files the number of unsaved file entries in \p
  /// unsaved_files.
  ///
  /// \param options A bitmask of options that affects how the translation unit
  /// is managed but not its compilation. This should be a bitwise OR of the
  /// CXTranslationUnit_XXX flags.
  ///
  /// \param[out] out_TU A non-NULL pointer to store the created
  /// \c CXTranslationUnit, describing the parsed code and containing any
  /// diagnostics produced by the compiler.
  ///
  /// \returns Zero on success, otherwise returns an error code.
  int clang_parseTranslationUnit2(
    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,
    ffi.Pointer<ffi.Pointer<CXTranslationUnitImpl>> out_TU,
  ) {
    return (_clang_parseTranslationUnit2 ??=
        _lookup<ffi.NativeFunction<_c_clang_parseTranslationUnit2>>(
                'clang_parseTranslationUnit2')
            .asFunction<_dart_clang_parseTranslationUnit2>())(
      CIdx,
      source_filename,
      command_line_args,
      num_command_line_args,
      unsaved_files,
      num_unsaved_files,
      options,
      out_TU,
    );
  }

  _dart_clang_parseTranslationUnit2? _clang_parseTranslationUnit2;

  /// Same as clang_parseTranslationUnit2 but requires a full command line
  /// for \c command_line_args including argv[0]. This is useful if the standard
  /// library paths are relative to the binary.
  int clang_parseTranslationUnit2FullArgv(
    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,
    ffi.Pointer<ffi.Pointer<CXTranslationUnitImpl>> out_TU,
  ) {
    return (_clang_parseTranslationUnit2FullArgv ??=
        _lookup<ffi.NativeFunction<_c_clang_parseTranslationUnit2FullArgv>>(
                'clang_parseTranslationUnit2FullArgv')
            .asFunction<_dart_clang_parseTranslationUnit2FullArgv>())(
      CIdx,
      source_filename,
      command_line_args,
      num_command_line_args,
      unsaved_files,
      num_unsaved_files,
      options,
      out_TU,
    );
  }

  _dart_clang_parseTranslationUnit2FullArgv?
      _clang_parseTranslationUnit2FullArgv;

  /// Returns the set of flags that is suitable for saving a translation
  /// unit.
  ///
  /// The set of flags returned provide options for
  /// \c clang_saveTranslationUnit() by default. The returned flag
  /// set contains an unspecified set of options that save translation units with
  /// the most commonly-requested data.
  int clang_defaultSaveOptions(
    ffi.Pointer<CXTranslationUnitImpl> TU,
  ) {
    return (_clang_defaultSaveOptions ??=
        _lookup<ffi.NativeFunction<_c_clang_defaultSaveOptions>>(
                'clang_defaultSaveOptions')
            .asFunction<_dart_clang_defaultSaveOptions>())(
      TU,
    );
  }

  _dart_clang_defaultSaveOptions? _clang_defaultSaveOptions;

  /// Saves a translation unit into a serialized representation of
  /// that translation unit on disk.
  ///
  /// Any translation unit that was parsed without error can be saved
  /// into a file. The translation unit can then be deserialized into a
  /// new \c CXTranslationUnit with \c clang_createTranslationUnit() or,
  /// if it is an incomplete translation unit that corresponds to a
  /// header, used as a precompiled header when parsing other translation
  /// units.
  ///
  /// \param TU The translation unit to save.
  ///
  /// \param FileName The file to which the translation unit will be saved.
  ///
  /// \param options A bitmask of options that affects how the translation unit
  /// is saved. This should be a bitwise OR of the
  /// CXSaveTranslationUnit_XXX flags.
  ///
  /// \returns A value that will match one of the enumerators of the CXSaveError
  /// enumeration. Zero (CXSaveError_None) indicates that the translation unit was
  /// saved successfully, while a non-zero value indicates that a problem occurred.
  int clang_saveTranslationUnit(
    ffi.Pointer<CXTranslationUnitImpl> TU,
    ffi.Pointer<ffi.Int8> FileName,
    int options,
  ) {
    return (_clang_saveTranslationUnit ??=
        _lookup<ffi.NativeFunction<_c_clang_saveTranslationUnit>>(
                'clang_saveTranslationUnit')
            .asFunction<_dart_clang_saveTranslationUnit>())(
      TU,
      FileName,
      options,
    );
  }

  _dart_clang_saveTranslationUnit? _clang_saveTranslationUnit;

  /// Suspend a translation unit in order to free memory associated with it.
  ///
  /// A suspended translation unit uses significantly less memory but on the other
  /// side does not support any other calls than \c clang_reparseTranslationUnit
  /// to resume it or \c clang_disposeTranslationUnit to dispose it completely.
  int clang_suspendTranslationUnit(
    ffi.Pointer<CXTranslationUnitImpl> arg0,
  ) {
    return (_clang_suspendTranslationUnit ??=
        _lookup<ffi.NativeFunction<_c_clang_suspendTranslationUnit>>(
                'clang_suspendTranslationUnit')
            .asFunction<_dart_clang_suspendTranslationUnit>())(
      arg0,
    );
  }

  _dart_clang_suspendTranslationUnit? _clang_suspendTranslationUnit;

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

  _dart_clang_disposeTranslationUnit? _clang_disposeTranslationUnit;

  /// Returns the set of flags that is suitable for reparsing a translation
  /// unit.
  ///
  /// The set of flags returned provide options for
  /// \c clang_reparseTranslationUnit() by default. The returned flag
  /// set contains an unspecified set of optimizations geared toward common uses
  /// of reparsing. The set of optimizations enabled may change from one version
  /// to the next.
  int clang_defaultReparseOptions(
    ffi.Pointer<CXTranslationUnitImpl> TU,
  ) {
    return (_clang_defaultReparseOptions ??=
        _lookup<ffi.NativeFunction<_c_clang_defaultReparseOptions>>(
                'clang_defaultReparseOptions')
            .asFunction<_dart_clang_defaultReparseOptions>())(
      TU,
    );
  }

  _dart_clang_defaultReparseOptions? _clang_defaultReparseOptions;

  /// Reparse the source files that produced this translation unit.
  ///
  /// This routine can be used to re-parse the source files that originally
  /// created the given translation unit, for example because those source files
  /// have changed (either on disk or as passed via \p unsaved_files). The
  /// source code will be reparsed with the same command-line options as it
  /// was originally parsed.
  ///
  /// Reparsing a translation unit invalidates all cursors and source locations
  /// that refer into that translation unit. This makes reparsing a translation
  /// unit semantically equivalent to destroying the translation unit and then
  /// creating a new translation unit with the same command-line arguments.
  /// However, it may be more efficient to reparse a translation
  /// unit using this routine.
  ///
  /// \param TU The translation unit whose contents will be re-parsed. The
  /// translation unit must originally have been built with
  /// \c clang_createTranslationUnitFromSourceFile().
  ///
  /// \param num_unsaved_files The number of unsaved file entries in \p
  /// unsaved_files.
  ///
  /// \param unsaved_files The files that have not yet been saved to disk
  /// but may be required for parsing, including the contents of
  /// those files.  The contents and name of these files (as specified by
  /// CXUnsavedFile) are copied when necessary, so the client only needs to
  /// guarantee their validity until the call to this function returns.
  ///
  /// \param options A bitset of options composed of the flags in CXReparse_Flags.
  /// The function \c clang_defaultReparseOptions() produces a default set of
  /// options recommended for most uses, based on the translation unit.
  ///
  /// \returns 0 if the sources could be reparsed.  A non-zero error code will be
  /// returned if reparsing was impossible, such that the translation unit is
  /// invalid. In such cases, the only valid call for \c TU is
  /// \c clang_disposeTranslationUnit(TU).  The error codes returned by this
  /// routine are described by the \c CXErrorCode enum.
  int clang_reparseTranslationUnit(
    ffi.Pointer<CXTranslationUnitImpl> TU,
    int num_unsaved_files,
    ffi.Pointer<CXUnsavedFile> unsaved_files,
    int options,
  ) {
    return (_clang_reparseTranslationUnit ??=
        _lookup<ffi.NativeFunction<_c_clang_reparseTranslationUnit>>(
                'clang_reparseTranslationUnit')
            .asFunction<_dart_clang_reparseTranslationUnit>())(
      TU,
      num_unsaved_files,
      unsaved_files,
      options,
    );
  }

  _dart_clang_reparseTranslationUnit? _clang_reparseTranslationUnit;

  /// Returns the human-readable null-terminated C string that represents
  /// the name of the memory category.  This string should never be freed.
  ffi.Pointer<ffi.Int8> clang_getTUResourceUsageName(
    int kind,
  ) {
    return (_clang_getTUResourceUsageName ??=
        _lookup<ffi.NativeFunction<_c_clang_getTUResourceUsageName>>(
                'clang_getTUResourceUsageName')
            .asFunction<_dart_clang_getTUResourceUsageName>())(
      kind,
    );
  }

  _dart_clang_getTUResourceUsageName? _clang_getTUResourceUsageName;

  /// Return the memory usage of a translation unit.  This object
  /// should be released with clang_disposeCXTUResourceUsage().
  CXTUResourceUsage clang_getCXTUResourceUsage(
    ffi.Pointer<CXTranslationUnitImpl> TU,
  ) {
    return (_clang_getCXTUResourceUsage ??=
        _lookup<ffi.NativeFunction<_c_clang_getCXTUResourceUsage>>(
                'clang_getCXTUResourceUsage')
            .asFunction<_dart_clang_getCXTUResourceUsage>())(
      TU,
    );
  }

  _dart_clang_getCXTUResourceUsage? _clang_getCXTUResourceUsage;

  void clang_disposeCXTUResourceUsage(
    CXTUResourceUsage usage,
  ) {
    return (_clang_disposeCXTUResourceUsage ??=
        _lookup<ffi.NativeFunction<_c_clang_disposeCXTUResourceUsage>>(
                'clang_disposeCXTUResourceUsage')
            .asFunction<_dart_clang_disposeCXTUResourceUsage>())(
      usage,
    );
  }

  _dart_clang_disposeCXTUResourceUsage? _clang_disposeCXTUResourceUsage;

  /// Get target information for this translation unit.
  ///
  /// The CXTargetInfo object cannot outlive the CXTranslationUnit object.
  ffi.Pointer<CXTargetInfoImpl> clang_getTranslationUnitTargetInfo(
    ffi.Pointer<CXTranslationUnitImpl> CTUnit,
  ) {
    return (_clang_getTranslationUnitTargetInfo ??=
        _lookup<ffi.NativeFunction<_c_clang_getTranslationUnitTargetInfo>>(
                'clang_getTranslationUnitTargetInfo')
            .asFunction<_dart_clang_getTranslationUnitTargetInfo>())(
      CTUnit,
    );
  }

  _dart_clang_getTranslationUnitTargetInfo? _clang_getTranslationUnitTargetInfo;

  /// Destroy the CXTargetInfo object.
  void clang_TargetInfo_dispose(
    ffi.Pointer<CXTargetInfoImpl> Info,
  ) {
    return (_clang_TargetInfo_dispose ??=
        _lookup<ffi.NativeFunction<_c_clang_TargetInfo_dispose>>(
                'clang_TargetInfo_dispose')
            .asFunction<_dart_clang_TargetInfo_dispose>())(
      Info,
    );
  }

  _dart_clang_TargetInfo_dispose? _clang_TargetInfo_dispose;

  /// Get the normalized target triple as a string.
  ///
  /// Returns the empty string in case of any error.
  CXString clang_TargetInfo_getTriple(
    ffi.Pointer<CXTargetInfoImpl> Info,
  ) {
    return (_clang_TargetInfo_getTriple ??=
        _lookup<ffi.NativeFunction<_c_clang_TargetInfo_getTriple>>(
                'clang_TargetInfo_getTriple')
            .asFunction<_dart_clang_TargetInfo_getTriple>())(
      Info,
    );
  }

  _dart_clang_TargetInfo_getTriple? _clang_TargetInfo_getTriple;

  /// Get the pointer width of the target in bits.
  ///
  /// Returns -1 in case of error.
  int clang_TargetInfo_getPointerWidth(
    ffi.Pointer<CXTargetInfoImpl> Info,
  ) {
    return (_clang_TargetInfo_getPointerWidth ??=
        _lookup<ffi.NativeFunction<_c_clang_TargetInfo_getPointerWidth>>(
                'clang_TargetInfo_getPointerWidth')
            .asFunction<_dart_clang_TargetInfo_getPointerWidth>())(
      Info,
    );
  }

  _dart_clang_TargetInfo_getPointerWidth? _clang_TargetInfo_getPointerWidth;

  /// Retrieve the NULL cursor, which represents no entity.
  CXCursor clang_getNullCursor() {
    return (_clang_getNullCursor ??=
        _lookup<ffi.NativeFunction<_c_clang_getNullCursor>>(
                'clang_getNullCursor')
            .asFunction<_dart_clang_getNullCursor>())();
  }

  _dart_clang_getNullCursor? _clang_getNullCursor;

  /// Retrieve the cursor that represents the given translation unit.
  ///
  /// The translation unit cursor can be used to start traversing the
  /// various declarations within the given translation unit.
  CXCursor clang_getTranslationUnitCursor(
    ffi.Pointer<CXTranslationUnitImpl> arg0,
  ) {
    return (_clang_getTranslationUnitCursor ??=
        _lookup<ffi.NativeFunction<_c_clang_getTranslationUnitCursor>>(
                'clang_getTranslationUnitCursor')
            .asFunction<_dart_clang_getTranslationUnitCursor>())(
      arg0,
    );
  }

  _dart_clang_getTranslationUnitCursor? _clang_getTranslationUnitCursor;

  /// Determine whether two cursors are equivalent.
  int clang_equalCursors(
    CXCursor arg0,
    CXCursor arg1,
  ) {
    return (_clang_equalCursors ??=
        _lookup<ffi.NativeFunction<_c_clang_equalCursors>>('clang_equalCursors')
            .asFunction<_dart_clang_equalCursors>())(
      arg0,
      arg1,
    );
  }

  _dart_clang_equalCursors? _clang_equalCursors;

  /// Returns non-zero if \p cursor is null.
  int clang_Cursor_isNull(
    CXCursor cursor,
  ) {
    return (_clang_Cursor_isNull ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_isNull>>(
                'clang_Cursor_isNull')
            .asFunction<_dart_clang_Cursor_isNull>())(
      cursor,
    );
  }

  _dart_clang_Cursor_isNull? _clang_Cursor_isNull;

  /// Compute a hash value for the given cursor.
  int clang_hashCursor(
    CXCursor arg0,
  ) {
    return (_clang_hashCursor ??=
        _lookup<ffi.NativeFunction<_c_clang_hashCursor>>('clang_hashCursor')
            .asFunction<_dart_clang_hashCursor>())(
      arg0,
    );
  }

  _dart_clang_hashCursor? _clang_hashCursor;

  /// Retrieve the kind of the given cursor.
  int clang_getCursorKind(
    CXCursor arg0,
  ) {
    return (_clang_getCursorKind ??=
        _lookup<ffi.NativeFunction<_c_clang_getCursorKind>>(
                'clang_getCursorKind')
            .asFunction<_dart_clang_getCursorKind>())(
      arg0,
    );
  }

  _dart_clang_getCursorKind? _clang_getCursorKind;

  /// Determine whether the given cursor kind represents a declaration.
  int clang_isDeclaration(
    int arg0,
  ) {
    return (_clang_isDeclaration ??=
        _lookup<ffi.NativeFunction<_c_clang_isDeclaration>>(
                'clang_isDeclaration')
            .asFunction<_dart_clang_isDeclaration>())(
      arg0,
    );
  }

  _dart_clang_isDeclaration? _clang_isDeclaration;

  /// Determine whether the given declaration is invalid.
  ///
  /// A declaration is invalid if it could not be parsed successfully.
  ///
  /// \returns non-zero if the cursor represents a declaration and it is
  /// invalid, otherwise NULL.
  int clang_isInvalidDeclaration(
    CXCursor arg0,
  ) {
    return (_clang_isInvalidDeclaration ??=
        _lookup<ffi.NativeFunction<_c_clang_isInvalidDeclaration>>(
                'clang_isInvalidDeclaration')
            .asFunction<_dart_clang_isInvalidDeclaration>())(
      arg0,
    );
  }

  _dart_clang_isInvalidDeclaration? _clang_isInvalidDeclaration;

  /// Determine whether the given cursor kind represents a simple
  /// reference.
  ///
  /// Note that other kinds of cursors (such as expressions) can also refer to
  /// other cursors. Use clang_getCursorReferenced() to determine whether a
  /// particular cursor refers to another entity.
  int clang_isReference(
    int arg0,
  ) {
    return (_clang_isReference ??=
        _lookup<ffi.NativeFunction<_c_clang_isReference>>('clang_isReference')
            .asFunction<_dart_clang_isReference>())(
      arg0,
    );
  }

  _dart_clang_isReference? _clang_isReference;

  /// Determine whether the given cursor kind represents an expression.
  int clang_isExpression(
    int arg0,
  ) {
    return (_clang_isExpression ??=
        _lookup<ffi.NativeFunction<_c_clang_isExpression>>('clang_isExpression')
            .asFunction<_dart_clang_isExpression>())(
      arg0,
    );
  }

  _dart_clang_isExpression? _clang_isExpression;

  /// Determine whether the given cursor kind represents a statement.
  int clang_isStatement(
    int arg0,
  ) {
    return (_clang_isStatement ??=
        _lookup<ffi.NativeFunction<_c_clang_isStatement>>('clang_isStatement')
            .asFunction<_dart_clang_isStatement>())(
      arg0,
    );
  }

  _dart_clang_isStatement? _clang_isStatement;

  /// Determine whether the given cursor kind represents an attribute.
  int clang_isAttribute(
    int arg0,
  ) {
    return (_clang_isAttribute ??=
        _lookup<ffi.NativeFunction<_c_clang_isAttribute>>('clang_isAttribute')
            .asFunction<_dart_clang_isAttribute>())(
      arg0,
    );
  }

  _dart_clang_isAttribute? _clang_isAttribute;

  /// Determine whether the given cursor has any attributes.
  int clang_Cursor_hasAttrs(
    CXCursor C,
  ) {
    return (_clang_Cursor_hasAttrs ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_hasAttrs>>(
                'clang_Cursor_hasAttrs')
            .asFunction<_dart_clang_Cursor_hasAttrs>())(
      C,
    );
  }

  _dart_clang_Cursor_hasAttrs? _clang_Cursor_hasAttrs;

  /// Determine whether the given cursor kind represents an invalid
  /// cursor.
  int clang_isInvalid(
    int arg0,
  ) {
    return (_clang_isInvalid ??=
        _lookup<ffi.NativeFunction<_c_clang_isInvalid>>('clang_isInvalid')
            .asFunction<_dart_clang_isInvalid>())(
      arg0,
    );
  }

  _dart_clang_isInvalid? _clang_isInvalid;

  /// Determine whether the given cursor kind represents a translation
  /// unit.
  int clang_isTranslationUnit(
    int arg0,
  ) {
    return (_clang_isTranslationUnit ??=
        _lookup<ffi.NativeFunction<_c_clang_isTranslationUnit>>(
                'clang_isTranslationUnit')
            .asFunction<_dart_clang_isTranslationUnit>())(
      arg0,
    );
  }

  _dart_clang_isTranslationUnit? _clang_isTranslationUnit;

  /// Determine whether the given cursor represents a preprocessing
  /// element, such as a preprocessor directive or macro instantiation.
  int clang_isPreprocessing(
    int arg0,
  ) {
    return (_clang_isPreprocessing ??=
        _lookup<ffi.NativeFunction<_c_clang_isPreprocessing>>(
                'clang_isPreprocessing')
            .asFunction<_dart_clang_isPreprocessing>())(
      arg0,
    );
  }

  _dart_clang_isPreprocessing? _clang_isPreprocessing;

  /// Determine whether the given cursor represents a currently
  /// unexposed piece of the AST (e.g., CXCursor_UnexposedStmt).
  int clang_isUnexposed(
    int arg0,
  ) {
    return (_clang_isUnexposed ??=
        _lookup<ffi.NativeFunction<_c_clang_isUnexposed>>('clang_isUnexposed')
            .asFunction<_dart_clang_isUnexposed>())(
      arg0,
    );
  }

  _dart_clang_isUnexposed? _clang_isUnexposed;

  /// Determine the linkage of the entity referred to by a given cursor.
  int clang_getCursorLinkage(
    CXCursor cursor,
  ) {
    return (_clang_getCursorLinkage ??=
        _lookup<ffi.NativeFunction<_c_clang_getCursorLinkage>>(
                'clang_getCursorLinkage')
            .asFunction<_dart_clang_getCursorLinkage>())(
      cursor,
    );
  }

  _dart_clang_getCursorLinkage? _clang_getCursorLinkage;

  /// Describe the visibility of the entity referred to by a cursor.
  ///
  /// This returns the default visibility if not explicitly specified by
  /// a visibility attribute. The default visibility may be changed by
  /// commandline arguments.
  ///
  /// \param cursor The cursor to query.
  ///
  /// \returns The visibility of the cursor.
  int clang_getCursorVisibility(
    CXCursor cursor,
  ) {
    return (_clang_getCursorVisibility ??=
        _lookup<ffi.NativeFunction<_c_clang_getCursorVisibility>>(
                'clang_getCursorVisibility')
            .asFunction<_dart_clang_getCursorVisibility>())(
      cursor,
    );
  }

  _dart_clang_getCursorVisibility? _clang_getCursorVisibility;

  /// Determine the availability of the entity that this cursor refers to,
  /// taking the current target platform into account.
  ///
  /// \param cursor The cursor to query.
  ///
  /// \returns The availability of the cursor.
  int clang_getCursorAvailability(
    CXCursor cursor,
  ) {
    return (_clang_getCursorAvailability ??=
        _lookup<ffi.NativeFunction<_c_clang_getCursorAvailability>>(
                'clang_getCursorAvailability')
            .asFunction<_dart_clang_getCursorAvailability>())(
      cursor,
    );
  }

  _dart_clang_getCursorAvailability? _clang_getCursorAvailability;

  /// Determine the availability of the entity that this cursor refers to
  /// on any platforms for which availability information is known.
  ///
  /// \param cursor The cursor to query.
  ///
  /// \param always_deprecated If non-NULL, will be set to indicate whether the
  /// entity is deprecated on all platforms.
  ///
  /// \param deprecated_message If non-NULL, will be set to the message text
  /// provided along with the unconditional deprecation of this entity. The client
  /// is responsible for deallocating this string.
  ///
  /// \param always_unavailable If non-NULL, will be set to indicate whether the
  /// entity is unavailable on all platforms.
  ///
  /// \param unavailable_message If non-NULL, will be set to the message text
  /// provided along with the unconditional unavailability of this entity. The
  /// client is responsible for deallocating this string.
  ///
  /// \param availability If non-NULL, an array of CXPlatformAvailability instances
  /// that will be populated with platform availability information, up to either
  /// the number of platforms for which availability information is available (as
  /// returned by this function) or \c availability_size, whichever is smaller.
  ///
  /// \param availability_size The number of elements available in the
  /// \c availability array.
  ///
  /// \returns The number of platforms (N) for which availability information is
  /// available (which is unrelated to \c availability_size).
  ///
  /// Note that the client is responsible for calling
  /// \c clang_disposeCXPlatformAvailability to free each of the
  /// platform-availability structures returned. There are
  /// \c min(N, availability_size) such structures.
  int clang_getCursorPlatformAvailability(
    CXCursor cursor,
    ffi.Pointer<ffi.Int32> always_deprecated,
    ffi.Pointer<CXString> deprecated_message,
    ffi.Pointer<ffi.Int32> always_unavailable,
    ffi.Pointer<CXString> unavailable_message,
    ffi.Pointer<CXPlatformAvailability> availability,
    int availability_size,
  ) {
    return (_clang_getCursorPlatformAvailability ??=
        _lookup<ffi.NativeFunction<_c_clang_getCursorPlatformAvailability>>(
                'clang_getCursorPlatformAvailability')
            .asFunction<_dart_clang_getCursorPlatformAvailability>())(
      cursor,
      always_deprecated,
      deprecated_message,
      always_unavailable,
      unavailable_message,
      availability,
      availability_size,
    );
  }

  _dart_clang_getCursorPlatformAvailability?
      _clang_getCursorPlatformAvailability;

  /// Free the memory associated with a \c CXPlatformAvailability structure.
  void clang_disposeCXPlatformAvailability(
    ffi.Pointer<CXPlatformAvailability> availability,
  ) {
    return (_clang_disposeCXPlatformAvailability ??=
        _lookup<ffi.NativeFunction<_c_clang_disposeCXPlatformAvailability>>(
                'clang_disposeCXPlatformAvailability')
            .asFunction<_dart_clang_disposeCXPlatformAvailability>())(
      availability,
    );
  }

  _dart_clang_disposeCXPlatformAvailability?
      _clang_disposeCXPlatformAvailability;

  /// Determine the "language" of the entity referred to by a given cursor.
  int clang_getCursorLanguage(
    CXCursor cursor,
  ) {
    return (_clang_getCursorLanguage ??=
        _lookup<ffi.NativeFunction<_c_clang_getCursorLanguage>>(
                'clang_getCursorLanguage')
            .asFunction<_dart_clang_getCursorLanguage>())(
      cursor,
    );
  }

  _dart_clang_getCursorLanguage? _clang_getCursorLanguage;

  /// Determine the "thread-local storage (TLS) kind" of the declaration
  /// referred to by a cursor.
  int clang_getCursorTLSKind(
    CXCursor cursor,
  ) {
    return (_clang_getCursorTLSKind ??=
        _lookup<ffi.NativeFunction<_c_clang_getCursorTLSKind>>(
                'clang_getCursorTLSKind')
            .asFunction<_dart_clang_getCursorTLSKind>())(
      cursor,
    );
  }

  _dart_clang_getCursorTLSKind? _clang_getCursorTLSKind;

  /// Returns the translation unit that a cursor originated from.
  ffi.Pointer<CXTranslationUnitImpl> clang_Cursor_getTranslationUnit(
    CXCursor arg0,
  ) {
    return (_clang_Cursor_getTranslationUnit ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_getTranslationUnit>>(
                'clang_Cursor_getTranslationUnit')
            .asFunction<_dart_clang_Cursor_getTranslationUnit>())(
      arg0,
    );
  }

  _dart_clang_Cursor_getTranslationUnit? _clang_Cursor_getTranslationUnit;

  /// Creates an empty CXCursorSet.
  ffi.Pointer<CXCursorSetImpl> clang_createCXCursorSet() {
    return (_clang_createCXCursorSet ??=
        _lookup<ffi.NativeFunction<_c_clang_createCXCursorSet>>(
                'clang_createCXCursorSet')
            .asFunction<_dart_clang_createCXCursorSet>())();
  }

  _dart_clang_createCXCursorSet? _clang_createCXCursorSet;

  /// Disposes a CXCursorSet and releases its associated memory.
  void clang_disposeCXCursorSet(
    ffi.Pointer<CXCursorSetImpl> cset,
  ) {
    return (_clang_disposeCXCursorSet ??=
        _lookup<ffi.NativeFunction<_c_clang_disposeCXCursorSet>>(
                'clang_disposeCXCursorSet')
            .asFunction<_dart_clang_disposeCXCursorSet>())(
      cset,
    );
  }

  _dart_clang_disposeCXCursorSet? _clang_disposeCXCursorSet;

  /// Queries a CXCursorSet to see if it contains a specific CXCursor.
  ///
  /// \returns non-zero if the set contains the specified cursor.
  int clang_CXCursorSet_contains(
    ffi.Pointer<CXCursorSetImpl> cset,
    CXCursor cursor,
  ) {
    return (_clang_CXCursorSet_contains ??=
        _lookup<ffi.NativeFunction<_c_clang_CXCursorSet_contains>>(
                'clang_CXCursorSet_contains')
            .asFunction<_dart_clang_CXCursorSet_contains>())(
      cset,
      cursor,
    );
  }

  _dart_clang_CXCursorSet_contains? _clang_CXCursorSet_contains;

  /// Inserts a CXCursor into a CXCursorSet.
  ///
  /// \returns zero if the CXCursor was already in the set, and non-zero otherwise.
  int clang_CXCursorSet_insert(
    ffi.Pointer<CXCursorSetImpl> cset,
    CXCursor cursor,
  ) {
    return (_clang_CXCursorSet_insert ??=
        _lookup<ffi.NativeFunction<_c_clang_CXCursorSet_insert>>(
                'clang_CXCursorSet_insert')
            .asFunction<_dart_clang_CXCursorSet_insert>())(
      cset,
      cursor,
    );
  }

  _dart_clang_CXCursorSet_insert? _clang_CXCursorSet_insert;

  /// Determine the semantic parent of the given cursor.
  ///
  /// The semantic parent of a cursor is the cursor that semantically contains
  /// the given \p cursor. For many declarations, the lexical and semantic parents
  /// are equivalent (the lexical parent is returned by
  /// \c clang_getCursorLexicalParent()). They diverge when declarations or
  /// definitions are provided out-of-line. For example:
  ///
  /// \code
  /// class C {
  /// void f();
  /// };
  ///
  /// void C::f() { }
  /// \endcode
  ///
  /// In the out-of-line definition of \c C::f, the semantic parent is
  /// the class \c C, of which this function is a member. The lexical parent is
  /// the place where the declaration actually occurs in the source code; in this
  /// case, the definition occurs in the translation unit. In general, the
  /// lexical parent for a given entity can change without affecting the semantics
  /// of the program, and the lexical parent of different declarations of the
  /// same entity may be different. Changing the semantic parent of a declaration,
  /// on the other hand, can have a major impact on semantics, and redeclarations
  /// of a particular entity should all have the same semantic context.
  ///
  /// In the example above, both declarations of \c C::f have \c C as their
  /// semantic context, while the lexical context of the first \c C::f is \c C
  /// and the lexical context of the second \c C::f is the translation unit.
  ///
  /// For global declarations, the semantic parent is the translation unit.
  CXCursor clang_getCursorSemanticParent(
    CXCursor cursor,
  ) {
    return (_clang_getCursorSemanticParent ??=
        _lookup<ffi.NativeFunction<_c_clang_getCursorSemanticParent>>(
                'clang_getCursorSemanticParent')
            .asFunction<_dart_clang_getCursorSemanticParent>())(
      cursor,
    );
  }

  _dart_clang_getCursorSemanticParent? _clang_getCursorSemanticParent;

  /// Determine the lexical parent of the given cursor.
  ///
  /// The lexical parent of a cursor is the cursor in which the given \p cursor
  /// was actually written. For many declarations, the lexical and semantic parents
  /// are equivalent (the semantic parent is returned by
  /// \c clang_getCursorSemanticParent()). They diverge when declarations or
  /// definitions are provided out-of-line. For example:
  ///
  /// \code
  /// class C {
  /// void f();
  /// };
  ///
  /// void C::f() { }
  /// \endcode
  ///
  /// In the out-of-line definition of \c C::f, the semantic parent is
  /// the class \c C, of which this function is a member. The lexical parent is
  /// the place where the declaration actually occurs in the source code; in this
  /// case, the definition occurs in the translation unit. In general, the
  /// lexical parent for a given entity can change without affecting the semantics
  /// of the program, and the lexical parent of different declarations of the
  /// same entity may be different. Changing the semantic parent of a declaration,
  /// on the other hand, can have a major impact on semantics, and redeclarations
  /// of a particular entity should all have the same semantic context.
  ///
  /// In the example above, both declarations of \c C::f have \c C as their
  /// semantic context, while the lexical context of the first \c C::f is \c C
  /// and the lexical context of the second \c C::f is the translation unit.
  ///
  /// For declarations written in the global scope, the lexical parent is
  /// the translation unit.
  CXCursor clang_getCursorLexicalParent(
    CXCursor cursor,
  ) {
    return (_clang_getCursorLexicalParent ??=
        _lookup<ffi.NativeFunction<_c_clang_getCursorLexicalParent>>(
                'clang_getCursorLexicalParent')
            .asFunction<_dart_clang_getCursorLexicalParent>())(
      cursor,
    );
  }

  _dart_clang_getCursorLexicalParent? _clang_getCursorLexicalParent;

  /// Determine the set of methods that are overridden by the given
  /// method.
  ///
  /// In both Objective-C and C++, a method (aka virtual member function,
  /// in C++) can override a virtual method in a base class. For
  /// Objective-C, a method is said to override any method in the class's
  /// base class, its protocols, or its categories' protocols, that has the same
  /// selector and is of the same kind (class or instance).
  /// If no such method exists, the search continues to the class's superclass,
  /// its protocols, and its categories, and so on. A method from an Objective-C
  /// implementation is considered to override the same methods as its
  /// corresponding method in the interface.
  ///
  /// For C++, a virtual member function overrides any virtual member
  /// function with the same signature that occurs in its base
  /// classes. With multiple inheritance, a virtual member function can
  /// override several virtual member functions coming from different
  /// base classes.
  ///
  /// In all cases, this function determines the immediate overridden
  /// method, rather than all of the overridden methods. For example, if
  /// a method is originally declared in a class A, then overridden in B
  /// (which in inherits from A) and also in C (which inherited from B),
  /// then the only overridden method returned from this function when
  /// invoked on C's method will be B's method. The client may then
  /// invoke this function again, given the previously-found overridden
  /// methods, to map out the complete method-override set.
  ///
  /// \param cursor A cursor representing an Objective-C or C++
  /// method. This routine will compute the set of methods that this
  /// method overrides.
  ///
  /// \param overridden A pointer whose pointee will be replaced with a
  /// pointer to an array of cursors, representing the set of overridden
  /// methods. If there are no overridden methods, the pointee will be
  /// set to NULL. The pointee must be freed via a call to
  /// \c clang_disposeOverriddenCursors().
  ///
  /// \param num_overridden A pointer to the number of overridden
  /// functions, will be set to the number of overridden functions in the
  /// array pointed to by \p overridden.
  void clang_getOverriddenCursors(
    CXCursor cursor,
    ffi.Pointer<ffi.Pointer<CXCursor>> overridden,
    ffi.Pointer<ffi.Uint32> num_overridden,
  ) {
    return (_clang_getOverriddenCursors ??=
        _lookup<ffi.NativeFunction<_c_clang_getOverriddenCursors>>(
                'clang_getOverriddenCursors')
            .asFunction<_dart_clang_getOverriddenCursors>())(
      cursor,
      overridden,
      num_overridden,
    );
  }

  _dart_clang_getOverriddenCursors? _clang_getOverriddenCursors;

  /// Free the set of overridden cursors returned by \c
  /// clang_getOverriddenCursors().
  void clang_disposeOverriddenCursors(
    ffi.Pointer<CXCursor> overridden,
  ) {
    return (_clang_disposeOverriddenCursors ??=
        _lookup<ffi.NativeFunction<_c_clang_disposeOverriddenCursors>>(
                'clang_disposeOverriddenCursors')
            .asFunction<_dart_clang_disposeOverriddenCursors>())(
      overridden,
    );
  }

  _dart_clang_disposeOverriddenCursors? _clang_disposeOverriddenCursors;

  /// Retrieve the file that is included by the given inclusion directive
  /// cursor.
  ffi.Pointer<ffi.Void> clang_getIncludedFile(
    CXCursor cursor,
  ) {
    return (_clang_getIncludedFile ??=
        _lookup<ffi.NativeFunction<_c_clang_getIncludedFile>>(
                'clang_getIncludedFile')
            .asFunction<_dart_clang_getIncludedFile>())(
      cursor,
    );
  }

  _dart_clang_getIncludedFile? _clang_getIncludedFile;

  /// Map a source location to the cursor that describes the entity at that
  /// location in the source code.
  ///
  /// clang_getCursor() maps an arbitrary source location within a translation
  /// unit down to the most specific cursor that describes the entity at that
  /// location. For example, given an expression \c x + y, invoking
  /// clang_getCursor() with a source location pointing to "x" will return the
  /// cursor for "x"; similarly for "y". If the cursor points anywhere between
  /// "x" or "y" (e.g., on the + or the whitespace around it), clang_getCursor()
  /// will return a cursor referring to the "+" expression.
  ///
  /// \returns a cursor representing the entity at the given source location, or
  /// a NULL cursor if no such entity can be found.
  CXCursor clang_getCursor(
    ffi.Pointer<CXTranslationUnitImpl> arg0,
    CXSourceLocation arg1,
  ) {
    return (_clang_getCursor ??=
        _lookup<ffi.NativeFunction<_c_clang_getCursor>>('clang_getCursor')
            .asFunction<_dart_clang_getCursor>())(
      arg0,
      arg1,
    );
  }

  _dart_clang_getCursor? _clang_getCursor;

  /// Retrieve the physical location of the source constructor referenced
  /// by the given cursor.
  ///
  /// The location of a declaration is typically the location of the name of that
  /// declaration, where the name of that declaration would occur if it is
  /// unnamed, or some keyword that introduces that particular declaration.
  /// The location of a reference is where that reference occurs within the
  /// source code.
  CXSourceLocation clang_getCursorLocation(
    CXCursor arg0,
  ) {
    return (_clang_getCursorLocation ??=
        _lookup<ffi.NativeFunction<_c_clang_getCursorLocation>>(
                'clang_getCursorLocation')
            .asFunction<_dart_clang_getCursorLocation>())(
      arg0,
    );
  }

  _dart_clang_getCursorLocation? _clang_getCursorLocation;

  /// Retrieve the physical extent of the source construct referenced by
  /// the given cursor.
  ///
  /// The extent of a cursor starts with the file/line/column pointing at the
  /// first character within the source construct that the cursor refers to and
  /// ends with the last character within that source construct. For a
  /// declaration, the extent covers the declaration itself. For a reference,
  /// the extent covers the location of the reference (e.g., where the referenced
  /// entity was actually used).
  CXSourceRange clang_getCursorExtent(
    CXCursor arg0,
  ) {
    return (_clang_getCursorExtent ??=
        _lookup<ffi.NativeFunction<_c_clang_getCursorExtent>>(
                'clang_getCursorExtent')
            .asFunction<_dart_clang_getCursorExtent>())(
      arg0,
    );
  }

  _dart_clang_getCursorExtent? _clang_getCursorExtent;

  /// Retrieve the type of a CXCursor (if any).
  CXType clang_getCursorType(
    CXCursor C,
  ) {
    return (_clang_getCursorType ??=
        _lookup<ffi.NativeFunction<_c_clang_getCursorType>>(
                'clang_getCursorType')
            .asFunction<_dart_clang_getCursorType>())(
      C,
    );
  }

  _dart_clang_getCursorType? _clang_getCursorType;

  /// Pretty-print the underlying type using the rules of the
  /// language of the translation unit from which it came.
  ///
  /// If the type is invalid, an empty string is returned.
  CXString clang_getTypeSpelling(
    CXType CT,
  ) {
    return (_clang_getTypeSpelling ??=
        _lookup<ffi.NativeFunction<_c_clang_getTypeSpelling>>(
                'clang_getTypeSpelling')
            .asFunction<_dart_clang_getTypeSpelling>())(
      CT,
    );
  }

  _dart_clang_getTypeSpelling? _clang_getTypeSpelling;

  /// Retrieve the underlying type of a typedef declaration.
  ///
  /// If the cursor does not reference a typedef declaration, an invalid type is
  /// returned.
  CXType clang_getTypedefDeclUnderlyingType(
    CXCursor C,
  ) {
    return (_clang_getTypedefDeclUnderlyingType ??=
        _lookup<ffi.NativeFunction<_c_clang_getTypedefDeclUnderlyingType>>(
                'clang_getTypedefDeclUnderlyingType')
            .asFunction<_dart_clang_getTypedefDeclUnderlyingType>())(
      C,
    );
  }

  _dart_clang_getTypedefDeclUnderlyingType? _clang_getTypedefDeclUnderlyingType;

  /// Retrieve the integer type of an enum declaration.
  ///
  /// If the cursor does not reference an enum declaration, an invalid type is
  /// returned.
  CXType clang_getEnumDeclIntegerType(
    CXCursor C,
  ) {
    return (_clang_getEnumDeclIntegerType ??=
        _lookup<ffi.NativeFunction<_c_clang_getEnumDeclIntegerType>>(
                'clang_getEnumDeclIntegerType')
            .asFunction<_dart_clang_getEnumDeclIntegerType>())(
      C,
    );
  }

  _dart_clang_getEnumDeclIntegerType? _clang_getEnumDeclIntegerType;

  /// Retrieve the integer value of an enum constant declaration as a signed
  /// long long.
  ///
  /// If the cursor does not reference an enum constant declaration, LLONG_MIN is returned.
  /// Since this is also potentially a valid constant value, the kind of the cursor
  /// must be verified before calling this function.
  int clang_getEnumConstantDeclValue(
    CXCursor C,
  ) {
    return (_clang_getEnumConstantDeclValue ??=
        _lookup<ffi.NativeFunction<_c_clang_getEnumConstantDeclValue>>(
                'clang_getEnumConstantDeclValue')
            .asFunction<_dart_clang_getEnumConstantDeclValue>())(
      C,
    );
  }

  _dart_clang_getEnumConstantDeclValue? _clang_getEnumConstantDeclValue;

  /// Retrieve the integer value of an enum constant declaration as an unsigned
  /// long long.
  ///
  /// If the cursor does not reference an enum constant declaration, ULLONG_MAX is returned.
  /// Since this is also potentially a valid constant value, the kind of the cursor
  /// must be verified before calling this function.
  int clang_getEnumConstantDeclUnsignedValue(
    CXCursor C,
  ) {
    return (_clang_getEnumConstantDeclUnsignedValue ??=
        _lookup<ffi.NativeFunction<_c_clang_getEnumConstantDeclUnsignedValue>>(
                'clang_getEnumConstantDeclUnsignedValue')
            .asFunction<_dart_clang_getEnumConstantDeclUnsignedValue>())(
      C,
    );
  }

  _dart_clang_getEnumConstantDeclUnsignedValue?
      _clang_getEnumConstantDeclUnsignedValue;

  /// Retrieve the bit width of a bit field declaration as an integer.
  ///
  /// If a cursor that is not a bit field declaration is passed in, -1 is returned.
  int clang_getFieldDeclBitWidth(
    CXCursor C,
  ) {
    return (_clang_getFieldDeclBitWidth ??=
        _lookup<ffi.NativeFunction<_c_clang_getFieldDeclBitWidth>>(
                'clang_getFieldDeclBitWidth')
            .asFunction<_dart_clang_getFieldDeclBitWidth>())(
      C,
    );
  }

  _dart_clang_getFieldDeclBitWidth? _clang_getFieldDeclBitWidth;

  /// Retrieve the number of non-variadic arguments associated with a given
  /// cursor.
  ///
  /// The number of arguments can be determined for calls as well as for
  /// declarations of functions or methods. For other cursors -1 is returned.
  int clang_Cursor_getNumArguments(
    CXCursor C,
  ) {
    return (_clang_Cursor_getNumArguments ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_getNumArguments>>(
                'clang_Cursor_getNumArguments')
            .asFunction<_dart_clang_Cursor_getNumArguments>())(
      C,
    );
  }

  _dart_clang_Cursor_getNumArguments? _clang_Cursor_getNumArguments;

  /// Retrieve the argument cursor of a function or method.
  ///
  /// The argument cursor can be determined for calls as well as for declarations
  /// of functions or methods. For other cursors and for invalid indices, an
  /// invalid cursor is returned.
  CXCursor clang_Cursor_getArgument(
    CXCursor C,
    int i,
  ) {
    return (_clang_Cursor_getArgument ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_getArgument>>(
                'clang_Cursor_getArgument')
            .asFunction<_dart_clang_Cursor_getArgument>())(
      C,
      i,
    );
  }

  _dart_clang_Cursor_getArgument? _clang_Cursor_getArgument;

  /// Returns the number of template args of a function decl representing a
  /// template specialization.
  ///
  /// If the argument cursor cannot be converted into a template function
  /// declaration, -1 is returned.
  ///
  /// For example, for the following declaration and specialization:
  /// template <typename T, int kInt, bool kBool>
  /// void foo() { ... }
  ///
  /// template <>
  /// void foo<float, -7, true>();
  ///
  /// The value 3 would be returned from this call.
  int clang_Cursor_getNumTemplateArguments(
    CXCursor C,
  ) {
    return (_clang_Cursor_getNumTemplateArguments ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_getNumTemplateArguments>>(
                'clang_Cursor_getNumTemplateArguments')
            .asFunction<_dart_clang_Cursor_getNumTemplateArguments>())(
      C,
    );
  }

  _dart_clang_Cursor_getNumTemplateArguments?
      _clang_Cursor_getNumTemplateArguments;

  /// Retrieve the kind of the I'th template argument of the CXCursor C.
  ///
  /// If the argument CXCursor does not represent a FunctionDecl, an invalid
  /// template argument kind is returned.
  ///
  /// For example, for the following declaration and specialization:
  /// template <typename T, int kInt, bool kBool>
  /// void foo() { ... }
  ///
  /// template <>
  /// void foo<float, -7, true>();
  ///
  /// For I = 0, 1, and 2, Type, Integral, and Integral will be returned,
  /// respectively.
  int clang_Cursor_getTemplateArgumentKind(
    CXCursor C,
    int I,
  ) {
    return (_clang_Cursor_getTemplateArgumentKind ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_getTemplateArgumentKind>>(
                'clang_Cursor_getTemplateArgumentKind')
            .asFunction<_dart_clang_Cursor_getTemplateArgumentKind>())(
      C,
      I,
    );
  }

  _dart_clang_Cursor_getTemplateArgumentKind?
      _clang_Cursor_getTemplateArgumentKind;

  /// Retrieve a CXType representing the type of a TemplateArgument of a
  /// function decl representing a template specialization.
  ///
  /// If the argument CXCursor does not represent a FunctionDecl whose I'th
  /// template argument has a kind of CXTemplateArgKind_Integral, an invalid type
  /// is returned.
  ///
  /// For example, for the following declaration and specialization:
  /// template <typename T, int kInt, bool kBool>
  /// void foo() { ... }
  ///
  /// template <>
  /// void foo<float, -7, true>();
  ///
  /// If called with I = 0, "float", will be returned.
  /// Invalid types will be returned for I == 1 or 2.
  CXType clang_Cursor_getTemplateArgumentType(
    CXCursor C,
    int I,
  ) {
    return (_clang_Cursor_getTemplateArgumentType ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_getTemplateArgumentType>>(
                'clang_Cursor_getTemplateArgumentType')
            .asFunction<_dart_clang_Cursor_getTemplateArgumentType>())(
      C,
      I,
    );
  }

  _dart_clang_Cursor_getTemplateArgumentType?
      _clang_Cursor_getTemplateArgumentType;

  /// Retrieve the value of an Integral TemplateArgument (of a function
  /// decl representing a template specialization) as a signed long long.
  ///
  /// It is undefined to call this function on a CXCursor that does not represent a
  /// FunctionDecl or whose I'th template argument is not an integral value.
  ///
  /// For example, for the following declaration and specialization:
  /// template <typename T, int kInt, bool kBool>
  /// void foo() { ... }
  ///
  /// template <>
  /// void foo<float, -7, true>();
  ///
  /// If called with I = 1 or 2, -7 or true will be returned, respectively.
  /// For I == 0, this function's behavior is undefined.
  int clang_Cursor_getTemplateArgumentValue(
    CXCursor C,
    int I,
  ) {
    return (_clang_Cursor_getTemplateArgumentValue ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_getTemplateArgumentValue>>(
                'clang_Cursor_getTemplateArgumentValue')
            .asFunction<_dart_clang_Cursor_getTemplateArgumentValue>())(
      C,
      I,
    );
  }

  _dart_clang_Cursor_getTemplateArgumentValue?
      _clang_Cursor_getTemplateArgumentValue;

  /// Retrieve the value of an Integral TemplateArgument (of a function
  /// decl representing a template specialization) as an unsigned long long.
  ///
  /// It is undefined to call this function on a CXCursor that does not represent a
  /// FunctionDecl or whose I'th template argument is not an integral value.
  ///
  /// For example, for the following declaration and specialization:
  /// template <typename T, int kInt, bool kBool>
  /// void foo() { ... }
  ///
  /// template <>
  /// void foo<float, 2147483649, true>();
  ///
  /// If called with I = 1 or 2, 2147483649 or true will be returned, respectively.
  /// For I == 0, this function's behavior is undefined.
  int clang_Cursor_getTemplateArgumentUnsignedValue(
    CXCursor C,
    int I,
  ) {
    return (_clang_Cursor_getTemplateArgumentUnsignedValue ??= _lookup<
                ffi.NativeFunction<
                    _c_clang_Cursor_getTemplateArgumentUnsignedValue>>(
            'clang_Cursor_getTemplateArgumentUnsignedValue')
        .asFunction<_dart_clang_Cursor_getTemplateArgumentUnsignedValue>())(
      C,
      I,
    );
  }

  _dart_clang_Cursor_getTemplateArgumentUnsignedValue?
      _clang_Cursor_getTemplateArgumentUnsignedValue;

  /// Determine whether two CXTypes represent the same type.
  ///
  /// \returns non-zero if the CXTypes represent the same type and
  /// zero otherwise.
  int clang_equalTypes(
    CXType A,
    CXType B,
  ) {
    return (_clang_equalTypes ??=
        _lookup<ffi.NativeFunction<_c_clang_equalTypes>>('clang_equalTypes')
            .asFunction<_dart_clang_equalTypes>())(
      A,
      B,
    );
  }

  _dart_clang_equalTypes? _clang_equalTypes;

  /// Return the canonical type for a CXType.
  ///
  /// Clang's type system explicitly models typedefs and all the ways
  /// a specific type can be represented.  The canonical type is the underlying
  /// type with all the "sugar" removed.  For example, if 'T' is a typedef
  /// for 'int', the canonical type for 'T' would be 'int'.
  CXType clang_getCanonicalType(
    CXType T,
  ) {
    return (_clang_getCanonicalType ??=
        _lookup<ffi.NativeFunction<_c_clang_getCanonicalType>>(
                'clang_getCanonicalType')
            .asFunction<_dart_clang_getCanonicalType>())(
      T,
    );
  }

  _dart_clang_getCanonicalType? _clang_getCanonicalType;

  /// Determine whether a CXType has the "const" qualifier set,
  /// without looking through typedefs that may have added "const" at a
  /// different level.
  int clang_isConstQualifiedType(
    CXType T,
  ) {
    return (_clang_isConstQualifiedType ??=
        _lookup<ffi.NativeFunction<_c_clang_isConstQualifiedType>>(
                'clang_isConstQualifiedType')
            .asFunction<_dart_clang_isConstQualifiedType>())(
      T,
    );
  }

  _dart_clang_isConstQualifiedType? _clang_isConstQualifiedType;

  /// Determine whether a  CXCursor that is a macro, is
  /// function like.
  int clang_Cursor_isMacroFunctionLike(
    CXCursor C,
  ) {
    return (_clang_Cursor_isMacroFunctionLike ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_isMacroFunctionLike>>(
                'clang_Cursor_isMacroFunctionLike')
            .asFunction<_dart_clang_Cursor_isMacroFunctionLike>())(
      C,
    );
  }

  _dart_clang_Cursor_isMacroFunctionLike? _clang_Cursor_isMacroFunctionLike;

  /// Determine whether a  CXCursor that is a macro, is a
  /// builtin one.
  int clang_Cursor_isMacroBuiltin(
    CXCursor C,
  ) {
    return (_clang_Cursor_isMacroBuiltin ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_isMacroBuiltin>>(
                'clang_Cursor_isMacroBuiltin')
            .asFunction<_dart_clang_Cursor_isMacroBuiltin>())(
      C,
    );
  }

  _dart_clang_Cursor_isMacroBuiltin? _clang_Cursor_isMacroBuiltin;

  /// Determine whether a  CXCursor that is a function declaration, is an
  /// inline declaration.
  int clang_Cursor_isFunctionInlined(
    CXCursor C,
  ) {
    return (_clang_Cursor_isFunctionInlined ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_isFunctionInlined>>(
                'clang_Cursor_isFunctionInlined')
            .asFunction<_dart_clang_Cursor_isFunctionInlined>())(
      C,
    );
  }

  _dart_clang_Cursor_isFunctionInlined? _clang_Cursor_isFunctionInlined;

  /// Determine whether a CXType has the "volatile" qualifier set,
  /// without looking through typedefs that may have added "volatile" at
  /// a different level.
  int clang_isVolatileQualifiedType(
    CXType T,
  ) {
    return (_clang_isVolatileQualifiedType ??=
        _lookup<ffi.NativeFunction<_c_clang_isVolatileQualifiedType>>(
                'clang_isVolatileQualifiedType')
            .asFunction<_dart_clang_isVolatileQualifiedType>())(
      T,
    );
  }

  _dart_clang_isVolatileQualifiedType? _clang_isVolatileQualifiedType;

  /// Determine whether a CXType has the "restrict" qualifier set,
  /// without looking through typedefs that may have added "restrict" at a
  /// different level.
  int clang_isRestrictQualifiedType(
    CXType T,
  ) {
    return (_clang_isRestrictQualifiedType ??=
        _lookup<ffi.NativeFunction<_c_clang_isRestrictQualifiedType>>(
                'clang_isRestrictQualifiedType')
            .asFunction<_dart_clang_isRestrictQualifiedType>())(
      T,
    );
  }

  _dart_clang_isRestrictQualifiedType? _clang_isRestrictQualifiedType;

  /// Returns the address space of the given type.
  int clang_getAddressSpace(
    CXType T,
  ) {
    return (_clang_getAddressSpace ??=
        _lookup<ffi.NativeFunction<_c_clang_getAddressSpace>>(
                'clang_getAddressSpace')
            .asFunction<_dart_clang_getAddressSpace>())(
      T,
    );
  }

  _dart_clang_getAddressSpace? _clang_getAddressSpace;

  /// Returns the typedef name of the given type.
  CXString clang_getTypedefName(
    CXType CT,
  ) {
    return (_clang_getTypedefName ??=
        _lookup<ffi.NativeFunction<_c_clang_getTypedefName>>(
                'clang_getTypedefName')
            .asFunction<_dart_clang_getTypedefName>())(
      CT,
    );
  }

  _dart_clang_getTypedefName? _clang_getTypedefName;

  /// For pointer types, returns the type of the pointee.
  CXType clang_getPointeeType(
    CXType T,
  ) {
    return (_clang_getPointeeType ??=
        _lookup<ffi.NativeFunction<_c_clang_getPointeeType>>(
                'clang_getPointeeType')
            .asFunction<_dart_clang_getPointeeType>())(
      T,
    );
  }

  _dart_clang_getPointeeType? _clang_getPointeeType;

  /// Return the cursor for the declaration of the given type.
  CXCursor clang_getTypeDeclaration(
    CXType T,
  ) {
    return (_clang_getTypeDeclaration ??=
        _lookup<ffi.NativeFunction<_c_clang_getTypeDeclaration>>(
                'clang_getTypeDeclaration')
            .asFunction<_dart_clang_getTypeDeclaration>())(
      T,
    );
  }

  _dart_clang_getTypeDeclaration? _clang_getTypeDeclaration;

  /// Returns the Objective-C type encoding for the specified declaration.
  CXString clang_getDeclObjCTypeEncoding(
    CXCursor C,
  ) {
    return (_clang_getDeclObjCTypeEncoding ??=
        _lookup<ffi.NativeFunction<_c_clang_getDeclObjCTypeEncoding>>(
                'clang_getDeclObjCTypeEncoding')
            .asFunction<_dart_clang_getDeclObjCTypeEncoding>())(
      C,
    );
  }

  _dart_clang_getDeclObjCTypeEncoding? _clang_getDeclObjCTypeEncoding;

  /// Returns the Objective-C type encoding for the specified CXType.
  CXString clang_Type_getObjCEncoding(
    CXType type,
  ) {
    return (_clang_Type_getObjCEncoding ??=
        _lookup<ffi.NativeFunction<_c_clang_Type_getObjCEncoding>>(
                'clang_Type_getObjCEncoding')
            .asFunction<_dart_clang_Type_getObjCEncoding>())(
      type,
    );
  }

  _dart_clang_Type_getObjCEncoding? _clang_Type_getObjCEncoding;

  /// Retrieve the spelling of a given CXTypeKind.
  CXString clang_getTypeKindSpelling(
    int K,
  ) {
    return (_clang_getTypeKindSpelling ??=
        _lookup<ffi.NativeFunction<_c_clang_getTypeKindSpelling>>(
                'clang_getTypeKindSpelling')
            .asFunction<_dart_clang_getTypeKindSpelling>())(
      K,
    );
  }

  _dart_clang_getTypeKindSpelling? _clang_getTypeKindSpelling;

  /// Retrieve the calling convention associated with a function type.
  ///
  /// If a non-function type is passed in, CXCallingConv_Invalid is returned.
  int clang_getFunctionTypeCallingConv(
    CXType T,
  ) {
    return (_clang_getFunctionTypeCallingConv ??=
        _lookup<ffi.NativeFunction<_c_clang_getFunctionTypeCallingConv>>(
                'clang_getFunctionTypeCallingConv')
            .asFunction<_dart_clang_getFunctionTypeCallingConv>())(
      T,
    );
  }

  _dart_clang_getFunctionTypeCallingConv? _clang_getFunctionTypeCallingConv;

  /// Retrieve the return type associated with a function type.
  ///
  /// If a non-function type is passed in, an invalid type is returned.
  CXType clang_getResultType(
    CXType T,
  ) {
    return (_clang_getResultType ??=
        _lookup<ffi.NativeFunction<_c_clang_getResultType>>(
                'clang_getResultType')
            .asFunction<_dart_clang_getResultType>())(
      T,
    );
  }

  _dart_clang_getResultType? _clang_getResultType;

  /// Retrieve the exception specification type associated with a function type.
  /// This is a value of type CXCursor_ExceptionSpecificationKind.
  ///
  /// If a non-function type is passed in, an error code of -1 is returned.
  int clang_getExceptionSpecificationType(
    CXType T,
  ) {
    return (_clang_getExceptionSpecificationType ??=
        _lookup<ffi.NativeFunction<_c_clang_getExceptionSpecificationType>>(
                'clang_getExceptionSpecificationType')
            .asFunction<_dart_clang_getExceptionSpecificationType>())(
      T,
    );
  }

  _dart_clang_getExceptionSpecificationType?
      _clang_getExceptionSpecificationType;

  /// Retrieve the number of non-variadic parameters associated with a
  /// function type.
  ///
  /// If a non-function type is passed in, -1 is returned.
  int clang_getNumArgTypes(
    CXType T,
  ) {
    return (_clang_getNumArgTypes ??=
        _lookup<ffi.NativeFunction<_c_clang_getNumArgTypes>>(
                'clang_getNumArgTypes')
            .asFunction<_dart_clang_getNumArgTypes>())(
      T,
    );
  }

  _dart_clang_getNumArgTypes? _clang_getNumArgTypes;

  /// Retrieve the type of a parameter of a function type.
  ///
  /// If a non-function type is passed in or the function does not have enough
  /// parameters, an invalid type is returned.
  CXType clang_getArgType(
    CXType T,
    int i,
  ) {
    return (_clang_getArgType ??=
        _lookup<ffi.NativeFunction<_c_clang_getArgType>>('clang_getArgType')
            .asFunction<_dart_clang_getArgType>())(
      T,
      i,
    );
  }

  _dart_clang_getArgType? _clang_getArgType;

  /// Retrieves the base type of the ObjCObjectType.
  ///
  /// If the type is not an ObjC object, an invalid type is returned.
  CXType clang_Type_getObjCObjectBaseType(
    CXType T,
  ) {
    return (_clang_Type_getObjCObjectBaseType ??=
        _lookup<ffi.NativeFunction<_c_clang_Type_getObjCObjectBaseType>>(
                'clang_Type_getObjCObjectBaseType')
            .asFunction<_dart_clang_Type_getObjCObjectBaseType>())(
      T,
    );
  }

  _dart_clang_Type_getObjCObjectBaseType? _clang_Type_getObjCObjectBaseType;

  /// Retrieve the number of protocol references associated with an ObjC object/id.
  ///
  /// If the type is not an ObjC object, 0 is returned.
  int clang_Type_getNumObjCProtocolRefs(
    CXType T,
  ) {
    return (_clang_Type_getNumObjCProtocolRefs ??=
        _lookup<ffi.NativeFunction<_c_clang_Type_getNumObjCProtocolRefs>>(
                'clang_Type_getNumObjCProtocolRefs')
            .asFunction<_dart_clang_Type_getNumObjCProtocolRefs>())(
      T,
    );
  }

  _dart_clang_Type_getNumObjCProtocolRefs? _clang_Type_getNumObjCProtocolRefs;

  /// Retrieve the decl for a protocol reference for an ObjC object/id.
  ///
  /// If the type is not an ObjC object or there are not enough protocol
  /// references, an invalid cursor is returned.
  CXCursor clang_Type_getObjCProtocolDecl(
    CXType T,
    int i,
  ) {
    return (_clang_Type_getObjCProtocolDecl ??=
        _lookup<ffi.NativeFunction<_c_clang_Type_getObjCProtocolDecl>>(
                'clang_Type_getObjCProtocolDecl')
            .asFunction<_dart_clang_Type_getObjCProtocolDecl>())(
      T,
      i,
    );
  }

  _dart_clang_Type_getObjCProtocolDecl? _clang_Type_getObjCProtocolDecl;

  /// Retreive the number of type arguments associated with an ObjC object.
  ///
  /// If the type is not an ObjC object, 0 is returned.
  int clang_Type_getNumObjCTypeArgs(
    CXType T,
  ) {
    return (_clang_Type_getNumObjCTypeArgs ??=
        _lookup<ffi.NativeFunction<_c_clang_Type_getNumObjCTypeArgs>>(
                'clang_Type_getNumObjCTypeArgs')
            .asFunction<_dart_clang_Type_getNumObjCTypeArgs>())(
      T,
    );
  }

  _dart_clang_Type_getNumObjCTypeArgs? _clang_Type_getNumObjCTypeArgs;

  /// Retrieve a type argument associated with an ObjC object.
  ///
  /// If the type is not an ObjC or the index is not valid,
  /// an invalid type is returned.
  CXType clang_Type_getObjCTypeArg(
    CXType T,
    int i,
  ) {
    return (_clang_Type_getObjCTypeArg ??=
        _lookup<ffi.NativeFunction<_c_clang_Type_getObjCTypeArg>>(
                'clang_Type_getObjCTypeArg')
            .asFunction<_dart_clang_Type_getObjCTypeArg>())(
      T,
      i,
    );
  }

  _dart_clang_Type_getObjCTypeArg? _clang_Type_getObjCTypeArg;

  /// Return 1 if the CXType is a variadic function type, and 0 otherwise.
  int clang_isFunctionTypeVariadic(
    CXType T,
  ) {
    return (_clang_isFunctionTypeVariadic ??=
        _lookup<ffi.NativeFunction<_c_clang_isFunctionTypeVariadic>>(
                'clang_isFunctionTypeVariadic')
            .asFunction<_dart_clang_isFunctionTypeVariadic>())(
      T,
    );
  }

  _dart_clang_isFunctionTypeVariadic? _clang_isFunctionTypeVariadic;

  /// Retrieve the return type associated with a given cursor.
  ///
  /// This only returns a valid type if the cursor refers to a function or method.
  CXType clang_getCursorResultType(
    CXCursor C,
  ) {
    return (_clang_getCursorResultType ??=
        _lookup<ffi.NativeFunction<_c_clang_getCursorResultType>>(
                'clang_getCursorResultType')
            .asFunction<_dart_clang_getCursorResultType>())(
      C,
    );
  }

  _dart_clang_getCursorResultType? _clang_getCursorResultType;

  /// Retrieve the exception specification type associated with a given cursor.
  /// This is a value of type CXCursor_ExceptionSpecificationKind.
  ///
  /// This only returns a valid result if the cursor refers to a function or method.
  int clang_getCursorExceptionSpecificationType(
    CXCursor C,
  ) {
    return (_clang_getCursorExceptionSpecificationType ??= _lookup<
                ffi.NativeFunction<
                    _c_clang_getCursorExceptionSpecificationType>>(
            'clang_getCursorExceptionSpecificationType')
        .asFunction<_dart_clang_getCursorExceptionSpecificationType>())(
      C,
    );
  }

  _dart_clang_getCursorExceptionSpecificationType?
      _clang_getCursorExceptionSpecificationType;

  /// Return 1 if the CXType is a POD (plain old data) type, and 0
  /// otherwise.
  int clang_isPODType(
    CXType T,
  ) {
    return (_clang_isPODType ??=
        _lookup<ffi.NativeFunction<_c_clang_isPODType>>('clang_isPODType')
            .asFunction<_dart_clang_isPODType>())(
      T,
    );
  }

  _dart_clang_isPODType? _clang_isPODType;

  /// Return the element type of an array, complex, or vector type.
  ///
  /// If a type is passed in that is not an array, complex, or vector type,
  /// an invalid type is returned.
  CXType clang_getElementType(
    CXType T,
  ) {
    return (_clang_getElementType ??=
        _lookup<ffi.NativeFunction<_c_clang_getElementType>>(
                'clang_getElementType')
            .asFunction<_dart_clang_getElementType>())(
      T,
    );
  }

  _dart_clang_getElementType? _clang_getElementType;

  /// Return the number of elements of an array or vector type.
  ///
  /// If a type is passed in that is not an array or vector type,
  /// -1 is returned.
  int clang_getNumElements(
    CXType T,
  ) {
    return (_clang_getNumElements ??=
        _lookup<ffi.NativeFunction<_c_clang_getNumElements>>(
                'clang_getNumElements')
            .asFunction<_dart_clang_getNumElements>())(
      T,
    );
  }

  _dart_clang_getNumElements? _clang_getNumElements;

  /// Return the element type of an array type.
  ///
  /// If a non-array type is passed in, an invalid type is returned.
  CXType clang_getArrayElementType(
    CXType T,
  ) {
    return (_clang_getArrayElementType ??=
        _lookup<ffi.NativeFunction<_c_clang_getArrayElementType>>(
                'clang_getArrayElementType')
            .asFunction<_dart_clang_getArrayElementType>())(
      T,
    );
  }

  _dart_clang_getArrayElementType? _clang_getArrayElementType;

  /// Return the array size of a constant array.
  ///
  /// If a non-array type is passed in, -1 is returned.
  int clang_getArraySize(
    CXType T,
  ) {
    return (_clang_getArraySize ??=
        _lookup<ffi.NativeFunction<_c_clang_getArraySize>>('clang_getArraySize')
            .asFunction<_dart_clang_getArraySize>())(
      T,
    );
  }

  _dart_clang_getArraySize? _clang_getArraySize;

  /// Retrieve the type named by the qualified-id.
  ///
  /// If a non-elaborated type is passed in, an invalid type is returned.
  CXType clang_Type_getNamedType(
    CXType T,
  ) {
    return (_clang_Type_getNamedType ??=
        _lookup<ffi.NativeFunction<_c_clang_Type_getNamedType>>(
                'clang_Type_getNamedType')
            .asFunction<_dart_clang_Type_getNamedType>())(
      T,
    );
  }

  _dart_clang_Type_getNamedType? _clang_Type_getNamedType;

  /// Determine if a typedef is 'transparent' tag.
  ///
  /// A typedef is considered 'transparent' if it shares a name and spelling
  /// location with its underlying tag type, as is the case with the NS_ENUM macro.
  ///
  /// \returns non-zero if transparent and zero otherwise.
  int clang_Type_isTransparentTagTypedef(
    CXType T,
  ) {
    return (_clang_Type_isTransparentTagTypedef ??=
        _lookup<ffi.NativeFunction<_c_clang_Type_isTransparentTagTypedef>>(
                'clang_Type_isTransparentTagTypedef')
            .asFunction<_dart_clang_Type_isTransparentTagTypedef>())(
      T,
    );
  }

  _dart_clang_Type_isTransparentTagTypedef? _clang_Type_isTransparentTagTypedef;

  /// Retrieve the nullability kind of a pointer type.
  int clang_Type_getNullability(
    CXType T,
  ) {
    return (_clang_Type_getNullability ??=
        _lookup<ffi.NativeFunction<_c_clang_Type_getNullability>>(
                'clang_Type_getNullability')
            .asFunction<_dart_clang_Type_getNullability>())(
      T,
    );
  }

  _dart_clang_Type_getNullability? _clang_Type_getNullability;

  /// Return the alignment of a type in bytes as per C++[expr.alignof]
  /// standard.
  ///
  /// If the type declaration is invalid, CXTypeLayoutError_Invalid is returned.
  /// If the type declaration is an incomplete type, CXTypeLayoutError_Incomplete
  /// is returned.
  /// If the type declaration is a dependent type, CXTypeLayoutError_Dependent is
  /// returned.
  /// If the type declaration is not a constant size type,
  /// CXTypeLayoutError_NotConstantSize is returned.
  int clang_Type_getAlignOf(
    CXType T,
  ) {
    return (_clang_Type_getAlignOf ??=
        _lookup<ffi.NativeFunction<_c_clang_Type_getAlignOf>>(
                'clang_Type_getAlignOf')
            .asFunction<_dart_clang_Type_getAlignOf>())(
      T,
    );
  }

  _dart_clang_Type_getAlignOf? _clang_Type_getAlignOf;

  /// Return the class type of an member pointer type.
  ///
  /// If a non-member-pointer type is passed in, an invalid type is returned.
  CXType clang_Type_getClassType(
    CXType T,
  ) {
    return (_clang_Type_getClassType ??=
        _lookup<ffi.NativeFunction<_c_clang_Type_getClassType>>(
                'clang_Type_getClassType')
            .asFunction<_dart_clang_Type_getClassType>())(
      T,
    );
  }

  _dart_clang_Type_getClassType? _clang_Type_getClassType;

  /// Return the size of a type in bytes as per C++[expr.sizeof] standard.
  ///
  /// If the type declaration is invalid, CXTypeLayoutError_Invalid is returned.
  /// If the type declaration is an incomplete type, CXTypeLayoutError_Incomplete
  /// is returned.
  /// If the type declaration is a dependent type, CXTypeLayoutError_Dependent is
  /// returned.
  int clang_Type_getSizeOf(
    CXType T,
  ) {
    return (_clang_Type_getSizeOf ??=
        _lookup<ffi.NativeFunction<_c_clang_Type_getSizeOf>>(
                'clang_Type_getSizeOf')
            .asFunction<_dart_clang_Type_getSizeOf>())(
      T,
    );
  }

  _dart_clang_Type_getSizeOf? _clang_Type_getSizeOf;

  /// Return the offset of a field named S in a record of type T in bits
  /// as it would be returned by __offsetof__ as per C++11[18.2p4]
  ///
  /// If the cursor is not a record field declaration, CXTypeLayoutError_Invalid
  /// is returned.
  /// If the field's type declaration is an incomplete type,
  /// CXTypeLayoutError_Incomplete is returned.
  /// If the field's type declaration is a dependent type,
  /// CXTypeLayoutError_Dependent is returned.
  /// If the field's name S is not found,
  /// CXTypeLayoutError_InvalidFieldName is returned.
  int clang_Type_getOffsetOf(
    CXType T,
    ffi.Pointer<ffi.Int8> S,
  ) {
    return (_clang_Type_getOffsetOf ??=
        _lookup<ffi.NativeFunction<_c_clang_Type_getOffsetOf>>(
                'clang_Type_getOffsetOf')
            .asFunction<_dart_clang_Type_getOffsetOf>())(
      T,
      S,
    );
  }

  _dart_clang_Type_getOffsetOf? _clang_Type_getOffsetOf;

  /// Return the type that was modified by this attributed type.
  ///
  /// If the type is not an attributed type, an invalid type is returned.
  CXType clang_Type_getModifiedType(
    CXType T,
  ) {
    return (_clang_Type_getModifiedType ??=
        _lookup<ffi.NativeFunction<_c_clang_Type_getModifiedType>>(
                'clang_Type_getModifiedType')
            .asFunction<_dart_clang_Type_getModifiedType>())(
      T,
    );
  }

  _dart_clang_Type_getModifiedType? _clang_Type_getModifiedType;

  /// Return the offset of the field represented by the Cursor.
  ///
  /// If the cursor is not a field declaration, -1 is returned.
  /// If the cursor semantic parent is not a record field declaration,
  /// CXTypeLayoutError_Invalid is returned.
  /// If the field's type declaration is an incomplete type,
  /// CXTypeLayoutError_Incomplete is returned.
  /// If the field's type declaration is a dependent type,
  /// CXTypeLayoutError_Dependent is returned.
  /// If the field's name S is not found,
  /// CXTypeLayoutError_InvalidFieldName is returned.
  int clang_Cursor_getOffsetOfField(
    CXCursor C,
  ) {
    return (_clang_Cursor_getOffsetOfField ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_getOffsetOfField>>(
                'clang_Cursor_getOffsetOfField')
            .asFunction<_dart_clang_Cursor_getOffsetOfField>())(
      C,
    );
  }

  _dart_clang_Cursor_getOffsetOfField? _clang_Cursor_getOffsetOfField;

  /// Determine whether the given cursor represents an anonymous
  /// tag or namespace
  int clang_Cursor_isAnonymous(
    CXCursor C,
  ) {
    return (_clang_Cursor_isAnonymous ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_isAnonymous>>(
                'clang_Cursor_isAnonymous')
            .asFunction<_dart_clang_Cursor_isAnonymous>())(
      C,
    );
  }

  _dart_clang_Cursor_isAnonymous? _clang_Cursor_isAnonymous;

  /// Determine whether the given cursor represents an anonymous record
  /// declaration.
  int clang_Cursor_isAnonymousRecordDecl(
    CXCursor C,
  ) {
    return (_clang_Cursor_isAnonymousRecordDecl ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_isAnonymousRecordDecl>>(
                'clang_Cursor_isAnonymousRecordDecl')
            .asFunction<_dart_clang_Cursor_isAnonymousRecordDecl>())(
      C,
    );
  }

  _dart_clang_Cursor_isAnonymousRecordDecl? _clang_Cursor_isAnonymousRecordDecl;

  /// Determine whether the given cursor represents an inline namespace
  /// declaration.
  int clang_Cursor_isInlineNamespace(
    CXCursor C,
  ) {
    return (_clang_Cursor_isInlineNamespace ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_isInlineNamespace>>(
                'clang_Cursor_isInlineNamespace')
            .asFunction<_dart_clang_Cursor_isInlineNamespace>())(
      C,
    );
  }

  _dart_clang_Cursor_isInlineNamespace? _clang_Cursor_isInlineNamespace;

  /// Returns the number of template arguments for given template
  /// specialization, or -1 if type \c T is not a template specialization.
  int clang_Type_getNumTemplateArguments(
    CXType T,
  ) {
    return (_clang_Type_getNumTemplateArguments ??=
        _lookup<ffi.NativeFunction<_c_clang_Type_getNumTemplateArguments>>(
                'clang_Type_getNumTemplateArguments')
            .asFunction<_dart_clang_Type_getNumTemplateArguments>())(
      T,
    );
  }

  _dart_clang_Type_getNumTemplateArguments? _clang_Type_getNumTemplateArguments;

  /// Returns the type template argument of a template class specialization
  /// at given index.
  ///
  /// This function only returns template type arguments and does not handle
  /// template template arguments or variadic packs.
  CXType clang_Type_getTemplateArgumentAsType(
    CXType T,
    int i,
  ) {
    return (_clang_Type_getTemplateArgumentAsType ??=
        _lookup<ffi.NativeFunction<_c_clang_Type_getTemplateArgumentAsType>>(
                'clang_Type_getTemplateArgumentAsType')
            .asFunction<_dart_clang_Type_getTemplateArgumentAsType>())(
      T,
      i,
    );
  }

  _dart_clang_Type_getTemplateArgumentAsType?
      _clang_Type_getTemplateArgumentAsType;

  /// Retrieve the ref-qualifier kind of a function or method.
  ///
  /// The ref-qualifier is returned for C++ functions or methods. For other types
  /// or non-C++ declarations, CXRefQualifier_None is returned.
  int clang_Type_getCXXRefQualifier(
    CXType T,
  ) {
    return (_clang_Type_getCXXRefQualifier ??=
        _lookup<ffi.NativeFunction<_c_clang_Type_getCXXRefQualifier>>(
                'clang_Type_getCXXRefQualifier')
            .asFunction<_dart_clang_Type_getCXXRefQualifier>())(
      T,
    );
  }

  _dart_clang_Type_getCXXRefQualifier? _clang_Type_getCXXRefQualifier;

  /// Returns non-zero if the cursor specifies a Record member that is a
  /// bitfield.
  int clang_Cursor_isBitField(
    CXCursor C,
  ) {
    return (_clang_Cursor_isBitField ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_isBitField>>(
                'clang_Cursor_isBitField')
            .asFunction<_dart_clang_Cursor_isBitField>())(
      C,
    );
  }

  _dart_clang_Cursor_isBitField? _clang_Cursor_isBitField;

  /// Returns 1 if the base class specified by the cursor with kind
  /// CX_CXXBaseSpecifier is virtual.
  int clang_isVirtualBase(
    CXCursor arg0,
  ) {
    return (_clang_isVirtualBase ??=
        _lookup<ffi.NativeFunction<_c_clang_isVirtualBase>>(
                'clang_isVirtualBase')
            .asFunction<_dart_clang_isVirtualBase>())(
      arg0,
    );
  }

  _dart_clang_isVirtualBase? _clang_isVirtualBase;

  /// Returns the access control level for the referenced object.
  ///
  /// If the cursor refers to a C++ declaration, its access control level within its
  /// parent scope is returned. Otherwise, if the cursor refers to a base specifier or
  /// access specifier, the specifier itself is returned.
  int clang_getCXXAccessSpecifier(
    CXCursor arg0,
  ) {
    return (_clang_getCXXAccessSpecifier ??=
        _lookup<ffi.NativeFunction<_c_clang_getCXXAccessSpecifier>>(
                'clang_getCXXAccessSpecifier')
            .asFunction<_dart_clang_getCXXAccessSpecifier>())(
      arg0,
    );
  }

  _dart_clang_getCXXAccessSpecifier? _clang_getCXXAccessSpecifier;

  /// Returns the storage class for a function or variable declaration.
  ///
  /// If the passed in Cursor is not a function or variable declaration,
  /// CX_SC_Invalid is returned else the storage class.
  int clang_Cursor_getStorageClass(
    CXCursor arg0,
  ) {
    return (_clang_Cursor_getStorageClass ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_getStorageClass>>(
                'clang_Cursor_getStorageClass')
            .asFunction<_dart_clang_Cursor_getStorageClass>())(
      arg0,
    );
  }

  _dart_clang_Cursor_getStorageClass? _clang_Cursor_getStorageClass;

  /// Determine the number of overloaded declarations referenced by a
  /// \c CXCursor_OverloadedDeclRef cursor.
  ///
  /// \param cursor The cursor whose overloaded declarations are being queried.
  ///
  /// \returns The number of overloaded declarations referenced by \c cursor. If it
  /// is not a \c CXCursor_OverloadedDeclRef cursor, returns 0.
  int clang_getNumOverloadedDecls(
    CXCursor cursor,
  ) {
    return (_clang_getNumOverloadedDecls ??=
        _lookup<ffi.NativeFunction<_c_clang_getNumOverloadedDecls>>(
                'clang_getNumOverloadedDecls')
            .asFunction<_dart_clang_getNumOverloadedDecls>())(
      cursor,
    );
  }

  _dart_clang_getNumOverloadedDecls? _clang_getNumOverloadedDecls;

  /// Retrieve a cursor for one of the overloaded declarations referenced
  /// by a \c CXCursor_OverloadedDeclRef cursor.
  ///
  /// \param cursor The cursor whose overloaded declarations are being queried.
  ///
  /// \param index The zero-based index into the set of overloaded declarations in
  /// the cursor.
  ///
  /// \returns A cursor representing the declaration referenced by the given
  /// \c cursor at the specified \c index. If the cursor does not have an
  /// associated set of overloaded declarations, or if the index is out of bounds,
  /// returns \c clang_getNullCursor();
  CXCursor clang_getOverloadedDecl(
    CXCursor cursor,
    int index,
  ) {
    return (_clang_getOverloadedDecl ??=
        _lookup<ffi.NativeFunction<_c_clang_getOverloadedDecl>>(
                'clang_getOverloadedDecl')
            .asFunction<_dart_clang_getOverloadedDecl>())(
      cursor,
      index,
    );
  }

  _dart_clang_getOverloadedDecl? _clang_getOverloadedDecl;

  /// For cursors representing an iboutletcollection attribute,
  /// this function returns the collection element type.
  CXType clang_getIBOutletCollectionType(
    CXCursor arg0,
  ) {
    return (_clang_getIBOutletCollectionType ??=
        _lookup<ffi.NativeFunction<_c_clang_getIBOutletCollectionType>>(
                'clang_getIBOutletCollectionType')
            .asFunction<_dart_clang_getIBOutletCollectionType>())(
      arg0,
    );
  }

  _dart_clang_getIBOutletCollectionType? _clang_getIBOutletCollectionType;

  /// Visit the children of a particular cursor.
  ///
  /// This function visits all the direct children of the given cursor,
  /// invoking the given \p visitor function with the cursors of each
  /// visited child. The traversal may be recursive, if the visitor returns
  /// \c CXChildVisit_Recurse. The traversal may also be ended prematurely, if
  /// the visitor returns \c CXChildVisit_Break.
  ///
  /// \param parent the cursor whose child may be visited. All kinds of
  /// cursors can be visited, including invalid cursors (which, by
  /// definition, have no children).
  ///
  /// \param visitor the visitor function that will be invoked for each
  /// child of \p parent.
  ///
  /// \param client_data pointer data supplied by the client, which will
  /// be passed to the visitor each time it is invoked.
  ///
  /// \returns a non-zero value if the traversal was terminated
  /// prematurely by the visitor returning \c CXChildVisit_Break.
  int clang_visitChildren(
    CXCursor parent,
    ffi.Pointer<ffi.NativeFunction<CXCursorVisitor>> visitor,
    ffi.Pointer<ffi.Void> client_data,
  ) {
    return (_clang_visitChildren ??=
        _lookup<ffi.NativeFunction<_c_clang_visitChildren>>(
                'clang_visitChildren')
            .asFunction<_dart_clang_visitChildren>())(
      parent,
      visitor,
      client_data,
    );
  }

  _dart_clang_visitChildren? _clang_visitChildren;

  /// Retrieve a Unified Symbol Resolution (USR) for the entity referenced
  /// by the given cursor.
  ///
  /// A Unified Symbol Resolution (USR) is a string that identifies a particular
  /// entity (function, class, variable, etc.) within a program. USRs can be
  /// compared across translation units to determine, e.g., when references in
  /// one translation refer to an entity defined in another translation unit.
  CXString clang_getCursorUSR(
    CXCursor arg0,
  ) {
    return (_clang_getCursorUSR ??=
        _lookup<ffi.NativeFunction<_c_clang_getCursorUSR>>('clang_getCursorUSR')
            .asFunction<_dart_clang_getCursorUSR>())(
      arg0,
    );
  }

  _dart_clang_getCursorUSR? _clang_getCursorUSR;

  /// Construct a USR for a specified Objective-C class.
  CXString clang_constructUSR_ObjCClass(
    ffi.Pointer<ffi.Int8> class_name,
  ) {
    return (_clang_constructUSR_ObjCClass ??=
        _lookup<ffi.NativeFunction<_c_clang_constructUSR_ObjCClass>>(
                'clang_constructUSR_ObjCClass')
            .asFunction<_dart_clang_constructUSR_ObjCClass>())(
      class_name,
    );
  }

  _dart_clang_constructUSR_ObjCClass? _clang_constructUSR_ObjCClass;

  /// Construct a USR for a specified Objective-C category.
  CXString clang_constructUSR_ObjCCategory(
    ffi.Pointer<ffi.Int8> class_name,
    ffi.Pointer<ffi.Int8> category_name,
  ) {
    return (_clang_constructUSR_ObjCCategory ??=
        _lookup<ffi.NativeFunction<_c_clang_constructUSR_ObjCCategory>>(
                'clang_constructUSR_ObjCCategory')
            .asFunction<_dart_clang_constructUSR_ObjCCategory>())(
      class_name,
      category_name,
    );
  }

  _dart_clang_constructUSR_ObjCCategory? _clang_constructUSR_ObjCCategory;

  /// Construct a USR for a specified Objective-C protocol.
  CXString clang_constructUSR_ObjCProtocol(
    ffi.Pointer<ffi.Int8> protocol_name,
  ) {
    return (_clang_constructUSR_ObjCProtocol ??=
        _lookup<ffi.NativeFunction<_c_clang_constructUSR_ObjCProtocol>>(
                'clang_constructUSR_ObjCProtocol')
            .asFunction<_dart_clang_constructUSR_ObjCProtocol>())(
      protocol_name,
    );
  }

  _dart_clang_constructUSR_ObjCProtocol? _clang_constructUSR_ObjCProtocol;

  /// Construct a USR for a specified Objective-C instance variable and
  /// the USR for its containing class.
  CXString clang_constructUSR_ObjCIvar(
    ffi.Pointer<ffi.Int8> name,
    CXString classUSR,
  ) {
    return (_clang_constructUSR_ObjCIvar ??=
        _lookup<ffi.NativeFunction<_c_clang_constructUSR_ObjCIvar>>(
                'clang_constructUSR_ObjCIvar')
            .asFunction<_dart_clang_constructUSR_ObjCIvar>())(
      name,
      classUSR,
    );
  }

  _dart_clang_constructUSR_ObjCIvar? _clang_constructUSR_ObjCIvar;

  /// Construct a USR for a specified Objective-C method and
  /// the USR for its containing class.
  CXString clang_constructUSR_ObjCMethod(
    ffi.Pointer<ffi.Int8> name,
    int isInstanceMethod,
    CXString classUSR,
  ) {
    return (_clang_constructUSR_ObjCMethod ??=
        _lookup<ffi.NativeFunction<_c_clang_constructUSR_ObjCMethod>>(
                'clang_constructUSR_ObjCMethod')
            .asFunction<_dart_clang_constructUSR_ObjCMethod>())(
      name,
      isInstanceMethod,
      classUSR,
    );
  }

  _dart_clang_constructUSR_ObjCMethod? _clang_constructUSR_ObjCMethod;

  /// Construct a USR for a specified Objective-C property and the USR
  /// for its containing class.
  CXString clang_constructUSR_ObjCProperty(
    ffi.Pointer<ffi.Int8> property,
    CXString classUSR,
  ) {
    return (_clang_constructUSR_ObjCProperty ??=
        _lookup<ffi.NativeFunction<_c_clang_constructUSR_ObjCProperty>>(
                'clang_constructUSR_ObjCProperty')
            .asFunction<_dart_clang_constructUSR_ObjCProperty>())(
      property,
      classUSR,
    );
  }

  _dart_clang_constructUSR_ObjCProperty? _clang_constructUSR_ObjCProperty;

  /// Retrieve a name for the entity referenced by this cursor.
  CXString clang_getCursorSpelling(
    CXCursor arg0,
  ) {
    return (_clang_getCursorSpelling ??=
        _lookup<ffi.NativeFunction<_c_clang_getCursorSpelling>>(
                'clang_getCursorSpelling')
            .asFunction<_dart_clang_getCursorSpelling>())(
      arg0,
    );
  }

  _dart_clang_getCursorSpelling? _clang_getCursorSpelling;

  /// Retrieve a range for a piece that forms the cursors spelling name.
  /// Most of the times there is only one range for the complete spelling but for
  /// Objective-C methods and Objective-C message expressions, there are multiple
  /// pieces for each selector identifier.
  ///
  /// \param pieceIndex the index of the spelling name piece. If this is greater
  /// than the actual number of pieces, it will return a NULL (invalid) range.
  ///
  /// \param options Reserved.
  CXSourceRange clang_Cursor_getSpellingNameRange(
    CXCursor arg0,
    int pieceIndex,
    int options,
  ) {
    return (_clang_Cursor_getSpellingNameRange ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_getSpellingNameRange>>(
                'clang_Cursor_getSpellingNameRange')
            .asFunction<_dart_clang_Cursor_getSpellingNameRange>())(
      arg0,
      pieceIndex,
      options,
    );
  }

  _dart_clang_Cursor_getSpellingNameRange? _clang_Cursor_getSpellingNameRange;

  /// Get a property value for the given printing policy.
  int clang_PrintingPolicy_getProperty(
    ffi.Pointer<ffi.Void> Policy,
    int Property,
  ) {
    return (_clang_PrintingPolicy_getProperty ??=
        _lookup<ffi.NativeFunction<_c_clang_PrintingPolicy_getProperty>>(
                'clang_PrintingPolicy_getProperty')
            .asFunction<_dart_clang_PrintingPolicy_getProperty>())(
      Policy,
      Property,
    );
  }

  _dart_clang_PrintingPolicy_getProperty? _clang_PrintingPolicy_getProperty;

  /// Set a property value for the given printing policy.
  void clang_PrintingPolicy_setProperty(
    ffi.Pointer<ffi.Void> Policy,
    int Property,
    int Value,
  ) {
    return (_clang_PrintingPolicy_setProperty ??=
        _lookup<ffi.NativeFunction<_c_clang_PrintingPolicy_setProperty>>(
                'clang_PrintingPolicy_setProperty')
            .asFunction<_dart_clang_PrintingPolicy_setProperty>())(
      Policy,
      Property,
      Value,
    );
  }

  _dart_clang_PrintingPolicy_setProperty? _clang_PrintingPolicy_setProperty;

  /// Retrieve the default policy for the cursor.
  ///
  /// The policy should be released after use with \c
  /// clang_PrintingPolicy_dispose.
  ffi.Pointer<ffi.Void> clang_getCursorPrintingPolicy(
    CXCursor arg0,
  ) {
    return (_clang_getCursorPrintingPolicy ??=
        _lookup<ffi.NativeFunction<_c_clang_getCursorPrintingPolicy>>(
                'clang_getCursorPrintingPolicy')
            .asFunction<_dart_clang_getCursorPrintingPolicy>())(
      arg0,
    );
  }

  _dart_clang_getCursorPrintingPolicy? _clang_getCursorPrintingPolicy;

  /// Release a printing policy.
  void clang_PrintingPolicy_dispose(
    ffi.Pointer<ffi.Void> Policy,
  ) {
    return (_clang_PrintingPolicy_dispose ??=
        _lookup<ffi.NativeFunction<_c_clang_PrintingPolicy_dispose>>(
                'clang_PrintingPolicy_dispose')
            .asFunction<_dart_clang_PrintingPolicy_dispose>())(
      Policy,
    );
  }

  _dart_clang_PrintingPolicy_dispose? _clang_PrintingPolicy_dispose;

  /// Pretty print declarations.
  ///
  /// \param Cursor The cursor representing a declaration.
  ///
  /// \param Policy The policy to control the entities being printed. If
  /// NULL, a default policy is used.
  ///
  /// \returns The pretty printed declaration or the empty string for
  /// other cursors.
  CXString clang_getCursorPrettyPrinted(
    CXCursor Cursor,
    ffi.Pointer<ffi.Void> Policy,
  ) {
    return (_clang_getCursorPrettyPrinted ??=
        _lookup<ffi.NativeFunction<_c_clang_getCursorPrettyPrinted>>(
                'clang_getCursorPrettyPrinted')
            .asFunction<_dart_clang_getCursorPrettyPrinted>())(
      Cursor,
      Policy,
    );
  }

  _dart_clang_getCursorPrettyPrinted? _clang_getCursorPrettyPrinted;

  /// Retrieve the display name for the entity referenced by this cursor.
  ///
  /// The display name contains extra information that helps identify the cursor,
  /// such as the parameters of a function or template or the arguments of a
  /// class template specialization.
  CXString clang_getCursorDisplayName(
    CXCursor arg0,
  ) {
    return (_clang_getCursorDisplayName ??=
        _lookup<ffi.NativeFunction<_c_clang_getCursorDisplayName>>(
                'clang_getCursorDisplayName')
            .asFunction<_dart_clang_getCursorDisplayName>())(
      arg0,
    );
  }

  _dart_clang_getCursorDisplayName? _clang_getCursorDisplayName;

  /// For a cursor that is a reference, retrieve a cursor representing the
  /// entity that it references.
  ///
  /// Reference cursors refer to other entities in the AST. For example, an
  /// Objective-C superclass reference cursor refers to an Objective-C class.
  /// This function produces the cursor for the Objective-C class from the
  /// cursor for the superclass reference. If the input cursor is a declaration or
  /// definition, it returns that declaration or definition unchanged.
  /// Otherwise, returns the NULL cursor.
  CXCursor clang_getCursorReferenced(
    CXCursor arg0,
  ) {
    return (_clang_getCursorReferenced ??=
        _lookup<ffi.NativeFunction<_c_clang_getCursorReferenced>>(
                'clang_getCursorReferenced')
            .asFunction<_dart_clang_getCursorReferenced>())(
      arg0,
    );
  }

  _dart_clang_getCursorReferenced? _clang_getCursorReferenced;

  /// For a cursor that is either a reference to or a declaration
  /// of some entity, retrieve a cursor that describes the definition of
  /// that entity.
  ///
  /// Some entities can be declared multiple times within a translation
  /// unit, but only one of those declarations can also be a
  /// definition. For example, given:
  ///
  /// \code
  /// int f(int, int);
  /// int g(int x, int y) { return f(x, y); }
  /// int f(int a, int b) { return a + b; }
  /// int f(int, int);
  /// \endcode
  ///
  /// there are three declarations of the function "f", but only the
  /// second one is a definition. The clang_getCursorDefinition()
  /// function will take any cursor pointing to a declaration of "f"
  /// (the first or fourth lines of the example) or a cursor referenced
  /// that uses "f" (the call to "f' inside "g") and will return a
  /// declaration cursor pointing to the definition (the second "f"
  /// declaration).
  ///
  /// If given a cursor for which there is no corresponding definition,
  /// e.g., because there is no definition of that entity within this
  /// translation unit, returns a NULL cursor.
  CXCursor clang_getCursorDefinition(
    CXCursor arg0,
  ) {
    return (_clang_getCursorDefinition ??=
        _lookup<ffi.NativeFunction<_c_clang_getCursorDefinition>>(
                'clang_getCursorDefinition')
            .asFunction<_dart_clang_getCursorDefinition>())(
      arg0,
    );
  }

  _dart_clang_getCursorDefinition? _clang_getCursorDefinition;

  /// Determine whether the declaration pointed to by this cursor
  /// is also a definition of that entity.
  int clang_isCursorDefinition(
    CXCursor arg0,
  ) {
    return (_clang_isCursorDefinition ??=
        _lookup<ffi.NativeFunction<_c_clang_isCursorDefinition>>(
                'clang_isCursorDefinition')
            .asFunction<_dart_clang_isCursorDefinition>())(
      arg0,
    );
  }

  _dart_clang_isCursorDefinition? _clang_isCursorDefinition;

  /// Retrieve the canonical cursor corresponding to the given cursor.
  ///
  /// In the C family of languages, many kinds of entities can be declared several
  /// times within a single translation unit. For example, a structure type can
  /// be forward-declared (possibly multiple times) and later defined:
  ///
  /// \code
  /// struct X;
  /// struct X;
  /// struct X {
  /// int member;
  /// };
  /// \endcode
  ///
  /// The declarations and the definition of \c X are represented by three
  /// different cursors, all of which are declarations of the same underlying
  /// entity. One of these cursor is considered the "canonical" cursor, which
  /// is effectively the representative for the underlying entity. One can
  /// determine if two cursors are declarations of the same underlying entity by
  /// comparing their canonical cursors.
  ///
  /// \returns The canonical cursor for the entity referred to by the given cursor.
  CXCursor clang_getCanonicalCursor(
    CXCursor arg0,
  ) {
    return (_clang_getCanonicalCursor ??=
        _lookup<ffi.NativeFunction<_c_clang_getCanonicalCursor>>(
                'clang_getCanonicalCursor')
            .asFunction<_dart_clang_getCanonicalCursor>())(
      arg0,
    );
  }

  _dart_clang_getCanonicalCursor? _clang_getCanonicalCursor;

  /// If the cursor points to a selector identifier in an Objective-C
  /// method or message expression, this returns the selector index.
  ///
  /// After getting a cursor with #clang_getCursor, this can be called to
  /// determine if the location points to a selector identifier.
  ///
  /// \returns The selector index if the cursor is an Objective-C method or message
  /// expression and the cursor is pointing to a selector identifier, or -1
  /// otherwise.
  int clang_Cursor_getObjCSelectorIndex(
    CXCursor arg0,
  ) {
    return (_clang_Cursor_getObjCSelectorIndex ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_getObjCSelectorIndex>>(
                'clang_Cursor_getObjCSelectorIndex')
            .asFunction<_dart_clang_Cursor_getObjCSelectorIndex>())(
      arg0,
    );
  }

  _dart_clang_Cursor_getObjCSelectorIndex? _clang_Cursor_getObjCSelectorIndex;

  /// Given a cursor pointing to a C++ method call or an Objective-C
  /// message, returns non-zero if the method/message is "dynamic", meaning:
  ///
  /// For a C++ method: the call is virtual.
  /// For an Objective-C message: the receiver is an object instance, not 'super'
  /// or a specific class.
  ///
  /// If the method/message is "static" or the cursor does not point to a
  /// method/message, it will return zero.
  int clang_Cursor_isDynamicCall(
    CXCursor C,
  ) {
    return (_clang_Cursor_isDynamicCall ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_isDynamicCall>>(
                'clang_Cursor_isDynamicCall')
            .asFunction<_dart_clang_Cursor_isDynamicCall>())(
      C,
    );
  }

  _dart_clang_Cursor_isDynamicCall? _clang_Cursor_isDynamicCall;

  /// Given a cursor pointing to an Objective-C message or property
  /// reference, or C++ method call, returns the CXType of the receiver.
  CXType clang_Cursor_getReceiverType(
    CXCursor C,
  ) {
    return (_clang_Cursor_getReceiverType ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_getReceiverType>>(
                'clang_Cursor_getReceiverType')
            .asFunction<_dart_clang_Cursor_getReceiverType>())(
      C,
    );
  }

  _dart_clang_Cursor_getReceiverType? _clang_Cursor_getReceiverType;

  /// Given a cursor that represents a property declaration, return the
  /// associated property attributes. The bits are formed from
  /// \c CXObjCPropertyAttrKind.
  ///
  /// \param reserved Reserved for future use, pass 0.
  int clang_Cursor_getObjCPropertyAttributes(
    CXCursor C,
    int reserved,
  ) {
    return (_clang_Cursor_getObjCPropertyAttributes ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_getObjCPropertyAttributes>>(
                'clang_Cursor_getObjCPropertyAttributes')
            .asFunction<_dart_clang_Cursor_getObjCPropertyAttributes>())(
      C,
      reserved,
    );
  }

  _dart_clang_Cursor_getObjCPropertyAttributes?
      _clang_Cursor_getObjCPropertyAttributes;

  /// Given a cursor that represents a property declaration, return the
  /// name of the method that implements the getter.
  CXString clang_Cursor_getObjCPropertyGetterName(
    CXCursor C,
  ) {
    return (_clang_Cursor_getObjCPropertyGetterName ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_getObjCPropertyGetterName>>(
                'clang_Cursor_getObjCPropertyGetterName')
            .asFunction<_dart_clang_Cursor_getObjCPropertyGetterName>())(
      C,
    );
  }

  _dart_clang_Cursor_getObjCPropertyGetterName?
      _clang_Cursor_getObjCPropertyGetterName;

  /// Given a cursor that represents a property declaration, return the
  /// name of the method that implements the setter, if any.
  CXString clang_Cursor_getObjCPropertySetterName(
    CXCursor C,
  ) {
    return (_clang_Cursor_getObjCPropertySetterName ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_getObjCPropertySetterName>>(
                'clang_Cursor_getObjCPropertySetterName')
            .asFunction<_dart_clang_Cursor_getObjCPropertySetterName>())(
      C,
    );
  }

  _dart_clang_Cursor_getObjCPropertySetterName?
      _clang_Cursor_getObjCPropertySetterName;

  /// Given a cursor that represents an Objective-C method or parameter
  /// declaration, return the associated Objective-C qualifiers for the return
  /// type or the parameter respectively. The bits are formed from
  /// CXObjCDeclQualifierKind.
  int clang_Cursor_getObjCDeclQualifiers(
    CXCursor C,
  ) {
    return (_clang_Cursor_getObjCDeclQualifiers ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_getObjCDeclQualifiers>>(
                'clang_Cursor_getObjCDeclQualifiers')
            .asFunction<_dart_clang_Cursor_getObjCDeclQualifiers>())(
      C,
    );
  }

  _dart_clang_Cursor_getObjCDeclQualifiers? _clang_Cursor_getObjCDeclQualifiers;

  /// Given a cursor that represents an Objective-C method or property
  /// declaration, return non-zero if the declaration was affected by "\@optional".
  /// Returns zero if the cursor is not such a declaration or it is "\@required".
  int clang_Cursor_isObjCOptional(
    CXCursor C,
  ) {
    return (_clang_Cursor_isObjCOptional ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_isObjCOptional>>(
                'clang_Cursor_isObjCOptional')
            .asFunction<_dart_clang_Cursor_isObjCOptional>())(
      C,
    );
  }

  _dart_clang_Cursor_isObjCOptional? _clang_Cursor_isObjCOptional;

  /// Returns non-zero if the given cursor is a variadic function or method.
  int clang_Cursor_isVariadic(
    CXCursor C,
  ) {
    return (_clang_Cursor_isVariadic ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_isVariadic>>(
                'clang_Cursor_isVariadic')
            .asFunction<_dart_clang_Cursor_isVariadic>())(
      C,
    );
  }

  _dart_clang_Cursor_isVariadic? _clang_Cursor_isVariadic;

  /// Returns non-zero if the given cursor points to a symbol marked with
  /// external_source_symbol attribute.
  ///
  /// \param language If non-NULL, and the attribute is present, will be set to
  /// the 'language' string from the attribute.
  ///
  /// \param definedIn If non-NULL, and the attribute is present, will be set to
  /// the 'definedIn' string from the attribute.
  ///
  /// \param isGenerated If non-NULL, and the attribute is present, will be set to
  /// non-zero if the 'generated_declaration' is set in the attribute.
  int clang_Cursor_isExternalSymbol(
    CXCursor C,
    ffi.Pointer<CXString> language,
    ffi.Pointer<CXString> definedIn,
    ffi.Pointer<ffi.Uint32> isGenerated,
  ) {
    return (_clang_Cursor_isExternalSymbol ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_isExternalSymbol>>(
                'clang_Cursor_isExternalSymbol')
            .asFunction<_dart_clang_Cursor_isExternalSymbol>())(
      C,
      language,
      definedIn,
      isGenerated,
    );
  }

  _dart_clang_Cursor_isExternalSymbol? _clang_Cursor_isExternalSymbol;

  /// Given a cursor that represents a declaration, return the associated
  /// comment's source range.  The range may include multiple consecutive comments
  /// with whitespace in between.
  CXSourceRange clang_Cursor_getCommentRange(
    CXCursor C,
  ) {
    return (_clang_Cursor_getCommentRange ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_getCommentRange>>(
                'clang_Cursor_getCommentRange')
            .asFunction<_dart_clang_Cursor_getCommentRange>())(
      C,
    );
  }

  _dart_clang_Cursor_getCommentRange? _clang_Cursor_getCommentRange;

  /// Given a cursor that represents a declaration, return the associated
  /// comment text, including comment markers.
  CXString clang_Cursor_getRawCommentText(
    CXCursor C,
  ) {
    return (_clang_Cursor_getRawCommentText ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_getRawCommentText>>(
                'clang_Cursor_getRawCommentText')
            .asFunction<_dart_clang_Cursor_getRawCommentText>())(
      C,
    );
  }

  _dart_clang_Cursor_getRawCommentText? _clang_Cursor_getRawCommentText;

  /// Given a cursor that represents a documentable entity (e.g.,
  /// declaration), return the associated \paragraph; otherwise return the
  /// first paragraph.
  CXString clang_Cursor_getBriefCommentText(
    CXCursor C,
  ) {
    return (_clang_Cursor_getBriefCommentText ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_getBriefCommentText>>(
                'clang_Cursor_getBriefCommentText')
            .asFunction<_dart_clang_Cursor_getBriefCommentText>())(
      C,
    );
  }

  _dart_clang_Cursor_getBriefCommentText? _clang_Cursor_getBriefCommentText;

  /// Retrieve the CXString representing the mangled name of the cursor.
  CXString clang_Cursor_getMangling(
    CXCursor arg0,
  ) {
    return (_clang_Cursor_getMangling ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_getMangling>>(
                'clang_Cursor_getMangling')
            .asFunction<_dart_clang_Cursor_getMangling>())(
      arg0,
    );
  }

  _dart_clang_Cursor_getMangling? _clang_Cursor_getMangling;

  /// Retrieve the CXStrings representing the mangled symbols of the C++
  /// constructor or destructor at the cursor.
  ffi.Pointer<CXStringSet> clang_Cursor_getCXXManglings(
    CXCursor arg0,
  ) {
    return (_clang_Cursor_getCXXManglings ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_getCXXManglings>>(
                'clang_Cursor_getCXXManglings')
            .asFunction<_dart_clang_Cursor_getCXXManglings>())(
      arg0,
    );
  }

  _dart_clang_Cursor_getCXXManglings? _clang_Cursor_getCXXManglings;

  /// Retrieve the CXStrings representing the mangled symbols of the ObjC
  /// class interface or implementation at the cursor.
  ffi.Pointer<CXStringSet> clang_Cursor_getObjCManglings(
    CXCursor arg0,
  ) {
    return (_clang_Cursor_getObjCManglings ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_getObjCManglings>>(
                'clang_Cursor_getObjCManglings')
            .asFunction<_dart_clang_Cursor_getObjCManglings>())(
      arg0,
    );
  }

  _dart_clang_Cursor_getObjCManglings? _clang_Cursor_getObjCManglings;

  /// Given a CXCursor_ModuleImportDecl cursor, return the associated module.
  ffi.Pointer<ffi.Void> clang_Cursor_getModule(
    CXCursor C,
  ) {
    return (_clang_Cursor_getModule ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_getModule>>(
                'clang_Cursor_getModule')
            .asFunction<_dart_clang_Cursor_getModule>())(
      C,
    );
  }

  _dart_clang_Cursor_getModule? _clang_Cursor_getModule;

  /// Given a CXFile header file, return the module that contains it, if one
  /// exists.
  ffi.Pointer<ffi.Void> clang_getModuleForFile(
    ffi.Pointer<CXTranslationUnitImpl> arg0,
    ffi.Pointer<ffi.Void> arg1,
  ) {
    return (_clang_getModuleForFile ??=
        _lookup<ffi.NativeFunction<_c_clang_getModuleForFile>>(
                'clang_getModuleForFile')
            .asFunction<_dart_clang_getModuleForFile>())(
      arg0,
      arg1,
    );
  }

  _dart_clang_getModuleForFile? _clang_getModuleForFile;

  /// \param Module a module object.
  ///
  /// \returns the module file where the provided module object came from.
  ffi.Pointer<ffi.Void> clang_Module_getASTFile(
    ffi.Pointer<ffi.Void> Module,
  ) {
    return (_clang_Module_getASTFile ??=
        _lookup<ffi.NativeFunction<_c_clang_Module_getASTFile>>(
                'clang_Module_getASTFile')
            .asFunction<_dart_clang_Module_getASTFile>())(
      Module,
    );
  }

  _dart_clang_Module_getASTFile? _clang_Module_getASTFile;

  /// \param Module a module object.
  ///
  /// \returns the parent of a sub-module or NULL if the given module is top-level,
  /// e.g. for 'std.vector' it will return the 'std' module.
  ffi.Pointer<ffi.Void> clang_Module_getParent(
    ffi.Pointer<ffi.Void> Module,
  ) {
    return (_clang_Module_getParent ??=
        _lookup<ffi.NativeFunction<_c_clang_Module_getParent>>(
                'clang_Module_getParent')
            .asFunction<_dart_clang_Module_getParent>())(
      Module,
    );
  }

  _dart_clang_Module_getParent? _clang_Module_getParent;

  /// \param Module a module object.
  ///
  /// \returns the name of the module, e.g. for the 'std.vector' sub-module it
  /// will return "vector".
  CXString clang_Module_getName(
    ffi.Pointer<ffi.Void> Module,
  ) {
    return (_clang_Module_getName ??=
        _lookup<ffi.NativeFunction<_c_clang_Module_getName>>(
                'clang_Module_getName')
            .asFunction<_dart_clang_Module_getName>())(
      Module,
    );
  }

  _dart_clang_Module_getName? _clang_Module_getName;

  /// \param Module a module object.
  ///
  /// \returns the full name of the module, e.g. "std.vector".
  CXString clang_Module_getFullName(
    ffi.Pointer<ffi.Void> Module,
  ) {
    return (_clang_Module_getFullName ??=
        _lookup<ffi.NativeFunction<_c_clang_Module_getFullName>>(
                'clang_Module_getFullName')
            .asFunction<_dart_clang_Module_getFullName>())(
      Module,
    );
  }

  _dart_clang_Module_getFullName? _clang_Module_getFullName;

  /// \param Module a module object.
  ///
  /// \returns non-zero if the module is a system one.
  int clang_Module_isSystem(
    ffi.Pointer<ffi.Void> Module,
  ) {
    return (_clang_Module_isSystem ??=
        _lookup<ffi.NativeFunction<_c_clang_Module_isSystem>>(
                'clang_Module_isSystem')
            .asFunction<_dart_clang_Module_isSystem>())(
      Module,
    );
  }

  _dart_clang_Module_isSystem? _clang_Module_isSystem;

  /// \param Module a module object.
  ///
  /// \returns the number of top level headers associated with this module.
  int clang_Module_getNumTopLevelHeaders(
    ffi.Pointer<CXTranslationUnitImpl> arg0,
    ffi.Pointer<ffi.Void> Module,
  ) {
    return (_clang_Module_getNumTopLevelHeaders ??=
        _lookup<ffi.NativeFunction<_c_clang_Module_getNumTopLevelHeaders>>(
                'clang_Module_getNumTopLevelHeaders')
            .asFunction<_dart_clang_Module_getNumTopLevelHeaders>())(
      arg0,
      Module,
    );
  }

  _dart_clang_Module_getNumTopLevelHeaders? _clang_Module_getNumTopLevelHeaders;

  /// \param Module a module object.
  ///
  /// \param Index top level header index (zero-based).
  ///
  /// \returns the specified top level header associated with the module.
  ffi.Pointer<ffi.Void> clang_Module_getTopLevelHeader(
    ffi.Pointer<CXTranslationUnitImpl> arg0,
    ffi.Pointer<ffi.Void> Module,
    int Index,
  ) {
    return (_clang_Module_getTopLevelHeader ??=
        _lookup<ffi.NativeFunction<_c_clang_Module_getTopLevelHeader>>(
                'clang_Module_getTopLevelHeader')
            .asFunction<_dart_clang_Module_getTopLevelHeader>())(
      arg0,
      Module,
      Index,
    );
  }

  _dart_clang_Module_getTopLevelHeader? _clang_Module_getTopLevelHeader;

  /// Determine if a C++ constructor is a converting constructor.
  int clang_CXXConstructor_isConvertingConstructor(
    CXCursor C,
  ) {
    return (_clang_CXXConstructor_isConvertingConstructor ??= _lookup<
                ffi.NativeFunction<
                    _c_clang_CXXConstructor_isConvertingConstructor>>(
            'clang_CXXConstructor_isConvertingConstructor')
        .asFunction<_dart_clang_CXXConstructor_isConvertingConstructor>())(
      C,
    );
  }

  _dart_clang_CXXConstructor_isConvertingConstructor?
      _clang_CXXConstructor_isConvertingConstructor;

  /// Determine if a C++ constructor is a copy constructor.
  int clang_CXXConstructor_isCopyConstructor(
    CXCursor C,
  ) {
    return (_clang_CXXConstructor_isCopyConstructor ??=
        _lookup<ffi.NativeFunction<_c_clang_CXXConstructor_isCopyConstructor>>(
                'clang_CXXConstructor_isCopyConstructor')
            .asFunction<_dart_clang_CXXConstructor_isCopyConstructor>())(
      C,
    );
  }

  _dart_clang_CXXConstructor_isCopyConstructor?
      _clang_CXXConstructor_isCopyConstructor;

  /// Determine if a C++ constructor is the default constructor.
  int clang_CXXConstructor_isDefaultConstructor(
    CXCursor C,
  ) {
    return (_clang_CXXConstructor_isDefaultConstructor ??= _lookup<
                ffi.NativeFunction<
                    _c_clang_CXXConstructor_isDefaultConstructor>>(
            'clang_CXXConstructor_isDefaultConstructor')
        .asFunction<_dart_clang_CXXConstructor_isDefaultConstructor>())(
      C,
    );
  }

  _dart_clang_CXXConstructor_isDefaultConstructor?
      _clang_CXXConstructor_isDefaultConstructor;

  /// Determine if a C++ constructor is a move constructor.
  int clang_CXXConstructor_isMoveConstructor(
    CXCursor C,
  ) {
    return (_clang_CXXConstructor_isMoveConstructor ??=
        _lookup<ffi.NativeFunction<_c_clang_CXXConstructor_isMoveConstructor>>(
                'clang_CXXConstructor_isMoveConstructor')
            .asFunction<_dart_clang_CXXConstructor_isMoveConstructor>())(
      C,
    );
  }

  _dart_clang_CXXConstructor_isMoveConstructor?
      _clang_CXXConstructor_isMoveConstructor;

  /// Determine if a C++ field is declared 'mutable'.
  int clang_CXXField_isMutable(
    CXCursor C,
  ) {
    return (_clang_CXXField_isMutable ??=
        _lookup<ffi.NativeFunction<_c_clang_CXXField_isMutable>>(
                'clang_CXXField_isMutable')
            .asFunction<_dart_clang_CXXField_isMutable>())(
      C,
    );
  }

  _dart_clang_CXXField_isMutable? _clang_CXXField_isMutable;

  /// Determine if a C++ method is declared '= default'.
  int clang_CXXMethod_isDefaulted(
    CXCursor C,
  ) {
    return (_clang_CXXMethod_isDefaulted ??=
        _lookup<ffi.NativeFunction<_c_clang_CXXMethod_isDefaulted>>(
                'clang_CXXMethod_isDefaulted')
            .asFunction<_dart_clang_CXXMethod_isDefaulted>())(
      C,
    );
  }

  _dart_clang_CXXMethod_isDefaulted? _clang_CXXMethod_isDefaulted;

  /// Determine if a C++ member function or member function template is
  /// pure virtual.
  int clang_CXXMethod_isPureVirtual(
    CXCursor C,
  ) {
    return (_clang_CXXMethod_isPureVirtual ??=
        _lookup<ffi.NativeFunction<_c_clang_CXXMethod_isPureVirtual>>(
                'clang_CXXMethod_isPureVirtual')
            .asFunction<_dart_clang_CXXMethod_isPureVirtual>())(
      C,
    );
  }

  _dart_clang_CXXMethod_isPureVirtual? _clang_CXXMethod_isPureVirtual;

  /// Determine if a C++ member function or member function template is
  /// declared 'static'.
  int clang_CXXMethod_isStatic(
    CXCursor C,
  ) {
    return (_clang_CXXMethod_isStatic ??=
        _lookup<ffi.NativeFunction<_c_clang_CXXMethod_isStatic>>(
                'clang_CXXMethod_isStatic')
            .asFunction<_dart_clang_CXXMethod_isStatic>())(
      C,
    );
  }

  _dart_clang_CXXMethod_isStatic? _clang_CXXMethod_isStatic;

  /// Determine if a C++ member function or member function template is
  /// explicitly declared 'virtual' or if it overrides a virtual method from
  /// one of the base classes.
  int clang_CXXMethod_isVirtual(
    CXCursor C,
  ) {
    return (_clang_CXXMethod_isVirtual ??=
        _lookup<ffi.NativeFunction<_c_clang_CXXMethod_isVirtual>>(
                'clang_CXXMethod_isVirtual')
            .asFunction<_dart_clang_CXXMethod_isVirtual>())(
      C,
    );
  }

  _dart_clang_CXXMethod_isVirtual? _clang_CXXMethod_isVirtual;

  /// Determine if a C++ record is abstract, i.e. whether a class or struct
  /// has a pure virtual member function.
  int clang_CXXRecord_isAbstract(
    CXCursor C,
  ) {
    return (_clang_CXXRecord_isAbstract ??=
        _lookup<ffi.NativeFunction<_c_clang_CXXRecord_isAbstract>>(
                'clang_CXXRecord_isAbstract')
            .asFunction<_dart_clang_CXXRecord_isAbstract>())(
      C,
    );
  }

  _dart_clang_CXXRecord_isAbstract? _clang_CXXRecord_isAbstract;

  /// Determine if an enum declaration refers to a scoped enum.
  int clang_EnumDecl_isScoped(
    CXCursor C,
  ) {
    return (_clang_EnumDecl_isScoped ??=
        _lookup<ffi.NativeFunction<_c_clang_EnumDecl_isScoped>>(
                'clang_EnumDecl_isScoped')
            .asFunction<_dart_clang_EnumDecl_isScoped>())(
      C,
    );
  }

  _dart_clang_EnumDecl_isScoped? _clang_EnumDecl_isScoped;

  /// Determine if a C++ member function or member function template is
  /// declared 'const'.
  int clang_CXXMethod_isConst(
    CXCursor C,
  ) {
    return (_clang_CXXMethod_isConst ??=
        _lookup<ffi.NativeFunction<_c_clang_CXXMethod_isConst>>(
                'clang_CXXMethod_isConst')
            .asFunction<_dart_clang_CXXMethod_isConst>())(
      C,
    );
  }

  _dart_clang_CXXMethod_isConst? _clang_CXXMethod_isConst;

  /// Given a cursor that represents a template, determine
  /// the cursor kind of the specializations would be generated by instantiating
  /// the template.
  ///
  /// This routine can be used to determine what flavor of function template,
  /// class template, or class template partial specialization is stored in the
  /// cursor. For example, it can describe whether a class template cursor is
  /// declared with "struct", "class" or "union".
  ///
  /// \param C The cursor to query. This cursor should represent a template
  /// declaration.
  ///
  /// \returns The cursor kind of the specializations that would be generated
  /// by instantiating the template \p C. If \p C is not a template, returns
  /// \c CXCursor_NoDeclFound.
  int clang_getTemplateCursorKind(
    CXCursor C,
  ) {
    return (_clang_getTemplateCursorKind ??=
        _lookup<ffi.NativeFunction<_c_clang_getTemplateCursorKind>>(
                'clang_getTemplateCursorKind')
            .asFunction<_dart_clang_getTemplateCursorKind>())(
      C,
    );
  }

  _dart_clang_getTemplateCursorKind? _clang_getTemplateCursorKind;

  /// Given a cursor that may represent a specialization or instantiation
  /// of a template, retrieve the cursor that represents the template that it
  /// specializes or from which it was instantiated.
  ///
  /// This routine determines the template involved both for explicit
  /// specializations of templates and for implicit instantiations of the template,
  /// both of which are referred to as "specializations". For a class template
  /// specialization (e.g., \c std::vector<bool>), this routine will return
  /// either the primary template (\c std::vector) or, if the specialization was
  /// instantiated from a class template partial specialization, the class template
  /// partial specialization. For a class template partial specialization and a
  /// function template specialization (including instantiations), this
  /// this routine will return the specialized template.
  ///
  /// For members of a class template (e.g., member functions, member classes, or
  /// static data members), returns the specialized or instantiated member.
  /// Although not strictly "templates" in the C++ language, members of class
  /// templates have the same notions of specializations and instantiations that
  /// templates do, so this routine treats them similarly.
  ///
  /// \param C A cursor that may be a specialization of a template or a member
  /// of a template.
  ///
  /// \returns If the given cursor is a specialization or instantiation of a
  /// template or a member thereof, the template or member that it specializes or
  /// from which it was instantiated. Otherwise, returns a NULL cursor.
  CXCursor clang_getSpecializedCursorTemplate(
    CXCursor C,
  ) {
    return (_clang_getSpecializedCursorTemplate ??=
        _lookup<ffi.NativeFunction<_c_clang_getSpecializedCursorTemplate>>(
                'clang_getSpecializedCursorTemplate')
            .asFunction<_dart_clang_getSpecializedCursorTemplate>())(
      C,
    );
  }

  _dart_clang_getSpecializedCursorTemplate? _clang_getSpecializedCursorTemplate;

  /// Given a cursor that references something else, return the source range
  /// covering that reference.
  ///
  /// \param C A cursor pointing to a member reference, a declaration reference, or
  /// an operator call.
  /// \param NameFlags A bitset with three independent flags:
  /// CXNameRange_WantQualifier, CXNameRange_WantTemplateArgs, and
  /// CXNameRange_WantSinglePiece.
  /// \param PieceIndex For contiguous names or when passing the flag
  /// CXNameRange_WantSinglePiece, only one piece with index 0 is
  /// available. When the CXNameRange_WantSinglePiece flag is not passed for a
  /// non-contiguous names, this index can be used to retrieve the individual
  /// pieces of the name. See also CXNameRange_WantSinglePiece.
  ///
  /// \returns The piece of the name pointed to by the given cursor. If there is no
  /// name, or if the PieceIndex is out-of-range, a null-cursor will be returned.
  CXSourceRange clang_getCursorReferenceNameRange(
    CXCursor C,
    int NameFlags,
    int PieceIndex,
  ) {
    return (_clang_getCursorReferenceNameRange ??=
        _lookup<ffi.NativeFunction<_c_clang_getCursorReferenceNameRange>>(
                'clang_getCursorReferenceNameRange')
            .asFunction<_dart_clang_getCursorReferenceNameRange>())(
      C,
      NameFlags,
      PieceIndex,
    );
  }

  _dart_clang_getCursorReferenceNameRange? _clang_getCursorReferenceNameRange;

  /// Get the raw lexical token starting with the given location.
  ///
  /// \param TU the translation unit whose text is being tokenized.
  ///
  /// \param Location the source location with which the token starts.
  ///
  /// \returns The token starting with the given location or NULL if no such token
  /// exist. The returned pointer must be freed with clang_disposeTokens before the
  /// translation unit is destroyed.
  ffi.Pointer<CXToken> clang_getToken(
    ffi.Pointer<CXTranslationUnitImpl> TU,
    CXSourceLocation Location,
  ) {
    return (_clang_getToken ??=
        _lookup<ffi.NativeFunction<_c_clang_getToken>>('clang_getToken')
            .asFunction<_dart_clang_getToken>())(
      TU,
      Location,
    );
  }

  _dart_clang_getToken? _clang_getToken;

  /// Determine the kind of the given token.
  int clang_getTokenKind(
    CXToken arg0,
  ) {
    return (_clang_getTokenKind ??=
        _lookup<ffi.NativeFunction<_c_clang_getTokenKind>>('clang_getTokenKind')
            .asFunction<_dart_clang_getTokenKind>())(
      arg0,
    );
  }

  _dart_clang_getTokenKind? _clang_getTokenKind;

  /// Determine the spelling of the given token.
  ///
  /// The spelling of a token is the textual representation of that token, e.g.,
  /// the text of an identifier or keyword.
  CXString clang_getTokenSpelling(
    ffi.Pointer<CXTranslationUnitImpl> arg0,
    CXToken arg1,
  ) {
    return (_clang_getTokenSpelling ??=
        _lookup<ffi.NativeFunction<_c_clang_getTokenSpelling>>(
                'clang_getTokenSpelling')
            .asFunction<_dart_clang_getTokenSpelling>())(
      arg0,
      arg1,
    );
  }

  _dart_clang_getTokenSpelling? _clang_getTokenSpelling;

  /// Retrieve the source location of the given token.
  CXSourceLocation clang_getTokenLocation(
    ffi.Pointer<CXTranslationUnitImpl> arg0,
    CXToken arg1,
  ) {
    return (_clang_getTokenLocation ??=
        _lookup<ffi.NativeFunction<_c_clang_getTokenLocation>>(
                'clang_getTokenLocation')
            .asFunction<_dart_clang_getTokenLocation>())(
      arg0,
      arg1,
    );
  }

  _dart_clang_getTokenLocation? _clang_getTokenLocation;

  /// Retrieve a source range that covers the given token.
  CXSourceRange clang_getTokenExtent(
    ffi.Pointer<CXTranslationUnitImpl> arg0,
    CXToken arg1,
  ) {
    return (_clang_getTokenExtent ??=
        _lookup<ffi.NativeFunction<_c_clang_getTokenExtent>>(
                'clang_getTokenExtent')
            .asFunction<_dart_clang_getTokenExtent>())(
      arg0,
      arg1,
    );
  }

  _dart_clang_getTokenExtent? _clang_getTokenExtent;

  /// Tokenize the source code described by the given range into raw
  /// lexical tokens.
  ///
  /// \param TU the translation unit whose text is being tokenized.
  ///
  /// \param Range the source range in which text should be tokenized. All of the
  /// tokens produced by tokenization will fall within this source range,
  ///
  /// \param Tokens this pointer will be set to point to the array of tokens
  /// that occur within the given source range. The returned pointer must be
  /// freed with clang_disposeTokens() before the translation unit is destroyed.
  ///
  /// \param NumTokens will be set to the number of tokens in the \c *Tokens
  /// array.
  void clang_tokenize(
    ffi.Pointer<CXTranslationUnitImpl> TU,
    CXSourceRange Range,
    ffi.Pointer<ffi.Pointer<CXToken>> Tokens,
    ffi.Pointer<ffi.Uint32> NumTokens,
  ) {
    return (_clang_tokenize ??=
        _lookup<ffi.NativeFunction<_c_clang_tokenize>>('clang_tokenize')
            .asFunction<_dart_clang_tokenize>())(
      TU,
      Range,
      Tokens,
      NumTokens,
    );
  }

  _dart_clang_tokenize? _clang_tokenize;

  /// Annotate the given set of tokens by providing cursors for each token
  /// that can be mapped to a specific entity within the abstract syntax tree.
  ///
  /// This token-annotation routine is equivalent to invoking
  /// clang_getCursor() for the source locations of each of the
  /// tokens. The cursors provided are filtered, so that only those
  /// cursors that have a direct correspondence to the token are
  /// accepted. For example, given a function call \c f(x),
  /// clang_getCursor() would provide the following cursors:
  ///
  /// * when the cursor is over the 'f', a DeclRefExpr cursor referring to 'f'.
  /// * when the cursor is over the '(' or the ')', a CallExpr referring to 'f'.
  /// * when the cursor is over the 'x', a DeclRefExpr cursor referring to 'x'.
  ///
  /// Only the first and last of these cursors will occur within the
  /// annotate, since the tokens "f" and "x' directly refer to a function
  /// and a variable, respectively, but the parentheses are just a small
  /// part of the full syntax of the function call expression, which is
  /// not provided as an annotation.
  ///
  /// \param TU the translation unit that owns the given tokens.
  ///
  /// \param Tokens the set of tokens to annotate.
  ///
  /// \param NumTokens the number of tokens in \p Tokens.
  ///
  /// \param Cursors an array of \p NumTokens cursors, whose contents will be
  /// replaced with the cursors corresponding to each token.
  void clang_annotateTokens(
    ffi.Pointer<CXTranslationUnitImpl> TU,
    ffi.Pointer<CXToken> Tokens,
    int NumTokens,
    ffi.Pointer<CXCursor> Cursors,
  ) {
    return (_clang_annotateTokens ??=
        _lookup<ffi.NativeFunction<_c_clang_annotateTokens>>(
                'clang_annotateTokens')
            .asFunction<_dart_clang_annotateTokens>())(
      TU,
      Tokens,
      NumTokens,
      Cursors,
    );
  }

  _dart_clang_annotateTokens? _clang_annotateTokens;

  /// Free the given set of tokens.
  void clang_disposeTokens(
    ffi.Pointer<CXTranslationUnitImpl> TU,
    ffi.Pointer<CXToken> Tokens,
    int NumTokens,
  ) {
    return (_clang_disposeTokens ??=
        _lookup<ffi.NativeFunction<_c_clang_disposeTokens>>(
                'clang_disposeTokens')
            .asFunction<_dart_clang_disposeTokens>())(
      TU,
      Tokens,
      NumTokens,
    );
  }

  _dart_clang_disposeTokens? _clang_disposeTokens;

  /// \defgroup CINDEX_DEBUG Debugging facilities
  ///
  /// These routines are used for testing and debugging, only, and should not
  /// be relied upon.
  ///
  /// @{
  CXString clang_getCursorKindSpelling(
    int Kind,
  ) {
    return (_clang_getCursorKindSpelling ??=
        _lookup<ffi.NativeFunction<_c_clang_getCursorKindSpelling>>(
                'clang_getCursorKindSpelling')
            .asFunction<_dart_clang_getCursorKindSpelling>())(
      Kind,
    );
  }

  _dart_clang_getCursorKindSpelling? _clang_getCursorKindSpelling;

  void clang_getDefinitionSpellingAndExtent(
    CXCursor arg0,
    ffi.Pointer<ffi.Pointer<ffi.Int8>> startBuf,
    ffi.Pointer<ffi.Pointer<ffi.Int8>> endBuf,
    ffi.Pointer<ffi.Uint32> startLine,
    ffi.Pointer<ffi.Uint32> startColumn,
    ffi.Pointer<ffi.Uint32> endLine,
    ffi.Pointer<ffi.Uint32> endColumn,
  ) {
    return (_clang_getDefinitionSpellingAndExtent ??=
        _lookup<ffi.NativeFunction<_c_clang_getDefinitionSpellingAndExtent>>(
                'clang_getDefinitionSpellingAndExtent')
            .asFunction<_dart_clang_getDefinitionSpellingAndExtent>())(
      arg0,
      startBuf,
      endBuf,
      startLine,
      startColumn,
      endLine,
      endColumn,
    );
  }

  _dart_clang_getDefinitionSpellingAndExtent?
      _clang_getDefinitionSpellingAndExtent;

  void clang_enableStackTraces() {
    return (_clang_enableStackTraces ??=
        _lookup<ffi.NativeFunction<_c_clang_enableStackTraces>>(
                'clang_enableStackTraces')
            .asFunction<_dart_clang_enableStackTraces>())();
  }

  _dart_clang_enableStackTraces? _clang_enableStackTraces;

  void clang_executeOnThread(
    ffi.Pointer<ffi.NativeFunction<_typedefC_1>> fn,
    ffi.Pointer<ffi.Void> user_data,
    int stack_size,
  ) {
    return (_clang_executeOnThread ??=
        _lookup<ffi.NativeFunction<_c_clang_executeOnThread>>(
                'clang_executeOnThread')
            .asFunction<_dart_clang_executeOnThread>())(
      fn,
      user_data,
      stack_size,
    );
  }

  _dart_clang_executeOnThread? _clang_executeOnThread;

  /// Determine the kind of a particular chunk within a completion string.
  ///
  /// \param completion_string the completion string to query.
  ///
  /// \param chunk_number the 0-based index of the chunk in the completion string.
  ///
  /// \returns the kind of the chunk at the index \c chunk_number.
  int clang_getCompletionChunkKind(
    ffi.Pointer<ffi.Void> completion_string,
    int chunk_number,
  ) {
    return (_clang_getCompletionChunkKind ??=
        _lookup<ffi.NativeFunction<_c_clang_getCompletionChunkKind>>(
                'clang_getCompletionChunkKind')
            .asFunction<_dart_clang_getCompletionChunkKind>())(
      completion_string,
      chunk_number,
    );
  }

  _dart_clang_getCompletionChunkKind? _clang_getCompletionChunkKind;

  /// Retrieve the text associated with a particular chunk within a
  /// completion string.
  ///
  /// \param completion_string the completion string to query.
  ///
  /// \param chunk_number the 0-based index of the chunk in the completion string.
  ///
  /// \returns the text associated with the chunk at index \c chunk_number.
  CXString clang_getCompletionChunkText(
    ffi.Pointer<ffi.Void> completion_string,
    int chunk_number,
  ) {
    return (_clang_getCompletionChunkText ??=
        _lookup<ffi.NativeFunction<_c_clang_getCompletionChunkText>>(
                'clang_getCompletionChunkText')
            .asFunction<_dart_clang_getCompletionChunkText>())(
      completion_string,
      chunk_number,
    );
  }

  _dart_clang_getCompletionChunkText? _clang_getCompletionChunkText;

  /// Retrieve the completion string associated with a particular chunk
  /// within a completion string.
  ///
  /// \param completion_string the completion string to query.
  ///
  /// \param chunk_number the 0-based index of the chunk in the completion string.
  ///
  /// \returns the completion string associated with the chunk at index
  /// \c chunk_number.
  ffi.Pointer<ffi.Void> clang_getCompletionChunkCompletionString(
    ffi.Pointer<ffi.Void> completion_string,
    int chunk_number,
  ) {
    return (_clang_getCompletionChunkCompletionString ??= _lookup<
                ffi.NativeFunction<
                    _c_clang_getCompletionChunkCompletionString>>(
            'clang_getCompletionChunkCompletionString')
        .asFunction<_dart_clang_getCompletionChunkCompletionString>())(
      completion_string,
      chunk_number,
    );
  }

  _dart_clang_getCompletionChunkCompletionString?
      _clang_getCompletionChunkCompletionString;

  /// Retrieve the number of chunks in the given code-completion string.
  int clang_getNumCompletionChunks(
    ffi.Pointer<ffi.Void> completion_string,
  ) {
    return (_clang_getNumCompletionChunks ??=
        _lookup<ffi.NativeFunction<_c_clang_getNumCompletionChunks>>(
                'clang_getNumCompletionChunks')
            .asFunction<_dart_clang_getNumCompletionChunks>())(
      completion_string,
    );
  }

  _dart_clang_getNumCompletionChunks? _clang_getNumCompletionChunks;

  /// Determine the priority of this code completion.
  ///
  /// The priority of a code completion indicates how likely it is that this
  /// particular completion is the completion that the user will select. The
  /// priority is selected by various internal heuristics.
  ///
  /// \param completion_string The completion string to query.
  ///
  /// \returns The priority of this completion string. Smaller values indicate
  /// higher-priority (more likely) completions.
  int clang_getCompletionPriority(
    ffi.Pointer<ffi.Void> completion_string,
  ) {
    return (_clang_getCompletionPriority ??=
        _lookup<ffi.NativeFunction<_c_clang_getCompletionPriority>>(
                'clang_getCompletionPriority')
            .asFunction<_dart_clang_getCompletionPriority>())(
      completion_string,
    );
  }

  _dart_clang_getCompletionPriority? _clang_getCompletionPriority;

  /// Determine the availability of the entity that this code-completion
  /// string refers to.
  ///
  /// \param completion_string The completion string to query.
  ///
  /// \returns The availability of the completion string.
  int clang_getCompletionAvailability(
    ffi.Pointer<ffi.Void> completion_string,
  ) {
    return (_clang_getCompletionAvailability ??=
        _lookup<ffi.NativeFunction<_c_clang_getCompletionAvailability>>(
                'clang_getCompletionAvailability')
            .asFunction<_dart_clang_getCompletionAvailability>())(
      completion_string,
    );
  }

  _dart_clang_getCompletionAvailability? _clang_getCompletionAvailability;

  /// Retrieve the number of annotations associated with the given
  /// completion string.
  ///
  /// \param completion_string the completion string to query.
  ///
  /// \returns the number of annotations associated with the given completion
  /// string.
  int clang_getCompletionNumAnnotations(
    ffi.Pointer<ffi.Void> completion_string,
  ) {
    return (_clang_getCompletionNumAnnotations ??=
        _lookup<ffi.NativeFunction<_c_clang_getCompletionNumAnnotations>>(
                'clang_getCompletionNumAnnotations')
            .asFunction<_dart_clang_getCompletionNumAnnotations>())(
      completion_string,
    );
  }

  _dart_clang_getCompletionNumAnnotations? _clang_getCompletionNumAnnotations;

  /// Retrieve the annotation associated with the given completion string.
  ///
  /// \param completion_string the completion string to query.
  ///
  /// \param annotation_number the 0-based index of the annotation of the
  /// completion string.
  ///
  /// \returns annotation string associated with the completion at index
  /// \c annotation_number, or a NULL string if that annotation is not available.
  CXString clang_getCompletionAnnotation(
    ffi.Pointer<ffi.Void> completion_string,
    int annotation_number,
  ) {
    return (_clang_getCompletionAnnotation ??=
        _lookup<ffi.NativeFunction<_c_clang_getCompletionAnnotation>>(
                'clang_getCompletionAnnotation')
            .asFunction<_dart_clang_getCompletionAnnotation>())(
      completion_string,
      annotation_number,
    );
  }

  _dart_clang_getCompletionAnnotation? _clang_getCompletionAnnotation;

  /// Retrieve the parent context of the given completion string.
  ///
  /// The parent context of a completion string is the semantic parent of
  /// the declaration (if any) that the code completion represents. For example,
  /// a code completion for an Objective-C method would have the method's class
  /// or protocol as its context.
  ///
  /// \param completion_string The code completion string whose parent is
  /// being queried.
  ///
  /// \param kind DEPRECATED: always set to CXCursor_NotImplemented if non-NULL.
  ///
  /// \returns The name of the completion parent, e.g., "NSObject" if
  /// the completion string represents a method in the NSObject class.
  CXString clang_getCompletionParent(
    ffi.Pointer<ffi.Void> completion_string,
    ffi.Pointer<ffi.Int32> kind,
  ) {
    return (_clang_getCompletionParent ??=
        _lookup<ffi.NativeFunction<_c_clang_getCompletionParent>>(
                'clang_getCompletionParent')
            .asFunction<_dart_clang_getCompletionParent>())(
      completion_string,
      kind,
    );
  }

  _dart_clang_getCompletionParent? _clang_getCompletionParent;

  /// Retrieve the brief documentation comment attached to the declaration
  /// that corresponds to the given completion string.
  CXString clang_getCompletionBriefComment(
    ffi.Pointer<ffi.Void> completion_string,
  ) {
    return (_clang_getCompletionBriefComment ??=
        _lookup<ffi.NativeFunction<_c_clang_getCompletionBriefComment>>(
                'clang_getCompletionBriefComment')
            .asFunction<_dart_clang_getCompletionBriefComment>())(
      completion_string,
    );
  }

  _dart_clang_getCompletionBriefComment? _clang_getCompletionBriefComment;

  /// Retrieve a completion string for an arbitrary declaration or macro
  /// definition cursor.
  ///
  /// \param cursor The cursor to query.
  ///
  /// \returns A non-context-sensitive completion string for declaration and macro
  /// definition cursors, or NULL for other kinds of cursors.
  ffi.Pointer<ffi.Void> clang_getCursorCompletionString(
    CXCursor cursor,
  ) {
    return (_clang_getCursorCompletionString ??=
        _lookup<ffi.NativeFunction<_c_clang_getCursorCompletionString>>(
                'clang_getCursorCompletionString')
            .asFunction<_dart_clang_getCursorCompletionString>())(
      cursor,
    );
  }

  _dart_clang_getCursorCompletionString? _clang_getCursorCompletionString;

  /// Retrieve the number of fix-its for the given completion index.
  ///
  /// Calling this makes sense only if CXCodeComplete_IncludeCompletionsWithFixIts
  /// option was set.
  ///
  /// \param results The structure keeping all completion results
  ///
  /// \param completion_index The index of the completion
  ///
  /// \return The number of fix-its which must be applied before the completion at
  /// completion_index can be applied
  int clang_getCompletionNumFixIts(
    ffi.Pointer<CXCodeCompleteResults> results,
    int completion_index,
  ) {
    return (_clang_getCompletionNumFixIts ??=
        _lookup<ffi.NativeFunction<_c_clang_getCompletionNumFixIts>>(
                'clang_getCompletionNumFixIts')
            .asFunction<_dart_clang_getCompletionNumFixIts>())(
      results,
      completion_index,
    );
  }

  _dart_clang_getCompletionNumFixIts? _clang_getCompletionNumFixIts;

  /// Fix-its that *must* be applied before inserting the text for the
  /// corresponding completion.
  ///
  /// By default, clang_codeCompleteAt() only returns completions with empty
  /// fix-its. Extra completions with non-empty fix-its should be explicitly
  /// requested by setting CXCodeComplete_IncludeCompletionsWithFixIts.
  ///
  /// For the clients to be able to compute position of the cursor after applying
  /// fix-its, the following conditions are guaranteed to hold for
  /// replacement_range of the stored fix-its:
  /// - Ranges in the fix-its are guaranteed to never contain the completion
  /// point (or identifier under completion point, if any) inside them, except
  /// at the start or at the end of the range.
  /// - If a fix-it range starts or ends with completion point (or starts or
  /// ends after the identifier under completion point), it will contain at
  /// least one character. It allows to unambiguously recompute completion
  /// point after applying the fix-it.
  ///
  /// The intuition is that provided fix-its change code around the identifier we
  /// complete, but are not allowed to touch the identifier itself or the
  /// completion point. One example of completions with corrections are the ones
  /// replacing '.' with '->' and vice versa:
  ///
  /// std::unique_ptr<std::vector<int>> vec_ptr;
  /// In 'vec_ptr.^', one of the completions is 'push_back', it requires
  /// replacing '.' with '->'.
  /// In 'vec_ptr->^', one of the completions is 'release', it requires
  /// replacing '->' with '.'.
  ///
  /// \param results The structure keeping all completion results
  ///
  /// \param completion_index The index of the completion
  ///
  /// \param fixit_index The index of the fix-it for the completion at
  /// completion_index
  ///
  /// \param replacement_range The fix-it range that must be replaced before the
  /// completion at completion_index can be applied
  ///
  /// \returns The fix-it string that must replace the code at replacement_range
  /// before the completion at completion_index can be applied
  CXString clang_getCompletionFixIt(
    ffi.Pointer<CXCodeCompleteResults> results,
    int completion_index,
    int fixit_index,
    ffi.Pointer<CXSourceRange> replacement_range,
  ) {
    return (_clang_getCompletionFixIt ??=
        _lookup<ffi.NativeFunction<_c_clang_getCompletionFixIt>>(
                'clang_getCompletionFixIt')
            .asFunction<_dart_clang_getCompletionFixIt>())(
      results,
      completion_index,
      fixit_index,
      replacement_range,
    );
  }

  _dart_clang_getCompletionFixIt? _clang_getCompletionFixIt;

  /// Returns a default set of code-completion options that can be
  /// passed to\c clang_codeCompleteAt().
  int clang_defaultCodeCompleteOptions() {
    return (_clang_defaultCodeCompleteOptions ??=
        _lookup<ffi.NativeFunction<_c_clang_defaultCodeCompleteOptions>>(
                'clang_defaultCodeCompleteOptions')
            .asFunction<_dart_clang_defaultCodeCompleteOptions>())();
  }

  _dart_clang_defaultCodeCompleteOptions? _clang_defaultCodeCompleteOptions;

  /// Perform code completion at a given location in a translation unit.
  ///
  /// This function performs code completion at a particular file, line, and
  /// column within source code, providing results that suggest potential
  /// code snippets based on the context of the completion. The basic model
  /// for code completion is that Clang will parse a complete source file,
  /// performing syntax checking up to the location where code-completion has
  /// been requested. At that point, a special code-completion token is passed
  /// to the parser, which recognizes this token and determines, based on the
  /// current location in the C/Objective-C/C++ grammar and the state of
  /// semantic analysis, what completions to provide. These completions are
  /// returned via a new \c CXCodeCompleteResults structure.
  ///
  /// Code completion itself is meant to be triggered by the client when the
  /// user types punctuation characters or whitespace, at which point the
  /// code-completion location will coincide with the cursor. For example, if \c p
  /// is a pointer, code-completion might be triggered after the "-" and then
  /// after the ">" in \c p->. When the code-completion location is after the ">",
  /// the completion results will provide, e.g., the members of the struct that
  /// "p" points to. The client is responsible for placing the cursor at the
  /// beginning of the token currently being typed, then filtering the results
  /// based on the contents of the token. For example, when code-completing for
  /// the expression \c p->get, the client should provide the location just after
  /// the ">" (e.g., pointing at the "g") to this code-completion hook. Then, the
  /// client can filter the results based on the current token text ("get"), only
  /// showing those results that start with "get". The intent of this interface
  /// is to separate the relatively high-latency acquisition of code-completion
  /// results from the filtering of results on a per-character basis, which must
  /// have a lower latency.
  ///
  /// \param TU The translation unit in which code-completion should
  /// occur. The source files for this translation unit need not be
  /// completely up-to-date (and the contents of those source files may
  /// be overridden via \p unsaved_files). Cursors referring into the
  /// translation unit may be invalidated by this invocation.
  ///
  /// \param complete_filename The name of the source file where code
  /// completion should be performed. This filename may be any file
  /// included in the translation unit.
  ///
  /// \param complete_line The line at which code-completion should occur.
  ///
  /// \param complete_column The column at which code-completion should occur.
  /// Note that the column should point just after the syntactic construct that
  /// initiated code completion, and not in the middle of a lexical token.
  ///
  /// \param unsaved_files the Files that have not yet been saved to disk
  /// but may be required for parsing or code completion, including the
  /// contents of those files.  The contents and name of these files (as
  /// specified by CXUnsavedFile) are copied when necessary, so the
  /// client only needs to guarantee their validity until the call to
  /// this function returns.
  ///
  /// \param num_unsaved_files The number of unsaved file entries in \p
  /// unsaved_files.
  ///
  /// \param options Extra options that control the behavior of code
  /// completion, expressed as a bitwise OR of the enumerators of the
  /// CXCodeComplete_Flags enumeration. The
  /// \c clang_defaultCodeCompleteOptions() function returns a default set
  /// of code-completion options.
  ///
  /// \returns If successful, a new \c CXCodeCompleteResults structure
  /// containing code-completion results, which should eventually be
  /// freed with \c clang_disposeCodeCompleteResults(). If code
  /// completion fails, returns NULL.
  ffi.Pointer<CXCodeCompleteResults> clang_codeCompleteAt(
    ffi.Pointer<CXTranslationUnitImpl> TU,
    ffi.Pointer<ffi.Int8> complete_filename,
    int complete_line,
    int complete_column,
    ffi.Pointer<CXUnsavedFile> unsaved_files,
    int num_unsaved_files,
    int options,
  ) {
    return (_clang_codeCompleteAt ??=
        _lookup<ffi.NativeFunction<_c_clang_codeCompleteAt>>(
                'clang_codeCompleteAt')
            .asFunction<_dart_clang_codeCompleteAt>())(
      TU,
      complete_filename,
      complete_line,
      complete_column,
      unsaved_files,
      num_unsaved_files,
      options,
    );
  }

  _dart_clang_codeCompleteAt? _clang_codeCompleteAt;

  /// Sort the code-completion results in case-insensitive alphabetical
  /// order.
  ///
  /// \param Results The set of results to sort.
  /// \param NumResults The number of results in \p Results.
  void clang_sortCodeCompletionResults(
    ffi.Pointer<CXCompletionResult> Results,
    int NumResults,
  ) {
    return (_clang_sortCodeCompletionResults ??=
        _lookup<ffi.NativeFunction<_c_clang_sortCodeCompletionResults>>(
                'clang_sortCodeCompletionResults')
            .asFunction<_dart_clang_sortCodeCompletionResults>())(
      Results,
      NumResults,
    );
  }

  _dart_clang_sortCodeCompletionResults? _clang_sortCodeCompletionResults;

  /// Free the given set of code-completion results.
  void clang_disposeCodeCompleteResults(
    ffi.Pointer<CXCodeCompleteResults> Results,
  ) {
    return (_clang_disposeCodeCompleteResults ??=
        _lookup<ffi.NativeFunction<_c_clang_disposeCodeCompleteResults>>(
                'clang_disposeCodeCompleteResults')
            .asFunction<_dart_clang_disposeCodeCompleteResults>())(
      Results,
    );
  }

  _dart_clang_disposeCodeCompleteResults? _clang_disposeCodeCompleteResults;

  /// Determine the number of diagnostics produced prior to the
  /// location where code completion was performed.
  int clang_codeCompleteGetNumDiagnostics(
    ffi.Pointer<CXCodeCompleteResults> Results,
  ) {
    return (_clang_codeCompleteGetNumDiagnostics ??=
        _lookup<ffi.NativeFunction<_c_clang_codeCompleteGetNumDiagnostics>>(
                'clang_codeCompleteGetNumDiagnostics')
            .asFunction<_dart_clang_codeCompleteGetNumDiagnostics>())(
      Results,
    );
  }

  _dart_clang_codeCompleteGetNumDiagnostics?
      _clang_codeCompleteGetNumDiagnostics;

  /// Retrieve a diagnostic associated with the given code completion.
  ///
  /// \param Results the code completion results 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_codeCompleteGetDiagnostic(
    ffi.Pointer<CXCodeCompleteResults> Results,
    int Index,
  ) {
    return (_clang_codeCompleteGetDiagnostic ??=
        _lookup<ffi.NativeFunction<_c_clang_codeCompleteGetDiagnostic>>(
                'clang_codeCompleteGetDiagnostic')
            .asFunction<_dart_clang_codeCompleteGetDiagnostic>())(
      Results,
      Index,
    );
  }

  _dart_clang_codeCompleteGetDiagnostic? _clang_codeCompleteGetDiagnostic;

  /// Determines what completions are appropriate for the context
  /// the given code completion.
  ///
  /// \param Results the code completion results to query
  ///
  /// \returns the kinds of completions that are appropriate for use
  /// along with the given code completion results.
  int clang_codeCompleteGetContexts(
    ffi.Pointer<CXCodeCompleteResults> Results,
  ) {
    return (_clang_codeCompleteGetContexts ??=
        _lookup<ffi.NativeFunction<_c_clang_codeCompleteGetContexts>>(
                'clang_codeCompleteGetContexts')
            .asFunction<_dart_clang_codeCompleteGetContexts>())(
      Results,
    );
  }

  _dart_clang_codeCompleteGetContexts? _clang_codeCompleteGetContexts;

  /// Returns the cursor kind for the container for the current code
  /// completion context. The container is only guaranteed to be set for
  /// contexts where a container exists (i.e. member accesses or Objective-C
  /// message sends); if there is not a container, this function will return
  /// CXCursor_InvalidCode.
  ///
  /// \param Results the code completion results to query
  ///
  /// \param IsIncomplete on return, this value will be false if Clang has complete
  /// information about the container. If Clang does not have complete
  /// information, this value will be true.
  ///
  /// \returns the container kind, or CXCursor_InvalidCode if there is not a
  /// container
  int clang_codeCompleteGetContainerKind(
    ffi.Pointer<CXCodeCompleteResults> Results,
    ffi.Pointer<ffi.Uint32> IsIncomplete,
  ) {
    return (_clang_codeCompleteGetContainerKind ??=
        _lookup<ffi.NativeFunction<_c_clang_codeCompleteGetContainerKind>>(
                'clang_codeCompleteGetContainerKind')
            .asFunction<_dart_clang_codeCompleteGetContainerKind>())(
      Results,
      IsIncomplete,
    );
  }

  _dart_clang_codeCompleteGetContainerKind? _clang_codeCompleteGetContainerKind;

  /// Returns the USR for the container for the current code completion
  /// context. If there is not a container for the current context, this
  /// function will return the empty string.
  ///
  /// \param Results the code completion results to query
  ///
  /// \returns the USR for the container
  CXString clang_codeCompleteGetContainerUSR(
    ffi.Pointer<CXCodeCompleteResults> Results,
  ) {
    return (_clang_codeCompleteGetContainerUSR ??=
        _lookup<ffi.NativeFunction<_c_clang_codeCompleteGetContainerUSR>>(
                'clang_codeCompleteGetContainerUSR')
            .asFunction<_dart_clang_codeCompleteGetContainerUSR>())(
      Results,
    );
  }

  _dart_clang_codeCompleteGetContainerUSR? _clang_codeCompleteGetContainerUSR;

  /// Returns the currently-entered selector for an Objective-C message
  /// send, formatted like "initWithFoo:bar:". Only guaranteed to return a
  /// non-empty string for CXCompletionContext_ObjCInstanceMessage and
  /// CXCompletionContext_ObjCClassMessage.
  ///
  /// \param Results the code completion results to query
  ///
  /// \returns the selector (or partial selector) that has been entered thus far
  /// for an Objective-C message send.
  CXString clang_codeCompleteGetObjCSelector(
    ffi.Pointer<CXCodeCompleteResults> Results,
  ) {
    return (_clang_codeCompleteGetObjCSelector ??=
        _lookup<ffi.NativeFunction<_c_clang_codeCompleteGetObjCSelector>>(
                'clang_codeCompleteGetObjCSelector')
            .asFunction<_dart_clang_codeCompleteGetObjCSelector>())(
      Results,
    );
  }

  _dart_clang_codeCompleteGetObjCSelector? _clang_codeCompleteGetObjCSelector;

  /// Return a version string, suitable for showing to a user, but not
  /// intended to be parsed (the format is not guaranteed to be stable).
  CXString clang_getClangVersion() {
    return (_clang_getClangVersion ??=
        _lookup<ffi.NativeFunction<_c_clang_getClangVersion>>(
                'clang_getClangVersion')
            .asFunction<_dart_clang_getClangVersion>())();
  }

  _dart_clang_getClangVersion? _clang_getClangVersion;

  /// Enable/disable crash recovery.
  ///
  /// \param isEnabled Flag to indicate if crash recovery is enabled.  A non-zero
  /// value enables crash recovery, while 0 disables it.
  void clang_toggleCrashRecovery(
    int isEnabled,
  ) {
    return (_clang_toggleCrashRecovery ??=
        _lookup<ffi.NativeFunction<_c_clang_toggleCrashRecovery>>(
                'clang_toggleCrashRecovery')
            .asFunction<_dart_clang_toggleCrashRecovery>())(
      isEnabled,
    );
  }

  _dart_clang_toggleCrashRecovery? _clang_toggleCrashRecovery;

  /// Visit the set of preprocessor inclusions in a translation unit.
  /// The visitor function is called with the provided data for every included
  /// file.  This does not include headers included by the PCH file (unless one
  /// is inspecting the inclusions in the PCH file itself).
  void clang_getInclusions(
    ffi.Pointer<CXTranslationUnitImpl> tu,
    ffi.Pointer<ffi.NativeFunction<CXInclusionVisitor>> visitor,
    ffi.Pointer<ffi.Void> client_data,
  ) {
    return (_clang_getInclusions ??=
        _lookup<ffi.NativeFunction<_c_clang_getInclusions>>(
                'clang_getInclusions')
            .asFunction<_dart_clang_getInclusions>())(
      tu,
      visitor,
      client_data,
    );
  }

  _dart_clang_getInclusions? _clang_getInclusions;

  /// If cursor is a statement declaration tries to evaluate the
  /// statement and if its variable, tries to evaluate its initializer,
  /// into its corresponding type.
  ffi.Pointer<ffi.Void> clang_Cursor_Evaluate(
    CXCursor C,
  ) {
    return (_clang_Cursor_Evaluate ??=
        _lookup<ffi.NativeFunction<_c_clang_Cursor_Evaluate>>(
                'clang_Cursor_Evaluate')
            .asFunction<_dart_clang_Cursor_Evaluate>())(
      C,
    );
  }

  _dart_clang_Cursor_Evaluate? _clang_Cursor_Evaluate;

  /// Returns the kind of the evaluated result.
  int clang_EvalResult_getKind(
    ffi.Pointer<ffi.Void> E,
  ) {
    return (_clang_EvalResult_getKind ??=
        _lookup<ffi.NativeFunction<_c_clang_EvalResult_getKind>>(
                'clang_EvalResult_getKind')
            .asFunction<_dart_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,
  ) {
    return (_clang_EvalResult_getAsInt ??=
        _lookup<ffi.NativeFunction<_c_clang_EvalResult_getAsInt>>(
                'clang_EvalResult_getAsInt')
            .asFunction<_dart_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,
  ) {
    return (_clang_EvalResult_getAsLongLong ??=
        _lookup<ffi.NativeFunction<_c_clang_EvalResult_getAsLongLong>>(
                'clang_EvalResult_getAsLongLong')
            .asFunction<_dart_clang_EvalResult_getAsLongLong>())(
      E,
    );
  }

  _dart_clang_EvalResult_getAsLongLong? _clang_EvalResult_getAsLongLong;

  /// Returns a non-zero value if the kind is Int and the evaluation
  /// result resulted in an unsigned integer.
  int clang_EvalResult_isUnsignedInt(
    ffi.Pointer<ffi.Void> E,
  ) {
    return (_clang_EvalResult_isUnsignedInt ??=
        _lookup<ffi.NativeFunction<_c_clang_EvalResult_isUnsignedInt>>(
                'clang_EvalResult_isUnsignedInt')
            .asFunction<_dart_clang_EvalResult_isUnsignedInt>())(
      E,
    );
  }

  _dart_clang_EvalResult_isUnsignedInt? _clang_EvalResult_isUnsignedInt;

  /// Returns the evaluation result as an unsigned integer if
  /// the kind is Int and clang_EvalResult_isUnsignedInt is non-zero.
  int clang_EvalResult_getAsUnsigned(
    ffi.Pointer<ffi.Void> E,
  ) {
    return (_clang_EvalResult_getAsUnsigned ??=
        _lookup<ffi.NativeFunction<_c_clang_EvalResult_getAsUnsigned>>(
                'clang_EvalResult_getAsUnsigned')
            .asFunction<_dart_clang_EvalResult_getAsUnsigned>())(
      E,
    );
  }

  _dart_clang_EvalResult_getAsUnsigned? _clang_EvalResult_getAsUnsigned;

  /// Returns the evaluation result as double if the
  /// kind is double.
  double clang_EvalResult_getAsDouble(
    ffi.Pointer<ffi.Void> E,
  ) {
    return (_clang_EvalResult_getAsDouble ??=
        _lookup<ffi.NativeFunction<_c_clang_EvalResult_getAsDouble>>(
                'clang_EvalResult_getAsDouble')
            .asFunction<_dart_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,
  ) {
    return (_clang_EvalResult_getAsStr ??=
        _lookup<ffi.NativeFunction<_c_clang_EvalResult_getAsStr>>(
                'clang_EvalResult_getAsStr')
            .asFunction<_dart_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,
  ) {
    return (_clang_EvalResult_dispose ??=
        _lookup<ffi.NativeFunction<_c_clang_EvalResult_dispose>>(
                'clang_EvalResult_dispose')
            .asFunction<_dart_clang_EvalResult_dispose>())(
      E,
    );
  }

  _dart_clang_EvalResult_dispose? _clang_EvalResult_dispose;

  /// Retrieve a remapping.
  ///
  /// \param path the path that contains metadata about remappings.
  ///
  /// \returns the requested remapping. This remapping must be freed
  /// via a call to \c clang_remap_dispose(). Can return NULL if an error occurred.
  ffi.Pointer<ffi.Void> clang_getRemappings(
    ffi.Pointer<ffi.Int8> path,
  ) {
    return (_clang_getRemappings ??=
        _lookup<ffi.NativeFunction<_c_clang_getRemappings>>(
                'clang_getRemappings')
            .asFunction<_dart_clang_getRemappings>())(
      path,
    );
  }

  _dart_clang_getRemappings? _clang_getRemappings;

  /// Retrieve a remapping.
  ///
  /// \param filePaths pointer to an array of file paths containing remapping info.
  ///
  /// \param numFiles number of file paths.
  ///
  /// \returns the requested remapping. This remapping must be freed
  /// via a call to \c clang_remap_dispose(). Can return NULL if an error occurred.
  ffi.Pointer<ffi.Void> clang_getRemappingsFromFileList(
    ffi.Pointer<ffi.Pointer<ffi.Int8>> filePaths,
    int numFiles,
  ) {
    return (_clang_getRemappingsFromFileList ??=
        _lookup<ffi.NativeFunction<_c_clang_getRemappingsFromFileList>>(
                'clang_getRemappingsFromFileList')
            .asFunction<_dart_clang_getRemappingsFromFileList>())(
      filePaths,
      numFiles,
    );
  }

  _dart_clang_getRemappingsFromFileList? _clang_getRemappingsFromFileList;

  /// Determine the number of remappings.
  int clang_remap_getNumFiles(
    ffi.Pointer<ffi.Void> arg0,
  ) {
    return (_clang_remap_getNumFiles ??=
        _lookup<ffi.NativeFunction<_c_clang_remap_getNumFiles>>(
                'clang_remap_getNumFiles')
            .asFunction<_dart_clang_remap_getNumFiles>())(
      arg0,
    );
  }

  _dart_clang_remap_getNumFiles? _clang_remap_getNumFiles;

  /// Get the original and the associated filename from the remapping.
  ///
  /// \param original If non-NULL, will be set to the original filename.
  ///
  /// \param transformed If non-NULL, will be set to the filename that the original
  /// is associated with.
  void clang_remap_getFilenames(
    ffi.Pointer<ffi.Void> arg0,
    int index,
    ffi.Pointer<CXString> original,
    ffi.Pointer<CXString> transformed,
  ) {
    return (_clang_remap_getFilenames ??=
        _lookup<ffi.NativeFunction<_c_clang_remap_getFilenames>>(
                'clang_remap_getFilenames')
            .asFunction<_dart_clang_remap_getFilenames>())(
      arg0,
      index,
      original,
      transformed,
    );
  }

  _dart_clang_remap_getFilenames? _clang_remap_getFilenames;

  /// Dispose the remapping.
  void clang_remap_dispose(
    ffi.Pointer<ffi.Void> arg0,
  ) {
    return (_clang_remap_dispose ??=
        _lookup<ffi.NativeFunction<_c_clang_remap_dispose>>(
                'clang_remap_dispose')
            .asFunction<_dart_clang_remap_dispose>())(
      arg0,
    );
  }

  _dart_clang_remap_dispose? _clang_remap_dispose;

  /// Find references of a declaration in a specific file.
  ///
  /// \param cursor pointing to a declaration or a reference of one.
  ///
  /// \param file to search for references.
  ///
  /// \param visitor callback that will receive pairs of CXCursor/CXSourceRange for
  /// each reference found.
  /// The CXSourceRange will point inside the file; if the reference is inside
  /// a macro (and not a macro argument) the CXSourceRange will be invalid.
  ///
  /// \returns one of the CXResult enumerators.
  int clang_findReferencesInFile(
    CXCursor cursor,
    ffi.Pointer<ffi.Void> file,
    CXCursorAndRangeVisitor visitor,
  ) {
    return (_clang_findReferencesInFile ??=
        _lookup<ffi.NativeFunction<_c_clang_findReferencesInFile>>(
                'clang_findReferencesInFile')
            .asFunction<_dart_clang_findReferencesInFile>())(
      cursor,
      file,
      visitor,
    );
  }

  _dart_clang_findReferencesInFile? _clang_findReferencesInFile;

  /// Find #import/#include directives in a specific file.
  ///
  /// \param TU translation unit containing the file to query.
  ///
  /// \param file to search for #import/#include directives.
  ///
  /// \param visitor callback that will receive pairs of CXCursor/CXSourceRange for
  /// each directive found.
  ///
  /// \returns one of the CXResult enumerators.
  int clang_findIncludesInFile(
    ffi.Pointer<CXTranslationUnitImpl> TU,
    ffi.Pointer<ffi.Void> file,
    CXCursorAndRangeVisitor visitor,
  ) {
    return (_clang_findIncludesInFile ??=
        _lookup<ffi.NativeFunction<_c_clang_findIncludesInFile>>(
                'clang_findIncludesInFile')
            .asFunction<_dart_clang_findIncludesInFile>())(
      TU,
      file,
      visitor,
    );
  }

  _dart_clang_findIncludesInFile? _clang_findIncludesInFile;

  int clang_index_isEntityObjCContainerKind(
    int arg0,
  ) {
    return (_clang_index_isEntityObjCContainerKind ??=
        _lookup<ffi.NativeFunction<_c_clang_index_isEntityObjCContainerKind>>(
                'clang_index_isEntityObjCContainerKind')
            .asFunction<_dart_clang_index_isEntityObjCContainerKind>())(
      arg0,
    );
  }

  _dart_clang_index_isEntityObjCContainerKind?
      _clang_index_isEntityObjCContainerKind;

  ffi.Pointer<CXIdxObjCContainerDeclInfo> clang_index_getObjCContainerDeclInfo(
    ffi.Pointer<CXIdxDeclInfo> arg0,
  ) {
    return (_clang_index_getObjCContainerDeclInfo ??=
        _lookup<ffi.NativeFunction<_c_clang_index_getObjCContainerDeclInfo>>(
                'clang_index_getObjCContainerDeclInfo')
            .asFunction<_dart_clang_index_getObjCContainerDeclInfo>())(
      arg0,
    );
  }

  _dart_clang_index_getObjCContainerDeclInfo?
      _clang_index_getObjCContainerDeclInfo;

  ffi.Pointer<CXIdxObjCInterfaceDeclInfo> clang_index_getObjCInterfaceDeclInfo(
    ffi.Pointer<CXIdxDeclInfo> arg0,
  ) {
    return (_clang_index_getObjCInterfaceDeclInfo ??=
        _lookup<ffi.NativeFunction<_c_clang_index_getObjCInterfaceDeclInfo>>(
                'clang_index_getObjCInterfaceDeclInfo')
            .asFunction<_dart_clang_index_getObjCInterfaceDeclInfo>())(
      arg0,
    );
  }

  _dart_clang_index_getObjCInterfaceDeclInfo?
      _clang_index_getObjCInterfaceDeclInfo;

  ffi.Pointer<CXIdxObjCCategoryDeclInfo> clang_index_getObjCCategoryDeclInfo(
    ffi.Pointer<CXIdxDeclInfo> arg0,
  ) {
    return (_clang_index_getObjCCategoryDeclInfo ??=
        _lookup<ffi.NativeFunction<_c_clang_index_getObjCCategoryDeclInfo>>(
                'clang_index_getObjCCategoryDeclInfo')
            .asFunction<_dart_clang_index_getObjCCategoryDeclInfo>())(
      arg0,
    );
  }

  _dart_clang_index_getObjCCategoryDeclInfo?
      _clang_index_getObjCCategoryDeclInfo;

  ffi.Pointer<CXIdxObjCProtocolRefListInfo>
      clang_index_getObjCProtocolRefListInfo(
    ffi.Pointer<CXIdxDeclInfo> arg0,
  ) {
    return (_clang_index_getObjCProtocolRefListInfo ??=
        _lookup<ffi.NativeFunction<_c_clang_index_getObjCProtocolRefListInfo>>(
                'clang_index_getObjCProtocolRefListInfo')
            .asFunction<_dart_clang_index_getObjCProtocolRefListInfo>())(
      arg0,
    );
  }

  _dart_clang_index_getObjCProtocolRefListInfo?
      _clang_index_getObjCProtocolRefListInfo;

  ffi.Pointer<CXIdxObjCPropertyDeclInfo> clang_index_getObjCPropertyDeclInfo(
    ffi.Pointer<CXIdxDeclInfo> arg0,
  ) {
    return (_clang_index_getObjCPropertyDeclInfo ??=
        _lookup<ffi.NativeFunction<_c_clang_index_getObjCPropertyDeclInfo>>(
                'clang_index_getObjCPropertyDeclInfo')
            .asFunction<_dart_clang_index_getObjCPropertyDeclInfo>())(
      arg0,
    );
  }

  _dart_clang_index_getObjCPropertyDeclInfo?
      _clang_index_getObjCPropertyDeclInfo;

  ffi.Pointer<CXIdxIBOutletCollectionAttrInfo>
      clang_index_getIBOutletCollectionAttrInfo(
    ffi.Pointer<CXIdxAttrInfo> arg0,
  ) {
    return (_clang_index_getIBOutletCollectionAttrInfo ??= _lookup<
                ffi.NativeFunction<
                    _c_clang_index_getIBOutletCollectionAttrInfo>>(
            'clang_index_getIBOutletCollectionAttrInfo')
        .asFunction<_dart_clang_index_getIBOutletCollectionAttrInfo>())(
      arg0,
    );
  }

  _dart_clang_index_getIBOutletCollectionAttrInfo?
      _clang_index_getIBOutletCollectionAttrInfo;

  ffi.Pointer<CXIdxCXXClassDeclInfo> clang_index_getCXXClassDeclInfo(
    ffi.Pointer<CXIdxDeclInfo> arg0,
  ) {
    return (_clang_index_getCXXClassDeclInfo ??=
        _lookup<ffi.NativeFunction<_c_clang_index_getCXXClassDeclInfo>>(
                'clang_index_getCXXClassDeclInfo')
            .asFunction<_dart_clang_index_getCXXClassDeclInfo>())(
      arg0,
    );
  }

  _dart_clang_index_getCXXClassDeclInfo? _clang_index_getCXXClassDeclInfo;

  /// For retrieving a custom CXIdxClientContainer attached to a
  /// container.
  ffi.Pointer<ffi.Void> clang_index_getClientContainer(
    ffi.Pointer<CXIdxContainerInfo> arg0,
  ) {
    return (_clang_index_getClientContainer ??=
        _lookup<ffi.NativeFunction<_c_clang_index_getClientContainer>>(
                'clang_index_getClientContainer')
            .asFunction<_dart_clang_index_getClientContainer>())(
      arg0,
    );
  }

  _dart_clang_index_getClientContainer? _clang_index_getClientContainer;

  /// For setting a custom CXIdxClientContainer attached to a
  /// container.
  void clang_index_setClientContainer(
    ffi.Pointer<CXIdxContainerInfo> arg0,
    ffi.Pointer<ffi.Void> arg1,
  ) {
    return (_clang_index_setClientContainer ??=
        _lookup<ffi.NativeFunction<_c_clang_index_setClientContainer>>(
                'clang_index_setClientContainer')
            .asFunction<_dart_clang_index_setClientContainer>())(
      arg0,
      arg1,
    );
  }

  _dart_clang_index_setClientContainer? _clang_index_setClientContainer;

  /// For retrieving a custom CXIdxClientEntity attached to an entity.
  ffi.Pointer<ffi.Void> clang_index_getClientEntity(
    ffi.Pointer<CXIdxEntityInfo> arg0,
  ) {
    return (_clang_index_getClientEntity ??=
        _lookup<ffi.NativeFunction<_c_clang_index_getClientEntity>>(
                'clang_index_getClientEntity')
            .asFunction<_dart_clang_index_getClientEntity>())(
      arg0,
    );
  }

  _dart_clang_index_getClientEntity? _clang_index_getClientEntity;

  /// For setting a custom CXIdxClientEntity attached to an entity.
  void clang_index_setClientEntity(
    ffi.Pointer<CXIdxEntityInfo> arg0,
    ffi.Pointer<ffi.Void> arg1,
  ) {
    return (_clang_index_setClientEntity ??=
        _lookup<ffi.NativeFunction<_c_clang_index_setClientEntity>>(
                'clang_index_setClientEntity')
            .asFunction<_dart_clang_index_setClientEntity>())(
      arg0,
      arg1,
    );
  }

  _dart_clang_index_setClientEntity? _clang_index_setClientEntity;

  /// An indexing action/session, to be applied to one or multiple
  /// translation units.
  ///
  /// \param CIdx The index object with which the index action will be associated.
  ffi.Pointer<ffi.Void> clang_IndexAction_create(
    ffi.Pointer<ffi.Void> CIdx,
  ) {
    return (_clang_IndexAction_create ??=
        _lookup<ffi.NativeFunction<_c_clang_IndexAction_create>>(
                'clang_IndexAction_create')
            .asFunction<_dart_clang_IndexAction_create>())(
      CIdx,
    );
  }

  _dart_clang_IndexAction_create? _clang_IndexAction_create;

  /// Destroy the given index action.
  ///
  /// The index action must not be destroyed until all of the translation units
  /// created within that index action have been destroyed.
  void clang_IndexAction_dispose(
    ffi.Pointer<ffi.Void> arg0,
  ) {
    return (_clang_IndexAction_dispose ??=
        _lookup<ffi.NativeFunction<_c_clang_IndexAction_dispose>>(
                'clang_IndexAction_dispose')
            .asFunction<_dart_clang_IndexAction_dispose>())(
      arg0,
    );
  }

  _dart_clang_IndexAction_dispose? _clang_IndexAction_dispose;

  /// Index the given source file and the translation unit corresponding
  /// to that file via callbacks implemented through #IndexerCallbacks.
  ///
  /// \param client_data pointer data supplied by the client, which will
  /// be passed to the invoked callbacks.
  ///
  /// \param index_callbacks Pointer to indexing callbacks that the client
  /// implements.
  ///
  /// \param index_callbacks_size Size of #IndexerCallbacks structure that gets
  /// passed in index_callbacks.
  ///
  /// \param index_options A bitmask of options that affects how indexing is
  /// performed. This should be a bitwise OR of the CXIndexOpt_XXX flags.
  ///
  /// \param[out] out_TU pointer to store a \c CXTranslationUnit that can be
  /// reused after indexing is finished. Set to \c NULL if you do not require it.
  ///
  /// \returns 0 on success or if there were errors from which the compiler could
  /// recover.  If there is a failure from which there is no recovery, returns
  /// a non-zero \c CXErrorCode.
  ///
  /// The rest of the parameters are the same as #clang_parseTranslationUnit.
  int clang_indexSourceFile(
    ffi.Pointer<ffi.Void> arg0,
    ffi.Pointer<ffi.Void> client_data,
    ffi.Pointer<IndexerCallbacks> index_callbacks,
    int index_callbacks_size,
    int index_options,
    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,
    ffi.Pointer<ffi.Pointer<CXTranslationUnitImpl>> out_TU,
    int TU_options,
  ) {
    return (_clang_indexSourceFile ??=
        _lookup<ffi.NativeFunction<_c_clang_indexSourceFile>>(
                'clang_indexSourceFile')
            .asFunction<_dart_clang_indexSourceFile>())(
      arg0,
      client_data,
      index_callbacks,
      index_callbacks_size,
      index_options,
      source_filename,
      command_line_args,
      num_command_line_args,
      unsaved_files,
      num_unsaved_files,
      out_TU,
      TU_options,
    );
  }

  _dart_clang_indexSourceFile? _clang_indexSourceFile;

  /// Same as clang_indexSourceFile but requires a full command line
  /// for \c command_line_args including argv[0]. This is useful if the standard
  /// library paths are relative to the binary.
  int clang_indexSourceFileFullArgv(
    ffi.Pointer<ffi.Void> arg0,
    ffi.Pointer<ffi.Void> client_data,
    ffi.Pointer<IndexerCallbacks> index_callbacks,
    int index_callbacks_size,
    int index_options,
    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,
    ffi.Pointer<ffi.Pointer<CXTranslationUnitImpl>> out_TU,
    int TU_options,
  ) {
    return (_clang_indexSourceFileFullArgv ??=
        _lookup<ffi.NativeFunction<_c_clang_indexSourceFileFullArgv>>(
                'clang_indexSourceFileFullArgv')
            .asFunction<_dart_clang_indexSourceFileFullArgv>())(
      arg0,
      client_data,
      index_callbacks,
      index_callbacks_size,
      index_options,
      source_filename,
      command_line_args,
      num_command_line_args,
      unsaved_files,
      num_unsaved_files,
      out_TU,
      TU_options,
    );
  }

  _dart_clang_indexSourceFileFullArgv? _clang_indexSourceFileFullArgv;

  /// Index the given translation unit via callbacks implemented through
  /// #IndexerCallbacks.
  ///
  /// The order of callback invocations is not guaranteed to be the same as
  /// when indexing a source file. The high level order will be:
  ///
  /// -Preprocessor callbacks invocations
  /// -Declaration/reference callbacks invocations
  /// -Diagnostic callback invocations
  ///
  /// The parameters are the same as #clang_indexSourceFile.
  ///
  /// \returns If there is a failure from which there is no recovery, returns
  /// non-zero, otherwise returns 0.
  int clang_indexTranslationUnit(
    ffi.Pointer<ffi.Void> arg0,
    ffi.Pointer<ffi.Void> client_data,
    ffi.Pointer<IndexerCallbacks> index_callbacks,
    int index_callbacks_size,
    int index_options,
    ffi.Pointer<CXTranslationUnitImpl> arg5,
  ) {
    return (_clang_indexTranslationUnit ??=
        _lookup<ffi.NativeFunction<_c_clang_indexTranslationUnit>>(
                'clang_indexTranslationUnit')
            .asFunction<_dart_clang_indexTranslationUnit>())(
      arg0,
      client_data,
      index_callbacks,
      index_callbacks_size,
      index_options,
      arg5,
    );
  }

  _dart_clang_indexTranslationUnit? _clang_indexTranslationUnit;

  /// Retrieve the CXIdxFile, file, line, column, and offset represented by
  /// the given CXIdxLoc.
  ///
  /// If the location refers into a macro expansion, retrieves the
  /// location of the macro expansion and if it refers into a macro argument
  /// retrieves the location of the argument.
  void clang_indexLoc_getFileLocation(
    CXIdxLoc loc,
    ffi.Pointer<ffi.Pointer<ffi.Void>> indexFile,
    ffi.Pointer<ffi.Pointer<ffi.Void>> file,
    ffi.Pointer<ffi.Uint32> line,
    ffi.Pointer<ffi.Uint32> column,
    ffi.Pointer<ffi.Uint32> offset,
  ) {
    return (_clang_indexLoc_getFileLocation ??=
        _lookup<ffi.NativeFunction<_c_clang_indexLoc_getFileLocation>>(
                'clang_indexLoc_getFileLocation')
            .asFunction<_dart_clang_indexLoc_getFileLocation>())(
      loc,
      indexFile,
      file,
      line,
      column,
      offset,
    );
  }

  _dart_clang_indexLoc_getFileLocation? _clang_indexLoc_getFileLocation;

  /// Retrieve the CXSourceLocation represented by the given CXIdxLoc.
  CXSourceLocation clang_indexLoc_getCXSourceLocation(
    CXIdxLoc loc,
  ) {
    return (_clang_indexLoc_getCXSourceLocation ??=
        _lookup<ffi.NativeFunction<_c_clang_indexLoc_getCXSourceLocation>>(
                'clang_indexLoc_getCXSourceLocation')
            .asFunction<_dart_clang_indexLoc_getCXSourceLocation>())(
      loc,
    );
  }

  _dart_clang_indexLoc_getCXSourceLocation? _clang_indexLoc_getCXSourceLocation;

  /// Visit the fields of a particular type.
  ///
  /// This function visits all the direct fields of the given cursor,
  /// invoking the given \p visitor function with the cursors of each
  /// visited field. The traversal may be ended prematurely, if
  /// the visitor returns \c CXFieldVisit_Break.
  ///
  /// \param T the record type whose field may be visited.
  ///
  /// \param visitor the visitor function that will be invoked for each
  /// field of \p T.
  ///
  /// \param client_data pointer data supplied by the client, which will
  /// be passed to the visitor each time it is invoked.
  ///
  /// \returns a non-zero value if the traversal was terminated
  /// prematurely by the visitor returning \c CXFieldVisit_Break.
  int clang_Type_visitFields(
    CXType T,
    ffi.Pointer<ffi.NativeFunction<CXFieldVisitor>> visitor,
    ffi.Pointer<ffi.Void> client_data,
  ) {
    return (_clang_Type_visitFields ??=
        _lookup<ffi.NativeFunction<_c_clang_Type_visitFields>>(
                'clang_Type_visitFields')
            .asFunction<_dart_clang_Type_visitFields>())(
      T,
      visitor,
      client_data,
    );
  }

  _dart_clang_Type_visitFields? _clang_Type_visitFields;
}

/// 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 {
  external ffi.Pointer<ffi.Void> data;

  @ffi.Uint32()
  external int private_flags;
}

class CXStringSet extends ffi.Struct {
  external ffi.Pointer<CXString> Strings;

  @ffi.Uint32()
  external int Count;
}

class CXTargetInfoImpl extends ffi.Opaque {}

class CXTranslationUnitImpl extends ffi.Opaque {}

/// 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.
  external ffi.Pointer<ffi.Int8> Filename;

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

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

/// Describes a version number of the form major.minor.subminor.
class CXVersion extends ffi.Struct {
  /// The major version number, e.g., the '10' in '10.7.3'. A negative
  /// value indicates that there is no version number at all.
  @ffi.Int32()
  external int Major;

  /// The minor version number, e.g., the '7' in '10.7.3'. This value
  /// will be negative if no minor version number was provided, e.g., for
  /// version '10'.
  @ffi.Int32()
  external int Minor;

  /// The subminor version number, e.g., the '3' in '10.7.3'. This value
  /// will be negative if no minor or subminor version number was provided,
  /// e.g., in version '10' or '10.7'.
  @ffi.Int32()
  external int Subminor;
}

abstract class CXGlobalOptFlags {
  /// Used to indicate that no special CXIndex options are needed.
  static const int CXGlobalOpt_None = 0;

  /// Used to indicate that threads that libclang creates for indexing
  /// purposes should use background priority.
  ///
  /// Affects #clang_indexSourceFile, #clang_indexTranslationUnit,
  /// #clang_parseTranslationUnit, #clang_saveTranslationUnit.
  static const int CXGlobalOpt_ThreadBackgroundPriorityForIndexing = 1;

  /// Used to indicate that threads that libclang creates for editing
  /// purposes should use background priority.
  ///
  /// Affects #clang_reparseTranslationUnit, #clang_codeCompleteAt,
  /// #clang_annotateTokens
  static const int CXGlobalOpt_ThreadBackgroundPriorityForEditing = 2;

  /// Used to indicate that all threads that libclang creates should use
  /// background priority.
  static const int CXGlobalOpt_ThreadBackgroundPriorityForAll = 3;
}

/// Uniquely identifies a CXFile, that refers to the same underlying file,
/// across an indexing session.
class CXFileUniqueID extends ffi.Struct {
  @ffi.Uint64()
  external int _unique_data_item_0;
  @ffi.Uint64()
  external int _unique_data_item_1;
  @ffi.Uint64()
  external int _unique_data_item_2;

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

/// Helper for array `data` in struct `CXFileUniqueID`.
class ArrayHelper_CXFileUniqueID_data_level0 {
  final CXFileUniqueID _struct;
  final List<int> dimensions;
  final int level;
  final int _absoluteIndex;
  int get length => dimensions[level];
  ArrayHelper_CXFileUniqueID_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.');
    }
  }

  int 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, int 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.');
    }
  }
}

/// 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 {
  external ffi.Pointer<ffi.Void> _unique_ptr_data_item_0;
  external 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()
  external 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 {
  external ffi.Pointer<ffi.Void> _unique_ptr_data_item_0;
  external 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()
  external int begin_int_data;

  @ffi.Uint32()
  external 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.');
    }
  }
}

/// Identifies an array of ranges.
class CXSourceRangeList extends ffi.Struct {
  /// The number of ranges in the \c ranges array.
  @ffi.Uint32()
  external int count;

  /// An array of \c CXSourceRanges.
  external ffi.Pointer<CXSourceRange> ranges;
}

class CXTUResourceUsageEntry extends ffi.Struct {
  @ffi.Int32()
  external int kind;

  @ffi.Uint64()
  external int amount;
}

/// The memory usage of a CXTranslationUnit, broken into categories.
class CXTUResourceUsage extends ffi.Struct {
  external ffi.Pointer<ffi.Void> data;

  @ffi.Uint32()
  external int numEntries;

  external ffi.Pointer<CXTUResourceUsageEntry> entries;
}

/// 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()
  external int kind;

  @ffi.Int32()
  external int xdata;

  external ffi.Pointer<ffi.Void> _unique_data_item_0;
  external ffi.Pointer<ffi.Void> _unique_data_item_1;
  external 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 availability of a given entity on a particular platform, e.g.,
/// a particular class might only be available on Mac OS 10.7 or newer.
class CXPlatformAvailability extends ffi.Struct {
  /// A string that describes the platform for which this structure
  /// provides availability information.
  ///
  /// Possible values are "ios" or "macos".
  external CXString Platform;

  /// The version number in which this entity was introduced.
  external CXVersion Introduced;

  /// The version number in which this entity was deprecated (but is
  /// still available).
  external CXVersion Deprecated;

  /// The version number in which this entity was obsoleted, and therefore
  /// is no longer available.
  external CXVersion Obsoleted;

  /// Whether the entity is unconditionally unavailable on this platform.
  @ffi.Int32()
  external int Unavailable;

  /// An optional message to provide to a user of this API, e.g., to
  /// suggest replacement APIs.
  external CXString Message;
}

class CXCursorSetImpl extends ffi.Opaque {}

/// 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()
  external int kind;

  external ffi.Pointer<ffi.Void> _unique_data_item_0;
  external 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 a single preprocessing token.
class CXToken extends ffi.Struct {
  @ffi.Uint32()
  external int _unique_int_data_item_0;
  @ffi.Uint32()
  external int _unique_int_data_item_1;
  @ffi.Uint32()
  external int _unique_int_data_item_2;
  @ffi.Uint32()
  external int _unique_int_data_item_3;

  /// Helper for array `int_data`.
  ArrayHelper_CXToken_int_data_level0 get int_data =>
      ArrayHelper_CXToken_int_data_level0(this, [4], 0, 0);
  external ffi.Pointer<ffi.Void> ptr_data;
}

/// Helper for array `int_data` in struct `CXToken`.
class ArrayHelper_CXToken_int_data_level0 {
  final CXToken _struct;
  final List<int> dimensions;
  final int level;
  final int _absoluteIndex;
  int get length => dimensions[level];
  ArrayHelper_CXToken_int_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.');
    }
  }

  int operator [](int index) {
    _checkBounds(index);
    switch (_absoluteIndex + index) {
      case 0:
        return _struct._unique_int_data_item_0;
      case 1:
        return _struct._unique_int_data_item_1;
      case 2:
        return _struct._unique_int_data_item_2;
      case 3:
        return _struct._unique_int_data_item_3;
      default:
        throw Exception('Invalid Array Helper generated.');
    }
  }

  void operator []=(int index, int value) {
    _checkBounds(index);
    switch (_absoluteIndex + index) {
      case 0:
        _struct._unique_int_data_item_0 = value;
        break;
      case 1:
        _struct._unique_int_data_item_1 = value;
        break;
      case 2:
        _struct._unique_int_data_item_2 = value;
        break;
      case 3:
        _struct._unique_int_data_item_3 = value;
        break;
      default:
        throw Exception('Invalid Array Helper generated.');
    }
  }
}

/// A single result of code completion.
class CXCompletionResult extends ffi.Struct {
  /// The kind of entity that this completion refers to.
  ///
  /// The cursor kind will be a macro, keyword, or a declaration (one of the
  /// *Decl cursor kinds), describing the entity that the completion is
  /// referring to.
  ///
  /// \todo In the future, we would like to provide a full cursor, to allow
  /// the client to extract additional information from declaration.
  @ffi.Int32()
  external int CursorKind;

  /// The code-completion string that describes how to insert this
  /// code-completion result into the editing buffer.
  external ffi.Pointer<ffi.Void> CompletionString;
}

/// Contains the results of code-completion.
///
/// This data structure contains the results of code completion, as
/// produced by \c clang_codeCompleteAt(). Its contents must be freed by
/// \c clang_disposeCodeCompleteResults.
class CXCodeCompleteResults extends ffi.Struct {
  /// The code-completion results.
  external ffi.Pointer<CXCompletionResult> Results;

  /// The number of code-completion results stored in the
  /// \c Results array.
  @ffi.Uint32()
  external int NumResults;
}

class CXCursorAndRangeVisitor extends ffi.Struct {
  external ffi.Pointer<ffi.Void> context;

  external ffi.Pointer<ffi.NativeFunction<_typedefC_2>> visit;
}

/// Source location passed to index callbacks.
class CXIdxLoc extends ffi.Struct {
  external ffi.Pointer<ffi.Void> _unique_ptr_data_item_0;
  external ffi.Pointer<ffi.Void> _unique_ptr_data_item_1;

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

/// Helper for array `ptr_data` in struct `CXIdxLoc`.
class ArrayHelper_CXIdxLoc_ptr_data_level0 {
  final CXIdxLoc _struct;
  final List<int> dimensions;
  final int level;
  final int _absoluteIndex;
  int get length => dimensions[level];
  ArrayHelper_CXIdxLoc_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.');
    }
  }
}

/// Data for ppIncludedFile callback.
class CXIdxIncludedFileInfo extends ffi.Struct {
  /// Location of '#' in the \#include/\#import directive.
  external CXIdxLoc hashLoc;

  /// Filename as written in the \#include/\#import directive.
  external ffi.Pointer<ffi.Int8> filename;

  /// The actual file that the \#include/\#import directive resolved to.
  external ffi.Pointer<ffi.Void> file;

  @ffi.Int32()
  external int isImport;

  @ffi.Int32()
  external int isAngled;

  /// Non-zero if the directive was automatically turned into a module
  /// import.
  @ffi.Int32()
  external int isModuleImport;
}

/// Data for IndexerCallbacks#importedASTFile.
class CXIdxImportedASTFileInfo extends ffi.Struct {
  /// Top level AST file containing the imported PCH, module or submodule.
  external ffi.Pointer<ffi.Void> file;

  /// The imported module or NULL if the AST file is a PCH.
  external ffi.Pointer<ffi.Void> module;

  /// Location where the file is imported. Applicable only for modules.
  external CXIdxLoc loc;

  /// Non-zero if an inclusion directive was automatically turned into
  /// a module import. Applicable only for modules.
  @ffi.Int32()
  external int isImplicit;
}

class CXIdxAttrInfo extends ffi.Struct {
  @ffi.Int32()
  external int kind;

  external CXCursor cursor;

  external CXIdxLoc loc;
}

class CXIdxEntityInfo extends ffi.Struct {
  @ffi.Int32()
  external int kind;

  @ffi.Int32()
  external int templateKind;

  @ffi.Int32()
  external int lang;

  external ffi.Pointer<ffi.Int8> name;

  external ffi.Pointer<ffi.Int8> USR;

  external CXCursor cursor;

  external ffi.Pointer<ffi.Pointer<CXIdxAttrInfo>> attributes;

  @ffi.Uint32()
  external int numAttributes;
}

class CXIdxContainerInfo extends ffi.Struct {
  external CXCursor cursor;
}

class CXIdxIBOutletCollectionAttrInfo extends ffi.Struct {
  external ffi.Pointer<CXIdxAttrInfo> attrInfo;

  external ffi.Pointer<CXIdxEntityInfo> objcClass;

  external CXCursor classCursor;

  external CXIdxLoc classLoc;
}

class CXIdxDeclInfo extends ffi.Struct {
  external ffi.Pointer<CXIdxEntityInfo> entityInfo;

  external CXCursor cursor;

  external CXIdxLoc loc;

  external ffi.Pointer<CXIdxContainerInfo> semanticContainer;

  /// Generally same as #semanticContainer but can be different in
  /// cases like out-of-line C++ member functions.
  external ffi.Pointer<CXIdxContainerInfo> lexicalContainer;

  @ffi.Int32()
  external int isRedeclaration;

  @ffi.Int32()
  external int isDefinition;

  @ffi.Int32()
  external int isContainer;

  external ffi.Pointer<CXIdxContainerInfo> declAsContainer;

  /// Whether the declaration exists in code or was created implicitly
  /// by the compiler, e.g. implicit Objective-C methods for properties.
  @ffi.Int32()
  external int isImplicit;

  external ffi.Pointer<ffi.Pointer<CXIdxAttrInfo>> attributes;

  @ffi.Uint32()
  external int numAttributes;

  @ffi.Uint32()
  external int flags;
}

class CXIdxObjCContainerDeclInfo extends ffi.Struct {
  external ffi.Pointer<CXIdxDeclInfo> declInfo;

  @ffi.Int32()
  external int kind;
}

class CXIdxBaseClassInfo extends ffi.Struct {
  external ffi.Pointer<CXIdxEntityInfo> base;

  external CXCursor cursor;

  external CXIdxLoc loc;
}

class CXIdxObjCProtocolRefInfo extends ffi.Struct {
  external ffi.Pointer<CXIdxEntityInfo> protocol;

  external CXCursor cursor;

  external CXIdxLoc loc;
}

class CXIdxObjCProtocolRefListInfo extends ffi.Struct {
  external ffi.Pointer<ffi.Pointer<CXIdxObjCProtocolRefInfo>> protocols;

  @ffi.Uint32()
  external int numProtocols;
}

class CXIdxObjCInterfaceDeclInfo extends ffi.Struct {
  external ffi.Pointer<CXIdxObjCContainerDeclInfo> containerInfo;

  external ffi.Pointer<CXIdxBaseClassInfo> superInfo;

  external ffi.Pointer<CXIdxObjCProtocolRefListInfo> protocols;
}

class CXIdxObjCCategoryDeclInfo extends ffi.Struct {
  external ffi.Pointer<CXIdxObjCContainerDeclInfo> containerInfo;

  external ffi.Pointer<CXIdxEntityInfo> objcClass;

  external CXCursor classCursor;

  external CXIdxLoc classLoc;

  external ffi.Pointer<CXIdxObjCProtocolRefListInfo> protocols;
}

class CXIdxObjCPropertyDeclInfo extends ffi.Struct {
  external ffi.Pointer<CXIdxDeclInfo> declInfo;

  external ffi.Pointer<CXIdxEntityInfo> getter;

  external ffi.Pointer<CXIdxEntityInfo> setter;
}

class CXIdxCXXClassDeclInfo extends ffi.Struct {
  external ffi.Pointer<CXIdxDeclInfo> declInfo;

  external ffi.Pointer<ffi.Pointer<CXIdxBaseClassInfo>> bases;

  @ffi.Uint32()
  external int numBases;
}

/// Data for IndexerCallbacks#indexEntityReference.
class CXIdxEntityRefInfo extends ffi.Struct {
  @ffi.Int32()
  external int kind;

  /// Reference cursor.
  external CXCursor cursor;

  external CXIdxLoc loc;

  /// The entity that gets referenced.
  external ffi.Pointer<CXIdxEntityInfo> referencedEntity;

  /// Immediate "parent" of the reference. For example:
  ///
  /// \code
  /// Foo *var;
  /// \endcode
  ///
  /// The parent of reference of type 'Foo' is the variable 'var'.
  /// For references inside statement bodies of functions/methods,
  /// the parentEntity will be the function/method.
  external ffi.Pointer<CXIdxEntityInfo> parentEntity;

  /// Lexical container context of the reference.
  external ffi.Pointer<CXIdxContainerInfo> container;

  /// Sets of symbol roles of the reference.
  @ffi.Int32()
  external int role;
}

/// A group of callbacks used by #clang_indexSourceFile and
/// #clang_indexTranslationUnit.
class IndexerCallbacks extends ffi.Struct {
  /// Called periodically to check whether indexing should be aborted.
  /// Should return 0 to continue, and non-zero to abort.
  external ffi.Pointer<ffi.NativeFunction<_typedefC_3>> abortQuery;

  /// Called at the end of indexing; passes the complete diagnostic set.
  external ffi.Pointer<ffi.NativeFunction<_typedefC_4>> diagnostic;

  external ffi.Pointer<ffi.NativeFunction<_typedefC_5>> enteredMainFile;

  /// Called when a file gets \#included/\#imported.
  external ffi.Pointer<ffi.NativeFunction<_typedefC_6>> ppIncludedFile;

  /// Called when a AST file (PCH or module) gets imported.
  ///
  /// AST files will not get indexed (there will not be callbacks to index all
  /// the entities in an AST file). The recommended action is that, if the AST
  /// file is not already indexed, to initiate a new indexing job specific to
  /// the AST file.
  external ffi.Pointer<ffi.NativeFunction<_typedefC_7>> importedASTFile;

  /// Called at the beginning of indexing a translation unit.
  external ffi.Pointer<ffi.NativeFunction<_typedefC_8>> startedTranslationUnit;

  external ffi.Pointer<ffi.NativeFunction<_typedefC_9>> indexDeclaration;

  /// Called to index a reference of an entity.
  external ffi.Pointer<ffi.NativeFunction<_typedefC_10>> indexEntityReference;
}

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_getCString = ffi.Pointer<ffi.Int8> Function(
  CXString string,
);

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

typedef _c_clang_disposeString = ffi.Void Function(
  CXString string,
);

typedef _dart_clang_disposeString = void Function(
  CXString string,
);

typedef _c_clang_disposeStringSet = ffi.Void Function(
  ffi.Pointer<CXStringSet> set_1,
);

typedef _dart_clang_disposeStringSet = void Function(
  ffi.Pointer<CXStringSet> set_1,
);

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_CXIndex_setGlobalOptions = ffi.Void Function(
  ffi.Pointer<ffi.Void> arg0,
  ffi.Uint32 options,
);

typedef _dart_clang_CXIndex_setGlobalOptions = void Function(
  ffi.Pointer<ffi.Void> arg0,
  int options,
);

typedef _c_clang_CXIndex_getGlobalOptions = ffi.Uint32 Function(
  ffi.Pointer<ffi.Void> arg0,
);

typedef _dart_clang_CXIndex_getGlobalOptions = int Function(
  ffi.Pointer<ffi.Void> arg0,
);

typedef _c_clang_CXIndex_setInvocationEmissionPathOption = ffi.Void Function(
  ffi.Pointer<ffi.Void> arg0,
  ffi.Pointer<ffi.Int8> Path,
);

typedef _dart_clang_CXIndex_setInvocationEmissionPathOption = void Function(
  ffi.Pointer<ffi.Void> arg0,
  ffi.Pointer<ffi.Int8> Path,
);

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

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

typedef _c_clang_getFileTime = ffi.Int64 Function(
  ffi.Pointer<ffi.Void> SFile,
);

typedef _dart_clang_getFileTime = int Function(
  ffi.Pointer<ffi.Void> SFile,
);

typedef _c_clang_getFileUniqueID = ffi.Int32 Function(
  ffi.Pointer<ffi.Void> file,
  ffi.Pointer<CXFileUniqueID> outID,
);

typedef _dart_clang_getFileUniqueID = int Function(
  ffi.Pointer<ffi.Void> file,
  ffi.Pointer<CXFileUniqueID> outID,
);

typedef _c_clang_isFileMultipleIncludeGuarded = ffi.Uint32 Function(
  ffi.Pointer<CXTranslationUnitImpl> tu,
  ffi.Pointer<ffi.Void> file,
);

typedef _dart_clang_isFileMultipleIncludeGuarded = int Function(
  ffi.Pointer<CXTranslationUnitImpl> tu,
  ffi.Pointer<ffi.Void> file,
);

typedef _c_clang_getFile = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<CXTranslationUnitImpl> tu,
  ffi.Pointer<ffi.Int8> file_name,
);

typedef _dart_clang_getFile = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<CXTranslationUnitImpl> tu,
  ffi.Pointer<ffi.Int8> file_name,
);

typedef _c_clang_getFileContents = ffi.Pointer<ffi.Int8> Function(
  ffi.Pointer<CXTranslationUnitImpl> tu,
  ffi.Pointer<ffi.Void> file,
  ffi.Pointer<ffi.Uint64> size,
);

typedef _dart_clang_getFileContents = ffi.Pointer<ffi.Int8> Function(
  ffi.Pointer<CXTranslationUnitImpl> tu,
  ffi.Pointer<ffi.Void> file,
  ffi.Pointer<ffi.Uint64> size,
);

typedef _c_clang_File_isEqual = ffi.Int32 Function(
  ffi.Pointer<ffi.Void> file1,
  ffi.Pointer<ffi.Void> file2,
);

typedef _dart_clang_File_isEqual = int Function(
  ffi.Pointer<ffi.Void> file1,
  ffi.Pointer<ffi.Void> file2,
);

typedef _c_clang_File_tryGetRealPathName = CXString Function(
  ffi.Pointer<ffi.Void> file,
);

typedef _dart_clang_File_tryGetRealPathName = CXString Function(
  ffi.Pointer<ffi.Void> file,
);

typedef _c_clang_getNullLocation = CXSourceLocation Function();

typedef _dart_clang_getNullLocation = CXSourceLocation Function();

typedef _c_clang_equalLocations = ffi.Uint32 Function(
  CXSourceLocation loc1,
  CXSourceLocation loc2,
);

typedef _dart_clang_equalLocations = int Function(
  CXSourceLocation loc1,
  CXSourceLocation loc2,
);

typedef _c_clang_getLocation = CXSourceLocation Function(
  ffi.Pointer<CXTranslationUnitImpl> tu,
  ffi.Pointer<ffi.Void> file,
  ffi.Uint32 line,
  ffi.Uint32 column,
);

typedef _dart_clang_getLocation = CXSourceLocation Function(
  ffi.Pointer<CXTranslationUnitImpl> tu,
  ffi.Pointer<ffi.Void> file,
  int line,
  int column,
);

typedef _c_clang_getLocationForOffset = CXSourceLocation Function(
  ffi.Pointer<CXTranslationUnitImpl> tu,
  ffi.Pointer<ffi.Void> file,
  ffi.Uint32 offset,
);

typedef _dart_clang_getLocationForOffset = CXSourceLocation Function(
  ffi.Pointer<CXTranslationUnitImpl> tu,
  ffi.Pointer<ffi.Void> file,
  int offset,
);

typedef _c_clang_Location_isInSystemHeader = ffi.Int32 Function(
  CXSourceLocation location,
);

typedef _dart_clang_Location_isInSystemHeader = int Function(
  CXSourceLocation location,
);

typedef _c_clang_Location_isFromMainFile = ffi.Int32 Function(
  CXSourceLocation location,
);

typedef _dart_clang_Location_isFromMainFile = int Function(
  CXSourceLocation location,
);

typedef _c_clang_getNullRange = CXSourceRange Function();

typedef _dart_clang_getNullRange = CXSourceRange Function();

typedef _c_clang_getRange = CXSourceRange Function(
  CXSourceLocation begin,
  CXSourceLocation end,
);

typedef _dart_clang_getRange = CXSourceRange Function(
  CXSourceLocation begin,
  CXSourceLocation end,
);

typedef _c_clang_equalRanges = ffi.Uint32 Function(
  CXSourceRange range1,
  CXSourceRange range2,
);

typedef _dart_clang_equalRanges = int Function(
  CXSourceRange range1,
  CXSourceRange range2,
);

typedef _c_clang_Range_isNull = ffi.Int32 Function(
  CXSourceRange range,
);

typedef _dart_clang_Range_isNull = int Function(
  CXSourceRange range,
);

typedef _c_clang_getExpansionLocation = ffi.Void Function(
  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_getExpansionLocation = void Function(
  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_getPresumedLocation = ffi.Void Function(
  CXSourceLocation location,
  ffi.Pointer<CXString> filename,
  ffi.Pointer<ffi.Uint32> line,
  ffi.Pointer<ffi.Uint32> column,
);

typedef _dart_clang_getPresumedLocation = void Function(
  CXSourceLocation location,
  ffi.Pointer<CXString> filename,
  ffi.Pointer<ffi.Uint32> line,
  ffi.Pointer<ffi.Uint32> column,
);

typedef _c_clang_getInstantiationLocation = ffi.Void Function(
  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_getInstantiationLocation = void Function(
  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_getSpellingLocation = ffi.Void Function(
  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_getSpellingLocation = void Function(
  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_getFileLocation = ffi.Void Function(
  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 = void Function(
  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_getRangeStart = CXSourceLocation Function(
  CXSourceRange range,
);

typedef _dart_clang_getRangeStart = CXSourceLocation Function(
  CXSourceRange range,
);

typedef _c_clang_getRangeEnd = CXSourceLocation Function(
  CXSourceRange range,
);

typedef _dart_clang_getRangeEnd = CXSourceLocation Function(
  CXSourceRange range,
);

typedef _c_clang_getSkippedRanges = ffi.Pointer<CXSourceRangeList> Function(
  ffi.Pointer<CXTranslationUnitImpl> tu,
  ffi.Pointer<ffi.Void> file,
);

typedef _dart_clang_getSkippedRanges = ffi.Pointer<CXSourceRangeList> Function(
  ffi.Pointer<CXTranslationUnitImpl> tu,
  ffi.Pointer<ffi.Void> file,
);

typedef _c_clang_getAllSkippedRanges = ffi.Pointer<CXSourceRangeList> Function(
  ffi.Pointer<CXTranslationUnitImpl> tu,
);

typedef _dart_clang_getAllSkippedRanges = ffi.Pointer<CXSourceRangeList>
    Function(
  ffi.Pointer<CXTranslationUnitImpl> tu,
);

typedef _c_clang_disposeSourceRangeList = ffi.Void Function(
  ffi.Pointer<CXSourceRangeList> ranges,
);

typedef _dart_clang_disposeSourceRangeList = void Function(
  ffi.Pointer<CXSourceRangeList> ranges,
);

typedef _c_clang_getNumDiagnosticsInSet = ffi.Uint32 Function(
  ffi.Pointer<ffi.Void> Diags,
);

typedef _dart_clang_getNumDiagnosticsInSet = int Function(
  ffi.Pointer<ffi.Void> Diags,
);

typedef _c_clang_getDiagnosticInSet = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<ffi.Void> Diags,
  ffi.Uint32 Index,
);

typedef _dart_clang_getDiagnosticInSet = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<ffi.Void> Diags,
  int Index,
);

typedef _c_clang_loadDiagnostics = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<ffi.Int8> file,
  ffi.Pointer<ffi.Int32> error,
  ffi.Pointer<CXString> errorString,
);

typedef _dart_clang_loadDiagnostics = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<ffi.Int8> file,
  ffi.Pointer<ffi.Int32> error,
  ffi.Pointer<CXString> errorString,
);

typedef _c_clang_disposeDiagnosticSet = ffi.Void Function(
  ffi.Pointer<ffi.Void> Diags,
);

typedef _dart_clang_disposeDiagnosticSet = void Function(
  ffi.Pointer<ffi.Void> Diags,
);

typedef _c_clang_getChildDiagnostics = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<ffi.Void> D,
);

typedef _dart_clang_getChildDiagnostics = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<ffi.Void> D,
);

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_getDiagnosticSetFromTU = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<CXTranslationUnitImpl> Unit,
);

typedef _dart_clang_getDiagnosticSetFromTU = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<CXTranslationUnitImpl> Unit,
);

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_formatDiagnostic = CXString Function(
  ffi.Pointer<ffi.Void> Diagnostic,
  ffi.Uint32 Options,
);

typedef _dart_clang_formatDiagnostic = CXString Function(
  ffi.Pointer<ffi.Void> Diagnostic,
  int Options,
);

typedef _c_clang_defaultDiagnosticDisplayOptions = ffi.Uint32 Function();

typedef _dart_clang_defaultDiagnosticDisplayOptions = int Function();

typedef _c_clang_getDiagnosticSeverity = ffi.Int32 Function(
  ffi.Pointer<ffi.Void> arg0,
);

typedef _dart_clang_getDiagnosticSeverity = int Function(
  ffi.Pointer<ffi.Void> arg0,
);

typedef _c_clang_getDiagnosticLocation = CXSourceLocation Function(
  ffi.Pointer<ffi.Void> arg0,
);

typedef _dart_clang_getDiagnosticLocation = CXSourceLocation Function(
  ffi.Pointer<ffi.Void> arg0,
);

typedef _c_clang_getDiagnosticSpelling = CXString Function(
  ffi.Pointer<ffi.Void> arg0,
);

typedef _dart_clang_getDiagnosticSpelling = CXString Function(
  ffi.Pointer<ffi.Void> arg0,
);

typedef _c_clang_getDiagnosticOption = CXString Function(
  ffi.Pointer<ffi.Void> Diag,
  ffi.Pointer<CXString> Disable,
);

typedef _dart_clang_getDiagnosticOption = CXString Function(
  ffi.Pointer<ffi.Void> Diag,
  ffi.Pointer<CXString> Disable,
);

typedef _c_clang_getDiagnosticCategory = ffi.Uint32 Function(
  ffi.Pointer<ffi.Void> arg0,
);

typedef _dart_clang_getDiagnosticCategory = int Function(
  ffi.Pointer<ffi.Void> arg0,
);

typedef _c_clang_getDiagnosticCategoryName = CXString Function(
  ffi.Uint32 Category,
);

typedef _dart_clang_getDiagnosticCategoryName = CXString Function(
  int Category,
);

typedef _c_clang_getDiagnosticCategoryText = CXString Function(
  ffi.Pointer<ffi.Void> arg0,
);

typedef _dart_clang_getDiagnosticCategoryText = CXString Function(
  ffi.Pointer<ffi.Void> arg0,
);

typedef _c_clang_getDiagnosticNumRanges = ffi.Uint32 Function(
  ffi.Pointer<ffi.Void> arg0,
);

typedef _dart_clang_getDiagnosticNumRanges = int Function(
  ffi.Pointer<ffi.Void> arg0,
);

typedef _c_clang_getDiagnosticRange = CXSourceRange Function(
  ffi.Pointer<ffi.Void> Diagnostic,
  ffi.Uint32 Range,
);

typedef _dart_clang_getDiagnosticRange = CXSourceRange Function(
  ffi.Pointer<ffi.Void> Diagnostic,
  int Range,
);

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

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

typedef _c_clang_getDiagnosticFixIt = CXString Function(
  ffi.Pointer<ffi.Void> Diagnostic,
  ffi.Uint32 FixIt,
  ffi.Pointer<CXSourceRange> ReplacementRange,
);

typedef _dart_clang_getDiagnosticFixIt = CXString Function(
  ffi.Pointer<ffi.Void> Diagnostic,
  int FixIt,
  ffi.Pointer<CXSourceRange> ReplacementRange,
);

typedef _c_clang_getTranslationUnitSpelling = CXString Function(
  ffi.Pointer<CXTranslationUnitImpl> CTUnit,
);

typedef _dart_clang_getTranslationUnitSpelling = CXString Function(
  ffi.Pointer<CXTranslationUnitImpl> CTUnit,
);

typedef _c_clang_createTranslationUnitFromSourceFile
    = ffi.Pointer<CXTranslationUnitImpl> Function(
  ffi.Pointer<ffi.Void> CIdx,
  ffi.Pointer<ffi.Int8> source_filename,
  ffi.Int32 num_clang_command_line_args,
  ffi.Pointer<ffi.Pointer<ffi.Int8>> clang_command_line_args,
  ffi.Uint32 num_unsaved_files,
  ffi.Pointer<CXUnsavedFile> unsaved_files,
);

typedef _dart_clang_createTranslationUnitFromSourceFile
    = ffi.Pointer<CXTranslationUnitImpl> Function(
  ffi.Pointer<ffi.Void> CIdx,
  ffi.Pointer<ffi.Int8> source_filename,
  int num_clang_command_line_args,
  ffi.Pointer<ffi.Pointer<ffi.Int8>> clang_command_line_args,
  int num_unsaved_files,
  ffi.Pointer<CXUnsavedFile> unsaved_files,
);

typedef _c_clang_createTranslationUnit = ffi.Pointer<CXTranslationUnitImpl>
    Function(
  ffi.Pointer<ffi.Void> CIdx,
  ffi.Pointer<ffi.Int8> ast_filename,
);

typedef _dart_clang_createTranslationUnit = ffi.Pointer<CXTranslationUnitImpl>
    Function(
  ffi.Pointer<ffi.Void> CIdx,
  ffi.Pointer<ffi.Int8> ast_filename,
);

typedef _c_clang_createTranslationUnit2 = ffi.Int32 Function(
  ffi.Pointer<ffi.Void> CIdx,
  ffi.Pointer<ffi.Int8> ast_filename,
  ffi.Pointer<ffi.Pointer<CXTranslationUnitImpl>> out_TU,
);

typedef _dart_clang_createTranslationUnit2 = int Function(
  ffi.Pointer<ffi.Void> CIdx,
  ffi.Pointer<ffi.Int8> ast_filename,
  ffi.Pointer<ffi.Pointer<CXTranslationUnitImpl>> out_TU,
);

typedef _c_clang_defaultEditingTranslationUnitOptions = ffi.Uint32 Function();

typedef _dart_clang_defaultEditingTranslationUnitOptions = int Function();

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_parseTranslationUnit2 = ffi.Int32 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,
  ffi.Pointer<ffi.Pointer<CXTranslationUnitImpl>> out_TU,
);

typedef _dart_clang_parseTranslationUnit2 = int 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,
  ffi.Pointer<ffi.Pointer<CXTranslationUnitImpl>> out_TU,
);

typedef _c_clang_parseTranslationUnit2FullArgv = ffi.Int32 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,
  ffi.Pointer<ffi.Pointer<CXTranslationUnitImpl>> out_TU,
);

typedef _dart_clang_parseTranslationUnit2FullArgv = int 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,
  ffi.Pointer<ffi.Pointer<CXTranslationUnitImpl>> out_TU,
);

typedef _c_clang_defaultSaveOptions = ffi.Uint32 Function(
  ffi.Pointer<CXTranslationUnitImpl> TU,
);

typedef _dart_clang_defaultSaveOptions = int Function(
  ffi.Pointer<CXTranslationUnitImpl> TU,
);

typedef _c_clang_saveTranslationUnit = ffi.Int32 Function(
  ffi.Pointer<CXTranslationUnitImpl> TU,
  ffi.Pointer<ffi.Int8> FileName,
  ffi.Uint32 options,
);

typedef _dart_clang_saveTranslationUnit = int Function(
  ffi.Pointer<CXTranslationUnitImpl> TU,
  ffi.Pointer<ffi.Int8> FileName,
  int options,
);

typedef _c_clang_suspendTranslationUnit = ffi.Uint32 Function(
  ffi.Pointer<CXTranslationUnitImpl> arg0,
);

typedef _dart_clang_suspendTranslationUnit = int Function(
  ffi.Pointer<CXTranslationUnitImpl> arg0,
);

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

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

typedef _c_clang_defaultReparseOptions = ffi.Uint32 Function(
  ffi.Pointer<CXTranslationUnitImpl> TU,
);

typedef _dart_clang_defaultReparseOptions = int Function(
  ffi.Pointer<CXTranslationUnitImpl> TU,
);

typedef _c_clang_reparseTranslationUnit = ffi.Int32 Function(
  ffi.Pointer<CXTranslationUnitImpl> TU,
  ffi.Uint32 num_unsaved_files,
  ffi.Pointer<CXUnsavedFile> unsaved_files,
  ffi.Uint32 options,
);

typedef _dart_clang_reparseTranslationUnit = int Function(
  ffi.Pointer<CXTranslationUnitImpl> TU,
  int num_unsaved_files,
  ffi.Pointer<CXUnsavedFile> unsaved_files,
  int options,
);

typedef _c_clang_getTUResourceUsageName = ffi.Pointer<ffi.Int8> Function(
  ffi.Int32 kind,
);

typedef _dart_clang_getTUResourceUsageName = ffi.Pointer<ffi.Int8> Function(
  int kind,
);

typedef _c_clang_getCXTUResourceUsage = CXTUResourceUsage Function(
  ffi.Pointer<CXTranslationUnitImpl> TU,
);

typedef _dart_clang_getCXTUResourceUsage = CXTUResourceUsage Function(
  ffi.Pointer<CXTranslationUnitImpl> TU,
);

typedef _c_clang_disposeCXTUResourceUsage = ffi.Void Function(
  CXTUResourceUsage usage,
);

typedef _dart_clang_disposeCXTUResourceUsage = void Function(
  CXTUResourceUsage usage,
);

typedef _c_clang_getTranslationUnitTargetInfo = ffi.Pointer<CXTargetInfoImpl>
    Function(
  ffi.Pointer<CXTranslationUnitImpl> CTUnit,
);

typedef _dart_clang_getTranslationUnitTargetInfo = ffi.Pointer<CXTargetInfoImpl>
    Function(
  ffi.Pointer<CXTranslationUnitImpl> CTUnit,
);

typedef _c_clang_TargetInfo_dispose = ffi.Void Function(
  ffi.Pointer<CXTargetInfoImpl> Info,
);

typedef _dart_clang_TargetInfo_dispose = void Function(
  ffi.Pointer<CXTargetInfoImpl> Info,
);

typedef _c_clang_TargetInfo_getTriple = CXString Function(
  ffi.Pointer<CXTargetInfoImpl> Info,
);

typedef _dart_clang_TargetInfo_getTriple = CXString Function(
  ffi.Pointer<CXTargetInfoImpl> Info,
);

typedef _c_clang_TargetInfo_getPointerWidth = ffi.Int32 Function(
  ffi.Pointer<CXTargetInfoImpl> Info,
);

typedef _dart_clang_TargetInfo_getPointerWidth = int Function(
  ffi.Pointer<CXTargetInfoImpl> Info,
);

typedef _c_clang_getNullCursor = CXCursor Function();

typedef _dart_clang_getNullCursor = CXCursor Function();

typedef _c_clang_getTranslationUnitCursor = CXCursor Function(
  ffi.Pointer<CXTranslationUnitImpl> arg0,
);

typedef _dart_clang_getTranslationUnitCursor = CXCursor Function(
  ffi.Pointer<CXTranslationUnitImpl> arg0,
);

typedef _c_clang_equalCursors = ffi.Uint32 Function(
  CXCursor arg0,
  CXCursor arg1,
);

typedef _dart_clang_equalCursors = int Function(
  CXCursor arg0,
  CXCursor arg1,
);

typedef _c_clang_Cursor_isNull = ffi.Int32 Function(
  CXCursor cursor,
);

typedef _dart_clang_Cursor_isNull = int Function(
  CXCursor cursor,
);

typedef _c_clang_hashCursor = ffi.Uint32 Function(
  CXCursor arg0,
);

typedef _dart_clang_hashCursor = int Function(
  CXCursor arg0,
);

typedef _c_clang_getCursorKind = ffi.Int32 Function(
  CXCursor arg0,
);

typedef _dart_clang_getCursorKind = int Function(
  CXCursor arg0,
);

typedef _c_clang_isDeclaration = ffi.Uint32 Function(
  ffi.Int32 arg0,
);

typedef _dart_clang_isDeclaration = int Function(
  int arg0,
);

typedef _c_clang_isInvalidDeclaration = ffi.Uint32 Function(
  CXCursor arg0,
);

typedef _dart_clang_isInvalidDeclaration = int Function(
  CXCursor arg0,
);

typedef _c_clang_isReference = ffi.Uint32 Function(
  ffi.Int32 arg0,
);

typedef _dart_clang_isReference = int Function(
  int arg0,
);

typedef _c_clang_isExpression = ffi.Uint32 Function(
  ffi.Int32 arg0,
);

typedef _dart_clang_isExpression = int Function(
  int arg0,
);

typedef _c_clang_isStatement = ffi.Uint32 Function(
  ffi.Int32 arg0,
);

typedef _dart_clang_isStatement = int Function(
  int arg0,
);

typedef _c_clang_isAttribute = ffi.Uint32 Function(
  ffi.Int32 arg0,
);

typedef _dart_clang_isAttribute = int Function(
  int arg0,
);

typedef _c_clang_Cursor_hasAttrs = ffi.Uint32 Function(
  CXCursor C,
);

typedef _dart_clang_Cursor_hasAttrs = int Function(
  CXCursor C,
);

typedef _c_clang_isInvalid = ffi.Uint32 Function(
  ffi.Int32 arg0,
);

typedef _dart_clang_isInvalid = int Function(
  int arg0,
);

typedef _c_clang_isTranslationUnit = ffi.Uint32 Function(
  ffi.Int32 arg0,
);

typedef _dart_clang_isTranslationUnit = int Function(
  int arg0,
);

typedef _c_clang_isPreprocessing = ffi.Uint32 Function(
  ffi.Int32 arg0,
);

typedef _dart_clang_isPreprocessing = int Function(
  int arg0,
);

typedef _c_clang_isUnexposed = ffi.Uint32 Function(
  ffi.Int32 arg0,
);

typedef _dart_clang_isUnexposed = int Function(
  int arg0,
);

typedef _c_clang_getCursorLinkage = ffi.Int32 Function(
  CXCursor cursor,
);

typedef _dart_clang_getCursorLinkage = int Function(
  CXCursor cursor,
);

typedef _c_clang_getCursorVisibility = ffi.Int32 Function(
  CXCursor cursor,
);

typedef _dart_clang_getCursorVisibility = int Function(
  CXCursor cursor,
);

typedef _c_clang_getCursorAvailability = ffi.Int32 Function(
  CXCursor cursor,
);

typedef _dart_clang_getCursorAvailability = int Function(
  CXCursor cursor,
);

typedef _c_clang_getCursorPlatformAvailability = ffi.Int32 Function(
  CXCursor cursor,
  ffi.Pointer<ffi.Int32> always_deprecated,
  ffi.Pointer<CXString> deprecated_message,
  ffi.Pointer<ffi.Int32> always_unavailable,
  ffi.Pointer<CXString> unavailable_message,
  ffi.Pointer<CXPlatformAvailability> availability,
  ffi.Int32 availability_size,
);

typedef _dart_clang_getCursorPlatformAvailability = int Function(
  CXCursor cursor,
  ffi.Pointer<ffi.Int32> always_deprecated,
  ffi.Pointer<CXString> deprecated_message,
  ffi.Pointer<ffi.Int32> always_unavailable,
  ffi.Pointer<CXString> unavailable_message,
  ffi.Pointer<CXPlatformAvailability> availability,
  int availability_size,
);

typedef _c_clang_disposeCXPlatformAvailability = ffi.Void Function(
  ffi.Pointer<CXPlatformAvailability> availability,
);

typedef _dart_clang_disposeCXPlatformAvailability = void Function(
  ffi.Pointer<CXPlatformAvailability> availability,
);

typedef _c_clang_getCursorLanguage = ffi.Int32 Function(
  CXCursor cursor,
);

typedef _dart_clang_getCursorLanguage = int Function(
  CXCursor cursor,
);

typedef _c_clang_getCursorTLSKind = ffi.Int32 Function(
  CXCursor cursor,
);

typedef _dart_clang_getCursorTLSKind = int Function(
  CXCursor cursor,
);

typedef _c_clang_Cursor_getTranslationUnit = ffi.Pointer<CXTranslationUnitImpl>
    Function(
  CXCursor arg0,
);

typedef _dart_clang_Cursor_getTranslationUnit
    = ffi.Pointer<CXTranslationUnitImpl> Function(
  CXCursor arg0,
);

typedef _c_clang_createCXCursorSet = ffi.Pointer<CXCursorSetImpl> Function();

typedef _dart_clang_createCXCursorSet = ffi.Pointer<CXCursorSetImpl> Function();

typedef _c_clang_disposeCXCursorSet = ffi.Void Function(
  ffi.Pointer<CXCursorSetImpl> cset,
);

typedef _dart_clang_disposeCXCursorSet = void Function(
  ffi.Pointer<CXCursorSetImpl> cset,
);

typedef _c_clang_CXCursorSet_contains = ffi.Uint32 Function(
  ffi.Pointer<CXCursorSetImpl> cset,
  CXCursor cursor,
);

typedef _dart_clang_CXCursorSet_contains = int Function(
  ffi.Pointer<CXCursorSetImpl> cset,
  CXCursor cursor,
);

typedef _c_clang_CXCursorSet_insert = ffi.Uint32 Function(
  ffi.Pointer<CXCursorSetImpl> cset,
  CXCursor cursor,
);

typedef _dart_clang_CXCursorSet_insert = int Function(
  ffi.Pointer<CXCursorSetImpl> cset,
  CXCursor cursor,
);

typedef _c_clang_getCursorSemanticParent = CXCursor Function(
  CXCursor cursor,
);

typedef _dart_clang_getCursorSemanticParent = CXCursor Function(
  CXCursor cursor,
);

typedef _c_clang_getCursorLexicalParent = CXCursor Function(
  CXCursor cursor,
);

typedef _dart_clang_getCursorLexicalParent = CXCursor Function(
  CXCursor cursor,
);

typedef _c_clang_getOverriddenCursors = ffi.Void Function(
  CXCursor cursor,
  ffi.Pointer<ffi.Pointer<CXCursor>> overridden,
  ffi.Pointer<ffi.Uint32> num_overridden,
);

typedef _dart_clang_getOverriddenCursors = void Function(
  CXCursor cursor,
  ffi.Pointer<ffi.Pointer<CXCursor>> overridden,
  ffi.Pointer<ffi.Uint32> num_overridden,
);

typedef _c_clang_disposeOverriddenCursors = ffi.Void Function(
  ffi.Pointer<CXCursor> overridden,
);

typedef _dart_clang_disposeOverriddenCursors = void Function(
  ffi.Pointer<CXCursor> overridden,
);

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

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

typedef _c_clang_getCursor = CXCursor Function(
  ffi.Pointer<CXTranslationUnitImpl> arg0,
  CXSourceLocation arg1,
);

typedef _dart_clang_getCursor = CXCursor Function(
  ffi.Pointer<CXTranslationUnitImpl> arg0,
  CXSourceLocation arg1,
);

typedef _c_clang_getCursorLocation = CXSourceLocation Function(
  CXCursor arg0,
);

typedef _dart_clang_getCursorLocation = CXSourceLocation Function(
  CXCursor arg0,
);

typedef _c_clang_getCursorExtent = CXSourceRange Function(
  CXCursor arg0,
);

typedef _dart_clang_getCursorExtent = CXSourceRange Function(
  CXCursor arg0,
);

typedef _c_clang_getCursorType = CXType Function(
  CXCursor C,
);

typedef _dart_clang_getCursorType = CXType Function(
  CXCursor C,
);

typedef _c_clang_getTypeSpelling = CXString Function(
  CXType CT,
);

typedef _dart_clang_getTypeSpelling = CXString Function(
  CXType CT,
);

typedef _c_clang_getTypedefDeclUnderlyingType = CXType Function(
  CXCursor C,
);

typedef _dart_clang_getTypedefDeclUnderlyingType = CXType Function(
  CXCursor C,
);

typedef _c_clang_getEnumDeclIntegerType = CXType Function(
  CXCursor C,
);

typedef _dart_clang_getEnumDeclIntegerType = CXType Function(
  CXCursor C,
);

typedef _c_clang_getEnumConstantDeclValue = ffi.Int64 Function(
  CXCursor C,
);

typedef _dart_clang_getEnumConstantDeclValue = int Function(
  CXCursor C,
);

typedef _c_clang_getEnumConstantDeclUnsignedValue = ffi.Uint64 Function(
  CXCursor C,
);

typedef _dart_clang_getEnumConstantDeclUnsignedValue = int Function(
  CXCursor C,
);

typedef _c_clang_getFieldDeclBitWidth = ffi.Int32 Function(
  CXCursor C,
);

typedef _dart_clang_getFieldDeclBitWidth = int Function(
  CXCursor C,
);

typedef _c_clang_Cursor_getNumArguments = ffi.Int32 Function(
  CXCursor C,
);

typedef _dart_clang_Cursor_getNumArguments = int Function(
  CXCursor C,
);

typedef _c_clang_Cursor_getArgument = CXCursor Function(
  CXCursor C,
  ffi.Uint32 i,
);

typedef _dart_clang_Cursor_getArgument = CXCursor Function(
  CXCursor C,
  int i,
);

typedef _c_clang_Cursor_getNumTemplateArguments = ffi.Int32 Function(
  CXCursor C,
);

typedef _dart_clang_Cursor_getNumTemplateArguments = int Function(
  CXCursor C,
);

typedef _c_clang_Cursor_getTemplateArgumentKind = ffi.Int32 Function(
  CXCursor C,
  ffi.Uint32 I,
);

typedef _dart_clang_Cursor_getTemplateArgumentKind = int Function(
  CXCursor C,
  int I,
);

typedef _c_clang_Cursor_getTemplateArgumentType = CXType Function(
  CXCursor C,
  ffi.Uint32 I,
);

typedef _dart_clang_Cursor_getTemplateArgumentType = CXType Function(
  CXCursor C,
  int I,
);

typedef _c_clang_Cursor_getTemplateArgumentValue = ffi.Int64 Function(
  CXCursor C,
  ffi.Uint32 I,
);

typedef _dart_clang_Cursor_getTemplateArgumentValue = int Function(
  CXCursor C,
  int I,
);

typedef _c_clang_Cursor_getTemplateArgumentUnsignedValue = ffi.Uint64 Function(
  CXCursor C,
  ffi.Uint32 I,
);

typedef _dart_clang_Cursor_getTemplateArgumentUnsignedValue = int Function(
  CXCursor C,
  int I,
);

typedef _c_clang_equalTypes = ffi.Uint32 Function(
  CXType A,
  CXType B,
);

typedef _dart_clang_equalTypes = int Function(
  CXType A,
  CXType B,
);

typedef _c_clang_getCanonicalType = CXType Function(
  CXType T,
);

typedef _dart_clang_getCanonicalType = CXType Function(
  CXType T,
);

typedef _c_clang_isConstQualifiedType = ffi.Uint32 Function(
  CXType T,
);

typedef _dart_clang_isConstQualifiedType = int Function(
  CXType T,
);

typedef _c_clang_Cursor_isMacroFunctionLike = ffi.Uint32 Function(
  CXCursor C,
);

typedef _dart_clang_Cursor_isMacroFunctionLike = int Function(
  CXCursor C,
);

typedef _c_clang_Cursor_isMacroBuiltin = ffi.Uint32 Function(
  CXCursor C,
);

typedef _dart_clang_Cursor_isMacroBuiltin = int Function(
  CXCursor C,
);

typedef _c_clang_Cursor_isFunctionInlined = ffi.Uint32 Function(
  CXCursor C,
);

typedef _dart_clang_Cursor_isFunctionInlined = int Function(
  CXCursor C,
);

typedef _c_clang_isVolatileQualifiedType = ffi.Uint32 Function(
  CXType T,
);

typedef _dart_clang_isVolatileQualifiedType = int Function(
  CXType T,
);

typedef _c_clang_isRestrictQualifiedType = ffi.Uint32 Function(
  CXType T,
);

typedef _dart_clang_isRestrictQualifiedType = int Function(
  CXType T,
);

typedef _c_clang_getAddressSpace = ffi.Uint32 Function(
  CXType T,
);

typedef _dart_clang_getAddressSpace = int Function(
  CXType T,
);

typedef _c_clang_getTypedefName = CXString Function(
  CXType CT,
);

typedef _dart_clang_getTypedefName = CXString Function(
  CXType CT,
);

typedef _c_clang_getPointeeType = CXType Function(
  CXType T,
);

typedef _dart_clang_getPointeeType = CXType Function(
  CXType T,
);

typedef _c_clang_getTypeDeclaration = CXCursor Function(
  CXType T,
);

typedef _dart_clang_getTypeDeclaration = CXCursor Function(
  CXType T,
);

typedef _c_clang_getDeclObjCTypeEncoding = CXString Function(
  CXCursor C,
);

typedef _dart_clang_getDeclObjCTypeEncoding = CXString Function(
  CXCursor C,
);

typedef _c_clang_Type_getObjCEncoding = CXString Function(
  CXType type,
);

typedef _dart_clang_Type_getObjCEncoding = CXString Function(
  CXType type,
);

typedef _c_clang_getTypeKindSpelling = CXString Function(
  ffi.Int32 K,
);

typedef _dart_clang_getTypeKindSpelling = CXString Function(
  int K,
);

typedef _c_clang_getFunctionTypeCallingConv = ffi.Int32 Function(
  CXType T,
);

typedef _dart_clang_getFunctionTypeCallingConv = int Function(
  CXType T,
);

typedef _c_clang_getResultType = CXType Function(
  CXType T,
);

typedef _dart_clang_getResultType = CXType Function(
  CXType T,
);

typedef _c_clang_getExceptionSpecificationType = ffi.Int32 Function(
  CXType T,
);

typedef _dart_clang_getExceptionSpecificationType = int Function(
  CXType T,
);

typedef _c_clang_getNumArgTypes = ffi.Int32 Function(
  CXType T,
);

typedef _dart_clang_getNumArgTypes = int Function(
  CXType T,
);

typedef _c_clang_getArgType = CXType Function(
  CXType T,
  ffi.Uint32 i,
);

typedef _dart_clang_getArgType = CXType Function(
  CXType T,
  int i,
);

typedef _c_clang_Type_getObjCObjectBaseType = CXType Function(
  CXType T,
);

typedef _dart_clang_Type_getObjCObjectBaseType = CXType Function(
  CXType T,
);

typedef _c_clang_Type_getNumObjCProtocolRefs = ffi.Uint32 Function(
  CXType T,
);

typedef _dart_clang_Type_getNumObjCProtocolRefs = int Function(
  CXType T,
);

typedef _c_clang_Type_getObjCProtocolDecl = CXCursor Function(
  CXType T,
  ffi.Uint32 i,
);

typedef _dart_clang_Type_getObjCProtocolDecl = CXCursor Function(
  CXType T,
  int i,
);

typedef _c_clang_Type_getNumObjCTypeArgs = ffi.Uint32 Function(
  CXType T,
);

typedef _dart_clang_Type_getNumObjCTypeArgs = int Function(
  CXType T,
);

typedef _c_clang_Type_getObjCTypeArg = CXType Function(
  CXType T,
  ffi.Uint32 i,
);

typedef _dart_clang_Type_getObjCTypeArg = CXType Function(
  CXType T,
  int i,
);

typedef _c_clang_isFunctionTypeVariadic = ffi.Uint32 Function(
  CXType T,
);

typedef _dart_clang_isFunctionTypeVariadic = int Function(
  CXType T,
);

typedef _c_clang_getCursorResultType = CXType Function(
  CXCursor C,
);

typedef _dart_clang_getCursorResultType = CXType Function(
  CXCursor C,
);

typedef _c_clang_getCursorExceptionSpecificationType = ffi.Int32 Function(
  CXCursor C,
);

typedef _dart_clang_getCursorExceptionSpecificationType = int Function(
  CXCursor C,
);

typedef _c_clang_isPODType = ffi.Uint32 Function(
  CXType T,
);

typedef _dart_clang_isPODType = int Function(
  CXType T,
);

typedef _c_clang_getElementType = CXType Function(
  CXType T,
);

typedef _dart_clang_getElementType = CXType Function(
  CXType T,
);

typedef _c_clang_getNumElements = ffi.Int64 Function(
  CXType T,
);

typedef _dart_clang_getNumElements = int Function(
  CXType T,
);

typedef _c_clang_getArrayElementType = CXType Function(
  CXType T,
);

typedef _dart_clang_getArrayElementType = CXType Function(
  CXType T,
);

typedef _c_clang_getArraySize = ffi.Int64 Function(
  CXType T,
);

typedef _dart_clang_getArraySize = int Function(
  CXType T,
);

typedef _c_clang_Type_getNamedType = CXType Function(
  CXType T,
);

typedef _dart_clang_Type_getNamedType = CXType Function(
  CXType T,
);

typedef _c_clang_Type_isTransparentTagTypedef = ffi.Uint32 Function(
  CXType T,
);

typedef _dart_clang_Type_isTransparentTagTypedef = int Function(
  CXType T,
);

typedef _c_clang_Type_getNullability = ffi.Int32 Function(
  CXType T,
);

typedef _dart_clang_Type_getNullability = int Function(
  CXType T,
);

typedef _c_clang_Type_getAlignOf = ffi.Int64 Function(
  CXType T,
);

typedef _dart_clang_Type_getAlignOf = int Function(
  CXType T,
);

typedef _c_clang_Type_getClassType = CXType Function(
  CXType T,
);

typedef _dart_clang_Type_getClassType = CXType Function(
  CXType T,
);

typedef _c_clang_Type_getSizeOf = ffi.Int64 Function(
  CXType T,
);

typedef _dart_clang_Type_getSizeOf = int Function(
  CXType T,
);

typedef _c_clang_Type_getOffsetOf = ffi.Int64 Function(
  CXType T,
  ffi.Pointer<ffi.Int8> S,
);

typedef _dart_clang_Type_getOffsetOf = int Function(
  CXType T,
  ffi.Pointer<ffi.Int8> S,
);

typedef _c_clang_Type_getModifiedType = CXType Function(
  CXType T,
);

typedef _dart_clang_Type_getModifiedType = CXType Function(
  CXType T,
);

typedef _c_clang_Cursor_getOffsetOfField = ffi.Int64 Function(
  CXCursor C,
);

typedef _dart_clang_Cursor_getOffsetOfField = int Function(
  CXCursor C,
);

typedef _c_clang_Cursor_isAnonymous = ffi.Uint32 Function(
  CXCursor C,
);

typedef _dart_clang_Cursor_isAnonymous = int Function(
  CXCursor C,
);

typedef _c_clang_Cursor_isAnonymousRecordDecl = ffi.Uint32 Function(
  CXCursor C,
);

typedef _dart_clang_Cursor_isAnonymousRecordDecl = int Function(
  CXCursor C,
);

typedef _c_clang_Cursor_isInlineNamespace = ffi.Uint32 Function(
  CXCursor C,
);

typedef _dart_clang_Cursor_isInlineNamespace = int Function(
  CXCursor C,
);

typedef _c_clang_Type_getNumTemplateArguments = ffi.Int32 Function(
  CXType T,
);

typedef _dart_clang_Type_getNumTemplateArguments = int Function(
  CXType T,
);

typedef _c_clang_Type_getTemplateArgumentAsType = CXType Function(
  CXType T,
  ffi.Uint32 i,
);

typedef _dart_clang_Type_getTemplateArgumentAsType = CXType Function(
  CXType T,
  int i,
);

typedef _c_clang_Type_getCXXRefQualifier = ffi.Int32 Function(
  CXType T,
);

typedef _dart_clang_Type_getCXXRefQualifier = int Function(
  CXType T,
);

typedef _c_clang_Cursor_isBitField = ffi.Uint32 Function(
  CXCursor C,
);

typedef _dart_clang_Cursor_isBitField = int Function(
  CXCursor C,
);

typedef _c_clang_isVirtualBase = ffi.Uint32 Function(
  CXCursor arg0,
);

typedef _dart_clang_isVirtualBase = int Function(
  CXCursor arg0,
);

typedef _c_clang_getCXXAccessSpecifier = ffi.Int32 Function(
  CXCursor arg0,
);

typedef _dart_clang_getCXXAccessSpecifier = int Function(
  CXCursor arg0,
);

typedef _c_clang_Cursor_getStorageClass = ffi.Int32 Function(
  CXCursor arg0,
);

typedef _dart_clang_Cursor_getStorageClass = int Function(
  CXCursor arg0,
);

typedef _c_clang_getNumOverloadedDecls = ffi.Uint32 Function(
  CXCursor cursor,
);

typedef _dart_clang_getNumOverloadedDecls = int Function(
  CXCursor cursor,
);

typedef _c_clang_getOverloadedDecl = CXCursor Function(
  CXCursor cursor,
  ffi.Uint32 index,
);

typedef _dart_clang_getOverloadedDecl = CXCursor Function(
  CXCursor cursor,
  int index,
);

typedef _c_clang_getIBOutletCollectionType = CXType Function(
  CXCursor arg0,
);

typedef _dart_clang_getIBOutletCollectionType = CXType Function(
  CXCursor arg0,
);

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

typedef _c_clang_visitChildren = ffi.Uint32 Function(
  CXCursor parent,
  ffi.Pointer<ffi.NativeFunction<CXCursorVisitor>> visitor,
  ffi.Pointer<ffi.Void> client_data,
);

typedef _dart_clang_visitChildren = int Function(
  CXCursor parent,
  ffi.Pointer<ffi.NativeFunction<CXCursorVisitor>> visitor,
  ffi.Pointer<ffi.Void> client_data,
);

typedef _c_clang_getCursorUSR = CXString Function(
  CXCursor arg0,
);

typedef _dart_clang_getCursorUSR = CXString Function(
  CXCursor arg0,
);

typedef _c_clang_constructUSR_ObjCClass = CXString Function(
  ffi.Pointer<ffi.Int8> class_name,
);

typedef _dart_clang_constructUSR_ObjCClass = CXString Function(
  ffi.Pointer<ffi.Int8> class_name,
);

typedef _c_clang_constructUSR_ObjCCategory = CXString Function(
  ffi.Pointer<ffi.Int8> class_name,
  ffi.Pointer<ffi.Int8> category_name,
);

typedef _dart_clang_constructUSR_ObjCCategory = CXString Function(
  ffi.Pointer<ffi.Int8> class_name,
  ffi.Pointer<ffi.Int8> category_name,
);

typedef _c_clang_constructUSR_ObjCProtocol = CXString Function(
  ffi.Pointer<ffi.Int8> protocol_name,
);

typedef _dart_clang_constructUSR_ObjCProtocol = CXString Function(
  ffi.Pointer<ffi.Int8> protocol_name,
);

typedef _c_clang_constructUSR_ObjCIvar = CXString Function(
  ffi.Pointer<ffi.Int8> name,
  CXString classUSR,
);

typedef _dart_clang_constructUSR_ObjCIvar = CXString Function(
  ffi.Pointer<ffi.Int8> name,
  CXString classUSR,
);

typedef _c_clang_constructUSR_ObjCMethod = CXString Function(
  ffi.Pointer<ffi.Int8> name,
  ffi.Uint32 isInstanceMethod,
  CXString classUSR,
);

typedef _dart_clang_constructUSR_ObjCMethod = CXString Function(
  ffi.Pointer<ffi.Int8> name,
  int isInstanceMethod,
  CXString classUSR,
);

typedef _c_clang_constructUSR_ObjCProperty = CXString Function(
  ffi.Pointer<ffi.Int8> property,
  CXString classUSR,
);

typedef _dart_clang_constructUSR_ObjCProperty = CXString Function(
  ffi.Pointer<ffi.Int8> property,
  CXString classUSR,
);

typedef _c_clang_getCursorSpelling = CXString Function(
  CXCursor arg0,
);

typedef _dart_clang_getCursorSpelling = CXString Function(
  CXCursor arg0,
);

typedef _c_clang_Cursor_getSpellingNameRange = CXSourceRange Function(
  CXCursor arg0,
  ffi.Uint32 pieceIndex,
  ffi.Uint32 options,
);

typedef _dart_clang_Cursor_getSpellingNameRange = CXSourceRange Function(
  CXCursor arg0,
  int pieceIndex,
  int options,
);

typedef _c_clang_PrintingPolicy_getProperty = ffi.Uint32 Function(
  ffi.Pointer<ffi.Void> Policy,
  ffi.Int32 Property,
);

typedef _dart_clang_PrintingPolicy_getProperty = int Function(
  ffi.Pointer<ffi.Void> Policy,
  int Property,
);

typedef _c_clang_PrintingPolicy_setProperty = ffi.Void Function(
  ffi.Pointer<ffi.Void> Policy,
  ffi.Int32 Property,
  ffi.Uint32 Value,
);

typedef _dart_clang_PrintingPolicy_setProperty = void Function(
  ffi.Pointer<ffi.Void> Policy,
  int Property,
  int Value,
);

typedef _c_clang_getCursorPrintingPolicy = ffi.Pointer<ffi.Void> Function(
  CXCursor arg0,
);

typedef _dart_clang_getCursorPrintingPolicy = ffi.Pointer<ffi.Void> Function(
  CXCursor arg0,
);

typedef _c_clang_PrintingPolicy_dispose = ffi.Void Function(
  ffi.Pointer<ffi.Void> Policy,
);

typedef _dart_clang_PrintingPolicy_dispose = void Function(
  ffi.Pointer<ffi.Void> Policy,
);

typedef _c_clang_getCursorPrettyPrinted = CXString Function(
  CXCursor Cursor,
  ffi.Pointer<ffi.Void> Policy,
);

typedef _dart_clang_getCursorPrettyPrinted = CXString Function(
  CXCursor Cursor,
  ffi.Pointer<ffi.Void> Policy,
);

typedef _c_clang_getCursorDisplayName = CXString Function(
  CXCursor arg0,
);

typedef _dart_clang_getCursorDisplayName = CXString Function(
  CXCursor arg0,
);

typedef _c_clang_getCursorReferenced = CXCursor Function(
  CXCursor arg0,
);

typedef _dart_clang_getCursorReferenced = CXCursor Function(
  CXCursor arg0,
);

typedef _c_clang_getCursorDefinition = CXCursor Function(
  CXCursor arg0,
);

typedef _dart_clang_getCursorDefinition = CXCursor Function(
  CXCursor arg0,
);

typedef _c_clang_isCursorDefinition = ffi.Uint32 Function(
  CXCursor arg0,
);

typedef _dart_clang_isCursorDefinition = int Function(
  CXCursor arg0,
);

typedef _c_clang_getCanonicalCursor = CXCursor Function(
  CXCursor arg0,
);

typedef _dart_clang_getCanonicalCursor = CXCursor Function(
  CXCursor arg0,
);

typedef _c_clang_Cursor_getObjCSelectorIndex = ffi.Int32 Function(
  CXCursor arg0,
);

typedef _dart_clang_Cursor_getObjCSelectorIndex = int Function(
  CXCursor arg0,
);

typedef _c_clang_Cursor_isDynamicCall = ffi.Int32 Function(
  CXCursor C,
);

typedef _dart_clang_Cursor_isDynamicCall = int Function(
  CXCursor C,
);

typedef _c_clang_Cursor_getReceiverType = CXType Function(
  CXCursor C,
);

typedef _dart_clang_Cursor_getReceiverType = CXType Function(
  CXCursor C,
);

typedef _c_clang_Cursor_getObjCPropertyAttributes = ffi.Uint32 Function(
  CXCursor C,
  ffi.Uint32 reserved,
);

typedef _dart_clang_Cursor_getObjCPropertyAttributes = int Function(
  CXCursor C,
  int reserved,
);

typedef _c_clang_Cursor_getObjCPropertyGetterName = CXString Function(
  CXCursor C,
);

typedef _dart_clang_Cursor_getObjCPropertyGetterName = CXString Function(
  CXCursor C,
);

typedef _c_clang_Cursor_getObjCPropertySetterName = CXString Function(
  CXCursor C,
);

typedef _dart_clang_Cursor_getObjCPropertySetterName = CXString Function(
  CXCursor C,
);

typedef _c_clang_Cursor_getObjCDeclQualifiers = ffi.Uint32 Function(
  CXCursor C,
);

typedef _dart_clang_Cursor_getObjCDeclQualifiers = int Function(
  CXCursor C,
);

typedef _c_clang_Cursor_isObjCOptional = ffi.Uint32 Function(
  CXCursor C,
);

typedef _dart_clang_Cursor_isObjCOptional = int Function(
  CXCursor C,
);

typedef _c_clang_Cursor_isVariadic = ffi.Uint32 Function(
  CXCursor C,
);

typedef _dart_clang_Cursor_isVariadic = int Function(
  CXCursor C,
);

typedef _c_clang_Cursor_isExternalSymbol = ffi.Uint32 Function(
  CXCursor C,
  ffi.Pointer<CXString> language,
  ffi.Pointer<CXString> definedIn,
  ffi.Pointer<ffi.Uint32> isGenerated,
);

typedef _dart_clang_Cursor_isExternalSymbol = int Function(
  CXCursor C,
  ffi.Pointer<CXString> language,
  ffi.Pointer<CXString> definedIn,
  ffi.Pointer<ffi.Uint32> isGenerated,
);

typedef _c_clang_Cursor_getCommentRange = CXSourceRange Function(
  CXCursor C,
);

typedef _dart_clang_Cursor_getCommentRange = CXSourceRange Function(
  CXCursor C,
);

typedef _c_clang_Cursor_getRawCommentText = CXString Function(
  CXCursor C,
);

typedef _dart_clang_Cursor_getRawCommentText = CXString Function(
  CXCursor C,
);

typedef _c_clang_Cursor_getBriefCommentText = CXString Function(
  CXCursor C,
);

typedef _dart_clang_Cursor_getBriefCommentText = CXString Function(
  CXCursor C,
);

typedef _c_clang_Cursor_getMangling = CXString Function(
  CXCursor arg0,
);

typedef _dart_clang_Cursor_getMangling = CXString Function(
  CXCursor arg0,
);

typedef _c_clang_Cursor_getCXXManglings = ffi.Pointer<CXStringSet> Function(
  CXCursor arg0,
);

typedef _dart_clang_Cursor_getCXXManglings = ffi.Pointer<CXStringSet> Function(
  CXCursor arg0,
);

typedef _c_clang_Cursor_getObjCManglings = ffi.Pointer<CXStringSet> Function(
  CXCursor arg0,
);

typedef _dart_clang_Cursor_getObjCManglings = ffi.Pointer<CXStringSet> Function(
  CXCursor arg0,
);

typedef _c_clang_Cursor_getModule = ffi.Pointer<ffi.Void> Function(
  CXCursor C,
);

typedef _dart_clang_Cursor_getModule = ffi.Pointer<ffi.Void> Function(
  CXCursor C,
);

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

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

typedef _c_clang_Module_getASTFile = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<ffi.Void> Module,
);

typedef _dart_clang_Module_getASTFile = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<ffi.Void> Module,
);

typedef _c_clang_Module_getParent = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<ffi.Void> Module,
);

typedef _dart_clang_Module_getParent = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<ffi.Void> Module,
);

typedef _c_clang_Module_getName = CXString Function(
  ffi.Pointer<ffi.Void> Module,
);

typedef _dart_clang_Module_getName = CXString Function(
  ffi.Pointer<ffi.Void> Module,
);

typedef _c_clang_Module_getFullName = CXString Function(
  ffi.Pointer<ffi.Void> Module,
);

typedef _dart_clang_Module_getFullName = CXString Function(
  ffi.Pointer<ffi.Void> Module,
);

typedef _c_clang_Module_isSystem = ffi.Int32 Function(
  ffi.Pointer<ffi.Void> Module,
);

typedef _dart_clang_Module_isSystem = int Function(
  ffi.Pointer<ffi.Void> Module,
);

typedef _c_clang_Module_getNumTopLevelHeaders = ffi.Uint32 Function(
  ffi.Pointer<CXTranslationUnitImpl> arg0,
  ffi.Pointer<ffi.Void> Module,
);

typedef _dart_clang_Module_getNumTopLevelHeaders = int Function(
  ffi.Pointer<CXTranslationUnitImpl> arg0,
  ffi.Pointer<ffi.Void> Module,
);

typedef _c_clang_Module_getTopLevelHeader = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<CXTranslationUnitImpl> arg0,
  ffi.Pointer<ffi.Void> Module,
  ffi.Uint32 Index,
);

typedef _dart_clang_Module_getTopLevelHeader = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<CXTranslationUnitImpl> arg0,
  ffi.Pointer<ffi.Void> Module,
  int Index,
);

typedef _c_clang_CXXConstructor_isConvertingConstructor = ffi.Uint32 Function(
  CXCursor C,
);

typedef _dart_clang_CXXConstructor_isConvertingConstructor = int Function(
  CXCursor C,
);

typedef _c_clang_CXXConstructor_isCopyConstructor = ffi.Uint32 Function(
  CXCursor C,
);

typedef _dart_clang_CXXConstructor_isCopyConstructor = int Function(
  CXCursor C,
);

typedef _c_clang_CXXConstructor_isDefaultConstructor = ffi.Uint32 Function(
  CXCursor C,
);

typedef _dart_clang_CXXConstructor_isDefaultConstructor = int Function(
  CXCursor C,
);

typedef _c_clang_CXXConstructor_isMoveConstructor = ffi.Uint32 Function(
  CXCursor C,
);

typedef _dart_clang_CXXConstructor_isMoveConstructor = int Function(
  CXCursor C,
);

typedef _c_clang_CXXField_isMutable = ffi.Uint32 Function(
  CXCursor C,
);

typedef _dart_clang_CXXField_isMutable = int Function(
  CXCursor C,
);

typedef _c_clang_CXXMethod_isDefaulted = ffi.Uint32 Function(
  CXCursor C,
);

typedef _dart_clang_CXXMethod_isDefaulted = int Function(
  CXCursor C,
);

typedef _c_clang_CXXMethod_isPureVirtual = ffi.Uint32 Function(
  CXCursor C,
);

typedef _dart_clang_CXXMethod_isPureVirtual = int Function(
  CXCursor C,
);

typedef _c_clang_CXXMethod_isStatic = ffi.Uint32 Function(
  CXCursor C,
);

typedef _dart_clang_CXXMethod_isStatic = int Function(
  CXCursor C,
);

typedef _c_clang_CXXMethod_isVirtual = ffi.Uint32 Function(
  CXCursor C,
);

typedef _dart_clang_CXXMethod_isVirtual = int Function(
  CXCursor C,
);

typedef _c_clang_CXXRecord_isAbstract = ffi.Uint32 Function(
  CXCursor C,
);

typedef _dart_clang_CXXRecord_isAbstract = int Function(
  CXCursor C,
);

typedef _c_clang_EnumDecl_isScoped = ffi.Uint32 Function(
  CXCursor C,
);

typedef _dart_clang_EnumDecl_isScoped = int Function(
  CXCursor C,
);

typedef _c_clang_CXXMethod_isConst = ffi.Uint32 Function(
  CXCursor C,
);

typedef _dart_clang_CXXMethod_isConst = int Function(
  CXCursor C,
);

typedef _c_clang_getTemplateCursorKind = ffi.Int32 Function(
  CXCursor C,
);

typedef _dart_clang_getTemplateCursorKind = int Function(
  CXCursor C,
);

typedef _c_clang_getSpecializedCursorTemplate = CXCursor Function(
  CXCursor C,
);

typedef _dart_clang_getSpecializedCursorTemplate = CXCursor Function(
  CXCursor C,
);

typedef _c_clang_getCursorReferenceNameRange = CXSourceRange Function(
  CXCursor C,
  ffi.Uint32 NameFlags,
  ffi.Uint32 PieceIndex,
);

typedef _dart_clang_getCursorReferenceNameRange = CXSourceRange Function(
  CXCursor C,
  int NameFlags,
  int PieceIndex,
);

typedef _c_clang_getToken = ffi.Pointer<CXToken> Function(
  ffi.Pointer<CXTranslationUnitImpl> TU,
  CXSourceLocation Location,
);

typedef _dart_clang_getToken = ffi.Pointer<CXToken> Function(
  ffi.Pointer<CXTranslationUnitImpl> TU,
  CXSourceLocation Location,
);

typedef _c_clang_getTokenKind = ffi.Int32 Function(
  CXToken arg0,
);

typedef _dart_clang_getTokenKind = int Function(
  CXToken arg0,
);

typedef _c_clang_getTokenSpelling = CXString Function(
  ffi.Pointer<CXTranslationUnitImpl> arg0,
  CXToken arg1,
);

typedef _dart_clang_getTokenSpelling = CXString Function(
  ffi.Pointer<CXTranslationUnitImpl> arg0,
  CXToken arg1,
);

typedef _c_clang_getTokenLocation = CXSourceLocation Function(
  ffi.Pointer<CXTranslationUnitImpl> arg0,
  CXToken arg1,
);

typedef _dart_clang_getTokenLocation = CXSourceLocation Function(
  ffi.Pointer<CXTranslationUnitImpl> arg0,
  CXToken arg1,
);

typedef _c_clang_getTokenExtent = CXSourceRange Function(
  ffi.Pointer<CXTranslationUnitImpl> arg0,
  CXToken arg1,
);

typedef _dart_clang_getTokenExtent = CXSourceRange Function(
  ffi.Pointer<CXTranslationUnitImpl> arg0,
  CXToken arg1,
);

typedef _c_clang_tokenize = ffi.Void Function(
  ffi.Pointer<CXTranslationUnitImpl> TU,
  CXSourceRange Range,
  ffi.Pointer<ffi.Pointer<CXToken>> Tokens,
  ffi.Pointer<ffi.Uint32> NumTokens,
);

typedef _dart_clang_tokenize = void Function(
  ffi.Pointer<CXTranslationUnitImpl> TU,
  CXSourceRange Range,
  ffi.Pointer<ffi.Pointer<CXToken>> Tokens,
  ffi.Pointer<ffi.Uint32> NumTokens,
);

typedef _c_clang_annotateTokens = ffi.Void Function(
  ffi.Pointer<CXTranslationUnitImpl> TU,
  ffi.Pointer<CXToken> Tokens,
  ffi.Uint32 NumTokens,
  ffi.Pointer<CXCursor> Cursors,
);

typedef _dart_clang_annotateTokens = void Function(
  ffi.Pointer<CXTranslationUnitImpl> TU,
  ffi.Pointer<CXToken> Tokens,
  int NumTokens,
  ffi.Pointer<CXCursor> Cursors,
);

typedef _c_clang_disposeTokens = ffi.Void Function(
  ffi.Pointer<CXTranslationUnitImpl> TU,
  ffi.Pointer<CXToken> Tokens,
  ffi.Uint32 NumTokens,
);

typedef _dart_clang_disposeTokens = void Function(
  ffi.Pointer<CXTranslationUnitImpl> TU,
  ffi.Pointer<CXToken> Tokens,
  int NumTokens,
);

typedef _c_clang_getCursorKindSpelling = CXString Function(
  ffi.Int32 Kind,
);

typedef _dart_clang_getCursorKindSpelling = CXString Function(
  int Kind,
);

typedef _c_clang_getDefinitionSpellingAndExtent = ffi.Void Function(
  CXCursor arg0,
  ffi.Pointer<ffi.Pointer<ffi.Int8>> startBuf,
  ffi.Pointer<ffi.Pointer<ffi.Int8>> endBuf,
  ffi.Pointer<ffi.Uint32> startLine,
  ffi.Pointer<ffi.Uint32> startColumn,
  ffi.Pointer<ffi.Uint32> endLine,
  ffi.Pointer<ffi.Uint32> endColumn,
);

typedef _dart_clang_getDefinitionSpellingAndExtent = void Function(
  CXCursor arg0,
  ffi.Pointer<ffi.Pointer<ffi.Int8>> startBuf,
  ffi.Pointer<ffi.Pointer<ffi.Int8>> endBuf,
  ffi.Pointer<ffi.Uint32> startLine,
  ffi.Pointer<ffi.Uint32> startColumn,
  ffi.Pointer<ffi.Uint32> endLine,
  ffi.Pointer<ffi.Uint32> endColumn,
);

typedef _c_clang_enableStackTraces = ffi.Void Function();

typedef _dart_clang_enableStackTraces = void Function();

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

typedef _c_clang_executeOnThread = ffi.Void Function(
  ffi.Pointer<ffi.NativeFunction<_typedefC_1>> fn,
  ffi.Pointer<ffi.Void> user_data,
  ffi.Uint32 stack_size,
);

typedef _dart_clang_executeOnThread = void Function(
  ffi.Pointer<ffi.NativeFunction<_typedefC_1>> fn,
  ffi.Pointer<ffi.Void> user_data,
  int stack_size,
);

typedef _c_clang_getCompletionChunkKind = ffi.Int32 Function(
  ffi.Pointer<ffi.Void> completion_string,
  ffi.Uint32 chunk_number,
);

typedef _dart_clang_getCompletionChunkKind = int Function(
  ffi.Pointer<ffi.Void> completion_string,
  int chunk_number,
);

typedef _c_clang_getCompletionChunkText = CXString Function(
  ffi.Pointer<ffi.Void> completion_string,
  ffi.Uint32 chunk_number,
);

typedef _dart_clang_getCompletionChunkText = CXString Function(
  ffi.Pointer<ffi.Void> completion_string,
  int chunk_number,
);

typedef _c_clang_getCompletionChunkCompletionString = ffi.Pointer<ffi.Void>
    Function(
  ffi.Pointer<ffi.Void> completion_string,
  ffi.Uint32 chunk_number,
);

typedef _dart_clang_getCompletionChunkCompletionString = ffi.Pointer<ffi.Void>
    Function(
  ffi.Pointer<ffi.Void> completion_string,
  int chunk_number,
);

typedef _c_clang_getNumCompletionChunks = ffi.Uint32 Function(
  ffi.Pointer<ffi.Void> completion_string,
);

typedef _dart_clang_getNumCompletionChunks = int Function(
  ffi.Pointer<ffi.Void> completion_string,
);

typedef _c_clang_getCompletionPriority = ffi.Uint32 Function(
  ffi.Pointer<ffi.Void> completion_string,
);

typedef _dart_clang_getCompletionPriority = int Function(
  ffi.Pointer<ffi.Void> completion_string,
);

typedef _c_clang_getCompletionAvailability = ffi.Int32 Function(
  ffi.Pointer<ffi.Void> completion_string,
);

typedef _dart_clang_getCompletionAvailability = int Function(
  ffi.Pointer<ffi.Void> completion_string,
);

typedef _c_clang_getCompletionNumAnnotations = ffi.Uint32 Function(
  ffi.Pointer<ffi.Void> completion_string,
);

typedef _dart_clang_getCompletionNumAnnotations = int Function(
  ffi.Pointer<ffi.Void> completion_string,
);

typedef _c_clang_getCompletionAnnotation = CXString Function(
  ffi.Pointer<ffi.Void> completion_string,
  ffi.Uint32 annotation_number,
);

typedef _dart_clang_getCompletionAnnotation = CXString Function(
  ffi.Pointer<ffi.Void> completion_string,
  int annotation_number,
);

typedef _c_clang_getCompletionParent = CXString Function(
  ffi.Pointer<ffi.Void> completion_string,
  ffi.Pointer<ffi.Int32> kind,
);

typedef _dart_clang_getCompletionParent = CXString Function(
  ffi.Pointer<ffi.Void> completion_string,
  ffi.Pointer<ffi.Int32> kind,
);

typedef _c_clang_getCompletionBriefComment = CXString Function(
  ffi.Pointer<ffi.Void> completion_string,
);

typedef _dart_clang_getCompletionBriefComment = CXString Function(
  ffi.Pointer<ffi.Void> completion_string,
);

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

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

typedef _c_clang_getCompletionNumFixIts = ffi.Uint32 Function(
  ffi.Pointer<CXCodeCompleteResults> results,
  ffi.Uint32 completion_index,
);

typedef _dart_clang_getCompletionNumFixIts = int Function(
  ffi.Pointer<CXCodeCompleteResults> results,
  int completion_index,
);

typedef _c_clang_getCompletionFixIt = CXString Function(
  ffi.Pointer<CXCodeCompleteResults> results,
  ffi.Uint32 completion_index,
  ffi.Uint32 fixit_index,
  ffi.Pointer<CXSourceRange> replacement_range,
);

typedef _dart_clang_getCompletionFixIt = CXString Function(
  ffi.Pointer<CXCodeCompleteResults> results,
  int completion_index,
  int fixit_index,
  ffi.Pointer<CXSourceRange> replacement_range,
);

typedef _c_clang_defaultCodeCompleteOptions = ffi.Uint32 Function();

typedef _dart_clang_defaultCodeCompleteOptions = int Function();

typedef _c_clang_codeCompleteAt = ffi.Pointer<CXCodeCompleteResults> Function(
  ffi.Pointer<CXTranslationUnitImpl> TU,
  ffi.Pointer<ffi.Int8> complete_filename,
  ffi.Uint32 complete_line,
  ffi.Uint32 complete_column,
  ffi.Pointer<CXUnsavedFile> unsaved_files,
  ffi.Uint32 num_unsaved_files,
  ffi.Uint32 options,
);

typedef _dart_clang_codeCompleteAt = ffi.Pointer<CXCodeCompleteResults>
    Function(
  ffi.Pointer<CXTranslationUnitImpl> TU,
  ffi.Pointer<ffi.Int8> complete_filename,
  int complete_line,
  int complete_column,
  ffi.Pointer<CXUnsavedFile> unsaved_files,
  int num_unsaved_files,
  int options,
);

typedef _c_clang_sortCodeCompletionResults = ffi.Void Function(
  ffi.Pointer<CXCompletionResult> Results,
  ffi.Uint32 NumResults,
);

typedef _dart_clang_sortCodeCompletionResults = void Function(
  ffi.Pointer<CXCompletionResult> Results,
  int NumResults,
);

typedef _c_clang_disposeCodeCompleteResults = ffi.Void Function(
  ffi.Pointer<CXCodeCompleteResults> Results,
);

typedef _dart_clang_disposeCodeCompleteResults = void Function(
  ffi.Pointer<CXCodeCompleteResults> Results,
);

typedef _c_clang_codeCompleteGetNumDiagnostics = ffi.Uint32 Function(
  ffi.Pointer<CXCodeCompleteResults> Results,
);

typedef _dart_clang_codeCompleteGetNumDiagnostics = int Function(
  ffi.Pointer<CXCodeCompleteResults> Results,
);

typedef _c_clang_codeCompleteGetDiagnostic = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<CXCodeCompleteResults> Results,
  ffi.Uint32 Index,
);

typedef _dart_clang_codeCompleteGetDiagnostic = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<CXCodeCompleteResults> Results,
  int Index,
);

typedef _c_clang_codeCompleteGetContexts = ffi.Uint64 Function(
  ffi.Pointer<CXCodeCompleteResults> Results,
);

typedef _dart_clang_codeCompleteGetContexts = int Function(
  ffi.Pointer<CXCodeCompleteResults> Results,
);

typedef _c_clang_codeCompleteGetContainerKind = ffi.Int32 Function(
  ffi.Pointer<CXCodeCompleteResults> Results,
  ffi.Pointer<ffi.Uint32> IsIncomplete,
);

typedef _dart_clang_codeCompleteGetContainerKind = int Function(
  ffi.Pointer<CXCodeCompleteResults> Results,
  ffi.Pointer<ffi.Uint32> IsIncomplete,
);

typedef _c_clang_codeCompleteGetContainerUSR = CXString Function(
  ffi.Pointer<CXCodeCompleteResults> Results,
);

typedef _dart_clang_codeCompleteGetContainerUSR = CXString Function(
  ffi.Pointer<CXCodeCompleteResults> Results,
);

typedef _c_clang_codeCompleteGetObjCSelector = CXString Function(
  ffi.Pointer<CXCodeCompleteResults> Results,
);

typedef _dart_clang_codeCompleteGetObjCSelector = CXString Function(
  ffi.Pointer<CXCodeCompleteResults> Results,
);

typedef _c_clang_getClangVersion = CXString Function();

typedef _dart_clang_getClangVersion = CXString Function();

typedef _c_clang_toggleCrashRecovery = ffi.Void Function(
  ffi.Uint32 isEnabled,
);

typedef _dart_clang_toggleCrashRecovery = void Function(
  int isEnabled,
);

typedef CXInclusionVisitor = ffi.Void Function(
  ffi.Pointer<ffi.Void>,
  ffi.Pointer<CXSourceLocation>,
  ffi.Uint32,
  ffi.Pointer<ffi.Void>,
);

typedef _c_clang_getInclusions = ffi.Void Function(
  ffi.Pointer<CXTranslationUnitImpl> tu,
  ffi.Pointer<ffi.NativeFunction<CXInclusionVisitor>> visitor,
  ffi.Pointer<ffi.Void> client_data,
);

typedef _dart_clang_getInclusions = void Function(
  ffi.Pointer<CXTranslationUnitImpl> tu,
  ffi.Pointer<ffi.NativeFunction<CXInclusionVisitor>> visitor,
  ffi.Pointer<ffi.Void> client_data,
);

typedef _c_clang_Cursor_Evaluate = ffi.Pointer<ffi.Void> Function(
  CXCursor C,
);

typedef _dart_clang_Cursor_Evaluate = ffi.Pointer<ffi.Void> Function(
  CXCursor C,
);

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_isUnsignedInt = ffi.Uint32 Function(
  ffi.Pointer<ffi.Void> E,
);

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

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

typedef _dart_clang_EvalResult_getAsUnsigned = 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_getRemappings = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<ffi.Int8> path,
);

typedef _dart_clang_getRemappings = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<ffi.Int8> path,
);

typedef _c_clang_getRemappingsFromFileList = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<ffi.Pointer<ffi.Int8>> filePaths,
  ffi.Uint32 numFiles,
);

typedef _dart_clang_getRemappingsFromFileList = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<ffi.Pointer<ffi.Int8>> filePaths,
  int numFiles,
);

typedef _c_clang_remap_getNumFiles = ffi.Uint32 Function(
  ffi.Pointer<ffi.Void> arg0,
);

typedef _dart_clang_remap_getNumFiles = int Function(
  ffi.Pointer<ffi.Void> arg0,
);

typedef _c_clang_remap_getFilenames = ffi.Void Function(
  ffi.Pointer<ffi.Void> arg0,
  ffi.Uint32 index,
  ffi.Pointer<CXString> original,
  ffi.Pointer<CXString> transformed,
);

typedef _dart_clang_remap_getFilenames = void Function(
  ffi.Pointer<ffi.Void> arg0,
  int index,
  ffi.Pointer<CXString> original,
  ffi.Pointer<CXString> transformed,
);

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

typedef _dart_clang_remap_dispose = void Function(
  ffi.Pointer<ffi.Void> arg0,
);

typedef _c_clang_findReferencesInFile = ffi.Int32 Function(
  CXCursor cursor,
  ffi.Pointer<ffi.Void> file,
  CXCursorAndRangeVisitor visitor,
);

typedef _dart_clang_findReferencesInFile = int Function(
  CXCursor cursor,
  ffi.Pointer<ffi.Void> file,
  CXCursorAndRangeVisitor visitor,
);

typedef _c_clang_findIncludesInFile = ffi.Int32 Function(
  ffi.Pointer<CXTranslationUnitImpl> TU,
  ffi.Pointer<ffi.Void> file,
  CXCursorAndRangeVisitor visitor,
);

typedef _dart_clang_findIncludesInFile = int Function(
  ffi.Pointer<CXTranslationUnitImpl> TU,
  ffi.Pointer<ffi.Void> file,
  CXCursorAndRangeVisitor visitor,
);

typedef _c_clang_index_isEntityObjCContainerKind = ffi.Int32 Function(
  ffi.Int32 arg0,
);

typedef _dart_clang_index_isEntityObjCContainerKind = int Function(
  int arg0,
);

typedef _c_clang_index_getObjCContainerDeclInfo
    = ffi.Pointer<CXIdxObjCContainerDeclInfo> Function(
  ffi.Pointer<CXIdxDeclInfo> arg0,
);

typedef _dart_clang_index_getObjCContainerDeclInfo
    = ffi.Pointer<CXIdxObjCContainerDeclInfo> Function(
  ffi.Pointer<CXIdxDeclInfo> arg0,
);

typedef _c_clang_index_getObjCInterfaceDeclInfo
    = ffi.Pointer<CXIdxObjCInterfaceDeclInfo> Function(
  ffi.Pointer<CXIdxDeclInfo> arg0,
);

typedef _dart_clang_index_getObjCInterfaceDeclInfo
    = ffi.Pointer<CXIdxObjCInterfaceDeclInfo> Function(
  ffi.Pointer<CXIdxDeclInfo> arg0,
);

typedef _c_clang_index_getObjCCategoryDeclInfo
    = ffi.Pointer<CXIdxObjCCategoryDeclInfo> Function(
  ffi.Pointer<CXIdxDeclInfo> arg0,
);

typedef _dart_clang_index_getObjCCategoryDeclInfo
    = ffi.Pointer<CXIdxObjCCategoryDeclInfo> Function(
  ffi.Pointer<CXIdxDeclInfo> arg0,
);

typedef _c_clang_index_getObjCProtocolRefListInfo
    = ffi.Pointer<CXIdxObjCProtocolRefListInfo> Function(
  ffi.Pointer<CXIdxDeclInfo> arg0,
);

typedef _dart_clang_index_getObjCProtocolRefListInfo
    = ffi.Pointer<CXIdxObjCProtocolRefListInfo> Function(
  ffi.Pointer<CXIdxDeclInfo> arg0,
);

typedef _c_clang_index_getObjCPropertyDeclInfo
    = ffi.Pointer<CXIdxObjCPropertyDeclInfo> Function(
  ffi.Pointer<CXIdxDeclInfo> arg0,
);

typedef _dart_clang_index_getObjCPropertyDeclInfo
    = ffi.Pointer<CXIdxObjCPropertyDeclInfo> Function(
  ffi.Pointer<CXIdxDeclInfo> arg0,
);

typedef _c_clang_index_getIBOutletCollectionAttrInfo
    = ffi.Pointer<CXIdxIBOutletCollectionAttrInfo> Function(
  ffi.Pointer<CXIdxAttrInfo> arg0,
);

typedef _dart_clang_index_getIBOutletCollectionAttrInfo
    = ffi.Pointer<CXIdxIBOutletCollectionAttrInfo> Function(
  ffi.Pointer<CXIdxAttrInfo> arg0,
);

typedef _c_clang_index_getCXXClassDeclInfo = ffi.Pointer<CXIdxCXXClassDeclInfo>
    Function(
  ffi.Pointer<CXIdxDeclInfo> arg0,
);

typedef _dart_clang_index_getCXXClassDeclInfo
    = ffi.Pointer<CXIdxCXXClassDeclInfo> Function(
  ffi.Pointer<CXIdxDeclInfo> arg0,
);

typedef _c_clang_index_getClientContainer = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<CXIdxContainerInfo> arg0,
);

typedef _dart_clang_index_getClientContainer = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<CXIdxContainerInfo> arg0,
);

typedef _c_clang_index_setClientContainer = ffi.Void Function(
  ffi.Pointer<CXIdxContainerInfo> arg0,
  ffi.Pointer<ffi.Void> arg1,
);

typedef _dart_clang_index_setClientContainer = void Function(
  ffi.Pointer<CXIdxContainerInfo> arg0,
  ffi.Pointer<ffi.Void> arg1,
);

typedef _c_clang_index_getClientEntity = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<CXIdxEntityInfo> arg0,
);

typedef _dart_clang_index_getClientEntity = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<CXIdxEntityInfo> arg0,
);

typedef _c_clang_index_setClientEntity = ffi.Void Function(
  ffi.Pointer<CXIdxEntityInfo> arg0,
  ffi.Pointer<ffi.Void> arg1,
);

typedef _dart_clang_index_setClientEntity = void Function(
  ffi.Pointer<CXIdxEntityInfo> arg0,
  ffi.Pointer<ffi.Void> arg1,
);

typedef _c_clang_IndexAction_create = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<ffi.Void> CIdx,
);

typedef _dart_clang_IndexAction_create = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<ffi.Void> CIdx,
);

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

typedef _dart_clang_IndexAction_dispose = void Function(
  ffi.Pointer<ffi.Void> arg0,
);

typedef _c_clang_indexSourceFile = ffi.Int32 Function(
  ffi.Pointer<ffi.Void> arg0,
  ffi.Pointer<ffi.Void> client_data,
  ffi.Pointer<IndexerCallbacks> index_callbacks,
  ffi.Uint32 index_callbacks_size,
  ffi.Uint32 index_options,
  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.Pointer<ffi.Pointer<CXTranslationUnitImpl>> out_TU,
  ffi.Uint32 TU_options,
);

typedef _dart_clang_indexSourceFile = int Function(
  ffi.Pointer<ffi.Void> arg0,
  ffi.Pointer<ffi.Void> client_data,
  ffi.Pointer<IndexerCallbacks> index_callbacks,
  int index_callbacks_size,
  int index_options,
  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,
  ffi.Pointer<ffi.Pointer<CXTranslationUnitImpl>> out_TU,
  int TU_options,
);

typedef _c_clang_indexSourceFileFullArgv = ffi.Int32 Function(
  ffi.Pointer<ffi.Void> arg0,
  ffi.Pointer<ffi.Void> client_data,
  ffi.Pointer<IndexerCallbacks> index_callbacks,
  ffi.Uint32 index_callbacks_size,
  ffi.Uint32 index_options,
  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.Pointer<ffi.Pointer<CXTranslationUnitImpl>> out_TU,
  ffi.Uint32 TU_options,
);

typedef _dart_clang_indexSourceFileFullArgv = int Function(
  ffi.Pointer<ffi.Void> arg0,
  ffi.Pointer<ffi.Void> client_data,
  ffi.Pointer<IndexerCallbacks> index_callbacks,
  int index_callbacks_size,
  int index_options,
  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,
  ffi.Pointer<ffi.Pointer<CXTranslationUnitImpl>> out_TU,
  int TU_options,
);

typedef _c_clang_indexTranslationUnit = ffi.Int32 Function(
  ffi.Pointer<ffi.Void> arg0,
  ffi.Pointer<ffi.Void> client_data,
  ffi.Pointer<IndexerCallbacks> index_callbacks,
  ffi.Uint32 index_callbacks_size,
  ffi.Uint32 index_options,
  ffi.Pointer<CXTranslationUnitImpl> arg5,
);

typedef _dart_clang_indexTranslationUnit = int Function(
  ffi.Pointer<ffi.Void> arg0,
  ffi.Pointer<ffi.Void> client_data,
  ffi.Pointer<IndexerCallbacks> index_callbacks,
  int index_callbacks_size,
  int index_options,
  ffi.Pointer<CXTranslationUnitImpl> arg5,
);

typedef _c_clang_indexLoc_getFileLocation = ffi.Void Function(
  CXIdxLoc loc,
  ffi.Pointer<ffi.Pointer<ffi.Void>> indexFile,
  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_indexLoc_getFileLocation = void Function(
  CXIdxLoc loc,
  ffi.Pointer<ffi.Pointer<ffi.Void>> indexFile,
  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_indexLoc_getCXSourceLocation = CXSourceLocation Function(
  CXIdxLoc loc,
);

typedef _dart_clang_indexLoc_getCXSourceLocation = CXSourceLocation Function(
  CXIdxLoc loc,
);

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

typedef _c_clang_Type_visitFields = ffi.Uint32 Function(
  CXType T,
  ffi.Pointer<ffi.NativeFunction<CXFieldVisitor>> visitor,
  ffi.Pointer<ffi.Void> client_data,
);

typedef _dart_clang_Type_visitFields = int Function(
  CXType T,
  ffi.Pointer<ffi.NativeFunction<CXFieldVisitor>> visitor,
  ffi.Pointer<ffi.Void> client_data,
);

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

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

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

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

typedef _typedefC_6 = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<ffi.Void>,
  ffi.Pointer<CXIdxIncludedFileInfo>,
);

typedef _typedefC_7 = ffi.Pointer<ffi.Void> Function(
  ffi.Pointer<ffi.Void>,
  ffi.Pointer<CXIdxImportedASTFileInfo>,
);

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

typedef _typedefC_9 = ffi.Void Function(
  ffi.Pointer<ffi.Void>,
  ffi.Pointer<CXIdxDeclInfo>,
);

typedef _typedefC_10 = ffi.Void Function(
  ffi.Pointer<ffi.Void>,
  ffi.Pointer<CXIdxEntityRefInfo>,
);