CameraHealth.h

Go to the documentation of this file.

/*******************************************************************************
 * This file is part of the Zivid API
 *
 * Copyright 2015-2026 (C) Zivid AS
 * All rights reserved.
 *
 * Zivid Software License, v1.0
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * 3. Neither the name of Zivid AS nor the names of its contributors may be used
 * to endorse or promote products derived from this software without specific
 * prior written permission.
 *
 * 4. This software, with or without modification, must not be used with any
 * other 3D camera than from Zivid AS.
 *
 * 5. Any software provided in binary form under this license must not be
 * reverse engineered, decompiled, modified and/or disassembled.
 *
 * THIS SOFTWARE IS PROVIDED BY ZIVID AS "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL ZIVID AS OR CONTRIBUTORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * Contact: Zivid Customer Success Team <customersuccess@zivid.com>
 * Info:    http://www.zivid.com
 ******************************************************************************/
 
#pragma once
 
#include <array>
#include <chrono>
#include <cmath>
#include <ctime>
#include <iomanip>
#include <memory>
#include <optional>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
 
#include "Zivid/DataModel/Detail/Detail.h"
#include "Zivid/DataModel/NodeType.h"
#include "Zivid/DataModel/Traits.h"
#include "Zivid/Detail/CoreExport.h"
#include "Zivid/Detail/TypeTraits.h"
#include "Zivid/Range.h"
 
#ifdef _MSC_VER
#    pragma warning(push)
#    pragma warning(disable : 4251) // "X needs to have dll-interface to be used by clients of class Y."
#endif
 
namespace Zivid
{

 
    // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
    class ZIVID_CORE_EXPORT CameraHealth
    {
    public:
        static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;

        static constexpr const char *path{ "" };

        static constexpr const char *name{ "CameraHealth" };

        static constexpr const char *description{
            R"description(Result of running the camera's health checks. Each check has a
`Status` (severity) and a `Value` (the underlying measurement, when
available). The `Overall` field aggregates the worst severity across
all populated checks.
 
Status values:
  - OK: Optimal.
  - Suboptimal: Degraded but functional.
  - Error: Faulty or out of spec.
  - Unknown: Check was not performed, or its outcome could not be determined.
)description"
        };
 
        static constexpr size_t version{ 1 };
 
#ifndef NO_DOC
        template<size_t>
        struct Version;
 
        using LatestVersion = Zivid::CameraHealth;
 
        // Short identifier. This value is not guaranteed to be universally unique
        // Todo(ZIVID-2808): Move this to internal DataModelExt header
        static constexpr std::array<uint8_t, 3> binaryId{ 'h', 'c', 'k' };
 
#endif

 
        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
        class ZIVID_CORE_EXPORT Fan
        {
        public:
            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;

            static constexpr const char *path{ "Fan" };

            static constexpr const char *name{ "Fan" };

            static constexpr const char *description{ R"description(The status of the camera's fan.
 
  - OK: Fan operating as expected.
  - Error: Unexpected fan stop.
  - Unknown: Fan status could not be determined.
)description" };

 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT Status
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;

                static constexpr const char *path{ "Fan/Status" };

                static constexpr const char *name{ "Status" };

                static constexpr const char *description{ R"description(Severity of the fan check.)description" };

                enum class ValueType
                {
                    ok,
                    suboptimal,
                    error,
                    unknown
                };
                static const Status ok;         
                static const Status suboptimal; 
                static const Status error;      
                static const Status unknown;    

                static std::set<ValueType> validValues()
                {
                    return { ValueType::ok, ValueType::suboptimal, ValueType::error, ValueType::unknown };
                }

                Status() = default;

                explicit constexpr Status(ValueType value)
                    : m_value{ verifyValue(value) }
                {}

                ValueType value() const;

                std::string toString() const;

                friend std::ostream &operator<<(std::ostream &stream, const Status::ValueType &value)
                {
                    return stream << Status{ value }.toString();
                }

                bool operator==(const Status &other) const
                {
                    return m_value == other.m_value;
                }

                bool operator!=(const Status &other) const
                {
                    return m_value != other.m_value;
                }

                friend std::ostream &operator<<(std::ostream &stream, const Status &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                constexpr ValueType static verifyValue(const ValueType &value)
                {
                    return value == ValueType::ok || value == ValueType::suboptimal || value == ValueType::error
                                   || value == ValueType::unknown
                               ? value
                               : throw std::invalid_argument{
                                     "Invalid value: Status{ "
                                     + std::to_string(static_cast<std::underlying_type<ValueType>::type>(value)) + " }"
                                 };
                }
 
                ValueType m_value{ ValueType::unknown };
 
                friend struct DataModel::Detail::Befriend<Status>;
            };

 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT Value
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;

                static constexpr const char *path{ "Fan/Value" };

                static constexpr const char *name{ "Value" };

                static constexpr const char *description{
                    R"description(Whether the fan is operating as expected, or stopped unexpectedly.)description"
                };

                enum class ValueType
                {
                    ok,
                    unexpectedFanStop
                };
                static const Value ok;                
                static const Value unexpectedFanStop; 

                static std::set<ValueType> validValues()
                {
                    return { ValueType::ok, ValueType::unexpectedFanStop };
                }

                Value() = default;

                explicit constexpr Value(ValueType value)
                    : m_opt{ verifyValue(value) }
                {}

                ValueType value() const;

                bool hasValue() const;

                void reset();

                std::string toString() const;

                friend std::ostream &operator<<(std::ostream &stream, const Value::ValueType &value)
                {
                    return stream << Value{ value }.toString();
                }

                bool operator==(const Value &other) const
                {
                    return m_opt == other.m_opt;
                }

                bool operator!=(const Value &other) const
                {
                    return m_opt != other.m_opt;
                }

                friend std::ostream &operator<<(std::ostream &stream, const Value &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                constexpr ValueType static verifyValue(const ValueType &value)
                {
                    return value == ValueType::ok || value == ValueType::unexpectedFanStop
                               ? value
                               : throw std::invalid_argument{
                                     "Invalid value: Value{ "
                                     + std::to_string(static_cast<std::underlying_type<ValueType>::type>(value)) + " }"
                                 };
                }
 
                std::optional<ValueType> m_opt;
 
                friend struct DataModel::Detail::Befriend<Value>;
            };
 
            using Descendants = std::tuple<CameraHealth::Fan::Status, CameraHealth::Fan::Value>;

            Fan();

#ifndef NO_DOC
            template<
                typename... Args,
                typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
                typename std::enable_if<
                    Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::
                        value,
                    int>::type = 0>
#else
            template<typename... Args>
#endif
            explicit Fan(Args &&...args)
            {
                using namespace Zivid::Detail::TypeTraits;
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to Fan(...). "
                    "Types should be listed at most once.");
 
                set(std::forward<Args>(args)...);
            }

#ifndef NO_DOC
            template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
#else
            template<typename... Args>
#endif
            void set(Args &&...args)
            {
                using namespace Zivid::Detail::TypeTraits;
 
                using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                static_assert(
                    AllArgsAreDescendantNodes::value, "All arguments passed to set(...) must be descendant nodes.");
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to set(...). "
                    "Types should be listed at most once.");
 
                Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
            }

#ifndef NO_DOC
            template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
#else
            template<typename... Args>
