From ec32cfa6e5162c950804352cf42ab1fd95db8de4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?K=C3=A9vin=20Chalet?= <kevinchalet@gmail.com>
Date: Thu, 14 Apr 2022 03:55:19 +0200
Subject: [PATCH] Add System.Text.Json.Nodes support and revamp the
 OpenIddictParameter primitive

---
 Directory.Build.targets                       |    6 +
 .../Startup.cs                                |   17 +-
 .../Worker.cs                                 |   16 +
 .../OpenIddict.Abstractions.csproj            |    2 +-
 .../OpenIddictResources.resx                  |    2 +-
 .../Primitives/OpenIddictConverter.cs         |   14 +-
 .../Primitives/OpenIddictMessage.cs           |   46 +-
 .../Primitives/OpenIddictParameter.cs         |  961 ++++++++++-----
 .../Primitives/OpenIddictRequest.cs           |   16 +
 .../Primitives/OpenIddictResponse.cs          |   16 +
 .../OpenIddictClientAspNetCoreHandlers.cs     |    7 +
 .../OpenIddictClientHandlers.Exchange.cs      |   19 +-
 .../OpenIddictClientHandlers.Userinfo.cs      |  104 +-
 .../OpenIddictClientHandlers.cs               |    1 +
 ...ServerAspNetCoreHandlers.Authentication.cs |   34 +-
 ...nIddictServerAspNetCoreHandlers.Session.cs |   34 +-
 .../OpenIddictServerAspNetCoreHandlers.cs     |   13 +
 ...IddictServerOwinHandlers.Authentication.cs |   34 +-
 .../OpenIddictServerOwinHandlers.Session.cs   |   34 +-
 .../OpenIddictValidationAspNetCoreHandlers.cs |    7 +
 ...nIddictValidationHandlers.Introspection.cs |  128 +-
 .../Primitives/OpenIddictConverterTests.cs    |   44 +-
 .../Primitives/OpenIddictMessageTests.cs      |   22 +
 .../Primitives/OpenIddictParameterTests.cs    | 1084 ++++++++++++++++-
 ...nIddictServerAspNetCoreIntegrationTests.cs |   34 +-
 25 files changed, 2155 insertions(+), 540 deletions(-)

diff --git a/Directory.Build.targets b/Directory.Build.targets
index 8d162cfd..bf296bb2 100644
--- a/Directory.Build.targets
+++ b/Directory.Build.targets
@@ -84,6 +84,12 @@
     <DefineConstants>$(DefineConstants);SUPPORTS_MULTIPLE_VALUES_IN_QUERYHELPERS</DefineConstants>
   </PropertyGroup>
 
+  <PropertyGroup
+    Condition=" ('$(TargetFrameworkIdentifier)' == '.NETCoreApp' And $([MSBuild]::VersionGreaterThanOrEquals($(TargetFrameworkVersion), '6.0'))) ">
+    <DefineConstants>$(DefineConstants);SUPPORTS_DIRECT_JSON_ELEMENT_SERIALIZATION</DefineConstants>
+    <DefineConstants>$(DefineConstants);SUPPORTS_JSON_NODES</DefineConstants>
+  </PropertyGroup>
+
   <!--
     Note: Entity Framework Core 2.x references System.Interactive.Async 3.x, that includes
     its own IAsyncEnumerable. To work around collisions between this type and the new type
diff --git a/sandbox/OpenIddict.Sandbox.AspNetCore.Server/Startup.cs b/sandbox/OpenIddict.Sandbox.AspNetCore.Server/Startup.cs
index b8d17bc5..57b0832e 100644
--- a/sandbox/OpenIddict.Sandbox.AspNetCore.Server/Startup.cs
+++ b/sandbox/OpenIddict.Sandbox.AspNetCore.Server/Startup.cs
@@ -79,9 +79,11 @@ public class Startup
             // Register the OpenIddict server components.
             .AddServer(options =>
             {
-                // Enable the authorization, device, logout, token, userinfo and verification endpoints.
+                // Enable the authorization, device, introspection,
+                // logout, token, userinfo and verification endpoints.
                 options.SetAuthorizationEndpointUris("/connect/authorize")
                        .SetDeviceEndpointUris("/connect/device")
+                       .SetIntrospectionEndpointUris("/connect/introspect")
                        .SetLogoutEndpointUris("/connect/logout")
                        .SetTokenEndpointUris("/connect/token")
                        .SetUserinfoEndpointUris("/connect/userinfo")
@@ -149,6 +151,19 @@ public class Startup
                 // Import the configuration from the local OpenIddict server instance.
                 options.UseLocalServer();
 
+                // Instead of validating the token locally by reading it directly,
+                // introspection can be used to ask a remote authorization server
+                // to validate the token (and its attached database entry).
+                //
+                // options.UseIntrospection()
+                //        .SetIssuer("https://localhost:44395/")
+                //        .SetClientId("resource_server")
+                //        .SetClientSecret("80B552BB-4CD8-48DA-946E-0815E0147DD2");
+                //
+                // When introspection is used, System.Net.Http integration must be enabled.
+                //
+                // options.UseSystemNetHttp();
+
                 // Register the ASP.NET Core host.
                 options.UseAspNetCore();
 
diff --git a/sandbox/OpenIddict.Sandbox.AspNetCore.Server/Worker.cs b/sandbox/OpenIddict.Sandbox.AspNetCore.Server/Worker.cs
index a10cb10b..40af0b80 100644
--- a/sandbox/OpenIddict.Sandbox.AspNetCore.Server/Worker.cs
+++ b/sandbox/OpenIddict.Sandbox.AspNetCore.Server/Worker.cs
@@ -66,6 +66,22 @@ public class Worker : IHostedService
                 });
             }
 
+            // Note: when using introspection instead of local token validation,
+            // an application entry MUST be created to allow the resource server
+            // to communicate with OpenIddict's introspection endpoint.
+            if (await manager.FindByClientIdAsync("resource_server") is null)
+            {
+                await manager.CreateAsync(new OpenIddictApplicationDescriptor
+                {
+                    ClientId = "resource_server",
+                    ClientSecret = "80B552BB-4CD8-48DA-946E-0815E0147DD2",
+                    Permissions =
+                    {
+                        Permissions.Endpoints.Introspection
+                    }
+                });
+            }
+
             // To test this sample with Postman, use the following settings:
             //
             // * Authorization URL: https://localhost:44395/connect/authorize
diff --git a/src/OpenIddict.Abstractions/OpenIddict.Abstractions.csproj b/src/OpenIddict.Abstractions/OpenIddict.Abstractions.csproj
index d261bf00..eee415c8 100644
--- a/src/OpenIddict.Abstractions/OpenIddict.Abstractions.csproj
+++ b/src/OpenIddict.Abstractions/OpenIddict.Abstractions.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net461;netstandard2.0;netstandard2.1</TargetFrameworks>
+    <TargetFrameworks>net461;net6.0;netstandard2.0;netstandard2.1</TargetFrameworks>
     <GenerateResxSourceEmitFormatMethods>true</GenerateResxSourceEmitFormatMethods>
   </PropertyGroup>
 
diff --git a/src/OpenIddict.Abstractions/OpenIddictResources.resx b/src/OpenIddict.Abstractions/OpenIddictResources.resx
index 3028e83e..b4f4ae4b 100644
--- a/src/OpenIddict.Abstractions/OpenIddictResources.resx
+++ b/src/OpenIddict.Abstractions/OpenIddictResources.resx
@@ -506,7 +506,7 @@ This may indicate that the event handler responsible for processing OpenID Conne
     <value>The ASP.NET Core HTTP request cannot be resolved.</value>
   </data>
   <data name="ID0115" xml:space="preserve">
-    <value>Only strings, booleans, integers, arrays of strings and instances of type 'OpenIddictParameter' or 'JsonElement' can be returned as custom parameters.</value>
+    <value>Only strings, booleans, integers, arrays of strings and instances of type 'OpenIddictParameter' or 'JsonElement' can be returned as custom parameters. On .NET 6.0 and higher, instances of type 'JsonNode' (i.e 'JsonArray', 'JsonObject' and 'JsonValue') are also supported.</value>
   </data>
   <data name="ID0116" xml:space="preserve">
     <value>A distributed cache instance must be registered when enabling request caching.
diff --git a/src/OpenIddict.Abstractions/Primitives/OpenIddictConverter.cs b/src/OpenIddict.Abstractions/Primitives/OpenIddictConverter.cs
index de673f10..efa2c556 100644
--- a/src/OpenIddict.Abstractions/Primitives/OpenIddictConverter.cs
+++ b/src/OpenIddict.Abstractions/Primitives/OpenIddictConverter.cs
@@ -10,7 +10,7 @@ using System.Text.Json.Serialization;
 namespace OpenIddict.Abstractions;
 
 /// <summary>
-/// Represents a JSON.NET converter able to convert OpenIddict primitives.
+/// Represents a JSON converter able to convert OpenIddict primitives.
 /// </summary>
 public class OpenIddictConverter : JsonConverter<OpenIddictMessage>
 {
@@ -20,11 +20,9 @@ public class OpenIddictConverter : JsonConverter<OpenIddictMessage>
     /// <param name="typeToConvert">The type to convert.</param>
     /// <returns><see langword="true"/> if the type is supported, <see langword="false"/> otherwise.</returns>
     public override bool CanConvert(Type typeToConvert!!)
-    {
-        return typeToConvert == typeof(OpenIddictMessage) ||
-               typeToConvert == typeof(OpenIddictRequest) ||
-               typeToConvert == typeof(OpenIddictResponse);
-    }
+        => typeToConvert == typeof(OpenIddictMessage) ||
+           typeToConvert == typeof(OpenIddictRequest) ||
+           typeToConvert == typeof(OpenIddictResponse);
 
     /// <summary>
     /// Deserializes an <see cref="OpenIddictMessage"/> instance.
@@ -50,7 +48,5 @@ public class OpenIddictConverter : JsonConverter<OpenIddictMessage>
     /// <param name="value">The instance.</param>
     /// <param name="options">The JSON serializer options.</param>
     public override void Write(Utf8JsonWriter writer!!, OpenIddictMessage value!!, JsonSerializerOptions options)
-    {
-        value.WriteTo(writer);
-    }
+        => value.WriteTo(writer);
 }
diff --git a/src/OpenIddict.Abstractions/Primitives/OpenIddictMessage.cs b/src/OpenIddict.Abstractions/Primitives/OpenIddictMessage.cs
index efe548a9..5649420b 100644
--- a/src/OpenIddict.Abstractions/Primitives/OpenIddictMessage.cs
+++ b/src/OpenIddict.Abstractions/Primitives/OpenIddictMessage.cs
@@ -12,6 +12,10 @@ using System.Text.Json;
 using System.Text.Json.Serialization;
 using Microsoft.Extensions.Primitives;
 
+#if SUPPORTS_JSON_NODES
+using System.Text.Json.Nodes;
+#endif
+
 namespace OpenIddict.Abstractions;
 
 /// <summary>
@@ -64,6 +68,34 @@ public class OpenIddictMessage
         }
     }
 
+#if SUPPORTS_JSON_NODES
+    /// <summary>
+    /// Initializes a new OpenIddict message.
+    /// </summary>
+    /// <param name="parameters">The message parameters.</param>
+    /// <remarks>Parameters with a null or empty key are always ignored.</remarks>
+    public OpenIddictMessage(JsonObject parameters!!)
+    {
+        foreach (var parameter in parameters)
+        {
+            // Ignore parameters whose name is null or empty.
+            if (string.IsNullOrEmpty(parameter.Key))
+            {
+                continue;
+            }
+
+            // While generally discouraged, JSON objects can contain multiple properties with
+            // the same name. In this case, the last occurrence replaces the previous ones.
+            if (HasParameter(parameter.Key))
+            {
+                RemoveParameter(parameter.Key);
+            }
+
+            AddParameter(parameter.Key, parameter.Value);
+        }
+    }
+#endif
+
     /// <summary>
     /// Initializes a new OpenIddict message.
     /// </summary>
@@ -220,19 +252,7 @@ public class OpenIddictMessage
     /// <param name="name">The parameter name.</param>
     /// <returns>The parameter value, or <see langword="null"/> if it cannot be found.</returns>
     public OpenIddictParameter? GetParameter(string name)
-    {
-        if (string.IsNullOrEmpty(name))
-        {
-            throw new ArgumentException(SR.GetResourceString(SR.ID0190), nameof(name));
-        }
-
-        if (Parameters.TryGetValue(name, out OpenIddictParameter value))
-        {
-            return value;
-        }
-
-        return null;
-    }
+        => TryGetParameter(name, out var parameter) ? parameter : (OpenIddictParameter?) null;
 
     /// <summary>
     /// Gets all the parameters associated with this instance.
diff --git a/src/OpenIddict.Abstractions/Primitives/OpenIddictParameter.cs b/src/OpenIddict.Abstractions/Primitives/OpenIddictParameter.cs
index 95fb938b..81d7486e 100644
--- a/src/OpenIddict.Abstractions/Primitives/OpenIddictParameter.cs
+++ b/src/OpenIddict.Abstractions/Primitives/OpenIddictParameter.cs
@@ -7,10 +7,13 @@
 using System.Collections.Immutable;
 using System.ComponentModel;
 using System.Globalization;
-using System.Text;
 using System.Text.Encodings.Web;
 using System.Text.Json;
 
+#if SUPPORTS_JSON_NODES
+using System.Text.Json.Nodes;
+#endif
+
 namespace OpenIddict.Abstractions;
 
 /// <summary>
@@ -37,6 +40,14 @@ public readonly struct OpenIddictParameter : IEquatable<OpenIddictParameter>
     /// <param name="value">The parameter value.</param>
     public OpenIddictParameter(JsonElement value) => Value = value;
 
+#if SUPPORTS_JSON_NODES
+    /// <summary>
+    /// Initializes a new parameter using the specified value.
+    /// </summary>
+    /// <param name="value">The parameter value.</param>
+    public OpenIddictParameter(JsonNode? value) => Value = value;
+#endif
+
     /// <summary>
     /// Initializes a new parameter using the specified value.
     /// </summary>
@@ -76,20 +87,68 @@ public readonly struct OpenIddictParameter : IEquatable<OpenIddictParameter>
     public OpenIddictParameter? this[string name] => GetNamedParameter(name);
 
     /// <summary>
-    /// Gets the number of unnamed child items contained in the current parameter
-    /// or 0 if the parameter doesn't represent an array of strings or a JSON array.
+    /// Gets the number of named or unnamed child items contained in the current parameter or 0
+    /// if the parameter doesn't represent an array of strings, a JSON array or a JSON object.
     /// </summary>
-    public int Count => Value switch
+    public int Count
     {
-        // If the parameter is a primitive array of strings, return its length.
-        string?[] value => value.Length,
+        get
+        {
+            return Value switch
+            {
+                // If the parameter is a primitive array of strings, return its length.
+                string?[] value => value.Length,
+
+                // If the parameter is a JSON array or a JSON object, return its length.
+                JsonElement { ValueKind: JsonValueKind.Array or JsonValueKind.Object } element
+                    => Count(element),
+
+#if SUPPORTS_JSON_NODES
+                // If the parameter is a JsonArray, return its length.
+                JsonArray value => value.Count,
+
+                // If the parameter is a JsonObject, return its length.
+                JsonObject value => value.Count,
+
+                // If the parameter is any other JsonNode (e.g a JsonValue), serialize it
+                // to a JsonElement first to determine its actual JSON representation
+                // and extract the number of items if the element is a JSON array or object.
+                JsonNode value when JsonSerializer.SerializeToElement(value)
+                    is JsonElement { ValueKind: JsonValueKind.Array or JsonValueKind.Object } element
+                    => Count(element),
+#endif
+                // Otherwise, return 0.
+                _ => 0
+            };
+
+            static int Count(JsonElement element)
+            {
+                switch (element.ValueKind)
+                {
+                    case JsonValueKind.Array:
+                        return element.GetArrayLength();
 
-        // If the parameter is a JSON array, return its length.
-        JsonElement { ValueKind: JsonValueKind.Array } value => value.GetArrayLength(),
+                    case JsonValueKind.Object:
+                        var count = 0;
 
-        // Otherwise, return 0.
-        _ => 0
-    };
+                        using (var enumerator = element.EnumerateObject())
+                        {
+                            checked
+                            {
+                                while (enumerator.MoveNext())
+                                {
+                                    count++;
+                                }
+                            }
+                        }
+
+                        return count;
+
+                    default: return 0;
+                }
+            }
+        }
+    }
 
     /// <summary>
     /// Gets the associated value, that can be either a primitive CLR type
@@ -103,91 +162,137 @@ public readonly struct OpenIddictParameter : IEquatable<OpenIddictParameter>
     /// instance is equal to the specified <see cref="OpenIddictParameter"/>.
     /// </summary>
     /// <param name="other">The other object to which to compare this instance.</param>
