Document json_document and json_view

- API pages for basic_json_document and basic_json_view, one per member,
  and for the four aliases, each with an example
- features/json_view.md: the problem the view solves, ownership and
  lifetime, what matches basic_json::parse() and what differs, and when
  to choose json, ordered_json, SAX, or the view
- the examples show why one would use the view, not only how: borrowed
  vs. owned input, reading a few fields and materializing one subtree,
  reusing a document across many messages
- registered in the mkdocs navigation, llms.txt, the docset, the
  exceptions page (out_of_range.416), architecture.md, the integration
  page, and the README; the yyjson credit is added to the README and
  license.md

Signed-off-by: Niels Lohmann <mail@nlohmann.me>

docs/mkdocs/docs/api/basic_json_view/basic_json_view.md

@@ -0,0 +1,51 @@
+# <small>nlohmann::basic_json_view::</small>basic_json_view
+
+```cpp
+basic_json_view() noexcept = default;
+```
+
+Creates an invalid (discarded) view: [`type()`](type.md) is `#!cpp value_t::discarded`,
+[`is_discarded()`](is_discarded.md) is `#!cpp true`, and `#!cpp explicit operator bool()` is `#!cpp false`.
+
+This is the only constructor a caller can use directly. Every other view is obtained from a
+[`basic_json_document`](../basic_json_document/index.md), via [`root()`](../basic_json_document/root.md) or (once
+element access is added) from navigating into a container.
+
+## Exception safety
+
+No-throw guarantee: this constructor never throws exceptions.
+
+## Complexity
+
+Constant.
+
+## Notes
+
+`basic_json_view` is trivially copyable (it holds two pointers), so a default-constructed view can be used as a
+placeholder for "no value yet" and later be assigned a real view.
+
+## Examples
+
+??? example
+
+    The example below shows the default constructor and that a `basic_json_view` is a small, copyable handle.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__basic_json_view.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__basic_json_view.output"
+    ```
+
+## See also
+
+- [is_discarded](is_discarded.md) - return whether the view is invalid
+- [operator bool](operator_bool.md) - return whether the view refers to a value
+- [root](../basic_json_document/root.md) - the view of a document's root value
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/empty.md

@@ -0,0 +1,61 @@
+# <small>nlohmann::basic_json_view::</small>empty
+
+```cpp
+bool empty() const noexcept;
+```
+
+Checks whether [`size()`](size.md) is `0`, as [`BasicJsonType::empty()`](../basic_json/empty.md) would for the same
+value.
+
+## Return value
+
+The return value depends on the type and is defined as follows:
+
+| Value type          | return value    |
+|----------------------|-----------------|
+| null                  | `#!cpp true`     |
+| discarded             | `#!cpp true`     |
+| boolean               | `#!cpp false`    |
+| string                | `#!cpp false`    |
+| number                | `#!cpp false`    |
+| object                | `#!cpp object_t::empty()` |
+| array                 | `#!cpp array_t::empty()`  |
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Constant.
+
+## Notes
+
+As for [`BasicJsonType::empty()`](../basic_json/empty.md), this does not return whether a string value is empty -- it
+is `#!cpp false` for any string, regardless of its length.
+
+## Examples
+
+??? example
+
+    The example below uses [`size()`](size.md) and `empty()` to decide whether a parsed message is worth acting on,
+    without materializing it into a `BasicJsonType` value.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__size_empty.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__size_empty.output"
+    ```
+
+## See also
+
+- [size](size.md) - return the number of elements
+- [`BasicJsonType::empty`](../basic_json/empty.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/index.md

@@ -0,0 +1,82 @@
+# <small>nlohmann::</small>basic_json_view
+
+<small>Defined in header `<nlohmann/json_view.hpp>`</small>
+
+```cpp
+template<typename BasicJsonType>
+class basic_json_view;
+```
+
+A read-only handle to one value of a [`basic_json_document`](../basic_json_document/index.md): two pointers (a pointer
+to the document and a pointer into its index), trivially copyable. A view is valid as long as
+
+- the document is alive,
+- the document has not been re-parsed with [`read()`](../basic_json_document/read.md) (or
+  [`parse()`](../basic_json_document/parse.md) into it) or shrunk with
+  [`shrink_to_fit()`](../basic_json_document/shrink_to_fit.md) since the view was taken, and
+- if the document borrows its source text, that text is still alive.
+
+Moving the document itself does not invalidate its views: the index is heap-allocated independently of the
+`basic_json_document` object.
+
+`basic_json_view` provides the read-only part of the `BasicJsonType` interface: the type-inspection functions, and
+[`materialize()`](materialize.md) to build the `BasicJsonType` value of a subtree on demand. It does not (yet) provide
+element access, iteration, `get<T>()`, JSON Pointer support, `dump()`, or comparison.
+
+## Template parameters
+
+`BasicJsonType`
+:   a specialization of [`basic_json`](../basic_json/index.md), matching the
+    [`basic_json_document`](../basic_json_document/index.md) the view was taken from.
+
+## Specializations
+
+- [**json_view**](../json_view.md) - views of a [`json_document`](../json_document.md)
+- [**ordered_json_view**](../ordered_json_view.md) - views of an [`ordered_json_document`](../ordered_json_document.md)
+
+## Member types
+
+- **value_t** - the JSON type enumeration, see [`basic_json::value_t`](../basic_json/value_t.md)
+- **string_t**, **number_integer_t**, **number_unsigned_t**, **number_float_t**, **json_pointer** - the corresponding
+  member types of `BasicJsonType`
+- **size_type** - `#!cpp std::size_t`
+- **string_view_t** - `#!cpp std::string_view` on C++17 and newer, a minimal internal substitute otherwise
+
+## Member functions
+
+- [(constructor)](basic_json_view.md)
+
+### Object inspection
+
+- [**type**](type.md) - return the type of the value
+- [**is_null**](is_null.md) - return whether the value is null
+- [**is_boolean**](is_boolean.md) - return whether the value is a boolean
+- [**is_number**](is_number.md) - return whether the value is a number
+- [**is_number_integer**](is_number_integer.md) - return whether the value is an integer number
+- [**is_number_unsigned**](is_number_unsigned.md) - return whether the value is an unsigned integer number
+- [**is_number_float**](is_number_float.md) - return whether the value is a floating-point number
+- [**is_string**](is_string.md) - return whether the value is a string
+- [**is_array**](is_array.md) - return whether the value is an array
+- [**is_object**](is_object.md) - return whether the value is an object
+- [**is_binary**](is_binary.md) - return whether the value is a binary array (always `#!cpp false`)
+- [**is_primitive**](is_primitive.md) - return whether the type is primitive
+- [**is_structured**](is_structured.md) - return whether the type is structured
+- [**is_discarded**](is_discarded.md) - return whether the view is invalid
+- [**operator bool**](operator_bool.md) - return whether the view refers to a value
+
+### Capacity
+
+- [**size**](size.md) - return the number of elements
+- [**empty**](empty.md) - return whether the value has no elements
+
+### Conversion
+
+- [**materialize**](materialize.md) - build the `BasicJsonType` value of this subtree
+
+### Source access
+
+- [**source_offset**](source_offset.md) - byte offset of this value in the document's source text
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/is_array.md

