#ifndef TREE_SITTER_API_H_

 #define TREE_SITTER_API_H_

 #ifndef TREE_SITTER_HIDE_SYMBOLS

 #if defined(__GNUC__) || defined(__clang__)

 #pragma GCC visibility push(default)

 #endif

 #endif

 #include <stdlib.h>

 #include <stdint.h>

 #include <stdbool.h>

 #ifdef __cplusplus

 extern "C" {

 #endif

 /****************************/

 /* Section - ABI Versioning */

 /****************************/

 /**

  * The latest ABI version that is supported by the current version of the

  * library. When Languages are generated by the Tree-sitter CLI, they are

  * assigned an ABI version number that corresponds to the current CLI version.

  * The Tree-sitter library is generally backwards-compatible with languages

  * generated using older CLI versions, but is not forwards-compatible.

  */

 #define TREE_SITTER_LANGUAGE_VERSION 14

 /**

  * The earliest ABI version that is supported by the current version of the

  * library.

  */

 #define TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION 13

 /*******************/

 /* Section - Types */

 /*******************/

 typedef uint16_t TSStateId;

 typedef uint16_t TSSymbol;

 typedef uint16_t TSFieldId;

 typedef struct TSLanguage TSLanguage;

 typedef struct TSParser TSParser;

 typedef struct TSTree TSTree;

 typedef struct TSQuery TSQuery;

 typedef struct TSQueryCursor TSQueryCursor;

 typedef struct TSLookaheadIterator TSLookaheadIterator;

 typedef enum TSInputEncoding {

   TSInputEncodingUTF8,

   TSInputEncodingUTF16,

 } TSInputEncoding;

 typedef enum TSSymbolType {

   TSSymbolTypeRegular,

   TSSymbolTypeAnonymous,

   TSSymbolTypeAuxiliary,

 } TSSymbolType;

 typedef struct TSPoint {

   uint32_t row;

   uint32_t column;

 } TSPoint;

 typedef struct TSRange {

   TSPoint start_point;

   TSPoint end_point;

   uint32_t start_byte;

   uint32_t end_byte;

 } TSRange;

 typedef struct TSInput {

   void *payload;

   const char *(*read)(void *payload, uint32_t byte_index, TSPoint position, uint32_t *bytes_read);

   TSInputEncoding encoding;

 } TSInput;

 typedef enum TSLogType {

   TSLogTypeParse,

   TSLogTypeLex,

 } TSLogType;

 typedef struct TSLogger {

   void *payload;

   void (*log)(void *payload, TSLogType log_type, const char *buffer);

 } TSLogger;

 typedef struct TSInputEdit {

   uint32_t start_byte;

   uint32_t old_end_byte;

   uint32_t new_end_byte;

   TSPoint start_point;

   TSPoint old_end_point;

   TSPoint new_end_point;

 } TSInputEdit;

 typedef struct TSNode {

   uint32_t context[4];

   const void *id;

   const TSTree *tree;

 } TSNode;

 typedef struct TSTreeCursor {

   const void *tree;

   const void *id;

   uint32_t context[3];

 } TSTreeCursor;

 typedef struct TSQueryCapture {

   TSNode node;

   uint32_t index;

 } TSQueryCapture;

 typedef enum TSQuantifier {

   TSQuantifierZero = 0, // must match the array initialization value

   TSQuantifierZeroOrOne,

   TSQuantifierZeroOrMore,

   TSQuantifierOne,

   TSQuantifierOneOrMore,

 } TSQuantifier;

 typedef struct TSQueryMatch {

   uint32_t id;

   uint16_t pattern_index;

   uint16_t capture_count;

   const TSQueryCapture *captures;

 } TSQueryMatch;

 typedef enum TSQueryPredicateStepType {

   TSQueryPredicateStepTypeDone,

   TSQueryPredicateStepTypeCapture,

   TSQueryPredicateStepTypeString,

 } TSQueryPredicateStepType;

 typedef struct TSQueryPredicateStep {

   TSQueryPredicateStepType type;

   uint32_t value_id;

 } TSQueryPredicateStep;

 typedef enum TSQueryError {

   TSQueryErrorNone = 0,

   TSQueryErrorSyntax,

   TSQueryErrorNodeType,

   TSQueryErrorField,

   TSQueryErrorCapture,

   TSQueryErrorStructure,

   TSQueryErrorLanguage,

 } TSQueryError;

 /********************/

 /* Section - Parser */

 /********************/

 /**

  * Create a new parser.

  */

 TSParser *ts_parser_new(void);

 /**

  * Delete the parser, freeing all of the memory that it used.

  */

 void ts_parser_delete(TSParser *self);

 /**

  * Get the parser's current language.

  */

 const TSLanguage *ts_parser_language(const TSParser *self);

 /**

  * Set the language that the parser should use for parsing.

  *

  * Returns a boolean indicating whether or not the language was successfully

  * assigned. True means assignment succeeded. False means there was a version

  * mismatch: the language was generated with an incompatible version of the

  * Tree-sitter CLI. Check the language's version using [`ts_language_version`]

  * and compare it to this library's [`TREE_SITTER_LANGUAGE_VERSION`] and

  * [`TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION`] constants.

  */

 bool ts_parser_set_language(TSParser *self, const TSLanguage *language);

 /**

  * Set the ranges of text that the parser should include when parsing.

  *

  * By default, the parser will always include entire documents. This function

  * allows you to parse only a *portion* of a document but still return a syntax

  * tree whose ranges match up with the document as a whole. You can also pass

  * multiple disjoint ranges.

  *

  * The second and third parameters specify the location and length of an array

  * of ranges. The parser does *not* take ownership of these ranges; it copies

  * the data, so it doesn't matter how these ranges are allocated.

  *

  * If `count` is zero, then the entire document will be parsed. Otherwise,

  * the given ranges must be ordered from earliest to latest in the document,

  * and they must not overlap. That is, the following must hold for all:

  *

  * `i < count - 1`: `ranges[i].end_byte <= ranges[i + 1].start_byte`

  *

  * If this requirement is not satisfied, the operation will fail, the ranges

  * will not be assigned, and this function will return `false`. On success,

  * this function returns `true`

  */

 bool ts_parser_set_included_ranges(

   TSParser *self,

   const TSRange *ranges,

   uint32_t count

 );

 /**

  * Get the ranges of text that the parser will include when parsing.

  *

  * The returned pointer is owned by the parser. The caller should not free it

  * or write to it. The length of the array will be written to the given

  * `count` pointer.

  */

 const TSRange *ts_parser_included_ranges(

   const TSParser *self,

   uint32_t *count

 );

 /**

  * Use the parser to parse some source code and create a syntax tree.

  *

  * If you are parsing this document for the first time, pass `NULL` for the

  * `old_tree` parameter. Otherwise, if you have already parsed an earlier

  * version of this document and the document has since been edited, pass the

  * previous syntax tree so that the unchanged parts of it can be reused.

  * This will save time and memory. For this to work correctly, you must have

  * already edited the old syntax tree using the [`ts_tree_edit`] function in a

  * way that exactly matches the source code changes.

  *

  * The [`TSInput`] parameter lets you specify how to read the text. It has the

  * following three fields:

  * 1. [`read`]: A function to retrieve a chunk of text at a given byte offset

  *    and (row, column) position. The function should return a pointer to the

  *    text and write its length to the [`bytes_read`] pointer. The parser does

  *    not take ownership of this buffer; it just borrows it until it has

  *    finished reading it. The function should write a zero value to the

  *    [`bytes_read`] pointer to indicate the end of the document.

  * 2. [`payload`]: An arbitrary pointer that will be passed to each invocation

  *    of the [`read`] function.

  * 3. [`encoding`]: An indication of how the text is encoded. Either

  *    `TSInputEncodingUTF8` or `TSInputEncodingUTF16`.

  *

  * This function returns a syntax tree on success, and `NULL` on failure. There

  * are three possible reasons for failure:

  * 1. The parser does not have a language assigned. Check for this using the

       [`ts_parser_language`] function.

  * 2. Parsing was cancelled due to a timeout that was set by an earlier call to

  *    the [`ts_parser_set_timeout_micros`] function. You can resume parsing from

  *    where the parser left out by calling [`ts_parser_parse`] again with the

  *    same arguments. Or you can start parsing from scratch by first calling

  *    [`ts_parser_reset`].

  * 3. Parsing was cancelled using a cancellation flag that was set by an

  *    earlier call to [`ts_parser_set_cancellation_flag`]. You can resume parsing

  *    from where the parser left out by calling [`ts_parser_parse`] again with

  *    the same arguments.

  *

  * [`read`]: TSInput::read

  * [`payload`]: TSInput::payload

  * [`encoding`]: TSInput::encoding

  * [`bytes_read`]: TSInput::read

  */

 TSTree *ts_parser_parse(

   TSParser *self,

   const TSTree *old_tree,

   TSInput input

 );

 /**

  * Use the parser to parse some source code stored in one contiguous buffer.

  * The first two parameters are the same as in the [`ts_parser_parse`] function

  * above. The second two parameters indicate the location of the buffer and its

  * length in bytes.

  */

 TSTree *ts_parser_parse_string(

   TSParser *self,

   const TSTree *old_tree,

   const char *string,

   uint32_t length

 );

 /**

  * Use the parser to parse some source code stored in one contiguous buffer with

  * a given encoding. The first four parameters work the same as in the

  * [`ts_parser_parse_string`] method above. The final parameter indicates whether

  * the text is encoded as UTF8 or UTF16.

  */

 TSTree *ts_parser_parse_string_encoding(

   TSParser *self,

   const TSTree *old_tree,

   const char *string,

   uint32_t length,

   TSInputEncoding encoding

 );

 /**

  * Instruct the parser to start the next parse from the beginning.

  *

  * If the parser previously failed because of a timeout or a cancellation, then

  * by default, it will resume where it left off on the next call to

  * [`ts_parser_parse`] or other parsing functions. If you don't want to resume,

  * and instead intend to use this parser to parse some other document, you must

  * call [`ts_parser_reset`] first.

  */

 void ts_parser_reset(TSParser *self);

 /**

  * Set the maximum duration in microseconds that parsing should be allowed to

  * take before halting.

  *

  * If parsing takes longer than this, it will halt early, returning NULL.

  * See [`ts_parser_parse`] for more information.

  */

 void ts_parser_set_timeout_micros(TSParser *self, uint64_t timeout_micros);

 /**

  * Get the duration in microseconds that parsing is allowed to take.

  */

 uint64_t ts_parser_timeout_micros(const TSParser *self);

 /**

  * Set the parser's current cancellation flag pointer.

  *

  * If a non-null pointer is assigned, then the parser will periodically read

  * from this pointer during parsing. If it reads a non-zero value, it will

  * halt early, returning NULL. See [`ts_parser_parse`] for more information.

  */

 void ts_parser_set_cancellation_flag(TSParser *self, const size_t *flag);

 /**

  * Get the parser's current cancellation flag pointer.

  */

 const size_t *ts_parser_cancellation_flag(const TSParser *self);

 /**

  * Set the logger that a parser should use during parsing.

  *

  * The parser does not take ownership over the logger payload. If a logger was

  * previously assigned, the caller is responsible for releasing any memory

  * owned by the previous logger.

  */

 void ts_parser_set_logger(TSParser *self, TSLogger logger);

 /**

  * Get the parser's current logger.

  */

 TSLogger ts_parser_logger(const TSParser *self);

 /**

  * Set the file descriptor to which the parser should write debugging graphs

  * during parsing. The graphs are formatted in the DOT language. You may want

  * to pipe these graphs directly to a `dot(1)` process in order to generate

  * SVG output. You can turn off this logging by passing a negative number.

  */

 void ts_parser_print_dot_graphs(TSParser *self, int fd);

 /******************/

 /* Section - Tree */

 /******************/

 /**

  * Create a shallow copy of the syntax tree. This is very fast.

  *

  * You need to copy a syntax tree in order to use it on more than one thread at

  * a time, as syntax trees are not thread safe.

  */

 TSTree *ts_tree_copy(const TSTree *self);

 /**

  * Delete the syntax tree, freeing all of the memory that it used.

  */

 void ts_tree_delete(TSTree *self);

 /**

  * Get the root node of the syntax tree.

  */

 TSNode ts_tree_root_node(const TSTree *self);

 /**

  * Get the root node of the syntax tree, but with its position

  * shifted forward by the given offset.

  */

 TSNode ts_tree_root_node_with_offset(

   const TSTree *self,

   uint32_t offset_bytes,

   TSPoint offset_extent

 );

 /**

  * Get the language that was used to parse the syntax tree.

  */

 const TSLanguage *ts_tree_language(const TSTree *self);

 /**

  * Get the array of included ranges that was used to parse the syntax tree.

  *

  * The returned pointer must be freed by the caller.

  */

 TSRange *ts_tree_included_ranges(const TSTree *self, uint32_t *length);

 /**

  * Edit the syntax tree to keep it in sync with source code that has been

  * edited.

  *

  * You must describe the edit both in terms of byte offsets and in terms of

  * (row, column) coordinates.

  */

 void ts_tree_edit(TSTree *self, const TSInputEdit *edit);

 /**

  * Compare an old edited syntax tree to a new syntax tree representing the same

  * document, returning an array of ranges whose syntactic structure has changed.

  *

  * For this to work correctly, the old syntax tree must have been edited such

  * that its ranges match up to the new tree. Generally, you'll want to call

  * this function right after calling one of the [`ts_parser_parse`] functions.

  * You need to pass the old tree that was passed to parse, as well as the new

  * tree that was returned from that function.

  *

  * The returned array is allocated using `malloc` and the caller is responsible

  * for freeing it using `free`. The length of the array will be written to the

  * given `length` pointer.

  */

 TSRange *ts_tree_get_changed_ranges(

   const TSTree *old_tree,

   const TSTree *new_tree,

   uint32_t *length

 );

 /**

  * Write a DOT graph describing the syntax tree to the given file.

  */

 void ts_tree_print_dot_graph(const TSTree *self, int file_descriptor);

 /******************/

 /* Section - Node */

 /******************/

 /**

  * Get the node's type as a null-terminated string.

  */

 const char *ts_node_type(TSNode self);

 /**

  * Get the node's type as a numerical id.

  */

 TSSymbol ts_node_symbol(TSNode self);

 /**

  * Get the node's language.

  */

 const TSLanguage *ts_node_language(TSNode self);

 /**

  * Get the node's type as it appears in the grammar ignoring aliases as a

  * null-terminated string.

  */

 const char *ts_node_grammar_type(TSNode self);

 /**

  * Get the node's type as a numerical id as it appears in the grammar ignoring

  * aliases. This should be used in [`ts_language_next_state`] instead of

  * [`ts_node_symbol`].

  */

 TSSymbol ts_node_grammar_symbol(TSNode self);

 /**

  * Get the node's start byte.

  */

 uint32_t ts_node_start_byte(TSNode self);

 /**