-    /// <returns><see langword="true"/> if the two instances are equal, <see langword="false"/> otherwise.</returns>
+    /// <returns>
+    /// <see langword="true"/> if the two instances have both the same representation
+    /// (e.g <see cref="string"/>) and value, <see langword="false"/> otherwise.
+    /// </returns>
     public bool Equals(OpenIddictParameter other)
     {
         return (left: Value, right: other.Value) switch
         {
             // If the two parameters reference the same instance, return true.
+            //
             // Note: true will also be returned if the two parameters are null.
             var (left, right) when ReferenceEquals(left, right) => true,
 
             // If one of the two parameters is null, return false.
             (null, _) or (_, null) => false,
 
+            // If the two parameters are booleans, compare them directly.
+            (bool left, bool right) => left == right,
+
+            // If the two parameters are integers, compare them directly.
+            (long left, long right) => left == right,
+
+            // If the two parameters are strings, use string.Equals().
+            (string left, string right) => string.Equals(left, right, StringComparison.Ordinal),
+
             // If the two parameters are string arrays, use SequenceEqual().
             (string?[] left, string?[] right) => left.SequenceEqual(right),
 
+            // If one of the two parameters is an undefined JsonElement, treat it
+            // as a null value and return true if the other parameter is null too.
+            (JsonElement { ValueKind: JsonValueKind.Null or JsonValueKind.Undefined }, var right)
+                => right is null,
+
+            (var left, JsonElement { ValueKind: JsonValueKind.Null or JsonValueKind.Undefined })
+                => left is null,
+
             // If the two parameters are JsonElement instances, use the custom comparer.
-            (JsonElement left, JsonElement right) => Equals(left, right),
+            (JsonElement left, JsonElement right) => DeepEquals(left, right),
 
-            // When one of the parameters is a bool, compare them as booleans.
-            (JsonElement { ValueKind: JsonValueKind.True  }, bool right) => right,
-            (JsonElement { ValueKind: JsonValueKind.False }, bool right) => !right,
+            // When one of the parameters is a JsonElement, compare their underlying values.
+            (JsonElement { ValueKind: JsonValueKind.True }, bool right) => right,
+            (bool left, JsonElement { ValueKind: JsonValueKind.True })  => left,
 
-            (bool left, JsonElement { ValueKind: JsonValueKind.True  }) => left,
-            (bool left, JsonElement { ValueKind: JsonValueKind.False }) => !left,
+            (JsonElement { ValueKind: JsonValueKind.False }, bool right) => !right,
+            (bool left, JsonElement { ValueKind: JsonValueKind.False })  => !left,
 
-            // When one of the parameters is a number, compare them as integers.
             (JsonElement { ValueKind: JsonValueKind.Number } left, long right)
-                => right == left.GetInt64(),
+                when left.TryGetInt64(out var result) => result == right,
 
             (long left, JsonElement { ValueKind: JsonValueKind.Number } right)
-                => left == right.GetInt64(),
+                when right.TryGetInt64(out var result) => left == result,
 
-            // When one of the parameters is a string, compare them as texts.
             (JsonElement { ValueKind: JsonValueKind.String } left, string right)
                 => string.Equals(left.GetString(), right, StringComparison.Ordinal),
 
             (string left, JsonElement { ValueKind: JsonValueKind.String } right)
                 => string.Equals(left, right.GetString(), StringComparison.Ordinal),
 
-            // Otherwise, use direct CLR comparison.
-            var (left, right) => left.Equals(right)
+#if SUPPORTS_JSON_NODES
+            // When one of the parameters is a JsonValue, try to compare their underlying values
+            // if the wrapped type is a common CLR primitive type to avoid the less efficient
+            // JsonElement-based comparison, that requires doing a full JSON serialization.
+            (JsonValue left, bool right) when  left.TryGetValue(out bool result) => result == right,
+            (bool left, JsonValue right) when right.TryGetValue(out bool result) => result == left,
+
+            (JsonValue left, long right) when  left.TryGetValue(out int result) => result == right,
+            (long left, JsonValue right) when right.TryGetValue(out int result) => result == left,
+
+            (JsonValue left, long right) when  left.TryGetValue(out long result) => result == right,
+            (long left, JsonValue right) when right.TryGetValue(out long result) => result == left,
+
+            (JsonValue left, string right) when left.TryGetValue(out string? result)
+                => string.Equals(result, right, StringComparison.Ordinal),
+
+            (string left, JsonValue right) when right.TryGetValue(out string? result)
+                => string.Equals(left, result, StringComparison.Ordinal),
+#endif
+            // Otherwise, serialize both values to JsonElement and compare them.
+#if SUPPORTS_DIRECT_JSON_ELEMENT_SERIALIZATION
+            var (left, right) => DeepEquals(
+                JsonSerializer.SerializeToElement(left, left.GetType()),
+                JsonSerializer.SerializeToElement(right, right.GetType()))
+#else
+            var (left, right) => DeepEquals(
+                JsonSerializer.Deserialize<JsonElement>(JsonSerializer.Serialize(left, left.GetType())),
+                JsonSerializer.Deserialize<JsonElement>(JsonSerializer.Serialize(right, right.GetType())))
+#endif
         };
 
-        static bool Equals(JsonElement left, JsonElement right)
+        static bool DeepEquals(JsonElement left, JsonElement right)
         {
-            switch (left.ValueKind)
+            switch ((left.ValueKind, right.ValueKind))
             {
-                case JsonValueKind.Undefined:
-                    return right.ValueKind is JsonValueKind.Undefined;
-
-                case JsonValueKind.Null:
-                    return right.ValueKind is JsonValueKind.Null;
-
-                case JsonValueKind.False:
-                    return right.ValueKind is JsonValueKind.False;
+                case (JsonValueKind.Undefined, JsonValueKind.Undefined):
+                case (JsonValueKind.Null,      JsonValueKind.Null):
+                case (JsonValueKind.False,     JsonValueKind.False):
+                case (JsonValueKind.True,      JsonValueKind.True):
+                    return true;
 
-                case JsonValueKind.True:
-                    return right.ValueKind is JsonValueKind.True;
+                // Treat undefined JsonElement instances as null values.
+                case (JsonValueKind.Undefined, JsonValueKind.Null):
+                case (JsonValueKind.Null, JsonValueKind.Undefined):
+                    return true;
 
-                case JsonValueKind.Number when right.ValueKind is JsonValueKind.Number:
-                    return left.GetInt64() == right.GetInt64();
+                case (JsonValueKind.Number, JsonValueKind.Number):
+                    return string.Equals(left.GetRawText(), right.GetRawText(), StringComparison.Ordinal);
 
-                case JsonValueKind.String when right.ValueKind is JsonValueKind.String:
+                case (JsonValueKind.String, JsonValueKind.String):
                     return string.Equals(left.GetString(), right.GetString(), StringComparison.Ordinal);
 
-                case JsonValueKind.Array when right.ValueKind is JsonValueKind.Array:
-                    if (left.GetArrayLength() != right.GetArrayLength())
+                case (JsonValueKind.Array, JsonValueKind.Array):
+                {
+                    var length = left.GetArrayLength();
+                    if (length != right.GetArrayLength())
                     {
                         return false;
                     }
 
-                    using (var enumerator = left.EnumerateArray())
+                    for (var index = 0; index < length; index++)
                     {
-                        for (var index = 0; enumerator.MoveNext(); index++)
+                        if (!DeepEquals(left[index], right[index]))
                         {
-                            if (!Equals(left[index], right[index]))
-                            {
-                                return false;
-                            }
+                            return false;
                         }
                     }
 
                     return true;
+                }
 
-                case JsonValueKind.Object when right.ValueKind is JsonValueKind.Object:
+                case (JsonValueKind.Object, JsonValueKind.Object):
+                {
                     foreach (var property in left.EnumerateObject())
                     {
                         if (!right.TryGetProperty(property.Name, out JsonElement element) ||
@@ -196,13 +301,14 @@ public readonly struct OpenIddictParameter : IEquatable<OpenIddictParameter>
                             return false;
                         }
 
-                        if (!Equals(property.Value, element))
+                        if (!DeepEquals(property.Value, element))
                         {
                             return false;
                         }
                     }
 
                     return true;
+                }
 
                 default: return false;
             }
@@ -214,7 +320,10 @@ public readonly struct OpenIddictParameter : IEquatable<OpenIddictParameter>
     /// instance is equal to the specified <see cref="object"/>.
     /// </summary>
     /// <param name="obj">The other object to which to compare this instance.</param>
-    /// <returns><see langword="true"/> if the two instances are equal, <see langword="false"/> otherwise.</returns>
+    /// <returns>
+    /// <see langword="true"/> if the two instances have both the same representation
+    /// (e.g <see cref="string"/>) and value, <see langword="false"/> otherwise.
+    /// </returns>
     public override bool Equals(object? obj) => obj is OpenIddictParameter parameter && Equals(parameter);
 
     /// <summary>
@@ -228,40 +337,81 @@ public readonly struct OpenIddictParameter : IEquatable<OpenIddictParameter>
             // When the parameter value is null, return 0.
             null => 0,
 
-            // When the parameter is a JsonElement, compute its hash code.
-            JsonElement value => GetHashCode(value),
+            // When the parameter is an array of strings, compute the hash code of its items to
+            // match the logic used when treating a JsonElement instance representing an array.
+            string?[] value => GetHashCodeFromArray(value),
 
+            // When the parameter is a JsonElement, compute its hash code.
+            JsonElement value => GetHashCodeFromJsonElement(value),
+
+#if SUPPORTS_JSON_NODES
+            // When the parameter is a JsonValue wrapping a JsonElement,
+            // apply the same logic as with direct JsonElement instances.
+            JsonValue value when value.TryGetValue(out JsonElement element)
+                => GetHashCodeFromJsonElement(element),
+
+            // When the parameter is a JsonValue, compute the hash code of its underlying value
+            // if the wrapped type is a common CLR primitive type to avoid the less efficient
+            // JsonElement-based computation, that requires doing a full JSON serialization.
+            JsonValue value when value.TryGetValue(out bool result) => result.GetHashCode(),
+
+            JsonValue value when value.TryGetValue(out int  result) => result.GetHashCode(),
+            JsonValue value when value.TryGetValue(out long result) => result.GetHashCode(),
+
+            JsonValue value when value.TryGetValue(out string? result) => result.GetHashCode(),
+
+            // When the parameter is a JsonNode (e.g a JsonValue wrapping a non-primitive type),
+            // serialize it to a JsonElement first to determine its actual JSON representation
+            // and apply the same logic as with non-wrapped JsonElement instances.
+            JsonNode value when JsonSerializer.SerializeToElement(value) is JsonElement element
+                => GetHashCodeFromJsonElement(element),
+#endif
             // Otherwise, use the default hash code method.
             var value => value.GetHashCode()
         };
 
-        static int GetHashCode(JsonElement value)
+        static int GetHashCodeFromArray(string?[] array)
+        {
+            var hash = new HashCode();
+
+            for (var index = 0; index < array.Length; index++)
+            {
+                hash.Add(array[index]);
+            }
+
+            return hash.ToHashCode();
+        }
+
+        static int GetHashCodeFromJsonElement(JsonElement element)
         {
-            switch (value.ValueKind)
+            switch (element.ValueKind)
             {
                 case JsonValueKind.Undefined:
                 case JsonValueKind.Null:
                     return 0;
 
+                case JsonValueKind.True:
+                    return true.GetHashCode();
+
                 case JsonValueKind.False:
                     return false.GetHashCode();
 
-                case JsonValueKind.True:
-                    return true.GetHashCode();
+                case JsonValueKind.Number when element.TryGetInt64(out var result):
+                    return result.GetHashCode();
 
                 case JsonValueKind.Number:
-                    return value.GetInt64().GetHashCode();
+                    return element.GetRawText().GetHashCode();
 
                 case JsonValueKind.String:
-                    return value.GetString()!.GetHashCode();
+                    return element.GetString()!.GetHashCode();
 
                 case JsonValueKind.Array:
                 {
                     var hash = new HashCode();
 
-                    foreach (var element in value.EnumerateArray())
+                    foreach (var item in element.EnumerateArray())
                     {
-                        hash.Add(GetHashCode(element));
+                        hash.Add(GetHashCodeFromJsonElement(item));
                     }
 
                     return hash.ToHashCode();
@@ -271,10 +421,10 @@ public readonly struct OpenIddictParameter : IEquatable<OpenIddictParameter>
                 {
                     var hash = new HashCode();
 
-                    foreach (var property in value.EnumerateObject())
+                    foreach (var property in element.EnumerateObject())
                     {
                         hash.Add(property.Name);
-                        hash.Add(GetHashCode(property.Value));
+                        hash.Add(GetHashCodeFromJsonElement(property.Value));
                     }
 
                     return hash.ToHashCode();
@@ -291,25 +441,7 @@ public readonly struct OpenIddictParameter : IEquatable<OpenIddictParameter>
     /// <param name="name">The name of the child item.</param>
     /// <returns>An <see cref="OpenIddictParameter"/> instance containing the item value.</returns>
     public OpenIddictParameter? GetNamedParameter(string name)
-    {
-        if (string.IsNullOrEmpty(name))
-        {
-            throw new ArgumentException(SR.GetResourceString(SR.ID0192), nameof(name));
-        }
-
-        if (Value is JsonElement { ValueKind: JsonValueKind.Object } element)
-        {
-            if (element.TryGetProperty(name, out JsonElement value))
-            {
-                return new OpenIddictParameter(value);
-            }
-
-            // If the item doesn't exist, return a null parameter.
-            return null;
-        }
-
-        return null;
-    }
+        => TryGetNamedParameter(name, out var value) ? value : (OpenIddictParameter?) null;
 
     /// <summary>
     /// Gets the child item corresponding to the specified index.
@@ -317,39 +449,7 @@ public readonly struct OpenIddictParameter : IEquatable<OpenIddictParameter>
     /// <param name="index">The index of the child item.</param>
     /// <returns>An <see cref="OpenIddictParameter"/> instance containing the item value.</returns>
     public OpenIddictParameter? GetUnnamedParameter(int index)
-    {
-        if (index < 0)
-        {
-            throw new ArgumentOutOfRangeException(nameof(index), SR.GetResourceString(SR.ID0193));
-        }
-
-        if (Value is string?[] array)
-        {
-            // If the specified index goes beyond the
-            // number of items in the array, return null.
-            if (index >= array.Length)
-            {
-                return null;
-            }
-
-            return new OpenIddictParameter(array[index]);
-        }
-
-        if (Value is JsonElement { ValueKind: JsonValueKind.Array } element)
-        {
-            // If the specified index goes beyond the
-            // number of items in the array, return null.
-            if (index >= element.GetArrayLength())
-            {
-                return null;
-            }
-
-            return new OpenIddictParameter(element[index]);
-        }
-
-        // If the value is not a JSON array, return null.
-        return null;
-    }
+        => TryGetUnnamedParameter(index, out var value) ? value : (OpenIddictParameter?) null;
 
     /// <summary>
     /// Gets the named child items associated with the current parameter, if it represents a JSON object.
@@ -358,19 +458,51 @@ public readonly struct OpenIddictParameter : IEquatable<OpenIddictParameter>
     /// <returns>A dictionary of all the parameters associated with the current instance.</returns>
     public IReadOnlyDictionary<string, OpenIddictParameter> GetNamedParameters()
     {
-        if (Value is JsonElement { ValueKind: JsonValueKind.Object } element)
+        return Value switch
+        {
+            // When the parameter is a JsonElement representing an object, return the requested item.
+            JsonElement { ValueKind: JsonValueKind.Object } value => GetParametersFromJsonElement(value),
+
+#if SUPPORTS_JSON_NODES
+            // When the parameter is a JsonObject, return the requested item.
+            JsonObject value => GetParametersFromJsonNode(value),
+
+            // When the parameter is a JsonNode (e.g a JsonValue wrapping a non-primitive type),
+            // serialize it to a JsonElement first to determine its actual JSON representation
+            // and apply the same logic as with non-wrapped JsonElement instances.
+            JsonNode value when JsonSerializer.SerializeToElement(value)
+                is JsonElement { ValueKind: JsonValueKind.Object } element
+                => GetParametersFromJsonElement(element),
+#endif
+            _ => ImmutableDictionary.Create<string, OpenIddictParameter>(StringComparer.Ordinal)
+        };
+
+        static IReadOnlyDictionary<string, OpenIddictParameter> GetParametersFromJsonElement(JsonElement element)
         {
             var parameters = new Dictionary<string, OpenIddictParameter>(StringComparer.Ordinal);
 
             foreach (var property in element.EnumerateObject())
             {
-                parameters[property.Name] = property.Value;
+                parameters[property.Name] = new(property.Value);
             }
 
             return parameters;
         }
 
-        return ImmutableDictionary.Create<string, OpenIddictParameter>(StringComparer.Ordinal);
+#if SUPPORTS_JSON_NODES
+
+        static IReadOnlyDictionary<string, OpenIddictParameter> GetParametersFromJsonNode(JsonObject node)
+        {
+            var parameters = new Dictionary<string, OpenIddictParameter>(node.Count, StringComparer.Ordinal);
+
+            foreach (var property in node)
+            {
+                parameters[property.Key] = new(property.Value);
+            }
+
+            return parameters;
+        }
+#endif
     }
 
     /// <summary>
@@ -380,31 +512,66 @@ public readonly struct OpenIddictParameter : IEquatable<OpenIddictParameter>
     /// <returns>An enumeration of all the unnamed parameters associated with the current instance.</returns>
     public IReadOnlyList<OpenIddictParameter> GetUnnamedParameters()
     {
-        if (Value is string?[] array)
+        return Value switch
         {
-            var parameters = new List<OpenIddictParameter>();
+            // When the parameter is an array of strings, return its items.
+            string?[] value => GetParametersFromArray(value),
+
+            // When the parameter is a JsonElement representing an array, return its children.
+            JsonElement { ValueKind: JsonValueKind.Array } value => GetParametersFromJsonElement(value),
+
+#if SUPPORTS_JSON_NODES
+            // When the parameter is a JsonArray, return its children.
+            JsonArray value => GetParametersFromJsonNode(value),
+
+            // When the parameter is a JsonNode (e.g a JsonValue wrapping a non-primitive type),
+            // serialize it to a JsonElement first to determine its actual JSON representation
+            // and apply the same logic as with non-wrapped JsonElement instances.
+            JsonNode value when JsonSerializer.SerializeToElement(value)
+                is JsonElement { ValueKind: JsonValueKind.Array } element
+                => GetParametersFromJsonElement(element),
+#endif
+            _ => ImmutableList.Create<OpenIddictParameter>()
+        };
+
+        static IReadOnlyList<OpenIddictParameter> GetParametersFromArray(string?[] array)
+        {
+            var parameters = new OpenIddictParameter[array.Length];
 
             for (var index = 0; index < array.Length; index++)
             {
-                parameters.Add(array[index]);
+                parameters[index] = new(array[index]);
             }
 
             return parameters;
         }
 
-        else if (Value is JsonElement { ValueKind: JsonValueKind.Array } element)
+        static IReadOnlyList<OpenIddictParameter> GetParametersFromJsonElement(JsonElement element)
         {
-            var parameters = new List<OpenIddictParameter>();
+            var length = element.GetArrayLength();
+            var parameters = new OpenIddictParameter[length];
 
-            foreach (var value in element.EnumerateArray())
+            for (var index = 0; index < length; index++)
             {
-                parameters.Add(value);
+                parameters[index] = new(element[index]);
             }
 
             return parameters;
         }
 
-        return ImmutableList.Create<OpenIddictParameter>();
+#if SUPPORTS_JSON_NODES
+        static IReadOnlyList<OpenIddictParameter> GetParametersFromJsonNode(JsonArray node)
+        {
+            var parameters = new OpenIddictParameter[node.Count];
+
+            for (var index = 0; index < node.Count; index++)
+            {
+                parameters[index] = new(node[index]);
+            }
+
+            return parameters;
+        }
+#endif
     }
 
     /// <summary>
@@ -423,7 +590,28 @@ public readonly struct OpenIddictParameter : IEquatable<OpenIddictParameter>
 
         JsonElement value => value.ToString(),
 
-        _ => throw new InvalidOperationException(SR.GetResourceString(SR.ID0194))
+#if SUPPORTS_JSON_NODES
+        JsonValue value when value.TryGetValue(out JsonElement element)
+            => element.ToString(),
+        
+        JsonValue value when value.TryGetValue(out bool result)
+            => result ? bool.TrueString : bool.FalseString,
+        
+        JsonValue value when value.TryGetValue(out int result)
+            => result.ToString(CultureInfo.InvariantCulture),
+
+        JsonValue value when value.TryGetValue(out long result)
+            => result.ToString(CultureInfo.InvariantCulture),
+
+        JsonValue value when value.TryGetValue(out string? result) => result,
+
+        JsonNode value => value.ToJsonString(new JsonSerializerOptions
+        {
+            Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
+            WriteIndented = false
+        }),
+#endif
+        _ => string.Empty
     };
 
     /// <summary>
@@ -439,17 +627,28 @@ public readonly struct OpenIddictParameter : IEquatable<OpenIddictParameter>
             throw new ArgumentException(SR.GetResourceString(SR.ID0192), nameof(name));
         }
 
-        if (Value is JsonElement { ValueKind: JsonValueKind.Object } element &&
-            element.TryGetProperty(name, out JsonElement property))
+        var result = Value switch
         {
-            value = new OpenIddictParameter(property);
-
-            return true;
-        }
-
-        value = default;
+            // When the parameter is a JsonElement representing an array, return the requested item.
+            JsonElement { ValueKind: JsonValueKind.Object } element =>
+                element.TryGetProperty(name, out JsonElement property) ? new(property) : null,
+
+#if SUPPORTS_JSON_NODES
+            // When the parameter is a JsonObject, return the requested item.
+            JsonObject node => node.TryGetPropertyValue(name, out JsonNode? property) ? new(property) : null,
+
+            // When the parameter is a JsonNode (e.g a JsonValue wrapping a non-primitive type),
+            // serialize it to a JsonElement first to determine its actual JSON representation
+            // and apply the same logic as with non-wrapped JsonElement instances.
+            JsonNode node when JsonSerializer.SerializeToElement(node)
+                is JsonElement { ValueKind: JsonValueKind.Object } element
+                => element.TryGetProperty(name, out JsonElement property) ? new(property) : null,
+#endif
+            _ => (OpenIddictParameter?) null
+        };
 
-        return false;
+        value = result.GetValueOrDefault();
+        return result.HasValue;
     }
 
     /// <summary>
@@ -465,37 +664,31 @@ public readonly struct OpenIddictParameter : IEquatable<OpenIddictParameter>
             throw new ArgumentOutOfRangeException(nameof(index), SR.GetResourceString(SR.ID0193));
         }
 
-        if (Value is string?[] array)
+        var result = Value switch
         {
-            if (index >= array.Length)
-            {
-                value = default;
-
-                return false;
-            }
-
-            value = new OpenIddictParameter(array[index]);
-
-            return true;
-        }
-
-        if (Value is JsonElement { ValueKind: JsonValueKind.Array } element)
-        {
-            if (index >= element.GetArrayLength())
-            {
-                value = default;
-
-                return false;
-            }
-
-            value = new OpenIddictParameter(element[index]);
-
-            return true;
-        }
-
-        value = default;
+            // When the parameter is an array of strings, return the requested item.
+            string?[] array => index < array.Length ? new(array[index]) : null,
+
+            // When the parameter is a JsonElement representing an array, return the requested item.
+            JsonElement { ValueKind: JsonValueKind.Array } element =>
+                index < element.GetArrayLength() ? new(element[index]) : null,
+
+#if SUPPORTS_JSON_NODES
+            // When the parameter is a JsonArray, return the requested item.
+            JsonArray node => index < node.Count ? new(node[index]) : null,
+
+            // When the parameter is a JsonNode (e.g a JsonValue wrapping a non-primitive type),
+            // serialize it to a JsonElement first to determine its actual JSON representation
+            // and apply the same logic as with non-wrapped JsonElement instances.
+            JsonNode node when JsonSerializer.SerializeToElement(node)
+                is JsonElement { ValueKind: JsonValueKind.Array } element
+                => index < element.GetArrayLength() ? new(element) : null,
+#endif
+            _ => (OpenIddictParameter?) null
+        };
 
-        return false;
+        value = result.GetValueOrDefault();
+        return result.HasValue;
     }
 
     /// <summary>
@@ -539,7 +732,15 @@ public readonly struct OpenIddictParameter : IEquatable<OpenIddictParameter>
                 value.WriteTo(writer);
                 break;
 
-            default: throw new InvalidOperationException(SR.GetResourceString(SR.ID0194));
+#if SUPPORTS_JSON_NODES
+            case JsonNode value:
+                value.WriteTo(writer, new JsonSerializerOptions
+                {
+                    Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
+                    WriteIndented = false
+                });
+                break;
+#endif
         }
     }
 
@@ -572,28 +773,56 @@ public readonly struct OpenIddictParameter : IEquatable<OpenIddictParameter>
     /// </summary>
     /// <param name="parameter">The parameter to convert.</param>
     /// <returns>The converted value.</returns>
-    public static explicit operator bool?(OpenIddictParameter? parameter) => parameter?.Value switch
+    public static explicit operator bool?(OpenIddictParameter? parameter)
     {
-        // When the parameter is a null value or a JsonElement representing null, return null.
-        null or JsonElement { ValueKind: JsonValueKind.Null or JsonValueKind.Undefined } => null,
+        return parameter?.Value switch
+        {
+            // When the parameter is a null value or a JsonElement representing null, return null.
+            null or JsonElement { ValueKind: JsonValueKind.Null or JsonValueKind.Undefined } => null,
 
-        // When the parameter is a boolean value, return it as-is.
-        bool value => value,
+            // When the parameter is a boolean value, return it as-is.
+            bool value => value,
 
-        // When the parameter is a string value, try to parse it.
-        string value => bool.TryParse(value, out var result) ? (bool?) result : null,
+            // When the parameter is a string value, try to parse it.
+            string value => bool.TryParse(value, out var result) ? result : null,
 
-        // When the parameter is a JsonElement representing a boolean, return it as-is.
-        JsonElement { ValueKind: JsonValueKind.False } => false,
-        JsonElement { ValueKind: JsonValueKind.True  } => true,
+            // When the parameter is a JsonElement, try to convert it if it's of a supported type.
+            JsonElement value => ConvertFromJsonElement(value),
 
-        // When the parameter is a JsonElement representing a string, try to parse it.
-        JsonElement { ValueKind: JsonValueKind.String } value
-            => bool.TryParse(value.GetString(), out var result) ? (bool?) result : null,
+#if SUPPORTS_JSON_NODES
+            // When the parameter is a JsonValue wrapping a JsonElement,
+            // apply the same logic as with direct JsonElement instances.
+            JsonValue value when value.TryGetValue(out JsonElement element) => ConvertFromJsonElement(element),
 
-        // If the parameter is of a different type, return null to indicate the conversion failed.
-        _ => null
-    };
+            // When the parameter is a JsonValue wrapping a boolean, return it as-is.
+            JsonValue value when value.TryGetValue(out bool result) => result,
+
+            // When the parameter is a JsonValue wrapping a string, try to parse it.
+            JsonValue value when value.TryGetValue(out string? text) =>
+                bool.TryParse(text, out var result) ? result : null,
+
+            // When the parameter is a JsonNode (e.g a JsonValue wrapping a non-primitive type),
+            // serialize it to a JsonElement first to determine its actual JSON representation
+            // and apply the same logic as with non-wrapped JsonElement instances.
+            JsonNode value when JsonSerializer.SerializeToElement(value) is JsonElement element
+                => ConvertFromJsonElement(element),
+#endif
+            // If the parameter is of a different type, return null to indicate the conversion failed.
+            _ => null
+        };
+
+        static bool? ConvertFromJsonElement(JsonElement element) => element.ValueKind switch
+        {
+            // When the parameter is a JsonElement representing a boolean, return it as-is.
+            JsonValueKind.True  => true,
+            JsonValueKind.False => false,
+
+            // When the parameter is a JsonElement representing a string, try to parse it.
+            JsonValueKind.String => bool.TryParse(element.GetString(), out var result) ? result : null,
+
+            _ => null
+        };
+    }
 
     /// <summary>
     /// Converts an <see cref="OpenIddictParameter"/> instance to a <see cref="JsonElement"/>.
@@ -604,20 +833,32 @@ public readonly struct OpenIddictParameter : IEquatable<OpenIddictParameter>
     {
         return parameter?.Value switch
         {
-            // When the parameter is a null value, return default.
+            // When the parameter is a null value, return an undefined JsonElement.
             null => default,
 
             // When the parameter is already a JsonElement, return it as-is.
             JsonElement value => value,
 
+#if SUPPORTS_JSON_NODES
+            // When the parameter is JsonNode, serialize it as a JsonElement.
+            JsonNode value => JsonSerializer.SerializeToElement(value),
+#endif
             // When the parameter is a string starting with '{' or '[' (which would correspond
             // to a JSON object or array), try to deserialize it to get a JsonElement instance.
             string { Length: > 0 } value when value[0] is '{' or '[' =>
                 DeserializeElement(value) ??
-                DeserializeElement(SerializeObject(value)) ?? default,
+                DeserializeElement(JsonSerializer.Serialize(value)) ?? default,
 
             // Otherwise, serialize it to get a JsonElement instance.
-            var value => DeserializeElement(SerializeObject(value)) ?? default
+#if SUPPORTS_DIRECT_JSON_ELEMENT_SERIALIZATION
+            object value => JsonSerializer.SerializeToElement(value, value.GetType(), new JsonSerializerOptions
+            {
+                Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
+                WriteIndented = false
+            })
+#else
+            object value => DeserializeElement(JsonSerializer.Serialize(value)) ?? default
+#endif
         };
 
         static JsonElement? DeserializeElement(string value)
@@ -633,50 +874,98 @@ public readonly struct OpenIddictParameter : IEquatable<OpenIddictParameter>
                 return null;
             }
         }
+    }
 
