This is an automated email from the ASF dual-hosted git repository.
jamesbognar pushed a commit to branch docs
in repository https://gitbox.apache.org/repos/asf/juneau.git
The following commit(s) were added to refs/heads/docs by this push:
new 0259c4fbf4 feat(marshall): null-inclusion knobs + first-class
Optional*/BitSet datatypes
0259c4fbf4 is described below
commit 0259c4fbf43929a595390427d7bc4830a34c6503
Author: James Bognar <[email protected]>
AuthorDate: Tue Jun 16 17:39:07 2026 -0400
feat(marshall): null-inclusion knobs + first-class Optional*/BitSet
datatypes
---
pages/release-notes/10.0.0.md | 83 ++++++++++
pages/topics/02.06.01.NullAndInclusionPolicies.md | 188 ++++++++++++++++++++++
pages/topics/02.09.01.SupportedJdkDatatypes.md | 176 ++++++++++++++++++++
sidebars.ts | 10 ++
4 files changed, 457 insertions(+)
diff --git a/pages/release-notes/10.0.0.md b/pages/release-notes/10.0.0.md
index a4cbda460a..39b40854c5 100644
--- a/pages/release-notes/10.0.0.md
+++ b/pages/release-notes/10.0.0.md
@@ -228,6 +228,89 @@ A full topic-page family lives under "2.50. Token / Record
Streaming" in the Mar
The streaming surface is **purely structural** — object swaps and `@Schema`
annotations apply only on the POJO databind path, never at the token layer.
Both surfaces are additive; the existing POJO ↔ document API remains the
primary, recommended path.
+#### Inclusion knob: `nonDefault()` on `Serializer.Builder`
+
+Juneau 10.0 adds a new serializer-side inclusion knob to suppress properties
whose value equals the type's
+default — the Juneau equivalent of Jackson's `@JsonInclude(NON_DEFAULT)`. It
lives alongside the existing
+`keepNullProperties` / `trimEmptyCollections` / `trimEmptyMaps` /
`trimStrings` family and applies uniformly
+across every format (no per-format opt-in).
+
+```java
+public class Person {
+ public String name = "Anonymous";
+ public int age = 0;
+}
+
+var s = JsonSerializer.create().nonDefault().build();
+s.serialize(new Person()); // → {}
+```
+
+Default values are resolved as:
+- For primitives / boxed wrappers — the Java type default (`0`, `false`,
`null`, …).
+- For bean properties — the value held on a freshly-constructed instance via
the bean's no-arg constructor.
+ The reference instance is built **once** and cached on `ClassMeta`. If the
bean cannot be instantiated, the
+ knob silently skips that bean rather than aborting the serialization.
+
+Equality uses value-based numeric comparison (so `1` ≡ `1.0` ≡ `1L`);
everything else uses `Objects.equals`.
+
+The matching annotation setting is `@SerializerConfig(nonDefault = "true")`.
+
+Precedence (first "omit" wins): `keepNullProperties` (handles `null` and
`Optional.empty()`) →
+`trimStrings` → `trimEmptyCollections` / `trimEmptyMaps` → `nonDefault`.
+
+#### Parser-side null coercion: `Nulls` policy
+
+A new `org.apache.juneau.marshall.Nulls` enum + matching `nulls` setting on
`Parser.Builder` /
+`@ParserConfig` / `@MarshalledProp` controls what happens when a `null`
reaches a bean property during
+parsing — the Juneau equivalent of Jackson's `@JsonSetter(nulls = …)`. Four
modes:
+
+- `LEAVE` — pass `null` through to the setter (current behavior, default).
+- `EMPTY` — substitute `""`, an empty mutable `Collection` / `Map`, or
`Optional.empty()`.
+- `DEFAULT` — substitute the bean's reference-instance value for that property.
+- `SKIP` — do not invoke the setter at all; any pre-existing field initializer
is preserved.
+
+Per-property setting wins over session, which wins over context default:
+
+```java
+public class Bean {
+ @MarshalledProp(nulls = Nulls.EMPTY)
+ public String s;
+
+ @MarshalledProp(nulls = Nulls.SKIP)
+ public String t = "initial";
+
+ public String u; // falls through to context default
+}
+
+var p = JsonParser.create().nulls(Nulls.LEAVE).build();
+var b = p.parse("{\"s\":null,\"t\":null,\"u\":null}", Bean.class);
+// b.s == "" b.t == "initial" b.u == null
+```
+
+See the new [Null & Inclusion Policies](/docs/topics/NullAndInclusionPolicies)
topic page for the full
+contract, including a Jackson migration table.
+
+#### First-class JDK datatype coverage (`OptionalInt` / `OptionalLong` /
`OptionalDouble` / `BitSet`)
+
+Juneau 10.0 extends its direct, in-box JDK datatype coverage with first-class
handling for the primitive
+`Optional` variants — `OptionalInt`, `OptionalLong`, `OptionalDouble` — and
for `BitSet`.
+
+The primitive `Optional` variants are handled directly on the
serializer/parser path, mirroring the
+existing `Optional<T>` plumbing rather than going through a swap. They share
the same wire contract as
+`Optional<T>`: empty maps to `null` (omitted by default, emitted as `null`
when `keepNullProperties()` is
+set), present emits the unwrapped primitive, and parse-side `null`/absent both
resolve back to the matching
+`empty()` sentinel — never a bare `null` inside the `Optional`.
+
+`BitSet` is likewise a first-class type with its own `BitSetFormat` enum — no
swap required. The new
+`bitSetFormat` knob selects the textual wire form (`INDICES`, the default
comma-delimited set-bit-index
+list; `BITS`, a little-endian bit string; or `HEX`, a hex-encoded byte array)
and is configurable at all
+four precedence levels (`@MarshalledProp`, `@Marshalled`, `@MarshalledConfig`,
and the `bitSetFormat(...)`
+builder setter), exactly like the other `*Format` enums.
+
+A new [Supported JDK Datatypes](/docs/topics/SupportedJdkDatatypes) topic page
enumerates the full coverage
+matrix and contrasts Juneau's first-class-in-box approach with Jackson's
per-module `jackson-datatype-*`
+family.
+
#### `MarshalledNode` typed tree façade + RFC 6901 JSON-Pointer addressing
Juneau 10.0 adds a typed tree façade and an RFC 6901 JSON-Pointer surface over
the existing `MarshalledMap`/`MarshalledList` collections model (in
`org.apache.juneau.marshall.collections`):
diff --git a/pages/topics/02.06.01.NullAndInclusionPolicies.md
b/pages/topics/02.06.01.NullAndInclusionPolicies.md
new file mode 100644
index 0000000000..ace9c73d0d
--- /dev/null
+++ b/pages/topics/02.06.01.NullAndInclusionPolicies.md
@@ -0,0 +1,188 @@
+---
+title: "Null & Inclusion Policies"
+slug: NullAndInclusionPolicies
+---
+
+Juneau gives you fine-grained control over **what gets emitted on the wire**
and **what happens when a `null`
+arrives during parsing**. The two surfaces are co-designed so the round-trip
behavior is predictable across
+every format (JSON, JSON5, XML, HTML, YAML, MsgPack, …).
+
+This page documents:
+
+- The serializer **inclusion knobs** that suppress empty / default values.
+- The parser **`Nulls` policy** that decides what to do when an incoming
`null` reaches a bean property.
+- The shared `Optional` contract that both sides honor.
+- A short Jackson `@JsonInclude` / `@JsonSetter(nulls=…)` mapping table.
+
+---
+
+## Serializer inclusion knobs
+
+All inclusion knobs live on `Serializer.Builder` and apply uniformly across
every format. They are evaluated in
+a fixed precedence order — **the first one that decides "omit" wins**:
+
+| Order | Knob | Default | What it omits |
+|---|---|---|---|
+| 1 | `keepNullProperties()` | off | `null` (and `Optional.empty()`)
properties **are omitted** unless this is enabled. |
+| 2 | `trimStrings()` | off | Trims whitespace from string values (does not
omit; normalizes). |
+| 3 | `trimEmptyCollections()` | off | Omits properties whose value is an
empty `Collection`/array. |
+| 4 | `trimEmptyMaps()` | off | Omits properties whose value is an empty
`Map`. |
+| 5 | `nonDefault()` | off | Omits properties whose value equals the type's
default. |
+
+Note: `null` is governed by `keepNullProperties`, **not** by `nonDefault`. The
two knobs compose — see below.
+
+### `nonDefault()`
+
+The `nonDefault()` knob suppresses any property whose value is equal to its
**default**. "Default" means:
+
+- For primitives and boxed wrappers — the Java type default (`0`, `0L`, `0.0`,
`false`, `'\u0000'`, `null`).
+- For bean properties — the value the property holds on a
**freshly-constructed instance** of the owning bean
+ via its no-arg constructor. The reference instance is built **once** and
cached on the bean's `ClassMeta`.
+- If a bean's no-arg constructor cannot be invoked (private, throws, etc.),
`nonDefault` is **silently skipped
+ for that bean** and properties are emitted normally. The knob never aborts a
serialization.
+
+Equality is by value, not by reference. Numeric comparisons use a
`BigDecimal.compareTo`-style check so
+`1` ≡ `1.0`, `0.0` ≡ `-0.0`, `0` ≡ `0L`, and so on. For everything else,
`Objects.equals` decides.
+
+```java
+public class Person {
+ public String name = "Anonymous";
+ public int age = 0;
+ public boolean active;
+}
+
+var s = JsonSerializer.create().nonDefault().build();
+
+var p = new Person();
+s.serialize(p); // → {}
+p.name = "Alice";
+s.serialize(p); // → {"name":"Alice"}
+p.age = 21;
+s.serialize(p); // → {"name":"Alice","age":21}
+```
+
+### Composing with `keepNullProperties()`
+
+Because `nonDefault` does **not** govern `null`, the two knobs compose cleanly:
+
+```java
+public class Bean {
+ public Integer boxed; // default = null
+ public String s; // default = null
+ public int i; // default = 0
+ public double d; // default = 0.0
+}
+
+var s = JsonSerializer.create().nonDefault().keepNullProperties().build();
+s.serialize(new Bean()); // → {"boxed":null,"s":null}
+```
+
+The primitive defaults `i:0` / `d:0.0` are omitted by `nonDefault`; the
explicit `null` properties are kept by
+`keepNullProperties`.
+
+### Configuring via annotation
+
+The same setting is available on `@SerializerConfig`:
+
+```java
+@SerializerConfig(nonDefault = "true")
+@Rest(serializers = JsonSerializer.class)
+public class MyResource extends BasicRestServlet {}
+```
+
+---
+
+## Parser null-coercion: the `Nulls` policy
+
+When a JSON `null` (or its equivalent in any format) reaches a bean property
during parsing, you can choose
+what value the setter actually receives via the `Nulls` enum:
+
+| Mode | Behavior |
+|---|---|
+| `LEAVE` | Pass the `null` straight through to the setter (default — matches
historical Juneau behavior). |
+| `EMPTY` | Substitute the type's "empty" value: `""` for strings, an empty
mutable collection / map for collection-typed properties, `Optional.empty()` /
`OptionalInt.empty()` / … for `Optional` properties. |
+| `DEFAULT` | Substitute the value the property holds on a freshly-constructed
reference instance of the owning bean (same cached instance used by serializer
`nonDefault`). |
+| `SKIP` | Do not invoke the setter at all — any pre-existing field
initializer or earlier assignment is preserved. |
+
+The policy can be set at three levels (per-property wins, then session, then
context):
+
+```java
+public class Bean {
+ @MarshalledProp(nulls = Nulls.EMPTY)
+ public String s;
+
+ @MarshalledProp(nulls = Nulls.SKIP)
+ public String t = "initial";
+
+ public String u;
+}
+
+var p = JsonParser.create().nulls(Nulls.LEAVE).build();
+var b = p.parse("{\"s\":null,\"t\":null,\"u\":null}", Bean.class);
+// b.s == "" (per-prop EMPTY wins)
+// b.t == "initial" (per-prop SKIP preserves initializer)
+// b.u == null (no per-prop override; falls through to context LEAVE)
+```
+
+### Configuring via annotation
+
+The context-level default is also configurable on `@ParserConfig`:
+
+```java
+@ParserConfig(nulls = "EMPTY")
+@Rest(parsers = JsonParser.class)
+public class MyResource extends BasicRestServlet {}
+```
+
+---
+
+## Shared `Optional` contract
+
+`Optional<T>`, `OptionalInt`, `OptionalLong`, and `OptionalDouble` participate
in both the inclusion and the
+null-coercion contracts as **first-class** types:
+
+| Wire form | Java value | Notes |
+|---|---|---|
+| absent property | `Optional.empty()` | parser fills in via
`ClassMeta.getOptionalDefault()` |
+| `null` literal | `Optional.empty()` | the `null` is *never* stored bare
inside the `Optional` |
+| value `v` | `Optional.of(v)` | parser unwraps and re-wraps automatically |
+
+On serialization, `Optional.empty()` (and `OptionalInt.empty()` /
`OptionalLong.empty()` / `OptionalDouble.empty()`)
+is treated **identically to `null`**: omitted unless `keepNullProperties()` is
set, in which case it is emitted
+as `null`. A present `Optional` is emitted as its unwrapped value.
+
+On per-property null-coercion of an `Optional` property:
+
+- `LEAVE` — the setter receives `null` (the `Optional` reference itself is
null). This is the historical
+ behavior; most callers prefer `EMPTY`.
+- `EMPTY` / `DEFAULT` — the setter receives `Optional.empty()` (or the bean's
reference-instance value for
+ `DEFAULT`). **Never** a bare `null` wrapped inside the `Optional`.
+- `SKIP` — the setter is not invoked; the field's initializer value (or
earlier assignment) survives.
+
+---
+
+## Jackson mapping
+
+For migrators coming from Jackson, the rough equivalents are:
+
+| Jackson | Juneau |
+|---|---|
+| `@JsonInclude(NON_NULL)` (default on most setups) | default behavior
(`keepNullProperties` is off) |
+| `@JsonInclude(NON_EMPTY)` | `trimEmptyCollections()` + `trimEmptyMaps()` (+
`trimStrings()` for whitespace-only) |
+| `@JsonInclude(NON_DEFAULT)` | `nonDefault()` |
+| `@JsonSetter(nulls = Nulls.AS_EMPTY)` | `@MarshalledProp(nulls =
Nulls.EMPTY)` |
+| `@JsonSetter(nulls = Nulls.SKIP)` | `@MarshalledProp(nulls = Nulls.SKIP)` |
+| `@JsonSetter(nulls = Nulls.SET)` (Jackson default) | `Nulls.LEAVE` (Juneau
default) |
+| `DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL` + setter coercion
| `Nulls.DEFAULT` on the offending property |
+
+The Juneau knobs are intentionally **at the model level**
(`Serializer.Builder` / `Parser.Builder` /
+`@MarshalledProp`), so the behavior is identical across every format — there
is no format-specific opt-in.
+
+---
+
+## See also
+
+- [Serializers and Parsers](/docs/topics/SerializersAndParsers)
+- [Complex Data Types](/docs/topics/ComplexDataTypes)
+- [@MarshalledProp Annotation](/docs/topics/BeanPropAnnotation)
+- [Supported JDK Datatypes](/docs/topics/SupportedJdkDatatypes)
diff --git a/pages/topics/02.09.01.SupportedJdkDatatypes.md
b/pages/topics/02.09.01.SupportedJdkDatatypes.md
new file mode 100644
index 0000000000..28ae06ebf5
--- /dev/null
+++ b/pages/topics/02.09.01.SupportedJdkDatatypes.md
@@ -0,0 +1,176 @@
+---
+title: "Supported JDK Datatypes"
+slug: SupportedJdkDatatypes
+---
+
+Juneau provides **first-class, direct serializer/parser support** for a wide
range of JDK datatypes — no
+extra modules, no opt-in registration, no swap setup required for the common
cases. This page enumerates the
+supported types, their default wire forms, and the per-type knobs that let you
adjust the wire form across
+all formats.
+
+## Design principle: first-class > swaps
+
+Juneau handles common JDK datatypes through **direct serializer/parser code
paths plus per-type `*Format`
+enums** (e.g. `TemporalFormat`, `DurationFormat`, `BinaryFormat`, …), not
through
+[Default Swaps](/docs/topics/DefaultSwaps). Swaps are reserved for two
scenarios:
+
+1. End-user customization of how a third-party type should be marshalled.
+2. A handful of internal types whose wire form is genuinely a single canonical
encoding with no useful
+ knobs (e.g. `StackTraceElement`, `MatchResult`).
+
+The primitive optionals (`OptionalInt` / `OptionalLong` / `OptionalDouble`)
and `BitSet` are handled on the
+first-class path — the optionals mirror the `Optional<T>` plumbing directly,
and `BitSet` carries its own
+`bitSetFormat` builder knob (see below).
+
+The advantage of the first-class path is that the format choice is a **builder
setter** rather than a
+swap-replacement dance:
+
+```java
+// First-class: per-type format knob on the builder.
+var s =
JsonSerializer.create().temporalFormat(TemporalFormat.ISO_LOCAL).build();
+
+// Versus the swap-based alternative you'd need without it.
+var s = JsonSerializer.create().swaps(MyCustomInstantSwap.class).build();
+```
+
+This mirrors the Jackson `jackson-datatype-*` family conceptually but without
the per-type module wiring —
+Juneau ships the support in-box.
+
+---
+
+## Numbers
+
+| Type | Default wire form | Knob |
+|---|---|---|
+| `byte` / `Byte` | number | — |
+| `short` / `Short` | number | — |
+| `int` / `Integer` | number | — |
+| `long` / `Long` | number | — |
+| `float` / `Float` | number | `floatFormat` |
+| `double` / `Double` | number | `floatFormat` |
+| `BigInteger` | number (or string when overflow risk) | `bigNumberFormat` |
+| `BigDecimal` | number (or string when overflow risk) | `bigNumberFormat` |
+
+The `bigNumberFormat` knob (`BigNumberFormat.DEFAULT` | `STRING` | `NUMBER`)
lets you force big-number wire
+emission as a quoted string for JavaScript-safe round-trips.
+
+`floatFormat` covers `NaN`/`Infinity` handling (`FloatFormat.DEFAULT` writes
lenient JSON;
+`FloatFormat.STRICT` forces a string).
+
+---
+
+## Booleans, chars, strings
+
+| Type | Default wire form | Knob |
+|---|---|---|
+| `boolean` / `Boolean` | `true` / `false` | `booleanFormat` (allows `0/1`) |
+| `char` / `Character` | string of length 1 | — |
+| `String` | string | `trimStrings` |
+| `CharSequence` / `StringBuilder` / `StringBuffer` | string | — |
+
+---
+
+## `Optional` family
+
+| Type | Wire form | Empty form | Notes |
+|---|---|---|---|
+| `Optional<T>` | unwrapped `T` when present | omitted (or `null` if
`keepNullProperties`) | parse: absent or `null` → `Optional.empty()` |
+| `OptionalInt` | unwrapped `int` when present | omitted (or `null` if
`keepNullProperties`) | parse: absent or `null` → `OptionalInt.empty()` |
+| `OptionalLong` | unwrapped `long` when present | omitted (or `null` if
`keepNullProperties`) | parse: absent or `null` → `OptionalLong.empty()` |
+| `OptionalDouble` | unwrapped `double` when present | omitted (or `null` if
`keepNullProperties`) | parse: absent or `null` → `OptionalDouble.empty()` |
+
+`Optional.empty()` is treated **identically to `null`** by the inclusion
machinery (governed by
+`keepNullProperties`). See [Null & Inclusion
Policies](/docs/topics/NullAndInclusionPolicies) for the full
+contract, including how per-property `Nulls` coercion interacts.
+
+---
+
+## Dates, times, and durations (`java.time`)
+
+| Type | Default wire form | Knob |
+|---|---|---|
+| `Instant` | ISO-8601 instant string | `temporalFormat` |
+| `LocalDate` | ISO-8601 date string | `temporalFormat` |
+| `LocalDateTime` | ISO-8601 local-datetime string | `temporalFormat` |
+| `LocalTime` | ISO-8601 local-time string | `temporalFormat` |
+| `ZonedDateTime` | ISO-8601 zoned-datetime string | `temporalFormat` |
+| `OffsetDateTime` | ISO-8601 offset-datetime string | `temporalFormat` |
+| `OffsetTime` | ISO-8601 offset-time string | `temporalFormat` |
+| `Year` / `YearMonth` / `MonthDay` | ISO-8601 partial string |
`temporalFormat` |
+| `ZoneId` | zone-id string (e.g. `"America/New_York"`) | — |
+| `ZoneOffset` | zone-offset string (e.g. `"+05:00"`) | — (handled via
`ZoneId`) |
+| `Duration` | ISO-8601 duration string (`"PT15M"`) | `durationFormat` |
+| `Period` | ISO-8601 period string (`"P1Y2M"`) | `periodFormat` |
+
+The `temporalFormat` knob (enum) selects ISO-8601 (`DEFAULT`), local without
zone, RFC-1123, epoch millis, or
+a custom pattern. The `durationFormat` and `periodFormat` knobs select
ISO-8601 (default) or numeric milli /
+day forms.
+
+Legacy `java.util.Calendar` / `java.util.Date` are also supported via
`calendarFormat` / `dateFormat`.
+
+---
+
+## Identifiers and URI types
+
+| Type | Default wire form | Knob |
+|---|---|---|
+| `UUID` | string (e.g. `"550e8400-…"`) | `uuidFormat` |
+| `URI` / `URL` | string | — |
+| `Locale` | BCP-47 language tag string | `localeFormat` |
+| `TimeZone` | timezone-id string | `timezoneFormat` |
+| `Currency` | ISO-4217 currency-code string | `currencyFormat` |
+| `Class<?>` | class-name string | `classFormat` |
+
+---
+
+## Binary
+
+| Type | Default wire form | Knob |
+|---|---|---|
+| `byte[]` | Base-64 string | `binaryFormat` (Base-64 / Base-64-URL / hex /
SPACED-HEX) |
+| `InputStream` / `Reader` | inline content | — |
+| `BitSet` | set-bit-index list string (e.g. `"0,2,5"`) | `bitSetFormat`
(`INDICES` / `BITS` / `HEX`) |
+
+The `bitSetFormat` knob selects the textual wire form: `INDICES` (default,
ascending set-bit indices as a
+comma-delimited token), `BITS` (little-endian bit string, e.g. `"101001"`), or
`HEX` (hex-encoded
+little-endian byte array). It is configurable at all four precedence levels
(`@MarshalledProp`,
+`@Marshalled`, `@MarshalledConfig`, and the `bitSetFormat(...)` builder
setter), exactly like the other
+`*Format` enums.
+
+---
+
+## Enums and collections
+
+| Type | Default wire form | Notes |
+|---|---|---|
+| `enum` | string (`enumFormat = NAME`) or ordinal int | per-type via
`enumFormat` |
+| `EnumSet<E>` | JSON array of enum names | parses back to `EnumSet` for
declared parameter `EnumSet<E>`; falls through to a generic `Set<E>` for raw /
unparameterized declarations |
+| `EnumMap<E,V>` | JSON object keyed by enum name | parses back to `EnumMap`
for declared parameter `EnumMap<E,V>`; falls through to a generic `Map<E,V>`
for raw / unparameterized declarations |
+| `BitSet` | set-bit-index list string (`bitSetFormat`: `INDICES` / `BITS` /
`HEX`) | first-class direct support — no swap; round-trips via `BitSetFormat` |
+| `Collection<E>` / `List<E>` / `Set<E>` / `Queue<E>` / `Deque<E>` | JSON
array | concrete implementation chosen by declared type |
+| `Map<K,V>` | JSON object | concrete implementation chosen by declared type |
+| `Iterator<E>` / `Iterable<E>` / `Stream<E>` | JSON array (serialize only) |
parse not supported |
+
+---
+
+## Juneau vs Jackson datatype modules
+
+Jackson ships per-type "datatype modules" (`jackson-datatype-jsr310`,
`jackson-datatype-jdk8`,
+`jackson-datatype-guava`, …) that you opt into individually. Juneau collapses
that surface in two ways:
+
+1. **JDK datatypes (`java.time`, `Optional*`, `BitSet`, etc.)** are supported
in-box by direct
+ serializer/parser code paths plus typed `*Format` enums for the format
choice — no module to register.
+2. **Third-party datatypes** continue to follow the
[Swap](/docs/topics/SwapBasics) /
+ [@Swap](/docs/topics/SwapAnnotation) machinery, which is symmetric to a
Jackson custom
+ `JsonSerializer`/`JsonDeserializer` pair but additionally usable across
every Juneau format.
+
+The net result: most Spring-Boot-style "I need `java.time` in my JSON" wiring
is unnecessary in Juneau —
+`JsonSerializer.DEFAULT.serialize(Instant.now())` Just Works.
+
+---
+
+## See also
+
+- [Complex Data Types](/docs/topics/ComplexDataTypes)
+- [Default Swaps](/docs/topics/DefaultSwaps)
+- [Null & Inclusion Policies](/docs/topics/NullAndInclusionPolicies)
diff --git a/sidebars.ts b/sidebars.ts
index 445ae49b74..82f7157a41 100644
--- a/sidebars.ts
+++ b/sidebars.ts
@@ -193,6 +193,11 @@ const sidebars: SidebarsConfig = {
id:
'topics/02.06.ContextSettings',
label: '2.6. Context
Settings',
},
+ {
+ type: 'doc',
+ id:
'topics/02.06.01.NullAndInclusionPolicies',
+ label: '2.6.1. Null &
Inclusion Policies',
+ },
{
type: 'doc',
id:
'topics/02.07.ContextAnnotations',
@@ -213,6 +218,11 @@ const sidebars: SidebarsConfig = {
id:
'topics/02.09.ComplexDataTypes',
label: '2.9. Complex
Data Types',
},
+ {
+ type: 'doc',
+ id:
'topics/02.09.01.SupportedJdkDatatypes',
+ label: '2.9.1.
Supported JDK Datatypes',
+ },
{
type: 'doc',
id:
'topics/02.10.SerializerSetsParserSets',
