{
  "api": "0.1",
  "brand": "Easy Universal",
  "functions": [
    {
      "declaration": "uint scan(const string&in str, ?&out...)",
      "namespace": ""
    },
    {
      "declaration": "string format(const string&in fmt, const ?&in...)",
      "namespace": ""
    },
    {
      "declaration": "string formatInt(int64 val, const string&in options = \"\", uint width = 0)",
      "namespace": ""
    },
    {
      "declaration": "string formatUInt(uint64 val, const string&in options = \"\", uint width = 0)",
      "namespace": ""
    },
    {
      "declaration": "string formatFloat(double val, const string&in options = \"\", uint width = 0, uint precision = 0)",
      "namespace": ""
    },
    {
      "declaration": "int64 parseInt(const string&in, uint base = 10, uint&out byteCount = 0)",
      "namespace": ""
    },
    {
      "declaration": "uint64 parseUInt(const string&in, uint base = 10, uint&out byteCount = 0)",
      "namespace": ""
    },
    {
      "declaration": "double parseFloat(const string&in, uint&out byteCount = 0)",
      "namespace": ""
    },
    {
      "declaration": "float cos(float)",
      "namespace": "math"
    },
    {
      "declaration": "float sin(float)",
      "namespace": "math"
    },
    {
      "declaration": "float tan(float)",
      "namespace": "math"
    },
    {
      "declaration": "float acos(float)",
      "namespace": "math"
    },
    {
      "declaration": "float asin(float)",
      "namespace": "math"
    },
    {
      "declaration": "float atan(float)",
      "namespace": "math"
    },
    {
      "declaration": "float atan2(float, float)",
      "namespace": "math"
    },
    {
      "declaration": "float cosh(float)",
      "namespace": "math"
    },
    {
      "declaration": "float sinh(float)",
      "namespace": "math"
    },
    {
      "declaration": "float tanh(float)",
      "namespace": "math"
    },
    {
      "declaration": "float log(float)",
      "namespace": "math"
    },
    {
      "declaration": "float log10(float)",
      "namespace": "math"
    },
    {
      "declaration": "float pow(float, float)",
      "namespace": "math"
    },
    {
      "declaration": "float sqrt(float)",
      "namespace": "math"
    },
    {
      "declaration": "float ceil(float)",
      "namespace": "math"
    },
    {
      "declaration": "float abs(float)",
      "namespace": "math"
    },
    {
      "declaration": "float floor(float)",
      "namespace": "math"
    },
    {
      "declaration": "float fraction(float)",
      "namespace": "math"
    },
    {
      "declaration": "double sin(double)",
      "namespace": "math"
    },
    {
      "declaration": "double cos(double)",
      "namespace": "math"
    },
    {
      "declaration": "double tan(double)",
      "namespace": "math"
    },
    {
      "declaration": "double asin(double)",
      "namespace": "math"
    },
    {
      "declaration": "double acos(double)",
      "namespace": "math"
    },
    {
      "declaration": "double atan(double)",
      "namespace": "math"
    },
    {
      "declaration": "double sinh(double)",
      "namespace": "math"
    },
    {
      "declaration": "double cosh(double)",
      "namespace": "math"
    },
    {
      "declaration": "double tanh(double)",
      "namespace": "math"
    },
    {
      "declaration": "double log(double)",
      "namespace": "math"
    },
    {
      "declaration": "double log10(double)",
      "namespace": "math"
    },
    {
      "declaration": "double sqrt(double)",
      "namespace": "math"
    },
    {
      "declaration": "double abs(double)",
      "namespace": "math"
    },
    {
      "declaration": "double ceil(double)",
      "namespace": "math"
    },
    {
      "declaration": "double floor(double)",
      "namespace": "math"
    },
    {
      "declaration": "double fraction(double)",
      "namespace": "math"
    },
    {
      "declaration": "double atan2(double, double)",
      "namespace": "math"
    },
    {
      "declaration": "double pow(double, double)",
      "namespace": "math"
    },
    {
      "declaration": "float fpFromIEEE(uint)",
      "namespace": "math"
    },
    {
      "declaration": "double fpFromIEEE(uint64)",
      "namespace": "math"
    },
    {
      "declaration": "uint fpToIEEE(float)",
      "namespace": "math"
    },
    {
      "declaration": "uint64 fpToIEEE(double)",
      "namespace": "math"
    },
    {
      "declaration": "bool is_finite(float)",
      "namespace": "math"
    },
    {
      "declaration": "bool is_finite(double)",
      "namespace": "math"
    },
    {
      "declaration": "bool closeTo(float, float, float epsilon = 0.00001f)",
      "namespace": "math"
    },
    {
      "declaration": "bool closeTo(double, double, double epsilon = 0.0000000001)",
      "namespace": "math"
    },
    {
      "declaration": "bool project(const matrix4&in, const vec3&in, float, float, vec2&out)",
      "namespace": "projection"
    },
    {
      "declaration": "bool perspective(const vec3&in, const vec3&in, const vec3&in, const vec3&in, const vec3&in, float, float, float, vec2&out)",
      "namespace": "projection"
    },
    {
      "declaration": "bool from_bytes(const string&in, matrix4&out)",
      "namespace": "projection"
    },
    {
      "declaration": "memory_buffer@ from_bytes(const string&in)",
      "namespace": "buffer"
    },
    {
      "declaration": "uint submit(const string&in kind, const string&in payload)",
      "namespace": "jobs"
    },
    {
      "declaration": "string state(uint)",
      "namespace": "jobs"
    },
    {
      "declaration": "string body(uint)",
      "namespace": "jobs"
    },
    {
      "declaration": "string error(uint)",
      "namespace": "jobs"
    },
    {
      "declaration": "bool release(uint)",
      "namespace": "jobs"
    },
    {
      "declaration": "bool enabled()",
      "namespace": "gui"
    },
    {
      "declaration": "string get(const string&in, const string&in fallback = '')",
      "namespace": "gui"
    },
    {
      "declaration": "void set(const string&in, const string&in)",
      "namespace": "gui"
    },
    {
      "declaration": "bool contains(const string&in)",
      "namespace": "gui"
    },
    {
      "declaration": "bool remove(const string&in)",
      "namespace": "gui"
    },
    {
      "declaration": "bool enabled()",
      "namespace": "config"
    },
    {
      "declaration": "bool contains(const string&in)",
      "namespace": "config"
    },
    {
      "declaration": "bool remove(const string&in)",
      "namespace": "config"
    },
    {
      "declaration": "bool get_bool(const string&in, bool fallback = false)",
      "namespace": "config"
    },
    {
      "declaration": "void set_bool(const string&in, bool)",
      "namespace": "config"
    },
    {
      "declaration": "int get_int(const string&in, int fallback = 0)",
      "namespace": "config"
    },
    {
      "declaration": "void set_int(const string&in, int)",
      "namespace": "config"
    },
    {
      "declaration": "float get_float(const string&in, float fallback = 0)",
      "namespace": "config"
    },
    {
      "declaration": "void set_float(const string&in, float)",
      "namespace": "config"
    },
    {
      "declaration": "bool enabled()",
      "namespace": "http"
    },
    {
      "declaration": "uint get(const string&in)",
      "namespace": "http"
    },
    {
      "declaration": "uint post(const string&in, const string&in)",
      "namespace": "http"
    },
    {
      "declaration": "string state(uint)",
      "namespace": "http"
    },
    {
      "declaration": "uint status(uint)",
      "namespace": "http"
    },
    {
      "declaration": "string body(uint)",
      "namespace": "http"
    },
    {
      "declaration": "string error(uint)",
      "namespace": "http"
    },
    {
      "declaration": "bool release(uint)",
      "namespace": "http"
    },
    {
      "declaration": "bool project(const string&in, float, float, float, float&out, float&out)",
      "namespace": "geometry"
    },
    {
      "declaration": "float distance3(float, float, float, float, float, float)",
      "namespace": "geometry"
    },
    {
      "declaration": "bool declared()",
      "namespace": "adapter"
    },
    {
      "declaration": "string game()",
      "namespace": "adapter"
    },
    {
      "declaration": "string source()",
      "namespace": "adapter"
    },
    {
      "declaration": "bool has_capability(const string&in)",
      "namespace": "adapter"
    },
    {
      "declaration": "bool source_available()",
      "namespace": "adapter"
    },
    {
      "declaration": "string status()",
      "namespace": "adapter"
    },
    {
      "declaration": "string last_error()",
      "namespace": "adapter"
    },
    {
      "declaration": "bool set_status(const string&in, const string&in message = '')",
      "namespace": "adapter"
    },
    {
      "declaration": "bool add_entity(uint64, const string&in, float, float, float, float, uint)",
      "namespace": "adapter"
    },
    {
      "declaration": "uint entity_count()",
      "namespace": "adapter"
    },
    {
      "declaration": "bool entity_position(uint, float&out, float&out, float&out)",
      "namespace": "adapter"
    },
    {
      "declaration": "uint64 entity_id(uint)",
      "namespace": "adapter"
    },
    {
      "declaration": "string entity_label(uint)",
      "namespace": "adapter"
    },
    {
      "declaration": "float entity_health(uint)",
      "namespace": "adapter"
    },
    {
      "declaration": "uint entity_team(uint)",
      "namespace": "adapter"
    },
    {
      "declaration": "bool enabled()",
      "namespace": "wt"
    },
    {
      "declaration": "bool available()",
      "namespace": "wt"
    },
    {
      "declaration": "bool read_number(const string&in, const string&in, float&out)",
      "namespace": "wt"
    },
    {
      "declaration": "bool enabled()",
      "namespace": "source"
    },
    {
      "declaration": "string kind()",
      "namespace": "source"
    },
    {
      "declaration": "uint provider_pid()",
      "namespace": "source"
    },
    {
      "declaration": "string status()",
      "namespace": "source"
    },
    {
      "declaration": "string last_error()",
      "namespace": "source"
    },
    {
      "declaration": "bool has_capability(const string&in)",
      "namespace": "source"
    },
    {
      "declaration": "string snapshot()",
      "namespace": "source"
    },
    {
      "declaration": "bool update(const string&in, const string&in)",
      "namespace": "source"
    },
    {
      "declaration": "string update_status()",
      "namespace": "source"
    },
    {
      "declaration": "bool read_number(const string&in, double&out)",
      "namespace": "source"
    },
    {
      "declaration": "bool read_text(const string&in, string&out)",
      "namespace": "source"
    },
    {
      "declaration": "bool read_bool(const string&in, bool&out)",
      "namespace": "source"
    },
    {
      "declaration": "bool enabled()",
      "namespace": "input"
    },
    {
      "declaration": "bool active()",
      "namespace": "input"
    },
    {
      "declaration": "bool key_down(uint)",
      "namespace": "input"
    },
    {
      "declaration": "bool move_mouse(int, int)",
      "namespace": "input"
    },
    {
      "declaration": "bool click_left()",
      "namespace": "input"
    },
    {
      "declaration": "string last_error()",
      "namespace": "input"
    },
    {
      "declaration": "bool attached()",
      "namespace": "process"
    },
    {
      "declaration": "bool alive()",
      "namespace": "process"
    },
    {
      "declaration": "memory_region[]@ enumerate_memory_regions(uint pid)",
      "namespace": "process"
    },
    {
      "declaration": "module_info[]@ enumerate_modules(uint pid, const string&in source)",
      "namespace": "process"
    },
    {
      "declaration": "module_difference[]@ diff_modules(uint pid)",
      "namespace": "process"
    },
    {
      "declaration": "thread_info[]@ enumerate_threads(uint pid)",
      "namespace": "process"
    },
    {
      "declaration": "handle_info[]@ enumerate_handles(uint pid)",
      "namespace": "process"
    },
    {
      "declaration": "thread_info[]@ find_orphan_threads(uint pid, const module_info[]&in modules)",
      "namespace": "process"
    },
    {
      "declaration": "bool write_enabled()",
      "namespace": "process"
    },
    {
      "declaration": "bool write_u8(uint pid, uint64 address, uint8 value)",
      "namespace": "process"
    },
    {
      "declaration": "bool write_u16(uint pid, uint64 address, uint16 value)",
      "namespace": "process"
    },
    {
      "declaration": "bool write_u32(uint pid, uint64 address, uint value)",
      "namespace": "process"
    },
    {
      "declaration": "bool write_u64(uint pid, uint64 address, uint64 value)",
      "namespace": "process"
    },
    {
      "declaration": "bool write_f32(uint pid, uint64 address, float value)",
      "namespace": "process"
    },
    {
      "declaration": "bool write_f64(uint pid, uint64 address, double value)",
      "namespace": "process"
    },
    {
      "declaration": "bool write_bytes(uint pid, uint64 address, const string&in bytes)",
      "namespace": "process"
    },
    {
      "declaration": "bool write_protected(uint pid, uint64 address, const string&in bytes, uint new_protect)",
      "namespace": "process"
    },
    {
      "declaration": "uint64 find_pattern(uint pid, const string&in module, const string&in pattern, const string&in mask)",
      "namespace": "process"
    },
    {
      "declaration": "uint64[]@ find_all_patterns(uint pid, const string&in module, const string&in pattern, const string&in mask)",
      "namespace": "process"
    },
    {
      "declaration": "uint64 resolve_rip_relative(uint pid, uint64 instruction, uint displacement_offset, uint instruction_length)",
      "namespace": "process"
    },
    {
      "declaration": "bool save_profile(uint pid, const string&in path)",
      "namespace": "process"
    },
    {
      "declaration": "string diff_profiles(const string&in path_a, const string&in path_b)",
      "namespace": "process"
    },
    {
      "declaration": "string diagnostics(uint pid)",
      "namespace": "process"
    },
    {
      "declaration": "uint pid()",
      "namespace": "process"
    },
    {
      "declaration": "string name()",
      "namespace": "process"
    },
    {
      "declaration": "uint64 module_base(const string&in)",
      "namespace": "process"
    },
    {
      "declaration": "string last_error()",
      "namespace": "process"
    },
    {
      "declaration": "bool read_u32(uint64, uint&out)",
      "namespace": "process"
    },
    {
      "declaration": "bool read_u64(uint64, uint64&out)",
      "namespace": "process"
    },
    {
      "declaration": "bool read_float(uint64, float&out)",
      "namespace": "process"
    },
    {
      "declaration": "bool read_bytes(uint64, uint, string&out)",
      "namespace": "process"
    },
    {
      "declaration": "bool read_u8(uint64, uint8&out)",
      "namespace": "process"
    },
    {
      "declaration": "bool read_u16(uint64, uint16&out)",
      "namespace": "process"
    },
    {
      "declaration": "bool read_i32(uint64, int&out)",
      "namespace": "process"
    },
    {
      "declaration": "bool read_double(uint64, double&out)",
      "namespace": "process"
    },
    {
      "declaration": "memory_buffer@ read_buffer(uint64, uint)",
      "namespace": "process"
    },
    {
      "declaration": "void log(const string&in)",
      "namespace": "runtime"
    },
    {
      "declaration": "float width()",
      "namespace": "screen"
    },
    {
      "declaration": "float height()",
      "namespace": "screen"
    },
    {
      "declaration": "float seconds()",
      "namespace": "time"
    },
    {
      "declaration": "float delta()",
      "namespace": "time"
    },
    {
      "declaration": "float x()",
      "namespace": "demo"
    },
    {
      "declaration": "float y()",
      "namespace": "demo"
    },
    {
      "declaration": "void text(float, float, const string&in, uint color = 0xffffffff)",
      "namespace": "render"
    },
    {
      "declaration": "void line(float, float, float, float, uint color = 0xffffffff, float thickness = 1)",
      "namespace": "render"
    },
    {
      "declaration": "void circle(float, float, float, uint color = 0xffffffff)",
      "namespace": "render"
    },
    {
      "declaration": "void filled_circle(float, float, float, uint color = 0xffffffff)",
      "namespace": "render"
    },
    {
      "declaration": "void push_clip(float, float, float, float)",
      "namespace": "render"
    },
    {
      "declaration": "void pop_clip()",
      "namespace": "render"
    },
    {
      "declaration": "float scroll(const string&in, float, float, float, float, float, float)",
      "namespace": "ui"
    },
    {
      "declaration": "void rect(float, float, float, float, uint color = 0xffffffff, bool filled = false)",
      "namespace": "render"
    },
    {
      "declaration": "void label(const string&in)",
      "namespace": "ui"
    },
    {
      "declaration": "bool button(const string&in, const string&in, float, float, float, float)",
      "namespace": "ui"
    },
    {
      "declaration": "bool checkbox(const string&in, const string&in, bool, float, float, float, float)",
      "namespace": "ui"
    },
    {
      "declaration": "float slider(const string&in, const string&in, float, float, float, float, float, float, float, float)",
      "namespace": "ui"
    },
    {
      "declaration": "uint cycle(const string&in, const string&in, uint, uint, float, float, float, float)",
      "namespace": "ui"
    },
    {
      "declaration": "string textbox(const string&in, const string&in, const string&in, uint, float, float, float, float)",
      "namespace": "ui"
    },
    {
      "declaration": "void theme(uint background, uint panel, uint text, uint accent, uint border)",
      "namespace": "ui"
    },
    {
      "declaration": "uint keybind(const string&in, const string&in, uint, float, float, float, float)",
      "namespace": "ui"
    },
    {
      "declaration": "string text(const string&in)",
      "namespace": "resources"
    },
    {
      "declaration": "string get(const string&in, const string&in fallback = '')",
      "namespace": "config"
    },
    {
      "declaration": "void set(const string&in, const string&in)",
      "namespace": "config"
    },
    {
      "declaration": "bool valid(const string&in)",
      "namespace": "json"
    },
    {
      "declaration": "string get_string(const string&in, const string&in, const string&in fallback = '')",
      "namespace": "json"
    }
  ],
  "schema": 1,
  "sdk_version": "0.3",
  "types": [
    {
      "behaviours": [
        {
          "declaration": "~string()",
          "kind": 2
        },
        {
          "declaration": "string()",
          "kind": 0
        },
        {
          "declaration": "string(const string&in)",
          "kind": 0
        }
      ],
      "methods": [
        "string& opAssign(const string&in)",
        "string& opAddAssign(const string&in)",
        "bool opEquals(const string&in) const",
        "int opCmp(const string&in) const",
        "string opAdd(const string&in) const",
        "uint length() const",
        "void resize(uint)",
        "bool isEmpty() const",
        "uint8& opIndex(uint)",
        "const uint8& opIndex(uint) const",
        "string& opAssign(double)",
        "string& opAddAssign(double)",
        "string opAdd(double) const",
        "string opAdd_r(double) const",
        "string& opAssign(float)",
        "string& opAddAssign(float)",
        "string opAdd(float) const",
        "string opAdd_r(float) const",
        "string& opAssign(int64)",
        "string& opAddAssign(int64)",
        "string opAdd(int64) const",
        "string opAdd_r(int64) const",
        "string& opAssign(uint64)",
        "string& opAddAssign(uint64)",
        "string opAdd(uint64) const",
        "string opAdd_r(uint64) const",
        "string& opAssign(bool)",
        "string& opAddAssign(bool)",
        "string opAdd(bool) const",
        "string opAdd_r(bool) const",
        "string substr(uint start = 0, int count = -1) const",
        "int findFirst(const string&in, uint start = 0) const",
        "int findFirstOf(const string&in, uint start = 0) const",
        "int findFirstNotOf(const string&in, uint start = 0) const",
        "int findLast(const string&in, int start = -1) const",
        "int findLastOf(const string&in, int start = -1) const",
        "int findLastNotOf(const string&in, int start = -1) const",
        "void insert(uint pos, const string&in other)",
        "void erase(uint pos, int count = -1)",
        "int regexFind(const string&in regex, uint start = 0, uint&out lengthOfMatch = void) const"
      ],
      "name": "string",
      "namespace": "",
      "properties": []
    },
    {
      "behaviours": [
        {
          "declaration": "void $beh5()",
          "kind": 5
        },
        {
          "declaration": "void $beh6()",
          "kind": 6
        },
        {
          "declaration": "int $beh9()",
          "kind": 9
        },
        {
          "declaration": "void $beh10()",
          "kind": 10
        },
        {
          "declaration": "bool $beh11()",
          "kind": 11
        },
        {
          "declaration": "void $beh12(int&in)",
          "kind": 12
        },
        {
          "declaration": "void $beh13(int&in)",
          "kind": 13
        },
        {
          "declaration": "bool $beh8(int&in, bool&out)",
          "kind": 8
        },
        {
          "declaration": "T[]@ $list(int&in, int&in) { repeat T }",
          "kind": 4
        }
      ],
      "methods": [
        "T& opIndex(uint index)",
        "const T& opIndex(uint index) const",
        "uint opForBegin() const",
        "bool opForEnd(uint) const",
        "uint opForNext(uint) const",
        "const T& opForValue0(uint index) const",
        "uint opForValue1(uint index) const",
        "T[]& opAssign(const T[]&in)",
        "void insertAt(uint index, const T&in value)",
        "void insertAt(uint index, const T[]&inout arr)",
        "void insertLast(const T&in value)",
        "void removeAt(uint index)",
        "void removeLast()",
        "void removeRange(uint start, uint count)",
        "uint length() const",
        "void reserve(uint length)",
        "void resize(uint length)",
        "void sortAsc()",
        "void sortAsc(uint startAt, uint count)",
        "void sortDesc()",
        "void sortDesc(uint startAt, uint count)",
        "void reverse()",
        "int find(const T&in value) const",
        "int find(uint startAt, const T&in value) const",
        "int findByRef(const T&in value) const",
        "int findByRef(uint startAt, const T&in value) const",
        "bool opEquals(const T[]&in) const",
        "bool isEmpty() const",
        "void sort(T[]::less&in, uint startAt = 0, uint count = uint(-1))"
      ],
      "name": "array",
      "namespace": "",
      "properties": []
    },
    {
      "behaviours": [
        {
          "declaration": "~thread_info()",
          "kind": 2
        },
        {
          "declaration": "thread_info()",
          "kind": 0
        },
        {
          "declaration": "thread_info(const thread_info&in)",
          "kind": 0
        }
      ],
      "methods": [
        "thread_info& opAssign(const thread_info&in)"
      ],
      "name": "thread_info",
      "namespace": "",
      "properties": [
        "uint id",
        "uint owner_pid",
        "int priority",
        "uint64 start_address",
        "bool start_known"
      ]
    },
    {
      "behaviours": [
        {
          "declaration": "~handle_info()",
          "kind": 2
        },
        {
          "declaration": "handle_info()",
          "kind": 0
        },
        {
          "declaration": "handle_info(const handle_info&in)",
          "kind": 0
        }
      ],
      "methods": [
        "handle_info& opAssign(const handle_info&in)"
      ],
      "name": "handle_info",
      "namespace": "",
      "properties": [
        "uint64 value",
        "uint type_index",
        "uint access",
        "uint attributes"
      ]
    },
    {
      "behaviours": [
        {
          "declaration": "~module_info()",
          "kind": 2
        },
        {
          "declaration": "module_info()",
          "kind": 0
        },
        {
          "declaration": "module_info(const module_info&in)",
          "kind": 0
        }
      ],
      "methods": [
        "module_info& opAssign(const module_info&in)"
      ],
      "name": "module_info",
      "namespace": "",
      "properties": [
        "uint64 base",
        "uint64 size",
        "string path"
      ]
    },
    {
      "behaviours": [
        {
          "declaration": "~module_difference()",
          "kind": 2
        },
        {
          "declaration": "module_difference()",
          "kind": 0
        },
        {
          "declaration": "module_difference(const module_difference&in)",
          "kind": 0
        }
      ],
      "methods": [
        "module_difference& opAssign(const module_difference&in)"
      ],
      "name": "module_difference",
      "namespace": "",
      "properties": [
        "uint64 base",
        "uint64 system_size",
        "uint64 peb_size",
        "string kind",
        "string system_path",
        "string peb_path"
      ]
    },
    {
      "behaviours": [
        {
          "declaration": "memory_region()",
          "kind": 0
        }
      ],
      "methods": [],
      "name": "memory_region",
      "namespace": "",
      "properties": [
        "uint64 address",
        "uint64 size",
        "uint state",
        "uint type",
        "uint protection",
        "bool readable",
        "bool writable",
        "bool executable",
        "bool guard"
      ]
    },
    {
      "behaviours": [
        {
          "declaration": "vec2()",
          "kind": 0
        },
        {
          "declaration": "vec2(float, float)",
          "kind": 0
        }
      ],
      "methods": [
        "vec2 add(const vec2&in) const",
        "vec2 subtract(const vec2&in) const",
        "vec2 lerp(const vec2&in, float) const",
        "vec2 multiply(float) const",
        "vec2 normalize() const",
        "float length() const",
        "float length_squared() const",
        "float distance(const vec2&in) const",
        "float dot(const vec2&in) const"
      ],
      "name": "vec2",
      "namespace": "",
      "properties": [
        "float x",
        "float y"
      ]
    },
    {
      "behaviours": [
        {
          "declaration": "vec3()",
          "kind": 0
        },
        {
          "declaration": "vec3(float, float, float)",
          "kind": 0
        }
      ],
      "methods": [
        "vec3 add(const vec3&in) const",
        "vec3 subtract(const vec3&in) const",
        "vec3 lerp(const vec3&in, float) const",
        "vec3 multiply(float) const",
        "vec3 normalize() const",
        "float length() const",
        "float length_squared() const",
        "float distance(const vec3&in) const",
        "float dot(const vec3&in) const",
        "vec3 cross(const vec3&in) const"
      ],
      "name": "vec3",
      "namespace": "",
      "properties": [
        "float x",
        "float y",
        "float z"
      ]
    },
    {
      "behaviours": [
        {
          "declaration": "matrix4()",
          "kind": 0
        }
      ],
      "methods": [
        "float get(uint, uint) const",
        "void set(uint, uint, float)",
        "matrix4 transpose() const",
        "matrix4 multiply(const matrix4&in) const"
      ],
      "name": "matrix4",
      "namespace": "",
      "properties": []
    },
    {
      "behaviours": [
        {
          "declaration": "void $beh5()",
          "kind": 5
        },
        {
          "declaration": "void $beh6()",
          "kind": 6
        }
      ],
      "methods": [
        "uint size() const",
        "bool read_u8(uint, uint8&out) const",
        "bool read_u16(uint, uint16&out) const",
        "bool read_u32(uint, uint&out) const",
        "bool read_i32(uint, int&out) const",
        "bool read_u64(uint, uint64&out) const",
        "bool read_float(uint, float&out) const",
        "bool read_double(uint, double&out) const",
        "bool slice(uint, uint, string&out) const"
      ],
      "name": "memory_buffer",
      "namespace": "",
      "properties": []
    }
  ]
}