-        static string SerializeObject(object instance)
+#if SUPPORTS_JSON_NODES
+    /// <summary>
+    /// Converts an <see cref="OpenIddictParameter"/> instance to a <see cref="JsonNode"/>.
+    /// </summary>
+    /// <param name="parameter">The parameter to convert.</param>
+    /// <returns>The converted value.</returns>
+    public static explicit operator JsonNode?(OpenIddictParameter? parameter)
+    {
+        return parameter?.Value switch
         {
-            using var stream = new MemoryStream();
-            using var writer = new Utf8JsonWriter(stream, new JsonWriterOptions
-            {
-                Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
-                Indented = false
-            });
+            // When the parameter is a null value or a JsonElement representing null, return null.
+            null or JsonElement { ValueKind: JsonValueKind.Null or JsonValueKind.Undefined } => null,
 
-            switch (instance)
-            {
-                case bool value:
-                    writer.WriteBooleanValue(value);
-                    break;
+            // When the parameter is already a JsonNode, return it as-is.
+            JsonNode value => value,
 
-                case long value:
-                    writer.WriteNumberValue(value);
-                    break;
+            // When the parameter is a boolean, return a JsonValue.
+            bool value => JsonValue.Create(value),
 
-                case string value:
-                    writer.WriteStringValue(value);
-                    break;
+            // When the parameter is an integer, return a JsonValue.
+            long value => JsonValue.Create(value),
 
-                case string?[] value:
-                    writer.WriteStartArray();
+            // When the parameter is a string starting with '{' or '[' (which would correspond
+            // to a JSON object or array), try to deserialize it to get a JsonNode instance.
+            string { Length: > 0 } value when value[0] is '{' or '[' => DeserializeNode(value),
 
-                    for (var index = 0; index < value.Length; index++)
-                    {
-                        writer.WriteStringValue(value[index]);
-                    }
+            // When the parameter is a string, return a JsonValue.
+            string value => JsonValue.Create(value),
+
+            // When the parameter is an array of strings, return a JsonArray.
+            string?[] value => CreateArray(value),
+
+            // When the parameter is JsonElement, deserialize it as a JsonNode.
+            JsonElement value => JsonSerializer.Deserialize<JsonNode>(value),
 
-                    writer.WriteEndArray();
-                    break;
+            // If the parameter is of a different type, return null to indicate the conversion failed.
+            _ => null
+        };
+
+        static JsonNode? DeserializeNode(string value)
+        {
+            try
+            {
+                return JsonNode.Parse(value);
+            }
 
-                default: throw new InvalidOperationException(SR.GetResourceString(SR.ID0194));
+            catch (JsonException)
+            {
+                return null;
             }
+        }
 
-            writer.Flush();
+        static JsonArray? CreateArray(string?[] values)
+        {
+            var array = new JsonArray();
 
-            return Encoding.UTF8.GetString(stream.ToArray());
+            for (var index = 0; index < values.Length; index++)
+            {
+                array.Add(values[index]);
+            }
+
+            return array;
         }
     }
 
+    /// <summary>
+    /// Converts an <see cref="OpenIddictParameter"/> instance to a <see cref="JsonArray"/>.
+    /// </summary>
+    /// <param name="parameter">The parameter to convert.</param>
+    /// <returns>The converted value.</returns>
+    public static explicit operator JsonArray?(OpenIddictParameter? parameter)
+        => ((JsonNode?) parameter) as JsonArray;
+
+    /// <summary>
+    /// Converts an <see cref="OpenIddictParameter"/> instance to a <see cref="JsonObject"/>.
+    /// </summary>
+    /// <param name="parameter">The parameter to convert.</param>
+    /// <returns>The converted value.</returns>
+    public static explicit operator JsonObject?(OpenIddictParameter? parameter)
+        => ((JsonNode?) parameter) as JsonObject;
+
+    /// <summary>
+    /// Converts an <see cref="OpenIddictParameter"/> instance to a <see cref="JsonValue"/>.
+    /// </summary>
+    /// <param name="parameter">The parameter to convert.</param>
+    /// <returns>The converted value.</returns>
+    public static explicit operator JsonValue?(OpenIddictParameter? parameter)
+        => ((JsonNode?) parameter) as JsonValue;
+#endif
+
     /// <summary>
     /// Converts an <see cref="OpenIddictParameter"/> instance to a long integer.
     /// </summary>
@@ -690,63 +979,120 @@ public readonly struct OpenIddictParameter : IEquatable<OpenIddictParameter>
     /// </summary>
     /// <param name="parameter">The parameter to convert.</param>
     /// <returns>The converted value.</returns>
-    public static explicit operator long?(OpenIddictParameter? parameter) => parameter?.Value switch
+    public static explicit operator long?(OpenIddictParameter? parameter)
     {
-        // When the parameter is a null value or a JsonElement representing null, return null.
-        null or JsonElement { ValueKind: JsonValueKind.Null or JsonValueKind.Undefined } => null,
+        return parameter?.Value switch
+        {
+            // When the parameter is a null value or a JsonElement representing null, return null.
+            null or JsonElement { ValueKind: JsonValueKind.Null or JsonValueKind.Undefined } => null,
 
-        // When the parameter is an integer, return it as-is.
-        long value => value,
+            // When the parameter is an integer, return it as-is.
+            long value => value,
 
-        // When the parameter is a string value, try to parse it.
-        string value
-            => long.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) ? (long?) result : null,
+            // When the parameter is a string value, try to parse it.
+            string value => long.TryParse(value, NumberStyles.Integer,
+                CultureInfo.InvariantCulture, out var result) ? result : null,
 
-        // When the parameter is a JsonElement representing a number, return it as-is.
-        JsonElement { ValueKind: JsonValueKind.Number } value
-            => value.TryGetInt64(out var result) ? (long?) result : null,
+            // When the parameter is a JsonElement, try to convert it if it's of a supported type.
+            JsonElement value => ConvertFromJsonElement(value),
 
-        // When the parameter is a JsonElement representing a string, try to parse it.
-        JsonElement { ValueKind: JsonValueKind.String } value
-            => long.TryParse(value.GetString(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) ? (long?) result : null,
+#if SUPPORTS_JSON_NODES
+            // When the parameter is a JsonValue wrapping a JsonElement,
+            // apply the same logic as with direct JsonElement instances.
+            JsonValue value when value.TryGetValue(out JsonElement element) => ConvertFromJsonElement(element),
 
-        // If the parameter is of a different type, return null to indicate the conversion failed.
-        _ => null
-    };
+            // When the parameter is a JsonValue wrapping an integer, return it as-is.
+            JsonValue value when value.TryGetValue(out int  result) => result,
+            JsonValue value when value.TryGetValue(out long result) => result,
+
+            // When the parameter is a JsonValue wrapping a string, return it as-is.
+            JsonValue value when value.TryGetValue(out string? text) =>
+                long.TryParse(text, NumberStyles.Integer,
+                    CultureInfo.InvariantCulture, out var result) ? result : null,
+
+            // When the parameter is a JsonNode (e.g a JsonValue wrapping a non-primitive type),
+            // serialize it to a JsonElement first to determine its actual JSON representation
+            // and apply the same logic as with non-wrapped JsonElement instances.
+            JsonNode value when JsonSerializer.SerializeToElement(value) is JsonElement element
+                => ConvertFromJsonElement(element),
+#endif
+            // If the parameter is of a different type, return null to indicate the conversion failed.
+            _ => null
+        };
+
+        static long? ConvertFromJsonElement(JsonElement element) => element.ValueKind switch
+        {
+            // When the parameter is a JsonElement representing a number, return it as-is.
+            JsonValueKind.Number => element.TryGetInt64(out var result) ? result : null,
+
+            // When the parameter is a JsonElement representing a string, try to parse it.
+            JsonValueKind.String => long.TryParse(element.GetString(), NumberStyles.Integer,
+                CultureInfo.InvariantCulture, out var result) ? result : null,
+
+            _ => null
+        };
+    }
 
     /// <summary>
     /// Converts an <see cref="OpenIddictParameter"/> instance to a string.
     /// </summary>
     /// <param name="parameter">The parameter to convert.</param>
     /// <returns>The converted value.</returns>
-    public static explicit operator string?(OpenIddictParameter? parameter) => parameter?.Value switch
+    public static explicit operator string?(OpenIddictParameter? parameter)
     {
-        // When the parameter is a null value or a JsonElement representing null, return null.
-        null or JsonElement { ValueKind: JsonValueKind.Null or JsonValueKind.Undefined } => null,
+        return parameter?.Value switch
+        {
+            // When the parameter is a null value or a JsonElement representing null, return null.
+            null or JsonElement { ValueKind: JsonValueKind.Null or JsonValueKind.Undefined } => null,
 
-        // When the parameter is a string value, return it as-is.
-        string value => value,
+            // When the parameter is a string value, return it as-is.
+            string value => value,
 
-        // When the parameter is a boolean value, use its string representation.
-        bool value => value.ToString(),
+            // When the parameter is a boolean value, use its string representation.
+            bool value => value ? bool.TrueString : bool.FalseString,
 
-        // When the parameter is an integer, use its string representation.
-        long value => value.ToString(CultureInfo.InvariantCulture),
+            // When the parameter is an integer, use its string representation.
+            long value => value.ToString(CultureInfo.InvariantCulture),
 
-        // When the parameter is a JsonElement representing a string, return it as-is.
-        JsonElement { ValueKind: JsonValueKind.String } value => value.GetString(),
+            // When the parameter is a JsonElement, try to convert it if it's of a supported type.
+            JsonElement value => ConvertFromJsonElement(value),
 
-        // When the parameter is a JsonElement representing a number, return its representation.
-        JsonElement { ValueKind: JsonValueKind.Number } value
-            => value.GetInt64().ToString(CultureInfo.InvariantCulture),
+#if SUPPORTS_JSON_NODES
+            // When the parameter is a JsonValue wrapping a JsonElement,
+            // apply the same logic as with direct JsonElement instances.
+            JsonValue value when value.TryGetValue(out JsonElement element) => ConvertFromJsonElement(element),
 
-        // When the parameter is a JsonElement representing a boolean, return its representation.
-        JsonElement { ValueKind: JsonValueKind.False } => bool.FalseString,
-        JsonElement { ValueKind: JsonValueKind.True  } => bool.TrueString,
+            // When the parameter is a JsonValue wrapping a string, return it as-is.
+            JsonValue value when value.TryGetValue(out string? result) => result,
 
-        // If the parameter is of a different type, return null to indicate the conversion failed.
-        _ => null
-    };
+            // When the parameter is a JsonValue wrapping a boolean, return its representation.
+            JsonValue value when value.TryGetValue(out bool result) => result ? bool.TrueString : bool.FalseString,
+
+            // When the parameter is a JsonValue wrapping a boolean, return its representation.
+            JsonValue value when value.TryGetValue(out int result)  => result.ToString(CultureInfo.InvariantCulture),
+            JsonValue value when value.TryGetValue(out long result) => result.ToString(CultureInfo.InvariantCulture),
+
+            // When the parameter is a JsonNode (e.g a JsonValue wrapping a non-primitive type),
+            // serialize it to a JsonElement first to determine its actual JSON representation
+            // and apply the same logic as with non-wrapped JsonElement instances.
+            JsonNode value when JsonSerializer.SerializeToElement(value) is JsonElement element
+                => ConvertFromJsonElement(element),
+#endif
+            // If the parameter is of a different type, return null to indicate the conversion failed.
+            _ => null
+        };
+
+        static string? ConvertFromJsonElement(JsonElement element) => element.ValueKind switch
+        {
+            // When the parameter is a JsonElement representing a string,
+            // a number or a boolean, return its string representation.
+            JsonValueKind.String or JsonValueKind.Number or
+            JsonValueKind.True   or JsonValueKind.False
+                => element.ToString()!,
+
+            _ => null
+        };
+    }
 
     /// <summary>
     /// Converts an <see cref="OpenIddictParameter"/> instance to an array of strings.
@@ -767,43 +1113,72 @@ public readonly struct OpenIddictParameter : IEquatable<OpenIddictParameter>
             string value => new string?[] { value },
 
             // When the parameter is a boolean value, return an array with its string representation.
-            bool value => new string?[] { value.ToString() },
+            bool value => new string?[] { value ? bool.TrueString : bool.FalseString },
 
             // When the parameter is an integer, return an array with its string representation.
             long value => new string?[] { value.ToString(CultureInfo.InvariantCulture) },
 
-            // When the parameter is a JsonElement representing a string, return an array with a single entry.
-            JsonElement { ValueKind: JsonValueKind.String } value => new string?[] { value.GetString() },
+            // When the parameter is a JsonElement, try to convert it if it's of a supported type.
+            JsonElement value => ConvertFromJsonElement(value),
+
+#if SUPPORTS_JSON_NODES
+            // When the parameter is a JsonValue wrapping a JsonElement,
+            // apply the same logic as with direct JsonElement instances.
+            JsonValue value when value.TryGetValue(out JsonElement element) => ConvertFromJsonElement(element),
+
+            // When the parameter is a JsonValue wrapping a string, return an array with a single entry.
+            JsonValue value when value.TryGetValue(out string? result) => new string?[] { result },
 
-            // When the parameter is a JsonElement representing a number, return an array with a single entry.
-            JsonElement { ValueKind: JsonValueKind.Number } value
-                => new string?[] { value.GetInt64().ToString(CultureInfo.InvariantCulture) },
+            // When the parameter is a JsonValue wrapping a boolean, return an array with its string representation.
+            JsonValue value when value.TryGetValue(out bool result)
+                => new string?[] { result ? bool.TrueString : bool.FalseString },
 
-            // When the parameter is a JsonElement representing a boolean, return an array with a single entry.
-            JsonElement { ValueKind: JsonValueKind.False } => new string?[] { bool.FalseString },
-            JsonElement { ValueKind: JsonValueKind.True  } => new string?[] { bool.TrueString  },
+            // When the parameter is a JsonValue wrapping an integer, return an array with its string representation.
+            JsonValue value when value.TryGetValue(out int result)
+                => new string?[] { result.ToString(CultureInfo.InvariantCulture) },
 
-            // When the parameter is a JsonElement representing an array of strings, return it.
-            JsonElement { ValueKind: JsonValueKind.Array } value => CreateArray(value),
+            JsonValue value when value.TryGetValue(out long result)
+                => new string?[] { result.ToString(CultureInfo.InvariantCulture) },
 
+            // When the parameter is a JsonNode (e.g a JsonValue wrapping a non-primitive type),
+            // serialize it to a JsonElement first to determine its actual JSON representation
+            // and apply the same logic as with non-wrapped JsonElement instances.
+            JsonNode value when JsonSerializer.SerializeToElement(value) is JsonElement element
+                => ConvertFromJsonElement(element),
+#endif
             // If the parameter is of a different type, return null to indicate the conversion failed.
             _ => null
         };
 
-        static string?[]? CreateArray(JsonElement value)
+        static string?[]? ConvertFromJsonElement(JsonElement element) => element.ValueKind switch
         {
-            var array = new string?[value.GetArrayLength()];
-            using var enumerator = value.EnumerateArray();
+            // When the parameter is a JsonElement representing a string, a number
+            // or a boolean, return an 1-item array with its string representation.
+            JsonValueKind.String or JsonValueKind.Number or
+            JsonValueKind.True   or JsonValueKind.False
+                => new string?[] { element.ToString()! },
 
-            for (var index = 0; enumerator.MoveNext(); index++)
+            // When the parameter is a JsonElement representing an array, return the elements as strings.
+            JsonValueKind.Array => CreateArrayFromJsonElement(element),
+
+            _ => null
+        };
+
+        static string?[]? CreateArrayFromJsonElement(JsonElement element)
+        {
+            var length = element.GetArrayLength();
+            var array = new string?[length];
+
+            for (var index = 0; index < length; index++)
             {
-                var element = enumerator.Current;
-                if (element.ValueKind is not JsonValueKind.String)
+                // Always return a null array if one of the items is a not string, a number or a boolean.
+                if (element[index] is not { ValueKind: JsonValueKind.String or JsonValueKind.Number or
+                                                       JsonValueKind.True   or JsonValueKind.False } item)
                 {
                     return null;
                 }
 
-                array[index] = element.GetString();
+                array[index] = item.ToString();
             }
 
             return array;
@@ -831,6 +1206,15 @@ public readonly struct OpenIddictParameter : IEquatable<OpenIddictParameter>
     /// <returns>An <see cref="OpenIddictParameter"/> instance.</returns>
     public static implicit operator OpenIddictParameter(JsonElement value) => new(value);
 
+#if SUPPORTS_JSON_NODES
+    /// <summary>
+    /// Converts a <see cref="JsonNode"/> to an <see cref="OpenIddictParameter"/> instance.
+    /// </summary>
+    /// <param name="value">The value to convert</param>
+    /// <returns>An <see cref="OpenIddictParameter"/> instance.</returns>
+    public static implicit operator OpenIddictParameter(JsonNode? value) => new(value);
+#endif
+
     /// <summary>
     /// Converts a long integer to an <see cref="OpenIddictParameter"/> instance.
     /// </summary>
@@ -870,20 +1254,45 @@ public readonly struct OpenIddictParameter : IEquatable<OpenIddictParameter>
         {
             null or JsonElement { ValueKind: JsonValueKind.Null or JsonValueKind.Undefined } => true,
 
-            string value    => string.IsNullOrEmpty(value),
-            string?[] value => value.Length == 0,
+            string value    => value.Length is 0,
+            string?[] value => value.Length is 0,
+
+            JsonElement value => IsEmptyJsonElement(value),
+
+#if SUPPORTS_JSON_NODES
+            JsonArray  value => value.Count is 0,
+            JsonObject value => value.Count is 0,
 
-            JsonElement { ValueKind: JsonValueKind.String } value => string.IsNullOrEmpty(value.GetString()),
-            JsonElement { ValueKind: JsonValueKind.Array  } value => value.GetArrayLength() == 0,
-            JsonElement { ValueKind: JsonValueKind.Object } value => IsEmptyNode(value),
+            JsonValue value when value.TryGetValue(out JsonElement element)
+                => IsEmptyJsonElement(element),
 
+            JsonValue value when value.TryGetValue(out string? result)
+                => string.IsNullOrEmpty(result),
+
+            JsonNode value when JsonSerializer.SerializeToElement(value) is JsonElement element
+                => IsEmptyJsonElement(element),
+#endif
             _ => false
         };
 
-        static bool IsEmptyNode(JsonElement value)
+        static bool IsEmptyJsonElement(JsonElement element)
         {
-            using var enumerator = value.EnumerateObject();
-            return !enumerator.MoveNext();
+            switch (element.ValueKind)
+            {
+                case JsonValueKind.String:
+                    return string.IsNullOrEmpty(element.GetString());
+
+                case JsonValueKind.Array:
+                    return element.GetArrayLength() is 0;
+
+                case JsonValueKind.Object:
+                    using (var enumerator = element.EnumerateObject())
+                    {
+                        return !enumerator.MoveNext();
+                    }
+
+                default: return false;
+            }
         }
     }
 }
diff --git a/src/OpenIddict.Abstractions/Primitives/OpenIddictRequest.cs b/src/OpenIddict.Abstractions/Primitives/OpenIddictRequest.cs
index ae9e5a18..5915b7c5 100644
--- a/src/OpenIddict.Abstractions/Primitives/OpenIddictRequest.cs
+++ b/src/OpenIddict.Abstractions/Primitives/OpenIddictRequest.cs
@@ -9,6 +9,10 @@ using System.Text.Json;
 using System.Text.Json.Serialization;
 using Microsoft.Extensions.Primitives;
 
+#if SUPPORTS_JSON_NODES
+using System.Text.Json.Nodes;
+#endif
+
 namespace OpenIddict.Abstractions;
 
 /// <summary>
@@ -41,6 +45,18 @@ public class OpenIddictRequest : OpenIddictMessage
     {
     }
 
+#if SUPPORTS_JSON_NODES
+    /// <summary>
+    /// Initializes a new OpenIddict request.
+    /// </summary>
+    /// <param name="parameters">The request parameters.</param>
+    /// <remarks>Parameters with a null or empty key are always ignored.</remarks>
+    public OpenIddictRequest(JsonObject parameters)
+        : base(parameters)
+    {
+    }
+#endif
+
     /// <summary>
     /// Initializes a new OpenIddict request.
     /// </summary>
diff --git a/src/OpenIddict.Abstractions/Primitives/OpenIddictResponse.cs b/src/OpenIddict.Abstractions/Primitives/OpenIddictResponse.cs
index 1631781f..f21098ef 100644
--- a/src/OpenIddict.Abstractions/Primitives/OpenIddictResponse.cs
+++ b/src/OpenIddict.Abstractions/Primitives/OpenIddictResponse.cs
@@ -9,6 +9,10 @@ using System.Text.Json;
 using System.Text.Json.Serialization;
 using Microsoft.Extensions.Primitives;
 
+#if SUPPORTS_JSON_NODES
+using System.Text.Json.Nodes;
+#endif
+
 namespace OpenIddict.Abstractions;
 
 /// <summary>
@@ -41,6 +45,18 @@ public class OpenIddictResponse : OpenIddictMessage
     {
     }
 
+#if SUPPORTS_JSON_NODES
+    /// <summary>
+    /// Initializes a new OpenIddict response.
+    /// </summary>
+    /// <param name="parameters">The response parameters.</param>
+    /// <remarks>Parameters with a null or empty key are always ignored.</remarks>
+    public OpenIddictResponse(JsonObject parameters)
+        : base(parameters)
+    {
+    }
+#endif
+
     /// <summary>
     /// Initializes a new OpenIddict response.
     /// </summary>
diff --git a/src/OpenIddict.Client.AspNetCore/OpenIddictClientAspNetCoreHandlers.cs b/src/OpenIddict.Client.AspNetCore/OpenIddictClientAspNetCoreHandlers.cs
index d299d4eb..1654aa76 100644
--- a/src/OpenIddict.Client.AspNetCore/OpenIddictClientAspNetCoreHandlers.cs
+++ b/src/OpenIddict.Client.AspNetCore/OpenIddictClientAspNetCoreHandlers.cs
@@ -17,6 +17,10 @@ using Microsoft.Extensions.Options;
 using Microsoft.Net.Http.Headers;
 using Properties = OpenIddict.Client.AspNetCore.OpenIddictClientAspNetCoreConstants.Properties;
 
+#if SUPPORTS_JSON_NODES
+using System.Text.Json.Nodes;
+#endif
+
 namespace OpenIddict.Client.AspNetCore;
 
 [EditorBrowsable(EditorBrowsableState.Never)]
@@ -447,6 +451,9 @@ public static partial class OpenIddictClientAspNetCoreHandlers
                     string              value => new OpenIddictParameter(value),
                     string[]            value => new OpenIddictParameter(value),
 
+#if SUPPORTS_JSON_NODES
+                    JsonNode            value => new OpenIddictParameter(value),
+#endif
                     _ => throw new InvalidOperationException(SR.GetResourceString(SR.ID0115))
                 };
             }
