Replace retired macOS 14 runner and test all available Xcode versions

GitHub retires the macos-14 image on 2026-11-02 (brownouts from
2026-10-05). Xcode 15 is not available on any remaining hosted
runner, so drop the macos-14 job and its documented compilers.

Also test the Xcode versions that the images provide but CI did not
use (26.1.1-26.3 on macos-15, 26.4.1-26.6 on a new macos-26 job), and
pin GCC 16 explicitly next to gcc:latest.

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

.github/workflows/macos.yml

@@ -17,11 +17,11 @@ permissions:
   contents: read
 
 jobs:
-  macos-14:
-    runs-on: macos-14 # https://github.com/actions/runner-images/blob/main/images/macos/macos-14-Readme.md
+  macos-15:
+    runs-on: macos-15 # https://github.com/actions/runner-images/blob/main/images/macos/macos-15-Readme.md
     strategy:
       matrix:
-        xcode: ['15.0.1', '15.1', '15.2', '15.3', '15.4']
+        xcode: ['16.0', '16.1', '16.2', '16.3', '16.4', '26.0.1', '26.1.1', '26.2', '26.3']
     env:
       DEVELOPER_DIR: /Applications/Xcode_${{ matrix.xcode }}.app/Contents/Developer
 
@@ -36,11 +36,11 @@ jobs:
       - name: Test
         run: cd build ; ctest -j 10 --output-on-failure
 
-  macos-15:
-    runs-on: macos-15 # https://github.com/actions/runner-images/blob/main/images/macos/macos-15-Readme.md
+  macos-26:
+    runs-on: macos-26 # https://github.com/actions/runner-images/blob/main/images/macos/macos-26-arm64-Readme.md
     strategy:
       matrix:
-        xcode: ['16.0', '16.1', '16.2', '16.3', '16.4', '26.0.1']
+        xcode: ['26.4.1', '26.5', '26.6']
     env:
       DEVELOPER_DIR: /Applications/Xcode_${{ matrix.xcode }}.app/Contents/Developer
 

.github/workflows/ubuntu.yml

@@ -209,7 +209,7 @@ jobs:
     strategy:
       matrix:
         # older GCC docker images (4, 5, 6) fail to check out code
-        compiler: ['7', '8', '9', '10', '11', '12', '13', '14', '15', 'latest']
+        compiler: ['7', '8', '9', '10', '11', '12', '13', '14', '15', '16', 'latest']
     container: gcc:${{ matrix.compiler }}
     steps:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1

docs/mkdocs/docs/api/basic_json/index.md

@@ -109,9 +109,6 @@ The class satisfies the following concept requirements:
 - **initializer_list_t** - type for initializer lists of `basic_json` values
 - [**input_format_t**](input_format_t.md) - type to choose the format to parse
 - [**json_sax_t**](../json_sax/index.md) - type for SAX events
-- [**with_object_t, with_array_t, with_string_t, with_boolean_t, with_integers_t, with_float_t, with_allocator_t,
-  with_json_serializer_t, with_binary_t, with_base_class_t**](with_t.md) - types to create a `basic_json` type with
-  one (or two) replaced template parameters
 
 ### Exceptions
 

docs/mkdocs/docs/api/basic_json/with_t.md