#endif
            Fan copyWith(Args &&...args) const
            {
                using namespace Zivid::Detail::TypeTraits;
 
                using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                static_assert(
                    AllArgsAreDescendantNodes::value,
                    "All arguments passed to copyWith(...) must be descendant nodes.");
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to copyWith(...). "
                    "Types should be listed at most once.");
 
                auto copy{ *this };
                copy.set(std::forward<Args>(args)...);
                return copy;
            }

            const Status &status() const
            {
                return m_status;
            }

            Status &status()
            {
                return m_status;
            }

            Fan &set(const Status &value)
            {
                m_status = value;
                return *this;
            }

            const Value &value() const
            {
                return m_value;
            }

            Value &value()
            {
                return m_value;
            }

            Fan &set(const Value &value)
            {
                m_value = value;
                return *this;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, CameraHealth::Fan::Status>::value, int>::type = 0>
            const CameraHealth::Fan::Status &get() const
            {
                return m_status;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, CameraHealth::Fan::Value>::value, int>::type = 0>
            const CameraHealth::Fan::Value &get() const
            {
                return m_value;
            }
 
            template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
            const CameraHealth::Fan::Status &get() const
            {
                return m_status;
            }
 
            template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
            const CameraHealth::Fan::Value &get() const
            {
                return m_value;
            }

            template<typename F>
            void forEach(const F &f) const
            {
                f(m_status);
                f(m_value);
            }

            template<typename F>
            void forEach(const F &f)
            {
                f(m_status);
                f(m_value);
            }

            bool operator==(const Fan &other) const;

            bool operator!=(const Fan &other) const;

            std::string toString() const;

            friend std::ostream &operator<<(std::ostream &stream, const Fan &value)
            {
                return stream << value.toString();
            }
 
        private:
            void setFromString(const std::string &value);
 
            void setFromString(const std::string &fullPath, const std::string &value);
 
            std::string getString(const std::string &fullPath) const;
 
            Status m_status;
            Value m_value;
 
            friend struct DataModel::Detail::Befriend<Fan>;
        };

 
        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
        class ZIVID_CORE_EXPORT InfieldVerification
        {
        public:
            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;

            static constexpr const char *path{ "InfieldVerification" };

            static constexpr const char *name{ "InfieldVerification" };

            static constexpr const char *description{
                R"description(The status of the camera's most recent infield verification.
 
  - OK: Last verification performed within the past year
  - Suboptimal: Last verification older than one year
  - Unknown: Camera has never been verified in the field
)description"
            };

 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT Status
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;

                static constexpr const char *path{ "InfieldVerification/Status" };

                static constexpr const char *name{ "Status" };

                static constexpr const char *description{
                    R"description(Severity of the infield verification check.)description"
                };

                enum class ValueType
                {
                    ok,
                    suboptimal,
                    error,
                    unknown
                };
                static const Status ok;         
                static const Status suboptimal; 
                static const Status error;      
                static const Status unknown;    

                static std::set<ValueType> validValues()
                {
                    return { ValueType::ok, ValueType::suboptimal, ValueType::error, ValueType::unknown };
                }

                Status() = default;

                explicit constexpr Status(ValueType value)
                    : m_value{ verifyValue(value) }
                {}

                ValueType value() const;

                std::string toString() const;

                friend std::ostream &operator<<(std::ostream &stream, const Status::ValueType &value)
                {
                    return stream << Status{ value }.toString();
                }

                bool operator==(const Status &other) const
                {
                    return m_value == other.m_value;
                }

                bool operator!=(const Status &other) const
                {
                    return m_value != other.m_value;
                }

                friend std::ostream &operator<<(std::ostream &stream, const Status &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                constexpr ValueType static verifyValue(const ValueType &value)
                {
                    return value == ValueType::ok || value == ValueType::suboptimal || value == ValueType::error
                                   || value == ValueType::unknown
                               ? value
                               : throw std::invalid_argument{
                                     "Invalid value: Status{ "
                                     + std::to_string(static_cast<std::underlying_type<ValueType>::type>(value)) + " }"
                                 };
                }
 
                ValueType m_value{ ValueType::unknown };
 
                friend struct DataModel::Detail::Befriend<Status>;
            };

 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT Value
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;

                static constexpr const char *path{ "InfieldVerification/Value" };

                static constexpr const char *name{ "Value" };

                static constexpr const char *description{
                    R"description(Time of the most recent infield verification.)description"
                };

                using ValueType = std::chrono::system_clock::time_point;

                static constexpr Range<std::chrono::system_clock::time_point> validRange()
                {
                    return { std::chrono::system_clock::time_point::min(),
                             std::chrono::system_clock::time_point::max() };
                }

                Value() = default;

                explicit constexpr Value(std::chrono::system_clock::time_point value)
                    : m_opt{ value }
                {}

                std::chrono::system_clock::time_point value() const;

                bool hasValue() const;

                void reset();

                std::string toString() const;

                bool operator==(const Value &other) const
                {
                    return m_opt == other.m_opt;
                }

                bool operator!=(const Value &other) const
                {
                    return m_opt != other.m_opt;
                }

                bool operator<(const Value &other) const
                {
                    return m_opt < other.m_opt;
                }

                bool operator>(const Value &other) const
                {
                    return m_opt > other.m_opt;
                }

                bool operator<=(const Value &other) const
                {
                    return m_opt <= other.m_opt;
                }

                bool operator>=(const Value &other) const
                {
                    return m_opt >= other.m_opt;
                }

                friend std::ostream &operator<<(std::ostream &stream, const Value &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                std::optional<std::chrono::system_clock::time_point> m_opt;
 
                friend struct DataModel::Detail::Befriend<Value>;
            };
 
            using Descendants =
                std::tuple<CameraHealth::InfieldVerification::Status, CameraHealth::InfieldVerification::Value>;

            InfieldVerification();

#ifndef NO_DOC
            template<
                typename... Args,
                typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
                typename std::enable_if<
                    Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::
                        value,
                    int>::type = 0>
#else
            template<typename... Args>
#endif
            explicit InfieldVerification(Args &&...args)
            {
                using namespace Zivid::Detail::TypeTraits;
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to InfieldVerification(...). "
                    "Types should be listed at most once.");
 
                set(std::forward<Args>(args)...);
            }

#ifndef NO_DOC
            template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
#else
            template<typename... Args>
#endif
            void set(Args &&...args)
            {
                using namespace Zivid::Detail::TypeTraits;
 
                using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                static_assert(
                    AllArgsAreDescendantNodes::value, "All arguments passed to set(...) must be descendant nodes.");
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to set(...). "
                    "Types should be listed at most once.");
 
                Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
            }

#ifndef NO_DOC
            template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
#else
            template<typename... Args>
#endif
            InfieldVerification copyWith(Args &&...args) const
            {
                using namespace Zivid::Detail::TypeTraits;
 
                using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                static_assert(
                    AllArgsAreDescendantNodes::value,
                    "All arguments passed to copyWith(...) must be descendant nodes.");
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to copyWith(...). "
                    "Types should be listed at most once.");
 
                auto copy{ *this };
                copy.set(std::forward<Args>(args)...);
                return copy;
            }

            const Status &status() const
            {
                return m_status;
            }

            Status &status()
            {
                return m_status;
            }

            InfieldVerification &set(const Status &value)
            {
                m_status = value;
                return *this;
            }

            const Value &value() const
            {
                return m_value;
            }

            Value &value()
            {
                return m_value;
            }

            InfieldVerification &set(const Value &value)
            {
                m_value = value;
                return *this;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, CameraHealth::InfieldVerification::Status>::value, int>::type =
                    0>
            const CameraHealth::InfieldVerification::Status &get() const
            {
                return m_status;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, CameraHealth::InfieldVerification::Value>::value, int>::type =
                    0>
            const CameraHealth::InfieldVerification::Value &get() const
            {
                return m_value;
            }
 
            template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
            const CameraHealth::InfieldVerification::Status &get() const
            {
                return m_status;
            }
 
            template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
            const CameraHealth::InfieldVerification::Value &get() const
            {
                return m_value;
            }

            template<typename F>
            void forEach(const F &f) const
            {
                f(m_status);
                f(m_value);
            }

            template<typename F>
            void forEach(const F &f)
            {
                f(m_status);
                f(m_value);
            }

            bool operator==(const InfieldVerification &other) const;

            bool operator!=(const InfieldVerification &other) const;

            std::string toString() const;

            friend std::ostream &operator<<(std::ostream &stream, const InfieldVerification &value)
            {
                return stream << value.toString();
            }
 
        private:
            void setFromString(const std::string &value);
 
            void setFromString(const std::string &fullPath, const std::string &value);
 
            std::string getString(const std::string &fullPath) const;
 
            Status m_status;
            Value m_value;
 
            friend struct DataModel::Detail::Befriend<InfieldVerification>;
        };

 
        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
        class ZIVID_CORE_EXPORT MaxTransferSpeed
        {
        public:
            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;

            static constexpr const char *path{ "MaxTransferSpeed" };

            static constexpr const char *name{ "MaxTransferSpeed" };

            static constexpr const char *description{
                R"description(The end-to-end link speed between the camera and the host
computer, defined as the minimum of the camera's link speed
and the PC's link speed.
 
  - OK: Max transfer speed > 1 Gbps
  - Suboptimal: Max transfer speed = 1 Gbps
  - Error: Max transfer speed < 1 Gbps
  - Unknown: Max transfer speed could not be determined
)description"
            };

 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT Status
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;

                static constexpr const char *path{ "MaxTransferSpeed/Status" };

                static constexpr const char *name{ "Status" };

                static constexpr const char *description{
                    R"description(Severity of the max transfer speed check.)description"
                };

                enum class ValueType
                {
                    ok,
                    suboptimal,
                    error,
                    unknown
                };
                static const Status ok;         
                static const Status suboptimal; 
                static const Status error;      
                static const Status unknown;    

                static std::set<ValueType> validValues()
                {
                    return { ValueType::ok, ValueType::suboptimal, ValueType::error, ValueType::unknown };
                }

                Status() = default;

                explicit constexpr Status(ValueType value)
                    : m_value{ verifyValue(value) }
                {}

                ValueType value() const;

                std::string toString() const;

                friend std::ostream &operator<<(std::ostream &stream, const Status::ValueType &value)
                {
                    return stream << Status{ value }.toString();
                }

                bool operator==(const Status &other) const
                {
                    return m_value == other.m_value;
                }

                bool operator!=(const Status &other) const
                {
                    return m_value != other.m_value;
                }

                friend std::ostream &operator<<(std::ostream &stream, const Status &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                constexpr ValueType static verifyValue(const ValueType &value)
                {
                    return value == ValueType::ok || value == ValueType::suboptimal || value == ValueType::error
                                   || value == ValueType::unknown
                               ? value
                               : throw std::invalid_argument{
                                     "Invalid value: Status{ "
                                     + std::to_string(static_cast<std::underlying_type<ValueType>::type>(value)) + " }"
                                 };
                }
 
                ValueType m_value{ ValueType::unknown };
 
                friend struct DataModel::Detail::Befriend<Status>;
            };

 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT Value
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;

                static constexpr const char *path{ "MaxTransferSpeed/Value" };

                static constexpr const char *name{ "Value" };

                static constexpr const char *description{
                    R"description(Max transfer speed in megabits per second (Mbps).)description"
                };

                using ValueType = uint32_t;

                static constexpr Range<uint32_t> validRange()
                {
                    return { std::numeric_limits<uint32_t>::lowest(), std::numeric_limits<uint32_t>::max() };
                }

                Value() = default;

                explicit constexpr Value(uint32_t value)
                    : m_opt{ value }
                {}

                uint32_t value() const;

                bool hasValue() const;

                void reset();

                std::string toString() const;

                bool operator==(const Value &other) const
                {
                    return m_opt == other.m_opt;
                }

                bool operator!=(const Value &other) const
                {
                    return m_opt != other.m_opt;
                }

                bool operator<(const Value &other) const
                {
                    return m_opt < other.m_opt;
                }

                bool operator>(const Value &other) const
                {
                    return m_opt > other.m_opt;
                }

                bool operator<=(const Value &other) const
                {
                    return m_opt <= other.m_opt;
                }

                bool operator>=(const Value &other) const
                {
                    return m_opt >= other.m_opt;
                }

                friend std::ostream &operator<<(std::ostream &stream, const Value &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                std::optional<uint32_t> m_opt;
 
                friend struct DataModel::Detail::Befriend<Value>;
            };
 
            using Descendants =
                std::tuple<CameraHealth::MaxTransferSpeed::Status, CameraHealth::MaxTransferSpeed::Value>;

            MaxTransferSpeed();

#ifndef NO_DOC
            template<
                typename... Args,
                typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
                typename std::enable_if<
                    Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::
                        value,
                    int>::type = 0>
#else
            template<typename... Args>
#endif
            explicit MaxTransferSpeed(Args &&...args)
            {
                using namespace Zivid::Detail::TypeTraits;
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to MaxTransferSpeed(...). "
                    "Types should be listed at most once.");
 
                set(std::forward<Args>(args)...);
            }

