Added documentation for "Serializers"

Author: bastianeicher

docs/.pages

@@ -4,7 +4,7 @@ nav:
   - setup
   - endpoints
   - serializers
-  - error-handling
   - link-handling
+  - error-handling
   - code-generation
   - imprint.md

docs/serializers/.pages

@@ -0,0 +1,5 @@
+nav:
+  - index.md
+  - json.md
+  - bson.md
+  - xml.md

docs/serializers/bson.md

@@ -0,0 +1,18 @@
+# BSON
+
+=== "C#"
+
+    The BSON serializer provides efficient binary serialization using [Newtonsoft.Json](https://www.newtonsoft.com/json)'s BSON support:
+
+    ```csharp
+    var endpoint = new EntryEndpoint(
+        new Uri("http://example.com/"),
+        serializer: new BsonSerializer());
+    ```
+
+    The BSON serializer uses the same Newtonsoft.Json settings as the default JSON serializer:
+
+    - Camel-case property naming
+    - String enums with camel-case naming
+    - Null values are not serialized
+    - Automatic type name handling

docs/serializers/index.md

@@ -1,3 +1,37 @@
 # Serializers
 
 Serializers control how entities are serialized when sending requests and deserialized when receiving responses.
+
+TypedRest provides built-in serializers for various transport formats:
+
+- [JSON](json.md)
+- [BSON](bson.md)
+- [XML](xml.md)
+
+You can also create and use custom serializers.
+
+## Inheritance
+
+When creating [endpoints](../endpoints/index.md), the serializer is automatically inherited from the parent (referrer) endpoint:
+
+=== "C#"
+
+    ```csharp
+    var client = new EntryEndpoint(new Uri("http://example.com/"));
+    client.Serializer = new SystemTextJsonSerializer();
+
+    var contacts = new CollectionEndpoint<Contact>(client, relativeUri: "./contacts");
+    // contacts.Serializer is automatically set to the same SystemTextJsonSerializer
+    ```
+
+=== "TypeScript"
+
+    ```typescript
+    const client = new EntryEndpoint(new URL("http://example.com/"));
+    client.serializer = new CustomSerializer();
+
+    const contacts = new CollectionEndpoint<Contact>(client, "./contacts");
+    // contacts.serializer is automatically set to the same CustomSerializer
+    ```
+
+This inheritance ensures consistent serialization behavior across your entire endpoint hierarchy.

docs/serializers/json.md

@@ -0,0 +1,103 @@
+# JSON
+
+JSON is the default serialization format in TypedRest.
+
+=== "C#"
+
+    **Newtonsoft.Json (Default)**
+
+    The default serializer uses [Newtonsoft.Json](https://www.newtonsoft.com/json) with the following settings:
+
+    - Camel-case property naming
+    - String enums with camel-case naming
+    - Null values are not serialized
+    - Automatic type name handling
+
+    ```csharp
+    var endpoint = new EntryEndpoint(new Uri("http://example.com/"));
+    // Uses NewtonsoftJsonSerializer by default
+    ```
+
+    To customize the serializer settings:
+
+    ```csharp
+    var endpoint = new EntryEndpoint(
+        new Uri("http://example.com/"),
+        serializer: new NewtonsoftJsonSerializer
+        {
+            SerializerSettings =
+            {
+                DateFormatString = "yyyy-MM-dd"
+            }
+        });
+    ```
+
+    **System.Text.Json**
+
+    You can also use the [System.Text.Json](https://learn.microsoft.com/en-us/dotnet/api/system.text.json) serializer with the [TypedRest.SystemTextJson](https://www.nuget.org/packages/TypedRest.SystemTextJson) NuGet package:
+
+    !!! note
+        The `TypedRest.SystemTextJson` package version should match your main `TypedRest` package version. Both packages follow the same versioning scheme.
+
+    Default settings:
+
+    - Web defaults (camel-case property naming)
+    - Null values are not serialized when writing
+
+    Basic usage:
+
+    ```csharp
+    var endpoint = new EntryEndpoint(
+        new Uri("http://example.com/"),
+        serializer: new SystemTextJsonSerializer());
+    ```
+
+    To customize the serializer options:
+
+    ```csharp
+    var endpoint = new EntryEndpoint(
+        new Uri("http://example.com/"),
+        serializer: new SystemTextJsonSerializer
+        {
+            Options =
+            {
+                WriteIndented = true,
+                Converters = {new JsonStringEnumConverter() }
+            }
+        });
+    ```
+
+=== "TypeScript"
+
+    TypeScript uses the native `JSON.stringify()` and `JSON.parse()` methods:
+
+    ```typescript
+    const endpoint = new EntryEndpoint(new URL("http://example.com/"));
+    // Uses JsonSerializer by default
+    ```
+
+    **Custom serializers**
+
+    You can implement the `Serializer` interface for custom serialization:
+
+    ```typescript
+    import { Serializer } from "typedrest";
+
+    class MySerializer implements Serializer {
+        readonly supportedMediaTypes = ["application/json"];
+
+        serialize<T>(entity: T): string {
+            // Custom serialization logic
+            return JSON.stringify(entity);
+        }
+
+        deserialize<T>(text: string): T {
+            // Custom deserialization logic
+            return JSON.parse(text) as T;
+        }
+    }
+
+    const endpoint = new EntryEndpoint(
+        new URL("http://example.com/"),
+        new MySerializer());
+    ```

docs/serializers/xml.md

@@ -0,0 +1,8 @@
+# XML
+
+=== "C#"
+    ```csharp
+    var endpoint = new EntryEndpoint(
+        new Uri("http://example.com/"),
+        serializer: new XmlSerializer());
+    ```