diff --git a/src/OpenIddict.Client/OpenIddictClientHandlers.Exchange.cs b/src/OpenIddict.Client/OpenIddictClientHandlers.Exchange.cs
index 50dd2c9c..dddceb7d 100644
--- a/src/OpenIddict.Client/OpenIddictClientHandlers.Exchange.cs
+++ b/src/OpenIddict.Client/OpenIddictClientHandlers.Exchange.cs
@@ -40,7 +40,7 @@ public static partial class OpenIddictClientHandlers
             {
                 foreach (var parameter in context.Response.GetParameters())
                 {
-                    if (ValidateParameterType(parameter.Key, parameter.Value.Value))
+                    if (ValidateParameterType(parameter.Key, parameter.Value))
                     {
                         continue;
                     }
@@ -55,14 +55,21 @@ public static partial class OpenIddictClientHandlers
 
                 return default;
 
-                static bool ValidateParameterType(string name, object? value) => name switch
+                // Note: in the typical case, the response parameters should be deserialized from a
+                // JSON response and thus natively stored as System.Text.Json.JsonElement instances.
+                //
+                // In the rare cases where the underlying value wouldn't be a JsonElement instance
+                // (e.g when custom parameters are manually added to the response), the static
+                // conversion operator would take care of converting the underlying value to a
+                // JsonElement instance using the same value type as the original parameter value.
+                static bool ValidateParameterType(string name, OpenIddictParameter value) => name switch
                 {
-                    // The 'expires_in' parameter MUST be formatted as a numeric date value.
-                    Parameters.ExpiresIn => value is long or JsonElement { ValueKind: JsonValueKind.Number },
-
                     // The 'access_token', 'id_token' and 'refresh_token' parameters MUST be formatted as unique strings.
                     Parameters.AccessToken or Parameters.IdToken or Parameters.RefreshToken
-                        => value is string or JsonElement { ValueKind: JsonValueKind.String },
+                        => ((JsonElement) value).ValueKind is JsonValueKind.String,
+
+                    // The 'expires_in' parameter MUST be formatted as a numeric date value.
+                    Parameters.ExpiresIn => ((JsonElement) value).ValueKind is JsonValueKind.Number,
 
                     // Parameters that are not in the well-known list can be of any type.
                     _ => true
diff --git a/src/OpenIddict.Client/OpenIddictClientHandlers.Userinfo.cs b/src/OpenIddict.Client/OpenIddictClientHandlers.Userinfo.cs
index bf535d97..19f8e9cc 100644
--- a/src/OpenIddict.Client/OpenIddictClientHandlers.Userinfo.cs
+++ b/src/OpenIddict.Client/OpenIddictClientHandlers.Userinfo.cs
@@ -5,7 +5,6 @@
  */
 
 using System.Collections.Immutable;
-using System.Globalization;
 using System.Security.Claims;
 using System.Text.Json;
 using Microsoft.IdentityModel.JsonWebTokens;
@@ -50,7 +49,7 @@ public static partial class OpenIddictClientHandlers
 
                 foreach (var parameter in context.Response.GetParameters())
                 {
-                    if (ValidateClaimType(parameter.Key, parameter.Value.Value))
+                    if (ValidateClaimType(parameter.Key, parameter.Value))
                     {
                         continue;
                     }
@@ -65,10 +64,17 @@ public static partial class OpenIddictClientHandlers
 
                 return default;
 
-                static bool ValidateClaimType(string name, object? value) => name switch
+                // Note: in the typical case, the response parameters should be deserialized from a
+                // JSON response and thus natively stored as System.Text.Json.JsonElement instances.
+                //
+                // In the rare cases where the underlying value wouldn't be a JsonElement instance
+                // (e.g when custom parameters are manually added to the response), the static
+                // conversion operator would take care of converting the underlying value to a
+                // JsonElement instance using the same value type as the original parameter value.
+                static bool ValidateClaimType(string name, OpenIddictParameter value) => name switch
                 {
-                    // The 'sub' parameter MUST be formatted as a string value.
-                    Claims.Subject => value is string or JsonElement { ValueKind: JsonValueKind.String },
+                    // The 'sub' parameter MUST be formatted as a unique string value.
+                    Claims.Subject => ((JsonElement) value).ValueKind is JsonValueKind.String,
 
                     // Parameters that are not in the well-known list can be of any type.
                     _ => true
@@ -123,8 +129,8 @@ public static partial class OpenIddictClientHandlers
 
                 foreach (var parameter in context.Response.GetParameters())
                 {
-                    // Always exclude null keys and values, as they can't be represented as valid claims.
-                    if (string.IsNullOrEmpty(parameter.Key) || OpenIddictParameter.IsNullOrEmpty(parameter.Value))
+                    // Always exclude null keys as they can't be represented as valid claims.
+                    if (string.IsNullOrEmpty(parameter.Key))
                     {
                         continue;
                     }
@@ -142,53 +148,40 @@ public static partial class OpenIddictClientHandlers
                         continue;
                     }
 
-                    switch (parameter.Value.Value)
+                    // Note: in the typical case, the response parameters should be deserialized from a
+                    // JSON response and thus natively stored as System.Text.Json.JsonElement instances.
+                    //
+                    // In the rare cases where the underlying value wouldn't be a JsonElement instance
+                    // (e.g when custom parameters are manually added to the response), the static
+                    // conversion operator would take care of converting the underlying value to a
+                    // JsonElement instance using the same value type as the original parameter value.
+                    switch ((JsonElement) parameter.Value)
                     {
-                        // Claims represented as arrays are split and mapped to multiple CLR claims.
-                        case JsonElement { ValueKind: JsonValueKind.Array } value:
-                            foreach (var element in value.EnumerateArray())
+                        // Top-level claims represented as arrays are split and mapped to multiple CLR claims
+                        // to match the logic implemented by IdentityModel for JWT token deserialization.
+                        case { ValueKind: JsonValueKind.Array } value:
+                            foreach (var item in value.EnumerateArray())
                             {
-                                var item = element.GetString();
-                                if (string.IsNullOrEmpty(item))
-                                {
-                                    continue;
-                                }
-
-                                identity.AddClaim(new Claim(parameter.Key, item,
-                                    GetClaimValueType(value.ValueKind), issuer, issuer, identity));
+                                identity.AddClaim(new Claim(
+                                    type          : parameter.Key,
+                                    value         : item.ToString()!,
+                                    valueType     : GetClaimValueType(item.ValueKind),
+                                    issuer        : issuer,
+                                    originalIssuer: issuer,
+                                    subject       : identity));
                             }
                             break;
 
-                        case JsonElement value:
-                            identity.AddClaim(new Claim(parameter.Key, value.ToString()!,
-                                GetClaimValueType(value.ValueKind), issuer, issuer, identity));
-                            break;
-
-                        // Note: in the typical case, the introspection parameters should be deserialized from
-                        // a JSON response and thus represented as System.Text.Json.JsonElement instances.
-                        // However, to support responses resolved from custom locations and parameters manually added
-                        // by the application using the events model, the CLR primitive types are also supported.
-
-                        case bool value:
-                            identity.AddClaim(new Claim(parameter.Key, value.ToString(),
-                                ClaimValueTypes.Boolean, issuer, issuer, identity));
-                            break;
-
-                        case long value:
-                            identity.AddClaim(new Claim(parameter.Key, value.ToString(CultureInfo.InvariantCulture),
-                                ClaimValueTypes.Integer64, issuer, issuer, identity));
-                            break;
-
-                        case string value:
-                            identity.AddClaim(new Claim(parameter.Key, value, ClaimValueTypes.String, issuer, issuer, identity));
-                            break;
-
-                        // Claims represented as arrays are split and mapped to multiple CLR claims.
-                        case string[] value:
-                            for (var index = 0; index < value.Length; index++)
-                            {
-                                identity.AddClaim(new Claim(parameter.Key, value[index], ClaimValueTypes.String, issuer, issuer, identity));
-                            }
+                        // Note: JsonElement.ToString() returns string.Empty for JsonValueKind.Null and
+                        // JsonValueKind.Undefined, which, unlike null strings, is a valid claim value.
+                        case { ValueKind: _ } value:
+                            identity.AddClaim(new Claim(
+                                type          : parameter.Key,
+                                value         : value.ToString()!,
+                                valueType     : GetClaimValueType(value.ValueKind),
+                                issuer        : issuer,
+                                originalIssuer: issuer,
+                                subject       : identity));
                             break;
                     }
                 }
@@ -197,13 +190,12 @@ public static partial class OpenIddictClientHandlers
 
                 static string GetClaimValueType(JsonValueKind kind) => kind switch
                 {
-                    JsonValueKind.True or JsonValueKind.False => ClaimValueTypes.Boolean,
-
-                    JsonValueKind.String => ClaimValueTypes.String,
-                    JsonValueKind.Number => ClaimValueTypes.Integer64,
-
-                    JsonValueKind.Array       => JsonClaimValueTypes.JsonArray,
-                    JsonValueKind.Object or _ => JsonClaimValueTypes.Json
+                    JsonValueKind.String                          => ClaimValueTypes.String,
+                    JsonValueKind.Number                          => ClaimValueTypes.Integer64,
+                    JsonValueKind.True or JsonValueKind.False     => ClaimValueTypes.Boolean,
+                    JsonValueKind.Null or JsonValueKind.Undefined => JsonClaimValueTypes.JsonNull,
+                    JsonValueKind.Array                           => JsonClaimValueTypes.JsonArray,
+                    JsonValueKind.Object or _                     => JsonClaimValueTypes.Json
                 };
             }
         }
diff --git a/src/OpenIddict.Client/OpenIddictClientHandlers.cs b/src/OpenIddict.Client/OpenIddictClientHandlers.cs
index 073f8fdd..cea07e93 100644
--- a/src/OpenIddict.Client/OpenIddictClientHandlers.cs
+++ b/src/OpenIddict.Client/OpenIddictClientHandlers.cs
@@ -105,6 +105,7 @@ public static partial class OpenIddictClientHandlers
 
         .AddRange(Authentication.DefaultHandlers)
         .AddRange(Discovery.DefaultHandlers)
+        .AddRange(Exchange.DefaultHandlers)
         .AddRange(Protection.DefaultHandlers)
         .AddRange(Userinfo.DefaultHandlers);
 
diff --git a/src/OpenIddict.Server.AspNetCore/OpenIddictServerAspNetCoreHandlers.Authentication.cs b/src/OpenIddict.Server.AspNetCore/OpenIddictServerAspNetCoreHandlers.Authentication.cs
index 3a9fedd9..ce829ccc 100644
--- a/src/OpenIddict.Server.AspNetCore/OpenIddictServerAspNetCoreHandlers.Authentication.cs
+++ b/src/OpenIddict.Server.AspNetCore/OpenIddictServerAspNetCoreHandlers.Authentication.cs
@@ -132,16 +132,13 @@ public static partial class OpenIddictServerAspNetCoreHandlers
                     throw new InvalidOperationException(SR.GetResourceString(SR.ID0117));
                 }
 
-                // Restore the authorization request parameters from the serialized payload.
+                // Restore the request parameters from the serialized payload.
                 foreach (var parameter in document.RootElement.EnumerateObject())
                 {
-                    // Avoid overriding the current request parameters.
-                    if (context.Request.HasParameter(parameter.Name))
+                    if (!context.Request.HasParameter(parameter.Name))
                     {
-                        continue;
+                        context.Request.AddParameter(parameter.Name, parameter.Value.Clone());
                     }
-
-                    context.Request.SetParameter(parameter.Name, parameter.Value.Clone());
                 }
             }
         }
@@ -207,17 +204,34 @@ public static partial class OpenIddictServerAspNetCoreHandlers
 
                 context.Request.RequestId = Base64UrlEncoder.Encode(data);
 
+                // Build a list of claims matching the parameters extracted from the request.
+                //
+                // Note: in most cases, parameters should be representated as strings as requests are
+                // typically resolved from the query string or the request form, where parameters
+                // are natively represented as strings. However, requests can also be extracted from
+                // different places where they can be represented as complex JSON representations
+                // (e.g requests extracted from a JSON Web Token that may be encrypted and/or signed).
+                var claims = from parameter in context.Request.GetParameters()
+                             let element = (JsonElement) parameter.Value
+                             let type = element.ValueKind switch
+                             {
+                                 JsonValueKind.String                          => ClaimValueTypes.String,
+                                 JsonValueKind.Number                          => ClaimValueTypes.Integer64,
+                                 JsonValueKind.True or JsonValueKind.False     => ClaimValueTypes.Boolean,
+                                 JsonValueKind.Null or JsonValueKind.Undefined => JsonClaimValueTypes.JsonNull,
+                                 JsonValueKind.Array                           => JsonClaimValueTypes.JsonArray,
+                                 JsonValueKind.Object or _                     => JsonClaimValueTypes.Json
+                             }
+                             select new Claim(parameter.Key, element.ToString()!, type);
+
                 // Store the serialized authorization request parameters in the distributed cache.
                 var token = context.Options.JsonWebTokenHandler.CreateToken(new SecurityTokenDescriptor
                 {
                     Audience = context.Issuer?.AbsoluteUri,
-                    Claims = context.Request.GetParameters().ToDictionary(
-                        parameter => parameter.Key,
-                        parameter => parameter.Value.Value),
                     EncryptingCredentials = context.Options.EncryptionCredentials.First(),
                     Issuer = context.Issuer?.AbsoluteUri,
                     SigningCredentials = context.Options.SigningCredentials.First(),
-                    Subject = new ClaimsIdentity(),
+                    Subject = new ClaimsIdentity(claims, TokenValidationParameters.DefaultAuthenticationType),
                     TokenType = JsonWebTokenTypes.Private.AuthorizationRequest
                 });
 
diff --git a/src/OpenIddict.Server.AspNetCore/OpenIddictServerAspNetCoreHandlers.Session.cs b/src/OpenIddict.Server.AspNetCore/OpenIddictServerAspNetCoreHandlers.Session.cs
index d4206310..0bfa4927 100644
--- a/src/OpenIddict.Server.AspNetCore/OpenIddictServerAspNetCoreHandlers.Session.cs
+++ b/src/OpenIddict.Server.AspNetCore/OpenIddictServerAspNetCoreHandlers.Session.cs
@@ -129,16 +129,13 @@ public static partial class OpenIddictServerAspNetCoreHandlers
                     throw new InvalidOperationException(SR.GetResourceString(SR.ID0118));
                 }
 
-                // Restore the authorization request parameters from the serialized payload.
+                // Restore the request parameters from the serialized payload.
                 foreach (var parameter in document.RootElement.EnumerateObject())
                 {
-                    // Avoid overriding the current request parameters.
-                    if (context.Request.HasParameter(parameter.Name))
+                    if (!context.Request.HasParameter(parameter.Name))
                     {
-                        continue;
+                        context.Request.AddParameter(parameter.Name, parameter.Value.Clone());
                     }
-
-                    context.Request.SetParameter(parameter.Name, parameter.Value.Clone());
                 }
             }
         }
@@ -204,17 +201,34 @@ public static partial class OpenIddictServerAspNetCoreHandlers
 
                 context.Request.RequestId = Base64UrlEncoder.Encode(data);
 
+                // Build a list of claims matching the parameters extracted from the request.
+                //
+                // Note: in most cases, parameters should be representated as strings as requests are
+                // typically resolved from the query string or the request form, where parameters
+                // are natively represented as strings. However, requests can also be extracted from
+                // different places where they can be represented as complex JSON representations
+                // (e.g requests extracted from a JSON Web Token that may be encrypted and/or signed).
+                var claims = from parameter in context.Request.GetParameters()
+                             let element = (JsonElement) parameter.Value
+                             let type = element.ValueKind switch
+                             {
+                                 JsonValueKind.String                          => ClaimValueTypes.String,
+                                 JsonValueKind.Number                          => ClaimValueTypes.Integer64,
+                                 JsonValueKind.True or JsonValueKind.False     => ClaimValueTypes.Boolean,
+                                 JsonValueKind.Null or JsonValueKind.Undefined => JsonClaimValueTypes.JsonNull,
+                                 JsonValueKind.Array                           => JsonClaimValueTypes.JsonArray,
+                                 JsonValueKind.Object or _                     => JsonClaimValueTypes.Json
+                             }
+                             select new Claim(parameter.Key, element.ToString()!, type);
+
                 // Store the serialized logout request parameters in the distributed cache.
                 var token = context.Options.JsonWebTokenHandler.CreateToken(new SecurityTokenDescriptor
                 {
                     Audience = context.Issuer?.AbsoluteUri,
-                    Claims = context.Request.GetParameters().ToDictionary(
-                        parameter => parameter.Key,
-                        parameter => parameter.Value.Value),
                     EncryptingCredentials = context.Options.EncryptionCredentials.First(),
                     Issuer = context.Issuer?.AbsoluteUri,
                     SigningCredentials = context.Options.SigningCredentials.First(),
-                    Subject = new ClaimsIdentity(),
+                    Subject = new ClaimsIdentity(claims, TokenValidationParameters.DefaultAuthenticationType),
                     TokenType = JsonWebTokenTypes.Private.LogoutRequest
                 });
 
diff --git a/src/OpenIddict.Server.AspNetCore/OpenIddictServerAspNetCoreHandlers.cs b/src/OpenIddict.Server.AspNetCore/OpenIddictServerAspNetCoreHandlers.cs
index 9d17b52c..2645e1f4 100644
--- a/src/OpenIddict.Server.AspNetCore/OpenIddictServerAspNetCoreHandlers.cs
+++ b/src/OpenIddict.Server.AspNetCore/OpenIddictServerAspNetCoreHandlers.cs
@@ -17,6 +17,10 @@ using Microsoft.Extensions.Options;
 using Microsoft.Net.Http.Headers;
 using Properties = OpenIddict.Server.AspNetCore.OpenIddictServerAspNetCoreConstants.Properties;
 
+#if SUPPORTS_JSON_NODES
+using System.Text.Json.Nodes;
+#endif
+
 namespace OpenIddict.Server.AspNetCore;
 
 [EditorBrowsable(EditorBrowsableState.Never)]
@@ -320,6 +324,9 @@ public static partial class OpenIddictServerAspNetCoreHandlers
                     string              value => new OpenIddictParameter(value),
                     string[]            value => new OpenIddictParameter(value),
 
+#if SUPPORTS_JSON_NODES
+                    JsonNode            value => new OpenIddictParameter(value),
+#endif
                     _ => throw new InvalidOperationException(SR.GetResourceString(SR.ID0115))
                 };
             }
@@ -367,6 +374,9 @@ public static partial class OpenIddictServerAspNetCoreHandlers
                     string              value => new OpenIddictParameter(value),
                     string[]            value => new OpenIddictParameter(value),
 
+#if SUPPORTS_JSON_NODES
+                    JsonNode            value => new OpenIddictParameter(value),
+#endif
                     _ => throw new InvalidOperationException(SR.GetResourceString(SR.ID0115))
                 };
             }
@@ -414,6 +424,9 @@ public static partial class OpenIddictServerAspNetCoreHandlers
                     string              value => new OpenIddictParameter(value),
                     string[]            value => new OpenIddictParameter(value),
 
+#if SUPPORTS_JSON_NODES
+                    JsonNode            value => new OpenIddictParameter(value),
+#endif
                     _ => throw new InvalidOperationException(SR.GetResourceString(SR.ID0115))
                 };
             }
diff --git a/src/OpenIddict.Server.Owin/OpenIddictServerOwinHandlers.Authentication.cs b/src/OpenIddict.Server.Owin/OpenIddictServerOwinHandlers.Authentication.cs
index 67857fee..c465aa28 100644
--- a/src/OpenIddict.Server.Owin/OpenIddictServerOwinHandlers.Authentication.cs
+++ b/src/OpenIddict.Server.Owin/OpenIddictServerOwinHandlers.Authentication.cs
@@ -129,16 +129,13 @@ public static partial class OpenIddictServerOwinHandlers
                     throw new InvalidOperationException(SR.GetResourceString(SR.ID0117));
                 }
 
-                // Restore the authorization request parameters from the serialized payload.
+                // Restore the request parameters from the serialized payload.
                 foreach (var parameter in document.RootElement.EnumerateObject())
                 {
-                    // Avoid overriding the current request parameters.
-                    if (context.Request.HasParameter(parameter.Name))
+                    if (!context.Request.HasParameter(parameter.Name))
                     {
-                        continue;
+                        context.Request.AddParameter(parameter.Name, parameter.Value.Clone());
                     }
-
-                    context.Request.SetParameter(parameter.Name, parameter.Value.Clone());
                 }
             }
         }
@@ -199,17 +196,34 @@ public static partial class OpenIddictServerOwinHandlers
 
                 context.Request.RequestId = Base64UrlEncoder.Encode(data);
 
+                // Build a list of claims matching the parameters extracted from the request.
+                //
+                // Note: in most cases, parameters should be representated as strings as requests are
+                // typically resolved from the query string or the request form, where parameters
+                // are natively represented as strings. However, requests can also be extracted from
+                // different places where they can be represented as complex JSON representations
+                // (e.g requests extracted from a JSON Web Token that may be encrypted and/or signed).
+                var claims = from parameter in context.Request.GetParameters()
+                             let element = (JsonElement) parameter.Value
+                             let type = element.ValueKind switch
+                             {
+                                 JsonValueKind.String                          => ClaimValueTypes.String,
+                                 JsonValueKind.Number                          => ClaimValueTypes.Integer64,
+                                 JsonValueKind.True or JsonValueKind.False     => ClaimValueTypes.Boolean,
+                                 JsonValueKind.Null or JsonValueKind.Undefined => JsonClaimValueTypes.JsonNull,
+                                 JsonValueKind.Array                           => JsonClaimValueTypes.JsonArray,
+                                 JsonValueKind.Object or _                     => JsonClaimValueTypes.Json
+                             }
+                             select new Claim(parameter.Key, element.ToString()!, type);
+
                 // Store the serialized authorization request parameters in the distributed cache.
                 var token = context.Options.JsonWebTokenHandler.CreateToken(new SecurityTokenDescriptor
                 {
                     Audience = context.Issuer?.AbsoluteUri,
-                    Claims = context.Request.GetParameters().ToDictionary(
-                        parameter => parameter.Key,
-                        parameter => parameter.Value.Value),
                     EncryptingCredentials = context.Options.EncryptionCredentials.First(),
                     Issuer = context.Issuer?.AbsoluteUri,
                     SigningCredentials = context.Options.SigningCredentials.First(),
-                    Subject = new ClaimsIdentity(),
+                    Subject = new ClaimsIdentity(claims, TokenValidationParameters.DefaultAuthenticationType),
                     TokenType = JsonWebTokenTypes.Private.AuthorizationRequest
                 });
 
diff --git a/src/OpenIddict.Server.Owin/OpenIddictServerOwinHandlers.Session.cs b/src/OpenIddict.Server.Owin/OpenIddictServerOwinHandlers.Session.cs
index 27eb5f29..bb2a9e32 100644
--- a/src/OpenIddict.Server.Owin/OpenIddictServerOwinHandlers.Session.cs
+++ b/src/OpenIddict.Server.Owin/OpenIddictServerOwinHandlers.Session.cs
@@ -127,16 +127,13 @@ public static partial class OpenIddictServerOwinHandlers
                     throw new InvalidOperationException(SR.GetResourceString(SR.ID0118));
                 }
 
-                // Restore the authorization request parameters from the serialized payload
+                // Restore the request parameters from the serialized payload.
                 foreach (var parameter in document.RootElement.EnumerateObject())
                 {
-                    // Avoid overriding the current request parameters.
-                    if (context.Request.HasParameter(parameter.Name))
+                    if (!context.Request.HasParameter(parameter.Name))
                     {
-                        continue;
+                        context.Request.AddParameter(parameter.Name, parameter.Value.Clone());
                     }
-
-                    context.Request.SetParameter(parameter.Name, parameter.Value.Clone());
                 }
             }
         }
@@ -197,17 +194,34 @@ public static partial class OpenIddictServerOwinHandlers
 
                 context.Request.RequestId = Base64UrlEncoder.Encode(data);
 
