Fix with_t nav entry and document chaining of the with_*_t aliases

Indent the with_t entry in mkdocs.yml so it is listed under basic_json, explain that the aliases can be chained and work on ordered_json, and test both, including json::with_object_t<ordered_map> == ordered_json. Signed-off-by: Niels Lohmann <mail@nlohmann.me>
Add tests for the with_*_t member alias templates
2026-10-05 14:10:31 +00:00 · 2026-10-05 08:44:53 +02:00 · 2026-10-04 18:10:17 +02:00 · 2026-10-04 18:04:45 +02:00 · 2026-10-04 18:01:49 +02:00 · 2026-10-04 18:00:36 +02:00
50 changed files with 435 additions and 1106 deletions
@@ -107,7 +107,7 @@ jobs:
    container: ubuntu:24.04
    strategy:
      matrix:
-        target: [ci_cmake_flags, ci_test_diagnostics, ci_test_diagnostic_positions, ci_test_noexceptions, ci_test_noimplicitconversions, ci_test_legacycomparison, ci_test_noglobaludls, ci_test_disableenumserialization, ci_test_disabletuplereferenceconversion, ci_test_skiplibraryversioncheck, ci_test_simdutf, ci_test_strict_nul_handling, ci_test_delete_deprecated_functions, ci_test_no_thread_local]
+        target: [ci_cmake_flags, ci_test_diagnostics, ci_test_diagnostic_positions, ci_test_noexceptions, ci_test_noimplicitconversions, ci_test_legacycomparison, ci_test_noglobaludls, ci_test_disableenumserialization, ci_test_disabletuplereferenceconversion, ci_test_skiplibraryversioncheck, ci_test_simdutf, ci_test_strict_nul_handling, ci_test_no_thread_local]
    steps:
      - name: Install build-essential
        run: apt-get update ; apt-get install -y build-essential unzip wget git