#ifndef NO_DOC
            template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
#else
            template<typename... Args>
#endif
            void set(Args &&...args)
            {
                using namespace Zivid::Detail::TypeTraits;
 
                using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                static_assert(
                    AllArgsAreDescendantNodes::value, "All arguments passed to set(...) must be descendant nodes.");
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to set(...). "
                    "Types should be listed at most once.");
 
                Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
            }

#ifndef NO_DOC
            template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
#else
            template<typename... Args>
#endif
            MaxTransferSpeed copyWith(Args &&...args) const
            {
                using namespace Zivid::Detail::TypeTraits;
 
                using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                static_assert(
                    AllArgsAreDescendantNodes::value,
                    "All arguments passed to copyWith(...) must be descendant nodes.");
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to copyWith(...). "
                    "Types should be listed at most once.");
 
                auto copy{ *this };
                copy.set(std::forward<Args>(args)...);
                return copy;
            }

            const Status &status() const
            {
                return m_status;
            }

            Status &status()
            {
                return m_status;
            }

            MaxTransferSpeed &set(const Status &value)
            {
                m_status = value;
                return *this;
            }

            const Value &value() const
            {
                return m_value;
            }

            Value &value()
            {
                return m_value;
            }

            MaxTransferSpeed &set(const Value &value)
            {
                m_value = value;
                return *this;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, CameraHealth::MaxTransferSpeed::Status>::value, int>::type = 0>
            const CameraHealth::MaxTransferSpeed::Status &get() const
            {
                return m_status;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, CameraHealth::MaxTransferSpeed::Value>::value, int>::type = 0>
            const CameraHealth::MaxTransferSpeed::Value &get() const
            {
                return m_value;
            }
 
            template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
            const CameraHealth::MaxTransferSpeed::Status &get() const
            {
                return m_status;
            }
 
            template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
            const CameraHealth::MaxTransferSpeed::Value &get() const
            {
                return m_value;
            }

            template<typename F>
            void forEach(const F &f) const
            {
                f(m_status);
                f(m_value);
            }

            template<typename F>
            void forEach(const F &f)
            {
                f(m_status);
                f(m_value);
            }

            bool operator==(const MaxTransferSpeed &other) const;

            bool operator!=(const MaxTransferSpeed &other) const;

            std::string toString() const;

            friend std::ostream &operator<<(std::ostream &stream, const MaxTransferSpeed &value)
            {
                return stream << value.toString();
            }
 
        private:
            void setFromString(const std::string &value);
 
            void setFromString(const std::string &fullPath, const std::string &value);
 
            std::string getString(const std::string &fullPath) const;
 
            Status m_status;
            Value m_value;
 
            friend struct DataModel::Detail::Befriend<MaxTransferSpeed>;
        };

 
        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
        class ZIVID_CORE_EXPORT Memory
        {
        public:
            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;

            static constexpr const char *path{ "Memory" };

            static constexpr const char *name{ "Memory" };

            static constexpr const char *description{ R"description(The status of the camera's memory test.
 
  - OK: Memory was tested and reported zero errors
  - Error: Memory was tested and an error was located
  - Unknown: Memory test was not performed
)description" };

 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT Status
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;

                static constexpr const char *path{ "Memory/Status" };

                static constexpr const char *name{ "Status" };

                static constexpr const char *description{ R"description(Severity of the memory check.)description" };

                enum class ValueType
                {
                    ok,
                    suboptimal,
                    error,
                    unknown
                };
                static const Status ok;         
                static const Status suboptimal; 
                static const Status error;      
                static const Status unknown;    

                static std::set<ValueType> validValues()
                {
                    return { ValueType::ok, ValueType::suboptimal, ValueType::error, ValueType::unknown };
                }

                Status() = default;

                explicit constexpr Status(ValueType value)
                    : m_value{ verifyValue(value) }
                {}

                ValueType value() const;

                std::string toString() const;

                friend std::ostream &operator<<(std::ostream &stream, const Status::ValueType &value)
                {
                    return stream << Status{ value }.toString();
                }

                bool operator==(const Status &other) const
                {
                    return m_value == other.m_value;
                }

                bool operator!=(const Status &other) const
                {
                    return m_value != other.m_value;
                }

                friend std::ostream &operator<<(std::ostream &stream, const Status &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                constexpr ValueType static verifyValue(const ValueType &value)
                {
                    return value == ValueType::ok || value == ValueType::suboptimal || value == ValueType::error
                                   || value == ValueType::unknown
                               ? value
                               : throw std::invalid_argument{
                                     "Invalid value: Status{ "
                                     + std::to_string(static_cast<std::underlying_type<ValueType>::type>(value)) + " }"
                                 };
                }
 
                ValueType m_value{ ValueType::unknown };
 
                friend struct DataModel::Detail::Befriend<Status>;
            };

 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT Value
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;

                static constexpr const char *path{ "Memory/Value" };

                static constexpr const char *name{ "Value" };

                static constexpr const char *description{
                    R"description(Number of memory errors detected by the memory test.)description"
                };

                using ValueType = uint32_t;

                static constexpr Range<uint32_t> validRange()
                {
                    return { std::numeric_limits<uint32_t>::lowest(), std::numeric_limits<uint32_t>::max() };
                }

                Value() = default;

                explicit constexpr Value(uint32_t value)
                    : m_opt{ value }
                {}

                uint32_t value() const;

                bool hasValue() const;

                void reset();

                std::string toString() const;

                bool operator==(const Value &other) const
                {
                    return m_opt == other.m_opt;
                }

                bool operator!=(const Value &other) const
                {
                    return m_opt != other.m_opt;
                }

                bool operator<(const Value &other) const
                {
                    return m_opt < other.m_opt;
                }

                bool operator>(const Value &other) const
                {
                    return m_opt > other.m_opt;
                }

                bool operator<=(const Value &other) const
                {
                    return m_opt <= other.m_opt;
                }

                bool operator>=(const Value &other) const
                {
                    return m_opt >= other.m_opt;
                }

                friend std::ostream &operator<<(std::ostream &stream, const Value &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                std::optional<uint32_t> m_opt;
 
                friend struct DataModel::Detail::Befriend<Value>;
            };
 
            using Descendants = std::tuple<CameraHealth::Memory::Status, CameraHealth::Memory::Value>;

            Memory();

#ifndef NO_DOC
            template<
                typename... Args,
                typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
                typename std::enable_if<
                    Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::
                        value,
                    int>::type = 0>
#else
            template<typename... Args>
#endif
            explicit Memory(Args &&...args)
            {
                using namespace Zivid::Detail::TypeTraits;
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to Memory(...). "
                    "Types should be listed at most once.");
 
                set(std::forward<Args>(args)...);
            }

#ifndef NO_DOC
            template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
#else
            template<typename... Args>
#endif
            void set(Args &&...args)
            {
                using namespace Zivid::Detail::TypeTraits;
 
                using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                static_assert(
                    AllArgsAreDescendantNodes::value, "All arguments passed to set(...) must be descendant nodes.");
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to set(...). "
                    "Types should be listed at most once.");
 
                Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
            }

#ifndef NO_DOC
            template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
#else
            template<typename... Args>