+                // Build a list of claims matching the parameters extracted from the request.
+                //
+                // Note: in most cases, parameters should be representated as strings as requests are
+                // typically resolved from the query string or the request form, where parameters
+                // are natively represented as strings. However, requests can also be extracted from
+                // different places where they can be represented as complex JSON representations
+                // (e.g requests extracted from a JSON Web Token that may be encrypted and/or signed).
+                var claims = from parameter in context.Request.GetParameters()
+                             let element = (JsonElement) parameter.Value
+                             let type = element.ValueKind switch
+                             {
+                                 JsonValueKind.String                          => ClaimValueTypes.String,
+                                 JsonValueKind.Number                          => ClaimValueTypes.Integer64,
+                                 JsonValueKind.True or JsonValueKind.False     => ClaimValueTypes.Boolean,
+                                 JsonValueKind.Null or JsonValueKind.Undefined => JsonClaimValueTypes.JsonNull,
+                                 JsonValueKind.Array                           => JsonClaimValueTypes.JsonArray,
+                                 JsonValueKind.Object or _                     => JsonClaimValueTypes.Json
+                             }
+                             select new Claim(parameter.Key, element.ToString()!, type);
+
                 // Store the serialized logout request parameters in the distributed cache.
                 var token = context.Options.JsonWebTokenHandler.CreateToken(new SecurityTokenDescriptor
                 {
                     Audience = context.Issuer?.AbsoluteUri,
-                    Claims = context.Request.GetParameters().ToDictionary(
-                        parameter => parameter.Key,
-                        parameter => parameter.Value.Value),
                     EncryptingCredentials = context.Options.EncryptionCredentials.First(),
                     Issuer = context.Issuer?.AbsoluteUri,
                     SigningCredentials = context.Options.SigningCredentials.First(),
-                    Subject = new ClaimsIdentity(),
+                    Subject = new ClaimsIdentity(claims, TokenValidationParameters.DefaultAuthenticationType),
                     TokenType = JsonWebTokenTypes.Private.LogoutRequest
                 });
 
diff --git a/src/OpenIddict.Validation.AspNetCore/OpenIddictValidationAspNetCoreHandlers.cs b/src/OpenIddict.Validation.AspNetCore/OpenIddictValidationAspNetCoreHandlers.cs
index 290da0a6..69856b5e 100644
--- a/src/OpenIddict.Validation.AspNetCore/OpenIddictValidationAspNetCoreHandlers.cs
+++ b/src/OpenIddict.Validation.AspNetCore/OpenIddictValidationAspNetCoreHandlers.cs
@@ -17,6 +17,10 @@ using Microsoft.Extensions.Primitives;
 using Microsoft.Net.Http.Headers;
 using Properties = OpenIddict.Validation.AspNetCore.OpenIddictValidationAspNetCoreConstants.Properties;
 
+#if SUPPORTS_JSON_NODES
+using System.Text.Json.Nodes;
+#endif
+
 namespace OpenIddict.Validation.AspNetCore;
 
 [EditorBrowsable(EditorBrowsableState.Never)]
@@ -317,6 +321,9 @@ public static partial class OpenIddictValidationAspNetCoreHandlers
                     string              value => new OpenIddictParameter(value),
                     string[]            value => new OpenIddictParameter(value),
 
+#if SUPPORTS_JSON_NODES
+                    JsonNode            value => new OpenIddictParameter(value),
+#endif
                     _ => throw new InvalidOperationException(SR.GetResourceString(SR.ID0115))
                 };
             }
diff --git a/src/OpenIddict.Validation/OpenIddictValidationHandlers.Introspection.cs b/src/OpenIddict.Validation/OpenIddictValidationHandlers.Introspection.cs
index 69b59510..4fcdd479 100644
--- a/src/OpenIddict.Validation/OpenIddictValidationHandlers.Introspection.cs
+++ b/src/OpenIddict.Validation/OpenIddictValidationHandlers.Introspection.cs
@@ -5,7 +5,6 @@
  */
 
 using System.Collections.Immutable;
-using System.Globalization;
 using System.Security.Claims;
 using System.Text.Json;
 using Microsoft.IdentityModel.JsonWebTokens;
@@ -152,7 +151,7 @@ public static partial class OpenIddictValidationHandlers
             {
                 foreach (var parameter in context.Response.GetParameters())
                 {
-                    if (ValidateClaimType(parameter.Key, parameter.Value.Value))
+                    if (ValidateClaimType(parameter.Key, parameter.Value))
                     {
                         continue;
                     }
@@ -167,32 +166,39 @@ public static partial class OpenIddictValidationHandlers
 
                 return default;
 
-                static bool ValidateClaimType(string name, object? value) => name switch
+                // Note: in the typical case, the response parameters should be deserialized from a
+                // JSON response and thus natively stored as System.Text.Json.JsonElement instances.
+                //
+                // In the rare cases where the underlying value wouldn't be a JsonElement instance
+                // (e.g when custom parameters are manually added to the response), the static
+                // conversion operator would take care of converting the underlying value to a
+                // JsonElement instance using the same value type as the original parameter value.
+                static bool ValidateClaimType(string name, OpenIddictParameter value) => name switch
                 {
-                    // The 'aud' claim MUST be represented either as a unique string or as an array of multiple strings.
-                    Claims.Audience when value is string or string[] => true,
-                    Claims.Audience when value is JsonElement { ValueKind: JsonValueKind.String } => true,
-                    Claims.Audience when value is JsonElement { ValueKind: JsonValueKind.Array } element &&
-                        ValidateArrayChildren(element, JsonValueKind.String) => true,
-                    Claims.Audience => false,
+                    // The 'jti', 'iss', 'scope' and 'token_usage' claims MUST be formatted as a unique string.
+                    Claims.JwtId or Claims.Issuer or Claims.Scope or Claims.TokenUsage
+                        => ((JsonElement) value).ValueKind is JsonValueKind.String,
+
+                    // The 'aud' claim MUST be represented either as a unique string or as an array of strings.
+                    //
+                    // Note: empty arrays and arrays that contain a single value are also considered valid.
+                    Claims.Audience => ((JsonElement) value) is JsonElement element &&
+                        element.ValueKind is JsonValueKind.String ||
+                       (element.ValueKind is JsonValueKind.Array && ValidateStringArray(element)),
 
                     // The 'exp', 'iat' and 'nbf' claims MUST be formatted as numeric date values.
                     Claims.ExpiresAt or Claims.IssuedAt or Claims.NotBefore
-                        => value is long or JsonElement { ValueKind: JsonValueKind.Number },
-
-                    // The 'jti', 'iss', 'scope' and 'token_usage' claims MUST be formatted as a unique string.
-                    Claims.JwtId or Claims.Issuer or Claims.Scope or Claims.TokenUsage
-                        => value is string or JsonElement { ValueKind: JsonValueKind.String },
+                        => ((JsonElement) value).ValueKind is JsonValueKind.Number,
 
                     // Claims that are not in the well-known list can be of any type.
                     _ => true
                 };
 
-                static bool ValidateArrayChildren(JsonElement element, JsonValueKind kind)
+                static bool ValidateStringArray(JsonElement element)
                 {
-                    foreach (var child in element.EnumerateArray())
+                    foreach (var item in element.EnumerateArray())
                     {
-                        if (child.ValueKind != kind)
+                        if (item.ValueKind is not JsonValueKind.String)
                         {
                             return false;
                         }
@@ -348,8 +354,8 @@ public static partial class OpenIddictValidationHandlers
 
                 foreach (var parameter in context.Response.GetParameters())
                 {
-                    // Always exclude null keys and values, as they can't be represented as valid claims.
-                    if (string.IsNullOrEmpty(parameter.Key) || OpenIddictParameter.IsNullOrEmpty(parameter.Value))
+                    // Always exclude null keys as they can't be represented as valid claims.
+                    if (string.IsNullOrEmpty(parameter.Key))
                     {
                         continue;
                     }
@@ -367,53 +373,40 @@ public static partial class OpenIddictValidationHandlers
                         continue;
                     }
 
-                    switch (parameter.Value.Value)
+                    // Note: in the typical case, the response parameters should be deserialized from a
+                    // JSON response and thus natively stored as System.Text.Json.JsonElement instances.
+                    //
+                    // In the rare cases where the underlying value wouldn't be a JsonElement instance
+                    // (e.g when custom parameters are manually added to the response), the static
+                    // conversion operator would take care of converting the underlying value to a
+                    // JsonElement instance using the same value type as the original parameter value.
+                    switch ((JsonElement) parameter.Value)
                     {
-                        // Claims represented as arrays are split and mapped to multiple CLR claims.
-                        case JsonElement { ValueKind: JsonValueKind.Array } value:
-                            foreach (var element in value.EnumerateArray())
+                        // Top-level claims represented as arrays are split and mapped to multiple CLR claims
+                        // to match the logic implemented by IdentityModel for JWT token deserialization.
+                        case { ValueKind: JsonValueKind.Array } value:
+                            foreach (var item in value.EnumerateArray())
                             {
-                                var item = element.GetString();
-                                if (string.IsNullOrEmpty(item))
-                                {
-                                    continue;
-                                }
-
-                                identity.AddClaim(new Claim(parameter.Key, item,
-                                    GetClaimValueType(value.ValueKind), issuer, issuer, identity));
+                                identity.AddClaim(new Claim(
+                                    type          : parameter.Key,
+                                    value         : item.ToString()!,
+                                    valueType     : GetClaimValueType(item.ValueKind),
+                                    issuer        : issuer,
+                                    originalIssuer: issuer,
+                                    subject       : identity));
                             }
                             break;
 
-                        case JsonElement value:
-                            identity.AddClaim(new Claim(parameter.Key, value.ToString()!,
-                                GetClaimValueType(value.ValueKind), issuer, issuer, identity));
-                            break;
-
-                        // Note: in the typical case, the introspection parameters should be deserialized from
-                        // a JSON response and thus represented as System.Text.Json.JsonElement instances.
-                        // However, to support responses resolved from custom locations and parameters manually added
-                        // by the application using the events model, the CLR primitive types are also supported.
-
-                        case bool value:
-                            identity.AddClaim(new Claim(parameter.Key, value.ToString(),
-                                ClaimValueTypes.Boolean, issuer, issuer, identity));
-                            break;
-
-                        case long value:
-                            identity.AddClaim(new Claim(parameter.Key, value.ToString(CultureInfo.InvariantCulture),
-                                ClaimValueTypes.Integer64, issuer, issuer, identity));
-                            break;
-
-                        case string value:
-                            identity.AddClaim(new Claim(parameter.Key, value, ClaimValueTypes.String, issuer, issuer, identity));
-                            break;
-
-                        // Claims represented as arrays are split and mapped to multiple CLR claims.
-                        case string[] value:
-                            for (var index = 0; index < value.Length; index++)
-                            {
-                                identity.AddClaim(new Claim(parameter.Key, value[index], ClaimValueTypes.String, issuer, issuer, identity));
-                            }
+                        // Note: JsonElement.ToString() returns string.Empty for JsonValueKind.Null and
+                        // JsonValueKind.Undefined, which, unlike null strings, is a valid claim value.
+                        case { ValueKind: _ } value:
+                            identity.AddClaim(new Claim(
+                                type          : parameter.Key,
+                                value         : value.ToString()!,
+                                valueType     : GetClaimValueType(value.ValueKind),
+                                issuer        : issuer,
+                                originalIssuer: issuer,
+                                subject       : identity));
                             break;
                     }
                 }
@@ -422,13 +415,12 @@ public static partial class OpenIddictValidationHandlers
 
                 static string GetClaimValueType(JsonValueKind kind) => kind switch
                 {
-                    JsonValueKind.True or JsonValueKind.False => ClaimValueTypes.Boolean,
-
-                    JsonValueKind.String => ClaimValueTypes.String,
-                    JsonValueKind.Number => ClaimValueTypes.Integer64,
-
-                    JsonValueKind.Array       => JsonClaimValueTypes.JsonArray,
-                    JsonValueKind.Object or _ => JsonClaimValueTypes.Json
+                    JsonValueKind.String                          => ClaimValueTypes.String,
+                    JsonValueKind.Number                          => ClaimValueTypes.Integer64,
+                    JsonValueKind.True or JsonValueKind.False     => ClaimValueTypes.Boolean,
+                    JsonValueKind.Null or JsonValueKind.Undefined => JsonClaimValueTypes.JsonNull,
+                    JsonValueKind.Array                           => JsonClaimValueTypes.JsonArray,
+                    JsonValueKind.Object or _                     => JsonClaimValueTypes.Json
                 };
             }
         }
diff --git a/test/OpenIddict.Abstractions.Tests/Primitives/OpenIddictConverterTests.cs b/test/OpenIddict.Abstractions.Tests/Primitives/OpenIddictConverterTests.cs
index a27a9de5..6d7e1372 100644
--- a/test/OpenIddict.Abstractions.Tests/Primitives/OpenIddictConverterTests.cs
+++ b/test/OpenIddict.Abstractions.Tests/Primitives/OpenIddictConverterTests.cs
@@ -8,6 +8,10 @@ using System.Text;
 using System.Text.Json;
 using Xunit;
 
+#if SUPPORTS_JSON_NODES
+using System.Text.Json.Nodes;
+#endif
+
 namespace OpenIddict.Abstractions.Tests.Primitives;
 
 public class OpenIddictConverterTests
@@ -129,6 +133,11 @@ public class OpenIddictConverterTests
         Assert.Null((long?) message.GetParameter("long"));
         Assert.Equal(JsonValueKind.Null, ((JsonElement) message.GetParameter("array")).ValueKind);
         Assert.Equal(JsonValueKind.Null, ((JsonElement) message.GetParameter("object")).ValueKind);
+
+#if SUPPORTS_JSON_NODES
+        Assert.Null((JsonNode?) message.GetParameter("array"));
+        Assert.Null((JsonNode?) message.GetParameter("object"));
+#endif
     }
 
     [Fact]
@@ -149,6 +158,11 @@ public class OpenIddictConverterTests
         Assert.Empty((string?) message.GetParameter("string"));
         Assert.NotNull((JsonElement?) message.GetParameter("array"));
         Assert.NotNull((JsonElement?) message.GetParameter("object"));
+
+#if SUPPORTS_JSON_NODES
+        Assert.NotNull((JsonNode?) message.GetParameter("array"));
+        Assert.NotNull((JsonNode?) message.GetParameter("object"));
+#endif
     }
 
     [Fact]
@@ -213,7 +227,11 @@ public class OpenIddictConverterTests
         message.AddParameter("string", new OpenIddictParameter((string?) null));
         message.AddParameter("bool", new OpenIddictParameter((bool?) null));
         message.AddParameter("long", new OpenIddictParameter((long?) null));
-        message.AddParameter("node", new OpenIddictParameter(default(JsonElement)));
+        message.AddParameter("element", new OpenIddictParameter(default(JsonElement)));
+
+#if SUPPORTS_JSON_NODES
+        message.AddParameter("node", new OpenIddictParameter((JsonNode?) null));
+#endif
 
         // Act
         converter.Write(writer, value: message, options: null!);
@@ -221,7 +239,12 @@ public class OpenIddictConverterTests
         // Assert
         writer.Flush();
         stream.Seek(0L, SeekOrigin.Begin);
-        Assert.Equal(@"{""string"":null,""bool"":null,""long"":null,""node"":null}", reader.ReadToEnd());
+
+#if SUPPORTS_JSON_NODES
+        Assert.Equal(@"{""string"":null,""bool"":null,""long"":null,""element"":null,""node"":null}", reader.ReadToEnd());
+#else
+        Assert.Equal(@"{""string"":null,""bool"":null,""long"":null,""element"":null}", reader.ReadToEnd());
+#endif
     }
 
     [Fact]
@@ -235,8 +258,14 @@ public class OpenIddictConverterTests
 
         var message = new OpenIddictMessage();
         message.AddParameter("string", new OpenIddictParameter(string.Empty));
-        message.AddParameter("array", new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>("[]")));
-        message.AddParameter("object", new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>("{}")));
+        message.AddParameter("element_array", new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>("[]")));
+        message.AddParameter("element_object", new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>("{}")));
+
+#if SUPPORTS_JSON_NODES
+        message.AddParameter("node_array", new OpenIddictParameter(new JsonArray()));
+        message.AddParameter("node_object", new OpenIddictParameter(new JsonObject()));
+        message.AddParameter("node_value", new OpenIddictParameter(JsonValue.Create(new { })));
+#endif
 
         // Act
         converter.Write(writer, value: message, options: null!);
@@ -244,7 +273,12 @@ public class OpenIddictConverterTests
         // Assert
         writer.Flush();
         stream.Seek(0L, SeekOrigin.Begin);
-        Assert.Equal(@"{""string"":"""",""array"":[],""object"":{}}", reader.ReadToEnd());
+
+#if SUPPORTS_JSON_NODES
+        Assert.Equal(@"{""string"":"""",""element_array"":[],""element_object"":{},""node_array"":[],""node_object"":{},""node_value"":{}}", reader.ReadToEnd());
+#else
+        Assert.Equal(@"{""string"":"""",""element_array"":[],""element_object"":{}}", reader.ReadToEnd());
+#endif
     }
 
     [Fact]
diff --git a/test/OpenIddict.Abstractions.Tests/Primitives/OpenIddictMessageTests.cs b/test/OpenIddict.Abstractions.Tests/Primitives/OpenIddictMessageTests.cs
index 8489cc1e..e0aea9cd 100644
--- a/test/OpenIddict.Abstractions.Tests/Primitives/OpenIddictMessageTests.cs
+++ b/test/OpenIddict.Abstractions.Tests/Primitives/OpenIddictMessageTests.cs
@@ -9,6 +9,10 @@ using System.Text.Encodings.Web;
 using System.Text.Json;
 using Xunit;
 
+#if SUPPORTS_JSON_NODES
+using System.Text.Json.Nodes;
+#endif
+
 namespace OpenIddict.Abstractions.Tests.Primitives;
 
 public class OpenIddictMessageTests
@@ -185,11 +189,23 @@ public class OpenIddictMessageTests
         message.AddParameter("value", JsonSerializer.Deserialize<JsonElement>(
             @"{""property"":""""}").GetProperty("property").GetString());
 
+#if SUPPORTS_JSON_NODES
+        message.AddParameter("node_array", new JsonArray());
+        message.AddParameter("node_object", new JsonObject());
+        message.AddParameter("node_value", JsonValue.Create(string.Empty));
+#endif
+
         // Assert
         Assert.Empty((string?) message.GetParameter("string"));
         Assert.NotNull((JsonElement?) message.GetParameter("array"));
         Assert.NotNull((JsonElement?) message.GetParameter("object"));
         Assert.NotNull((JsonElement?) message.GetParameter("value"));
+
+#if SUPPORTS_JSON_NODES
+        Assert.NotNull((JsonNode?) message.GetParameter("node_array"));
+        Assert.NotNull((JsonNode?) message.GetParameter("node_object"));
+        Assert.NotNull((JsonNode?) message.GetParameter("node_value"));
+#endif
     }
 
     [Theory]