@@ -0,0 +1,46 @@
+# <small>nlohmann::basic_json_view::</small>is_array
+
+```cpp
+bool is_array() const noexcept;
+```
+
+This function returns `#!cpp true` if and only if the value is an array.
+
+## Return value
+
+`#!cpp true` if the type is an array, `#!cpp false` otherwise.
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Constant.
+
+## Examples
+
+??? example
+
+    The example below classifies several parsed documents by the type of their root value, without materializing any
+    of them into a `BasicJsonType` value.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__type_predicates.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__type_predicates.output"
+    ```
+
+## See also
+
+- [is_structured](is_structured.md) - return whether the type is structured
+- [size](size.md), [empty](empty.md) - the number of elements, and whether there are none
+- [`BasicJsonType::is_array`](../basic_json/is_array.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/is_binary.md

@@ -0,0 +1,46 @@
+# <small>nlohmann::basic_json_view::</small>is_binary
+
+```cpp
+bool is_binary() const noexcept;
+```
+
+This function always returns `#!cpp false`: a JSON text has no binary values, so a view can never refer to one. The
+function exists for interface parity with [`BasicJsonType::is_binary`](../basic_json/is_binary.md).
+
+## Return value
+
+`#!cpp false`, always.
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Constant.
+
+## Examples
+
+??? example
+
+    The example below classifies several parsed documents by the type of their root value, without materializing any
+    of them into a `BasicJsonType` value.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__type_predicates.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__type_predicates.output"
+    ```
+
+## See also
+
+- [type](type.md) - return the type of the value
+- [`BasicJsonType::is_binary`](../basic_json/is_binary.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/is_boolean.md

@@ -0,0 +1,45 @@
+# <small>nlohmann::basic_json_view::</small>is_boolean
+
+```cpp
+bool is_boolean() const noexcept;
+```
+
+This function returns `#!cpp true` if and only if the value is a boolean.
+
+## Return value
+
+`#!cpp true` if the type is a boolean, `#!cpp false` otherwise.
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Constant.
+
+## Examples
+
+??? example
+
+    The example below classifies several parsed documents by the type of their root value, without materializing any
+    of them into a `BasicJsonType` value.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__type_predicates.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__type_predicates.output"
+    ```
+
+## See also
+
+- [type](type.md) - return the type of the value
+- [`BasicJsonType::is_boolean`](../basic_json/is_boolean.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/is_discarded.md

@@ -0,0 +1,55 @@
+# <small>nlohmann::basic_json_view::</small>is_discarded
+
+```cpp
+bool is_discarded() const noexcept;
+```
+
+Returns whether this view is invalid, i.e. does not refer to a value. This is the case for a default-constructed
+view (see [(constructor)](basic_json_view.md)), and for [`root()`](../basic_json_document/root.md) of a document
+that is itself [discarded](../basic_json_document/is_discarded.md) -- in particular, the root of a failed
+[`parse()`](../basic_json_document/parse.md) with `allow_exceptions` set to `#!cpp false`.
+
+## Return value
+
+`#!cpp true` if the view is discarded, `#!cpp false` otherwise.
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Constant.
+
+## Notes
+
+`#!cpp v.is_discarded()` and `#!cpp !static_cast<bool>(v)` are equivalent; use whichever reads better at the call
+site.
+
+## Examples
+
+??? example
+
+    The example below classifies several parsed documents by the type of their root value, without materializing any
+    of them into a `BasicJsonType` value.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__type_predicates.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__type_predicates.output"
+    ```
+
+## See also
+
+- [operator bool](operator_bool.md) - return whether the view refers to a value
+- [(constructor)](basic_json_view.md) - the default constructor creates a discarded view
+- [is_discarded (basic_json_document)](../basic_json_document/is_discarded.md) - return whether the last parse failed
+- [`BasicJsonType::is_discarded`](../basic_json/is_discarded.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/is_null.md

@@ -0,0 +1,45 @@
+# <small>nlohmann::basic_json_view::</small>is_null
+
+```cpp
+bool is_null() const noexcept;
+```
+
+This function returns `#!cpp true` if and only if the value is `#!json null`.
+
+## Return value
+
+`#!cpp true` if the type is `#!json null`, `#!cpp false` otherwise.
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Constant.
+
+## Examples
+
+??? example
+
+    The example below classifies several parsed documents by the type of their root value, without materializing any
+    of them into a `BasicJsonType` value.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__type_predicates.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__type_predicates.output"
+    ```
+
+## See also
+
+- [type](type.md) - return the type of the value
+- [`BasicJsonType::is_null`](../basic_json/is_null.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/is_number.md

@@ -0,0 +1,47 @@
+# <small>nlohmann::basic_json_view::</small>is_number
+
+```cpp
+bool is_number() const noexcept;
+```
+
+This function returns `#!cpp true` if and only if the value is a number, i.e. an integer, unsigned integer, or floating-point value. It is defined as `#!cpp is_number_integer() || is_number_float()`.
+
+## Return value
+
+`#!cpp true` if the type is a number, `#!cpp false` otherwise.
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Constant.
+
+## Examples
+
+??? example
+
+    The example below classifies several parsed documents by the type of their root value, without materializing any
+    of them into a `BasicJsonType` value.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__type_predicates.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__type_predicates.output"
+    ```
+
+## See also
+
+- [is_number_integer](is_number_integer.md) - return whether the value is an integer or unsigned integer number
+- [is_number_unsigned](is_number_unsigned.md) - return whether the value is an unsigned integer number
+- [is_number_float](is_number_float.md) - return whether the value is a floating-point number
+- [`BasicJsonType::is_number`](../basic_json/is_number.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/is_number_float.md

@@ -0,0 +1,51 @@
+# <small>nlohmann::basic_json_view::</small>is_number_float
+
+```cpp
+bool is_number_float() const noexcept;
+```
+
+This function returns `#!cpp true` if and only if the value is a floating-point number.
+
+## Return value
+
+`#!cpp true` if the type is `#!cpp value_t::number_float`, `#!cpp false` otherwise.
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Constant.
+
+## Notes
+
+As for [`BasicJsonType::parse`](../basic_json/parse.md), an integer literal that does not fit into the 64-bit
+integer type is classified as a floating-point number, so `is_number_float()` can be `#!cpp true` even for an
+integer-looking token in the source text.
+
+## Examples
+
+??? example
+
+    The example below classifies several parsed documents by the type of their root value, without materializing any
+    of them into a `BasicJsonType` value.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__type_predicates.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__type_predicates.output"
+    ```
+
+## See also
+
+- [is_number](is_number.md) - return whether the value is a number
+- [`BasicJsonType::is_number_float`](../basic_json/is_number_float.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/is_number_integer.md

@@ -0,0 +1,51 @@
+# <small>nlohmann::basic_json_view::</small>is_number_integer
+
+```cpp
+bool is_number_integer() const noexcept;
+```
+
+This function returns `#!cpp true` if and only if the value is an integer or unsigned integer number.
+
+## Return value
+
+`#!cpp true` if the type is `#!cpp value_t::number_integer` or `#!cpp value_t::number_unsigned`, `#!cpp false` otherwise.
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Constant.
+
+## Notes
+
+As for [`BasicJsonType::is_number_integer`](../basic_json/is_number_integer.md), this includes unsigned integer
+values; use [`is_number_unsigned`](is_number_unsigned.md) to test for those specifically.
+
+## Examples
+
+??? example
+
+    The example below classifies several parsed documents by the type of their root value, without materializing any
+    of them into a `BasicJsonType` value.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__type_predicates.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__type_predicates.output"
+    ```
+
+## See also
+
+- [is_number](is_number.md) - return whether the value is a number
+- [is_number_unsigned](is_number_unsigned.md) - return whether the value is an unsigned integer number
+- [`BasicJsonType::is_number_integer`](../basic_json/is_number_integer.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/is_number_unsigned.md

@@ -0,0 +1,45 @@
+# <small>nlohmann::basic_json_view::</small>is_number_unsigned
+
+```cpp
+bool is_number_unsigned() const noexcept;
+```
+
+This function returns `#!cpp true` if and only if the value is an unsigned integer number.
+
+## Return value
+
+`#!cpp true` if the type is `#!cpp value_t::number_unsigned`, `#!cpp false` otherwise.
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Constant.
+
+## Examples
+
+??? example
+
+    The example below classifies several parsed documents by the type of their root value, without materializing any
+    of them into a `BasicJsonType` value.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__type_predicates.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__type_predicates.output"
+    ```
+
+## See also
+
+- [is_number_integer](is_number_integer.md) - return whether the value is an integer or unsigned integer number
+- [`BasicJsonType::is_number_unsigned`](../basic_json/is_number_unsigned.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/is_object.md

@@ -0,0 +1,46 @@
+# <small>nlohmann::basic_json_view::</small>is_object
+
+```cpp
+bool is_object() const noexcept;
+```
+
+This function returns `#!cpp true` if and only if the value is an object.
+
+## Return value
+
+`#!cpp true` if the type is an object, `#!cpp false` otherwise.
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Constant.
+
+## Examples
+
+??? example
+
+    The example below classifies several parsed documents by the type of their root value, without materializing any
+    of them into a `BasicJsonType` value.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__type_predicates.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__type_predicates.output"
+    ```
+
+## See also
+
+- [is_structured](is_structured.md) - return whether the type is structured
+- [size](size.md), [empty](empty.md) - the number of elements, and whether there are none
+- [`BasicJsonType::is_object`](../basic_json/is_object.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/is_primitive.md

@@ -0,0 +1,46 @@
+# <small>nlohmann::basic_json_view::</small>is_primitive
+
+```cpp
+bool is_primitive() const noexcept;
+```
+
+This function returns `#!cpp true` if and only if the value is primitive, i.e. `#!json null`, a boolean, a number, or a string. It is defined as `#!cpp is_null() || is_string() || is_boolean() || is_number()`.
+
+## Return value
+
+`#!cpp true` if the type is primitive, `#!cpp false` otherwise.
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Constant.
+
+## Examples
+
+??? example
+
+    The example below classifies several parsed documents by the type of their root value, without materializing any
+    of them into a `BasicJsonType` value.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__type_predicates.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__type_predicates.output"
+    ```
+
+## See also
+
+- [is_structured](is_structured.md) - return whether the type is structured (the complement of this function, for a
+  non-discarded view)
+- [`BasicJsonType::is_primitive`](../basic_json/is_primitive.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/is_string.md

@@ -0,0 +1,45 @@
+# <small>nlohmann::basic_json_view::</small>is_string
+
+```cpp
+bool is_string() const noexcept;
+```
+
+This function returns `#!cpp true` if and only if the value is a string.
+
+## Return value
+
+`#!cpp true` if the type is a string, `#!cpp false` otherwise.
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Constant.
+
+## Examples
+
+??? example
+
+    The example below classifies several parsed documents by the type of their root value, without materializing any
+    of them into a `BasicJsonType` value.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__type_predicates.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__type_predicates.output"
+    ```
+
+## See also
+
+- [source_offset](source_offset.md) - byte offset of this value in the document's source text
+- [`BasicJsonType::is_string`](../basic_json/is_string.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/is_structured.md

@@ -0,0 +1,46 @@
+# <small>nlohmann::basic_json_view::</small>is_structured
+
+```cpp
+bool is_structured() const noexcept;
+```
+
+This function returns `#!cpp true` if and only if the value is structured, i.e. an array or an object. It is defined as `#!cpp is_array() || is_object()`.
+
+## Return value
+
+`#!cpp true` if the type is structured, `#!cpp false` otherwise.
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Constant.
+
+## Examples
+
+??? example
+
+    The example below classifies several parsed documents by the type of their root value, without materializing any
+    of them into a `BasicJsonType` value.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__type_predicates.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__type_predicates.output"
+    ```
+
+## See also
+
+- [is_primitive](is_primitive.md) - return whether the type is primitive
+- [size](size.md), [empty](empty.md) - the number of elements, and whether there are none
+- [`BasicJsonType::is_structured`](../basic_json/is_structured.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/materialize.md

@@ -0,0 +1,69 @@
+# <small>nlohmann::basic_json_view::</small>materialize
+
+```cpp
+BasicJsonType materialize() const;
+```
+
+Builds the `BasicJsonType` value of this subtree: the value [`BasicJsonType::parse()`](../basic_json/parse.md) would
+have produced for the same source text, allocated for the first time by this call.
+
+## Return value
+
+The `BasicJsonType` value of this subtree, or a discarded `BasicJsonType` value (`#!cpp BasicJsonType(value_t::discarded)`)
+if the view is [discarded](is_discarded.md).
+
+## Exception safety
+
+Strong guarantee: if an exception is thrown, there are no changes to the view or the document it refers to (nothing
+about either is mutated by this function).
+
+## Exceptions
+
+May throw `#!cpp std::bad_alloc` (via `BasicJsonType`'s allocator) if constructing the result fails.
+
+## Complexity
+
+Linear in the size of the subtree.
+
+## Notes
+
+`materialize()` replays the subtree through the same SAX builder [`BasicJsonType::parse()`](../basic_json/parse.md)
+uses internally, so the result matches it exactly -- including, for an object, that a repeated key keeps only its
+last value. The replay is iterative, so it is not limited by the call stack the way a naive recursive conversion
+would be; the JSON nesting depth is limited only by available memory, as for `BasicJsonType::parse()` itself.
+
+Unlike parsing with [`JSON_DIAGNOSTIC_POSITIONS`](../macros/json_diagnostic_positions.md) enabled, the values
+produced by `materialize()` do not carry source positions: there is no lexer run during the replay to record them.
+
+Calling `materialize()` on the same view repeatedly builds a new, independent `BasicJsonType` value each time; it
+never caches the result.
+
+## Examples
+
+??? example
+
+    The example below skips messages that are not useful -- a discarded value, or an empty array -- using only
+    [`is_array()`](is_array.md) and [`empty()`](empty.md), and calls `materialize()` only for the messages that are
+    actually used, so no `BasicJsonType` value (and none of its per-element allocations) is ever built for the
+    skipped ones.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__materialize.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__materialize.output"
+    ```
+
+## See also
+
+- [root](../basic_json_document/root.md) - the view of a document's root value
+- [`BasicJsonType::parse`](../basic_json/parse.md) - build a `BasicJsonType` value directly from a JSON text
+- [`JSON_DIAGNOSTIC_POSITIONS`](../macros/json_diagnostic_positions.md) - source positions on parsed values (not
+  produced by `materialize()`)
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/operator_bool.md

@@ -0,0 +1,46 @@
+# <small>nlohmann::basic_json_view::</small>operator bool
+
+```cpp
+explicit operator bool() const noexcept;
+```
+
+Returns whether this view refers to a value, i.e. the negation of [`is_discarded()`](is_discarded.md). Being
+`#!cpp explicit`, this conversion is only considered in a boolean context (`#!cpp if (v)`, `#!cpp !v`, `#!cpp v &&
+...`), not for implicit conversions to other types.
+
+## Return value
+
+`#!cpp true` if the view refers to a value, `#!cpp false` if it is [discarded](is_discarded.md).
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Constant.
+
+## Examples
+
+??? example
+
+    The example below classifies several parsed documents by the type of their root value, without materializing any
+    of them into a `BasicJsonType` value.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__type_predicates.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__type_predicates.output"
+    ```
+
+## See also
+
+- [is_discarded](is_discarded.md) - return whether the view is invalid
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/size.md

@@ -0,0 +1,60 @@
+# <small>nlohmann::basic_json_view::</small>size
+
+```cpp
+size_type size() const noexcept;
+```
+
+Returns the number of elements, as [`BasicJsonType::size()`](../basic_json/size.md) would for the same value.
+
+## Return value
+
+The return value depends on the type and is defined as follows:
+
+| Value type          | return value                |
+|----------------------|-----------------------------|
+| null                  | `0`                          |
+| discarded             | `0`                          |
+| boolean               | `1`                          |
+| string                | `1`                          |
+| number                | `1`                          |
+| object                | number of key/value pairs    |
+| array                 | number of elements           |
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Constant: for an object or array, the element count is stored in the index, not counted on demand.
+
+## Notes
+
+As for [`BasicJsonType::size()`](../basic_json/size.md), this does not return the length of a string value -- it is
+`1` for a string, regardless of its length.
+
+## Examples
+
+??? example
+
+    The example below uses `size()` and [`empty()`](empty.md) to decide whether a parsed message is worth acting on,
+    without materializing it into a `BasicJsonType` value.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__size_empty.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__size_empty.output"
+    ```
+
+## See also
+
+- [empty](empty.md) - return whether the value has no elements
+- [`BasicJsonType::size`](../basic_json/size.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/source_offset.md

@@ -0,0 +1,55 @@
+# <small>nlohmann::basic_json_view::</small>source_offset
+
+```cpp
+std::size_t source_offset() const noexcept;
+```
+
+Returns the byte offset of this value in the document's [`source()`](../basic_json_document/source.md) text, without
+materializing anything.
+
+## Return value
+
+- For a string with no escapes, a number, `#!json true`/`#!json false`/`#!json null`, an array, or an object: the
+  byte offset of the first byte of the value's token (for a string: the first byte after the opening quote) in
+  [`source()`](../basic_json_document/source.md).
+- `#!cpp static_cast<std::size_t>(-1)` for a [discarded](is_discarded.md) view, and for a string that contains
+  escapes -- such a string was decoded once into the document's own buffer, so there is no single byte range in
+  `source()` left to point at.
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Constant.
+
+## Notes
+
+This is a raw offset, not a length: the API does not (yet) expose how many bytes the token occupies in the source
+text, so `source_offset()` alone is enough to report *where* a value came from (for an error message, for syntax
+highlighting, ...) but not to slice its exact text back out of [`source()`](../basic_json_document/source.md) for a
+string, whose token length is not the same as its decoded [`size()`](size.md).
+
+## Examples
+
+??? example
+
+    ```cpp
+    --8<-- "examples/basic_json_view__source_offset.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__source_offset.output"
+    ```
+
+## See also
+
+- [source](../basic_json_document/source.md) - the parsed text
+- [is_string](is_string.md) - return whether the value is a string
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/type.md

@@ -0,0 +1,53 @@
+# <small>nlohmann::basic_json_view::</small>type
+
+```cpp
+value_t type() const noexcept;
+```
+
+Returns the type of the value this view refers to, as a value from the [`value_t`](../basic_json/value_t.md)
+enumeration -- the same enumeration [`BasicJsonType::type()`](../basic_json/type.md) uses.
+
+## Return value
+
+The type of the value; `#!cpp value_t::discarded` for a [discarded](is_discarded.md) view.
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Constant.
+
+## Notes
+
+Unlike [`BasicJsonType::type()`](../basic_json/type.md), this function can never return `#!cpp value_t::binary`: a
+JSON text has no binary values, so `type()` only distinguishes the eight ordinary JSON value types (plus
+`#!cpp discarded`).
+
+## Examples
+
+??? example
+
+    The example below classifies several parsed documents by the type of their root value, without materializing any
+    of them into a `BasicJsonType` value.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__type_predicates.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__type_predicates.output"
+    ```
+
+## See also
+
+- [is_null](is_null.md), [is_boolean](is_boolean.md), [is_number](is_number.md), [is_string](is_string.md),
+  [is_array](is_array.md), [is_object](is_object.md) - type-specific predicates built on `type()`
+- [`BasicJsonType::type`](../basic_json/type.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.