@@ -1,124 +0,0 @@
-# <small>nlohmann::basic_json::</small>with_t
-
-Member alias templates `with_object_t`, `with_array_t`, `with_string_t`, `with_boolean_t`, `with_integers_t`,
-`with_float_t`, `with_allocator_t`, `with_json_serializer_t`, `with_binary_t`, and `with_base_class_t`.
-
-```cpp
-template<template<typename, typename, typename...> class ObjectType2>
-using with_object_t = basic_json<ObjectType2, ArrayType, StringType, BooleanType,
-      NumberIntegerType, NumberUnsignedType, NumberFloatType,
-      AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>;
-
-template<template<typename, typename...> class ArrayType2>
-using with_array_t = basic_json<ObjectType, ArrayType2, StringType, BooleanType,
-      NumberIntegerType, NumberUnsignedType, NumberFloatType,
-      AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>;
-
-template<class StringType2>
-using with_string_t = basic_json<ObjectType, ArrayType, StringType2, BooleanType,
-      NumberIntegerType, NumberUnsignedType, NumberFloatType,
-      AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>;
-
-template<class BooleanType2>
-using with_boolean_t = basic_json<ObjectType, ArrayType, StringType, BooleanType2,
-      NumberIntegerType, NumberUnsignedType, NumberFloatType,
-      AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>;
-
-template<class NumberIntegerType2, class NumberUnsignedType2>
-using with_integers_t = basic_json<ObjectType, ArrayType, StringType, BooleanType,
-      NumberIntegerType2, NumberUnsignedType2, NumberFloatType,
-      AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>;
-
-template<class NumberFloatType2>
-using with_float_t = basic_json<ObjectType, ArrayType, StringType, BooleanType,
-      NumberIntegerType, NumberUnsignedType, NumberFloatType2,
-      AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>;
-
-template<template<typename> class AllocatorType2>
-using with_allocator_t = basic_json<ObjectType, ArrayType, StringType, BooleanType,
-      NumberIntegerType, NumberUnsignedType, NumberFloatType,
-      AllocatorType2, JSONSerializer, BinaryType, CustomBaseClass>;
-
-template<template<typename, typename = void> class JSONSerializer2>
-using with_json_serializer_t = basic_json<ObjectType, ArrayType, StringType, BooleanType,
-      NumberIntegerType, NumberUnsignedType, NumberFloatType,
-      AllocatorType, JSONSerializer2, BinaryType, CustomBaseClass>;
-
-template<class BinaryType2>
-using with_binary_t = basic_json<ObjectType, ArrayType, StringType, BooleanType,
-      NumberIntegerType, NumberUnsignedType, NumberFloatType,
-      AllocatorType, JSONSerializer, BinaryType2, CustomBaseClass>;
-
-template<class CustomBaseClass2>
-using with_base_class_t = basic_json<ObjectType, ArrayType, StringType, BooleanType,
-      NumberIntegerType, NumberUnsignedType, NumberFloatType,
-      AllocatorType, JSONSerializer, BinaryType, CustomBaseClass2>;
-```
-
-These member alias templates make it easier to create a `basic_json` type that is identical to the current type except
-for one (or, in the case of `with_integers_t`, two) of its [template parameters](index.md#template-parameters).
-Spelling out all 11 template parameters of `basic_json` just to change a single one is verbose and error-prone; these
-aliases only require the replacement type(s).
-
-with_object_t&lt;ObjectType2&gt;
-:   replaces `ObjectType`
-
-with_array_t&lt;ArrayType2&gt;
-:   replaces `ArrayType`
-
-with_string_t&lt;StringType2&gt;
-:   replaces `StringType`
-
-with_boolean_t&lt;BooleanType2&gt;
-:   replaces `BooleanType`
-
-with_integers_t&lt;NumberIntegerType2, NumberUnsignedType2&gt;
-:   replaces both `NumberIntegerType` and `NumberUnsignedType`; the two are combined into a single alias because they
-    are usually changed together (for instance, when switching to fixed-width integer types)
-
-with_float_t&lt;NumberFloatType2&gt;
-:   replaces `NumberFloatType`
-
-with_allocator_t&lt;AllocatorType2&gt;
-:   replaces `AllocatorType`
-
-with_json_serializer_t&lt;JSONSerializer2&gt;
-:   replaces `JSONSerializer`
-
-with_binary_t&lt;BinaryType2&gt;
-:   replaces `BinaryType`
-
-with_base_class_t&lt;CustomBaseClass2&gt;
-:   replaces `CustomBaseClass`; see also [`json_base_class_t`](json_base_class_t.md)
-
-## Notes
-
-All other template parameters are kept unchanged, so the resulting type still uses, for instance, the same
-`ObjectType` unless `with_object_t` itself is used.
-
-## Examples
-
-??? example
-
-    The following code shows how `with_object_t` can be used to create a JSON type that stores object elements in a
-    `std::map` and therefore keeps them sorted by key, unlike the default type which preserves insertion order
-    only when `nlohmann::ordered_json` is used.
-
-    ```cpp
-    --8<-- "examples/with_t.cpp"
-    ```
-
-    Output:
-
-    ```json
-    --8<-- "examples/with_t.output"
-    ```
-
-## See also
-
-- [basic_json](index.md#template-parameters) - the template parameters that can be replaced
-- [json_base_class_t](json_base_class_t.md) - the type used for `CustomBaseClass`
-
-## Version history
-
-- Added in version 3.13.0.

docs/mkdocs/docs/community/quality_assurance.md

@@ -21,11 +21,6 @@ Note: Some modern features (like C++20 ranges or filesystem support) may be disa
       
         | Compiler                                     | Architecture | Operating System                  | CI        |
         |----------------------------------------------|--------------|-----------------------------------|-----------|
-        | AppleClang 15.0.0.15000040; Xcode 15.0.1     | arm64        | macOS 14.7.2 (Sonoma)             | GitHub    |
-        | AppleClang 15.0.0.15000100; Xcode 15.1       | arm64        | macOS 14.7.2 (Sonoma)             | GitHub    |
-        | AppleClang 15.0.0.15000100; Xcode 15.2       | arm64        | macOS 14.7.2 (Sonoma)             | GitHub    |
-        | AppleClang 15.0.0.15000309; Xcode 15.3       | arm64        | macOS 14.7.2 (Sonoma)             | GitHub    |
-        | AppleClang 15.0.0.15000309; Xcode 15.4       | arm64        | macOS 14.7.2 (Sonoma)             | GitHub    |
         | AppleClang 16.0.0.16000026; Xcode 16         | arm64        | macOS 15.2 (Sequoia)              | GitHub    |
         | AppleClang 16.0.0.16000026; Xcode 16.1       | arm64        | macOS 15.2 (Sequoia)              | GitHub    |
         | AppleClang 16.0.0.16000026; Xcode 16.2       | arm64        | macOS 15.2 (Sequoia)              | GitHub    |

docs/mkdocs/docs/examples/json_base_class_t.cpp

@@ -13,7 +13,19 @@ class visitor_adaptor_with_metadata
     void do_visit(const Ptr& ptr, const Fnc& fnc) const;
 };
 
-using json = nlohmann::json::with_base_class_t<visitor_adaptor_with_metadata>;
+using json = nlohmann::basic_json <
+             std::map,
+             std::vector,
+             std::string,
+             bool,
+             std::int64_t,
+             std::uint64_t,
+             double,
+             std::allocator,
+             nlohmann::adl_serializer,
+             std::vector<std::uint8_t>,
+             visitor_adaptor_with_metadata
+             >;
 
 template <class Fnc>
 void visitor_adaptor_with_metadata::visit(const Fnc& fnc) const

docs/mkdocs/docs/examples/with_t.cpp

@@ -1,18 +0,0 @@
-#include <iostream>
-#include <map>
-#include <nlohmann/json.hpp>
-
-// a JSON type that stores objects in a std::map (which keeps keys sorted)
-// instead of the default ordered associative container
-using sorted_json = nlohmann::json::with_object_t<std::map>;
-
-int main()
-{
-    sorted_json j;
-    j["c"] = 1;
-    j["a"] = 2;
-    j["b"] = 3;
-
-    // keys are sorted, because std::map is used to store the object
-    std::cout << j.dump() << std::endl;
-}

docs/mkdocs/docs/examples/with_t.output

@@ -1 +0,0 @@
-{"a":2,"b":3,"c":1}

docs/mkdocs/mkdocs.yml

@@ -232,7 +232,6 @@ nav:
           - 'update': api/basic_json/update.md
           - 'value': api/basic_json/value.md
           - 'value_t': api/basic_json/value_t.md
-- 'with_t': api/basic_json/with_t.md
       - byte_container_with_subtype:
           - 'Overview': api/byte_container_with_subtype/index.md
           - '(constructor)': api/byte_container_with_subtype/byte_container_with_subtype.md

include/nlohmann/json.hpp

@@ -226,70 +226,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     /// SAX interface type, see @ref nlohmann::json_sax
     using json_sax_t = json_sax<basic_json>;
 
-    ////////////////////////////////////////////////////////////////////////////////
-    // utility templates to create a json type with different template parameters //
-    ////////////////////////////////////////////////////////////////////////////////
-
-    /// Json type using a different type for storing objects
-    /// @sa https://json.nlohmann.me/api/basic_json/with_t/
-    template<template<typename, typename, typename...> class ObjectType2>
-    using with_object_t = basic_json<ObjectType2, ArrayType, StringType, BooleanType,
-          NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>;
-
-    /// Json type using a different type for storing arrays
-    /// @sa https://json.nlohmann.me/api/basic_json/with_t/
-    template<template<typename, typename...> class ArrayType2>
-    using with_array_t =  basic_json<ObjectType, ArrayType2, StringType, BooleanType,
-          NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>;
-
-    /// Json type using a different type for storing strings
-    /// @sa https://json.nlohmann.me/api/basic_json/with_t/
-    template<class StringType2>
-    using with_string_t =  basic_json<ObjectType, ArrayType, StringType2, BooleanType,
-          NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>;
-
-    /// Json type using a different type for storing booleans
-    /// @sa https://json.nlohmann.me/api/basic_json/with_t/
-    template<class BooleanType2>
-    using with_boolean_t =  basic_json<ObjectType, ArrayType, StringType, BooleanType2,
-          NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>;
-
-    /// Json type using different types for storing signed and unsigned integers
-    /// @sa https://json.nlohmann.me/api/basic_json/with_t/
-    template<class NumberIntegerType2, class NumberUnsignedType2>
-    using with_integers_t =  basic_json<ObjectType, ArrayType, StringType, BooleanType,
-          NumberIntegerType2, NumberUnsignedType2, NumberFloatType, AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>;
-
-    /// Json type using a different type for storing floating point numbers
-    /// @sa https://json.nlohmann.me/api/basic_json/with_t/
-    template<class NumberFloatType2>
-    using with_float_t =  basic_json<ObjectType, ArrayType, StringType, BooleanType,
-          NumberIntegerType, NumberUnsignedType, NumberFloatType2, AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>;
-
-    /// Json type using a different type as base allocator
-    /// @sa https://json.nlohmann.me/api/basic_json/with_t/
-    template<template<typename> class AllocatorType2>
-    using with_allocator_t =  basic_json<ObjectType, ArrayType, StringType, BooleanType,
-          NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType2, JSONSerializer, BinaryType, CustomBaseClass>;
-
-    /// Json type using a different type as json serializer
-    /// @sa https://json.nlohmann.me/api/basic_json/with_t/
-    template<template<typename, typename = void> class JSONSerializer2>
-    using with_json_serializer_t =  basic_json<ObjectType, ArrayType, StringType, BooleanType,
-          NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer2, BinaryType, CustomBaseClass>;
-
-    /// Json type using a different type for storing binary data
-    /// @sa https://json.nlohmann.me/api/basic_json/with_t/
-    template<class BinaryType2>
-    using with_binary_t =  basic_json<ObjectType, ArrayType, StringType, BooleanType,
-          NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer, BinaryType2, CustomBaseClass>;
-
-    /// Json type using a different type as base class
-    /// @sa https://json.nlohmann.me/api/basic_json/with_t/
-    template<class CustomBaseClass2>
-    using with_base_class_t =  basic_json<ObjectType, ArrayType, StringType, BooleanType,
-          NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer, BinaryType, CustomBaseClass2>;
-
     ////////////////
     // exceptions //
     ////////////////

single_include/nlohmann/json.hpp

@@ -27348,70 +27348,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     /// SAX interface type, see @ref nlohmann::json_sax
     using json_sax_t = json_sax<basic_json>;
 
-    ////////////////////////////////////////////////////////////////////////////////
-    // utility templates to create a json type with different template parameters //
-    ////////////////////////////////////////////////////////////////////////////////
-
-    /// Json type using a different type for storing objects
-    /// @sa https://json.nlohmann.me/api/basic_json/with_t/
-    template<template<typename, typename, typename...> class ObjectType2>
-    using with_object_t = basic_json<ObjectType2, ArrayType, StringType, BooleanType,
-                                     NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>;
-
-    /// Json type using a different type for storing arrays
-    /// @sa https://json.nlohmann.me/api/basic_json/with_t/
-    template<template<typename, typename...> class ArrayType2>
-    using with_array_t =  basic_json<ObjectType, ArrayType2, StringType, BooleanType,
-                                     NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>;
-
-    /// Json type using a different type for storing strings
-    /// @sa https://json.nlohmann.me/api/basic_json/with_t/
-    template<class StringType2>
-    using with_string_t =  basic_json<ObjectType, ArrayType, StringType2, BooleanType,
-                                      NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>;
-
-    /// Json type using a different type for storing booleans
-    /// @sa https://json.nlohmann.me/api/basic_json/with_t/
-    template<class BooleanType2>
-    using with_boolean_t =  basic_json<ObjectType, ArrayType, StringType, BooleanType2,
-                                       NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>;
-
-    /// Json type using different types for storing signed and unsigned integers
-    /// @sa https://json.nlohmann.me/api/basic_json/with_t/
-    template<class NumberIntegerType2, class NumberUnsignedType2>
-    using with_integers_t =  basic_json<ObjectType, ArrayType, StringType, BooleanType,
-                                        NumberIntegerType2, NumberUnsignedType2, NumberFloatType, AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>;
-
-    /// Json type using a different type for storing floating point numbers
-    /// @sa https://json.nlohmann.me/api/basic_json/with_t/
-    template<class NumberFloatType2>
-    using with_float_t =  basic_json<ObjectType, ArrayType, StringType, BooleanType,
-                                     NumberIntegerType, NumberUnsignedType, NumberFloatType2, AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>;
-
-    /// Json type using a different type as base allocator
-    /// @sa https://json.nlohmann.me/api/basic_json/with_t/
-    template<template<typename> class AllocatorType2>
-    using with_allocator_t =  basic_json<ObjectType, ArrayType, StringType, BooleanType,
-                                         NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType2, JSONSerializer, BinaryType, CustomBaseClass>;
-
-    /// Json type using a different type as json serializer
-    /// @sa https://json.nlohmann.me/api/basic_json/with_t/
-    template<template<typename, typename = void> class JSONSerializer2>
-    using with_json_serializer_t =  basic_json<ObjectType, ArrayType, StringType, BooleanType,
-        NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer2, BinaryType, CustomBaseClass>;
-
-    /// Json type using a different type for storing binary data
-    /// @sa https://json.nlohmann.me/api/basic_json/with_t/
-    template<class BinaryType2>
-    using with_binary_t =  basic_json<ObjectType, ArrayType, StringType, BooleanType,
-                                      NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer, BinaryType2, CustomBaseClass>;
-
-    /// Json type using a different type as base class
-    /// @sa https://json.nlohmann.me/api/basic_json/with_t/
-    template<class CustomBaseClass2>
-    using with_base_class_t =  basic_json<ObjectType, ArrayType, StringType, BooleanType,
-                                          NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer, BinaryType, CustomBaseClass2>;
-
     ////////////////
     // exceptions //
     ////////////////

tests/src/unit-allocator.cpp

@@ -48,7 +48,14 @@ TEST_CASE("bad_alloc")
     SECTION("bad_alloc")
     {
         // create JSON type using the throwing allocator
-        using bad_json = nlohmann::json::with_allocator_t<bad_allocator>;
+        using bad_json = nlohmann::basic_json<std::map,
+              std::vector,
+              std::string,
+              bool,
+              std::int64_t,
+              std::uint64_t,
+              double,
+              bad_allocator>;
 
         // creating an object should throw
         CHECK_THROWS_AS(bad_json(bad_json::value_t::object), std::bad_alloc&);
@@ -122,7 +129,14 @@ void my_allocator_clean_up(T* p)
 TEST_CASE("controlled bad_alloc")
 {
     // create JSON type using the throwing allocator
-    using my_json = nlohmann::json::with_allocator_t<my_allocator>;
+    using my_json = nlohmann::basic_json<std::map,
+          std::vector,
+          std::string,
+          bool,
+          std::int64_t,
+          std::uint64_t,
+          double,
+          my_allocator>;
 
     SECTION("class json_value")
     {
@@ -574,7 +588,14 @@ TEST_CASE("bad my_allocator::construct")
 {
     SECTION("my_allocator::construct doesn't forward")
     {
-        using bad_alloc_json = nlohmann::json::with_allocator_t<allocator_no_forward>;
+        using bad_alloc_json = nlohmann::basic_json<std::map,
+              std::vector,
+              std::string,
+              bool,
+              std::int64_t,
+              std::uint64_t,
+              double,
+              allocator_no_forward>;
 
         bad_alloc_json j;
         j["test"] = bad_alloc_json::array_t();

tests/src/unit-alt-string.cpp

@@ -163,7 +163,16 @@ void int_to_string(alt_string& target, std::size_t value)
     target = std::to_string(value).c_str();
 }
 
-using alt_json = nlohmann::json::with_string_t<alt_string>;
+using alt_json = nlohmann::basic_json <
+                 std::map,
+                 std::vector,
+                 alt_string,
+                 bool,
+                 std::int64_t,
+                 std::uint64_t,
+                 double,
+                 std::allocator,
+                 nlohmann::adl_serializer >;
 
 bool operator<(const char* op1, const alt_string& op2) noexcept
 {

tests/src/unit-custom-base-class.cpp

@@ -38,7 +38,20 @@ class json_metadata
 };
 
 template<class T>
-using json_with_metadata = nlohmann::json::with_base_class_t<json_metadata<T>>;
+using json_with_metadata =
+    nlohmann::basic_json <
+    std::map,
+    std::vector,
+    std::string,
+    bool,
+    std::int64_t,
+    std::uint64_t,
+    double,
+    std::allocator,
+    nlohmann::adl_serializer,
+    std::vector<std::uint8_t>,
+    json_metadata<T>
+    >;
 
 TEST_CASE("JSON Node Metadata")
 {
@@ -255,7 +268,19 @@ class visitor_adaptor
     void do_visit(const Ptr& ptr, const Fnc& fnc) const;
 };
 
-using json_with_visitor_t = nlohmann::json::with_base_class_t<visitor_adaptor>;
+using json_with_visitor_t = nlohmann::basic_json <
+                            std::map,
+                            std::vector,
+                            std::string,
+                            bool,
+                            std::int64_t,
+                            std::uint64_t,
+                            double,
+                            std::allocator,
+                            nlohmann::adl_serializer,
+                            std::vector<std::uint8_t>,
+                            visitor_adaptor
+                            >;
 
 template <class Fnc>
 void visitor_adaptor::visit(const Fnc& fnc) const

tests/src/unit-udt.cpp

@@ -23,7 +23,6 @@ using nlohmann::json;
     using namespace nlohmann::literals; // NOLINT(google-build-using-namespace)
 #endif
 
-#include <deque>
 #include <map>
 #include <memory>
 #include <string>
@@ -685,7 +684,8 @@ static std::ostream& operator<<(std::ostream& os, small_pod l)
 TEST_CASE("custom serializer for pods" * doctest::test_suite("udt"))
 {
     using custom_json =
-        nlohmann::json::with_json_serializer_t<pod_serializer>;
+        nlohmann::basic_json<std::map, std::vector, std::string, bool,
+        std::int64_t, std::uint64_t, double, std::allocator, pod_serializer>;
 
     auto p = udt::small_pod{42, '/', 42};
     custom_json const j = p;
@@ -703,7 +703,7 @@ TEST_CASE("custom serializer for pods" * doctest::test_suite("udt"))
 template <typename T, typename>
 struct another_adl_serializer;
 
-using custom_json = nlohmann::json::with_json_serializer_t<another_adl_serializer>;
+using custom_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, double, std::allocator, another_adl_serializer>;
 
 template <typename T, typename>
 struct another_adl_serializer
@@ -734,68 +734,6 @@ TEST_CASE("custom serializer that does adl by default" * doctest::test_suite("ud
     CHECK(me == cj.get<udt::person>());
 }
 
-TEST_CASE("with_*_t aliases" * doctest::test_suite("udt"))
-{
-    // a custom base class used to check with_base_class_t
-    struct custom_base_class {};
-
-    CHECK(std::is_same<json::with_object_t<std::deque>,
-          nlohmann::basic_json<std::deque, std::vector, std::string, bool,
-          std::int64_t, std::uint64_t, double, std::allocator,
-          nlohmann::adl_serializer, std::vector<std::uint8_t>>>::value);
-
-    CHECK(std::is_same<json::with_array_t<std::deque>,
-          nlohmann::basic_json<std::map, std::deque, std::string, bool,
-          std::int64_t, std::uint64_t, double, std::allocator,
-          nlohmann::adl_serializer, std::vector<std::uint8_t>>>::value);
-
-    CHECK(std::is_same<json::with_string_t<std::wstring>,
-          nlohmann::basic_json<std::map, std::vector, std::wstring, bool,
-          std::int64_t, std::uint64_t, double, std::allocator,
-          nlohmann::adl_serializer, std::vector<std::uint8_t>>>::value);
-
-    CHECK(std::is_same<json::with_boolean_t<int>,
-          nlohmann::basic_json<std::map, std::vector, std::string, int,
-          std::int64_t, std::uint64_t, double, std::allocator,
-          nlohmann::adl_serializer, std::vector<std::uint8_t>>>::value);
-
-    CHECK(std::is_same<json::with_integers_t<std::int32_t, std::uint32_t>,
-          nlohmann::basic_json<std::map, std::vector, std::string, bool,
-          std::int32_t, std::uint32_t, double, std::allocator,
-          nlohmann::adl_serializer, std::vector<std::uint8_t>>>::value);
-
-    CHECK(std::is_same<json::with_float_t<float>,
-          nlohmann::basic_json<std::map, std::vector, std::string, bool,
-          std::int64_t, std::uint64_t, float, std::allocator,
-          nlohmann::adl_serializer, std::vector<std::uint8_t>>>::value);
-
-    CHECK(std::is_same<json::with_allocator_t<std::allocator>,
-          nlohmann::basic_json<std::map, std::vector, std::string, bool,
-          std::int64_t, std::uint64_t, double, std::allocator,
-          nlohmann::adl_serializer, std::vector<std::uint8_t>>>::value);
-
-    CHECK(std::is_same<json::with_json_serializer_t<nlohmann::adl_serializer>,
-          nlohmann::basic_json<std::map, std::vector, std::string, bool,
-          std::int64_t, std::uint64_t, double, std::allocator,
-          nlohmann::adl_serializer, std::vector<std::uint8_t>>>::value);
-
-    CHECK(std::is_same<json::with_binary_t<std::vector<char>>,
-          nlohmann::basic_json<std::map, std::vector, std::string, bool,
-          std::int64_t, std::uint64_t, double, std::allocator,
-          nlohmann::adl_serializer, std::vector<char>>>::value);
-
-    CHECK(std::is_same<json::with_base_class_t<custom_base_class>,
-          nlohmann::basic_json<std::map, std::vector, std::string, bool,
-          std::int64_t, std::uint64_t, double, std::allocator,
-          nlohmann::adl_serializer, std::vector<std::uint8_t>, custom_base_class>>::value);
-
-    // with_string_t on ordered_json must keep ordered_map as the object type
-    CHECK(std::is_same<nlohmann::ordered_json::with_string_t<std::wstring>,
-          nlohmann::basic_json<nlohmann::ordered_map, std::vector, std::wstring, bool,
-          std::int64_t, std::uint64_t, double, std::allocator,
-          nlohmann::adl_serializer, std::vector<std::uint8_t>>>::value);
-}
-
 TEST_CASE("different basic_json types conversions")
 {
     SECTION("null")