@@ -384,6 +400,12 @@ public class OpenIddictMessageTests
         message.SetParameter("value", JsonSerializer.Deserialize<JsonElement>(
             @"{""property"":""""}").GetProperty("property").GetString());
 
+#if SUPPORTS_JSON_NODES
+        message.SetParameter("node_array", new JsonArray());
+        message.SetParameter("node_object", new JsonObject());
+        message.SetParameter("node_value", JsonValue.Create(string.Empty));
+#endif
+
         // Assert
         Assert.Empty(message.GetParameters());
     }
diff --git a/test/OpenIddict.Abstractions.Tests/Primitives/OpenIddictParameterTests.cs b/test/OpenIddict.Abstractions.Tests/Primitives/OpenIddictParameterTests.cs
index d18e89ef..b31d6ddc 100644
--- a/test/OpenIddict.Abstractions.Tests/Primitives/OpenIddictParameterTests.cs
+++ b/test/OpenIddict.Abstractions.Tests/Primitives/OpenIddictParameterTests.cs
@@ -8,6 +8,10 @@ using System.Text;
 using System.Text.Json;
 using Xunit;
 
+#if SUPPORTS_JSON_NODES
+using System.Text.Json.Nodes;
+#endif
+
 namespace OpenIddict.Abstractions.Tests.Primitives;
 
 public class OpenIddictParameterTests
@@ -67,7 +71,7 @@ public class OpenIddictParameterTests
     }
 
     [Fact]
-    public void Count_ReturnsExpectedValueForJsonArray()
+    public void Count_ReturnsExpectedValueForJsonArrayElements()
     {
         // Arrange
         var parameter = new OpenIddictParameter(
@@ -78,15 +82,60 @@ public class OpenIddictParameterTests
     }
 
     [Fact]
-    public void Count_ReturnsZeroForJsonObjects()
+    public void Count_ReturnsExpectedValueForJsonObjectElements()
     {
         // Arrange
         var parameter = new OpenIddictParameter(
             JsonSerializer.Deserialize<JsonElement>(@"{""parameter"":""value""}"));
 
+        // Act and assert
+        Assert.Equal(1, parameter.Count);
+    }
+
+#if SUPPORTS_JSON_NODES
+    [Fact]
+    public void Count_ReturnsExpectedValueForJsonArrayNodes()
+    {
+        // Arrange
+        var parameter = new OpenIddictParameter(new JsonArray("Fabrikam", "Contoso"));
+
+        // Act and assert
+        Assert.Equal(2, parameter.Count);
+    }
+
+    [Fact]
+    public void Count_ReturnsExpectedValueForJsonValueNodes()
+    {
+        // Arrange
+        var parameter = new OpenIddictParameter(JsonValue.Create(new[] { "Fabrikam", "Contoso" }));
+
+        // Act and assert
+        Assert.Equal(2, parameter.Count);
+    }
+
+    [Fact]
+    public void Count_ReturnsReturnsExpectedValueForJsonObjectNodes()
+    {
+        // Arrange
+        var parameter = new OpenIddictParameter(new JsonObject
+        {
+            ["parameter"] = "value"
+        });
+
+        // Act and assert
+        Assert.Equal(1, parameter.Count);
+    }
+
+    [Fact]
+    public void Count_ReturnsZeroForJsonValueNodes()
+    {
+        // Arrange
+        var parameter = new OpenIddictParameter(JsonValue.Create("value"));
+
         // Act and assert
         Assert.Equal(0, parameter.Count);
     }
+#endif
 
     [Fact]
     public void Equals_ReturnsTrueWhenBothParametersAreNull()
@@ -133,6 +182,13 @@ public class OpenIddictParameterTests
 
         Assert.False(new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>("[]"))
             .Equals(new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>("{}"))));
+
+#if SUPPORTS_JSON_NODES
+        Assert.False(new OpenIddictParameter(JsonValue.Create(true)).Equals(new OpenIddictParameter(JsonValue.Create("true"))));
+        Assert.False(new OpenIddictParameter(JsonValue.Create("true")).Equals(new OpenIddictParameter(JsonValue.Create(true))));
+        Assert.False(new OpenIddictParameter(new JsonObject()).Equals(new OpenIddictParameter(new JsonArray())));
+        Assert.False(new OpenIddictParameter(new JsonArray()).Equals(new OpenIddictParameter(new JsonObject())));
+#endif
     }
 
     [Fact]
@@ -143,11 +199,12 @@ public class OpenIddictParameterTests
 
         // Act and assert
         Assert.True(parameter.Equals(new string[] { "Fabrikam", "Contoso" }));
+        Assert.False(parameter.Equals(new string[] { "Fabrikam" }));
         Assert.False(parameter.Equals(new string[] { "Contoso", "Fabrikam" }));
     }
 
     [Fact]
-    public void Equals_UsesDeepEqualsForJsonArrays()
+    public void Equals_UsesDeepEqualsForJsonArrayElements()
     {
         // Arrange
         var parameter = new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>("[0,1,2,3]"));
@@ -157,10 +214,41 @@ public class OpenIddictParameterTests
         Assert.False(parameter.Equals(JsonSerializer.Deserialize<JsonElement>("[]")));
         Assert.False(parameter.Equals(JsonSerializer.Deserialize<JsonElement>("[0,1,2]")));
         Assert.False(parameter.Equals(JsonSerializer.Deserialize<JsonElement>("[3,2,1,0]")));
+        Assert.False(parameter.Equals(JsonSerializer.Deserialize<JsonElement>("{}")));
+
+#if SUPPORTS_JSON_NODES
+        Assert.True(parameter.Equals(new OpenIddictParameter(new JsonArray(0, 1, 2, 3))));
+        Assert.False(parameter.Equals(new OpenIddictParameter(new JsonArray())));
+        Assert.False(parameter.Equals(new OpenIddictParameter(new JsonArray(0, 1, 2))));
+        Assert.False(parameter.Equals(new OpenIddictParameter(new JsonArray(3, 2, 1, 0))));
+        Assert.False(parameter.Equals(new OpenIddictParameter(new JsonObject())));
+#endif
     }
 
+#if SUPPORTS_JSON_NODES
     [Fact]
-    public void Equals_UsesDeepEqualsForJsonObjects()
+    public void Equals_UsesDeepEqualsForJsonArrayNodes()
+    {
+        // Arrange
+        var parameter = new OpenIddictParameter(new JsonArray(0, 1, 2, 3));
+
+        // Act and assert
+        Assert.True(parameter.Equals(JsonSerializer.Deserialize<JsonElement>("[0,1,2,3]")));
+        Assert.False(parameter.Equals(JsonSerializer.Deserialize<JsonElement>("[]")));
+        Assert.False(parameter.Equals(JsonSerializer.Deserialize<JsonElement>("[0,1,2]")));
+        Assert.False(parameter.Equals(JsonSerializer.Deserialize<JsonElement>("[3,2,1,0]")));
+        Assert.False(parameter.Equals(JsonSerializer.Deserialize<JsonElement>("{}")));
+
+        Assert.True(parameter.Equals(new OpenIddictParameter(new JsonArray(0, 1, 2, 3))));
+        Assert.False(parameter.Equals(new OpenIddictParameter(new JsonArray())));
+        Assert.False(parameter.Equals(new OpenIddictParameter(new JsonArray(0, 1, 2))));
+        Assert.False(parameter.Equals(new OpenIddictParameter(new JsonArray(3, 2, 1, 0))));
+        Assert.False(parameter.Equals(new OpenIddictParameter(new JsonObject())));
+    }
+#endif
+
+    [Fact]
+    public void Equals_UsesDeepEqualsForJsonObjectElements()
     {
         // Arrange
         var parameter = new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>(@"{""field"":[0,1,2,3]}"));
@@ -170,22 +258,133 @@ public class OpenIddictParameterTests
         Assert.False(parameter.Equals(JsonSerializer.Deserialize<JsonElement>(@"{}")));
         Assert.False(parameter.Equals(JsonSerializer.Deserialize<JsonElement>(@"{""field"":""value""}")));
         Assert.False(parameter.Equals(JsonSerializer.Deserialize<JsonElement>(@"{""field"":[0,1,2]}")));
+        Assert.False(parameter.Equals(JsonSerializer.Deserialize<JsonElement>(@"[]")));
+
+#if SUPPORTS_JSON_NODES
+        Assert.True(parameter.Equals(new OpenIddictParameter(new JsonObject
+        {
+            ["field"] = new JsonArray(0, 1, 2, 3)
+        })));
+
+        Assert.False(parameter.Equals(new OpenIddictParameter(new JsonObject())));
+
+        Assert.False(parameter.Equals(new OpenIddictParameter(new JsonObject
+        {
+            ["field"] = JsonValue.Create("value")
+        })));
+
+        Assert.False(parameter.Equals(new OpenIddictParameter(new JsonObject
+        {
+            ["field"] =  JsonValue.Create(JsonSerializer.Deserialize<JsonElement>(
+                @"{""field"":""value""}").GetProperty("field"))
+        })));
+
+        Assert.False(parameter.Equals(new OpenIddictParameter(new JsonObject
+        {
+            ["field"] = new JsonArray(0, 1, 2)
+        })));
+
+        Assert.False(parameter.Equals(new OpenIddictParameter(new JsonArray())));
+#endif
     }
 
+#if SUPPORTS_JSON_NODES
     [Fact]
-    public void Equals_ComparesUnderlyingValuesForJsonValues()
+    public void Equals_UsesDeepEqualsForJsonObjectNodes()
     {
         // Arrange
-        var value = JsonSerializer.Deserialize<JsonElement>(@"{""field"":42}").GetProperty("field");
-        var parameter = new OpenIddictParameter(value);
+        var parameter = new OpenIddictParameter(new JsonObject
+        {
+            ["field"] = new JsonArray(0, 1, 2, 3)
+        });
 
         // Act and assert
-        Assert.True(parameter.Equals(new OpenIddictParameter(42)));
-        Assert.False(parameter.Equals(new OpenIddictParameter(100)));
+        Assert.True(parameter.Equals(JsonSerializer.Deserialize<JsonElement>(@"{""field"":[0,1,2,3]}")));
+        Assert.False(parameter.Equals(JsonSerializer.Deserialize<JsonElement>(@"{}")));
+        Assert.False(parameter.Equals(JsonSerializer.Deserialize<JsonElement>(@"{""field"":""value""}")));
+        Assert.False(parameter.Equals(JsonSerializer.Deserialize<JsonElement>(@"{""field"":[0,1,2]}")));
+        Assert.False(parameter.Equals(JsonSerializer.Deserialize<JsonElement>(@"[]")));
+
+        Assert.True(parameter.Equals(new JsonObject
+        {
+            ["field"] = new JsonArray(0, 1, 2, 3)
+        }));
+
+        Assert.False(parameter.Equals(new JsonObject()));
+
+        Assert.False(parameter.Equals(new JsonObject
+        {
+            ["field"] = JsonValue.Create("value")
+        }));
+
+        Assert.False(parameter.Equals(new OpenIddictParameter(new JsonObject
+        {
+            ["field"] = JsonValue.Create(JsonSerializer.Deserialize<JsonElement>(
+                @"{""field"":""value""}").GetProperty("field"))
+        })));
+
+        Assert.False(parameter.Equals(new JsonObject
+        {
+            ["field"] = new JsonArray(0, 1, 2)
+        }));
+
+        Assert.True(parameter.Equals(JsonValue.Create(new Dictionary<string, object>
+        {
+            ["field"] = new JsonArray(0, 1, 2, 3)
+        })));
+
+        Assert.True(parameter.Equals(JsonValue.Create(new Dictionary<string, object>
+        {
+            ["field"] = new[] { 0, 1, 2, 3 }
+        })));
     }
+#endif
 
     [Fact]
-    public void Equals_SupportsUndefinedJsonValues()
+    public void Equals_ComparesUnderlyingValuesForJsonValueElements()
+    {
+        // Arrange, act and assert
+        Assert.True(new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>(
+            @"{""field"":42}").GetProperty("field")).Equals(new OpenIddictParameter(42)));
+
+        Assert.False(new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>(
+            @"{""field"":42}").GetProperty("field")).Equals(new OpenIddictParameter(100)));
+
+        Assert.True(new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>(
+            @"{""field"":""Fabrikam""}").GetProperty("field")).Equals(new OpenIddictParameter("Fabrikam")));
+
+        Assert.False(new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>(
+            @"{""field"":""Fabrikam""}").GetProperty("field")).Equals(new OpenIddictParameter("Contoso")));
+    }
+
+#if SUPPORTS_JSON_NODES
+    [Fact]
+    public void Equals_ComparesUnderlyingValuesForJsonValueNodes()
+    {
+        // Arrange, act and assert
+        Assert.True(new OpenIddictParameter(JsonValue.Create(42)).Equals(new OpenIddictParameter(42)));
+        Assert.False(new OpenIddictParameter(JsonValue.Create(42)).Equals(new OpenIddictParameter(100)));
+        Assert.True(new OpenIddictParameter(JsonValue.Create(42L)).Equals(new OpenIddictParameter(42)));
+        Assert.False(new OpenIddictParameter(JsonValue.Create(42L)).Equals(new OpenIddictParameter(100)));
+        Assert.True(new OpenIddictParameter(JsonValue.Create("Fabrikam")).Equals(new OpenIddictParameter("Fabrikam")));
+        Assert.False(new OpenIddictParameter(JsonValue.Create("Fabrikam")).Equals(new OpenIddictParameter("Contoso")));
+
+        Assert.True(new OpenIddictParameter(JsonValue.Create(JsonSerializer.Deserialize<JsonElement>(
+            @"{""field"":42}").GetProperty("field")))!.Equals(new OpenIddictParameter(42)));
+
+        Assert.False(new OpenIddictParameter(JsonValue.Create(JsonSerializer.Deserialize<JsonElement>(
+            @"{""field"":42}").GetProperty("field")))!.Equals(new OpenIddictParameter(100)));
+
+        Assert.True(new OpenIddictParameter(JsonValue.Create(JsonSerializer.Deserialize<JsonElement>(
+            @"{""field"":""Fabrikam""}").GetProperty("field")))!.Equals(new OpenIddictParameter("Fabrikam")));
+
+        Assert.False(new OpenIddictParameter(JsonValue.Create(JsonSerializer.Deserialize<JsonElement>(
+            @"{""field"":""Fabrikam""}").GetProperty("field")))!.Equals(new OpenIddictParameter("Contoso")));
+    }
+#endif
+
+    [Fact]
+    public void Equals_SupportsUndefinedJsonValueElements()
     {
         // Arrange
         var parameter = new OpenIddictParameter(42);
@@ -194,8 +393,20 @@ public class OpenIddictParameterTests
         Assert.False(parameter.Equals(new OpenIddictParameter(default(JsonElement))));
     }
 
+#if SUPPORTS_JSON_NODES
     [Fact]
-    public void Equals_SupportsJsonValues()
+    public void Equals_SupportsUndefinedJsonValueNodes()
+    {
+        // Arrange
+        var parameter = new OpenIddictParameter(42);
+
+        // Act and assert
+        Assert.False(parameter.Equals(new OpenIddictParameter((JsonNode?) null)));
+    }
+#endif
+
+    [Fact]
+    public void Equals_SupportsJsonValueElements()
     {
         // Arrange
         var parameter = new OpenIddictParameter(42);
@@ -207,6 +418,25 @@ public class OpenIddictParameterTests
             JsonSerializer.Deserialize<JsonElement>(@"{""field"":100}").GetProperty("field"))));
     }
 
+#if SUPPORTS_JSON_NODES
+    [Fact]
+    public void Equals_SupportsJsonValueNodes()
+    {
+        // Arrange
+        var parameter = new OpenIddictParameter(42);
+
+        // Act and assert
+        Assert.True(parameter.Equals(new OpenIddictParameter(JsonValue.Create(42))));
+        Assert.False(parameter.Equals(new OpenIddictParameter(JsonValue.Create(100))));
+
+        Assert.True(parameter.Equals(new OpenIddictParameter(JsonValue.Create(
+            JsonSerializer.Deserialize<JsonElement>(@"{""field"":42}").GetProperty("field")))));
+
+        Assert.False(parameter.Equals(new OpenIddictParameter(JsonValue.Create(
+            JsonSerializer.Deserialize<JsonElement>(@"{""field"":100}").GetProperty("field")))));
+    }
+#endif
+
     [Fact]
     public void Equals_ReturnsFalseForNonParameters()
     {
@@ -228,27 +458,141 @@ public class OpenIddictParameterTests
     }
 
     [Fact]
-    public void GetHashCode_ReturnsHashCodeValue()
+    public void GetHashCode_ReturnsUnderlyingHashCodeForPrimitiveValues()
     {
-        // Arrange
-        var value = "Fabrikam";
-        var parameter = new OpenIddictParameter(value);
+        // Arrange, act and assert
+        Assert.Equal(1, new OpenIddictParameter(true).GetHashCode());
+        Assert.Equal(0, new OpenIddictParameter(false).GetHashCode());
+        Assert.Equal(42.GetHashCode(), new OpenIddictParameter(42).GetHashCode());
+        Assert.Equal("Fabrikam".GetHashCode(), new OpenIddictParameter("Fabrikam").GetHashCode());
 
-        // Act and assert
-        Assert.Equal(value.GetHashCode(), parameter.GetHashCode());
+        Assert.NotEqual(1, new OpenIddictParameter("true").GetHashCode());
+        Assert.NotEqual(0, new OpenIddictParameter("false").GetHashCode());
+        Assert.NotEqual(42.GetHashCode(), new OpenIddictParameter("42").GetHashCode());
+        Assert.NotEqual("Fabrikam".GetHashCode(), new OpenIddictParameter(42).GetHashCode());
     }
 
     [Fact]
-    public void GetHashCode_ReturnsUnderlyingJsonValueHashCode()
+    public void GetHashCode_ReturnsUnderlyingHashCodeForArrays()
     {
-        // Arrange
-        var value = "Fabrikam";
-        var parameter = new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>(@"{""field"":""Fabrikam""}").GetProperty("field"));
+        // Arrange, act and assert
+        Assert.Equal(
+            new OpenIddictParameter(new string[] { "Fabrikam", "Contoso" }).GetHashCode(),
+            new OpenIddictParameter(new string[] { "Fabrikam", "Contoso" }).GetHashCode());
 
-        // Act and assert
-        Assert.Equal(value.GetHashCode(), parameter.GetHashCode());
+        Assert.NotEqual(
+            new OpenIddictParameter(new string[] { "Fabrikam", "Contoso" }).GetHashCode(),
+            new OpenIddictParameter(new string[] { "Contoso", "Fabrikam" }).GetHashCode());
     }
 
+    [Fact]
+    public void GetHashCode_ReturnsUnderlyingHashCodeForJsonElements()
+    {
+        // Arrange, act and assert
+        Assert.Equal(
+            new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>(
+                @"{""field"":""Fabrikam""}").GetProperty("field")).GetHashCode(),
+            new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>(
+                @"{""field"":""Fabrikam""}").GetProperty("field")).GetHashCode());
+
+        Assert.Equal(
+            new OpenIddictParameter("Fabrikam").GetHashCode(),
+            new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>(
+                @"{""field"":""Fabrikam""}").GetProperty("field")).GetHashCode());
+
+        Assert.NotEqual(
+            new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>(
+                @"{""field"":""Fabrikam""}").GetProperty("field")).GetHashCode(),
+            new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>(
+                @"{""field"":""Contoso""}").GetProperty("field")).GetHashCode());
+
+        Assert.NotEqual(
+            new OpenIddictParameter("Fabrikam").GetHashCode(),
+            new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>(
+                @"{""field"":""Contoso""}").GetProperty("field")).GetHashCode());
+
+        Assert.Equal(
+            new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>(
+                @"{""field"":""Fabrikam""}")).GetHashCode(),
+            new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>(
+                @"{""field"":""Fabrikam""}")).GetHashCode());
+
+        Assert.NotEqual(
+            new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>(
+                @"{""field"":""Fabrikam""}")).GetHashCode(),
+            new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>(
+                @"{""field"":""Contoso""}")).GetHashCode());
+
+        Assert.Equal(
+            new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>(
+                @"[""Fabrikam"",""Contoso""]")).GetHashCode(),
+            new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>(
+                @"[""Fabrikam"",""Contoso""]")).GetHashCode());
+
+        Assert.Equal(
+            new OpenIddictParameter(new[] { "Fabrikam", "Contoso" }).GetHashCode(),
+            new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>(
+                @"[""Fabrikam"",""Contoso""]")).GetHashCode());
+
+        Assert.NotEqual(
+            new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>(
+                @"[""Fabrikam"",""Contoso""]")).GetHashCode(),
+            new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>(
+                @"[""Contoso"",""Fabrikam""]")).GetHashCode());
+
+        Assert.NotEqual(
+            new OpenIddictParameter(new[] { "Fabrikam", "Contoso" }).GetHashCode(),
+            new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>(
+                @"[""Contoso"",""Fabrikam""]")).GetHashCode());
+    }
+
+#if SUPPORTS_JSON_NODES
+    [Fact]
+    public void GetHashCode_ReturnsUnderlyingHashCodeForJsonNodes()
+    {
+        // Arrange, act and assert
+        Assert.Equal(
+            new OpenIddictParameter(JsonValue.Create(true)).GetHashCode(),
+            new OpenIddictParameter(JsonValue.Create(true)).GetHashCode());
+
+        Assert.Equal(
+            new OpenIddictParameter(true).GetHashCode(),
+            new OpenIddictParameter(JsonValue.Create(true)).GetHashCode());
+
+        Assert.NotEqual(
+            new OpenIddictParameter(JsonValue.Create(true)).GetHashCode(),
+            new OpenIddictParameter(JsonValue.Create(false)).GetHashCode());
+
+        Assert.NotEqual(
+            new OpenIddictParameter(true).GetHashCode(),
+            new OpenIddictParameter(JsonValue.Create(false)).GetHashCode());
+
+        Assert.Equal(
+            new OpenIddictParameter(JsonValue.Create(42)).GetHashCode(),
+            new OpenIddictParameter(JsonValue.Create(42)).GetHashCode());
+
+        Assert.Equal(
+            new OpenIddictParameter(42).GetHashCode(),
+            new OpenIddictParameter(JsonValue.Create(42)).GetHashCode());
+
+        Assert.NotEqual(
+            new OpenIddictParameter(JsonValue.Create(42)).GetHashCode(),
+            new OpenIddictParameter(JsonValue.Create(0)).GetHashCode());
+
+        Assert.NotEqual(
+            new OpenIddictParameter(42).GetHashCode(),
+            new OpenIddictParameter(JsonValue.Create(0)).GetHashCode());
+
+        Assert.Equal(
+            new OpenIddictParameter(JsonValue.Create(new { field = "value" })).GetHashCode(),
+            new OpenIddictParameter(JsonValue.Create(new { field = "value" })).GetHashCode());
+
+        Assert.NotEqual(
+            new OpenIddictParameter(JsonValue.Create(new { field = "value" })).GetHashCode(),
+            new OpenIddictParameter(JsonValue.Create(new { field = "abc" })).GetHashCode());
+    }
+#endif
+
     [Theory]
     [InlineData(null)]
     [InlineData("")]
@@ -300,7 +644,7 @@ public class OpenIddictParameterTests
     }
 
     [Fact]
-    public void GetNamedParameter_ReturnsNullForJsonArrays()
+    public void GetNamedParameter_ReturnsNullForJsonArrayElements()
     {
         // Arrange
         var parameter = new OpenIddictParameter(
@@ -310,8 +654,20 @@ public class OpenIddictParameterTests
         Assert.Null(parameter.GetNamedParameter("Fabrikam"));
     }
 
+#if SUPPORTS_JSON_NODES
     [Fact]
-    public void GetNamedParameter_ReturnsExpectedParameterForJsonObject()
+    public void GetNamedParameter_ReturnsNullForJsonArrayNodes()
+    {
+        // Arrange
+        var parameter = new OpenIddictParameter(new JsonArray("Fabrikam", "Contoso"));
+
+        // Act and assert
+        Assert.Null(parameter.GetNamedParameter("Fabrikam"));
+    }
+#endif
+
+    [Fact]
+    public void GetNamedParameter_ReturnsExpectedParameterForJsonObjectElements()
     {
         // Arrange
         var parameter = new OpenIddictParameter(
@@ -321,6 +677,21 @@ public class OpenIddictParameterTests
         Assert.Equal("value", (string?) parameter.GetNamedParameter("parameter"));
     }
 
+#if SUPPORTS_JSON_NODES
+    [Fact]
+    public void GetNamedParameter_ReturnsExpectedParameterForJsonObjectNodes()
+    {
+        // Arrange
+        var parameter = new OpenIddictParameter(new JsonObject
+        {
+            ["parameter"] = "value"
+        });
+
+        // Act and assert
+        Assert.Equal("value", (string?) parameter.GetNamedParameter("parameter"));
+    }
+#endif
+
     [Fact]
     public void GetUnnamedParameter_ThrowsAnExceptionForNegativeIndex()
     {
@@ -374,7 +745,7 @@ public class OpenIddictParameterTests
     }
 
     [Fact]
-    public void GetUnnamedParameter_ReturnsNullForOutOfRangeJsonArrayIndex()
+    public void GetUnnamedParameter_ReturnsNullForOutOfRangeJsonArrayElementIndex()
     {
         // Arrange
         var parameter = new OpenIddictParameter(
@@ -384,8 +755,20 @@ public class OpenIddictParameterTests
         Assert.Null(parameter.GetUnnamedParameter(2));
     }
 
+#if SUPPORTS_JSON_NODES
     [Fact]
-    public void GetUnnamedParameter_ReturnsNullForJsonObjects()
+    public void GetUnnamedParameter_ReturnsNullForOutOfRangeJsonArrayNodeIndex()
+    {
+        // Arrange
+        var parameter = new OpenIddictParameter(new JsonArray("Fabrikam", "Contoso"));
+
+        // Act and assert
+        Assert.Null(parameter.GetUnnamedParameter(2));
+    }
+#endif
+
+    [Fact]
+    public void GetUnnamedParameter_ReturnsNullForJsonObjectElements()
     {
         // Arrange
         var parameter = new OpenIddictParameter(
@@ -395,8 +778,23 @@ public class OpenIddictParameterTests
         Assert.Null(parameter.GetUnnamedParameter(0));
     }
 
+#if SUPPORTS_JSON_NODES
     [Fact]
-    public void GetUnnamedParameter_ReturnsExpectedNodeForJsonArray()
+    public void GetUnnamedParameter_ReturnsNullForJsonObjectNodes()
+    {
+        // Arrange
+        var parameter = new OpenIddictParameter(new JsonObject
+        {
+            ["parameter"] = "value"
+        });
+
+        // Act and assert
+        Assert.Null(parameter.GetUnnamedParameter(0));
+    }
+#endif
+
+    [Fact]
+    public void GetUnnamedParameter_ReturnsExpectedNodeForJsonArrayElements()
     {
         // Arrange
         var parameter = new OpenIddictParameter(
@@ -406,6 +804,18 @@ public class OpenIddictParameterTests
         Assert.Equal("Fabrikam", (string?) parameter.GetUnnamedParameter(0));
     }
 
+#if SUPPORTS_JSON_NODES
+    [Fact]
+    public void GetUnnamedParameter_ReturnsExpectedNodeForJsonArrayNodes()
+    {
+        // Arrange
+        var parameter = new OpenIddictParameter(new JsonArray("Fabrikam", "Contoso"));
+
+        // Act and assert
+        Assert.Equal("Fabrikam", (string?) parameter.GetUnnamedParameter(0));
+    }
+#endif
+
     [Fact]
     public void GetNamedParameters_ReturnsEmptyDictionaryForPrimitiveValues()
     {
@@ -433,7 +843,7 @@ public class OpenIddictParameterTests
     }
 
     [Fact]
-    public void GetNamedParameters_ReturnsEmptyDictionaryForJsonValues()
+    public void GetNamedParameters_ReturnsEmptyDictionaryForJsonValueElements()
     {
         // Arrange
         var parameter = new OpenIddictParameter(
@@ -443,8 +853,20 @@ public class OpenIddictParameterTests
         Assert.Empty(parameter.GetNamedParameters());
     }
 
+#if SUPPORTS_JSON_NODES
     [Fact]
-    public void GetNamedParameters_ReturnsEmptyDictionaryForJsonArrays()
+    public void GetNamedParameters_ReturnsEmptyDictionaryForJsonValueNodes()
+    {
+        // Arrange
+        var parameter = new OpenIddictParameter(JsonValue.Create(42));
+
+        // Act and assert
+        Assert.Empty(parameter.GetNamedParameters());
+    }
+#endif
+
+    [Fact]
+    public void GetNamedParameters_ReturnsEmptyDictionaryForJsonArrayElements()
     {
         // Arrange
         var parameter = new OpenIddictParameter(
@@ -454,8 +876,20 @@ public class OpenIddictParameterTests
         Assert.Empty(parameter.GetNamedParameters());
     }
 
+#if SUPPORTS_JSON_NODES
     [Fact]
-    public void GetNamedParameters_ReturnsExpectedParametersForJsonObjects()
+    public void GetNamedParameters_ReturnsEmptyDictionaryForJsonArrayNodes()
+    {
+        // Arrange
+        var parameter = new OpenIddictParameter(new JsonArray("Fabrikam", "Contoso"));
+
+        // Act and assert
+        Assert.Empty(parameter.GetNamedParameters());
+    }
+#endif
+
+    [Fact]
+    public void GetNamedParameters_ReturnsExpectedParametersForJsonObjectElements()
     {
         // Arrange
         var parameters = new Dictionary<string, string?>
@@ -470,8 +904,28 @@ public class OpenIddictParameterTests
         Assert.Equal(parameters, parameter.GetNamedParameters().ToDictionary(pair => pair.Key, pair => (string?) pair.Value));
     }
 
+#if SUPPORTS_JSON_NODES
+    [Fact]
+    public void GetNamedParameters_ReturnsExpectedParametersForJsonObjectNodes()
+    {
+        // Arrange
+        var parameters = new Dictionary<string, string?>
+        {
+            ["parameter"] = "value"
+        };
+
+        var parameter = new OpenIddictParameter(new JsonObject
+        {
+            ["parameter"] = "value"
+        });
+
+        // Act and assert
+        Assert.Equal(parameters, parameter.GetNamedParameters().ToDictionary(pair => pair.Key, pair => (string?) pair.Value));
+    }
+#endif
+
     [Fact]
-    public void GetNamedParameters_ReturnsLastOccurrenceOfMultipleParameters()
+    public void GetNamedParameters_ReturnsLastOccurrenceOfMultipleElementParameters()
     {
         // Arrange
         var parameter = new OpenIddictParameter(
@@ -481,6 +935,22 @@ public class OpenIddictParameterTests
         Assert.Equal("value_2", parameter.GetNamedParameters()["parameter"]);
     }
 
+#if SUPPORTS_JSON_NODES
+    [Fact]
+    public void GetNamedParameters_ReturnsLastOccurrenceOfMultipleNodeParameters()
+    {
+        // Arrange
+        var parameter = new OpenIddictParameter(new JsonObject
+        {
+            ["parameter"] = "value_1",
+            ["parameter"] = "value_2"
+        });
+
+        // Act and assert
+        Assert.Equal("value_2", parameter.GetNamedParameters()["parameter"]);
+    }
+#endif
+
     [Fact]
     public void GetUnnamedParameters_ReturnsEmptyListForPrimitiveValues()
     {
@@ -509,7 +979,7 @@ public class OpenIddictParameterTests
     }
 
     [Fact]
-    public void GetUnnamedParameters_ReturnsEmptyListForJsonValues()
+    public void GetUnnamedParameters_ReturnsEmptyListForJsonValueElements()
     {
         // Arrange
         var parameter = new OpenIddictParameter(
@@ -519,8 +989,20 @@ public class OpenIddictParameterTests
         Assert.Empty(parameter.GetUnnamedParameters());
     }
 
+#if SUPPORTS_JSON_NODES
+    [Fact]
+    public void GetUnnamedParameters_ReturnsEmptyListForJsonValueNodes()
+    {
+        // Arrange
+        var parameter = new OpenIddictParameter(JsonValue.Create(42));
+
+        // Act and assert
+        Assert.Empty(parameter.GetUnnamedParameters());
+    }
+#endif
+
     [Fact]
-    public void GetUnnamedParameters_ReturnsExpectedParametersForJsonArrays()
+    public void GetUnnamedParameters_ReturnsExpectedParametersForJsonArrayElements()
     {
         // Arrange
         var parameters = new[]
@@ -537,8 +1019,27 @@ public class OpenIddictParameterTests
                                  select (string?) element);
     }
 
+#if SUPPORTS_JSON_NODES
     [Fact]
-    public void GetUnnamedParameters_ReturnsEmptyListForJsonObjects()
+    public void GetUnnamedParameters_ReturnsExpectedParametersForJsonArrayNodes()
+    {
+        // Arrange
+        var parameters = new[]
+        {
+            "Fabrikam",
+            "Contoso"
+        };
+
+        var parameter = new OpenIddictParameter(new JsonArray("Fabrikam", "Contoso"));
+
+        // Act and assert
+        Assert.Equal(parameters, from element in parameter.GetUnnamedParameters()
+                                 select (string?) element);
+    }
+#endif
+
+    [Fact]
+    public void GetUnnamedParameters_ReturnsEmptyListForJsonObjectElements()
     {
         // Arrange
         var parameter = new OpenIddictParameter(
@@ -548,6 +1049,21 @@ public class OpenIddictParameterTests
         Assert.Empty(parameter.GetUnnamedParameters());
     }
 
+#if SUPPORTS_JSON_NODES
+    [Fact]
+    public void GetUnnamedParameters_ReturnsEmptyListForJsonObjectNodes()
+    {
+        // Arrange
+        var parameter = new OpenIddictParameter(new JsonObject
+        {
+            ["parameter"] = "value"
+        });
+
+        // Act and assert
+        Assert.Empty(parameter.GetUnnamedParameters());
+    }
+#endif
+
     [Fact]
     public void IsNullOrEmpty_ReturnsTrueForNullValues()
     {
@@ -555,7 +1071,7 @@ public class OpenIddictParameterTests
         Assert.True(OpenIddictParameter.IsNullOrEmpty(new OpenIddictParameter((bool?) null)));
         Assert.True(OpenIddictParameter.IsNullOrEmpty(new OpenIddictParameter((long?) null)));
         Assert.True(OpenIddictParameter.IsNullOrEmpty(new OpenIddictParameter((string?) null)));
-        Assert.True(OpenIddictParameter.IsNullOrEmpty(new OpenIddictParameter((string[]?) null)));
+        Assert.True(OpenIddictParameter.IsNullOrEmpty(new OpenIddictParameter((string?[]?) null)));
     }
 
     [Fact]
@@ -563,6 +1079,10 @@ public class OpenIddictParameterTests
     {
         // Arrange, act and assert
         Assert.True(OpenIddictParameter.IsNullOrEmpty(new OpenIddictParameter(default(JsonElement))));
+
+#if SUPPORTS_JSON_NODES
+        Assert.True(OpenIddictParameter.IsNullOrEmpty(new OpenIddictParameter((JsonNode?) null)));
+#endif
     }
 
     [Fact]
@@ -578,6 +1098,15 @@ public class OpenIddictParameterTests
             JsonSerializer.Deserialize<JsonElement>("{}"))));
         Assert.True(OpenIddictParameter.IsNullOrEmpty(new OpenIddictParameter(
             JsonSerializer.Deserialize<JsonElement>(@"{""field"":""""}").GetProperty("field"))));
