Fix clang-tidy misc-const-correctness in unit-udt_macro.cpp

The four zero-member ONLY_SERIALIZE test objects are only ever read (via to_json), never mutated, so mark them const per clang-tidy. Signed-off-by: Niels Lohmann <mail@nlohmann.me>
Fix CI failures in zero-member NLOHMANN_DEFINE_TYPE_* macros
2026-07-29 05:44:54 +00:00 · 2026-07-12 06:37:49 +00:00 · 2026-07-11 23:55:43 +02:00 · 2026-07-11 19:55:56 +02:00
26 changed files with 601 additions and 1852 deletions
@@ -21,7 +21,6 @@ cc_library(
        "include/nlohmann/adl_serializer.hpp",
        "include/nlohmann/byte_container_with_subtype.hpp",
        "include/nlohmann/detail/abi_macros.hpp",
-        "include/nlohmann/detail/conversions/from_chars.hpp",
        "include/nlohmann/detail/conversions/from_json.hpp",
        "include/nlohmann/detail/conversions/to_chars.hpp",
        "include/nlohmann/detail/conversions/to_json.hpp",
@@ -49,7 +49,7 @@ Unlike the [`parse()`](parse.md) function, this function neither throws an excep
 :   defaults to `IteratorType`; may be a different type comparable to `IteratorType` via `operator!=`, for instance.

    - a custom sentinel type for C++20 ranges
-    - `std::default_sentinel_t`, when `IteratorType` is `std::counted_iterator`
+    - `std::counted_iterator` with a different sentinel type

 ## Parameters

@@ -36,10 +36,8 @@ The exact mapping and its limitations are described on a [dedicated page](../../
 :   a compatible iterator type

 `SentinelType`
-:   defaults to `IteratorType`; may be a different type comparable to `IteratorType` via `operator!=`, for instance.
-
-    - a custom sentinel type for C++20 ranges
-    - `std::default_sentinel_t`, when `IteratorType` is `std::counted_iterator`
+:   defaults to `IteratorType`; may be a different type comparable to `IteratorType` via `operator!=`, for instance a
+    custom sentinel type for C++20 ranges

 ## Parameters

@@ -36,10 +36,8 @@ The exact mapping and its limitations are described on a [dedicated page](../../
 :   a compatible iterator type

 `SentinelType`
-:   defaults to `IteratorType`; may be a different type comparable to `IteratorType` via `operator!=`, for instance.
-
-    - a custom sentinel type for C++20 ranges
-    - `std::default_sentinel_t`, when `IteratorType` is `std::counted_iterator`
+:   defaults to `IteratorType`; may be a different type comparable to `IteratorType` via `operator!=`, for instance a
+    custom sentinel type for C++20 ranges

 ## Parameters

@@ -39,10 +39,8 @@ The exact mapping and its limitations are described on a [dedicated page](../../
 :   a compatible iterator type

 `SentinelType`
-:   defaults to `IteratorType`; may be a different type comparable to `IteratorType` via `operator!=`, for instance.
-
-    - a custom sentinel type for C++20 ranges
-    - `std::default_sentinel_t`, when `IteratorType` is `std::counted_iterator`
+:   defaults to `IteratorType`; may be a different type comparable to `IteratorType` via `operator!=`, for instance a
+    custom sentinel type for C++20 ranges

 ## Parameters

@@ -36,10 +36,8 @@ The exact mapping and its limitations are described on a [dedicated page](../../
 :   a compatible iterator type

 `SentinelType`
-:   defaults to `IteratorType`; may be a different type comparable to `IteratorType` via `operator!=`, for instance.
-
-    - a custom sentinel type for C++20 ranges
-    - `std::default_sentinel_t`, when `IteratorType` is `std::counted_iterator`
+:   defaults to `IteratorType`; may be a different type comparable to `IteratorType` via `operator!=`, for instance a
+    custom sentinel type for C++20 ranges

 ## Parameters

@@ -36,10 +36,8 @@ The exact mapping and its limitations are described on a [dedicated page](../../
 :   a compatible iterator type

 `SentinelType`
-:   defaults to `IteratorType`; may be a different type comparable to `IteratorType` via `operator!=`, for instance.
-
-    - a custom sentinel type for C++20 ranges
-    - `std::default_sentinel_t`, when `IteratorType` is `std::counted_iterator`
+:   defaults to `IteratorType`; may be a different type comparable to `IteratorType` via `operator!=`, for instance a
+    custom sentinel type for C++20 ranges

 ## Parameters

@@ -48,7 +48,7 @@ static basic_json parse(IteratorType first, SentinelType last,
 :   defaults to `IteratorType`; may be a different type comparable to `IteratorType` via `operator!=`, for instance.

    - a custom sentinel type for C++20 ranges
-    - `std::default_sentinel_t`, when `IteratorType` is `std::counted_iterator`
+    - `std::counted_iterator` with a different sentinel type

 ## Parameters

@@ -48,10 +48,7 @@ The SAX event lister must follow the interface of [`json_sax`](../json_sax/index
    with a size of 1, 2, or 4 bytes (interpreted respectively as UTF-8, UTF-16, and UTF-32)

 `SentinelType`
-:   defaults to `IteratorType`; may be a different type comparable to `IteratorType` via `operator!=`, for overload (2), for instance.
-
-    - a custom sentinel type for C++20 ranges
-    - `std::default_sentinel_t`, when `IteratorType` is `std::counted_iterator`
+:   defaults to `IteratorType`; may be a different type comparable to `IteratorType` via `operator!=`, for overload (2)

 `SAX`
 :   a class fulfilling the SAX event listener interface; see [`json_sax`](../json_sax/index.md)
@@ -38,8 +38,7 @@ When the macro is not defined, the library will define it to its default value.

    Diagnostic messages can also be controlled with the CMake option
    [`JSON_Diagnostics`](../../integration/cmake.md#json_diagnostics) (`OFF` by default)
-    which defines `JSON_DIAGNOSTICS` accordingly. Note this only applies when building the
-    library from source — see the pre-installed-package caveat on that page.
+    which defines `JSON_DIAGNOSTICS` accordingly.

 ## Examples

@@ -215,6 +215,24 @@ For _derived_ classes and structs, use the following macros
    nlohmann::ordered_json j = p; // keys appear in declaration order: name, address, age
    ```

+!!! note "Zero-member types"
+
+    All 12 `NLOHMANN_DEFINE_TYPE_*`/`NLOHMANN_DEFINE_DERIVED_TYPE_*` macros (excluding the `WITH_NAMES` variants)
+    also accept types with no member variables to serialize, producing/accepting an empty JSON object `{}`
+    (or, for the derived-type macros, just the base class's own JSON representation):
+
+    ```cpp
+    namespace ns {
+        struct marker {
+            bool operator==(const marker&) const { return true; }
+            NLOHMANN_DEFINE_TYPE_INTRUSIVE(marker)
+        };
+    }
+
+    ns::marker m{};
+    nlohmann::json j = m; // {}
+    ```
+
 !!! note "No macro for non-default-constructible types"

    There is currently no `NLOHMANN_DEFINE_TYPE_*`-style macro for types that are not
@@ -47,28 +47,6 @@ json j = {{"one", 1}, {"two", 2}};
 auto m = j.get<std::map<std::string, int>>();  // {{"one", 1}, {"two", 2}}
 ```

-`#!cpp std::pair` and `#!cpp std::tuple` are also supported, converting positionally to and from a JSON array:
-
-```cpp
-json j = {1.0, "hello", 42};
-auto t = j.get<std::tuple<double, std::string, int>>();  // {1.0, "hello", 42}
-```
-
-!!! info "Extracting references into a tuple"
-
-    A tuple type may also hold references (e.g. `#!cpp std::tuple<double&, std::string&>`) to avoid copying: `get`
-    then returns a tuple of references pointing directly at the elements stored inside the `basic_json` array,
-    rather than a tuple of copies:
-
-    ```cpp
-    json j = {1.0, "hello"};
-    auto refs = j.get<std::tuple<double&, std::string&>>();
-    std::get<1>(refs) = "world";  // modifies j[1] in place
-    ```
-
-    A referenced type must be one the library actually stores (or an arithmetic type it can convert to/from);
-    otherwise this is a compile error.
-
 ## Implicit conversions

 By default, a JSON value implicitly converts to a compatible C++ type, so the explicit `get` call can often be omitted:
@@ -158,20 +136,6 @@ std::vector<int> numbers = {1, 2, 3};
 json j = numbers;   // [1,2,3]
 ```

-!!! info "Constructing from a C++20 range view"
-
-    A `json` array can also be constructed directly from a C++20 range view (`std::ranges::view`), such as the result
-    of `std::views::filter` or `std::views::transform` -- no intermediate container is needed:
-
-    ```cpp
-    std::vector<int> nums{1, 2, 37, 42, 21};
-    auto filtered = nums | std::views::filter([](int i) { return i > 10; });
-    json j(filtered);   // [37,42,21]
-    ```
-
-    This requires [`JSON_HAS_RANGES`](../api/macros/json_has_ranges.md) to be enabled and is unavailable on MinGW due
-    to incomplete C++20 ranges support there.
-
 ## Your own types

 The conversions above are built in for standard types. To make the same syntax work for **your own** types, provide
@@ -135,31 +135,6 @@ Enable CI build targets. The exact targets are used during the several CI steps

 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.

-!!! warning "Does not apply to a pre-installed package"
-
-    This option only takes effect when building nlohmann/json from source as part of your own
-    CMake project (e.g. via [`FetchContent`](#fetchcontent) or [`add_subdirectory`](#external)).
-    It has **no effect** on a package that was already built and installed elsewhere (Homebrew,
-    vcpkg, a system package, etc.) — the resulting compile definition is baked into the exported
-    `nlohmann_jsonTargets.cmake` at install time, and `set(JSON_Diagnostics ON)` before
-    `find_package()` does not change it (verified against the Homebrew-installed package: the
-    exported target still carries a fixed `$<$<BOOL:OFF>:JSON_DIAGNOSTICS=1>`, regardless of any
-    variable set in the consuming project).
-
-    To enable extended diagnostics for a pre-installed package, override the imported target's
-    property directly after `find_package()`:
-
-    ```cmake
-    find_package(nlohmann_json REQUIRED)
-    set_target_properties(nlohmann_json::nlohmann_json PROPERTIES
-        INTERFACE_COMPILE_DEFINITIONS "JSON_DIAGNOSTICS=1")
-    ```
-
-    This only works cleanly when your project is the sole consumer of that imported target. If
-    nlohmann_json is pulled in from more than one place in your dependency graph with different
-    `JSON_DIAGNOSTICS` values, you may see a `"JSON_DIAGNOSTICS" redefined` compiler error, since
-    conflicting `-D` flags can end up on the same compile command line.
-
 ### `JSON_Diagnostic_Positions`

 Enable position diagnostics by defining macro [`JSON_DIAGNOSTIC_POSITIONS`](../api/macros/json_diagnostic_positions.md). This option is `OFF` by default.
@@ -1,636 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <nlohmann/detail/macro_scope.hpp>
-
-#if JSON_HAS_FROM_CHARS
-    #include <algorithm> // find, find_if
-    #include <charconv> // from_chars, from_chars_result
-    #include <cmath> // isnan
-#else
-    #include <cctype> // isspace
-    #include <cerrno> // ERANGE
-    #include <clocale> // localeconv, newlocale, freelocale
-    #include <cstdlib> // strto*
-    #include <memory> // unique_ptr
-    #include <type_traits> // enable_if, is_unsigned, remove_pointer
-    #include <utility> // declval
-
-    #ifdef __has_include
-        #if __has_include(<xlocale.h>)
-            #include <xlocale.h> // strto*_l, isspace_l
-        #endif
-    #endif
-#endif
-#include <limits> // numeric_limits<T>::[has_]infinity, quiet_NaN
-#include <system_error> // errc
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail
-{
-
-constexpr char get_locale_independent_decimal_point() noexcept
-{
-    return '.';
-}
-
-#if JSON_HAS_FROM_CHARS
-
-//////////////////////////////////////////////
-// Delegate to std::from_chars if supported //
-//////////////////////////////////////////////
-
-/*!
-@brief Number parsing implementation details
-
-A traits class template that allows users of nlohmann::detail::from_chars to
-query details of the used implementation.
-
-@tparam T numeric type to parse, matching the `value` argument of from_chars
-*/
-template <typename T>
-struct from_chars_traits
-{
-    /// whether the from_chars in unaffected by the current global C locale
-    static constexpr bool is_locale_independent = true;
-
-    /// getter for the character used as decimal point by from_chars
-    static constexpr char(*get_decimal_point)() = &get_locale_independent_decimal_point;
-};
-
-using std::from_chars_result;
-
-/*!
-@brief Parse integer/floating-point numbers
-
-Parses the string [first, last) into the numeric type T.
-
-This implementation merely delegates to `std::from_chars` with one noteworthy
-difference: Different C++ standard library implementations do not agree on
-whether `value` should be set in the out-of-range case for floating-point
-numbers. Presently, libstdc++ leaves `value` unchanged whereas libc++ and MS STL
-set `value` to +/-0 or +/-inf which allows its users to distinguish between the
-various cases of over- and underflow. The C++ proposal [P4168][1] details this
-discrepancy and advocates to standardize the latter behavior.
-
-Since we need to be able to distinguish absolute underflow (+/-0) from absolute
-overflow (+/-inf), this implementation "corrects" the out-of-range behavior
-accordingly by estimating the effective exponent through manual string parsing.
-
-[1]: https://isocpp.org/files/papers/P4168R0.html
-
-@tparam T numeric type to parse
-@param[in] first points to the beginning of the parsed string (inclusive)
-@param[in] end points to the end of the parsed string (exclusive)
-@param[out] value references the variable to set the parsed number
-@return structure consisting of `ptr` and `ec` such that:
-        - If the string starting at `first` matches a number, `ptr` points to
-          the address immediately after the last character that matches.
-          * If the matched number can be represented by `T`, `value` is set and
-            `ec` is value-initialized.
-          * If the matched number cannot be represented by `T`, `ec` is set to
-            `std::errc::result_out_of_range` and depending on the type of `T`:
-            + `value` is left unchanged for integral `T`,
-            + `value` is set to +/-0 or +/-inf for floating-point `T`.
-        - If the string starting at `first` doesn't match a number, `ptr`
-          points to `first`, `ec` is `std::errc::invalid_argument`, and `value`
-          is left unchanged.
-*/
-template <typename T>
-JSON_HEDLEY_NON_NULL(1, 2)
-inline from_chars_result from_chars(const char* first, const char* last, T& value)
-{
-    // No implementation of std::from_chars will set its value argument to NaN,
-    // so by using NaN as the initial value, we can tell if it changed.
-    T inner_value = std::numeric_limits<T>::quiet_NaN();
-    auto res = std::from_chars(first, last, inner_value);
-
-    if constexpr (std::numeric_limits<T>::has_infinity)
-    {
-        if (res.ec == std::errc::result_out_of_range)
-        {
-            if (std::isnan(inner_value)) // inner_value was not set
-            {
-                // [first, res.ptr) matches a valid floating-point number that's
-                // out-of-range and our std::from_chars did not set `value`, so we
-                // need to distinguish the type of under-/overflow ourselves.
-                const char* mantissa_begin = *first == '-' ? first + 1 : first;
-                const char* mantissa_end = std::find_if(mantissa_begin, res.ptr, [](char c)
-                {
-                    return c == 'e' || c == 'E';
-                });
-                const char* decimal_point = std::find(mantissa_begin, mantissa_end, '.');
-                const char* significant_digit = std::find_if(mantissa_begin, mantissa_end, [](char d)
-                {
-                    return d >= '1' && d <= '9';
-                });
-
-                // Position of the significant digit relative to the decimal gives
-                // the order of magnitude of the mantissa.
-                auto effective_exponent = static_cast<int>(decimal_point - significant_digit);
-
-                // If the number includes an explicit exponent, add that to the the
-                // total exponent.
-                if (mantissa_end != res.ptr)
-                {
-                    const char* exponent_begin = *(mantissa_end + 1) == '+'
-                                                 ? mantissa_end + 2 // skip the exponent's + sign
-                                                 : mantissa_end + 1;
-                    int exponent = 0;
-                    auto exp_res = std::from_chars(exponent_begin, res.ptr, exponent);
-                    JSON_ASSERT(exp_res.ptr == res.ptr);
-
-                    if (exp_res.ec == std::errc::result_out_of_range)
-                    {
-                        // NOTE: Parentheses around function names mitigate min/max macro collision on Windows
-                        effective_exponent = *exponent_begin == '-'
-                                             ? (std::numeric_limits<int>::min)()
-                                             : (std::numeric_limits<int>::max)();
-                    }
-                    else
-                    {
-                        JSON_ASSERT(exp_res.ec == std::errc{});
-                        effective_exponent += exponent;
-                    }
-                }
-
-                // Set `value` to the sign-correct non-finite value based on the
-                // effective exponent.
-                value = (*first == '-' ? -1 : 1) * (effective_exponent < 0
-                                                    ? T{}
-                                                    : std::numeric_limits<T>::infinity());
-            }
-            else
-            {
-                value = inner_value;
-            }
-        }
-    }
-
-    if (res.ec == std::errc{})
-    {
-        value = inner_value;
-    }
-
-    return res;
-}
-
-#else
-
-//////////////////////////////////////////////
-// Fallback implementation using strto*[_l] //
-//////////////////////////////////////////////
-
-#if defined(_WIN32)
-
-/*!
-@brief Extended locale functions on Windows
-
-A trait object which provides wrappers for isspace and the strto* family of
-functions, based on the platform's support for extended locale APIs.
-
-This is the Windows implementation. The primary class template definition
-falls back to the standard locale-dependent functions, which is used on
-MinGW, whose C runtime only provides an incomplete subset of the
-`_<funcname>_l` family (e.g., missing `_strtof_l`/`_strtold_l` depending on
-the toolchain version). A specialization for genuine MSVC (including
-clang-cl, which mimics the MSVC ABI and CRT) is used instead, as the full
-`_<funcname>_l` family has reliably been available there since at least
-Visual Studio 2005.
-*/
-template <typename = const char*, typename = float>
-struct extended_locale_traits
-{
-    static constexpr bool is_locale_independent = false;
-
-    JSON_HEDLEY_PURE
-    static char get_decimal_point() noexcept
-    {
-        const auto* loc = localeconv();
-        JSON_ASSERT(loc != nullptr);
-        return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point);
-    }
-
-    static int isspace(int c) noexcept
-    {
-        return std::isspace(c);
-    }
-
-    // NOLINTNEXTLINE(runtime/int)
-    static long long strtoll(const char* str, char** endptr) noexcept
-    {
-        return std::strtoll(str, endptr, 10);
-    }
-
-    // NOLINTNEXTLINE(runtime/int)
-    static unsigned long long strtoull(const char* str, char** endptr) noexcept
-    {
-        return std::strtoull(str, endptr, 10);
-    }
-
-    static constexpr float(&strtof)(const char*, char**) = std::strtof;
-    static constexpr double(&strtod)(const char*, char**) = std::strtod;
-    static constexpr long double(&strtold)(const char*, char**) = std::strtold;
-};
-
-#if defined(_MSC_VER)
-
-/*!
-@brief Get a pointer to a globally shared instance of the "C" locale on Windows
-
-This function uses _create_locale/_free_locale to allocate a "C" locale instance
-which can be passed to extended locale APIs. This instance is created on first
-use and has static storage duration, such that it can be used for the duration
-of the program.
-*/
-inline _locale_t get_c_locale_t() noexcept
-{
-    struct LocaleTDeleter
-    {
-        void operator()(_locale_t loc) noexcept
-        {
-            ::_free_locale(loc);
-        }
-    };
-    using LocaleUPtr = std::unique_ptr<std::remove_pointer<_locale_t>::type, LocaleTDeleter>;
-    static const LocaleUPtr c_locale = LocaleUPtr{::_create_locale(LC_ALL, "C"), LocaleTDeleter{}};
-    return c_locale.get();
-}
-
-template <typename T>
-struct extended_locale_traits<T, float>
-{
-    static constexpr bool is_locale_independent = true;
-    static constexpr char(&get_decimal_point)() = get_locale_independent_decimal_point;
-
-    static int isspace(int c) noexcept
-    {
-        return _isspace_l(c, get_c_locale_t());
-    }
-
-    // NOLINTNEXTLINE(runtime/int)
-    static long long strtoll(const char* str, char** endptr) noexcept
-    {
-        return _strtoll_l(str, endptr, 10, get_c_locale_t());
-    }
-
-    // NOLINTNEXTLINE(runtime/int)
-    static unsigned long long strtoull(const char* str, char** endptr) noexcept
-    {
-        return _strtoull_l(str, endptr, 10, get_c_locale_t());
-    }
-
-    static float strtof(T str, char** str_end)
-    {
-        return _strtof_l(str, str_end, get_c_locale_t());
-    }
-
-    static double strtod(T str, char** str_end)
-    {
-        return _strtod_l(str, str_end, get_c_locale_t());
-    }
-
-    static long double strtold(T str, char** str_end)
-    {
-        return _strtold_l(str, str_end, get_c_locale_t());
-    }
-};
-
-#endif
-
-#else
-
-/*!
-@brief Get a pointer to a globally shared instance of the "C" locale on POSIX
-
-This function uses newlocale/freelocale to allocate a "C" locale instance
-which can be passed to extended locale APIs. This instance is created on first
-use and has static storage duration, such that it can be used for the duration
-of the program.
-
-newlocale/freelocale themselves are in POSIX and are available independent of
-the platform's support for extended locale APIs.
-*/
-inline locale_t get_c_locale_t() noexcept
-{
-    struct LocaleTDeleter
-    {
-        void operator()(locale_t loc) noexcept
-        {
-            ::freelocale(loc);
-        }
-    };
-    using LocaleUPtr = std::unique_ptr<std::remove_pointer<locale_t>::type, LocaleTDeleter>;
-
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wexit-time-destructors"
-#endif
-    static const LocaleUPtr c_locale = LocaleUPtr {::newlocale(LC_ALL_MASK, "C", nullptr), LocaleTDeleter{}};
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif
-
-    return c_locale.get();
-}
-
-/*!
-@brief Extended locale functions on POSIX
-
-A trait object which provides wrappers for isspace and the strto* family of
-functions, based on the platform's support for extended locale APIs.
-
-This is the POSIX implementation where extended locale support might not be
-available. The primary class template definition falls back to the standard
-locale-dependent functions. A partial specialization uses SFINAE to detect the
-availability of `strtof_l` (as a proxy for the whole `<funcname>_l` family) and
-provides access to locale-independent functions.
-*/
-template <typename = const char*, typename = float>
-struct extended_locale_traits
-{
-    static constexpr bool is_locale_independent = false;
-
-    /*!
-    @brief Query the decimal point used by the current C locale
-
-    Note that calling this function while switching the global C locale from
-    another thread is undefined behavior.
-    */
-    JSON_HEDLEY_PURE
-    static char get_decimal_point() noexcept
-    {
-        const auto* loc = localeconv();
-        JSON_ASSERT(loc != nullptr);
-        return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point);
-    }
-
-    static int isspace(int c) noexcept
-    {
-        return std::isspace(c);
-    }
-
-    // NOLINTNEXTLINE(runtime/int)
-    static long long strtoll(const char* str, char** endptr) noexcept
-    {
-        return std::strtoll(str, endptr, 10);
-    }
-
-    // NOLINTNEXTLINE(runtime/int)
-    static unsigned long long strtoull(const char* str, char** endptr) noexcept
-    {
-        return std::strtoull(str, endptr, 10);
-    }
-
-    static constexpr float(&strtof)(const char*, char**) = std::strtof;
-    static constexpr double(&strtod)(const char*, char**) = std::strtod;
-    static constexpr long double(&strtold)(const char*, char**) = std::strtold;
-};
-
-template <typename T>
-struct extended_locale_traits<T, decltype(strtof_l(
-            std::declval<T>(),
-            std::declval<char**>(),
-            std::declval<locale_t>()))>
-{
-    static constexpr bool is_locale_independent = true;
-    static constexpr char(&get_decimal_point)() = get_locale_independent_decimal_point;
-
-    static int isspace(int c) noexcept
-    {
-        return isspace_l(c, get_c_locale_t());
-    }
-
-    // NOLINTNEXTLINE(runtime/int)
-    static long long strtoll(const char* str, char** endptr) noexcept
-    {
-        return ::strtoll_l(str, endptr, 10, get_c_locale_t());
-    }
-
-    // NOLINTNEXTLINE(runtime/int)
-    static unsigned long long strtoull(const char* str, char** endptr) noexcept
-    {
-        return ::strtoull_l(str, endptr, 10, get_c_locale_t());
-    }
-
-    static float strtof(T str, char** str_end)
-    {
-        return ::strtof_l(str, str_end, get_c_locale_t());
-    }
-
-    static double strtod(T str, char** str_end)
-    {
-        return ::strtod_l(str, str_end, get_c_locale_t());
-    }
-
-    static long double strtold(T str, char** str_end)
-    {
-        return ::strtold_l(str, str_end, get_c_locale_t());
-    }
-};
-
-#endif
-
-/*!
-@brief Number parsing implementation details
-
-A traits class template that allows users of nlohmann::detail::from_chars to
-query details of the used implementation.
-
-Each specialization provides the following static members:
- is_locale_independent: whether the from_chars in unaffected by the current
-                         global C locale
- get_decimal_point: getter for the character used as decimal point by from_chars
- strto: dispatches to the C standard library strto* function for type T, or to
-         the corresponding extended locale function, if available.
-
-@tparam T numeric type to parse, matching the `value` argument of from_chars
-*/
-template <typename T>
-struct from_chars_traits;
-
-template <>
-struct from_chars_traits<long long> // NOLINT(runtime/int)
-{
-    static constexpr bool is_locale_independent = extended_locale_traits<>::is_locale_independent;
-
-    static char get_decimal_point()
-    {
-        return extended_locale_traits<>::get_decimal_point();
-    }
-
-    // NOLINTNEXTLINE(runtime/int)
-    static constexpr long long(*strto)(const char*, char**) = &extended_locale_traits<>::strtoll;
-};
-
-template <>
-struct from_chars_traits<unsigned long long> // NOLINT(runtime/int)
-{
-    static constexpr bool is_locale_independent = extended_locale_traits<>::is_locale_independent;
-
-    static char get_decimal_point()
-    {
-        return extended_locale_traits<>::get_decimal_point();
-    }
-
-    // NOLINTNEXTLINE(runtime/int)
-    static constexpr unsigned long long(*strto)(const char*, char**) = &extended_locale_traits<>::strtoull;
-};
-
-template <>
-struct from_chars_traits<float>
-{
-    static constexpr bool is_locale_independent = extended_locale_traits<>::is_locale_independent;
-
-    static char get_decimal_point()
-    {
-        return extended_locale_traits<>::get_decimal_point();
-    }
-
-    static constexpr float(*strto)(const char*, char**) = &extended_locale_traits<>::strtof;
-};
-
-template <>
-struct from_chars_traits<double>
-{
-    static constexpr bool is_locale_independent = extended_locale_traits<>::is_locale_independent;
-
-    static char get_decimal_point()
-    {
-        return extended_locale_traits<>::get_decimal_point();
-    }
-
-    static constexpr double(*strto)(const char*, char**) = &extended_locale_traits<>::strtod;
-};
-
-template <>
-struct from_chars_traits<long double>
-{
-    static constexpr bool is_locale_independent = extended_locale_traits<>::is_locale_independent;
-
-    static char get_decimal_point()
-    {
-        return extended_locale_traits<>::get_decimal_point();
-    }
-
-    static constexpr long double(*strto)(const char*, char**) = &extended_locale_traits<>::strtold;
-};
-
-template <typename T>
-constexpr typename std::enable_if<std::numeric_limits<T>::has_infinity, bool>::type is_out_of_range_value(T value) noexcept
-{
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-    return value == T {} || value == std::numeric_limits<T>::infinity() || value == -std::numeric_limits<T>::infinity();
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
-}
-
-template <typename T>
-constexpr typename std::enable_if < !std::numeric_limits<T>::has_infinity, bool >::type is_out_of_range_value(T value) noexcept
-{
-    // NOTE: Parentheses around function names mitigate min/max macro collision on Windows
-    return value == (std::numeric_limits<T>::max)() || value == (std::numeric_limits<T>::min)();
-}
-
-struct from_chars_result
-{
-    const char* ptr;
-    std::errc ec;
-};
-
-/*!
-@brief Parse integer/floating-point numbers
-
-Parses the string [first, last) into the numeric type T.
-
-This implementation uses the C standard library functions strto*, or their
-extended locale counterparts strto*_l, to emulate the behavior of
-`std::from_chars` on platforms where it is not (fully) supported.
-
-Regarding the under-/overflow behavior, this implementation adopts the behavior
-proposed by [P4168][1] and implemented by libc++ and MS STL of setting `value`
-to the corresponding non-finite floating-point value in case of an out-of-range
-result.
-
-[1]: https://isocpp.org/files/papers/P4168R0.html
-
-@pre Unlike std::from_chars, this implementation requires the string to be
-     null-terminated, such that `last` dereferences into a NUL byte.
-
-@tparam T numeric type to parse
-@param[in] first points to the beginning of the parsed string (inclusive)
-@param[in] end points to the end of the parsed string (exclusive)
-@param[out] value references the variable to set the parsed number
-@return structure consisting of `ptr` and `ec` such that:
-        - If the string starting at `first` matches a number, `ptr` points to
-          the address immediately after the last character that matches.
-          * If the matched number can be represented by `T`, `value` is set and
-            `ec` is value-initialized.
-          * If the matched number cannot be represented by `T`, `ec` is set to
-            `std::errc::result_out_of_range` and depending on the type of `T`:
-            + `value` is left unchanged for integral `T`,
-            + `value` is set to +/-0 or +/-inf for floating-point `T`.
-        - If the string starting at `first` doesn't match a number, `ptr`
-          points to `first`, `ec` is `std::errc::invalid_argument`, and `value`
-          is left unchanged.
-*/
-template <typename T>
-JSON_HEDLEY_NON_NULL(1, 2)
-inline from_chars_result from_chars(const char* first, const char* last, T& value)
-{
-    JSON_ASSERT(*last == '\0');
-
-    // Unlike strto*, from_chars does not accept leading whitespace or + signs
-    if (first == last || *first == '+'
-            || (std::is_unsigned<T>::value && *first == '-')
-            || extended_locale_traits<>::isspace(*first) != 0)
-    {
-        return {first, std::errc::invalid_argument};
-    }
-
-    errno = 0;
-    char* ptr = nullptr; // NOLINT(misc-const-correctness)
-    T result = from_chars_traits<T>::strto(first, &ptr);
-
-    if (ptr == first)
-    {
-        return {ptr, std::errc::invalid_argument};
-    }
-
-    // Upon under-/overflow, strto* returns a marginal value and sets errno.
-    // Note that it is NOT sufficient to just check errno: strto* only clears
-    // errno if the parsed string actually parses into 0/[U]LLONG_MIN/-_MAX
-    // and this result was returned without indicating an under-/overflow.
-    // Otherwise, errno may not be relied upon to indicate the *absence* of
-    // an out-of-range error.
-    if (is_out_of_range_value(result) && errno == ERANGE)
-    {
-        if (std::numeric_limits<T>::has_infinity)
-        {
-            // ONLY for floating-point types, set `value` to the same non-finite
-            // result returned by strto* to allow users to distinguish between
-            // different types of under-/overflow.
-            value = result;
-        }
-        return {ptr, std::errc::result_out_of_range};
-    }
-
-    value = result;
-    return {ptr, std::errc{}};
-}
-
-#endif
-
-}  // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
@@ -220,29 +220,20 @@ class iterator_input_adapter
    // whether IteratorType refers to a contiguous range and therefore supports
    // a std::memcpy fast path (pointers always do; in C++20 we can also detect
    // library iterators such as those of std::vector and std::string).
-    // Computing the available element count needs either same-type iterators
-    // (plain std::distance) or, in C++20, a sized sentinel (std::ranges::distance),
-    // e.g. std::counted_iterator paired with std::default_sentinel_t.
+    // The fast path also requires SentinelType == IteratorType so std::distance works.
    static constexpr bool iterator_is_contiguous =
+        std::is_same<IteratorType, SentinelType>::value && (
 #if defined(__cpp_lib_concepts) && defined(JSON_HAS_CPP_20)
-        (std::is_same<IteratorType, SentinelType>::value || std::sized_sentinel_for<SentinelType, IteratorType>)
-        && (std::contiguous_iterator<IteratorType> || std::is_pointer<IteratorType>::value);
-#else
-        std::is_same<IteratorType, SentinelType>::value && std::is_pointer<IteratorType>::value;
+            std::contiguous_iterator<IteratorType> ||
 #endif
+            std::is_pointer<IteratorType>::value);

    // contiguous fast path: bulk copy the remaining range with std::memcpy
    template<class T>
    std::size_t get_elements_impl(T* dest, std::size_t count, std::true_type /*contiguous*/)
    {
        const std::size_t wanted = count * sizeof(T);
-#if defined(__cpp_lib_concepts) && defined(JSON_HAS_CPP_20)
-        // std::ranges::distance also supports sized sentinels of a different
-        // type (e.g. std::counted_iterator + std::default_sentinel_t)
-        const std::size_t available = static_cast<std::size_t>(std::ranges::distance(current, end)) * sizeof(char_type);
-#else
        const std::size_t available = static_cast<std::size_t>(std::distance(current, end)) * sizeof(char_type);
-#endif
        const std::size_t copied = (std::min)(wanted, available);
        if (JSON_HEDLEY_LIKELY(copied != 0))
        {
@@ -9,15 +9,15 @@
 #pragma once

 #include <array> // array
+#include <clocale> // localeconv
 #include <cstddef> // size_t
 #include <cstdio> // snprintf
+#include <cstdlib> // strtof, strtod, strtold, strtoll, strtoull
 #include <initializer_list> // initializer_list
 #include <string> // char_traits, string
-#include <system_error> // errc
 #include <utility> // move
 #include <vector> // vector

-#include <nlohmann/detail/conversions/from_chars.hpp>
 #include <nlohmann/detail/input/input_adapters.hpp>
 #include <nlohmann/detail/input/position_t.hpp>
 #include <nlohmann/detail/macro_scope.hpp>
@@ -152,7 +152,7 @@ class lexer : public lexer_base<BasicJsonType>
    explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false) noexcept
        : ia(std::move(adapter))
        , ignore_comments(ignore_comments_)
-        , decimal_point_char(static_cast<char_int_type>(from_chars_traits<number_float_t>::get_decimal_point()))
+        , decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
    {}

    // deleted because of pointer members
@@ -163,6 +163,19 @@ class lexer : public lexer_base<BasicJsonType>
    ~lexer() = default;

  private:
+    /////////////////////
+    // locales
+    /////////////////////
+
+    /// return the locale-dependent decimal point
+    JSON_HEDLEY_PURE
+    static char get_decimal_point() noexcept
+    {
+        const auto* loc = localeconv();
+        JSON_ASSERT(loc != nullptr);
+        return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point);
+    }
+
    /////////////////////
    // scan functions
    /////////////////////
@@ -928,6 +941,24 @@ class lexer : public lexer_base<BasicJsonType>
        }
    }

+    JSON_HEDLEY_NON_NULL(2)
+    static void strtof(float& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtof(str, endptr);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    static void strtof(double& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtod(str, endptr);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    static void strtof(long double& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtold(str, endptr);
+    }
+
    /*!
    @brief scan a number literal

@@ -1248,18 +1279,19 @@ scan_number_done:
        // we are done scanning a number)
        unget();

+        char* endptr = nullptr; // NOLINT(misc-const-correctness,cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+        errno = 0;
+
        // try to parse integers first and fall back to floats
        if (number_type == token_type::value_unsigned)
        {
-            unsigned long long x{}; // NOLINT(runtime/int)
-            const auto res = ::nlohmann::detail::from_chars(token_buffer.data(), token_buffer.data() + token_buffer.size(), x);
+            const auto x = std::strtoull(token_buffer.data(), &endptr, 10);

            // we checked the number format before
-            JSON_ASSERT(res.ptr == token_buffer.data() + token_buffer.size());
+            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());

-            if (res.ec != std::errc::result_out_of_range)
+            if (errno != ERANGE)
            {
-                JSON_ASSERT(res.ec == std::errc{});
                value_unsigned = static_cast<number_unsigned_t>(x);
                if (value_unsigned == x)
                {
@@ -1269,15 +1301,13 @@ scan_number_done:
        }
        else if (number_type == token_type::value_integer)
        {
-            long long x{}; // NOLINT(runtime/int)
-            const auto res = ::nlohmann::detail::from_chars(token_buffer.data(), token_buffer.data() + token_buffer.size(), x);
+            const auto x = std::strtoll(token_buffer.data(), &endptr, 10);

            // we checked the number format before
-            JSON_ASSERT(res.ptr == token_buffer.data() + token_buffer.size());
+            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());

-            if (res.ec != std::errc::result_out_of_range)
+            if (errno != ERANGE)
            {
-                JSON_ASSERT(res.ec == std::errc{});
                value_integer = static_cast<number_integer_t>(x);
                if (value_integer == x)
                {
@@ -1288,11 +1318,10 @@ scan_number_done:

        // this code is reached if we parse a floating-point number or if an
        // integer conversion above failed
-        const auto res = ::nlohmann::detail::from_chars(token_buffer.data(), token_buffer.data() + token_buffer.size(), value_float);
+        strtof(value_float, token_buffer.data(), &endptr);

        // we checked the number format before
-        JSON_ASSERT(res.ptr == token_buffer.data() + token_buffer.size());
-        JSON_ASSERT(res.ec != std::errc::invalid_argument);
+        JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());

        return token_type::value_float;
    }
@@ -124,20 +124,6 @@
    #define JSON_HAS_FILESYSTEM 0
 #endif

-#ifndef JSON_HAS_FROM_CHARS
-    #if defined(JSON_HAS_CPP_17) && defined(__cpp_lib_to_chars)
-        // The std::from_chars<float> implementation in libstdc++ 11 gets some of the corner cases wrong;
-        // starting with libstdc++ 12, these are fixed by switching the implementation to fast_float.
-        #if defined(_GLIBCXX_RELEASE) && _GLIBCXX_RELEASE < 12
-            #define JSON_HAS_FROM_CHARS 0
-        #else
-            #define JSON_HAS_FROM_CHARS 1
-        #endif
-    #else
-        #define JSON_HAS_FROM_CHARS 0
-    #endif
-#endif
-
 #ifndef JSON_HAS_THREE_WAY_COMPARISON
    #if defined(__cpp_impl_three_way_comparison) && __cpp_impl_three_way_comparison >= 201907L \
        && defined(__cpp_lib_three_way_comparison) && __cpp_lib_three_way_comparison >= 201907L
@@ -601,16 +587,59 @@ void templated_json_throw(ExceptionType exception)

 #define NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(...) template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> __VA_ARGS__

+// Tags used to dispatch the NLOHMANN_DEFINE_TYPE_*/NLOHMANN_DEFINE_DERIVED_TYPE_*
+// macros below between a zero-member and a one-or-more-member implementation
+// (issue #4041, e.g. NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type) with no further
+// arguments). NLOHMANN_JSON_TYPE_TAG(...) expands to the token 1 when
+// __VA_ARGS__ is a single token (Type alone) and to N for two or more (Type,
+// member...); NLOHMANN_JSON_DERIVED_TYPE_TAG(...) is the same idea shifted by
+// one slot for the two-token Type,BaseType prefix used by the derived-type
+// macros. Both reuse the existing 64-slot NLOHMANN_JSON_GET_MACRO dispatch
+// with one extra trailing sentinel token appended so its own trailing "..."
+// is never left completely empty at the lowest supported argument count --
+// invoking a variadic macro so that "..." matches nothing is only granted
+// unconditionally by the standard since C++20, and pre-C++20 compilers may
+// reject it under -pedantic regardless of what the macro body does.
+#define NLOHMANN_JSON_CAT_(x, y) x ## y
+#define NLOHMANN_JSON_CAT(x, y) NLOHMANN_JSON_CAT_(x, y)
+
+#define NLOHMANN_JSON_TYPE_TAG(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \
+        N, N, N, N, N, N, N, N, N, N, \
+        N, N, N, N, N, N, N, N, N, N, \
+        N, N, N, N, N, N, N, N, N, N, \
+        N, N, N, N, N, N, N, N, N, N, \
+        N, N, N, N, N, N, N, N, N, N, \
+        N, N, N, N, N, N, N, N, N, N, \
+        N, N, N, 1, \
+        NLOHMANN_JSON_TYPE_TAG_SENTINEL))
+
+#define NLOHMANN_JSON_DERIVED_TYPE_TAG(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \
+        N, N, N, N, N, N, N, N, N, N, \
+        N, N, N, N, N, N, N, N, N, N, \
+        N, N, N, N, N, N, N, N, N, N, \
+        N, N, N, N, N, N, N, N, N, N, \
+        N, N, N, N, N, N, N, N, N, N, \
+        N, N, N, N, N, N, N, N, N, N, \
+        N, N, 2, N, \
+        NLOHMANN_JSON_DERIVED_TYPE_TAG_SENTINEL))
+
 /*!
@brief macro
@def NLOHMANN_DEFINE_TYPE_INTRUSIVE
@since version 3.9.0
@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/
 */
-#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...)  \
+#define NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_N(Type, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }) \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) })

+#define NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_1(Type)  \
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type&) { nlohmann_json_j = BasicJsonType::object(); }) \
+    /* NOLINTNEXTLINE(bugprone-macro-parentheses) Type is used as a declarator type, not in an expression */ \
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType&, Type&) noexcept { })
+
+#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_CAT(NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_, NLOHMANN_JSON_TYPE_TAG(__VA_ARGS__))(__VA_ARGS__))
+
 #define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_NAMES(Type, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) }) \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_NAME, __VA_ARGS__)) })
@@ -621,10 +650,17 @@ void templated_json_throw(ExceptionType exception)
@since version 3.11.0
@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/
 */
-#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Type, ...)  \
+#define NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT_N(Type, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }) \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) })

+#define NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT_1(Type)  \
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type&) { nlohmann_json_j = BasicJsonType::object(); }) \
+    /* NOLINTNEXTLINE(bugprone-macro-parentheses) Type is used as a declarator type, not in an expression */ \
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType&, Type&) noexcept { })
+
+#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_CAT(NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT_, NLOHMANN_JSON_TYPE_TAG(__VA_ARGS__))(__VA_ARGS__))
+
 #define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT_WITH_NAMES(Type, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) }) \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT_WITH_NAME, __VA_ARGS__)) })
@@ -635,9 +671,14 @@ void templated_json_throw(ExceptionType exception)
@since version 3.11.3
@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/
 */
-#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, ...)  \
+#define NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE_N(Type, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) })

+#define NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE_1(Type)  \
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type&) { nlohmann_json_j = BasicJsonType::object(); })
+
+#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_CAT(NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE_, NLOHMANN_JSON_TYPE_TAG(__VA_ARGS__))(__VA_ARGS__))
+
 #define NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE_WITH_NAMES(Type, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) })

@@ -647,10 +688,17 @@ void templated_json_throw(ExceptionType exception)
@since version 3.9.0
@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/
 */
-#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...)  \
+#define NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_N(Type, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }) \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) })

+#define NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_1(Type)  \
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type&) { nlohmann_json_j = BasicJsonType::object(); }) \
+    /* NOLINTNEXTLINE(bugprone-macro-parentheses) Type is used as a declarator type, not in an expression */ \
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType&, Type&) noexcept { })
+
+#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_CAT(NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_, NLOHMANN_JSON_TYPE_TAG(__VA_ARGS__))(__VA_ARGS__))
+
 #define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_NAMES(Type, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) }) \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_NAME, __VA_ARGS__)) })
@@ -661,10 +709,17 @@ void templated_json_throw(ExceptionType exception)
@since version 3.11.0
@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/
 */
-#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, ...)  \
+#define NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT_N(Type, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }) \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) })

+#define NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT_1(Type)  \
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type&) { nlohmann_json_j = BasicJsonType::object(); }) \
+    /* NOLINTNEXTLINE(bugprone-macro-parentheses) Type is used as a declarator type, not in an expression */ \
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType&, Type&) noexcept { })
+
+#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_CAT(NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT_, NLOHMANN_JSON_TYPE_TAG(__VA_ARGS__))(__VA_ARGS__))
+
 #define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT_WITH_NAMES(Type, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) }) \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT_WITH_NAME, __VA_ARGS__)) })
@@ -675,9 +730,14 @@ void templated_json_throw(ExceptionType exception)
@since version 3.11.3
@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/
 */
-#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, ...)  \
+#define NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE_N(Type, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) })

+#define NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE_1(Type)  \
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type&) { nlohmann_json_j = BasicJsonType::object(); })
+
+#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_CAT(NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE_, NLOHMANN_JSON_TYPE_TAG(__VA_ARGS__))(__VA_ARGS__))
+
 #define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE_WITH_NAMES(Type, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) })

@@ -687,10 +747,17 @@ void templated_json_throw(ExceptionType exception)
@since version 3.12.0
@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/
 */
-#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE(Type, BaseType, ...)  \
+#define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_N(Type, BaseType, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }) \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) })

+#define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_2(Type, BaseType)  \
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); }) \
+    /* NOLINTNEXTLINE(bugprone-macro-parentheses) Type/BaseType are used as declarator types, not in expressions */ \
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); })
+
+#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_CAT(NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_, NLOHMANN_JSON_DERIVED_TYPE_TAG(__VA_ARGS__))(__VA_ARGS__))
+
 #define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_NAMES(Type, BaseType, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) }) \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_NAME, __VA_ARGS__)) })
@@ -701,10 +768,17 @@ void templated_json_throw(ExceptionType exception)
@since version 3.12.0
@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/
 */
-#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT(Type, BaseType, ...)  \
+#define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT_N(Type, BaseType, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }) \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) })

+#define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT_2(Type, BaseType)  \
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType&>(nlohmann_json_t)); }) \
+    /* NOLINTNEXTLINE(bugprone-macro-parentheses) Type/BaseType are used as declarator types, not in expressions */ \
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); })
+
+#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_CAT(NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT_, NLOHMANN_JSON_DERIVED_TYPE_TAG(__VA_ARGS__))(__VA_ARGS__))
+
 #define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT_WITH_NAMES(Type, BaseType, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) }) \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT_WITH_NAME, __VA_ARGS__)) })
@@ -715,9 +789,14 @@ void templated_json_throw(ExceptionType exception)
@since version 3.12.0
@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/
 */
-#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, BaseType, ...)  \
+#define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE_N(Type, BaseType, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) })

+#define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE_2(Type, BaseType)  \
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); })
+
+#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_CAT(NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE_, NLOHMANN_JSON_DERIVED_TYPE_TAG(__VA_ARGS__))(__VA_ARGS__))
+
 #define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE_WITH_NAMES(Type, BaseType, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) })

@@ -728,10 +807,17 @@ void templated_json_throw(ExceptionType exception)
@since version 3.12.0
@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/
 */
-#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE(Type, BaseType, ...)  \
+#define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_N(Type, BaseType, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }) \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) })

+#define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_2(Type, BaseType)  \
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); }) \
+    /* NOLINTNEXTLINE(bugprone-macro-parentheses) Type/BaseType are used as declarator types, not in expressions */ \
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); })
+
+#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_CAT(NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_, NLOHMANN_JSON_DERIVED_TYPE_TAG(__VA_ARGS__))(__VA_ARGS__))
+
 #define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_NAMES(Type, BaseType, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) }) \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_NAME, __VA_ARGS__)) })
@@ -742,10 +828,17 @@ void templated_json_throw(ExceptionType exception)
@since version 3.12.0
@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/
 */
-#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, BaseType, ...)  \
+#define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT_N(Type, BaseType, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }) \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) })

+#define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT_2(Type, BaseType)  \
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); }) \
+    /* NOLINTNEXTLINE(bugprone-macro-parentheses) Type/BaseType are used as declarator types, not in expressions */ \
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); })
+
+#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_CAT(NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT_, NLOHMANN_JSON_DERIVED_TYPE_TAG(__VA_ARGS__))(__VA_ARGS__))
+
 #define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT_WITH_NAMES(Type, BaseType, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) }) \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT_WITH_NAME, __VA_ARGS__)) })
@@ -756,9 +849,14 @@ void templated_json_throw(ExceptionType exception)
@since version 3.12.0
@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/
 */
-#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, BaseType, ...)  \
+#define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE_N(Type, BaseType, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) })

+#define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE_2(Type, BaseType)  \
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); })
+
+#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_CAT(NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE_, NLOHMANN_JSON_DERIVED_TYPE_TAG(__VA_ARGS__))(__VA_ARGS__))
+
 #define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE_WITH_NAMES(Type, BaseType, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) })

@@ -39,7 +39,6 @@
    #undef JSON_HAS_CPP_26
    #undef JSON_HAS_FILESYSTEM
    #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
-    #undef JSON_HAS_FROM_CHARS
    #undef JSON_HAS_THREE_WAY_COMPARISON
    #undef JSON_HAS_RANGES
    #undef JSON_HAS_STD_FORMAT
@@ -121,10 +121,6 @@ json_test_set_test_options(test-disabled_exceptions
 # raise timeout of expensive Unicode test
 json_test_set_test_options(test-unicode4 TEST_PROPERTIES TIMEOUT 3000)

-# link pthreads to tests that need it
-find_package(Threads REQUIRED)
-json_test_set_test_options(test-regression2 LINK_LIBRARIES Threads::Threads)
-
 #############################################################################
 # add unit tests
 #############################################################################
@@ -55,8 +55,6 @@ TEST_CASE("lexer class")

        SECTION("numbers")
        {
-            // Number parsing implementation uses std::from_chars where available,
-            // so run this test suite with JSON_HAS_CPP_17 as well.
            CHECK((scan_string("0") == json::lexer::token_type::value_unsigned));
            CHECK((scan_string("1") == json::lexer::token_type::value_unsigned));
            CHECK((scan_string("2") == json::lexer::token_type::value_unsigned));
@@ -67,20 +65,13 @@ TEST_CASE("lexer class")
            CHECK((scan_string("7") == json::lexer::token_type::value_unsigned));
            CHECK((scan_string("8") == json::lexer::token_type::value_unsigned));
            CHECK((scan_string("9") == json::lexer::token_type::value_unsigned));
-            CHECK((scan_string("18446744073709551615") == json::lexer::token_type::value_unsigned));

            CHECK((scan_string("-0") == json::lexer::token_type::value_integer));
            CHECK((scan_string("-1") == json::lexer::token_type::value_integer));
-            CHECK((scan_string("-9223372036854775808") == json::lexer::token_type::value_integer));

            CHECK((scan_string("1.1") == json::lexer::token_type::value_float));
            CHECK((scan_string("-1.1") == json::lexer::token_type::value_float));
            CHECK((scan_string("1E10") == json::lexer::token_type::value_float));
-
-            // out-of-range integers/floats are treated as value_float tokens
-            CHECK((scan_string("18446744073709551616") == json::lexer::token_type::value_float));
-            CHECK((scan_string("-9223372036854775809") == json::lexer::token_type::value_float));
-            CHECK((scan_string("1E400") == json::lexer::token_type::value_float));
        }

        SECTION("whitespace")
@@ -1782,21 +1782,6 @@ TEST_CASE("std::optional")
                             "[json.exception.type_error.302] type must be string, but is null", json::type_error&);
        CHECK_THROWS_WITH_AS(std::optional<int>(j_null),
                             "[json.exception.type_error.302] type must be number, but is null", json::type_error&);
-
-        // Assignment goes through the same overload resolution as direct
-        // construction, so it throws for the same reason. This relies on
-        // basic_json's implicit conversion operator, so it only applies
-        // when JSON_USE_IMPLICIT_CONVERSIONS is enabled (the default).
-#if JSON_USE_IMPLICIT_CONVERSIONS
-        std::optional<std::string> opt_assign;
-        CHECK_THROWS_WITH_AS(opt_assign = j_null,
-                             "[json.exception.type_error.302] type must be string, but is null", json::type_error&);
-#endif
-
-        // get_to() is the correct way to obtain std::nullopt from a JSON null.
-        std::optional<std::string> opt_get_to = "placeholder";
-        j_null.get_to(opt_get_to);
-        CHECK(opt_get_to == std::nullopt);
    }

    SECTION("string")
@@ -1,278 +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"
-
-#include <nlohmann/json.hpp>
-
-#include <algorithm>
-#include <cmath>
-#include <cstddef>
-#include <limits>
-#include <string>
-#include <system_error>
-
-// nlohmann::details::from_chars is a wrapper around std::from_chars when it is
-// available (__cpp_lib_to_chars is defined), otherwise our fallback
-// implementation kicks in.
-//
-// Due to the incomplete implementation of this C++17 standard library feature
-// (for example, lack of support for long double even in current libc++),
-// JSON_HAS_CPP_17 does not guarantee that std::from_chars is available.
-// However, the reverse holds: If the test is compiled in C++11 mode, the
-// fallback implementation will be used for sure.
-// By mentioning the JSON_HAS_CPP_17 macro in this here comment, the test will
-// be compiled both using our fallback and, at least on some platforms,
-// the C++17 standard library version, as a way of ensuring that the
-// expectations formulated in this test align with `std::from_chars`.
-
-namespace
-{
-struct init_val_t {};
-constexpr init_val_t init_val{};
-
-template <typename T>
-void check_result(std::string& str, T& value, std::ptrdiff_t expected_ptr_offset, std::errc expected_ec)
-{
-    // On platforms where neither `std::from_chars`, nor extended locale support (`strtof_l`) are
-    // available, the `strtof`-based implementation is in fact locale-dependent and might use a
-    // different decimal separator, so we need to adapt the test expectations accordingly.
-    std::replace(str.begin(), str.end(), '.', nlohmann::detail::from_chars_traits<T>::get_decimal_point());
-
-    auto res = nlohmann::detail::from_chars(str.data(), str.data() + str.size(), value);
-    CHECK_MESSAGE(res.ec == expected_ec, "Error code mismatch while parsing: \"", str,
-                  "\": Actual: ", make_error_code(res.ec).message(),
-                  "; expected: ", make_error_code(expected_ec).message());
-    CHECK_MESSAGE(res.ptr - str.data() == expected_ptr_offset, "Ptr offset mismatch while parsing: \"", str, "\"");
-}
-
-template <typename T>
-typename std::enable_if<std::is_integral<T>::value, void>::type
-check(std::string str, T expected_value, std::ptrdiff_t expected_ptr_offset, std::errc expected_ec)
-{
-    T value = 42;
-    check_result(str, value, expected_ptr_offset, expected_ec);
-    CHECK_MESSAGE(value == expected_value, "while parsing: \"", str, "\"");
-}
-
-template <typename T>
-typename std::enable_if<std::is_floating_point<T>::value, void>::type
-check(std::string str, T expected_value, std::ptrdiff_t expected_ptr_offset, std::errc expected_ec)
-{
-    {
-        T value = 42;
-        check_result(str, value, expected_ptr_offset, expected_ec);
-        CHECK_MESSAGE(value == expected_value, "while parsing: \"", str, "\"");
-        CHECK_MESSAGE(std::signbit(value) == std::signbit(expected_value), "while parsing: \"", str, "\"");
-    }
-    {
-        T value = std::numeric_limits<T>::quiet_NaN();
-        check_result(str, value, expected_ptr_offset, expected_ec);
-        CHECK_MESSAGE(value == expected_value, "while parsing: \"", str, "\"");
-    }
-}
-
-template <typename T>
-typename std::enable_if<std::is_integral<T>::value, void>::type
-check(std::string str, init_val_t /*unused*/, std::ptrdiff_t expected_ptr_offset, std::errc expected_ec)
-{
-    T const init_value = 42;
-    T value = init_value;
-    check_result(str, value, expected_ptr_offset, expected_ec);
-    CHECK_MESSAGE(value == init_value, "while parsing: \"", str, "\"");
-}
-
-template <typename T>
-typename std::enable_if<std::is_floating_point<T>::value, void>::type
-check(std::string str, init_val_t /*unused*/, std::ptrdiff_t expected_ptr_offset, std::errc expected_ec)
-{
-    {
-        T const init_value = 42;
-        T value = init_value;
-        check_result(str, value, expected_ptr_offset, expected_ec);
-        CHECK_MESSAGE(value == init_value, "while parsing: \"", str, "\"");
-    }
-    {
-        T value = std::numeric_limits<T>::quiet_NaN();
-        check_result(str, value, expected_ptr_offset, expected_ec);
-        CHECK_MESSAGE(doctest::IsNaN<T>(value), "while parsing: \"", str, "\"");
-    }
-}
-
-}  // namespace
-
-TEST_CASE("integral results consistent with std::from_chars")
-{
-    SECTION("unsigned long long")
-    {
-        check<unsigned long long>("", init_val, 0, std::errc::invalid_argument);
-        check<unsigned long long>("0", 0ULL, 1, std::errc{});
-        check<unsigned long long>(" 123", init_val, 0, std::errc::invalid_argument);
-        check<unsigned long long>("123 ", 123ULL, 3, std::errc{});
-        check<unsigned long long>("+123", init_val, 0, std::errc::invalid_argument);
-        check<unsigned long long>("-123", init_val, 0, std::errc::invalid_argument);
-        check<unsigned long long>("123", 123ULL, 3, std::errc{});
-        check<unsigned long long>("123e10", 123ULL, 3, std::errc{});
-        check<unsigned long long>("18446744073709551615", 18446744073709551615ULL, 20, std::errc{});
-        check<unsigned long long>("18446744073709551616", init_val, 20, std::errc::result_out_of_range);
-    }
-
-    SECTION("long long")
-    {
-        check<long long>("", init_val, 0, std::errc::invalid_argument);
-        check<long long>("0", 0LL, 1, std::errc{});
-        check<long long>(" 123", init_val, 0, std::errc::invalid_argument);
-        check<long long>("123 ", 123LL, 3, std::errc{});
-        check<long long>("+123", init_val, 0, std::errc::invalid_argument);
-        check<long long>("-123", -123LL, 4, std::errc{});
-        check<long long>("123", 123LL, 3, std::errc{});
-        check<long long>("123e10", 123LL, 3, std::errc{});
-        check<long long>("9223372036854775807", 9223372036854775807LL, 19, std::errc{});
-        check<long long>("9223372036854775808", init_val, 19, std::errc::result_out_of_range);
-        check<long long>("-9223372036854775808", -9223372036854775807LL - 1, 20, std::errc{});
-        check<long long>("-9223372036854775809", init_val, 20, std::errc::result_out_of_range);
-    }
-}
-
-TEST_CASE("floating point results consistent with std::from_chars")
-{
-    INFO("Using decimal point '",
-         std::string{1, nlohmann::detail::from_chars_traits<float>::get_decimal_point()},
-         "' to match our possibly-locale-dependent from_chars fallback implementation");
-
-    SECTION("single precision")
-    {
-        check<float>("", init_val, 0, std::errc::invalid_argument);
-        check<float>(" 123", init_val, 0, std::errc::invalid_argument);
-        check<float>("123 ", 123.0f, 3, std::errc{});
-        check<float>("+123", init_val, 0, std::errc::invalid_argument);
-        check<float>("-123", -123.0f, 4, std::errc{});
-        check<float>("123", 123.0f, 3, std::errc{});
-        check<float>("123e10", 123e10f, 6, std::errc{});
-        check<float>("123e+10", 123e10f, 7, std::errc{});
-        check<float>("123e-10", 123e-10f, 7, std::errc{});
-        check<float>("123.456", 123.456f, 7, std::errc{});
-        check<float>("123;456", 123.0f, 3, std::errc{});
-        check<float>("123.456 ", 123.456f, 7, std::errc{});
-        check<float>("123;456 ", 123.0f, 3, std::errc{});
-        check<float>("123456789.123456789", 123456789.123456789f, 19, std::errc{});
-        check<float>("1e40", std::numeric_limits<float>::infinity(), 4, std::errc::result_out_of_range);
-        check<float>("-1e40", -std::numeric_limits<float>::infinity(), 5, std::errc::result_out_of_range);
-        check<float>("2e308", std::numeric_limits<float>::infinity(), 5, std::errc::result_out_of_range);
-        check<float>("-2e308", -std::numeric_limits<float>::infinity(), 6, std::errc::result_out_of_range);
-        check<float>("123.456e-789", 0.0f, 12, std::errc::result_out_of_range);
-        check<float>("-123.456e-789", -0.0f, 13, std::errc::result_out_of_range);
-        check<float>("1e-45", 1e-45f, 5, std::errc{});
-        check<float>("1e-46", 0.0f, 5, std::errc::result_out_of_range);
-        check<float>("1E-45", 1e-45f, 5, std::errc{});
-        check<float>("1E-46", 0.0f, 5, std::errc::result_out_of_range);
-        check<float>("10e-46", 1e-45f, 6, std::errc{});
-        check<float>("0.1e-45", 0.0f, 7, std::errc::result_out_of_range);
-        check<float>("100000000000000000000000000000000000000", 1e38f, 39, std::errc{});
-        check<float>("100000000000000000000000000000000000000.0", 1e38f, 41, std::errc{});
-        check<float>("1000000000000000000000000000000000000000e-1", 1e38f, 43, std::errc{});
-        check<float>("0.0000000000000000000000000000000000000000000001e84", 1e38f, 51, std::errc{});
-        check<float>("0.000000000000000000000000000000000000000000001", 1e-45f, 47, std::errc{});
-        check<float>("00.000000000000000000000000000000000000000000001", 1e-45f, 48, std::errc{});
-        check<float>("0.0000000000000000000000000000000000000000000001e1", 1e-45f, 50, std::errc{});
-        check<float>("1000000000000000000000000000000000000000e-84", 1e-45f, 44, std::errc{});
-        check<float>("1000000000000000000000000000000000000000", std::numeric_limits<float>::infinity(), 40, std::errc::result_out_of_range);
-        check<float>("1000000000000000000000000000000000000000.0", std::numeric_limits<float>::infinity(), 42, std::errc::result_out_of_range);
-        check<float>("100000000000000000000000000000000000000e1", std::numeric_limits<float>::infinity(), 41, std::errc::result_out_of_range);
-        check<float>("0.0000000000000000000000000000000000000000000001e85", std::numeric_limits<float>::infinity(), 51, std::errc::result_out_of_range);
-        check<float>("1000000000000000000000000000000000000000e-85", 0.0f, 44, std::errc::result_out_of_range);
-        check<float>("0.0000000000000000000000000000000000000000000001", 0.0f, 48, std::errc::result_out_of_range);
-        check<float>("0.000000000000000000000000000000000000000000001e-1", 0.0f, 50, std::errc::result_out_of_range);
-        check<float>("1e-99999999999999999999", 0.0f, 23, std::errc::result_out_of_range);
-        check<float>("1e+99999999999999999999", std::numeric_limits<float>::infinity(), 23, std::errc::result_out_of_range);
-        check<float>("-1e-99999999999999999999", -0.0f, 24, std::errc::result_out_of_range);
-        check<float>("-1e+99999999999999999999", -std::numeric_limits<float>::infinity(), 24, std::errc::result_out_of_range);
-    }
-
-    SECTION("double precision")
-    {
-        check<double>("", init_val, 0, std::errc::invalid_argument);
-        check<double>(" 123", init_val, 0, std::errc::invalid_argument);
-        check<double>("123 ", 123.0, 3, std::errc{});
-        check<double>("+123", init_val, 0, std::errc::invalid_argument);
-        check<double>("-123", -123.0, 4, std::errc{});
-        check<double>("123", 123.0, 3, std::errc{});
-        check<double>("123e10", 123e10, 6, std::errc{});
-        check<double>("123e+10", 123e10, 7, std::errc{});
-        check<double>("123e-10", 123e-10, 7, std::errc{});
-        check<double>("123.456", 123.456, 7, std::errc{});
-        check<double>("123;456", 123.0, 3, std::errc{});
-        check<double>("123.456 ", 123.456, 7, std::errc{});
-        check<double>("123;456 ", 123.0, 3, std::errc{});
-        check<double>("123456789.123456789", 123456789.123456789, 19, std::errc{});
-        check<double>("1e40", 1e40, 4, std::errc{});
-        check<double>("-1e40", -1e40, 5, std::errc{});
-        check<double>("2e308", std::numeric_limits<double>::infinity(), 5, std::errc::result_out_of_range);
-        check<double>("-2e308", -std::numeric_limits<double>::infinity(), 6, std::errc::result_out_of_range);
-        check<double>("2e-324", 0.0, 6, std::errc::result_out_of_range);
-        check<double>("-2e-324", -0.0, 7, std::errc::result_out_of_range);
-        check<double>("123.456e-789", 0.0, 12, std::errc::result_out_of_range);
-        check<double>("-123.456e-789", -0.0, 13, std::errc::result_out_of_range);
-        check<double>("1e-99999999999999999999", 0.0, 23, std::errc::result_out_of_range);
-        check<double>("1e+99999999999999999999", std::numeric_limits<double>::infinity(), 23, std::errc::result_out_of_range);
-        check<double>("-1e-99999999999999999999", -0.0, 24, std::errc::result_out_of_range);
-        check<double>("-1e+99999999999999999999", -std::numeric_limits<double>::infinity(), 24, std::errc::result_out_of_range);
-    }
-
-    SECTION("long double precision")
-    {
-        check<long double>("", init_val, 0, std::errc::invalid_argument);
-        check<long double>(" 123", init_val, 0, std::errc::invalid_argument);
-        check<long double>("123 ", 123.0L, 3, std::errc{});
-        check<long double>("+123", init_val, 0, std::errc::invalid_argument);
-        check<long double>("-123", -123.0L, 4, std::errc{});
-        check<long double>("123", 123.0L, 3, std::errc{});
-        check<long double>("123e10", 123e10L, 6, std::errc{});
-        check<long double>("123e+10", 123e10L, 7, std::errc{});
-        check<long double>("123e-10", 123e-10L, 7, std::errc{});
-        check<long double>("123.456", 123.456L, 7, std::errc{});
-        check<long double>("123;456", 123.0L, 3, std::errc{});
-        check<long double>("123.456 ", 123.456L, 7, std::errc{});
-        check<long double>("123;456 ", 123.0L, 3, std::errc{});
-        check<long double>("123456789.123456789", 123456789.123456789L, 19, std::errc{});
-        check<long double>("1e40", 1e40L, 4, std::errc{});
-        check<long double>("-1e40", -1e40L, 5, std::errc{});
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable: 4127)
-#endif
-        if (sizeof(long double) > 8)
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-        {
-            // Right-hand-side is calculated to avoid warning about literal
-            // exceeding range on platforms where this branch is NOT taken.
-            check<long double>("2e308", 1e308L * 2, 5, std::errc{});
-            check<long double>("-2e308", -1e308L * 2, 6, std::errc{});
-            check<long double>("2e-324", 8e-324L / 4, 6, std::errc{});
-            check<long double>("-2e-324", -8e-324L / 4, 7, std::errc{});
-        }
-        else
-        {
-            check<long double>("2e308", std::numeric_limits<long double>::infinity(), 5, std::errc::result_out_of_range);
-            check<long double>("-2e308", -std::numeric_limits<long double>::infinity(), 6, std::errc::result_out_of_range);
-            check<long double>("2e-324", 0.0L, 6, std::errc::result_out_of_range);
-            check<long double>("-2e-324", -0.0L, 7, std::errc::result_out_of_range);
-        }
-        check<long double>("1e5000", std::numeric_limits<long double>::infinity(), 6, std::errc::result_out_of_range);
-        check<long double>("-1e5000", -std::numeric_limits<long double>::infinity(), 7, std::errc::result_out_of_range);
-        check<long double>("123.456e-7890", 0.0L, 13, std::errc::result_out_of_range);
-        check<long double>("-123.456e-7890", -0.0L, 14, std::errc::result_out_of_range);
-        check<long double>("1e-99999999999999999999", 0.0L, 23, std::errc::result_out_of_range);
-        check<long double>("1e+99999999999999999999", std::numeric_limits<long double>::infinity(), 23, std::errc::result_out_of_range);
-        check<long double>("-1e-99999999999999999999", -0.0L, 24, std::errc::result_out_of_range);
-        check<long double>("-1e+99999999999999999999", -std::numeric_limits<long double>::infinity(), 24, std::errc::result_out_of_range);
-    }
-}
-
@@ -26,11 +26,8 @@ using ordered_json = nlohmann::ordered_json;
    using namespace nlohmann::literals; // NOLINT(google-build-using-namespace)
 #endif

-#include <atomic>
-#include <clocale>
 #include <cstdio>
 #include <list>
-#include <thread>
 #include <type_traits>
 #include <utility>

@@ -1242,44 +1239,6 @@ TEST_CASE("regression tests 2")
        CHECK(j == json({2, 4, 6}));
    }
 #endif
-
-    SECTION("issue #5198 - TOCTOU race between lexer construction and locale changes causes float truncation")
-    {
-        std::atomic<bool> stop_requested{};
-        std::thread switcher([&stop_requested]
-        {
-            bool german = true;
-            const std::string initial_locale = std::setlocale(LC_NUMERIC, nullptr);
-
-            while (!stop_requested)
-            {
-                const bool setlocale_res = std::setlocale(LC_NUMERIC, german ? "de_DE.UTF-8" : "C");
-                WARN_MESSAGE(setlocale_res,
-                             "Setting locale failed, probably because de_DE.UTF-8 is not installed. "
-                             "This test was skipped as it would be inconclusive.");
-                if (!setlocale_res)
-                {
-                    stop_requested = true;
-                }
-                german = !german;
-            }
-
-            (void)std::setlocale(LC_NUMERIC, initial_locale.c_str()); // restore original locale
-        });
-
-        for (std::size_t i = 0; i < 10000 && !stop_requested; ++i)
-        {
-            const json j = json::parse("{\"val\": 99.123456789}");
-            const double parsed = j.value("val", 0.0);
-            if (!CHECK(parsed == 99.123456789))
-            {
-                break;
-            }
-        }
-
-        stop_requested = true;
-        switcher.join();
-    }
 }

 TEST_CASE_TEMPLATE("issue #4798 - nlohmann::json::to_msgpack() encode float NaN as double", T, double, float) // NOLINT(readability-math-missing-parentheses, bugprone-throwing-static-initialization)
@@ -778,6 +778,124 @@ class derived_person_only_serialize_private_3 : person_without_default_construct
    NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE_WITH_NAMES(derived_person_only_serialize_private_3, person_without_default_constructor_3, "json_hair_color", hair_color)
 };

+// Zero-member types for issue #4041: NLOHMANN_DEFINE_TYPE_* and
+// NLOHMANN_DEFINE_DERIVED_TYPE_* must compile and produce a valid (empty)
+// JSON object when no member arguments are given.
+class empty_intrusive
+{
+  public:
+    bool operator==(const empty_intrusive& /*rhs*/) const
+    {
+        return true;
+    }
+    NLOHMANN_DEFINE_TYPE_INTRUSIVE(empty_intrusive)
+};
+
+class empty_intrusive_with_default
+{
+  public:
+    bool operator==(const empty_intrusive_with_default& /*rhs*/) const
+    {
+        return true;
+    }
+    NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(empty_intrusive_with_default)
+};
+
+class empty_intrusive_only_serialize
+{
+  public:
+    NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(empty_intrusive_only_serialize)
+};
+
+class empty_non_intrusive
+{
+  public:
+    bool operator==(const empty_non_intrusive& /*rhs*/) const
+    {
+        return true;
+    }
+};
+// NOLINTNEXTLINE(misc-use-internal-linkage)
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(empty_non_intrusive)
+
+class empty_non_intrusive_with_default
+{
+  public:
+    bool operator==(const empty_non_intrusive_with_default& /*rhs*/) const
+    {
+        return true;
+    }
+};
+// NOLINTNEXTLINE(misc-use-internal-linkage)
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(empty_non_intrusive_with_default)
+
+class empty_non_intrusive_only_serialize {};
+// NOLINTNEXTLINE(misc-use-internal-linkage)
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(empty_non_intrusive_only_serialize)
+
+class empty_derived_intrusive : public person_with_private_data
+{
+  public:
+    empty_derived_intrusive() = default;
+    empty_derived_intrusive(std::string name_, int age_, json metadata_)
+        : person_with_private_data(std::move(name_), age_, std::move(metadata_))
+    {}
+    NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE(empty_derived_intrusive, person_with_private_data)
+};
+
+class empty_derived_intrusive_with_default : public person_with_private_data
+{
+  public:
+    empty_derived_intrusive_with_default() = default;
+    empty_derived_intrusive_with_default(std::string name_, int age_, json metadata_)
+        : person_with_private_data(std::move(name_), age_, std::move(metadata_))
+    {}
+    NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT(empty_derived_intrusive_with_default, person_with_private_data)
+};
+
+class empty_derived_intrusive_only_serialize : public person_with_private_data
+{
+  public:
+    empty_derived_intrusive_only_serialize() = default;
+    empty_derived_intrusive_only_serialize(std::string name_, int age_, json metadata_)
+        : person_with_private_data(std::move(name_), age_, std::move(metadata_))
+    {}
+    NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE(empty_derived_intrusive_only_serialize, person_with_private_data)
+};
+
+class empty_derived_non_intrusive : public person_with_private_data
+{
+  public:
+    empty_derived_non_intrusive() = default;
+    empty_derived_non_intrusive(std::string name_, int age_, json metadata_)
+        : person_with_private_data(std::move(name_), age_, std::move(metadata_))
+    {}
+};
+// NOLINTNEXTLINE(misc-use-internal-linkage)
+NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE(empty_derived_non_intrusive, person_with_private_data)
+
+class empty_derived_non_intrusive_with_default : public person_with_private_data
+{
+  public:
+    empty_derived_non_intrusive_with_default() = default;
+    empty_derived_non_intrusive_with_default(std::string name_, int age_, json metadata_)
+        : person_with_private_data(std::move(name_), age_, std::move(metadata_))
+    {}
+};
+// NOLINTNEXTLINE(misc-use-internal-linkage)
+NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT(empty_derived_non_intrusive_with_default, person_with_private_data)
+
+class empty_derived_non_intrusive_only_serialize : public person_with_private_data
+{
+  public:
+    empty_derived_non_intrusive_only_serialize() = default;
+    empty_derived_non_intrusive_only_serialize(std::string name_, int age_, json metadata_)
+        : person_with_private_data(std::move(name_), age_, std::move(metadata_))
+    {}
+};
+// NOLINTNEXTLINE(misc-use-internal-linkage)
+NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(empty_derived_non_intrusive_only_serialize, person_with_private_data)
+
 } // namespace persons

 TEST_CASE_TEMPLATE("Serialization/deserialization via NLOHMANN_DEFINE_TYPE_INTRUSIVE and NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE", Pair, // NOLINT(readability-math-missing-parentheses, bugprone-throwing-static-initialization)
@@ -1191,3 +1309,108 @@ TEST_CASE_TEMPLATE("Serialization of non-default-constructible classes via NLOHM
        }
    }
 }
+
+// Regression tests for issue #4041: NLOHMANN_DEFINE_TYPE_* and
+// NLOHMANN_DEFINE_DERIVED_TYPE_* macros must compile and produce valid
+// (empty, or base-only for the derived case) JSON objects when no member
+// arguments are given, on every supported C++ standard.
+TEST_CASE_TEMPLATE("Serialization/deserialization of zero-member types via NLOHMANN_DEFINE_TYPE_* (issue #4041)", Json, // NOLINT(readability-math-missing-parentheses, bugprone-throwing-static-initialization)
+                   nlohmann::json, nlohmann::ordered_json)
+{
+    constexpr bool is_ordered = std::is_same<Json, nlohmann::ordered_json>::value;
+    const char* const derived_dump = is_ordered
+                                     ? R"({"age":1,"name":"Erik","metadata":null})"
+                                     : R"({"age":1,"metadata":null,"name":"Erik"})";
+
+    SECTION("NLOHMANN_DEFINE_TYPE_INTRUSIVE with zero members")
+    {
+        persons::empty_intrusive obj{};
+        Json j = obj;
+        CHECK(j.dump() == "{}");
+        CHECK(j.template get<persons::empty_intrusive>() == obj);
+    }
+
+    SECTION("NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT with zero members")
+    {
+        persons::empty_intrusive_with_default obj{};
+        Json j = obj;
+        CHECK(j.dump() == "{}");
+        CHECK(j.template get<persons::empty_intrusive_with_default>() == obj);
+    }
+
+    SECTION("NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE with zero members")
+    {
+        const persons::empty_intrusive_only_serialize obj{};
+        Json j = obj;
+        CHECK(j.dump() == "{}");
+    }
+
+    SECTION("NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE with zero members")
+    {
+        persons::empty_non_intrusive obj{};
+        Json j = obj;
+        CHECK(j.dump() == "{}");
+        CHECK(j.template get<persons::empty_non_intrusive>() == obj);
+    }
+
+    SECTION("NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT with zero members")
+    {
+        persons::empty_non_intrusive_with_default obj{};
+        Json j = obj;
+        CHECK(j.dump() == "{}");
+        CHECK(j.template get<persons::empty_non_intrusive_with_default>() == obj);
+    }
+
+    SECTION("NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE with zero members")
+    {
+        const persons::empty_non_intrusive_only_serialize obj{};
+        Json j = obj;
+        CHECK(j.dump() == "{}");
+    }
+
+    SECTION("NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE with zero own members")
+    {
+        persons::empty_derived_intrusive obj{"Erik", 1, nullptr};
+        Json j = obj;
+        CHECK(j.dump() == derived_dump);
+        CHECK(j.template get<persons::empty_derived_intrusive>() == obj);
+    }
+
+    SECTION("NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT with zero own members")
+    {
+        persons::empty_derived_intrusive_with_default obj{"Erik", 1, nullptr};
+        Json j = obj;
+        CHECK(j.dump() == derived_dump);
+        CHECK(j.template get<persons::empty_derived_intrusive_with_default>() == obj);
+    }
+
+    SECTION("NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE with zero own members")
+    {
+        const persons::empty_derived_intrusive_only_serialize obj{"Erik", 1, nullptr};
+        Json j = obj;
+        CHECK(j.dump() == derived_dump);
+    }
+
+    SECTION("NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE with zero own members")
+    {
+        persons::empty_derived_non_intrusive obj{"Erik", 1, nullptr};
+        Json j = obj;
+        CHECK(j.dump() == derived_dump);
+        CHECK(j.template get<persons::empty_derived_non_intrusive>() == obj);
+    }
+
+    SECTION("NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT with zero own members")
+    {
+        persons::empty_derived_non_intrusive_with_default obj{"Erik", 1, nullptr};
+        Json j = obj;
+        CHECK(j.dump() == derived_dump);
+        CHECK(j.template get<persons::empty_derived_non_intrusive_with_default>() == obj);
+    }
+
+    SECTION("NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE with zero own members")
+    {
+        const persons::empty_derived_non_intrusive_only_serialize obj{"Erik", 1, nullptr};
+        Json j = obj;
+        CHECK(j.dump() == derived_dump);
+    }
+}
@@ -6,13 +6,6 @@
 // SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
 // SPDX-License-Identifier: MIT

-// cmake/test.cmake selects the C++ standard versions with which to build a
-// unit test based on the presence of JSON_HAS_CPP_<VERSION> macros.
-// When using macros that are only defined for particular versions of the standard
-// (e.g., JSON_HAS_FILESYSTEM for C++17 and up), please mention the corresponding
-// version macro in a comment close by, like this:
-// JSON_HAS_CPP_<VERSION> (do not remove; see note at top of file)
-
 #include "doctest_compatibility.h"

 #include <nlohmann/json.hpp>
@@ -20,10 +13,6 @@ using nlohmann::json;

 #include <list>

-#if defined(__cpp_lib_concepts) && defined(JSON_HAS_CPP_20)
-    #include <iterator>
-#endif
-
 namespace
 {
 TEST_CASE("Use arbitrary stdlib container")
@@ -212,22 +201,4 @@ TEST_CASE("Parse with heterogeneous iterator and sentinel types")
    CHECK(j2.at(0) == 1);
 }

-#if defined(__cpp_lib_concepts) && defined(JSON_HAS_CPP_20)
-// JSON_HAS_CPP_20 (do not remove; see note at top of file)
-TEST_CASE("Parse with std::counted_iterator and std::default_sentinel_t")
-{
-    using iterator_type = std::string::const_iterator;
-    const std::string json_str = R"({"key":"value","array":[1,2,3]})";
-    const auto len = static_cast<std::iter_difference_t<iterator_type>>(json_str.size());
-
-    const std::counted_iterator<iterator_type> first(json_str.begin(), len);
-    const json j = json::parse(first, std::default_sentinel);
-    CHECK(j["key"] == "value");
-    CHECK(j["array"].size() == 3);
-
-    const std::counted_iterator<iterator_type> first2(json_str.begin(), len);
-    CHECK(json::accept(first2, std::default_sentinel));
-}
-#endif
-
 } // namespace