`JsonNode` can contain fundamental types (integers, booleans, floating point numbers, strings) and complex types (arrays and objects).
When parsing a JSON data stream you extract the root node and walk the node tree by retrieving the type of data contained inside the node with
the `JSON_NODE_TYPE` macro. If the node contains a fundamental type you can retrieve a copy of the `GValue` holding it with the [
method@Json.Node.get_value] function, and then use the `GValue` API to extract the data; if the node contains a complex type you can retrieve
the [struct@Json.Object] or the [struct@Json.Array] using [method@Json.Node.get_object] or [method@Json.Node.get_array] respectively, and then
retrieve the nodes they contain.
A `JsonNode` may be marked as immutable using [method@Json.Node.seal]. This marks the node and all its descendents as read-only, and means that
subsequent calls to setter functions (such as [method@Json.Node.set_array]) on them will abort as a programmer error. By marking a node tree as
immutable, it may be referenced in multiple places and its hash value cached for fast lookups, without the possibility of a value deep within
the tree changing and affecting hash values. Immutable nodes may be passed to functions which retain a reference to them without needing to take
A `JsonNode` supports two types of memory management: `malloc`/`free` semantics, and reference counting semantics. The two may be mixed to a
limited extent: nodes may be allocated (which gives them a reference count of 1), referenced one or more times, unreferenced exactly that number
of times (using [method@Json.Node.unref]), then either unreferenced exactly once more or freed (using [method@Json.Node.free]) to destroy them.
The [method@Json.Node.free] function must not be used when a node might have a reference count not equal to 1. To this end, JSON-GLib uses [
method@Json.Node.copy] and [method@Json.Node.unref] internally.