#endif
            Memory copyWith(Args &&...args) const
            {
                using namespace Zivid::Detail::TypeTraits;
 
                using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                static_assert(
                    AllArgsAreDescendantNodes::value,
                    "All arguments passed to copyWith(...) must be descendant nodes.");
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to copyWith(...). "
                    "Types should be listed at most once.");
 
                auto copy{ *this };
                copy.set(std::forward<Args>(args)...);
                return copy;
            }

            const Status &status() const
            {
                return m_status;
            }

            Status &status()
            {
                return m_status;
            }

            Memory &set(const Status &value)
            {
                m_status = value;
                return *this;
            }

            const Value &value() const
            {
                return m_value;
            }

            Value &value()
            {
                return m_value;
            }

            Memory &set(const Value &value)
            {
                m_value = value;
                return *this;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, CameraHealth::Memory::Status>::value, int>::type = 0>
            const CameraHealth::Memory::Status &get() const
            {
                return m_status;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, CameraHealth::Memory::Value>::value, int>::type = 0>
            const CameraHealth::Memory::Value &get() const
            {
                return m_value;
            }
 
            template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
            const CameraHealth::Memory::Status &get() const
            {
                return m_status;
            }
 
            template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
            const CameraHealth::Memory::Value &get() const
            {
                return m_value;
            }

            template<typename F>
            void forEach(const F &f) const
            {
                f(m_status);
                f(m_value);
            }

            template<typename F>
            void forEach(const F &f)
            {
                f(m_status);
                f(m_value);
            }

            bool operator==(const Memory &other) const;

            bool operator!=(const Memory &other) const;

            std::string toString() const;

            friend std::ostream &operator<<(std::ostream &stream, const Memory &value)
            {
                return stream << value.toString();
            }
 
        private:
            void setFromString(const std::string &value);
 
            void setFromString(const std::string &fullPath, const std::string &value);
 
            std::string getString(const std::string &fullPath) const;
 
            Status m_status;
            Value m_value;
 
            friend struct DataModel::Detail::Befriend<Memory>;
        };

 
        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
        class ZIVID_CORE_EXPORT Overall
        {
        public:
            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;

            static constexpr const char *path{ "Overall" };

            static constexpr const char *name{ "Overall" };

            static constexpr const char *description{
                R"description(The aggregated severity across all checks, taking the
highest-precedence severity among them. Precedence from highest to
lowest is Error, Unknown, Suboptimal, OK: a failing check is the
most important to surface, and a check whose outcome could not be
determined (Unknown) takes precedence over a Suboptimal one.
)description"
            };

            enum class ValueType
            {
                ok,
                suboptimal,
                error,
                unknown
            };
            static const Overall ok;         
            static const Overall suboptimal; 
            static const Overall error;      
            static const Overall unknown;    

            static std::set<ValueType> validValues()
            {
                return { ValueType::ok, ValueType::suboptimal, ValueType::error, ValueType::unknown };
            }

            Overall() = default;

            explicit constexpr Overall(ValueType value)
                : m_value{ verifyValue(value) }
            {}

            ValueType value() const;

            std::string toString() const;

            friend std::ostream &operator<<(std::ostream &stream, const Overall::ValueType &value)
            {
                return stream << Overall{ value }.toString();
            }

            bool operator==(const Overall &other) const
            {
                return m_value == other.m_value;
            }

            bool operator!=(const Overall &other) const
            {
                return m_value != other.m_value;
            }

            friend std::ostream &operator<<(std::ostream &stream, const Overall &value)
            {
                return stream << value.toString();
            }
 
        private:
            void setFromString(const std::string &value);
 
            constexpr ValueType static verifyValue(const ValueType &value)
            {
                return value == ValueType::ok || value == ValueType::suboptimal || value == ValueType::error
                               || value == ValueType::unknown
                           ? value
                           : throw std::invalid_argument{
                                 "Invalid value: Overall{ "
                                 + std::to_string(static_cast<std::underlying_type<ValueType>::type>(value)) + " }"
                             };
            }
 
            ValueType m_value{ ValueType::unknown };
 
            friend struct DataModel::Detail::Befriend<Overall>;
        };

 
        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
        class ZIVID_CORE_EXPORT Temperature
        {
        public:
            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;

            static constexpr const char *path{ "Temperature" };

            static constexpr const char *name{ "Temperature" };

            static constexpr const char *description{
                R"description(The status of the camera's temperatures. Each sub-status
reflects the temperature of a specific component.
)description"
            };

 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT DMD
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;

                static constexpr const char *path{ "Temperature/DMD" };

                static constexpr const char *name{ "DMD" };

                static constexpr const char *description{
                    R"description(The status of the DMD (Digital Micromirror Device)
temperature, in degrees Celsius.
 
  - OK: Temperature in (0, 50)
  - Suboptimal: Temperature in [50, 60]
  - Error: Temperature < 0 or > 60
)description"
                };

 
                // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                class ZIVID_CORE_EXPORT Status
                {
                public:
                    static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;

                    static constexpr const char *path{ "Temperature/DMD/Status" };

                    static constexpr const char *name{ "Status" };

                    static constexpr const char *description{
                        R"description(Severity of the DMD temperature check.)description"
                    };

                    enum class ValueType
                    {
                        ok,
                        suboptimal,
                        error,
                        unknown
                    };
                    static const Status ok;         
                    static const Status suboptimal; 
                    static const Status error;      
                    static const Status unknown;    

                    static std::set<ValueType> validValues()
                    {
                        return { ValueType::ok, ValueType::suboptimal, ValueType::error, ValueType::unknown };
                    }

                    Status() = default;

                    explicit constexpr Status(ValueType value)
                        : m_value{ verifyValue(value) }
                    {}

                    ValueType value() const;

                    std::string toString() const;

                    friend std::ostream &operator<<(std::ostream &stream, const Status::ValueType &value)
                    {
                        return stream << Status{ value }.toString();
                    }

                    bool operator==(const Status &other) const
                    {
                        return m_value == other.m_value;
                    }

                    bool operator!=(const Status &other) const
                    {
                        return m_value != other.m_value;
                    }

                    friend std::ostream &operator<<(std::ostream &stream, const Status &value)
                    {
                        return stream << value.toString();
                    }
 
                private:
                    void setFromString(const std::string &value);
 
                    constexpr ValueType static verifyValue(const ValueType &value)
                    {
                        return value == ValueType::ok || value == ValueType::suboptimal || value == ValueType::error
                                       || value == ValueType::unknown
                                   ? value
                                   : throw std::invalid_argument{
                                         "Invalid value: Status{ "
                                         + std::to_string(static_cast<std::underlying_type<ValueType>::type>(value))
                                         + " }"
                                     };
                    }
 
                    ValueType m_value{ ValueType::unknown };
 
                    friend struct DataModel::Detail::Befriend<Status>;
                };

 
                // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                class ZIVID_CORE_EXPORT Value
                {
                public:
                    static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;

                    static constexpr const char *path{ "Temperature/DMD/Value" };

                    static constexpr const char *name{ "Value" };

                    static constexpr const char *description{
                        R"description(DMD temperature in degrees Celsius.)description"
                    };

                    using ValueType = double;

                    static constexpr Range<double> validRange()
                    {
                        return { std::numeric_limits<double>::lowest(), std::numeric_limits<double>::max() };
                    }

                    Value() = default;

                    explicit constexpr Value(double value)
                        : m_opt{ value }
                    {}

                    double value() const;

                    bool hasValue() const;

                    void reset();

                    std::string toString() const;

                    bool operator==(const Value &other) const
                    {
                        return m_opt == other.m_opt;
                    }

                    bool operator!=(const Value &other) const
                    {
                        return m_opt != other.m_opt;
                    }

                    bool operator<(const Value &other) const
                    {
                        return m_opt < other.m_opt;
                    }

                    bool operator>(const Value &other) const
                    {
                        return m_opt > other.m_opt;
                    }

                    bool operator<=(const Value &other) const
                    {
                        return m_opt <= other.m_opt;
                    }

                    bool operator>=(const Value &other) const
                    {
                        return m_opt >= other.m_opt;
                    }

                    friend std::ostream &operator<<(std::ostream &stream, const Value &value)
                    {
                        return stream << value.toString();
                    }
 
                private:
                    void setFromString(const std::string &value);
 
                    std::optional<double> m_opt;
 
                    friend struct DataModel::Detail::Befriend<Value>;
                };
 
                using Descendants =
                    std::tuple<CameraHealth::Temperature::DMD::Status, CameraHealth::Temperature::DMD::Value>;

                DMD();

#ifndef NO_DOC
                template<
                    typename... Args,
                    typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
                    typename std::enable_if<
                        Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::
                            value,
                        int>::type = 0>
#else
                template<typename... Args>
#endif
                explicit DMD(Args &&...args)
                {
                    using namespace Zivid::Detail::TypeTraits;
 
                    static_assert(
                        AllArgsDecayedAreUnique<Args...>::value,
                        "Found duplicate types among the arguments passed to DMD(...). "
                        "Types should be listed at most once.");
 
                    set(std::forward<Args>(args)...);
                }

#ifndef NO_DOC
                template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
#else
                template<typename... Args>
#endif
                void set(Args &&...args)
                {
                    using namespace Zivid::Detail::TypeTraits;
 
                    using AllArgsAreDescendantNodes =
                        AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                    static_assert(
                        AllArgsAreDescendantNodes::value, "All arguments passed to set(...) must be descendant nodes.");
 
                    static_assert(
                        AllArgsDecayedAreUnique<Args...>::value,
                        "Found duplicate types among the arguments passed to set(...). "
                        "Types should be listed at most once.");
 
                    Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
                }

#ifndef NO_DOC
                template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
#else
                template<typename... Args>
