BlendBasicType = enum
  B_char, B_uchar, B_short, B_ushort, B_int32, B_long, B_ulong, B_float,
  B_double, B_int64, B_uint64, B_void, B_int8

BlendFile = ref BlendFileVal

BlendFileVal = object
  mem: pointer
  file_path*: string
  dna: TypeAttrsRef
  blocks: FNodesByAddress
  named_blocks*: NamedBlocks
  struct_to_type: StructToTypeMap
  type_lengths: TypeLengths
  type_names: seq[cstring]
  old_mem_ptr: pointer
  endp: pointer
  byte_seq: seq[byte]

FNode = object
  blend_file {.cursor.}: BlendFile
  blend_file_ref: BlendFile
  p: pointer
  count: uint32
  tid: uint16

proc `$`(n: FNode; depth = 0; max_depth = 3; just_name = false;
         dump_pointers = false): string {....raises: [KeyError], tags: [].}

proc `[]`(n: FNode; index: Natural): FNode {....raises: [KeyError], tags: [].}

proc `[]`(n: FNode; name: string): FNode {....raises: [KeyError], tags: [].}

proc `[]`(ns: FNodeSlice; name: string): FNodeSlice

proc `[]`[T](a: ptr array[16, T]; r: HSlice): seq[T]

proc `[]`[U, V: Ordinal](node: FNode; s: HSlice[U, V]): FNodeSlice[V]

proc basic_type(n: FNode): BlendBasicType {....raises: [], tags: [].}

proc contains(n: FNode; name: string): bool {....raises: [], tags: [].}

proc cstr(n: FNode): cstring {....raises: [], tags: [].}

proc debug_dump(f: BlendFile) {....raises: [KeyError], tags: [].}

proc f32(n: FNode): ptr array[16, float32] {.inline, ...raises: [], tags: [].}

proc f64(n: FNode): ptr array[16, float64] {....raises: [], tags: [].}

proc find_pointer_usage(n: FNode) {....raises: [], tags: [].}

proc get[T](x: ptr array[16, T]; y = 0): T

proc hash(n: FNode): Hash {....raises: [], tags: [].}

proc i8(n: FNode): ptr array[16, int8] {....raises: [], tags: [].}

proc i16(n: FNode): ptr array[16, int16] {....raises: [], tags: [].}

proc i32(n: FNode): ptr array[16, int32] {....raises: [], tags: [].}

proc i64(n: FNode): ptr array[16, int64] {....raises: [], tags: [].}

proc len(node: FNode): uint32 {....raises: [], tags: [].}

proc openBlendFile(path: string; data: pointer; len: int): BlendFile {.
    ...raises: [ValueError, KeyError], tags: [].}

proc set_type(n: var FNode; s: string) {....raises: [ValueError], tags: [].}

proc strip2(s: string): string {.inline, ...raises: [], tags: [].}

proc u8(n: FNode): ptr array[16, uint8] {....raises: [], tags: [].}

proc u16(n: FNode): ptr array[16, uint16] {....raises: [], tags: [].}

proc u64(n: FNode): ptr array[16, uint64] {....raises: [], tags: [].}

iterator items(n: FNode; stride = 0): FNode {....raises: [KeyError], tags: [].}

iterator items[T](ns: FNodeSlice[T]): FNode

iterator pairs[T](ns: FNodeSlice[T]): (int, FNode)

template `$`(p: pointer): string

template `.`[T: FNode or FNodeSlice](n: T; field: untyped): T

template `==`(n, n2: FNode): bool

template `?.`(n: FNode; y: untyped): untyped

template `[]`(blocks: NamedBlocks; s: string): untyped

template arr_len(node: FNode; arr, len: untyped): FNodeSlice[int32]

template get_array(n: FNode; size: Natural; T: typedesc): ptr UncheckedArray[
    T:type]

template isNil(n: FNode): bool

template str(n: FNode): string

template type_name(n: FNode): cstring

template valid(n: FNode): bool