+
+#if SUPPORTS_JSON_NODES
+        Assert.True(OpenIddictParameter.IsNullOrEmpty(new OpenIddictParameter(new JsonArray())));
+        Assert.True(OpenIddictParameter.IsNullOrEmpty(new OpenIddictParameter(new JsonObject())));
+        Assert.True(OpenIddictParameter.IsNullOrEmpty(new OpenIddictParameter(JsonValue.Create(string.Empty))));
+
+        Assert.True(OpenIddictParameter.IsNullOrEmpty(new OpenIddictParameter(JsonValue.Create(
+            JsonSerializer.Deserialize<JsonElement>(@"{""field"":""""}").GetProperty("field")))));
+#endif
     }
 
     [Fact]
@@ -597,6 +1126,20 @@ public class OpenIddictParameterTests
             JsonSerializer.Deserialize<JsonElement>(@"{""field"":""Fabrikam""}"))));
         Assert.False(OpenIddictParameter.IsNullOrEmpty(new OpenIddictParameter(
             JsonSerializer.Deserialize<JsonElement>(@"{""field"":""Fabrikam""}").GetProperty("field"))));
+
+#if SUPPORTS_JSON_NODES
+        Assert.False(OpenIddictParameter.IsNullOrEmpty(new OpenIddictParameter(new JsonArray("Fabrikam"))));
+
+        Assert.False(OpenIddictParameter.IsNullOrEmpty(new OpenIddictParameter(new JsonObject
+        {
+            ["field"] = "Fabrikam"
+        })));
+
+        Assert.False(OpenIddictParameter.IsNullOrEmpty(new OpenIddictParameter(JsonValue.Create(
+            JsonSerializer.Deserialize<JsonElement>(@"{""field"":""Fabrikam""}").GetProperty("field")))));
+
+        Assert.False(OpenIddictParameter.IsNullOrEmpty(new OpenIddictParameter(JsonValue.Create("Fabrikam"))));
+#endif
     }
 
     [Fact]
@@ -663,7 +1206,7 @@ public class OpenIddictParameterTests
     }
 
     [Fact]
-    public void ToString_ReturnsEmptyStringForNullJsonValues()
+    public void ToString_ReturnsEmptyStringForNullJsonValueElements()
     {
         // Arrange
         var parameter = new OpenIddictParameter(
@@ -674,7 +1217,7 @@ public class OpenIddictParameterTests
     }
 
     [Fact]
-    public void ToString_ReturnsEmptyStringForUndefinedJsonValues()
+    public void ToString_ReturnsEmptyStringForUndefinedJsonValueElements()
     {
         // Arrange
         var parameter = new OpenIddictParameter(default(JsonElement));
@@ -683,6 +1226,18 @@ public class OpenIddictParameterTests
         Assert.Empty(parameter.ToString());
     }
 
+#if SUPPORTS_JSON_NODES
+    [Fact]
+    public void ToString_ReturnsEmptyStringForUndefinedJsonValueNodes()
+    {
+        // Arrange
+        var parameter = new OpenIddictParameter((JsonNode?) null);
+
+        // Act and assert
+        Assert.Empty(parameter.ToString());
+    }
+#endif
+
     [Fact]
     public void ToString_ReturnsUnderlyingJsonValue()
     {
@@ -697,6 +1252,30 @@ public class OpenIddictParameterTests
             JsonSerializer.Deserialize<JsonElement>(@"{""field"":[""Fabrikam"",""Contoso""]}").GetProperty("field")).ToString());
         Assert.Equal(@"{""field"":""value""}", new OpenIddictParameter(
             JsonSerializer.Deserialize<JsonElement>(@"{""field"":""value""}")).ToString());
+
+#if SUPPORTS_JSON_NODES
+        Assert.Equal(bool.TrueString, new OpenIddictParameter(JsonValue.Create(true)).ToString());
+        Assert.Equal(bool.FalseString, new OpenIddictParameter(JsonValue.Create(false)).ToString());
+        Assert.Equal("Fabrikam", new OpenIddictParameter(JsonValue.Create("Fabrikam")).ToString());
+        Assert.Equal(@"[""Fabrikam"",""Contoso""]", new OpenIddictParameter(new JsonArray("Fabrikam", "Contoso")).ToString());
+
+        Assert.Equal(@"{""field"":""value""}", new OpenIddictParameter(new JsonObject
+        {
+            ["field"] = "value"
+        }).ToString());
+
+        Assert.Equal(@"{""field"":""value""}", new OpenIddictParameter(JsonValue.Create(new
+        {
+            field = "value"
+        })).ToString());
+
+        Assert.Equal(bool.TrueString, new OpenIddictParameter(JsonValue.Create(
+            JsonSerializer.Deserialize<JsonElement>(@"{""field"":true}").GetProperty("field"))).ToString());
+        Assert.Equal(bool.FalseString, new OpenIddictParameter(JsonValue.Create(
+            JsonSerializer.Deserialize<JsonElement>(@"{""field"":false}").GetProperty("field"))).ToString());
+        Assert.Equal("Fabrikam", new OpenIddictParameter(JsonValue.Create(
+            JsonSerializer.Deserialize<JsonElement>(@"{""field"":""Fabrikam""}").GetProperty("field"))).ToString());
+#endif
     }
 
     [Theory]
@@ -753,7 +1332,7 @@ public class OpenIddictParameterTests
     }
 
     [Fact]
-    public void TryGetNamedParameter_ReturnsFalseForJsonArrays()
+    public void TryGetNamedParameter_ReturnsFalseForJsonArrayElements()
     {
         // Arrange
         var parameter = new OpenIddictParameter(
@@ -764,8 +1343,21 @@ public class OpenIddictParameterTests
         Assert.Equal(default, value);
     }
 
+#if SUPPORTS_JSON_NODES
     [Fact]
-    public void TryGetNamedParameter_ReturnsExpectedParameterForJsonObject()
+    public void TryGetNamedParameter_ReturnsFalseForJsonArrayNodes()
+    {
+        // Arrange
+        var parameter = new OpenIddictParameter(new JsonArray("Fabrikam", "Contoso"));
+
+        // Act and assert
+        Assert.False(parameter.TryGetNamedParameter("Fabrikam", out var value));
+        Assert.Equal(default, value);
+    }
+#endif
+
+    [Fact]
+    public void TryGetNamedParameter_ReturnsExpectedParameterForJsonObjectElements()
     {
         // Arrange
         var parameter = new OpenIddictParameter(
@@ -776,6 +1368,22 @@ public class OpenIddictParameterTests
         Assert.Equal("value", (string?) value);
     }
 
+#if SUPPORTS_JSON_NODES
+    [Fact]
+    public void TryGetNamedParameter_ReturnsExpectedParameterForJsonObjectNodes()
+    {
+        // Arrange
+        var parameter = new OpenIddictParameter(new JsonObject
+        {
+            ["parameter"] = "value"
+        });
+
+        // Act and assert
+        Assert.True(parameter.TryGetNamedParameter("parameter", out var value));
+        Assert.Equal("value", (string?) value);
+    }
+#endif
+
     [Fact]
     public void TryGetUnnamedParameter_ThrowsAnExceptionForNegativeIndex()
     {
@@ -832,7 +1440,7 @@ public class OpenIddictParameterTests
     }
 
     [Fact]
-    public void TryGetUnnamedParameter_ReturnsFalseForOutOfRangeJsonArrayIndex()
+    public void TryGetUnnamedParameter_ReturnsFalseForOutOfRangeJsonArrayElementIndex()
     {
         // Arrange
         var parameter = new OpenIddictParameter(
@@ -843,8 +1451,21 @@ public class OpenIddictParameterTests
         Assert.Equal(default, value);
     }
 
+#if SUPPORTS_JSON_NODES
     [Fact]
-    public void TryGetUnnamedParameter_ReturnsFalseForJsonObjects()
+    public void TryGetUnnamedParameter_ReturnsFalseForOutOfRangeJsonArrayNodeIndex()
+    {
+        // Arrange
+        var parameter = new OpenIddictParameter(new JsonArray("Fabrikam", "Contoso"));
+
+        // Act and assert
+        Assert.False(parameter.TryGetUnnamedParameter(2, out var value));
+        Assert.Equal(default, value);
+    }
+#endif
+
+    [Fact]
+    public void TryGetUnnamedParameter_ReturnsFalseForJsonObjectElements()
     {
         // Arrange
         var parameter = new OpenIddictParameter(
@@ -855,8 +1476,24 @@ public class OpenIddictParameterTests
         Assert.Equal(default, value);
     }
 
+#if SUPPORTS_JSON_NODES
     [Fact]
-    public void TryGetUnnamedParameter_ReturnsExpectedNodeForJsonArray()
+    public void TryGetUnnamedParameter_ReturnsFalseForJsonObjectNodes()
+    {
+        // Arrange
+        var parameter = new OpenIddictParameter(new JsonObject
+        {
+            ["parameter"] = "value"
+        });
+
+        // Act and assert
+        Assert.False(parameter.TryGetUnnamedParameter(0, out var value));
+        Assert.Equal(default, value);
+    }
+#endif
+
+    [Fact]
+    public void TryGetUnnamedParameter_ReturnsExpectedNodeForJsonArrayElements()
     {
         // Arrange
         var parameter = new OpenIddictParameter(
@@ -867,6 +1504,19 @@ public class OpenIddictParameterTests
         Assert.Equal("Fabrikam", (string?) value);
     }
 
+#if SUPPORTS_JSON_NODES
+    [Fact]
+    public void TryGetUnnamedParameter_ReturnsExpectedNodeForJsonArrayNodes()
+    {
+        // Arrange
+        var parameter = new OpenIddictParameter(new JsonArray("Fabrikam", "Contoso"));
+
+        // Act and assert
+        Assert.True(parameter.TryGetUnnamedParameter(0, out var value));
+        Assert.Equal("Fabrikam", (string?) value);
+    }
+#endif
+
     [Fact]
     public void WriteTo_ThrowsAnExceptionForNullWriter()
     {
@@ -944,6 +1594,15 @@ public class OpenIddictParameterTests
         // Arrange, act and assert
         Assert.False((bool) new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>("[]")));
         Assert.Null((bool?) new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>("[]")));
+        Assert.False((bool) new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>("{}")));
+        Assert.Null((bool?) new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>("{}")));
+
+#if SUPPORTS_JSON_NODES
+        Assert.False((bool) new OpenIddictParameter(new JsonObject()));
+        Assert.Null((bool?) new OpenIddictParameter(new JsonObject()));
+        Assert.False((bool) new OpenIddictParameter(new JsonArray()));
+        Assert.Null((bool?) new OpenIddictParameter(new JsonArray()));
+#endif
     }
 
     [Fact]
@@ -982,6 +1641,36 @@ public class OpenIddictParameterTests
             JsonSerializer.Deserialize<JsonElement>(@"{""field"":""false""}").GetProperty("field")));
         Assert.False((bool?) new OpenIddictParameter(
             JsonSerializer.Deserialize<JsonElement>(@"{""field"":""false""}").GetProperty("field")));
+
+#if SUPPORTS_JSON_NODES
+        Assert.True((bool) new OpenIddictParameter(JsonValue.Create(true)));
+        Assert.True((bool?) new OpenIddictParameter(JsonValue.Create(true)));
+        Assert.True((bool) new OpenIddictParameter(JsonValue.Create("true")));
+        Assert.True((bool?) new OpenIddictParameter(JsonValue.Create("true")));
+
+        Assert.False((bool) new OpenIddictParameter(JsonValue.Create(false)));
+        Assert.False((bool?) new OpenIddictParameter(JsonValue.Create(false)));
+        Assert.False((bool) new OpenIddictParameter(JsonValue.Create("false")));
+        Assert.False((bool?) new OpenIddictParameter(JsonValue.Create("false")));
+
+        Assert.True((bool) new OpenIddictParameter(JsonValue.Create(
+            JsonSerializer.Deserialize<JsonElement>(@"{""field"":true}").GetProperty("field"))));
+        Assert.True((bool?) new OpenIddictParameter(JsonValue.Create(
+            JsonSerializer.Deserialize<JsonElement>(@"{""field"":true}").GetProperty("field"))));
+        Assert.True((bool) new OpenIddictParameter(JsonValue.Create(
+            JsonSerializer.Deserialize<JsonElement>(@"{""field"":""true""}").GetProperty("field"))));
+        Assert.True((bool?) new OpenIddictParameter(JsonValue.Create(
+            JsonSerializer.Deserialize<JsonElement>(@"{""field"":""true""}").GetProperty("field"))));
+
+        Assert.False((bool) new OpenIddictParameter(JsonValue.Create(
+            JsonSerializer.Deserialize<JsonElement>(@"{""field"":false}").GetProperty("field"))));
+        Assert.False((bool?) new OpenIddictParameter(JsonValue.Create(
+            JsonSerializer.Deserialize<JsonElement>(@"{""field"":false}").GetProperty("field"))));
+        Assert.False((bool) new OpenIddictParameter(JsonValue.Create(
+            JsonSerializer.Deserialize<JsonElement>(@"{""field"":""false""}").GetProperty("field"))));
+        Assert.False((bool?) new OpenIddictParameter(JsonValue.Create(
+            JsonSerializer.Deserialize<JsonElement>(@"{""field"":""false""}").GetProperty("field"))));
+#endif
     }
 
     [Fact]
@@ -999,6 +1688,47 @@ public class OpenIddictParameterTests
         Assert.Equal(JsonValueKind.Undefined, ((JsonElement) new OpenIddictParameter(new JsonElement())).ValueKind);
     }
 
+    [Fact]
+    public void JsonElementConverter_CanConvertFromPrimitiveValues()
+    {
+        // Arrange, act and assert
+        Assert.Equal(JsonValueKind.True, ((JsonElement) new OpenIddictParameter(true)).ValueKind);
+        Assert.True(((JsonElement) new OpenIddictParameter(true)).GetBoolean());
+
+        Assert.Equal(JsonValueKind.Number, ((JsonElement) new OpenIddictParameter(42)).ValueKind);
+        Assert.Equal(42L, ((JsonElement) new OpenIddictParameter(42)).GetInt64());
+
+        Assert.Equal(JsonValueKind.String, ((JsonElement) new OpenIddictParameter(string.Empty)).ValueKind);
+        Assert.Empty(((JsonElement) new OpenIddictParameter(string.Empty)).GetString());
+
+        Assert.Equal(JsonValueKind.String, ((JsonElement) new OpenIddictParameter("value")).ValueKind);
+        Assert.Equal("value", ((JsonElement) new OpenIddictParameter("value")).GetString());
+
+        Assert.Equal(JsonValueKind.String, ((JsonElement) new OpenIddictParameter("true")).ValueKind);
+        Assert.Equal("true", ((JsonElement) new OpenIddictParameter("true")).GetString());
+
+        Assert.Equal(JsonValueKind.String, ((JsonElement) new OpenIddictParameter("42")).ValueKind);
+        Assert.Equal("42", ((JsonElement) new OpenIddictParameter("42")).GetString());
+
+        Assert.Equal(JsonValueKind.String, ((JsonElement) new OpenIddictParameter("{abc}")).ValueKind);
+        Assert.Equal("{abc}", ((JsonElement) new OpenIddictParameter("{abc}")).GetString());
+
+        Assert.Equal(JsonValueKind.String, ((JsonElement) new OpenIddictParameter("[abc]")).ValueKind);
+        Assert.Equal("[abc]", ((JsonElement) new OpenIddictParameter("[abc]")).GetString());
+    }
+
+    [Fact]
+    public void JsonElementConverter_CanConvertFromArrays()
+    {
+        // Arrange and act
+        var array = (JsonElement) new OpenIddictParameter(new[] { "Contoso", "Fabrikam" });
+
+        // Assert
+        Assert.Equal(2, array.GetArrayLength());
+        Assert.Equal("Contoso", array[0].GetString());
+        Assert.Equal("Fabrikam", array[1].GetString());
+    }
+
     [Fact]
     public void JsonElementConverter_CanConvertFromJsonValues()
     {
@@ -1036,17 +1766,193 @@ public class OpenIddictParameterTests
         Assert.Equal("value", dictionary.GetProperty("Property").GetString());
     }
 
+#if SUPPORTS_JSON_NODES
     [Fact]
-    public void JsonElementConverter_CanConvertFromArrays()
+    public void JsonNodeConverter_ReturnsDefaultValueForNullValues()
+    {
+        // Arrange, act and assert
+        Assert.Null((JsonNode?) new OpenIddictParameter());
+        Assert.Null((JsonNode?) (OpenIddictParameter?) null);
+    }
+
+    [Fact]
+    public void JsonNodeConverter_CanConvertFromJsonValues()
     {
         // Arrange and act
-        var array = (JsonElement) new OpenIddictParameter(new[] { "Contoso", "Fabrikam" });
+        var array = (JsonNode?) new OpenIddictParameter(new JsonArray("Contoso", "Fabrikam"));
+        var dictionary = (JsonNode?) new OpenIddictParameter(new JsonObject
+        {
+            ["Property"] = "value"
+        });
 
         // Assert
-        Assert.Equal("Contoso", array[0].GetString());
-        Assert.Equal("Fabrikam", array[1].GetString());
+        Assert.Equal("Contoso", array!.AsArray()[0]!.GetValue<string>());
+        Assert.Equal("Fabrikam", array!.AsArray()[1]!.GetValue<string>());
+        Assert.Equal("value", dictionary!.AsObject()["Property"]!.GetValue<string>());
+
+        Assert.True(((JsonNode?) new OpenIddictParameter(JsonValue.Create(true)))!.GetValue<bool>());
+        Assert.Equal(42, ((JsonNode?) new OpenIddictParameter(JsonValue.Create(42)))!.GetValue<int>());
+        Assert.Equal("Fabrikam", ((JsonNode?) new OpenIddictParameter(JsonValue.Create("Fabrikam")))!.GetValue<string>());
+
+        Assert.True(((JsonElement) new OpenIddictParameter(JsonValue.Create(
+            JsonSerializer.Deserialize<JsonElement>(@"{""field"":true}").GetProperty("field")))).GetBoolean());
+
+        Assert.Equal(42, ((JsonElement) new OpenIddictParameter(JsonValue.Create(
+            JsonSerializer.Deserialize<JsonElement>(@"{""field"":42}").GetProperty("field")))).GetInt64());
+
+        Assert.Equal("Fabrikam", ((JsonElement) new OpenIddictParameter(JsonValue.Create(
+            JsonSerializer.Deserialize<JsonElement>(@"{""field"":""Fabrikam""}").GetProperty("field")))).GetString());
     }
 
+    [Fact]
+    public void JsonNodeConverter_CanConvertFromSerializedJson()
+    {
+        // Arrange and act
+        var array = (JsonNode?) new OpenIddictParameter(@"[""Contoso"",""Fabrikam""]");
+        var dictionary = (JsonNode?) new OpenIddictParameter(@"{""Property"":""value""}");
+
+        // Assert
+        Assert.Equal("Contoso", array!.AsArray()[0]!.GetValue<string>());
+        Assert.Equal("Fabrikam", array!.AsArray()[1]!.GetValue<string>());
+        Assert.Equal("value", dictionary!.AsObject()["Property"]!.GetValue<string>());
+    }
+
+    [Fact]
+    public void JsonNodeConverter_CanConvertFromArrays()
+    {
+        // Arrange and act
+        var array = (JsonNode?) new OpenIddictParameter(new[] { "Contoso", "Fabrikam" });
+
+        // Assert
+        Assert.Equal("Contoso", array!.AsArray()[0]!.GetValue<string>());
+        Assert.Equal("Fabrikam", array!.AsArray()[1]!.GetValue<string>());
+    }
+
+    [Fact]
+    public void JsonArrayConverter_ReturnsDefaultValueForNullValues()
+    {
+        // Arrange, act and assert
+        Assert.Null((JsonArray?) new OpenIddictParameter());
+        Assert.Null((JsonArray?) (OpenIddictParameter?) null);
+    }
+
+    [Fact]
+    public void JsonArrayConverter_CanConvertFromJsonArrays()
+    {
+        // Arrange and act
+        var array = (JsonArray?) new OpenIddictParameter(new JsonArray("Contoso", "Fabrikam"));
+
+        // Assert
+        Assert.Equal("Contoso", array![0]!.GetValue<string>());
+        Assert.Equal("Fabrikam", array![1]!.GetValue<string>());
+    }
+
+    [Fact]
+    public void JsonArrayConverter_CanConvertFromSerializedJson()
+    {
+        // Arrange and act
+        var array = (JsonArray?) new OpenIddictParameter(@"[""Contoso"",""Fabrikam""]");
+
+        // Assert
+        Assert.Equal("Contoso", array![0]!.GetValue<string>());
+        Assert.Equal("Fabrikam", array![1]!.GetValue<string>());
+    }
+
+    [Fact]
+    public void JsonArrayConverter_CanConvertFromArrays()
+    {
+        // Arrange and act
+        var array = (JsonArray?) new OpenIddictParameter(new[] { "Contoso", "Fabrikam" });
+
+        // Assert
+        Assert.Equal("Contoso", array![0]!.GetValue<string>());
+        Assert.Equal("Fabrikam", array![1]!.GetValue<string>());
+    }
+
+    [Fact]
+    public void JsonArrayConverter_ReturnsDefaultValueForUnsupportedJsonValues()
+    {
+        // Assert, arrange and act
+        Assert.Null((JsonArray?) new OpenIddictParameter(@"{""Property"":""value""}"));
+        Assert.Null((JsonArray?) new OpenIddictParameter(new JsonObject
+        {
+            ["Property"] = "value"
+        }));
+    }
+
+    [Fact]
+    public void JsonObjectConverter_ReturnsDefaultValueForNullValues()
+    {
+        // Arrange, act and assert
+        Assert.Null((JsonObject?) new OpenIddictParameter());
+        Assert.Null((JsonObject?) (OpenIddictParameter?) null);
+    }
+
+    [Fact]
+    public void JsonObjectConverter_CanConvertFromJsonValues()
+    {
+        // Arrange and act
+        var dictionary = (JsonObject?) new OpenIddictParameter(new JsonObject
+        {
+            ["Property"] = "value"
+        });
+
+        // Assert
+        Assert.Equal("value", dictionary!.AsObject()["Property"]!.GetValue<string>());
+    }
+
+    [Fact]
+    public void JsonObjectConverter_CanConvertFromSerializedJson()
+    {
+        // Arrange and act
+        var dictionary = (JsonObject?) new OpenIddictParameter(@"{""Property"":""value""}");
+
+        // Assert
+        Assert.Equal("value", dictionary!.AsObject()["Property"]!.GetValue<string>());
+    }
+
+    [Fact]
+    public void JsonObjectConverter_ReturnsDefaultValueForUnsupportedJsonValues()
+    {
+        // Assert, arrange and act
+        Assert.Null((JsonObject?) new OpenIddictParameter(@"[""Contoso"",""Fabrikam""]"));
+        Assert.Null((JsonObject?) new OpenIddictParameter(new[] { "Contoso", "Fabrikam" }));
+    }
+
+    [Fact]
+    public void JsonValueConverter_ReturnsDefaultValueForNullValues()
+    {
+        // Arrange, act and assert
+        Assert.Null((JsonValue?) new OpenIddictParameter());
+        Assert.Null((JsonValue?) (OpenIddictParameter?) null);
+    }
+
+    [Fact]
+    public void JsonValueConverter_CanConvertFromPrimitiveValues()
+    {
+        // Arrange, act and assert
+        Assert.True(((JsonValue?) new OpenIddictParameter(JsonValue.Create(true)))!.GetValue<bool>());
+        Assert.Equal(42, ((JsonValue?) new OpenIddictParameter(JsonValue.Create(42)))!.GetValue<int>());
+        Assert.Equal(42L, ((JsonValue?) new OpenIddictParameter(JsonValue.Create(42L)))!.GetValue<long>());
+        Assert.Equal("value", ((JsonValue?) new OpenIddictParameter(JsonValue.Create("value")))!.GetValue<string>());
+    }
+
+    [Fact]
+    public void JsonValueConverter_ReturnsDefaultValueForUnsupportedJsonValues()
+    {
+        // Assert, arrange and act
+        Assert.Null((JsonValue?) new OpenIddictParameter(@"[""Contoso"",""Fabrikam""]"));
+        Assert.Null((JsonValue?) new OpenIddictParameter(new[] { "Contoso", "Fabrikam" }));
+
+        Assert.Null((JsonValue?) new OpenIddictParameter(@"{""Property"":""value""}"));
+
+        Assert.Null((JsonValue?) new OpenIddictParameter(new JsonObject
+        {
+            ["Property"] = "value"
+        }));
+    }
+#endif
+
     [Fact]
     public void LongConverter_CanCreateParameterFromLongValue()
     {
@@ -1085,6 +1991,11 @@ public class OpenIddictParameterTests
         // Arrange, act and assert
         Assert.Equal(0, (long) new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>("[]")));
         Assert.Null((long?) new OpenIddictParameter(JsonSerializer.Deserialize<JsonElement>("[]")));
+
+#if SUPPORTS_JSON_NODES
+        Assert.Equal(0, (long) new OpenIddictParameter(new JsonArray()));
+        Assert.Null((long?) new OpenIddictParameter(new JsonArray()));
+#endif
     }
 
     [Fact]
@@ -1105,6 +2016,18 @@ public class OpenIddictParameterTests
             JsonSerializer.Deserialize<JsonElement>(@"{""field"":42}").GetProperty("field")));
         Assert.Equal(42, (long?) new OpenIddictParameter(
             JsonSerializer.Deserialize<JsonElement>(@"{""field"":42}").GetProperty("field")));
+
+#if SUPPORTS_JSON_NODES
+        Assert.Equal(42, (long?) new OpenIddictParameter(JsonValue.Create(42)));
+        Assert.Equal(42, (long?) new OpenIddictParameter(JsonValue.Create(42)));
+        Assert.Equal(42, (long?) new OpenIddictParameter(JsonValue.Create(42L)));
+        Assert.Equal(42, (long?) new OpenIddictParameter(JsonValue.Create(42L)));
+
+        Assert.Equal(42, (long?) new OpenIddictParameter(JsonValue.Create(
+            JsonSerializer.Deserialize<JsonElement>(@"{""field"":42}").GetProperty("field"))));
+        Assert.Equal(42, (long?) new OpenIddictParameter(JsonValue.Create(
+            JsonSerializer.Deserialize<JsonElement>(@"{""field"":42}").GetProperty("field"))));
+#endif
     }
 
     [Fact]
@@ -1137,6 +2060,14 @@ public class OpenIddictParameterTests
             JsonSerializer.Deserialize<JsonElement>(@"[""Contoso"",""Fabrikam""]")));
         Assert.Null((string?) new OpenIddictParameter(
             JsonSerializer.Deserialize<JsonElement>(@"{""field"":""Fabrikam""}")));
+
+#if SUPPORTS_JSON_NODES
+        Assert.Null((string?) new OpenIddictParameter(new JsonArray("Contoso", "Fabrikam")));
+        Assert.Null((string?) new OpenIddictParameter(new JsonObject
+        {
+            ["field"] = "Fabrikam"
+        }));
+#endif
     }
 
     [Fact]
@@ -1158,6 +2089,20 @@ public class OpenIddictParameterTests
             JsonSerializer.Deserialize<JsonElement>(@"{""field"":false}").GetProperty("field")));
         Assert.Equal("42", (string?) new OpenIddictParameter(
             JsonSerializer.Deserialize<JsonElement>(@"{""field"":42}").GetProperty("field")));
+
+#if SUPPORTS_JSON_NODES
+        Assert.Equal("Fabrikam", (string?) new OpenIddictParameter(JsonValue.Create("Fabrikam")));
+        Assert.Equal(bool.FalseString, (string?) new OpenIddictParameter(JsonValue.Create(false)));
+        Assert.Equal("42", (string?) new OpenIddictParameter(JsonValue.Create(42)));
+        Assert.Equal("42", (string?) new OpenIddictParameter(JsonValue.Create(42L)));
+
+        Assert.Equal("Fabrikam", (string?) new OpenIddictParameter(JsonValue.Create(
+            JsonSerializer.Deserialize<JsonElement>(@"{""field"":""Fabrikam""}").GetProperty("field"))));
+        Assert.Equal(bool.FalseString, (string?) new OpenIddictParameter(JsonValue.Create(
+            JsonSerializer.Deserialize<JsonElement>(@"{""field"":false}").GetProperty("field"))));
+        Assert.Equal("42", (string?) new OpenIddictParameter(JsonValue.Create(
+            JsonSerializer.Deserialize<JsonElement>(@"{""field"":42}").GetProperty("field"))));
+#endif
     }
 
     [Fact]
@@ -1177,45 +2122,68 @@ public class OpenIddictParameterTests
     public void StringArrayConverter_CanCreateParameterFromPrimitiveValues()
     {
         // Arrange, act and assert
-        Assert.Equal(new[] { "Fabrikam" }, (string[]?) new OpenIddictParameter("Fabrikam"));
-        Assert.Equal(new[] { "False" }, (string[]?) new OpenIddictParameter(false));
-        Assert.Equal(new[] { "42" }, (string[]?) new OpenIddictParameter(42));
+        Assert.Equal(new[] { "Fabrikam" }, (string?[]?) new OpenIddictParameter("Fabrikam"));
+        Assert.Equal(new[] { "False" }, (string?[]?) new OpenIddictParameter(false));
+        Assert.Equal(new[] { "42" }, (string?[]?) new OpenIddictParameter(42));
     }
 
     [Fact]
     public void StringArrayConverter_ReturnsDefaultValueForNullValues()
     {
         // Arrange, act and assert
-        Assert.Null((string[]?) new OpenIddictParameter());
+        Assert.Null((string?[]?) new OpenIddictParameter());
     }
 
     [Fact]
     public void StringArrayConverter_ReturnsSingleElementArrayForStringValue()
     {
         // Arrange, act and assert
-        Assert.Equal(new[] { "Fabrikam" }, (string[]?) new OpenIddictParameter("Fabrikam"));
+        Assert.Equal(new[] { "Fabrikam" }, (string?[]?) new OpenIddictParameter("Fabrikam"));
     }
 
     [Fact]
     public void StringArrayConverter_ReturnsDefaultValueForUnsupportedJsonValues()
     {
         // Arrange, act and assert
-        Assert.Null((string[]?) new OpenIddictParameter(new JsonElement()));
+        Assert.Null((string?[]?) new OpenIddictParameter(new JsonElement()));
+        Assert.Null((string?[]?) new OpenIddictParameter(
+            JsonSerializer.Deserialize<JsonElement>(@"[""value"",[]]")));
+
+        Assert.Null((string?[]?) new OpenIddictParameter(
+            JsonSerializer.Deserialize<JsonElement>(@"[""value"",{}]")));
+
+#if SUPPORTS_JSON_NODES
+        Assert.Null((string?[]?) new OpenIddictParameter((JsonNode?) null));
+        Assert.Null((string?[]?) new OpenIddictParameter(new JsonArray("value", new JsonArray())));
+        Assert.Null((string?[]?) new OpenIddictParameter(new JsonArray("value", new JsonObject())));
+#endif
     }
 
     [Fact]
     public void StringArrayConverter_CanConvertFromJsonValues()
     {
         // Arrange, act and assert
-        Assert.Equal(new[] { "Fabrikam" }, (string[]?) new OpenIddictParameter(
+        Assert.Equal(new[] { "Fabrikam" }, (string?[]?) new OpenIddictParameter(
             JsonSerializer.Deserialize<JsonElement>(@"{""field"":""Fabrikam""}").GetProperty("field")));
-        Assert.Equal(new[] { "False" }, (string[]?) new OpenIddictParameter(
+        Assert.Equal(new[] { "False" }, (string?[]?) new OpenIddictParameter(
             JsonSerializer.Deserialize<JsonElement>(@"{""field"":false}").GetProperty("field")));
-        Assert.Equal(new[] { "42" }, (string[]?) new OpenIddictParameter(
+        Assert.Equal(new[] { "42" }, (string?[]?) new OpenIddictParameter(
             JsonSerializer.Deserialize<JsonElement>(@"{""field"":42}").GetProperty("field")));
-        Assert.Equal(new[] { "Fabrikam" }, (string[]?) new OpenIddictParameter(
+        Assert.Equal(new[] { "Fabrikam" }, (string?[]?) new OpenIddictParameter(
             JsonSerializer.Deserialize<JsonElement>(@"[""Fabrikam""]")));
-        Assert.Equal(new[] { "Contoso", "Fabrikam" }, (string[]?) new OpenIddictParameter(
+        Assert.Equal(new[] { "Contoso", "Fabrikam" }, (string?[]?) new OpenIddictParameter(
             JsonSerializer.Deserialize<JsonElement>(@"[""Contoso"",""Fabrikam""]")));
+        Assert.Equal(new[] { "value", "42", bool.TrueString }, (string?[]?) new OpenIddictParameter(
+            JsonSerializer.Deserialize<JsonElement>(@"[""value"",42,true]")));
+
+#if SUPPORTS_JSON_NODES
+        Assert.Equal(new[] { "Fabrikam" }, (string?[]?) new OpenIddictParameter(JsonValue.Create("Fabrikam")));
+        Assert.Equal(new[] { bool.FalseString }, (string?[]?) new OpenIddictParameter(JsonValue.Create(false)));
+        Assert.Equal(new[] { "42" }, (string?[]?) new OpenIddictParameter(JsonValue.Create(42)));
+        Assert.Equal(new[] { "42" }, (string?[]?) new OpenIddictParameter(JsonValue.Create(42L)));
+        Assert.Equal(new[] { "Fabrikam" }, (string?[]?) new OpenIddictParameter(new JsonArray("Fabrikam")));
+        Assert.Equal(new[] { "Contoso", "Fabrikam" }, (string?[]?) new OpenIddictParameter(new JsonArray("Contoso", "Fabrikam")));
+        Assert.Equal(new[] { "value", "42", bool.TrueString }, (string?[]?) new OpenIddictParameter(new JsonArray("value", 42, true)));
+#endif
     }
 }
diff --git a/test/OpenIddict.Server.AspNetCore.IntegrationTests/OpenIddictServerAspNetCoreIntegrationTests.cs b/test/OpenIddict.Server.AspNetCore.IntegrationTests/OpenIddictServerAspNetCoreIntegrationTests.cs
index b0246c61..2e2fde9e 100644
--- a/test/OpenIddict.Server.AspNetCore.IntegrationTests/OpenIddictServerAspNetCoreIntegrationTests.cs
+++ b/test/OpenIddict.Server.AspNetCore.IntegrationTests/OpenIddictServerAspNetCoreIntegrationTests.cs
@@ -22,6 +22,10 @@ using static OpenIddict.Server.AspNetCore.OpenIddictServerAspNetCoreHandlers;
 using static OpenIddict.Server.OpenIddictServerEvents;
 using static OpenIddict.Server.OpenIddictServerHandlers.Protection;
 
+#if SUPPORTS_JSON_NODES
+using System.Text.Json.Nodes;
+#endif
+
 namespace OpenIddict.Server.AspNetCore.IntegrationTests;
 
 public partial class OpenIddictServerAspNetCoreIntegrationTests : OpenIddictServerIntegrationTests
@@ -167,10 +171,13 @@ public partial class OpenIddictServerAspNetCoreIntegrationTests : OpenIddictServ
         Assert.Equal(JsonValueKind.Number, ((JsonElement) response["integer_parameter"]).ValueKind);
         Assert.Equal("Bob l'Eponge", (string?) response["string_parameter"]);
         Assert.Equal(JsonValueKind.String, ((JsonElement) response["string_parameter"]).ValueKind);
-        Assert.Equal(new[] { "Contoso", "Fabrikam" }, (string[]?) response["array_parameter"]);
-        Assert.Equal(JsonValueKind.Array, ((JsonElement) response["array_parameter"]).ValueKind);
-        Assert.Equal("value", (string?) response["object_parameter"]?["parameter"]);
-        Assert.Equal(JsonValueKind.Object, ((JsonElement) response["object_parameter"]).ValueKind);
+
+#if SUPPORTS_JSON_NODES
+        Assert.Equal(new[] { "Contoso", "Fabrikam" }, (string[]?) response["node_array_parameter"]);
+        Assert.IsType<JsonArray>((JsonNode?) response["node_array_parameter"]);
+        Assert.Equal("value", (string?) response["node_object_parameter"]?["parameter"]);
+        Assert.IsType<JsonObject>((JsonNode?) response["node_object_parameter"]);
+#endif
     }
 
     [Fact]
@@ -762,6 +769,13 @@ public partial class OpenIddictServerAspNetCoreIntegrationTests : OpenIddictServ
         Assert.Equal(JsonValueKind.Array, ((JsonElement) response["array_parameter"]).ValueKind);
         Assert.Equal("value", (string?) response["object_parameter"]?["parameter"]);
         Assert.Equal(JsonValueKind.Object, ((JsonElement) response["object_parameter"]).ValueKind);
+
+#if SUPPORTS_JSON_NODES
+        Assert.Equal(new[] { "Contoso", "Fabrikam" }, (string[]?) response["node_array_parameter"]);
+        Assert.IsType<JsonArray>((JsonNode?) response["node_array_parameter"]);
+        Assert.Equal("value", (string?) response["node_object_parameter"]?["parameter"]);
+        Assert.IsType<JsonObject>((JsonNode?) response["node_object_parameter"]);
+#endif
     }
 
     [Fact]
@@ -893,7 +907,11 @@ public partial class OpenIddictServerAspNetCoreIntegrationTests : OpenIddictServ
                             ["integer_parameter"] = 42,
                             ["string_parameter"] = "Bob l'Eponge",
                             ["array_parameter"] = JsonSerializer.Deserialize<JsonElement>(@"[""Contoso"",""Fabrikam""]"),
-                            ["object_parameter"] = JsonSerializer.Deserialize<JsonElement>(@"{""parameter"":""value""}")
+                            ["object_parameter"] = JsonSerializer.Deserialize<JsonElement>(@"{""parameter"":""value""}"),
+#if SUPPORTS_JSON_NODES
+                            ["node_array_parameter"] = new JsonArray("Contoso", "Fabrikam"),
+                            ["node_object_parameter"] = new JsonObject { ["parameter"] = "value" }
+#endif
                         });
 
                     await context.SignInAsync(OpenIddictServerAspNetCoreDefaults.AuthenticationScheme, principal, properties);
@@ -942,7 +960,11 @@ public partial class OpenIddictServerAspNetCoreIntegrationTests : OpenIddictServ
                             ["integer_parameter"] = 42,
                             ["string_parameter"] = "Bob l'Eponge",
                             ["array_parameter"] = JsonSerializer.Deserialize<JsonElement>(@"[""Contoso"",""Fabrikam""]"),
-                            ["object_parameter"] = JsonSerializer.Deserialize<JsonElement>(@"{""parameter"":""value""}")
+                            ["object_parameter"] = JsonSerializer.Deserialize<JsonElement>(@"{""parameter"":""value""}"),
+#if SUPPORTS_JSON_NODES
+                            ["node_array_parameter"] = new JsonArray("Contoso", "Fabrikam"),
+                            ["node_object_parameter"] = new JsonObject { ["parameter"] = "value" }
+#endif
                         });
 
                     await context.ChallengeAsync(OpenIddictServerAspNetCoreDefaults.AuthenticationScheme, properties);