@@ -62,7 +62,6 @@ option(JSON_MultipleHeaders                "Use non-amalgamated version of the l
 option(JSON_SystemInclude                  "Include as system headers (skip for clang-tidy)." OFF)
 option(JSON_StrictNulHandling              "Build with strict NUL-byte handling enabled." OFF)
 option(JSON_StrictBinaryUTF8               "Build with UTF-8 checks in the CBOR, UBJSON, BJData, and BSON writers enabled." OFF)
-option(JSON_DeleteDeprecatedFunctions      "Delete the deprecated functions instead of only deprecating them." OFF)

 if (JSON_CI)
    include(ci)
@@ -124,10 +123,6 @@ if (JSON_StrictBinaryUTF8)
    message(STATUS "Strict UTF-8 checks in binary writers enabled (JSON_STRICT_BINARY_UTF8=1)")
 endif()

-if (JSON_DeleteDeprecatedFunctions)
-    message(STATUS "Deprecated functions are deleted (JSON_DELETE_DEPRECATED_FUNCTIONS=1)")
-endif()
-
 if (JSON_Diagnostic_Positions)
    message(STATUS "Diagnostic positions enabled (JSON_DIAGNOSTIC_POSITIONS=1)")
 endif()
@@ -164,7 +159,6 @@ target_compile_definitions(
    $<$<BOOL:${JSON_LegacyDiscardedValueComparison}>:JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON=1>
    $<$<BOOL:${JSON_StrictNulHandling}>:JSON_STRICT_NUL_HANDLING=1>
    $<$<BOOL:${JSON_StrictBinaryUTF8}>:JSON_STRICT_BINARY_UTF8=1>
-    $<$<BOOL:${JSON_DeleteDeprecatedFunctions}>:JSON_DELETE_DEPRECATED_FUNCTIONS=1>
 )

 target_include_directories(
@@ -249,20 +249,6 @@ add_custom_target(ci_test_strict_nul_handling
    COMMENT "Compile and test with strict NUL-byte handling enabled"
 )

-###############################################################################
-# Delete the deprecated functions.
-###############################################################################
-
-add_custom_target(ci_test_delete_deprecated_functions
-    COMMAND ${CMAKE_COMMAND}
-    -DCMAKE_BUILD_TYPE=Debug -GNinja
-    -DJSON_BuildTests=ON -DJSON_FastTests=ON -DJSON_DeleteDeprecatedFunctions=ON
-    -S${PROJECT_SOURCE_DIR} -B${PROJECT_BINARY_DIR}/build_delete_deprecated_functions
-    COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_delete_deprecated_functions
-    COMMAND cd ${PROJECT_BINARY_DIR}/build_delete_deprecated_functions && ${CMAKE_CTEST_COMMAND} --parallel ${N} --output-on-failure
-    COMMENT "Compile and test with the deprecated functions deleted"
-)
-
 ###############################################################################
 # Disable global UDLs.
 ###############################################################################
@@ -376,7 +362,7 @@ add_custom_target(ci_test_coverage
 # Sanitizers.
 ###############################################################################

-set(CLANG_CXX_FLAGS_SANITIZER "-g -O1 -fsanitize=address -fsanitize=undefined -fsanitize=integer -fsanitize=nullability -fno-omit-frame-pointer -fno-sanitize-recover=all -fno-sanitize=unsigned-integer-overflow -fno-sanitize=unsigned-shift-base -fsanitize-ignorelist=${PROJECT_SOURCE_DIR}/cmake/clang_sanitizer_ignorelist.txt")
+set(CLANG_CXX_FLAGS_SANITIZER "-g -O1 -fsanitize=address -fsanitize=undefined -fsanitize=integer -fsanitize=nullability -fno-omit-frame-pointer -fno-sanitize-recover=all -fno-sanitize=unsigned-integer-overflow -fno-sanitize=unsigned-shift-base")

 add_custom_target(ci_test_clang_sanitizer
    COMMAND CXX=${CLANG_TOOL} CXXFLAGS=${CLANG_CXX_FLAGS_SANITIZER} ${CMAKE_COMMAND}
@@ -719,7 +705,7 @@ ci_get_cmake(4.0.0  CMAKE_4_0_0_BINARY)
 # the tests require CMake 3.13 or later, so they are excluded for CMake 3.5.0
 set(JSON_CMAKE_FLAGS_3_5_0 JSON_Diagnostics JSON_Diagnostic_Positions JSON_GlobalUDLs JSON_ImplicitConversions JSON_DisableEnumSerialization
    JSON_LegacyDiscardedValueComparison JSON_Install JSON_MultipleHeaders JSON_SystemInclude JSON_Valgrind
-    JSON_StrictNulHandling JSON_StrictBinaryUTF8 JSON_DeleteDeprecatedFunctions)
+    JSON_StrictNulHandling JSON_StrictBinaryUTF8)
 set(JSON_CMAKE_FLAGS_3_31_6 JSON_BuildTests ${JSON_CMAKE_FLAGS_3_5_0})
 set(JSON_CMAKE_FLAGS_4_0_0 JSON_BuildTests ${JSON_CMAKE_FLAGS_3_5_0})

@@ -1,8 +0,0 @@
-# Sanitizer ignore list for ci_test_clang_sanitizer (-fsanitize-ignorelist).
-#
-# libstdc++ 14's <format> declares `_Scanner(basic_string_view<_CharT>, size_t __nargs = -1)`, so every std::format
-# call converts -1 to size_t, which -fsanitize=integer reports as implicit-integer-sign-change. This is
-# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=119429, not a bug in this library. Only that check and only <format> are
-# excluded, so implicit sign changes in the library and the tests are still reported.
-[implicit-integer-sign-change]
-src:*/include/c++/*/format
@@ -219,7 +219,6 @@ INSERT INTO searchIndex(name, type, path) VALUES ('Supported Macros', 'Guide', '
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_ASSERT', 'Macro', 'api/macros/json_assert/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_BRACE_INIT_COPY_SEMANTICS', 'Macro', 'api/macros/json_brace_init_copy_semantics/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_CATCH_USER', 'Macro', 'api/macros/json_throw_user/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('JSON_DELETE_DEPRECATED_FUNCTIONS', 'Macro', 'api/macros/json_delete_deprecated_functions/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_DIAGNOSTICS', 'Macro', 'api/macros/json_diagnostics/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_DIAGNOSTIC_POSITIONS', 'Macro', 'api/macros/json_diagnostic_positions/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_DISABLE_ENUM_SERIALIZATION', 'Macro', 'api/macros/json_disable_enum_serialization/index.html');
@@ -250,7 +249,6 @@ INSERT INTO searchIndex(name, type, path) VALUES ('JSON_TRY_USER', 'Macro', 'api
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_USE_GLOBAL_UDLS', 'Macro', 'api/macros/json_use_global_udls/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_USE_IMPLICIT_CONVERSIONS', 'Macro', 'api/macros/json_use_implicit_conversions/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON', 'Macro', 'api/macros/json_use_legacy_discarded_value_comparison/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS', 'Macro', 'api/macros/json_use_objects_for_enum_keyed_maps/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_USE_SIMDUTF', 'Macro', 'api/macros/json_use_simdutf/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('Macros', 'Macro', 'api/macros/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE', 'Macro', 'api/macros/nlohmann_define_derived_type/index.html');
@@ -8,7 +8,7 @@ static basic_json diff(const basic_json& source,
 Creates a [JSON Patch](http://jsonpatch.com) so that value `source` can be changed into the value `target` by calling
 [`patch`](patch.md) function.

-For two JSON values `source` and `target`, the following code always yields `#!cpp true`:
+For two JSON values `source` and `target`, the following code yields always `#!cpp true`:
 ```cpp
 source.patch(diff(source, target)) == target;
 ```
@@ -27,7 +27,7 @@ a JSON patch to convert the `source` to `target`

 ## Exception safety

-Strong guarantee: `source` and `target` are never modified.
+Strong guarantee: if an exception is thrown, there are no changes in the JSON value.

 ## Complexity

@@ -120,12 +120,3 @@ Linear in the size of the input.
 - Extended container support (1) to include types with lvalue-only ADL `begin`/`end` (matching `std::begin`/`std::end` semantics) in version 3.13.0.
 - Extended overload (2) to accept heterogeneous iterator+sentinel pairs (C++20 ranges support) in version 3.13.0.
 - Added `error_handler` parameter in version 3.13.0.
-
-!!! warning "Deprecation"
-
-    - Overload (2) replaces calls to `from_bjdata` with a pointer and a length as first two parameters, which has been
-      deprecated in version 3.13.0. This overload will be removed in version 4.0.0. Please replace all calls like
-      `#!cpp from_bjdata(ptr, len, ...);` with `#!cpp from_bjdata(ptr, ptr+len, ...);`.
-
-    You should be warned by your compiler with a `-Wdeprecated-declarations` warning if you are using a deprecated
-    function.
@@ -106,12 +106,3 @@ Linear in the size of the input.
 ## Version history

 - Added in version 3.13.0.
-
-!!! warning "Deprecation"
-
-    - Overload (2) replaces calls to `from_bon8` with a pointer and a length as first two parameters, which has been
-      deprecated in version 3.13.0. This overload will be removed in version 4.0.0. Please replace all calls like
-      `#!cpp from_bon8(ptr, len, ...);` with `#!cpp from_bon8(ptr, ptr+len, ...);`.
-
-    You should be warned by your compiler with a `-Wdeprecated-declarations` warning if you are using a deprecated
-    function.
@@ -109,6 +109,9 @@ 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

@@ -0,0 +1,136 @@
+# <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.
+
+The aliases are members of every `basic_json` specialization, including [`ordered_json`](../ordered_json.md), and the
+type they produce is again a `basic_json` specialization. They can therefore be chained to replace several template
+parameters at once:
+
+```cpp
+using my_json = nlohmann::json::with_integers_t<int, unsigned int>::with_float_t<float>;
+using my_ordered_json = nlohmann::ordered_json::with_string_t<std::wstring>;
+```
+
+The result is the same type as spelling out all template parameters, so the order of the chained aliases does not
+matter. For instance, `nlohmann::json::with_object_t<nlohmann::ordered_map>` is `nlohmann::ordered_json`.
+
+## 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.
@@ -61,11 +61,6 @@ header. See also the [macro overview page](../../features/macros.md).
 - [**JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS**](json_use_objects_for_enum_keyed_maps.md) - opt in to storing maps with enum
  keys as objects

-## Deprecated functions
-
- [**JSON_DELETE_DEPRECATED_FUNCTIONS**](json_delete_deprecated_functions.md) - opt in to deleting the deprecated
-  functions ahead of their removal in version 4.0.0
-
 ## Comparison behavior

 - [**JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON**](json_use_legacy_discarded_value_comparison.md) -
@@ -1,96 +0,0 @@
-# JSON_DELETE_DEPRECATED_FUNCTIONS
-
-```cpp
-#define JSON_DELETE_DEPRECATED_FUNCTIONS /* value */
-```
-
-When defined to `1`, all [deprecated functions](../../community/roadmap.md#removal-of-deprecated-functions) of the
-library are declared as deleted (`= delete`) instead of only being marked as deprecated. Code that still calls one of
-them no longer compiles. This way, you can find all calls that need to be replaced before version 4.0.0 removes these
-functions; the [migration guide](../../integration/migration_guide.md#replace-deprecated-functions) describes how.
-
-A deleted function, unlike a removed one, still takes part in overload resolution. A call that would select it
-therefore fails to compile instead of silently selecting another overload. This matters for the deprecated
-`from_*(ptr, len)` overloads of [`from_cbor`](../basic_json/from_cbor.md), [`from_msgpack`](../basic_json/from_msgpack.md),
-[`from_ubjson`](../basic_json/from_ubjson.md), [`from_bjdata`](../basic_json/from_bjdata.md),
-[`from_bon8`](../basic_json/from_bon8.md), and [`from_bson`](../basic_json/from_bson.md): without them, a call like
-`from_cbor(ptr, len)` would compile, read `ptr` as a NUL-terminated string, and convert `len` to the `strict` parameter.
-
-The macro does not affect the deprecated legacy comparison of discarded values, which is controlled by
-[`JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON`](json_use_legacy_discarded_value_comparison.md).
-
-## Default definition
-
-The default value is `0` (disabled, the deprecated functions can still be called, and the compiler warns about it).
-
-```cpp
-#define JSON_DELETE_DEPRECATED_FUNCTIONS 0
-```
-
-## Notes
-
-!!! info "CMake option"
-
-    The macro can also be set with the CMake option
-    [`JSON_DeleteDeprecatedFunctions`](../../integration/cmake.md#json_deletedeprecatedfunctions) (`OFF` by default).
-
-!!! warning "Opt-in only"
-
-    This macro must be defined **before** including `<nlohmann/json.hpp>`. Defining it after the include has no
-    effect. Define it for the whole project to avoid different declarations of the same class in different
-    translation units.
-
-!!! note "ABI compatibility"
-
-    The macro only turns calls that compile into calls that do not; it does not change the layout or the behavior of
-    any type. Its value is therefore not encoded in the [namespace](../../features/namespace.md).
-
-## Examples
-
-??? example "Example: default behavior (macro not defined)"
-
-    Without the macro, the deprecated overload is called, and the compiler warns about it:
-
-    ```cpp
-    #include <nlohmann/json.hpp>
-
-    using json = nlohmann::json;
-
-    int main()
-    {
-        const std::vector<std::uint8_t> v = {0x82, 0x01, 0x02};
-        auto j = json::from_cbor(v.data(), v.size());
-        // warning: 'from_cbor' is deprecated: Since 3.8.0; use from_cbor(ptr, ptr + len)
-    }
-    ```
-
-??? example "Example: deleted deprecated functions (macro defined to 1)"
-
-    With the macro, the call does not compile:
-
-    ```cpp
-    #define JSON_DELETE_DEPRECATED_FUNCTIONS 1
-    #include <nlohmann/json.hpp>
-
-    using json = nlohmann::json;
-
-    int main()
-    {
-        const std::vector<std::uint8_t> v = {0x82, 0x01, 0x02};
-        auto j = json::from_cbor(v.data(), v.size());
-        // error: call to deleted function 'from_cbor'
-    }
-    ```
-
-## See also
-
- [Roadmap: removal of deprecated functions](../../community/roadmap.md#removal-of-deprecated-functions) - the
-  deprecated functions and the version they were deprecated in
- [Migration guide: replace deprecated functions](../../integration/migration_guide.md#replace-deprecated-functions) -
-  how to replace each deprecated function
-
-## Version history
-
- Added in version 3.13.0.
- Planned to be removed in version 4.0.0, which removes the deprecated functions. The deprecated `from_*(ptr, len)`
-  overloads stay deleted in version 4.0.0.
@@ -112,4 +112,3 @@ The default value is `0` (disabled — existing behavior is preserved).
 ## Version history

 - Added in version 3.13.0.
- Planned to become the default (with the macro removed) in version 4.0.0.
@@ -44,7 +44,7 @@ By default, implicit conversions are enabled.

 ## Examples

-??? example "Example: implicit and explicit conversions"
+??? example "Example: implicit conversion"

    This is an example for an implicit conversion:

@@ -69,7 +69,7 @@ The default value is `0` (disabled — existing behavior is preserved).

 ## Examples

-??? example "Example: default behavior (macro not defined)"
+??? example "Default behavior (macro not defined)"

    Without the macro, a map with enum keys is stored as an array of pairs:

@@ -96,7 +96,7 @@ The default value is `0` (disabled — existing behavior is preserved).
    }
    ```

-??? example "Example: objects for enum-keyed maps (macro defined to 1)"
+??? example "Objects for enum-keyed maps (macro defined to 1)"

    With the macro, the same map is stored as an object:

@@ -64,8 +64,6 @@ The following macros guard changes that are planned to become the default in ver
 | [`JSON_PRECISE_STREAM_POSITION`](../api/macros/json_precise_stream_position.md)                                  | `0`         | `1`: reading from a stream does not consume the character after a number                                                      | –                                                                                                                  | 3.13.0 |
 | [`JSON_STRICT_NUL_HANDLING`](../api/macros/json_strict_nul_handling.md)                                          | `0`         | `1`: a NUL byte in the input is a parse error instead of the end of input                                                     | [`JSON_StrictNulHandling`](../integration/cmake.md#json_strictnulhandling)                                         | 3.13.0 |
 | [`JSON_STRICT_BINARY_UTF8`](../api/macros/json_strict_binary_utf8.md)                                            | `0`         | `1`: `to_cbor`, `to_ubjson`, `to_bjdata`, and `to_bson` throw for strings that are not valid UTF-8 by default                 | [`JSON_StrictBinaryUTF8`](../integration/cmake.md#json_strictbinaryutf8)                                           | 3.13.0 |
-| [`JSON_DISABLE_TUPLE_REFERENCE_CONVERSION`](../api/macros/json_disable_tuple_reference_conversion.md)            | `0`         | `1`: a `basic_json` value can no longer be created from a one-element tuple of a reference to it, such as `std::forward_as_tuple(j)`| [`JSON_DisableTupleReferenceConversion`](../integration/cmake.md#json_disabletuplereferenceconversion)             | 3.13.0 |
-| [`JSON_DELETE_DEPRECATED_FUNCTIONS`](../api/macros/json_delete_deprecated_functions.md)                          | `0`         | removed: the deprecated functions are removed (see below); the `from_*(ptr, len)` overloads stay deleted                      | [`JSON_DeleteDeprecatedFunctions`](../integration/cmake.md#json_deletedeprecatedfunctions)                         | 3.13.0 |

 For example, the following makes a 3.x release behave like version 4.0 with respect to these changes:

@@ -77,8 +75,6 @@ For example, the following makes a 3.x release behave like version 4.0 with resp
 #define JSON_PRECISE_STREAM_POSITION 1
 #define JSON_STRICT_NUL_HANDLING 1
 #define JSON_STRICT_BINARY_UTF8 1
-#define JSON_DISABLE_TUPLE_REFERENCE_CONVERSION 1
-#define JSON_DELETE_DEPRECATED_FUNCTIONS 1
 #include <nlohmann/json.hpp>
 ```

@@ -88,13 +84,8 @@ way to achieve this.
 ### Removal of deprecated functions

 Version 4.0 will remove all deprecated functions. Compiling with deprecation warnings enabled shows which of them your
-code still uses. Defining [`JSON_DELETE_DEPRECATED_FUNCTIONS`](../api/macros/json_delete_deprecated_functions.md) to
-`1` turns these warnings into errors, as the deprecated functions are then deleted. The
-[migration guide](../integration/migration_guide.md#replace-deprecated-functions) shows how to replace each of them.
-
-The `from_*` overloads taking a pointer and a length are not removed in version 4.0, but stay deleted. Without them, a
-call like `from_cbor(ptr, len)` would still compile: it would read `ptr` as a NUL-terminated string and convert `len`
-to the `strict` parameter.
+code still uses. The [migration guide](../integration/migration_guide.md#replace-deprecated-functions) shows how to
+replace each of them.

 | Deprecated                                                                                                                                                                                                                                         | Since  | Migration                                                                        |
 |----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------|----------------------------------------------------------------------------------|
@@ -106,7 +97,6 @@ to the `strict` parameter.
 | [`json_pointer::operator string_t`](../api/json_pointer/operator_string_t.md)                                                                                                                                                                      | 3.11.0 | [JSON Pointers](../integration/migration_guide.md#json-pointers)                 |
 | [`json_pointer`](../api/json_pointer/index.md) with a `basic_json` type as template argument, and the overloads of `value`, `contains`, `operator[]`, and `at` accepting such a pointer                                                           | 3.11.0 | [JSON Pointers](../integration/migration_guide.md#json-pointers)                 |
 | Comparing a [`json_pointer`](../api/json_pointer/index.md) with a string via [`operator==`](../api/json_pointer/operator_eq.md) or [`operator!=`](../api/json_pointer/operator_ne.md)                                                              | 3.11.2 | [JSON Pointers](../integration/migration_guide.md#json-pointers)                 |
-| [`from_bjdata`](../api/basic_json/from_bjdata.md) and [`from_bon8`](../api/basic_json/from_bon8.md) with `(ptr, len)`                                                                                                                              | 3.13.0 | [Parsing](../integration/migration_guide.md#parsing)                             |

 The deprecated legacy comparison of discarded values is controlled by a macro and therefore listed in the table above.

@@ -13,19 +13,7 @@ class visitor_adaptor_with_metadata
    void do_visit(const Ptr& ptr, const Fnc& fnc) const;
 };

-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
-             >;
+using json = nlohmann::json::with_base_class_t<visitor_adaptor_with_metadata>;

 template <class Fnc>
 void visitor_adaptor_with_metadata::visit(const Fnc& fnc) const
@@ -0,0 +1,18 @@
+#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;
+}
@@ -0,0 +1 @@
+{"a":2,"b":3,"c":1}
@@ -23,17 +23,6 @@ This macro overrides [`#!cpp catch`](https://en.cppreference.com/w/cpp/language/

 See [full documentation of `JSON_CATCH_USER(exception)`](../api/macros/json_throw_user.md).

-## `JSON_DELETE_DEPRECATED_FUNCTIONS`
-
-When defined to `1`, all deprecated functions are declared as deleted instead of only being marked as deprecated, so
-code that still calls them no longer compiles. This way, you can find all calls that need to be replaced before version
-4.0.0 removes these functions.
-
-The macro can also be set with the CMake option
-[`JSON_DeleteDeprecatedFunctions`](../integration/cmake.md#json_deletedeprecatedfunctions) (`OFF` by default).
-
-See [full documentation of `JSON_DELETE_DEPRECATED_FUNCTIONS`](../api/macros/json_delete_deprecated_functions.md).
-
 ## `JSON_DIAGNOSTICS`

 This macro enables extended diagnostics for exception messages. Possible values are `1` to enable or `0` to disable
@@ -97,8 +86,7 @@ See [full documentation of `JSON_DISABLE_ENUM_SERIALIZATION`](../api/macros/json
 ## `JSON_DISABLE_TUPLE_REFERENCE_CONVERSION`

 When defined to `1`, a JSON value can no longer be created from a one-element `std::tuple` holding a reference to a JSON
-value, such as the result of `std::forward_as_tuple(j)`. This lets `std::tuple` convert such tuples element-wise. This
-is planned to become the default in version 4.0.0.
+value, such as the result of `std::forward_as_tuple(j)`. This lets `std::tuple` convert such tuples element-wise.

 See [full documentation of `JSON_DISABLE_TUPLE_REFERENCE_CONVERSION`](../api/macros/json_disable_tuple_reference_conversion.md).

@@ -132,12 +132,6 @@ Build the unit tests when [`BUILD_TESTING`](https://cmake.org/cmake/help/latest/

 Enable CI build targets. The exact targets are used during the several CI steps and are subject to change without notice. This option is `OFF` by default.

-### `JSON_DeleteDeprecatedFunctions`
-
-Delete the deprecated functions instead of only deprecating them by defining the macro
-[`JSON_DELETE_DEPRECATED_FUNCTIONS`](../api/macros/json_delete_deprecated_functions.md). This option is `OFF` by
-default.
-
 ### `JSON_Diagnostics`

 Enable [extended diagnostic messages](../home/exceptions.md#extended-diagnostic-messages) by defining macro [`JSON_DIAGNOSTICS`](../api/macros/json_diagnostics.md). This option is `OFF` by default.
@@ -14,13 +14,6 @@ deprecations are annotated with
 [`HEDLEY_DEPRECATED_FOR`](https://nemequ.github.io/hedley/api-reference.html#HEDLEY_DEPRECATED_FOR) to report which
 function to use instead.

-!!! tip "Find all calls of deprecated functions"
-
-    Define [`JSON_DELETE_DEPRECATED_FUNCTIONS`](../api/macros/json_delete_deprecated_functions.md) to `1` (or set the
-    CMake option [`JSON_DeleteDeprecatedFunctions`](cmake.md#json_deletedeprecatedfunctions)) to delete all deprecated
-    functions. Every remaining call then fails to compile, even if deprecation warnings are disabled, so your code is
-    ready for version 4.0.0 once it compiles with the macro.
-
 ### Parsing

 - Function `friend std::istream& operator<<(basic_json&, std::istream&)` is deprecated since 3.0.0. Please use
@@ -48,10 +41,8 @@ function to use instead.
  [`from_ubjson`](../api/basic_json/from_ubjson.md), and [`from_bson`](../api/basic_json/from_bson.md)) via initializer
  lists is deprecated since 3.8.0. Instead, pass two iterators; for instance, call `from_cbor(ptr, ptr+len)` instead of
  `from_cbor({ptr, len})`. Likewise, passing a pointer and a length as two separate arguments to `from_cbor`,
-  `from_msgpack`, `from_ubjson`, and `from_bson` is deprecated since 3.8.0, and to
-  [`from_bjdata`](../api/basic_json/from_bjdata.md) and [`from_bon8`](../api/basic_json/from_bon8.md) since 3.13.0; call
-  `from_cbor(ptr, ptr+len)` instead of `from_cbor(ptr, len)`. These overloads will not be removed in version 4.0.0, but
-  deleted, so a call like `from_cbor(ptr, len)` cannot compile and convert `len` to the `strict` parameter.
+  `from_msgpack`, `from_ubjson`, and `from_bson` is deprecated since 3.8.0; call `from_cbor(ptr, ptr+len)` instead of
+  `from_cbor(ptr, len)`.

    === "Deprecated"
  
@@ -232,6 +232,7 @@ 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
@@ -292,7 +293,6 @@ nav:
          - 'JSON_BRACE_INIT_COPY_SEMANTICS': api/macros/json_brace_init_copy_semantics.md
          - 'JSON_CATCH_USER, JSON_THROW_USER, JSON_TRY_USER': api/macros/json_throw_user.md
          - 'JSON_DIAGNOSTICS': api/macros/json_diagnostics.md
-          - 'JSON_DELETE_DEPRECATED_FUNCTIONS': api/macros/json_delete_deprecated_functions.md
          - 'JSON_DIAGNOSTIC_POSITIONS': api/macros/json_diagnostic_positions.md
          - 'JSON_DISABLE_ENUM_SERIALIZATION': api/macros/json_disable_enum_serialization.md
          - 'JSON_DISABLE_TUPLE_REFERENCE_CONVERSION': api/macros/json_disable_tuple_reference_conversion.md
@@ -172,7 +172,7 @@ inline void from_json(const BasicJsonType& j, EnumType& e)
          typename BasicJsonType::number_unsigned_t, underlying_type>::type;
    value_type val;
    get_arithmetic_value(j, val);
-    e = static_cast<EnumType>(bool_aware_static_cast<underlying_type>(val));
+    e = static_cast<EnumType>(static_cast<underlying_type>(val));
 }
 #endif  // JSON_DISABLE_ENUM_SERIALIZATION

@@ -365,7 +365,7 @@ inline void to_json(BasicJsonType& j, EnumType e) noexcept
 {
    using underlying_type = typename std::underlying_type<EnumType>::type;
    static constexpr value_t integral_value_t = std::is_unsigned<underlying_type>::value ? value_t::number_unsigned : value_t::number_integer;
-    external_constructor<integral_value_t>::construct(j, bool_aware_static_cast<underlying_type>(e));
+    external_constructor<integral_value_t>::construct(j, static_cast<underlying_type>(e));
 }
 #endif  // JSON_DISABLE_ENUM_SERIALIZATION

@@ -662,11 +662,10 @@ class binary_reader
        }

        // the value is -1 - number, which fits into number_integer_t
-        // whenever number does; the outer cast undoes the integral promotion
-        // for number_integer_t types narrower than int
+        // whenever number does
        if (JSON_HEDLEY_LIKELY(value_in_range_of<number_integer_t>(number)))
        {
-            return sax->number_integer(conditional_static_cast<number_integer_t>(static_cast<number_integer_t>(-1) - static_cast<number_integer_t>(number)));
+            return sax->number_integer(static_cast<number_integer_t>(-1) - static_cast<number_integer_t>(number));
        }

        // like the lexer does for JSON text, store a value too small for
@@ -4004,8 +4003,7 @@ class binary_reader
        {
            return sax->number_unsigned(static_cast<number_unsigned_t>(number));
        }
-        // std::isfinite has no integer overloads in MSVC's <cmath>
-        return emit_float(static_cast<long double>(number));
+        return emit_float(number);
    }

    /*!
@@ -4028,8 +4026,7 @@ class binary_reader
        {
            return sax->number_unsigned(static_cast<number_unsigned_t>(number));
        }
-        // std::isfinite has no integer overloads in MSVC's <cmath>
-        return emit_float(static_cast<long double>(number));
+        return emit_float(number);
    }

    /*!
@@ -4040,8 +4037,7 @@ class binary_reader
    and NaN in the input are passed on unchanged. Integers only overflow if
    number_float_t cannot represent 2^64, e.g., a half-precision type.

-    @tparam NumberType a floating-point type (emit_signed and emit_unsigned
-                       convert integers to long double first)
+    @tparam NumberType a floating-point or integer type
    @param[in] number  the number
    @return whether the SAX parser accepted the value

@@ -81,13 +81,9 @@ class json_pointer
    /// @sa https://json.nlohmann.me/api/json_pointer/operator_string_t/
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, to_string())
    operator string_t() const
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
    {
        return to_string();
    }
-#endif

 #ifndef JSON_NO_IO
    /// @brief write string representation of the JSON pointer to stream
@@ -1026,13 +1022,9 @@ class json_pointer
    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
    JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer))
    bool operator==(const string_t& rhs) const
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
    {
        return *this == json_pointer(rhs);
    }
-#endif

    /// @brief 3-way compares two JSON pointers
    template<typename RefStringTypeRhs>
@@ -1110,26 +1102,18 @@ template<typename RefStringTypeLhs,
 JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer))
 inline bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
                       const StringType& rhs)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
 {
    return lhs == json_pointer<RefStringTypeLhs>(rhs);
 }
-#endif

 template<typename RefStringTypeRhs,
         typename StringType = typename json_pointer<RefStringTypeRhs>::string_t>
 JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer))
 inline bool operator==(const StringType& lhs,
                       const json_pointer<RefStringTypeRhs>& rhs)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
 {
    return json_pointer<RefStringTypeRhs>(lhs) == rhs;
 }
-#endif

 template<typename RefStringTypeLhs, typename RefStringTypeRhs>
 inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
@@ -1143,26 +1127,18 @@ template<typename RefStringTypeLhs,
 JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer))
 inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
                       const StringType& rhs)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
 {
    return !(lhs == rhs);
 }
-#endif

 template<typename RefStringTypeRhs,
         typename StringType = typename json_pointer<RefStringTypeRhs>::string_t>
 JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer))
 inline bool operator!=(const StringType& lhs,
                       const json_pointer<RefStringTypeRhs>& rhs)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
 {
    return !(lhs == rhs);
 }
-#endif

 template<typename RefStringTypeLhs, typename RefStringTypeRhs>
 inline bool operator<(const json_pointer<RefStringTypeLhs>& lhs,
@@ -888,10 +888,6 @@
    #define JSON_DISABLE_ENUM_SERIALIZATION 0
 #endif

-#ifndef JSON_DELETE_DEPRECATED_FUNCTIONS
-    #define JSON_DELETE_DEPRECATED_FUNCTIONS 0
-#endif
-
 #ifndef JSON_DISABLE_TUPLE_REFERENCE_CONVERSION
    #define JSON_DISABLE_TUPLE_REFERENCE_CONVERSION 0
 #endif
@@ -43,7 +43,6 @@
    #undef JSON_PRECISE_STREAM_POSITION
    #undef JSON_STRICT_NUL_HANDLING
    #undef JSON_STRICT_BINARY_UTF8
-    #undef JSON_DELETE_DEPRECATED_FUNCTIONS
    #undef JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
 #endif

@@ -906,21 +906,6 @@ T conditional_static_cast(U value)
    return value;
 }

-// like conditional_static_cast, but converts to bool by comparing with zero,
-// because MSVC 2015 warns about any conversion to bool (C4800), even with an
-// explicit cast; used for enums whose underlying type is bool
-template < typename T, typename U, enable_if_t < !std::is_same<T, bool>::value, int > = 0 >
-T bool_aware_static_cast(U value)
-{
-    return conditional_static_cast<T>(value);
-}
-
-template<typename T, typename U, enable_if_t<std::is_same<T, bool>::value, int> = 0>
-bool bool_aware_static_cast(U value)
-{
-    return value != U();
-}
-
 template<typename... Types>
 using all_integral = conjunction<std::is_integral<Types>...>;

@@ -226,6 +226,70 @@ 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 //
    ////////////////
@@ -3492,13 +3556,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
    ValueType value(const ::nlohmann::json_pointer<BasicJsonType>& ptr, const ValueType& default_value) const
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return value(ptr.convert(), default_value);
    }
-#endif

    template < class ValueType, class BasicJsonType, class ReturnType = typename value_return_type<ValueType>::type,
               detail::enable_if_t <
@@ -3507,13 +3567,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
    ReturnType value(const ::nlohmann::json_pointer<BasicJsonType>& ptr, ValueType && default_value) const
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return value(ptr.convert(), std::forward<ValueType>(default_value));
    }
-#endif

    /// @brief access the first element
    /// @sa https://json.nlohmann.me/api/basic_json/front/
@@ -3871,13 +3927,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    JSON_HEDLEY_WARN_UNUSED_RESULT
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
    bool contains(const typename ::nlohmann::json_pointer<BasicJsonType>& ptr) const
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return ptr.contains(this);
    }
-#endif

    /// @}

@@ -3988,13 +4040,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    ///             that is, replace `json::iterator_wrapper(j)` with `j.items()`.
    JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
    static iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
    {
        return ref.items();
    }
-#endif

    /// @brief wrapper to access iterator member functions in range-based for
    /// @sa https://json.nlohmann.me/api/basic_json/items/
@@ -4003,13 +4051,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    ///         that is, replace `json::iterator_wrapper(j)` with `j.items()`.
    JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
    static iteration_proxy<const_iterator> iterator_wrapper(const_reference ref) noexcept
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
    {
        return ref.items();
    }
-#endif

    /// @brief helper to access iterator member functions in range-based for
    /// @sa https://json.nlohmann.me/api/basic_json/items/
@@ -5098,7 +5142,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
    template<typename ScalarType>
    requires std::is_scalar_v<ScalarType>
-    friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(rhs)>, ScalarType>::value)
+    friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return basic_json(lhs) <= rhs;
    }
@@ -5107,7 +5151,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
    template<typename ScalarType>
    requires std::is_scalar_v<ScalarType>
-    friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(rhs)>, ScalarType>::value)
+    friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return basic_json(lhs) >= rhs;
    }
@@ -5128,16 +5172,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 #endif
    }

-    // The friend comparisons with a scalar name the JSON type via decltype of
-    // their parameter in noexcept, because older MSVC versions do not see the
-    // class scope there: MSVC 2015 and 2017 take basic_json as the template,
-    // and MSVC 2019 16.0 rejects member types and template parameters.
-
    /// @brief comparison: equal
    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator==(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(lhs)>, ScalarType>::value)
+    friend bool operator==(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return lhs == basic_json(rhs);
    }
@@ -5146,7 +5185,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator==(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(rhs)>, ScalarType>::value)
+    friend bool operator==(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return basic_json(lhs) == rhs;
    }
@@ -5162,7 +5201,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator!=(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(lhs)>, ScalarType>::value)
+    friend bool operator!=(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return lhs != basic_json(rhs);
    }
@@ -5171,7 +5210,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator!=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(rhs)>, ScalarType>::value)
+    friend bool operator!=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return basic_json(lhs) != rhs;
    }
@@ -5191,7 +5230,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator<(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(lhs)>, ScalarType>::value)
+    friend bool operator<(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return lhs < basic_json(rhs);
    }
@@ -5200,7 +5239,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator<(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(rhs)>, ScalarType>::value)
+    friend bool operator<(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return basic_json(lhs) < rhs;
    }
@@ -5220,7 +5259,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator<=(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(lhs)>, ScalarType>::value)
+    friend bool operator<=(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return lhs <= basic_json(rhs);
    }
@@ -5229,7 +5268,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(rhs)>, ScalarType>::value)
+    friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return basic_json(lhs) <= rhs;
    }
@@ -5250,7 +5289,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator>(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(lhs)>, ScalarType>::value)
+    friend bool operator>(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return lhs > basic_json(rhs);
    }
@@ -5259,7 +5298,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator>(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(rhs)>, ScalarType>::value)
+    friend bool operator>(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return basic_json(lhs) > rhs;
    }
@@ -5279,7 +5318,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator>=(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(lhs)>, ScalarType>::value)
+    friend bool operator>=(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return lhs >= basic_json(rhs);
    }
@@ -5288,7 +5327,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(rhs)>, ScalarType>::value)
+    friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return basic_json(lhs) >= rhs;
    }
@@ -5324,9 +5363,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        return o;
    }

-#if !JSON_DELETE_DEPRECATED_FUNCTIONS
-    // the deleted version is a function template after the class, because
-    // GCC < 5 and Clang < 10 reject deleted friend functions in class templates
    /// @brief serialize to stream
    /// @sa https://json.nlohmann.me/api/operator_ltlt/
    /// @deprecated This function is deprecated since 3.0.0 and will be removed in
@@ -5338,7 +5374,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    {
        return o << j;
    }
-#endif
 #endif  // JSON_NO_IO
    /// @}

@@ -5390,16 +5425,12 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                            const bool allow_exceptions = true,
                            const bool ignore_comments = false,
                            const bool ignore_trailing_commas = false)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
    {
        basic_json result;
        auto p = parser(i.get(), std::move(cb), allow_exceptions, ignore_comments, ignore_trailing_commas);
        p.parse(true, result);
        return result;
    }
-#endif

    /// @brief check if the input is valid JSON
    /// @sa https://json.nlohmann.me/api/basic_json/accept/
@@ -5429,13 +5460,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    static bool accept(detail::span_input_adapter&& i,
                       const bool ignore_comments = false,
                       const bool ignore_trailing_commas = false)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
    {
        return parser(i.get(), nullptr, false, ignore_comments, ignore_trailing_commas, true).accept(true);
    }
-#endif

    /// @brief generate SAX events
    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
@@ -5496,9 +5523,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                          const bool strict = true,
                          const bool ignore_comments = false,
                          const bool ignore_trailing_commas = false)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        auto ia = i.get();
        return format == input_format_t::json
@@ -5507,14 +5531,10 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
               // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(sax, strict);
    }
-#endif
 #if defined(__clang__)
 #pragma clang diagnostic pop
 #endif
 #ifndef JSON_NO_IO
-#if !JSON_DELETE_DEPRECATED_FUNCTIONS
-    // the deleted version is a function template after the class, because
-    // GCC < 5 and Clang < 10 reject deleted friend functions in class templates
    /// @brief deserialize from stream
    /// @sa https://json.nlohmann.me/api/operator_gtgt/
    /// @deprecated This stream operator is deprecated since 3.0.0 and will be removed in
@@ -5526,7 +5546,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    {
        return operator>>(i, j);
    }
-#endif

    /// @brief deserialize from stream
    /// @sa https://json.nlohmann.me/api/operator_gtgt/
@@ -5874,13 +5893,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                                const bool strict = true,
                                const bool allow_exceptions = true,
                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
    }
-#endif

    JSON_HEDLEY_WARN_UNUSED_RESULT
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
@@ -5888,13 +5903,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                                const bool strict = true,
                                const bool allow_exceptions = true,
                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
    {
        return from_binary_impl(i.get(), input_format_t::cbor, strict, allow_exceptions, error_handler_t::keep, tag_handler);
    }
-#endif

    /// @brief create a JSON value from an input in MessagePack format
    /// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/
@@ -5927,26 +5938,18 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    static basic_json from_msgpack(const T* ptr, std::size_t len,
                                   const bool strict = true,
                                   const bool allow_exceptions = true)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return from_msgpack(ptr, ptr + len, strict, allow_exceptions);
    }
-#endif

    JSON_HEDLEY_WARN_UNUSED_RESULT
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
    static basic_json from_msgpack(detail::span_input_adapter&& i,
                                   const bool strict = true,
                                   const bool allow_exceptions = true)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
    {
        return from_binary_impl(i.get(), input_format_t::msgpack, strict, allow_exceptions);
    }
-#endif

    /// @brief create a JSON value from an input in UBJSON format
    /// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/
@@ -5979,26 +5982,18 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    static basic_json from_ubjson(const T* ptr, std::size_t len,
                                  const bool strict = true,
                                  const bool allow_exceptions = true)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return from_ubjson(ptr, ptr + len, strict, allow_exceptions);
    }
-#endif

    JSON_HEDLEY_WARN_UNUSED_RESULT
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
    static basic_json from_ubjson(detail::span_input_adapter&& i,
                                  const bool strict = true,
                                  const bool allow_exceptions = true)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
    {
        return from_binary_impl(i.get(), input_format_t::ubjson, strict, allow_exceptions);
    }
-#endif

    /// @brief create a JSON value from an input in BJData format
    /// @sa https://json.nlohmann.me/api/basic_json/from_bjdata/
@@ -6025,20 +6020,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        return from_binary_impl(detail::input_adapter(std::move(first), std::move(last)), input_format_t::bjdata, strict, allow_exceptions, error_handler);
    }

-    template<typename T>
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    JSON_HEDLEY_DEPRECATED_FOR(3.13.0, from_bjdata(ptr, ptr + len))
-    static basic_json from_bjdata(const T* ptr, std::size_t len,
-                                  const bool strict = true,
-                                  const bool allow_exceptions = true)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
-    {
-        return from_bjdata(ptr, ptr + len, strict, allow_exceptions);
-    }
-#endif
-
    /// @brief create a JSON value from an input in BON8 format
    /// @sa https://json.nlohmann.me/api/basic_json/from_bon8/
    template<typename InputType>
@@ -6062,20 +6043,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        return from_binary_impl(detail::input_adapter(std::move(first), std::move(last)), input_format_t::bon8, strict, allow_exceptions);
    }

-    template<typename T>
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    JSON_HEDLEY_DEPRECATED_FOR(3.13.0, from_bon8(ptr, ptr + len))
-    static basic_json from_bon8(const T* ptr, std::size_t len,
-                                const bool strict = true,
-                                const bool allow_exceptions = true)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
-    {
-        return from_bon8(ptr, ptr + len, strict, allow_exceptions);
-    }
-#endif
-
    /// @brief create a JSON value from an input in BSON format
    /// @sa https://json.nlohmann.me/api/basic_json/from_bson/
    template<typename InputType>
@@ -6107,26 +6074,18 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    static basic_json from_bson(const T* ptr, std::size_t len,
                                const bool strict = true,
                                const bool allow_exceptions = true)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return from_bson(ptr, ptr + len, strict, allow_exceptions);
    }
-#endif

    JSON_HEDLEY_WARN_UNUSED_RESULT
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
    static basic_json from_bson(detail::span_input_adapter&& i,
                                const bool strict = true,
                                const bool allow_exceptions = true)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
    {
        return from_binary_impl(i.get(), input_format_t::bson, strict, allow_exceptions);
    }
-#endif
    /// @}

    //////////////////////////
@@ -6146,13 +6105,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
    reference operator[](const ::nlohmann::json_pointer<BasicJsonType>& ptr)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return ptr.get_unchecked(this);
    }
-#endif

    /// @brief access specified element via JSON Pointer
    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
@@ -6164,13 +6119,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
    const_reference operator[](const ::nlohmann::json_pointer<BasicJsonType>& ptr) const
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return ptr.get_unchecked(this);
    }
-#endif

    /// @brief access specified element via JSON Pointer
    /// @sa https://json.nlohmann.me/api/basic_json/at/
@@ -6182,13 +6133,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
    reference at(const ::nlohmann::json_pointer<BasicJsonType>& ptr)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return ptr.get_checked(this);
    }
-#endif

    /// @brief access specified element via JSON Pointer
    /// @sa https://json.nlohmann.me/api/basic_json/at/
@@ -6200,13 +6147,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
    const_reference at(const ::nlohmann::json_pointer<BasicJsonType>& ptr) const
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return ptr.get_checked(this);
    }
-#endif

    /// @brief return flattened JSON value
    /// @sa https://json.nlohmann.me/api/basic_json/flatten/
@@ -7183,18 +7126,6 @@ std::string format_as(const NLOHMANN_BASIC_JSON_TPL& j)
    return j.dump();
 }

-#if JSON_DELETE_DEPRECATED_FUNCTIONS && !defined(JSON_NO_IO)
-    /// @brief serialize to stream (deleted; use operator<<(std::ostream&, const basic_json&))
-    /// @sa https://json.nlohmann.me/api/operator_ltlt/
-    NLOHMANN_BASIC_JSON_TPL_DECLARATION
-    std::ostream& operator>>(const NLOHMANN_BASIC_JSON_TPL& j, std::ostream& o) = delete;
-
-    /// @brief deserialize from stream (deleted; use operator>>(std::istream&, basic_json&))
-    /// @sa https://json.nlohmann.me/api/operator_gtgt/
-    NLOHMANN_BASIC_JSON_TPL_DECLARATION
-    std::istream& operator<<(NLOHMANN_BASIC_JSON_TPL& j, std::istream& i) = delete;
-#endif
-
 NLOHMANN_JSON_NAMESPACE_END

 ///////////////////////
@@ -3225,10 +3225,6 @@ JSON_HEDLEY_DIAGNOSTIC_POP
    #define JSON_DISABLE_ENUM_SERIALIZATION 0
 #endif

-#ifndef JSON_DELETE_DEPRECATED_FUNCTIONS
-    #define JSON_DELETE_DEPRECATED_FUNCTIONS 0
-#endif
-
 #ifndef JSON_DISABLE_TUPLE_REFERENCE_CONVERSION
    #define JSON_DISABLE_TUPLE_REFERENCE_CONVERSION 0
 #endif
@@ -4905,21 +4901,6 @@ T conditional_static_cast(U value)
    return value;
 }

-// like conditional_static_cast, but converts to bool by comparing with zero,
-// because MSVC 2015 warns about any conversion to bool (C4800), even with an
-// explicit cast; used for enums whose underlying type is bool
-template < typename T, typename U, enable_if_t < !std::is_same<T, bool>::value, int > = 0 >
-T bool_aware_static_cast(U value)
-{
-    return conditional_static_cast<T>(value);
-}
-
-template<typename T, typename U, enable_if_t<std::is_same<T, bool>::value, int> = 0>
-bool bool_aware_static_cast(U value)
-{
-    return value != U();
-}
-
 template<typename... Types>
 using all_integral = conjunction<std::is_integral<Types>...>;

@@ -5715,7 +5696,7 @@ inline void from_json(const BasicJsonType& j, EnumType& e)
          typename BasicJsonType::number_unsigned_t, underlying_type>::type;
    value_type val;
    get_arithmetic_value(j, val);
-    e = static_cast<EnumType>(bool_aware_static_cast<underlying_type>(val));
+    e = static_cast<EnumType>(static_cast<underlying_type>(val));
 }
 #endif  // JSON_DISABLE_ENUM_SERIALIZATION

@@ -7159,7 +7140,7 @@ inline void to_json(BasicJsonType& j, EnumType e) noexcept
 {
    using underlying_type = typename std::underlying_type<EnumType>::type;
    static constexpr value_t integral_value_t = std::is_unsigned<underlying_type>::value ? value_t::number_unsigned : value_t::number_integer;
-    external_constructor<integral_value_t>::construct(j, bool_aware_static_cast<underlying_type>(e));
+    external_constructor<integral_value_t>::construct(j, static_cast<underlying_type>(e));
 }
 #endif  // JSON_DISABLE_ENUM_SERIALIZATION

@@ -14368,11 +14349,10 @@ class binary_reader
        }

        // the value is -1 - number, which fits into number_integer_t
-        // whenever number does; the outer cast undoes the integral promotion
-        // for number_integer_t types narrower than int
+        // whenever number does
        if (JSON_HEDLEY_LIKELY(value_in_range_of<number_integer_t>(number)))
        {
-            return sax->number_integer(conditional_static_cast<number_integer_t>(static_cast<number_integer_t>(-1) - static_cast<number_integer_t>(number)));
+            return sax->number_integer(static_cast<number_integer_t>(-1) - static_cast<number_integer_t>(number));
        }

        // like the lexer does for JSON text, store a value too small for
@@ -17710,8 +17690,7 @@ class binary_reader
        {
            return sax->number_unsigned(static_cast<number_unsigned_t>(number));
        }
-        // std::isfinite has no integer overloads in MSVC's <cmath>
-        return emit_float(static_cast<long double>(number));
+        return emit_float(number);
    }

    /*!
@@ -17734,8 +17713,7 @@ class binary_reader
        {
            return sax->number_unsigned(static_cast<number_unsigned_t>(number));
        }
-        // std::isfinite has no integer overloads in MSVC's <cmath>
-        return emit_float(static_cast<long double>(number));
+        return emit_float(number);
    }

    /*!
@@ -17746,8 +17724,7 @@ class binary_reader
    and NaN in the input are passed on unchanged. Integers only overflow if
    number_float_t cannot represent 2^64, e.g., a half-precision type.

-    @tparam NumberType a floating-point type (emit_signed and emit_unsigned
-                       convert integers to long double first)
+    @tparam NumberType a floating-point or integer type
    @param[in] number  the number
    @return whether the SAX parser accepted the value

@@ -19953,13 +19930,9 @@ class json_pointer
    /// @sa https://json.nlohmann.me/api/json_pointer/operator_string_t/
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, to_string())
    operator string_t() const
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
    {
        return to_string();
    }
-#endif

 #ifndef JSON_NO_IO
    /// @brief write string representation of the JSON pointer to stream
@@ -20898,13 +20871,9 @@ class json_pointer
    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
    JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer))
    bool operator==(const string_t& rhs) const
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
    {
        return *this == json_pointer(rhs);
    }
-#endif

    /// @brief 3-way compares two JSON pointers
    template<typename RefStringTypeRhs>
@@ -20982,26 +20951,18 @@ template<typename RefStringTypeLhs,
 JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer))
 inline bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
                       const StringType& rhs)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
 {
    return lhs == json_pointer<RefStringTypeLhs>(rhs);
 }
-#endif

 template<typename RefStringTypeRhs,
         typename StringType = typename json_pointer<RefStringTypeRhs>::string_t>
 JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer))
 inline bool operator==(const StringType& lhs,
                       const json_pointer<RefStringTypeRhs>& rhs)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
 {
    return json_pointer<RefStringTypeRhs>(lhs) == rhs;
 }
-#endif

 template<typename RefStringTypeLhs, typename RefStringTypeRhs>
 inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
@@ -21015,26 +20976,18 @@ template<typename RefStringTypeLhs,
 JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer))
 inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
                       const StringType& rhs)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
 {
    return !(lhs == rhs);
 }
-#endif

 template<typename RefStringTypeRhs,
         typename StringType = typename json_pointer<RefStringTypeRhs>::string_t>
 JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer))
 inline bool operator!=(const StringType& lhs,
                       const json_pointer<RefStringTypeRhs>& rhs)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
 {
    return !(lhs == rhs);
 }
-#endif

 template<typename RefStringTypeLhs, typename RefStringTypeRhs>
 inline bool operator<(const json_pointer<RefStringTypeLhs>& lhs,
@@ -27395,6 +27348,70 @@ 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 //
    ////////////////
@@ -30661,13 +30678,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
    ValueType value(const ::nlohmann::json_pointer<BasicJsonType>& ptr, const ValueType& default_value) const
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return value(ptr.convert(), default_value);
    }
-#endif

    template < class ValueType, class BasicJsonType, class ReturnType = typename value_return_type<ValueType>::type,
               detail::enable_if_t <
@@ -30676,13 +30689,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
    ReturnType value(const ::nlohmann::json_pointer<BasicJsonType>& ptr, ValueType && default_value) const
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return value(ptr.convert(), std::forward<ValueType>(default_value));
    }
-#endif

    /// @brief access the first element
    /// @sa https://json.nlohmann.me/api/basic_json/front/
@@ -31040,13 +31049,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    JSON_HEDLEY_WARN_UNUSED_RESULT
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
    bool contains(const typename ::nlohmann::json_pointer<BasicJsonType>& ptr) const
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return ptr.contains(this);
    }
-#endif

    /// @}

@@ -31157,13 +31162,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    ///             that is, replace `json::iterator_wrapper(j)` with `j.items()`.
    JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
    static iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
    {
        return ref.items();
    }
-#endif

    /// @brief wrapper to access iterator member functions in range-based for
    /// @sa https://json.nlohmann.me/api/basic_json/items/
@@ -31172,13 +31173,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    ///         that is, replace `json::iterator_wrapper(j)` with `j.items()`.
    JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
    static iteration_proxy<const_iterator> iterator_wrapper(const_reference ref) noexcept
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
    {
        return ref.items();
    }
-#endif

    /// @brief helper to access iterator member functions in range-based for
    /// @sa https://json.nlohmann.me/api/basic_json/items/
@@ -32267,7 +32264,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
    template<typename ScalarType>
    requires std::is_scalar_v<ScalarType>
-    friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(rhs)>, ScalarType>::value)
+    friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return basic_json(lhs) <= rhs;
    }
@@ -32276,7 +32273,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
    template<typename ScalarType>
    requires std::is_scalar_v<ScalarType>
-    friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(rhs)>, ScalarType>::value)
+    friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return basic_json(lhs) >= rhs;
    }
@@ -32297,16 +32294,11 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
 #endif
    }

-    // The friend comparisons with a scalar name the JSON type via decltype of
-    // their parameter in noexcept, because older MSVC versions do not see the
-    // class scope there: MSVC 2015 and 2017 take basic_json as the template,
-    // and MSVC 2019 16.0 rejects member types and template parameters.
-
    /// @brief comparison: equal
    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator==(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(lhs)>, ScalarType>::value)
+    friend bool operator==(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return lhs == basic_json(rhs);
    }
@@ -32315,7 +32307,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator==(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(rhs)>, ScalarType>::value)
+    friend bool operator==(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return basic_json(lhs) == rhs;
    }
@@ -32331,7 +32323,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator!=(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(lhs)>, ScalarType>::value)
+    friend bool operator!=(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return lhs != basic_json(rhs);
    }
@@ -32340,7 +32332,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator!=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(rhs)>, ScalarType>::value)
+    friend bool operator!=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return basic_json(lhs) != rhs;
    }
@@ -32360,7 +32352,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator<(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(lhs)>, ScalarType>::value)
+    friend bool operator<(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return lhs < basic_json(rhs);
    }
@@ -32369,7 +32361,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator<(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(rhs)>, ScalarType>::value)
+    friend bool operator<(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return basic_json(lhs) < rhs;
    }
@@ -32389,7 +32381,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator<=(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(lhs)>, ScalarType>::value)
+    friend bool operator<=(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return lhs <= basic_json(rhs);
    }
@@ -32398,7 +32390,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(rhs)>, ScalarType>::value)
+    friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return basic_json(lhs) <= rhs;
    }
@@ -32419,7 +32411,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator>(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(lhs)>, ScalarType>::value)
+    friend bool operator>(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return lhs > basic_json(rhs);
    }
@@ -32428,7 +32420,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator>(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(rhs)>, ScalarType>::value)
+    friend bool operator>(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return basic_json(lhs) > rhs;
    }
@@ -32448,7 +32440,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator>=(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(lhs)>, ScalarType>::value)
+    friend bool operator>=(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return lhs >= basic_json(rhs);
    }
@@ -32457,7 +32449,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(rhs)>, ScalarType>::value)
+    friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return basic_json(lhs) >= rhs;
    }
@@ -32493,9 +32485,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        return o;
    }

-#if !JSON_DELETE_DEPRECATED_FUNCTIONS
-    // the deleted version is a function template after the class, because
-    // GCC < 5 and Clang < 10 reject deleted friend functions in class templates
    /// @brief serialize to stream
    /// @sa https://json.nlohmann.me/api/operator_ltlt/
    /// @deprecated This function is deprecated since 3.0.0 and will be removed in
@@ -32507,7 +32496,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    {
        return o << j;
    }
-#endif
 #endif  // JSON_NO_IO
    /// @}

@@ -32559,16 +32547,12 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                            const bool allow_exceptions = true,
                            const bool ignore_comments = false,
                            const bool ignore_trailing_commas = false)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
    {
        basic_json result;
        auto p = parser(i.get(), std::move(cb), allow_exceptions, ignore_comments, ignore_trailing_commas);
        p.parse(true, result);
        return result;
    }
-#endif

    /// @brief check if the input is valid JSON
    /// @sa https://json.nlohmann.me/api/basic_json/accept/
@@ -32598,13 +32582,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    static bool accept(detail::span_input_adapter&& i,
                       const bool ignore_comments = false,
                       const bool ignore_trailing_commas = false)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
    {
        return parser(i.get(), nullptr, false, ignore_comments, ignore_trailing_commas, true).accept(true);
    }
-#endif

    /// @brief generate SAX events
    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
@@ -32665,9 +32645,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                          const bool strict = true,
                          const bool ignore_comments = false,
                          const bool ignore_trailing_commas = false)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        auto ia = i.get();
        return format == input_format_t::json
@@ -32676,14 +32653,10 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
               // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(sax, strict);
    }
-#endif
 #if defined(__clang__)
 #pragma clang diagnostic pop
 #endif
 #ifndef JSON_NO_IO
-#if !JSON_DELETE_DEPRECATED_FUNCTIONS
-    // the deleted version is a function template after the class, because
-    // GCC < 5 and Clang < 10 reject deleted friend functions in class templates
    /// @brief deserialize from stream
    /// @sa https://json.nlohmann.me/api/operator_gtgt/
    /// @deprecated This stream operator is deprecated since 3.0.0 and will be removed in
@@ -32695,7 +32668,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    {
        return operator>>(i, j);
    }
-#endif

    /// @brief deserialize from stream
    /// @sa https://json.nlohmann.me/api/operator_gtgt/
@@ -33043,13 +33015,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                                const bool strict = true,
                                const bool allow_exceptions = true,
                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
    }
-#endif

    JSON_HEDLEY_WARN_UNUSED_RESULT
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
@@ -33057,13 +33025,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                                const bool strict = true,
                                const bool allow_exceptions = true,
                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
    {
        return from_binary_impl(i.get(), input_format_t::cbor, strict, allow_exceptions, error_handler_t::keep, tag_handler);
    }
-#endif

    /// @brief create a JSON value from an input in MessagePack format
    /// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/
@@ -33096,26 +33060,18 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    static basic_json from_msgpack(const T* ptr, std::size_t len,
                                   const bool strict = true,
                                   const bool allow_exceptions = true)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return from_msgpack(ptr, ptr + len, strict, allow_exceptions);
    }
-#endif

    JSON_HEDLEY_WARN_UNUSED_RESULT
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
    static basic_json from_msgpack(detail::span_input_adapter&& i,
                                   const bool strict = true,
                                   const bool allow_exceptions = true)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
    {
        return from_binary_impl(i.get(), input_format_t::msgpack, strict, allow_exceptions);
    }
-#endif

    /// @brief create a JSON value from an input in UBJSON format
    /// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/
@@ -33148,26 +33104,18 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    static basic_json from_ubjson(const T* ptr, std::size_t len,
                                  const bool strict = true,
                                  const bool allow_exceptions = true)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return from_ubjson(ptr, ptr + len, strict, allow_exceptions);
    }
-#endif

    JSON_HEDLEY_WARN_UNUSED_RESULT
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
    static basic_json from_ubjson(detail::span_input_adapter&& i,
                                  const bool strict = true,
                                  const bool allow_exceptions = true)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
    {
        return from_binary_impl(i.get(), input_format_t::ubjson, strict, allow_exceptions);
    }
-#endif

    /// @brief create a JSON value from an input in BJData format
    /// @sa https://json.nlohmann.me/api/basic_json/from_bjdata/
@@ -33194,20 +33142,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        return from_binary_impl(detail::input_adapter(std::move(first), std::move(last)), input_format_t::bjdata, strict, allow_exceptions, error_handler);
    }

-    template<typename T>
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    JSON_HEDLEY_DEPRECATED_FOR(3.13.0, from_bjdata(ptr, ptr + len))
-    static basic_json from_bjdata(const T* ptr, std::size_t len,
-                                  const bool strict = true,
-                                  const bool allow_exceptions = true)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
-    {
-        return from_bjdata(ptr, ptr + len, strict, allow_exceptions);
-    }
-#endif
-
    /// @brief create a JSON value from an input in BON8 format
    /// @sa https://json.nlohmann.me/api/basic_json/from_bon8/
    template<typename InputType>
@@ -33231,20 +33165,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        return from_binary_impl(detail::input_adapter(std::move(first), std::move(last)), input_format_t::bon8, strict, allow_exceptions);
    }

-    template<typename T>
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    JSON_HEDLEY_DEPRECATED_FOR(3.13.0, from_bon8(ptr, ptr + len))
-    static basic_json from_bon8(const T* ptr, std::size_t len,
-                                const bool strict = true,
-                                const bool allow_exceptions = true)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
-    {
-        return from_bon8(ptr, ptr + len, strict, allow_exceptions);
-    }
-#endif
-
    /// @brief create a JSON value from an input in BSON format
    /// @sa https://json.nlohmann.me/api/basic_json/from_bson/
    template<typename InputType>
@@ -33276,26 +33196,18 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    static basic_json from_bson(const T* ptr, std::size_t len,
                                const bool strict = true,
                                const bool allow_exceptions = true)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return from_bson(ptr, ptr + len, strict, allow_exceptions);
    }
-#endif

    JSON_HEDLEY_WARN_UNUSED_RESULT
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
    static basic_json from_bson(detail::span_input_adapter&& i,
                                const bool strict = true,
                                const bool allow_exceptions = true)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
    {
        return from_binary_impl(i.get(), input_format_t::bson, strict, allow_exceptions);
    }
-#endif
    /// @}

    //////////////////////////
@@ -33315,13 +33227,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
    reference operator[](const ::nlohmann::json_pointer<BasicJsonType>& ptr)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return ptr.get_unchecked(this);
    }
-#endif

    /// @brief access specified element via JSON Pointer
    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
@@ -33333,13 +33241,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
    const_reference operator[](const ::nlohmann::json_pointer<BasicJsonType>& ptr) const
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return ptr.get_unchecked(this);
    }
-#endif

    /// @brief access specified element via JSON Pointer
    /// @sa https://json.nlohmann.me/api/basic_json/at/
@@ -33351,13 +33255,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
    reference at(const ::nlohmann::json_pointer<BasicJsonType>& ptr)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return ptr.get_checked(this);
    }
-#endif

    /// @brief access specified element via JSON Pointer
    /// @sa https://json.nlohmann.me/api/basic_json/at/
@@ -33369,13 +33269,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
    const_reference at(const ::nlohmann::json_pointer<BasicJsonType>& ptr) const
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return ptr.get_checked(this);
    }
-#endif

    /// @brief return flattened JSON value
    /// @sa https://json.nlohmann.me/api/basic_json/flatten/
@@ -34352,18 +34248,6 @@ std::string format_as(const NLOHMANN_BASIC_JSON_TPL& j)
    return j.dump();
 }

-#if JSON_DELETE_DEPRECATED_FUNCTIONS && !defined(JSON_NO_IO)
-    /// @brief serialize to stream (deleted; use operator<<(std::ostream&, const basic_json&))
-    /// @sa https://json.nlohmann.me/api/operator_ltlt/
-    NLOHMANN_BASIC_JSON_TPL_DECLARATION
-    std::ostream& operator>>(const NLOHMANN_BASIC_JSON_TPL& j, std::ostream& o) = delete;
-
-    /// @brief deserialize from stream (deleted; use operator>>(std::istream&, basic_json&))
-    /// @sa https://json.nlohmann.me/api/operator_gtgt/
-    NLOHMANN_BASIC_JSON_TPL_DECLARATION
-    std::istream& operator<<(NLOHMANN_BASIC_JSON_TPL& j, std::istream& i) = delete;
-#endif
-
 NLOHMANN_JSON_NAMESPACE_END

 ///////////////////////
@@ -34547,7 +34431,6 @@ struct formatter<nlohmann::NLOHMANN_BASIC_JSON_TPL, char> // NOLINT(cert-dcl58-c
    #undef JSON_PRECISE_STREAM_POSITION
    #undef JSON_STRICT_NUL_HANDLING
    #undef JSON_STRICT_BINARY_UTF8
-    #undef JSON_DELETE_DEPRECATED_FUNCTIONS
    #undef JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
 #endif

@@ -48,14 +48,7 @@ TEST_CASE("bad_alloc")
    SECTION("bad_alloc")
    {
        // create JSON type using the throwing allocator
-        using bad_json = nlohmann::basic_json<std::map,
-              std::vector,
-              std::string,
-              bool,
-              std::int64_t,
-              std::uint64_t,
-              double,
-              bad_allocator>;
+        using bad_json = nlohmann::json::with_allocator_t<bad_allocator>;

        // creating an object should throw
        CHECK_THROWS_AS(bad_json(bad_json::value_t::object), std::bad_alloc&);
@@ -129,14 +122,7 @@ void my_allocator_clean_up(T* p)
 TEST_CASE("controlled bad_alloc")
 {
    // create JSON type using the throwing allocator
-    using my_json = nlohmann::basic_json<std::map,
-          std::vector,
-          std::string,
-          bool,
-          std::int64_t,
-          std::uint64_t,
-          double,
-          my_allocator>;
+    using my_json = nlohmann::json::with_allocator_t<my_allocator>;

    SECTION("class json_value")
    {
@@ -521,10 +507,6 @@ struct countdown_allocator : std::allocator<T>

 TEST_CASE("converting a deeply nested value from another specialization fails cleanly (#5650)")
 {
-    // MSVC 2015's debug STL constructs the containers' debug proxies through
-    // the allocator in noexcept constructors, so a failing construction crashes
-    // the program there instead of throwing std::bad_alloc. Nothing to check.
-#if !(defined(_MSC_VER) && _MSC_VER < 1910 && defined(_ITERATOR_DEBUG_LEVEL) && _ITERATOR_DEBUG_LEVEL > 0)
    using countdown_json = nlohmann::basic_json<std::map,
          std::vector,
          std::string,
@@ -562,7 +544,6 @@ TEST_CASE("converting a deeply nested value from another specialization fails cl
        }
    }
    CHECK(failures > 0);
-#endif
 }

 namespace
@@ -593,14 +574,7 @@ TEST_CASE("bad my_allocator::construct")
 {
    SECTION("my_allocator::construct doesn't 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>;
+        using bad_alloc_json = nlohmann::json::with_allocator_t<allocator_no_forward>;

        bad_alloc_json j;
        j["test"] = bad_alloc_json::array_t();
@@ -163,16 +163,7 @@ void int_to_string(alt_string& target, std::size_t value)
    target = std::to_string(value).c_str();
 }

-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 >;
+using alt_json = nlohmann::json::with_string_t<alt_string>;

 bool operator<(const char* op1, const alt_string& op2) noexcept
 {
@@ -9,14 +9,6 @@
 #include "doctest_compatibility.h"

 #define JSON_TESTS_PRIVATE
-// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
-// line *before* including json.hpp, since the library #undefs it once the header
-// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
-// tests of deprecated functions are skipped if these functions are deleted
-#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
-    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-#endif
-
 #include <nlohmann/json.hpp>
 using nlohmann::json;

@@ -4498,33 +4490,3 @@ TEST_CASE("BJData roundtrips" * doctest::skip())
        }
    }
 }
-
-TEST_CASE("issue #5648 - from_bjdata(ptr, len) must read len bytes, not treat ptr as a C string")
-{
-    // to_bjdata() encodes the integer 0 as the two bytes 'i' 0x00 (a BJData
-    // type marker followed by the value byte 0x00), so the packed data
-    // below contains a 0x00 byte before its end.
-    const json j = {{"a", 0}};
-    const std::vector<std::uint8_t> packed = json::to_bjdata(j);
-    bool contains_nul = false;
-    for (const auto byte : packed)
-    {
-        contains_nul |= (byte == 0x00);
-    }
-    REQUIRE(contains_nul);
-
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-    // before the fix, from_bjdata had no (ptr, len) overload, so this call
-    // bound to from_bjdata(InputType&&, bool strict) instead: ptr was read
-    // as a NUL-terminated C string (stopping at the embedded 0x00 byte), and
-    // len was silently converted to the strict flag. The deprecated
-    // overload added for this issue forwards to from_bjdata(ptr, ptr + len,
-    // ...) instead, like from_ubjson's deprecated (ptr, len) overload does.
-    json result;
-    CHECK_NOTHROW(result = json::from_bjdata(packed.data(), packed.size()));
-    CHECK(result == j);
-
-    // len must not collapse into the strict flag either
-    CHECK(json::from_bjdata(packed.data(), packed.size(), false) == j);
-#endif
-}
@@ -8,14 +8,6 @@

 #include "doctest_compatibility.h"

-// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
-// line *before* including json.hpp, since the library #undefs it once the header
-// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
-// tests of deprecated functions are skipped if these functions are deleted
-#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
-    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-#endif
-
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 #ifdef JSON_TEST_NO_GLOBAL_UDLS
@@ -1022,36 +1014,6 @@ TEST_CASE("BON8 roundtrips" * doctest::skip())
    }
 }

-TEST_CASE("issue #5648 - from_bon8(ptr, len) must read len bytes, not treat ptr as a C string")
-{
-    // to_bon8() encodes the integer 40 as the two bytes 0xC2 0x00 (a BON8
-    // lead byte followed by a continuation byte of 0x00), so the packed data
-    // below contains a 0x00 byte before its end.
-    const json j = {{"a", 40}, {"b", "x"}};
-    const std::vector<std::uint8_t> packed = json::to_bon8(j);
-    bool contains_nul = false;
-    for (const auto byte : packed)
-    {
-        contains_nul |= (byte == 0x00);
-    }
-    REQUIRE(contains_nul);
-
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-    // before the fix, from_bon8 had no (ptr, len) overload, so this call
-    // bound to from_bon8(InputType&&, bool strict) instead: ptr was read as
-    // a NUL-terminated C string (stopping at the embedded 0x00 byte), and
-    // len was silently converted to the strict flag. The deprecated
-    // overload added for this issue forwards to from_bon8(ptr, ptr + len,
-    // ...) instead, like from_cbor's deprecated (ptr, len) overload does.
-    json result;
-    CHECK_NOTHROW(result = json::from_bon8(packed.data(), packed.size()));
-    CHECK(result == j);
-
-    // len must not collapse into the strict flag either
-    CHECK(json::from_bon8(packed.data(), packed.size(), false) == j);
-#endif
-}
-
 #ifdef JSON_HAS_CPP_17
 TEST_CASE("BON8 with std::byte")
 {
@@ -8,14 +8,6 @@

 #include "doctest_compatibility.h"

-// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
-// line *before* including json.hpp, since the library #undefs it once the header
-// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
-// tests of deprecated functions are skipped if these functions are deleted
-#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
-    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-#endif
-
 #include <nlohmann/json.hpp>
 using nlohmann::json;

@@ -1269,10 +1261,8 @@ TEST_CASE("BSON input that cannot be read is discarded by every overload")
    CHECK_THROWS_AS(_ = json::from_bson(input.begin(), input.end()), json::parse_error&);
    CHECK(json::from_bson(input, true, false).is_discarded());
    CHECK(json::from_bson(input.begin(), input.end(), true, false).is_discarded());
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
    CHECK(json::from_bson(input.data(), input.size(), true, false).is_discarded());
    CHECK(json::from_bson({input.data(), input.size()}, true, false).is_discarded());
-#endif
 }

 TEST_CASE("BSON SAX parsing stops at every event")
@@ -1750,7 +1740,6 @@ TEST_CASE("BSON roundtrips" * doctest::skip())
                CHECK(j1 == j2);
            }

-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
            {
                INFO_WITH_TEMP(filename + ": uint8_t* and size");
                // parse JSON file
@@ -1765,7 +1754,6 @@ TEST_CASE("BSON roundtrips" * doctest::skip())
                // compare parsed JSON values
                CHECK(j1 == j2);
            }
-#endif

            {
                INFO_WITH_TEMP(filename + ": output to output adapters");
@@ -8,14 +8,6 @@

 #include "doctest_compatibility.h"

-// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
-// line *before* including json.hpp, since the library #undefs it once the header
-// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
-// tests of deprecated functions are skipped if these functions are deleted
-#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
-    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-#endif
-
 #include <nlohmann/json.hpp>
 using nlohmann::json;

@@ -2223,10 +2215,8 @@ TEST_CASE("CBOR input that cannot be read is discarded by every overload")
    CHECK_THROWS_AS(_ = json::from_cbor(input.begin(), input.end()), json::parse_error&);
    CHECK(json::from_cbor(input, true, false).is_discarded());
    CHECK(json::from_cbor(input.begin(), input.end(), true, false).is_discarded());
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
    CHECK(json::from_cbor(input.data(), input.size(), true, false).is_discarded());
    CHECK(json::from_cbor({input.data(), input.size()}, true, false).is_discarded());
-#endif

    // a string that ends early, read through iterators that are not
    // contiguous and have to be copied from one element at a time
@@ -2623,14 +2613,12 @@ TEST_CASE("CBOR roundtrips" * doctest::skip())
                CHECK(j1 == j2);
            }

-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
            {
                INFO_WITH_TEMP(filename + ": uint8_t* and size");
                json j2;
                CHECK_NOTHROW(j2 = json::from_cbor({packed.data(), packed.size()}));
                CHECK(j1 == j2);
            }
-#endif

            {
                INFO_WITH_TEMP(filename + ": output to output adapters");
@@ -191,10 +191,8 @@ TEST_CASE("value conversion")
    {
        enum class bool_enum : bool { off, on };

-        // the extra parentheses keep doctest from printing the enum via its
-        // underlying type, which MSVC 2015 reports as C4800
-        CHECK((json(bool_enum::off).get<bool_enum>() == bool_enum::off));
-        CHECK((json(bool_enum::on).get<bool_enum>() == bool_enum::on));
+        CHECK(json(bool_enum::off).get<bool_enum>() == bool_enum::off);
+        CHECK(json(bool_enum::on).get<bool_enum>() == bool_enum::on);
    }
 #endif

@@ -853,10 +851,7 @@ TEST_CASE("std::optional")
        CHECK_THROWS_WITH_AS(json(opt), "cannot serialize throwing_to_json_type", std::runtime_error&);

        // the conversion is noexcept exactly when converting the contained value is
-        // (MSVC 2017 evaluates the conditional noexcept of this conversion as true)
-#if !defined(_MSC_VER) || _MSC_VER >= 1920
        static_assert(!std::is_nothrow_constructible<json, const std::optional<throwing_to_json_type>&>::value);
-#endif
        static_assert(std::is_nothrow_constructible<json, const std::optional<int>&>::value);
    }
 #endif
@@ -38,20 +38,7 @@ class json_metadata
 };

 template<class 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>
-    >;
+using json_with_metadata = nlohmann::json::with_base_class_t<json_metadata<T>>;

 TEST_CASE("JSON Node Metadata")
 {
@@ -268,19 +255,7 @@ class visitor_adaptor
    void do_visit(const Ptr& ptr, const Fnc& fnc) const;
 };

-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
-                            >;
+using json_with_visitor_t = nlohmann::json::with_base_class_t<visitor_adaptor>;

 template <class Fnc>
 void visitor_adaptor::visit(const Fnc& fnc) const
@@ -1,229 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include "doctest_compatibility.h"
-
-// This file tests the opt-in JSON_DELETE_DEPRECATED_FUNCTIONS, so it defines the
-// macro itself instead of relying on the build configuration.
-#ifdef JSON_DELETE_DEPRECATED_FUNCTIONS
-    #undef JSON_DELETE_DEPRECATED_FUNCTIONS
-#endif
-#define JSON_DELETE_DEPRECATED_FUNCTIONS 1
-
-#include <nlohmann/json.hpp>
-using nlohmann::json;
-
-#include <cstddef>
-#include <cstdint>
-#include <istream>
-#include <ostream>
-#include <sstream>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-namespace
-{
-template<typename...>
-struct make_void
-{
-    using type = void;
-};
-
-template<typename... Ts>
-using void_t = typename make_void<Ts...>::type;
-
-// A deleted function is still found by overload resolution, but naming it in an
-// unevaluated operand is ill-formed, so each of the following traits is false
-// exactly if the expression selects a deleted (or no) function.
-#define JSON_TEST_DETECT(name, expr)                                 \
-    template<typename J, typename = void>                            \
-    struct name : std::false_type {};                                \
-    template<typename J>                                             \
-    struct name<J, void_t<decltype(expr)>> : std::true_type {}
-
-using ptr_t = const std::uint8_t*;
-
-JSON_TEST_DETECT(from_cbor_ptr_len, J::from_cbor(std::declval<ptr_t>(), std::declval<std::size_t>()));
-JSON_TEST_DETECT(from_msgpack_ptr_len, J::from_msgpack(std::declval<ptr_t>(), std::declval<std::size_t>()));
-JSON_TEST_DETECT(from_ubjson_ptr_len, J::from_ubjson(std::declval<ptr_t>(), std::declval<std::size_t>()));
-JSON_TEST_DETECT(from_bjdata_ptr_len, J::from_bjdata(std::declval<ptr_t>(), std::declval<std::size_t>()));
-JSON_TEST_DETECT(from_bon8_ptr_len, J::from_bon8(std::declval<ptr_t>(), std::declval<std::size_t>()));
-JSON_TEST_DETECT(from_bson_ptr_len, J::from_bson(std::declval<ptr_t>(), std::declval<std::size_t>()));
-
-JSON_TEST_DETECT(from_cbor_ptr_ptr, J::from_cbor(std::declval<ptr_t>(), std::declval<ptr_t>()));
-JSON_TEST_DETECT(from_msgpack_ptr_ptr, J::from_msgpack(std::declval<ptr_t>(), std::declval<ptr_t>()));
-JSON_TEST_DETECT(from_ubjson_ptr_ptr, J::from_ubjson(std::declval<ptr_t>(), std::declval<ptr_t>()));
-JSON_TEST_DETECT(from_bjdata_ptr_ptr, J::from_bjdata(std::declval<ptr_t>(), std::declval<ptr_t>()));
-JSON_TEST_DETECT(from_bon8_ptr_ptr, J::from_bon8(std::declval<ptr_t>(), std::declval<ptr_t>()));
-JSON_TEST_DETECT(from_bson_ptr_ptr, J::from_bson(std::declval<ptr_t>(), std::declval<ptr_t>()));
-
-JSON_TEST_DETECT(from_cbor_init_list, J::from_cbor({std::declval<ptr_t>(), std::declval<std::size_t>()}));
-JSON_TEST_DETECT(from_msgpack_init_list, J::from_msgpack({std::declval<ptr_t>(), std::declval<std::size_t>()}));
-JSON_TEST_DETECT(from_ubjson_init_list, J::from_ubjson({std::declval<ptr_t>(), std::declval<std::size_t>()}));
-JSON_TEST_DETECT(from_bson_init_list, J::from_bson({std::declval<ptr_t>(), std::declval<std::size_t>()}));
-
-JSON_TEST_DETECT(parse_init_list, J::parse({std::declval<ptr_t>(), std::declval<std::size_t>()}));
-JSON_TEST_DETECT(accept_init_list, J::accept({std::declval<ptr_t>(), std::declval<std::size_t>()}));
-JSON_TEST_DETECT(sax_parse_init_list, J::sax_parse({std::declval<ptr_t>(), std::declval<std::size_t>()}, std::declval<nlohmann::json_sax<J>*>()));
-JSON_TEST_DETECT(parse_ptr_ptr, J::parse(std::declval<ptr_t>(), std::declval<ptr_t>()));
-
-JSON_TEST_DETECT(iterator_wrapper, J::iterator_wrapper(std::declval<J&>()));
-JSON_TEST_DETECT(iterator_wrapper_const, J::iterator_wrapper(std::declval<const J&>()));
-JSON_TEST_DETECT(items, std::declval<J&>().items());
-
-JSON_TEST_DETECT(json_ltlt_istream, std::declval<J&>() << std::declval<std::istream&>());
-JSON_TEST_DETECT(istream_gtgt_json, std::declval<std::istream&>() >> std::declval<J&>());
-JSON_TEST_DETECT(json_gtgt_ostream, std::declval<const J&>() >> std::declval<std::ostream&>());
-JSON_TEST_DETECT(ostream_ltlt_json, std::declval<std::ostream&>() << std::declval<const J&>());
-
-JSON_TEST_DETECT(ptr_eq_ptr, std::declval<const typename J::json_pointer&>() == std::declval<const typename J::json_pointer&>());
-JSON_TEST_DETECT(ptr_ne_ptr, std::declval<const typename J::json_pointer&>() != std::declval<const typename J::json_pointer&>());
-JSON_TEST_DETECT(ptr_eq_string, std::declval<const typename J::json_pointer&>() == std::declval<const std::string&>());
-JSON_TEST_DETECT(string_eq_ptr, std::declval<const std::string&>() == std::declval<const typename J::json_pointer&>());
-JSON_TEST_DETECT(ptr_eq_c_string, std::declval<const typename J::json_pointer&>() == std::declval<const char*>());
-JSON_TEST_DETECT(c_string_eq_ptr, std::declval<const char*>() == std::declval<const typename J::json_pointer&>());
-JSON_TEST_DETECT(ptr_ne_string, std::declval<const typename J::json_pointer&>() != std::declval<const std::string&>());
-JSON_TEST_DETECT(string_ne_ptr, std::declval<const std::string&>() != std::declval<const typename J::json_pointer&>());
-JSON_TEST_DETECT(ptr_to_string, std::declval<const typename J::json_pointer&>().to_string());
-
-// json_pointer with a basic_json type as template argument
-template<typename J>
-using legacy_ptr_t = const nlohmann::json_pointer<J>& ;
-JSON_TEST_DETECT(legacy_ptr_value, std::declval<const J&>().value(std::declval<legacy_ptr_t<J>>(), 0));
-JSON_TEST_DETECT(legacy_ptr_value_rvalue, std::declval<const J&>().value(std::declval<legacy_ptr_t<J>>(), std::string()));
-JSON_TEST_DETECT(legacy_ptr_contains, std::declval<const J&>().contains(std::declval<legacy_ptr_t<J>>()));
-JSON_TEST_DETECT(legacy_ptr_subscript, std::declval<J&>()[std::declval<legacy_ptr_t<J>>()]);
-JSON_TEST_DETECT(legacy_ptr_subscript_const, std::declval<const J&>()[std::declval<legacy_ptr_t<J>>()]);
-JSON_TEST_DETECT(legacy_ptr_at, std::declval<J&>().at(std::declval<legacy_ptr_t<J>>()));
-JSON_TEST_DETECT(legacy_ptr_at_const, std::declval<const J&>().at(std::declval<legacy_ptr_t<J>>()));
-JSON_TEST_DETECT(ptr_value, std::declval<const J&>().value(std::declval<const typename J::json_pointer&>(), 0));
-JSON_TEST_DETECT(ptr_at, std::declval<J&>().at(std::declval<const typename J::json_pointer&>()));
-
-#undef JSON_TEST_DETECT
-} // namespace
-
-TEST_CASE("JSON_DELETE_DEPRECATED_FUNCTIONS")
-{
-    // MSVC 2015 does not treat selecting a deleted function in decltype as a
-    // substitution failure, so the traits cannot tell deleted functions apart
-    // there; calling them still fails to compile
-#if !(defined(_MSC_VER) && _MSC_VER < 1910)
-    SECTION("from_* with a pointer and a length")
-    {
-        // the overloads are deleted rather than removed, so the length cannot
-        // silently bind to the strict parameter of from_*(InputType&&, bool)
-        CHECK_FALSE(from_cbor_ptr_len<json>::value);
-        CHECK_FALSE(from_msgpack_ptr_len<json>::value);
-        CHECK_FALSE(from_ubjson_ptr_len<json>::value);
-        CHECK_FALSE(from_bjdata_ptr_len<json>::value);
-        CHECK_FALSE(from_bon8_ptr_len<json>::value);
-        CHECK_FALSE(from_bson_ptr_len<json>::value);
-
-        // the replacement
-        CHECK(from_cbor_ptr_ptr<json>::value);
-        CHECK(from_msgpack_ptr_ptr<json>::value);
-        CHECK(from_ubjson_ptr_ptr<json>::value);
-        CHECK(from_bjdata_ptr_ptr<json>::value);
-        CHECK(from_bon8_ptr_ptr<json>::value);
-        CHECK(from_bson_ptr_ptr<json>::value);
-    }
-
-    SECTION("initializer lists of a pointer and a length")
-    {
-        CHECK_FALSE(from_cbor_init_list<json>::value);
-        CHECK_FALSE(from_msgpack_init_list<json>::value);
-        CHECK_FALSE(from_ubjson_init_list<json>::value);
-        CHECK_FALSE(from_bson_init_list<json>::value);
-        CHECK_FALSE(parse_init_list<json>::value);
-        CHECK_FALSE(accept_init_list<json>::value);
-        CHECK_FALSE(sax_parse_init_list<json>::value);
-
-        // the replacement
-        CHECK(parse_ptr_ptr<json>::value);
-    }
-
-    SECTION("iterator_wrapper")
-    {
-        CHECK_FALSE(iterator_wrapper<json>::value);
-        CHECK_FALSE(iterator_wrapper_const<json>::value);
-
-        // the replacement
-        CHECK(items<json>::value);
-    }
-
-    SECTION("stream operators with reversed operands")
-    {
-        CHECK_FALSE(json_ltlt_istream<json>::value);
-        CHECK_FALSE(json_gtgt_ostream<json>::value);
-
-        // the replacement
-        CHECK(istream_gtgt_json<json>::value);
-        CHECK(ostream_ltlt_json<json>::value);
-    }
-
-    SECTION("json_pointer")
-    {
-        // conversion to a string
-        CHECK_FALSE(std::is_constructible<std::string, json::json_pointer>::value);
-        CHECK_FALSE(std::is_convertible<json::json_pointer, std::string>::value);
-
-        // comparison with a string
-        CHECK_FALSE(ptr_eq_string<json>::value);
-        CHECK_FALSE(string_eq_ptr<json>::value);
-        CHECK_FALSE(ptr_eq_c_string<json>::value);
-        CHECK_FALSE(c_string_eq_ptr<json>::value);
-        CHECK_FALSE(ptr_ne_string<json>::value);
-        CHECK_FALSE(string_ne_ptr<json>::value);
-
-        // the replacement
-        CHECK(ptr_to_string<json>::value);
-        CHECK(ptr_eq_ptr<json>::value);
-        CHECK(ptr_ne_ptr<json>::value);
-    }
-
-    SECTION("json_pointer with a basic_json type as template argument")
-    {
-        CHECK_FALSE(legacy_ptr_value<json>::value);
-        CHECK_FALSE(legacy_ptr_value_rvalue<json>::value);
-        CHECK_FALSE(legacy_ptr_contains<json>::value);
-        CHECK_FALSE(legacy_ptr_subscript<json>::value);
-        CHECK_FALSE(legacy_ptr_subscript_const<json>::value);
-        CHECK_FALSE(legacy_ptr_at<json>::value);
-        CHECK_FALSE(legacy_ptr_at_const<json>::value);
-
-        // the replacement
-        CHECK(ptr_value<json>::value);
-        CHECK(ptr_at<json>::value);
-    }
-
-#endif
-
-    SECTION("the non-deprecated functions still work")
-    {
-        const json j = {{"a", {1, 2}}};
-        const auto cbor = json::to_cbor(j);
-        CHECK(json::from_cbor(cbor.data(), cbor.data() + cbor.size()) == j);
-
-        const json::json_pointer ptr("/a/1");
-        CHECK(ptr == json::json_pointer("/a/1"));
-        CHECK(ptr.to_string() == "/a/1");
-        CHECK(j[ptr] == 2);
-        CHECK(j.at(ptr) == 2);
-        CHECK(j.value(ptr, 0) == 2);
-        CHECK(j.contains(ptr));
-
-        std::ostringstream os;
-        os << j;
-        CHECK(os.str() == R"({"a":[1,2]})");
-        std::istringstream is(os.str());
-        json parsed;
-        is >> parsed;
-        CHECK(parsed == j);
-    }
-}
@@ -16,14 +16,6 @@
    #define JSON_TEST_STRICT_NUL_HANDLING_ENABLED 1
 #endif

-// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
-// line *before* including json.hpp, since the library #undefs it once the header
-// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
-// tests of deprecated functions are skipped if these functions are deleted
-#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
-    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-#endif
-
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 #ifdef JSON_TEST_NO_GLOBAL_UDLS
@@ -299,7 +291,6 @@ TEST_CASE("deserialization")
            }));
        }

-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
        SECTION("operator<<")
        {
            std::stringstream ss;
@@ -308,7 +299,6 @@ TEST_CASE("deserialization")
            j << ss;
            CHECK(j == json({"foo", 1, 2, 3, false, {{"one", 1}}}));
        }
-#endif

        SECTION("operator>>")
        {
@@ -433,7 +423,6 @@ TEST_CASE("deserialization")
            CHECK_THROWS_WITH_AS(_ = json::parse(nullptr), "[json.exception.parse_error.101] parse error: attempting to parse an empty input; check that your input string or stream contains the expected JSON", json::parse_error&);
        }

-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
        SECTION("operator<<")
        {
            std::stringstream ss;
@@ -441,7 +430,6 @@ TEST_CASE("deserialization")
            json j;
            CHECK_THROWS_WITH_AS(j << ss, "[json.exception.parse_error.101] parse error at line 1, column 29: syntax error while parsing array - unexpected end of input; expected ']'", json::parse_error&);
        }
-#endif

        SECTION("operator>>")
        {
@@ -1160,9 +1148,9 @@ TEST_CASE("deserialization")
        {
            std::istringstream s(bom + "123 456");
            json j;
-            s >> j;
+            j << s;
            CHECK(j == 123);
-            s >> j;
+            j << s;
            CHECK(j == 456);
        }
    }
@@ -1551,10 +1551,6 @@ TEST_CASE_TEMPLATE("element access 2", Json, nlohmann::json, nlohmann::ordered_j
        // count(0) used to compile and then crash instead of failing to compile
        using nlohmann::detail::is_detected;

-        // MSVC 2015 does not treat selecting a deleted function in decltype as
-        // a substitution failure, so it detects the deleted overloads as
-        // callable; calling them still fails to compile
-#if !(defined(_MSC_VER) && _MSC_VER < 1910)
        CHECK_FALSE(is_detected<can_call_find_with_0, Json&>::value);
        CHECK_FALSE(is_detected<can_call_find_with_0, const Json&>::value);
        CHECK_FALSE(is_detected<can_call_count_with_0, Json&>::value);
@@ -1566,7 +1562,6 @@ TEST_CASE_TEMPLATE("element access 2", Json, nlohmann::json, nlohmann::ordered_j

        // another integral literal type must be rejected as well, not just int
        CHECK_FALSE(is_detected<can_call_contains_with_0L, Json&>::value);
-#endif

        // the valid overloads must remain callable
        CHECK(is_detected<can_call_find, Json&, const char*>::value);
@@ -8,14 +8,6 @@

 #include "doctest_compatibility.h"

-// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
-// line *before* including json.hpp, since the library #undefs it once the header
-// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
-// tests of deprecated functions are skipped if these functions are deleted
-#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
-    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-#endif
-
 #include <nlohmann/json.hpp>
 using nlohmann::json;

@@ -27,7 +19,6 @@ DOCTEST_GCC_SUPPRESS_WARNING_PUSH
 DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
 DOCTEST_CLANG_SUPPRESS_WARNING("-Wrange-loop-construct")

-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
 TEST_CASE("iterator_wrapper")
 {
    SECTION("object")
@@ -724,7 +715,6 @@ TEST_CASE("iterator_wrapper")
        }
    }
 }
-#endif

 TEST_CASE("items()")
 {
@@ -9,14 +9,6 @@
 #include "doctest_compatibility.h"

 #define JSON_TESTS_PRIVATE
-// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
-// line *before* including json.hpp, since the library #undefs it once the header
-// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
-// tests of deprecated functions are skipped if these functions are deleted
-#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
-    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-#endif
-
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 #ifdef JSON_TEST_NO_GLOBAL_UDLS
@@ -572,9 +564,7 @@ TEST_CASE("JSON pointers")
            std::stringstream ss;
            ss << ptr;
            CHECK(ptr.to_string() == ptr_str);
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
            CHECK(std::string(ptr) == ptr_str);
-#endif
            CHECK(ss.str() == ptr_str);
        }
    }
@@ -754,6 +744,8 @@ TEST_CASE("JSON pointers")

    SECTION("equality comparison")
    {
+        const char* ptr_cpstring = "/foo/bar";
+        const char ptr_castring[] = "/foo/bar"; // NOLINT(misc-const-correctness,hicpp-avoid-c-arrays,modernize-avoid-c-arrays,cppcoreguidelines-avoid-c-arrays)
        std::string ptr_string{"/foo/bar"};
        auto ptr1 = json::json_pointer(ptr_string);
        auto ptr2 = json::json_pointer(ptr_string);
@@ -763,12 +755,6 @@ TEST_CASE("JSON pointers")

        CHECK(ptr1 == ptr2);

-        CHECK_FALSE(ptr1 != ptr2);
-
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-        const char* ptr_cpstring = "/foo/bar";
-        const char ptr_castring[] = "/foo/bar"; // NOLINT(misc-const-correctness,hicpp-avoid-c-arrays,modernize-avoid-c-arrays,cppcoreguidelines-avoid-c-arrays)
-
        CHECK(ptr1 == "/foo/bar");
        CHECK(ptr1 == ptr_cpstring);
        CHECK(ptr1 == ptr_castring);
@@ -779,6 +765,8 @@ TEST_CASE("JSON pointers")
        CHECK(ptr_castring == ptr1);
        CHECK(ptr_string == ptr1);

+        CHECK_FALSE(ptr1 != ptr2);
+
        CHECK_FALSE(ptr1 != "/foo/bar");
        CHECK_FALSE(ptr1 != ptr_cpstring);
        CHECK_FALSE(ptr1 != ptr_castring);
@@ -800,7 +788,6 @@ TEST_CASE("JSON pointers")
            CHECK_THROWS_WITH_AS("/~~" == ptr1,
                                 "[json.exception.parse_error.108] parse error: escape character '~' must be followed with '0' or '1'", json::parse_error&);
        }
-#endif
    }

    SECTION("less-than comparison")
@@ -852,7 +839,6 @@ TEST_CASE("JSON pointers")
        json_ptr_j ptr_j{ptr_string};
        json_ptr_oj ptr_oj{ptr_string};

-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
        CHECK(j.contains(ptr));
        CHECK(j.contains(ptr_j));
        CHECK(j.contains(ptr_oj));
@@ -865,7 +851,6 @@ TEST_CASE("JSON pointers")

        CHECK(j.value(ptr, "x") == j.value(ptr_j, "x"));
        CHECK(j.value(ptr, "x") == j.value(ptr_oj, "x"));
-#endif

        CHECK(ptr == ptr_j);
        CHECK(ptr == ptr_oj);
@@ -8,14 +8,6 @@

 #include "doctest_compatibility.h"

-// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
-// line *before* including json.hpp, since the library #undefs it once the header
-// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
-// tests of deprecated functions are skipped if these functions are deleted
-#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
-    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-#endif
-
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 #ifdef JSON_TEST_NO_GLOBAL_UDLS
@@ -1803,10 +1795,8 @@ TEST_CASE("MessagePack input that cannot be read is discarded by every overload"
    CHECK_THROWS_AS(_ = json::from_msgpack(input.begin(), input.end()), json::parse_error&);
    CHECK(json::from_msgpack(input, true, false).is_discarded());
    CHECK(json::from_msgpack(input.begin(), input.end(), true, false).is_discarded());
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
    CHECK(json::from_msgpack(input.data(), input.size(), true, false).is_discarded());
    CHECK(json::from_msgpack({input.data(), input.size()}, true, false).is_discarded());
-#endif
 }

 TEST_CASE("MessagePack SAX parsing stops at every event")
@@ -2109,14 +2099,12 @@ TEST_CASE("MessagePack roundtrips" * doctest::skip())
                CHECK(j1 == j2);
            }

-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
            {
                INFO_WITH_TEMP(filename + ": uint8_t* and size");
                json j2;
                CHECK_NOTHROW(j2 = json::from_msgpack({packed.data(), packed.size()}));
                CHECK(j1 == j2);
            }
-#endif

            {
                INFO_WITH_TEMP(filename + ": output to output adapters");
@@ -569,7 +569,7 @@ TEST_CASE("regression tests 2")
    SECTION("issue #2067 - cannot serialize binary data to text JSON")
    {
        const std::array<unsigned char, 23> data = {{0x81, 0xA4, 0x64, 0x61, 0x74, 0x61, 0xC4, 0x0F, 0x33, 0x30, 0x30, 0x32, 0x33, 0x34, 0x30, 0x31, 0x30, 0x37, 0x30, 0x35, 0x30, 0x31, 0x30}};
-        const json j = json::from_msgpack(data.begin(), data.end());
+        const json j = json::from_msgpack(data.data(), data.size());
        // dump() is nodiscard; this only checks that dumping does not throw
        CHECK_NOTHROW(
            utils::ignore_return_value(
@@ -8,14 +8,6 @@

 #include "doctest_compatibility.h"

-// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
-// line *before* including json.hpp, since the library #undefs it once the header
-// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
-// tests of deprecated functions are skipped if these functions are deleted
-#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
-    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-#endif
-
 #include <nlohmann/json.hpp>
 using nlohmann::json;

@@ -56,7 +48,6 @@ TEST_CASE("serialization")
        }
    }

-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
    SECTION("operator>>")
    {
        SECTION("no given width")
@@ -88,7 +79,6 @@ TEST_CASE("serialization")
                  "[\n\t\"foo\",\n\t1,\n\t2,\n\t3,\n\tfalse,\n\t{\n\t\t\"one\": 1\n\t}\n]");
        }
    }
-#endif

    SECTION("dump")
    {
@@ -8,14 +8,6 @@

 #include "doctest_compatibility.h"

-// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
-// line *before* including json.hpp, since the library #undefs it once the header
-// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
-// tests of deprecated functions are skipped if these functions are deleted
-#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
-    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-#endif
-
 #include <nlohmann/json.hpp>
 using nlohmann::json;

@@ -2220,10 +2212,8 @@ TEST_CASE("UBJSON input that cannot be read is discarded by every overload")
    CHECK_THROWS_AS(_ = json::from_ubjson(input.begin(), input.end()), json::parse_error&);
    CHECK(json::from_ubjson(input, true, false).is_discarded());
    CHECK(json::from_ubjson(input.begin(), input.end(), true, false).is_discarded());
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
    CHECK(json::from_ubjson(input.data(), input.size(), true, false).is_discarded());
    CHECK(json::from_ubjson({input.data(), input.size()}, true, false).is_discarded());
-#endif
 }

 TEST_CASE("UBJSON SAX parsing stops at every event")
@@ -2971,14 +2961,12 @@ TEST_CASE("UBJSON roundtrips" * doctest::skip())
                CHECK(j1 == j2);
            }

-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
            {
                INFO_WITH_TEMP(filename + ": uint8_t* and size");
                json j2;
                CHECK_NOTHROW(j2 = json::from_ubjson({packed.data(), packed.size()}));
                CHECK(j1 == j2);
            }
-#endif

            {
                INFO_WITH_TEMP(filename + ": output to output adapters");
@@ -23,6 +23,7 @@ using nlohmann::json;
    using namespace nlohmann::literals; // NOLINT(google-build-using-namespace)
 #endif

+#include <deque>
 #include <map>
 #include <memory>
 #include <string>
@@ -684,8 +685,7 @@ static std::ostream& operator<<(std::ostream& os, small_pod l)
 TEST_CASE("custom serializer for pods" * doctest::test_suite("udt"))
 {
    using custom_json =
-        nlohmann::basic_json<std::map, std::vector, std::string, bool,
-        std::int64_t, std::uint64_t, double, std::allocator, pod_serializer>;
+        nlohmann::json::with_json_serializer_t<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::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, double, std::allocator, another_adl_serializer>;
+using custom_json = nlohmann::json::with_json_serializer_t<another_adl_serializer>;

 template <typename T, typename>
 struct another_adl_serializer
@@ -734,6 +734,80 @@ 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);
+
+    // the aliases are members of the resulting type, so they can be chained
+    CHECK(std::is_same<json::with_integers_t<int, unsigned int>::with_float_t<float>,
+          nlohmann::basic_json<std::map, std::vector, std::string, bool,
+          int, unsigned int, float, std::allocator,
+          nlohmann::adl_serializer, std::vector<std::uint8_t>>>::value);
+    CHECK(std::is_same<json::with_float_t<float>::with_integers_t<int, unsigned int>,
+          json::with_integers_t<int, unsigned int>::with_float_t<float>>::value);
+
+    // replacing the object type of json with ordered_map yields ordered_json
+    CHECK(std::is_same<json::with_object_t<nlohmann::ordered_map>, nlohmann::ordered_json>::value);
+    CHECK(std::is_same<nlohmann::ordered_json::with_object_t<std::map>, json>::value);
+}
+
 TEST_CASE("different basic_json types conversions")
 {
    SECTION("null")
Author	SHA1	Message	Date
Niels Lohmann	8ab8fa9341	Fix with_t nav entry and document chaining of the with_*_t aliases Indent the with_t entry in mkdocs.yml so it is listed under basic_json, explain that the aliases can be chained and work on ordered_json, and test both, including json::with_object_t<ordered_map> == ordered_json. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-05 08:44:53 +02:00
Niels LohmannandRaphael Grimm	ea72ffe0a3	Add tests for the with__t member alias templates Check with std::is_same that each with__t alias produces the expected basic_json type, and that with_string_t keeps nlohmann::ordered_map as the object type when used on ordered_json. Co-authored-by: Raphael Grimm <1005058+barcode@users.noreply.github.com> Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-04 18:10:17 +02:00
Niels LohmannandRaphael Grimm	7e4b496811	Add documentation for the with_*_t member alias templates Add docs/mkdocs/docs/api/basic_json/with_t.md documenting 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, with an accompanying example, and link the page from the basic_json member types list and the mkdocs navigation. Co-authored-by: Raphael Grimm <1005058+barcode@users.noreply.github.com> Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-04 18:04:45 +02:00
Niels LohmannandRaphael Grimm	97f724951b	Rename with_changed__t aliases to with__t and merge integer/unsigned aliases Per review discussion on #3898 between gregmarr and nlohmann: - rename with_changed_X_t to with_X_t for brevity - replace the separate with_changed_integer_t/with_changed_unsigned_t aliases with a single with_integers_t<NumberIntegerType2, NumberUnsignedType2> - add @sa doc comment links for the upcoming documentation page Co-authored-by: Raphael Grimm <1005058+barcode@users.noreply.github.com> Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-04 18:01:49 +02:00
barcode	c7a0d59e16	Add helper types to make it easier to create a basic_json type with modified template parameters Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-04 18:00:36 +02:00