#endif
                DMD copyWith(Args &&...args) const
                {
                    using namespace Zivid::Detail::TypeTraits;
 
                    using AllArgsAreDescendantNodes =
                        AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                    static_assert(
                        AllArgsAreDescendantNodes::value,
                        "All arguments passed to copyWith(...) must be descendant nodes.");
 
                    static_assert(
                        AllArgsDecayedAreUnique<Args...>::value,
                        "Found duplicate types among the arguments passed to copyWith(...). "
                        "Types should be listed at most once.");
 
                    auto copy{ *this };
                    copy.set(std::forward<Args>(args)...);
                    return copy;
                }

                const Status &status() const
                {
                    return m_status;
                }

                Status &status()
                {
                    return m_status;
                }

                DMD &set(const Status &value)
                {
                    m_status = value;
                    return *this;
                }

                const Value &value() const
                {
                    return m_value;
                }

                Value &value()
                {
                    return m_value;
                }

                DMD &set(const Value &value)
                {
                    m_value = value;
                    return *this;
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, CameraHealth::Temperature::DMD::Status>::value, int>::type =
                        0>
                const CameraHealth::Temperature::DMD::Status &get() const
                {
                    return m_status;
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, CameraHealth::Temperature::DMD::Value>::value, int>::type =
                        0>
                const CameraHealth::Temperature::DMD::Value &get() const
                {
                    return m_value;
                }
 
                template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                const CameraHealth::Temperature::DMD::Status &get() const
                {
                    return m_status;
                }
 
                template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
                const CameraHealth::Temperature::DMD::Value &get() const
                {
                    return m_value;
                }

                template<typename F>
                void forEach(const F &f) const
                {
                    f(m_status);
                    f(m_value);
                }

                template<typename F>
                void forEach(const F &f)
                {
                    f(m_status);
                    f(m_value);
                }

                bool operator==(const DMD &other) const;

                bool operator!=(const DMD &other) const;

                std::string toString() const;

                friend std::ostream &operator<<(std::ostream &stream, const DMD &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                void setFromString(const std::string &fullPath, const std::string &value);
 
                std::string getString(const std::string &fullPath) const;
 
                Status m_status;
                Value m_value;
 
                friend struct DataModel::Detail::Befriend<DMD>;
            };

 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT LED
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;

                static constexpr const char *path{ "Temperature/LED" };

                static constexpr const char *name{ "LED" };

                static constexpr const char *description{
                    R"description(The status of the LED temperature, in degrees Celsius.
 
  - OK: Temperature in (0, 60)
  - Suboptimal: Temperature in [60, 70]
  - Error: Temperature < 0 or > 70
)description"
                };

 
                // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                class ZIVID_CORE_EXPORT Status
                {
                public:
                    static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;

                    static constexpr const char *path{ "Temperature/LED/Status" };

                    static constexpr const char *name{ "Status" };

                    static constexpr const char *description{
                        R"description(Severity of the LED temperature check.)description"
                    };

                    enum class ValueType
                    {
                        ok,
                        suboptimal,
                        error,
                        unknown
                    };
                    static const Status ok;         
                    static const Status suboptimal; 
                    static const Status error;      
                    static const Status unknown;    

                    static std::set<ValueType> validValues()
                    {
                        return { ValueType::ok, ValueType::suboptimal, ValueType::error, ValueType::unknown };
                    }

                    Status() = default;

                    explicit constexpr Status(ValueType value)
                        : m_value{ verifyValue(value) }
                    {}

                    ValueType value() const;

                    std::string toString() const;

                    friend std::ostream &operator<<(std::ostream &stream, const Status::ValueType &value)
                    {
                        return stream << Status{ value }.toString();
                    }

                    bool operator==(const Status &other) const
                    {
                        return m_value == other.m_value;
                    }

                    bool operator!=(const Status &other) const
                    {
                        return m_value != other.m_value;
                    }

                    friend std::ostream &operator<<(std::ostream &stream, const Status &value)
                    {
                        return stream << value.toString();
                    }
 
                private:
                    void setFromString(const std::string &value);
 
                    constexpr ValueType static verifyValue(const ValueType &value)
                    {
                        return value == ValueType::ok || value == ValueType::suboptimal || value == ValueType::error
                                       || value == ValueType::unknown
                                   ? value
                                   : throw std::invalid_argument{
                                         "Invalid value: Status{ "
                                         + std::to_string(static_cast<std::underlying_type<ValueType>::type>(value))
                                         + " }"
                                     };
                    }
 
                    ValueType m_value{ ValueType::unknown };
 
                    friend struct DataModel::Detail::Befriend<Status>;
                };

 
                // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                class ZIVID_CORE_EXPORT Value
                {
                public:
                    static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;

                    static constexpr const char *path{ "Temperature/LED/Value" };

                    static constexpr const char *name{ "Value" };

                    static constexpr const char *description{
                        R"description(LED temperature in degrees Celsius.)description"
                    };

                    using ValueType = double;

                    static constexpr Range<double> validRange()
                    {
                        return { std::numeric_limits<double>::lowest(), std::numeric_limits<double>::max() };
                    }

                    Value() = default;

                    explicit constexpr Value(double value)
                        : m_opt{ value }
                    {}

                    double value() const;

                    bool hasValue() const;

                    void reset();

                    std::string toString() const;

                    bool operator==(const Value &other) const
                    {
                        return m_opt == other.m_opt;
                    }

                    bool operator!=(const Value &other) const
                    {
                        return m_opt != other.m_opt;
                    }

                    bool operator<(const Value &other) const
                    {
                        return m_opt < other.m_opt;
                    }

                    bool operator>(const Value &other) const
                    {
                        return m_opt > other.m_opt;
                    }

                    bool operator<=(const Value &other) const
                    {
                        return m_opt <= other.m_opt;
                    }

                    bool operator>=(const Value &other) const
                    {
                        return m_opt >= other.m_opt;
                    }

                    friend std::ostream &operator<<(std::ostream &stream, const Value &value)
                    {
                        return stream << value.toString();
                    }
 
                private:
                    void setFromString(const std::string &value);
 
                    std::optional<double> m_opt;
 
                    friend struct DataModel::Detail::Befriend<Value>;
                };
 
                using Descendants =
                    std::tuple<CameraHealth::Temperature::LED::Status, CameraHealth::Temperature::LED::Value>;

                LED();

#ifndef NO_DOC
                template<
                    typename... Args,
                    typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
                    typename std::enable_if<
                        Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::
                            value,
                        int>::type = 0>
#else
                template<typename... Args>
#endif
                explicit LED(Args &&...args)
                {
                    using namespace Zivid::Detail::TypeTraits;
 
                    static_assert(
                        AllArgsDecayedAreUnique<Args...>::value,
                        "Found duplicate types among the arguments passed to LED(...). "
                        "Types should be listed at most once.");
 
                    set(std::forward<Args>(args)...);
                }

#ifndef NO_DOC
                template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
#else
                template<typename... Args>
#endif
                void set(Args &&...args)
                {
                    using namespace Zivid::Detail::TypeTraits;
 
                    using AllArgsAreDescendantNodes =
                        AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                    static_assert(
                        AllArgsAreDescendantNodes::value, "All arguments passed to set(...) must be descendant nodes.");
 
                    static_assert(
                        AllArgsDecayedAreUnique<Args...>::value,
                        "Found duplicate types among the arguments passed to set(...). "
                        "Types should be listed at most once.");
 
                    Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
                }

#ifndef NO_DOC
                template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
#else
                template<typename... Args>
#endif
                LED copyWith(Args &&...args) const
                {
                    using namespace Zivid::Detail::TypeTraits;
 
                    using AllArgsAreDescendantNodes =
                        AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                    static_assert(
                        AllArgsAreDescendantNodes::value,
                        "All arguments passed to copyWith(...) must be descendant nodes.");
 
                    static_assert(
                        AllArgsDecayedAreUnique<Args...>::value,
                        "Found duplicate types among the arguments passed to copyWith(...). "
                        "Types should be listed at most once.");
 
                    auto copy{ *this };
                    copy.set(std::forward<Args>(args)...);
                    return copy;
                }

                const Status &status() const
                {
                    return m_status;
                }

                Status &status()
                {
                    return m_status;
                }

                LED &set(const Status &value)
                {
                    m_status = value;
                    return *this;
                }

                const Value &value() const
                {
                    return m_value;
                }

                Value &value()
                {
                    return m_value;
                }

                LED &set(const Value &value)
                {
                    m_value = value;
                    return *this;
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, CameraHealth::Temperature::LED::Status>::value, int>::type =
                        0>
                const CameraHealth::Temperature::LED::Status &get() const
                {
                    return m_status;
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, CameraHealth::Temperature::LED::Value>::value, int>::type =
                        0>
                const CameraHealth::Temperature::LED::Value &get() const
                {
                    return m_value;
                }
 
                template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                const CameraHealth::Temperature::LED::Status &get() const
                {
                    return m_status;
                }
 
                template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
                const CameraHealth::Temperature::LED::Value &get() const
                {
                    return m_value;
                }

                template<typename F>
                void forEach(const F &f) const
                {
                    f(m_status);
                    f(m_value);
                }

                template<typename F>
                void forEach(const F &f)
                {
                    f(m_status);
                    f(m_value);
                }

                bool operator==(const LED &other) const;

                bool operator!=(const LED &other) const;

                std::string toString() const;

                friend std::ostream &operator<<(std::ostream &stream, const LED &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                void setFromString(const std::string &fullPath, const std::string &value);
 
                std::string getString(const std::string &fullPath) const;
 
                Status m_status;
                Value m_value;
 
                friend struct DataModel::Detail::Befriend<LED>;
            };

 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT Lens
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;

                static constexpr const char *path{ "Temperature/Lens" };

                static constexpr const char *name{ "Lens" };

                static constexpr const char *description{
                    R"description(The status of the lens temperature, in degrees Celsius.
 
  - OK: Temperature in (0, 50)
  - Suboptimal: Temperature in [50, 60]
  - Error: Temperature < 0 or > 60
)description"
                };

 
                // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                class ZIVID_CORE_EXPORT Status
                {
                public:
                    static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;

                    static constexpr const char *path{ "Temperature/Lens/Status" };

                    static constexpr const char *name{ "Status" };

                    static constexpr const char *description{
                        R"description(Severity of the lens temperature check.)description"
                    };

                    enum class ValueType
                    {
                        ok,
                        suboptimal,
                        error,
                        unknown
                    };
                    static const Status ok;         
                    static const Status suboptimal; 
                    static const Status error;      
                    static const Status unknown;    

                    static std::set<ValueType> validValues()
                    {
                        return { ValueType::ok, ValueType::suboptimal, ValueType::error, ValueType::unknown };
                    }

                    Status() = default;

                    explicit constexpr Status(ValueType value)
                        : m_value{ verifyValue(value) }
                    {}

                    ValueType value() const;

                    std::string toString() const;

                    friend std::ostream &operator<<(std::ostream &stream, const Status::ValueType &value)
                    {
                        return stream << Status{ value }.toString();
                    }

                    bool operator==(const Status &other) const
                    {
                        return m_value == other.m_value;
                    }

                    bool operator!=(const Status &other) const
                    {
                        return m_value != other.m_value;
                    }

                    friend std::ostream &operator<<(std::ostream &stream, const Status &value)
                    {
                        return stream << value.toString();
                    }
 
                private:
                    void setFromString(const std::string &value);
 
                    constexpr ValueType static verifyValue(const ValueType &value)
                    {
                        return value == ValueType::ok || value == ValueType::suboptimal || value == ValueType::error
                                       || value == ValueType::unknown
                                   ? value
                                   : throw std::invalid_argument{
                                         "Invalid value: Status{ "
                                         + std::to_string(static_cast<std::underlying_type<ValueType>::type>(value))
                                         + " }"
                                     };
                    }
 
                    ValueType m_value{ ValueType::unknown };
 
                    friend struct DataModel::Detail::Befriend<Status>;
                };

 
                // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                class ZIVID_CORE_EXPORT Value
                {
                public:
                    static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;

                    static constexpr const char *path{ "Temperature/Lens/Value" };

                    static constexpr const char *name{ "Value" };

                    static constexpr const char *description{
                        R"description(Lens temperature in degrees Celsius.)description"
                    };

                    using ValueType = double;

                    static constexpr Range<double> validRange()
                    {
                        return { std::numeric_limits<double>::lowest(), std::numeric_limits<double>::max() };
                    }

                    Value() = default;

                    explicit constexpr Value(double value)
                        : m_opt{ value }
                    {}

                    double value() const;

                    bool hasValue() const;

                    void reset();

                    std::string toString() const;

                    bool operator==(const Value &other) const
                    {
                        return m_opt == other.m_opt;
                    }

                    bool operator!=(const Value &other) const
                    {
                        return m_opt != other.m_opt;
                    }

                    bool operator<(const Value &other) const
                    {
                        return m_opt < other.m_opt;
                    }

                    bool operator>(const Value &other) const
                    {
                        return m_opt > other.m_opt;
                    }

                    bool operator<=(const Value &other) const
                    {
                        return m_opt <= other.m_opt;
                    }

                    bool operator>=(const Value &other) const
                    {
                        return m_opt >= other.m_opt;
                    }

                    friend std::ostream &operator<<(std::ostream &stream, const Value &value)
                    {
                        return stream << value.toString();
                    }
 
                private:
                    void setFromString(const std::string &value);
 
                    std::optional<double> m_opt;
 
                    friend struct DataModel::Detail::Befriend<Value>;
                };
 
                using Descendants =
                    std::tuple<CameraHealth::Temperature::Lens::Status, CameraHealth::Temperature::Lens::Value>;

                Lens();

#ifndef NO_DOC
                template<
                    typename... Args,
                    typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
                    typename std::enable_if<
                        Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::
                            value,
                        int>::type = 0>
#else
                template<typename... Args>
#endif
                explicit Lens(Args &&...args)
                {
                    using namespace Zivid::Detail::TypeTraits;
 
                    static_assert(
                        AllArgsDecayedAreUnique<Args...>::value,
                        "Found duplicate types among the arguments passed to Lens(...). "
                        "Types should be listed at most once.");
 
                    set(std::forward<Args>(args)...);
                }

#ifndef NO_DOC
                template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
#else
                template<typename... Args>
#endif
                void set(Args &&...args)
                {
                    using namespace Zivid::Detail::TypeTraits;
 
                    using AllArgsAreDescendantNodes =
                        AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                    static_assert(
                        AllArgsAreDescendantNodes::value, "All arguments passed to set(...) must be descendant nodes.");
 
                    static_assert(
                        AllArgsDecayedAreUnique<Args...>::value,
                        "Found duplicate types among the arguments passed to set(...). "
                        "Types should be listed at most once.");
 
                    Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
                }

#ifndef NO_DOC
                template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
#else
                template<typename... Args>
#endif
                Lens copyWith(Args &&...args) const
                {
                    using namespace Zivid::Detail::TypeTraits;
 
                    using AllArgsAreDescendantNodes =
                        AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                    static_assert(
                        AllArgsAreDescendantNodes::value,
                        "All arguments passed to copyWith(...) must be descendant nodes.");
 
                    static_assert(
                        AllArgsDecayedAreUnique<Args...>::value,
                        "Found duplicate types among the arguments passed to copyWith(...). "
                        "Types should be listed at most once.");
 
                    auto copy{ *this };
                    copy.set(std::forward<Args>(args)...);
                    return copy;
                }

                const Status &status() const
                {
                    return m_status;
                }

                Status &status()
                {
                    return m_status;
                }

                Lens &set(const Status &value)
                {
                    m_status = value;
                    return *this;
                }

                const Value &value() const
                {
                    return m_value;
                }

                Value &value()
                {
                    return m_value;
                }

                Lens &set(const Value &value)
                {
                    m_value = value;
                    return *this;
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, CameraHealth::Temperature::Lens::Status>::value, int>::
                        type = 0>
                const CameraHealth::Temperature::Lens::Status &get() const
                {
                    return m_status;
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, CameraHealth::Temperature::Lens::Value>::value, int>::type =
                        0>
                const CameraHealth::Temperature::Lens::Value &get() const
                {
                    return m_value;
                }
 
                template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                const CameraHealth::Temperature::Lens::Status &get() const
                {
                    return m_status;
                }
 
                template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
                const CameraHealth::Temperature::Lens::Value &get() const
                {
                    return m_value;
                }

                template<typename F>
                void forEach(const F &f) const
                {
                    f(m_status);
                    f(m_value);
                }

                template<typename F>
                void forEach(const F &f)
                {
                    f(m_status);
                    f(m_value);
                }

                bool operator==(const Lens &other) const;

                bool operator!=(const Lens &other) const;

                std::string toString() const;

                friend std::ostream &operator<<(std::ostream &stream, const Lens &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                void setFromString(const std::string &fullPath, const std::string &value);
 
                std::string getString(const std::string &fullPath) const;
 
                Status m_status;
                Value m_value;
 
                friend struct DataModel::Detail::Befriend<Lens>;
            };
 
            using Descendants = std::tuple<
                CameraHealth::Temperature::DMD,
                CameraHealth::Temperature::DMD::Status,
                CameraHealth::Temperature::DMD::Value,
                CameraHealth::Temperature::LED,
                CameraHealth::Temperature::LED::Status,
                CameraHealth::Temperature::LED::Value,
                CameraHealth::Temperature::Lens,
                CameraHealth::Temperature::Lens::Status,
                CameraHealth::Temperature::Lens::Value>;

            Temperature();

#ifndef NO_DOC
            template<
                typename... Args,
                typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
                typename std::enable_if<
                    Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::
                        value,
                    int>::type = 0>
#else
            template<typename... Args>
#endif
            explicit Temperature(Args &&...args)
            {
                using namespace Zivid::Detail::TypeTraits;
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to Temperature(...). "
                    "Types should be listed at most once.");
 
                set(std::forward<Args>(args)...);
            }

#ifndef NO_DOC
            template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
#else
            template<typename... Args>
#endif
            void set(Args &&...args)
            {
                using namespace Zivid::Detail::TypeTraits;
 
                using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                static_assert(
                    AllArgsAreDescendantNodes::value, "All arguments passed to set(...) must be descendant nodes.");
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to set(...). "
                    "Types should be listed at most once.");
 
                Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
            }

#ifndef NO_DOC
            template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
#else
            template<typename... Args>
#endif
            Temperature copyWith(Args &&...args) const
            {
                using namespace Zivid::Detail::TypeTraits;
 
                using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                static_assert(
                    AllArgsAreDescendantNodes::value,
                    "All arguments passed to copyWith(...) must be descendant nodes.");
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to copyWith(...). "
                    "Types should be listed at most once.");
 
                auto copy{ *this };
                copy.set(std::forward<Args>(args)...);
                return copy;
            }

            const DMD &dmd() const
            {
                return m_dmd;
            }

            DMD &dmd()
            {
                return m_dmd;
            }

            Temperature &set(const DMD &value)
            {
                m_dmd = value;
                return *this;
            }

            Temperature &set(const DMD::Status &value)
            {
                m_dmd.set(value);
                return *this;
            }

            Temperature &set(const DMD::Value &value)
            {
                m_dmd.set(value);
                return *this;
            }

            const LED &led() const
            {
                return m_led;
            }

            LED &led()
            {
                return m_led;
            }

            Temperature &set(const LED &value)
            {
                m_led = value;
                return *this;
            }

            Temperature &set(const LED::Status &value)
            {
                m_led.set(value);
                return *this;
            }

            Temperature &set(const LED::Value &value)
            {
                m_led.set(value);
                return *this;
            }

            const Lens &lens() const
            {
                return m_lens;
            }

            Lens &lens()
            {
                return m_lens;
            }

            Temperature &set(const Lens &value)
            {
                m_lens = value;
                return *this;
            }

            Temperature &set(const Lens::Status &value)
            {
                m_lens.set(value);
                return *this;
            }

            Temperature &set(const Lens::Value &value)
            {
                m_lens.set(value);
                return *this;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, CameraHealth::Temperature::DMD>::value, int>::type = 0>
            const CameraHealth::Temperature::DMD &get() const
            {
                return m_dmd;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, CameraHealth::Temperature::DMD::Status>::value, int>::type = 0>
            const CameraHealth::Temperature::DMD::Status &get() const
            {
                return m_dmd.get<CameraHealth::Temperature::DMD::Status>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, CameraHealth::Temperature::DMD::Value>::value, int>::type = 0>
            const CameraHealth::Temperature::DMD::Value &get() const
            {
                return m_dmd.get<CameraHealth::Temperature::DMD::Value>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, CameraHealth::Temperature::LED>::value, int>::type = 0>
            const CameraHealth::Temperature::LED &get() const
            {
                return m_led;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, CameraHealth::Temperature::LED::Status>::value, int>::type = 0>
            const CameraHealth::Temperature::LED::Status &get() const
            {
                return m_led.get<CameraHealth::Temperature::LED::Status>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, CameraHealth::Temperature::LED::Value>::value, int>::type = 0>
            const CameraHealth::Temperature::LED::Value &get() const
            {
                return m_led.get<CameraHealth::Temperature::LED::Value>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, CameraHealth::Temperature::Lens>::value, int>::type = 0>
            const CameraHealth::Temperature::Lens &get() const
            {
                return m_lens;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, CameraHealth::Temperature::Lens::Status>::value, int>::type = 0>
            const CameraHealth::Temperature::Lens::Status &get() const
            {
                return m_lens.get<CameraHealth::Temperature::Lens::Status>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, CameraHealth::Temperature::Lens::Value>::value, int>::type = 0>
            const CameraHealth::Temperature::Lens::Value &get() const
            {
                return m_lens.get<CameraHealth::Temperature::Lens::Value>();
            }
 
            template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
            const CameraHealth::Temperature::DMD &get() const
            {
                return m_dmd;
            }
 
            template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
            const CameraHealth::Temperature::LED &get() const
            {
                return m_led;
            }
 
            template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
            const CameraHealth::Temperature::Lens &get() const
            {
                return m_lens;
            }

            template<typename F>
            void forEach(const F &f) const
            {
                f(m_dmd);
                f(m_led);
                f(m_lens);
            }

            template<typename F>
            void forEach(const F &f)
            {
                f(m_dmd);
                f(m_led);
                f(m_lens);
            }

            bool operator==(const Temperature &other) const;

            bool operator!=(const Temperature &other) const;

            std::string toString() const;

            friend std::ostream &operator<<(std::ostream &stream, const Temperature &value)
            {
                return stream << value.toString();
            }
 
        private:
            void setFromString(const std::string &value);
 
            void setFromString(const std::string &fullPath, const std::string &value);
 
            std::string getString(const std::string &fullPath) const;
 
            DMD m_dmd;
            LED m_led;
            Lens m_lens;
 
            friend struct DataModel::Detail::Befriend<Temperature>;
        };
 
        using Descendants = std::tuple<
            CameraHealth::Fan,
            CameraHealth::Fan::Status,
            CameraHealth::Fan::Value,
            CameraHealth::InfieldVerification,
            CameraHealth::InfieldVerification::Status,
            CameraHealth::InfieldVerification::Value,
            CameraHealth::MaxTransferSpeed,
            CameraHealth::MaxTransferSpeed::Status,
            CameraHealth::MaxTransferSpeed::Value,
            CameraHealth::Memory,
            CameraHealth::Memory::Status,
            CameraHealth::Memory::Value,
            CameraHealth::Overall,
            CameraHealth::Temperature,
            CameraHealth::Temperature::DMD,
            CameraHealth::Temperature::DMD::Status,
            CameraHealth::Temperature::DMD::Value,
            CameraHealth::Temperature::LED,
            CameraHealth::Temperature::LED::Status,
            CameraHealth::Temperature::LED::Value,
            CameraHealth::Temperature::Lens,
            CameraHealth::Temperature::Lens::Status,
            CameraHealth::Temperature::Lens::Value>;

        CameraHealth();

        explicit CameraHealth(const std::string &fileName);

        [[nodiscard]] static CameraHealth fromSerialized(const std::string &value);

        std::string serialize() const;

#ifndef NO_DOC
        template<
            typename... Args,
            typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
            typename std::enable_if<
                Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::value,
                int>::type = 0>
#else
        template<typename... Args>
#endif
        explicit CameraHealth(Args &&...args)
        {
            using namespace Zivid::Detail::TypeTraits;
 
            static_assert(
                AllArgsDecayedAreUnique<Args...>::value,
                "Found duplicate types among the arguments passed to CameraHealth(...). "
                "Types should be listed at most once.");
 
            set(std::forward<Args>(args)...);
        }

#ifndef NO_DOC
        template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
#else
        template<typename... Args>
#endif
        void set(Args &&...args)
        {
            using namespace Zivid::Detail::TypeTraits;
 
            using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
            static_assert(
                AllArgsAreDescendantNodes::value, "All arguments passed to set(...) must be descendant nodes.");
 
            static_assert(
                AllArgsDecayedAreUnique<Args...>::value,
                "Found duplicate types among the arguments passed to set(...). "
                "Types should be listed at most once.");
 
            Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
        }

#ifndef NO_DOC
        template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
#else
        template<typename... Args>
#endif
        CameraHealth copyWith(Args &&...args) const
        {
            using namespace Zivid::Detail::TypeTraits;
 
            using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
            static_assert(
                AllArgsAreDescendantNodes::value, "All arguments passed to copyWith(...) must be descendant nodes.");
 
            static_assert(
                AllArgsDecayedAreUnique<Args...>::value,
                "Found duplicate types among the arguments passed to copyWith(...). "
                "Types should be listed at most once.");
 
            auto copy{ *this };
            copy.set(std::forward<Args>(args)...);
            return copy;
        }

        const Fan &fan() const
        {
            return m_fan;
        }

        Fan &fan()
        {
            return m_fan;
        }

        CameraHealth &set(const Fan &value)
        {
            m_fan = value;
            return *this;
        }

        CameraHealth &set(const Fan::Status &value)
        {
            m_fan.set(value);
            return *this;
        }

        CameraHealth &set(const Fan::Value &value)
        {
            m_fan.set(value);
            return *this;
        }

        const InfieldVerification &infieldVerification() const
        {
            return m_infieldVerification;
        }

        InfieldVerification &infieldVerification()
        {
            return m_infieldVerification;
        }

        CameraHealth &set(const InfieldVerification &value)
        {
            m_infieldVerification = value;
            return *this;
        }

        CameraHealth &set(const InfieldVerification::Status &value)
        {
            m_infieldVerification.set(value);
            return *this;
        }

        CameraHealth &set(const InfieldVerification::Value &value)
        {
            m_infieldVerification.set(value);
            return *this;
        }

        const MaxTransferSpeed &maxTransferSpeed() const
        {
            return m_maxTransferSpeed;
        }

        MaxTransferSpeed &maxTransferSpeed()
        {
            return m_maxTransferSpeed;
        }

        CameraHealth &set(const MaxTransferSpeed &value)
        {
            m_maxTransferSpeed = value;
            return *this;
        }

        CameraHealth &set(const MaxTransferSpeed::Status &value)
        {
            m_maxTransferSpeed.set(value);
            return *this;
        }

        CameraHealth &set(const MaxTransferSpeed::Value &value)
        {
            m_maxTransferSpeed.set(value);
            return *this;
        }

        const Memory &memory() const
        {
            return m_memory;
        }

        Memory &memory()
        {
            return m_memory;
        }

        CameraHealth &set(const Memory &value)
        {
            m_memory = value;
            return *this;
        }

        CameraHealth &set(const Memory::Status &value)
        {
            m_memory.set(value);
            return *this;
        }

        CameraHealth &set(const Memory::Value &value)
        {
            m_memory.set(value);
            return *this;
        }

        const Overall &overall() const
        {
            return m_overall;
        }

        Overall &overall()
        {
            return m_overall;
        }

        CameraHealth &set(const Overall &value)
        {
            m_overall = value;
            return *this;
        }

        const Temperature &temperature() const
        {
            return m_temperature;
        }

        Temperature &temperature()
        {
            return m_temperature;
        }

        CameraHealth &set(const Temperature &value)
        {
            m_temperature = value;
            return *this;
        }

        CameraHealth &set(const Temperature::DMD &value)
        {
            m_temperature.set(value);
            return *this;
        }

        CameraHealth &set(const Temperature::DMD::Status &value)
        {
            m_temperature.set(value);
            return *this;
        }

        CameraHealth &set(const Temperature::DMD::Value &value)
        {
            m_temperature.set(value);
            return *this;
        }

        CameraHealth &set(const Temperature::LED &value)
        {
            m_temperature.set(value);
            return *this;
        }

        CameraHealth &set(const Temperature::LED::Status &value)
        {
            m_temperature.set(value);
            return *this;
        }

        CameraHealth &set(const Temperature::LED::Value &value)
        {
            m_temperature.set(value);
            return *this;
        }

        CameraHealth &set(const Temperature::Lens &value)
        {
            m_temperature.set(value);
            return *this;
        }

        CameraHealth &set(const Temperature::Lens::Status &value)
        {
            m_temperature.set(value);
            return *this;
        }

        CameraHealth &set(const Temperature::Lens::Value &value)
        {
            m_temperature.set(value);
            return *this;
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, CameraHealth::Fan>::value, int>::type = 0>
        const CameraHealth::Fan &get() const
        {
            return m_fan;
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, CameraHealth::Fan::Status>::value, int>::type = 0>
        const CameraHealth::Fan::Status &get() const
        {
            return m_fan.get<CameraHealth::Fan::Status>();
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, CameraHealth::Fan::Value>::value, int>::type = 0>
        const CameraHealth::Fan::Value &get() const
        {
            return m_fan.get<CameraHealth::Fan::Value>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, CameraHealth::InfieldVerification>::value, int>::type = 0>
        const CameraHealth::InfieldVerification &get() const
        {
            return m_infieldVerification;
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, CameraHealth::InfieldVerification::Status>::value, int>::type = 0>
        const CameraHealth::InfieldVerification::Status &get() const
        {
            return m_infieldVerification.get<CameraHealth::InfieldVerification::Status>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, CameraHealth::InfieldVerification::Value>::value, int>::type = 0>
        const CameraHealth::InfieldVerification::Value &get() const
        {
            return m_infieldVerification.get<CameraHealth::InfieldVerification::Value>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, CameraHealth::MaxTransferSpeed>::value, int>::type = 0>
        const CameraHealth::MaxTransferSpeed &get() const
        {
            return m_maxTransferSpeed;
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, CameraHealth::MaxTransferSpeed::Status>::value, int>::type = 0>
        const CameraHealth::MaxTransferSpeed::Status &get() const
        {
            return m_maxTransferSpeed.get<CameraHealth::MaxTransferSpeed::Status>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, CameraHealth::MaxTransferSpeed::Value>::value, int>::type = 0>
        const CameraHealth::MaxTransferSpeed::Value &get() const
        {
            return m_maxTransferSpeed.get<CameraHealth::MaxTransferSpeed::Value>();
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, CameraHealth::Memory>::value, int>::type = 0>
        const CameraHealth::Memory &get() const
        {
            return m_memory;
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, CameraHealth::Memory::Status>::value, int>::type = 0>
        const CameraHealth::Memory::Status &get() const
        {
            return m_memory.get<CameraHealth::Memory::Status>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, CameraHealth::Memory::Value>::value, int>::type = 0>
        const CameraHealth::Memory::Value &get() const
        {
            return m_memory.get<CameraHealth::Memory::Value>();
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, CameraHealth::Overall>::value, int>::type = 0>
        const CameraHealth::Overall &get() const
        {
            return m_overall;
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, CameraHealth::Temperature>::value, int>::type = 0>
        const CameraHealth::Temperature &get() const
        {
            return m_temperature;
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, CameraHealth::Temperature::DMD>::value, int>::type = 0>
        const CameraHealth::Temperature::DMD &get() const
        {
            return m_temperature.get<CameraHealth::Temperature::DMD>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, CameraHealth::Temperature::DMD::Status>::value, int>::type = 0>
        const CameraHealth::Temperature::DMD::Status &get() const
        {
            return m_temperature.get<CameraHealth::Temperature::DMD::Status>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, CameraHealth::Temperature::DMD::Value>::value, int>::type = 0>
        const CameraHealth::Temperature::DMD::Value &get() const
        {
            return m_temperature.get<CameraHealth::Temperature::DMD::Value>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, CameraHealth::Temperature::LED>::value, int>::type = 0>
        const CameraHealth::Temperature::LED &get() const
        {
            return m_temperature.get<CameraHealth::Temperature::LED>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, CameraHealth::Temperature::LED::Status>::value, int>::type = 0>
        const CameraHealth::Temperature::LED::Status &get() const
        {
            return m_temperature.get<CameraHealth::Temperature::LED::Status>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, CameraHealth::Temperature::LED::Value>::value, int>::type = 0>
        const CameraHealth::Temperature::LED::Value &get() const
        {
            return m_temperature.get<CameraHealth::Temperature::LED::Value>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, CameraHealth::Temperature::Lens>::value, int>::type = 0>
        const CameraHealth::Temperature::Lens &get() const
        {
            return m_temperature.get<CameraHealth::Temperature::Lens>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, CameraHealth::Temperature::Lens::Status>::value, int>::type = 0>
        const CameraHealth::Temperature::Lens::Status &get() const
        {
            return m_temperature.get<CameraHealth::Temperature::Lens::Status>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, CameraHealth::Temperature::Lens::Value>::value, int>::type = 0>
        const CameraHealth::Temperature::Lens::Value &get() const
        {
            return m_temperature.get<CameraHealth::Temperature::Lens::Value>();
        }
 
        template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
        const CameraHealth::Fan &get() const
        {
            return m_fan;
        }
 
        template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
        const CameraHealth::InfieldVerification &get() const
        {
            return m_infieldVerification;
        }
 
        template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
        const CameraHealth::MaxTransferSpeed &get() const
        {
            return m_maxTransferSpeed;
        }
 
        template<size_t i, typename std::enable_if<i == 3, int>::type = 0>
        const CameraHealth::Memory &get() const
        {
            return m_memory;
        }
 
        template<size_t i, typename std::enable_if<i == 4, int>::type = 0>
        const CameraHealth::Overall &get() const
        {
            return m_overall;
        }
 
        template<size_t i, typename std::enable_if<i == 5, int>::type = 0>
        const CameraHealth::Temperature &get() const
        {
            return m_temperature;
        }

        template<typename F>
        void forEach(const F &f) const
        {
            f(m_fan);
            f(m_infieldVerification);
            f(m_maxTransferSpeed);
            f(m_memory);
            f(m_overall);
            f(m_temperature);
        }

        template<typename F>
        void forEach(const F &f)
        {
            f(m_fan);
            f(m_infieldVerification);
            f(m_maxTransferSpeed);
            f(m_memory);
            f(m_overall);
            f(m_temperature);
        }

        bool operator==(const CameraHealth &other) const;

        bool operator!=(const CameraHealth &other) const;

        std::string toString() const;

        friend std::ostream &operator<<(std::ostream &stream, const CameraHealth &value)
        {
            return stream << value.toString();
        }

        void save(const std::string &fileName) const;

        void load(const std::string &fileName);
 
    private:
        void setFromString(const std::string &value);
 
        void setFromString(const std::string &fullPath, const std::string &value);
 
        std::string getString(const std::string &fullPath) const;
 
        Fan m_fan;
        InfieldVerification m_infieldVerification;
        MaxTransferSpeed m_maxTransferSpeed;
        Memory m_memory;
        Overall m_overall;
        Temperature m_temperature;
 
        friend struct DataModel::Detail::Befriend<CameraHealth>;
    };
 
#ifndef NO_DOC
    template<>
    struct CameraHealth::Version<1>
    {
        using Type = CameraHealth;
    };
#endif
 
} // namespace Zivid
 
#ifndef NO_DOC
namespace Zivid::Detail
{
 
    ZIVID_CORE_EXPORT void save(const Zivid::CameraHealth &dataModel, std::ostream &ostream);
    ZIVID_CORE_EXPORT void load(Zivid::CameraHealth &dataModel, std::istream &istream);
 
} // namespace Zivid::Detail
#endif
 
#ifdef _MSC_VER
#    pragma warning(pop)
#endif
 
#ifndef NO_DOC
#    if !(defined(_MSC_VER) && (_MSC_VER <= 1900))
namespace std // NOLINT
{
 
    template<>
    struct tuple_size<Zivid::CameraHealth::Fan> : integral_constant<size_t, 2>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::CameraHealth::Fan>
    {
        static_assert(i < tuple_size<Zivid::CameraHealth::Fan>::value, "Index must be less than 2");
 
        using type // NOLINT
            = decltype(declval<Zivid::CameraHealth::Fan>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::CameraHealth::InfieldVerification> : integral_constant<size_t, 2>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::CameraHealth::InfieldVerification>
    {
        static_assert(i < tuple_size<Zivid::CameraHealth::InfieldVerification>::value, "Index must be less than 2");
 
        using type // NOLINT
            = decltype(declval<Zivid::CameraHealth::InfieldVerification>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::CameraHealth::MaxTransferSpeed> : integral_constant<size_t, 2>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::CameraHealth::MaxTransferSpeed>
    {
        static_assert(i < tuple_size<Zivid::CameraHealth::MaxTransferSpeed>::value, "Index must be less than 2");
 
        using type // NOLINT
            = decltype(declval<Zivid::CameraHealth::MaxTransferSpeed>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::CameraHealth::Memory> : integral_constant<size_t, 2>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::CameraHealth::Memory>
    {
        static_assert(i < tuple_size<Zivid::CameraHealth::Memory>::value, "Index must be less than 2");
 
        using type // NOLINT
            = decltype(declval<Zivid::CameraHealth::Memory>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::CameraHealth::Temperature> : integral_constant<size_t, 3>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::CameraHealth::Temperature>
    {
        static_assert(i < tuple_size<Zivid::CameraHealth::Temperature>::value, "Index must be less than 3");
 
        using type // NOLINT
            = decltype(declval<Zivid::CameraHealth::Temperature>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::CameraHealth::Temperature::DMD> : integral_constant<size_t, 2>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::CameraHealth::Temperature::DMD>
    {
        static_assert(i < tuple_size<Zivid::CameraHealth::Temperature::DMD>::value, "Index must be less than 2");
 
        using type // NOLINT
            = decltype(declval<Zivid::CameraHealth::Temperature::DMD>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::CameraHealth::Temperature::LED> : integral_constant<size_t, 2>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::CameraHealth::Temperature::LED>
    {
        static_assert(i < tuple_size<Zivid::CameraHealth::Temperature::LED>::value, "Index must be less than 2");
 
        using type // NOLINT
            = decltype(declval<Zivid::CameraHealth::Temperature::LED>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::CameraHealth::Temperature::Lens> : integral_constant<size_t, 2>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::CameraHealth::Temperature::Lens>
    {
        static_assert(i < tuple_size<Zivid::CameraHealth::Temperature::Lens>::value, "Index must be less than 2");
 
        using type // NOLINT
            = decltype(declval<Zivid::CameraHealth::Temperature::Lens>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::CameraHealth> : integral_constant<size_t, 6>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::CameraHealth>
    {
        static_assert(i < tuple_size<Zivid::CameraHealth>::value, "Index must be less than 6");
 
        using type // NOLINT
            = decltype(declval<Zivid::CameraHealth>().get<i>());
    };
 
} // namespace std
#    endif
#endif
 
// If we have access to the DataModel library, automatically include internal DataModel
// header. This header is necessary for serialization and deserialization.
#if defined(__has_include) && !defined(NO_DOC)
#    if __has_include("Zivid/CameraHealthInternal.h") && __has_include("Zivid/DataModelNodeMetaData.h")
#        include "Zivid/CameraHealthInternal.h"
#    endif
#endif