FrameInfo.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 FrameInfo
    {
    public:
        static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;

        static constexpr const char *path{ "" };

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

        static constexpr const char *description{ R"description(Various information for a frame)description" };
 
        static constexpr size_t version{ 8 };
 
#ifndef NO_DOC
        template<size_t>
        struct Version;
 
        using LatestVersion = Zivid::FrameInfo;
 
        // 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{ 'f', 'i', 'f' };
 
#endif

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

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

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

            static constexpr const char *description{ R"description(Diagnostic information for frame)description" };

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

                static constexpr const char *path{ "Diagnostics/PacketLoss" };

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

                static constexpr const char *description{ R"description(Is frame missing any data)description" };

                using ValueType = bool;
                static const PacketLoss yes; 
                static const PacketLoss no;  

                static std::set<bool> validValues()
                {
                    return { false, true };
                }

                PacketLoss() = default;

                explicit constexpr PacketLoss(bool value)
                    : m_value{ value }
                {}

                bool value() const;

                std::string toString() const;

                explicit operator bool() const
                {
                    return m_value;
                }

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

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

                friend std::ostream &operator<<(std::ostream &stream, const PacketLoss &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                bool m_value{ false };
 
                friend struct DataModel::Detail::Befriend<PacketLoss>;
            };
 
            using Descendants = std::tuple<FrameInfo::Diagnostics::PacketLoss>;

            Diagnostics();

#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 Diagnostics(Args &&...args)
            {
                using namespace Zivid::Detail::TypeTraits;
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to Diagnostics(...). "
                    "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
            Diagnostics 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 PacketLoss &packetLoss() const
            {
                return m_packetLoss;
            }

            PacketLoss &packetLoss()
            {
                return m_packetLoss;
            }

            Diagnostics &set(const PacketLoss &value)
            {
                m_packetLoss = value;
                return *this;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, FrameInfo::Diagnostics::PacketLoss>::value, int>::type = 0>
            const FrameInfo::Diagnostics::PacketLoss &get() const
            {
                return m_packetLoss;
            }
 
            template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
            const FrameInfo::Diagnostics::PacketLoss &get() const
            {
                return m_packetLoss;
            }

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

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

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

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

            std::string toString() const;

            friend std::ostream &operator<<(std::ostream &stream, const Diagnostics &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;
 
            PacketLoss m_packetLoss;
 
            friend struct DataModel::Detail::Befriend<Diagnostics>;
        };

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

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

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

            static constexpr const char *description{ R"description(Metrics related to this capture.)description" };

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

                static constexpr const char *path{ "Metrics/AcquisitionTime" };

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

                static constexpr const char *description{
                    R"description(Acquisition Time is the duration from the start of the capture to when the camera has acquired the
last image. After this time, the camera has finished its acquisition and you can move the robot,
or capture with another camera with overlapping field of view. Acquisition Time is equal to the
time it takes for the Camera::capture(settings) API function call to return.
)description"
                };

                using ValueType = std::chrono::microseconds;

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

                AcquisitionTime() = default;

                explicit constexpr AcquisitionTime(std::chrono::microseconds value)
                    : m_value{ value }
                {}

                std::chrono::microseconds value() const;

                std::string toString() const;

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

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

                bool operator<(const AcquisitionTime &other) const
                {
                    return m_value < other.m_value;
                }

                bool operator>(const AcquisitionTime &other) const
                {
                    return m_value > other.m_value;
                }

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

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

                friend std::ostream &operator<<(std::ostream &stream, const AcquisitionTime &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                std::chrono::microseconds m_value{ -1 };
 
                friend struct DataModel::Detail::Befriend<AcquisitionTime>;
            };

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

                static constexpr const char *path{ "Metrics/CaptureTime" };

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

                static constexpr const char *description{
                    R"description(Capture Time is the duration from the start of the capture to when all of the data transfer and
processing has completed. After this time the 3D point cloud and/or 2D color image is ready and
available on the GPU memory, and can be copied to the system memory (RAM).
)description"
                };

                using ValueType = std::chrono::microseconds;

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

                CaptureTime() = default;

                explicit constexpr CaptureTime(std::chrono::microseconds value)
                    : m_value{ value }
                {}

                std::chrono::microseconds value() const;

                std::string toString() const;

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

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

                bool operator<(const CaptureTime &other) const
                {
                    return m_value < other.m_value;
                }

                bool operator>(const CaptureTime &other) const
                {
                    return m_value > other.m_value;
                }

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

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

                friend std::ostream &operator<<(std::ostream &stream, const CaptureTime &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                std::chrono::microseconds m_value{ -1 };
 
                friend struct DataModel::Detail::Befriend<CaptureTime>;
            };

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

                static constexpr const char *path{ "Metrics/KernelComputeTime" };

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

                static constexpr const char *description{
                    R"description(Kernel Compute Time is the duration of the compute on the GPU. It is a subset of Capture Time. Kernel
Compute Time depends on the capture settings and the compute power of the GPU. Note that Kernel Compute
Time + Acquisition Time is not equal to Capture Time, as acquisition and processing operations can be
performed in parallel.
)description"
                };

                using ValueType = std::chrono::microseconds;

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

                KernelComputeTime() = default;

                explicit constexpr KernelComputeTime(std::chrono::microseconds value)
                    : m_value{ value }
                {}

                std::chrono::microseconds value() const;

                std::string toString() const;

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

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

                bool operator<(const KernelComputeTime &other) const
                {
                    return m_value < other.m_value;
                }

                bool operator>(const KernelComputeTime &other) const
                {
                    return m_value > other.m_value;
                }

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

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

                friend std::ostream &operator<<(std::ostream &stream, const KernelComputeTime &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                std::chrono::microseconds m_value{ -1 };
 
                friend struct DataModel::Detail::Befriend<KernelComputeTime>;
            };

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

                static constexpr const char *path{ "Metrics/ReprocessingTime" };

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

                static constexpr const char *description{
                    R"description(Reprocessing re-runs the entire processing pipeline (including filters, color balance etc.) on a
previously acquired frame. Reprocessing is available in Zivid Studio for captures with Diagnostics Mode
enabled. The ReprocessingTime field is only set if this frame was reprocessed after it was initially
captured, otherwise it will be unset.
 
Reprocessing Time is the duration from the start of the reprocessing action and until all processing
of the new frame has finished. After this time the 3D point cloud and/or 2D color image is ready and
available on the GPU memory and can be copied to the system memory (RAM).
 
Reprocessing Time depends on the processing settings that are enabled, which capture engine that was
used, the pixel sampling setting and the number of acquisitions used. Reprocessing Time also depends on
the compute power of the compute device.
 
Note that for a frame that has been re-processed, the Acquisition Time and Capture Time refers to
the originally captured frame. Only Reprocessing Time is updated in a reprocessed frame.
)description"
                };

                using ValueType = std::chrono::microseconds;

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

                ReprocessingTime() = default;

                explicit constexpr ReprocessingTime(std::chrono::microseconds value)
                    : m_opt{ value }
                {}

                std::chrono::microseconds value() const;

                bool hasValue() const;

                void reset();

                std::string toString() const;

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

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

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

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

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

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

                friend std::ostream &operator<<(std::ostream &stream, const ReprocessingTime &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                std::optional<std::chrono::microseconds> m_opt;
 
                friend struct DataModel::Detail::Befriend<ReprocessingTime>;
            };

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

                static constexpr const char *path{ "Metrics/ThrottlingTime" };

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

                static constexpr const char *description{
                    R"description(Throttling Time is the duration that the capture was paused due to thermal or other constraints on the
camera's components while it was capturing this frame. This duration is part of the overall Acquisition
Time. If the camera throttled during a capture, it will result in a longer Acquisition Time.
 
Whether or not the camera will throttle depends on the ambient temperature, the capture settings, and
the how frequently the camera is capturing.
)description"
                };

                using ValueType = std::chrono::microseconds;

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

                ThrottlingTime() = default;

                explicit constexpr ThrottlingTime(std::chrono::microseconds value)
                    : m_value{ value }
                {}

                std::chrono::microseconds value() const;

                std::string toString() const;

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

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

                bool operator<(const ThrottlingTime &other) const
                {
                    return m_value < other.m_value;
                }

                bool operator>(const ThrottlingTime &other) const
                {
                    return m_value > other.m_value;
                }

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

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

                friend std::ostream &operator<<(std::ostream &stream, const ThrottlingTime &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                std::chrono::microseconds m_value{ -1 };
 
                friend struct DataModel::Detail::Befriend<ThrottlingTime>;
            };
 
            using Descendants = std::tuple<
                FrameInfo::Metrics::AcquisitionTime,
                FrameInfo::Metrics::CaptureTime,
                FrameInfo::Metrics::KernelComputeTime,
                FrameInfo::Metrics::ReprocessingTime,
                FrameInfo::Metrics::ThrottlingTime>;

            Metrics();

#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 Metrics(Args &&...args)
            {
                using namespace Zivid::Detail::TypeTraits;
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to Metrics(...). "
                    "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
            Metrics 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 AcquisitionTime &acquisitionTime() const
            {
                return m_acquisitionTime;
            }

            AcquisitionTime &acquisitionTime()
            {
                return m_acquisitionTime;
            }

            Metrics &set(const AcquisitionTime &value)
            {
                m_acquisitionTime = value;
                return *this;
            }

            const CaptureTime &captureTime() const
            {
                return m_captureTime;
            }

            CaptureTime &captureTime()
            {
                return m_captureTime;
            }

            Metrics &set(const CaptureTime &value)
            {
                m_captureTime = value;
                return *this;
            }

            const KernelComputeTime &kernelComputeTime() const
            {
                return m_kernelComputeTime;
            }

            KernelComputeTime &kernelComputeTime()
            {
                return m_kernelComputeTime;
            }

            Metrics &set(const KernelComputeTime &value)
            {
                m_kernelComputeTime = value;
                return *this;
            }

            const ReprocessingTime &reprocessingTime() const
            {
                return m_reprocessingTime;
            }

            ReprocessingTime &reprocessingTime()
            {
                return m_reprocessingTime;
            }

            Metrics &set(const ReprocessingTime &value)
            {
                m_reprocessingTime = value;
                return *this;
            }

            const ThrottlingTime &throttlingTime() const
            {
                return m_throttlingTime;
            }

            ThrottlingTime &throttlingTime()
            {
                return m_throttlingTime;
            }

            Metrics &set(const ThrottlingTime &value)
            {
                m_throttlingTime = value;
                return *this;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, FrameInfo::Metrics::AcquisitionTime>::value, int>::type = 0>
            const FrameInfo::Metrics::AcquisitionTime &get() const
            {
                return m_acquisitionTime;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, FrameInfo::Metrics::CaptureTime>::value, int>::type = 0>
            const FrameInfo::Metrics::CaptureTime &get() const
            {
                return m_captureTime;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, FrameInfo::Metrics::KernelComputeTime>::value, int>::type = 0>
            const FrameInfo::Metrics::KernelComputeTime &get() const
            {
                return m_kernelComputeTime;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, FrameInfo::Metrics::ReprocessingTime>::value, int>::type = 0>
            const FrameInfo::Metrics::ReprocessingTime &get() const
            {
                return m_reprocessingTime;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, FrameInfo::Metrics::ThrottlingTime>::value, int>::type = 0>
            const FrameInfo::Metrics::ThrottlingTime &get() const
            {
                return m_throttlingTime;
            }
 
            template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
            const FrameInfo::Metrics::AcquisitionTime &get() const
            {
                return m_acquisitionTime;
            }
 
            template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
            const FrameInfo::Metrics::CaptureTime &get() const
            {
                return m_captureTime;
            }
 
            template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
            const FrameInfo::Metrics::KernelComputeTime &get() const
            {
                return m_kernelComputeTime;
            }
 
            template<size_t i, typename std::enable_if<i == 3, int>::type = 0>
            const FrameInfo::Metrics::ReprocessingTime &get() const
            {
                return m_reprocessingTime;
            }
 
            template<size_t i, typename std::enable_if<i == 4, int>::type = 0>
            const FrameInfo::Metrics::ThrottlingTime &get() const
            {
                return m_throttlingTime;
            }

            template<typename F>
            void forEach(const F &f) const
            {
                f(m_acquisitionTime);
                f(m_captureTime);
                f(m_kernelComputeTime);
                f(m_reprocessingTime);
                f(m_throttlingTime);
            }

            template<typename F>
            void forEach(const F &f)
            {
                f(m_acquisitionTime);
                f(m_captureTime);
                f(m_kernelComputeTime);
                f(m_reprocessingTime);
                f(m_throttlingTime);
            }

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

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

            std::string toString() const;

            friend std::ostream &operator<<(std::ostream &stream, const Metrics &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;
 
            AcquisitionTime m_acquisitionTime;
            CaptureTime m_captureTime;
            KernelComputeTime m_kernelComputeTime;
            ReprocessingTime m_reprocessingTime;
            ThrottlingTime m_throttlingTime;
 
            friend struct DataModel::Detail::Befriend<Metrics>;
        };

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

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

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

            static constexpr const char *description{
                R"description(The version information for installed software at the time of image capture)description"
            };

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

                static constexpr const char *path{ "SoftwareVersion/Core" };

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

                static constexpr const char *description{ R"description(Core version)description" };

                using ValueType = std::string;

                static constexpr Range<ValueType::size_type> validSize()
                {
                    return { 0, std::numeric_limits<ValueType::size_type>::max() };
                }

                Core() = default;

                explicit Core(std::string value)
                    : m_value{ std::move(value) }
                {}

                const std::string &value() const;

                std::string toString() const;

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

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

                bool operator<(const Core &other) const
                {
                    return m_value < other.m_value;
                }

                bool operator>(const Core &other) const
                {
                    return m_value > other.m_value;
                }

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

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

                friend std::ostream &operator<<(std::ostream &stream, const Core &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                std::string m_value{ "No-version" };
 
                friend struct DataModel::Detail::Befriend<Core>;
            };
 
            using Descendants = std::tuple<FrameInfo::SoftwareVersion::Core>;

            SoftwareVersion();

#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 SoftwareVersion(Args &&...args)
            {
                using namespace Zivid::Detail::TypeTraits;
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to SoftwareVersion(...). "
                    "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
            SoftwareVersion 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 Core &core() const
            {
                return m_core;
            }

            Core &core()
            {
                return m_core;
            }

            SoftwareVersion &set(const Core &value)
            {
                m_core = value;
                return *this;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion::Core>::value, int>::type = 0>
            const FrameInfo::SoftwareVersion::Core &get() const
            {
                return m_core;
            }
 
            template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
            const FrameInfo::SoftwareVersion::Core &get() const
            {
                return m_core;
            }

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

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

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

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

            std::string toString() const;

            friend std::ostream &operator<<(std::ostream &stream, const SoftwareVersion &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;
 
            Core m_core;
 
            friend struct DataModel::Detail::Befriend<SoftwareVersion>;
        };

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

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

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

            static constexpr const char *description{
                R"description(Information about the system that captured this frame)description"
            };

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

                static constexpr const char *path{ "SystemInfo/CPU" };

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

                static constexpr const char *description{ R"description(CPU)description" };

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

                    static constexpr const char *path{ "SystemInfo/CPU/Model" };

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

                    static constexpr const char *description{ R"description(CPU model)description" };

                    using ValueType = std::string;

                    static constexpr Range<ValueType::size_type> validSize()
                    {
                        return { 0, std::numeric_limits<ValueType::size_type>::max() };
                    }

                    Model() = default;

                    explicit Model(std::string value)
                        : m_value{ std::move(value) }
                    {}

                    const std::string &value() const;

                    std::string toString() const;

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

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

                    bool operator<(const Model &other) const
                    {
                        return m_value < other.m_value;
                    }

                    bool operator>(const Model &other) const
                    {
                        return m_value > other.m_value;
                    }

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

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

                    friend std::ostream &operator<<(std::ostream &stream, const Model &value)
                    {
                        return stream << value.toString();
                    }
 
                private:
                    void setFromString(const std::string &value);
 
                    std::string m_value{};
 
                    friend struct DataModel::Detail::Befriend<Model>;
                };
 
                using Descendants = std::tuple<FrameInfo::SystemInfo::CPU::Model>;

                CPU();

#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 CPU(Args &&...args)
                {
                    using namespace Zivid::Detail::TypeTraits;
 
                    static_assert(
                        AllArgsDecayedAreUnique<Args...>::value,
                        "Found duplicate types among the arguments passed to CPU(...). "
                        "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
                CPU 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 Model &model() const
                {
                    return m_model;
                }

                Model &model()
                {
                    return m_model;
                }

                CPU &set(const Model &value)
                {
                    m_model = value;
                    return *this;
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, FrameInfo::SystemInfo::CPU::Model>::value, int>::type = 0>
                const FrameInfo::SystemInfo::CPU::Model &get() const
                {
                    return m_model;
                }
 
                template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                const FrameInfo::SystemInfo::CPU::Model &get() const
                {
                    return m_model;
                }

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

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

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

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

                std::string toString() const;

                friend std::ostream &operator<<(std::ostream &stream, const CPU &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;
 
                Model m_model;
 
                friend struct DataModel::Detail::Befriend<CPU>;
            };

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

                static constexpr const char *path{ "SystemInfo/ComputeDevice" };

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

                static constexpr const char *description{ R"description(Compute device)description" };

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

                    static constexpr const char *path{ "SystemInfo/ComputeDevice/Model" };

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

                    static constexpr const char *description{ R"description(Compute device model)description" };

                    using ValueType = std::string;

                    static constexpr Range<ValueType::size_type> validSize()
                    {
                        return { 0, std::numeric_limits<ValueType::size_type>::max() };
                    }

                    Model() = default;

                    explicit Model(std::string value)
                        : m_value{ std::move(value) }
                    {}

                    const std::string &value() const;

                    std::string toString() const;

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

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

                    bool operator<(const Model &other) const
                    {
                        return m_value < other.m_value;
                    }

                    bool operator>(const Model &other) const
                    {
                        return m_value > other.m_value;
                    }

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

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

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

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

                    static constexpr const char *path{ "SystemInfo/ComputeDevice/Vendor" };

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

                    static constexpr const char *description{ R"description(Compute device vendor)description" };

                    using ValueType = std::string;

                    static constexpr Range<ValueType::size_type> validSize()
                    {
                        return { 0, std::numeric_limits<ValueType::size_type>::max() };
                    }

                    Vendor() = default;

                    explicit Vendor(std::string value)
                        : m_value{ std::move(value) }
                    {}

                    const std::string &value() const;

                    std::string toString() const;

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

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

                    bool operator<(const Vendor &other) const
                    {
                        return m_value < other.m_value;
                    }

                    bool operator>(const Vendor &other) const
                    {
                        return m_value > other.m_value;
                    }

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

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

                    friend std::ostream &operator<<(std::ostream &stream, const Vendor &value)
                    {
                        return stream << value.toString();
                    }
 
                private:
                    void setFromString(const std::string &value);
 
                    std::string m_value{};
 
                    friend struct DataModel::Detail::Befriend<Vendor>;
                };
 
                using Descendants = std::
                    tuple<FrameInfo::SystemInfo::ComputeDevice::Model, FrameInfo::SystemInfo::ComputeDevice::Vendor>;

                ComputeDevice();

#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 ComputeDevice(Args &&...args)
                {
                    using namespace Zivid::Detail::TypeTraits;
 
                    static_assert(
                        AllArgsDecayedAreUnique<Args...>::value,
                        "Found duplicate types among the arguments passed to ComputeDevice(...). "
                        "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
                ComputeDevice 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 Model &model() const
                {
                    return m_model;
                }

                Model &model()
                {
                    return m_model;
                }

                ComputeDevice &set(const Model &value)
                {
                    m_model = value;
                    return *this;
                }

                const Vendor &vendor() const
                {
                    return m_vendor;
                }

                Vendor &vendor()
                {
                    return m_vendor;
                }

                ComputeDevice &set(const Vendor &value)
                {
                    m_vendor = value;
                    return *this;
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, FrameInfo::SystemInfo::ComputeDevice::Model>::value, int>::
                        type = 0>
                const FrameInfo::SystemInfo::ComputeDevice::Model &get() const
                {
                    return m_model;
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, FrameInfo::SystemInfo::ComputeDevice::Vendor>::value, int>::
                        type = 0>
                const FrameInfo::SystemInfo::ComputeDevice::Vendor &get() const
                {
                    return m_vendor;
                }
 
                template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                const FrameInfo::SystemInfo::ComputeDevice::Model &get() const
                {
                    return m_model;
                }
 
                template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
                const FrameInfo::SystemInfo::ComputeDevice::Vendor &get() const
                {
                    return m_vendor;
                }

                template<typename F>
                void forEach(const F &f) const
                {
                    f(m_model);
                    f(m_vendor);
                }

                template<typename F>
                void forEach(const F &f)
                {
                    f(m_model);
                    f(m_vendor);
                }

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

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

                std::string toString() const;

                friend std::ostream &operator<<(std::ostream &stream, const ComputeDevice &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;
 
                Model m_model;
                Vendor m_vendor;
 
                friend struct DataModel::Detail::Befriend<ComputeDevice>;
            };

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

                static constexpr const char *path{ "SystemInfo/OperatingSystem" };

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

                static constexpr const char *description{ R"description(Operating system)description" };

                using ValueType = std::string;

                static constexpr Range<ValueType::size_type> validSize()
                {
                    return { 0, std::numeric_limits<ValueType::size_type>::max() };
                }

                OperatingSystem() = default;

                explicit OperatingSystem(std::string value)
                    : m_value{ std::move(value) }
                {}

                const std::string &value() const;

                std::string toString() const;

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

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

                bool operator<(const OperatingSystem &other) const
                {
                    return m_value < other.m_value;
                }

                bool operator>(const OperatingSystem &other) const
                {
                    return m_value > other.m_value;
                }

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

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

                friend std::ostream &operator<<(std::ostream &stream, const OperatingSystem &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                std::string m_value{};
 
                friend struct DataModel::Detail::Befriend<OperatingSystem>;
            };
 
            using Descendants = std::tuple<
                FrameInfo::SystemInfo::CPU,
                FrameInfo::SystemInfo::CPU::Model,
                FrameInfo::SystemInfo::ComputeDevice,
                FrameInfo::SystemInfo::ComputeDevice::Model,
                FrameInfo::SystemInfo::ComputeDevice::Vendor,
                FrameInfo::SystemInfo::OperatingSystem>;

            SystemInfo();

#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 SystemInfo(Args &&...args)
            {
                using namespace Zivid::Detail::TypeTraits;
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to SystemInfo(...). "
                    "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
            SystemInfo 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 CPU &cpu() const
            {
                return m_cpu;
            }

            CPU &cpu()
            {
                return m_cpu;
            }

            SystemInfo &set(const CPU &value)
            {
                m_cpu = value;
                return *this;
            }

            SystemInfo &set(const CPU::Model &value)
            {
                m_cpu.set(value);
                return *this;
            }

            const ComputeDevice &computeDevice() const
            {
                return m_computeDevice;
            }

            ComputeDevice &computeDevice()
            {
                return m_computeDevice;
            }

            SystemInfo &set(const ComputeDevice &value)
            {
                m_computeDevice = value;
                return *this;
            }

            SystemInfo &set(const ComputeDevice::Model &value)
            {
                m_computeDevice.set(value);
                return *this;
            }

            SystemInfo &set(const ComputeDevice::Vendor &value)
            {
                m_computeDevice.set(value);
                return *this;
            }

            const OperatingSystem &operatingSystem() const
            {
                return m_operatingSystem;
            }

            OperatingSystem &operatingSystem()
            {
                return m_operatingSystem;
            }

            SystemInfo &set(const OperatingSystem &value)
            {
                m_operatingSystem = value;
                return *this;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, FrameInfo::SystemInfo::CPU>::value, int>::type = 0>
            const FrameInfo::SystemInfo::CPU &get() const
            {
                return m_cpu;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, FrameInfo::SystemInfo::CPU::Model>::value, int>::type = 0>
            const FrameInfo::SystemInfo::CPU::Model &get() const
            {
                return m_cpu.get<FrameInfo::SystemInfo::CPU::Model>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, FrameInfo::SystemInfo::ComputeDevice>::value, int>::type = 0>
            const FrameInfo::SystemInfo::ComputeDevice &get() const
            {
                return m_computeDevice;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, FrameInfo::SystemInfo::ComputeDevice::Model>::value, int>::
                    type = 0>
            const FrameInfo::SystemInfo::ComputeDevice::Model &get() const
            {
                return m_computeDevice.get<FrameInfo::SystemInfo::ComputeDevice::Model>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, FrameInfo::SystemInfo::ComputeDevice::Vendor>::value, int>::
                    type = 0>
            const FrameInfo::SystemInfo::ComputeDevice::Vendor &get() const
            {
                return m_computeDevice.get<FrameInfo::SystemInfo::ComputeDevice::Vendor>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, FrameInfo::SystemInfo::OperatingSystem>::value, int>::type = 0>
            const FrameInfo::SystemInfo::OperatingSystem &get() const
            {
                return m_operatingSystem;
            }
 
            template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
            const FrameInfo::SystemInfo::CPU &get() const
            {
                return m_cpu;
            }
 
            template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
            const FrameInfo::SystemInfo::ComputeDevice &get() const
            {
                return m_computeDevice;
            }
 
            template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
            const FrameInfo::SystemInfo::OperatingSystem &get() const
            {
                return m_operatingSystem;
            }

            template<typename F>
            void forEach(const F &f) const
            {
                f(m_cpu);
                f(m_computeDevice);
                f(m_operatingSystem);
            }

            template<typename F>
            void forEach(const F &f)
            {
                f(m_cpu);
                f(m_computeDevice);
                f(m_operatingSystem);
            }

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

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

            std::string toString() const;

            friend std::ostream &operator<<(std::ostream &stream, const SystemInfo &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;
 
            CPU m_cpu;
            ComputeDevice m_computeDevice;
            OperatingSystem m_operatingSystem;
 
            friend struct DataModel::Detail::Befriend<SystemInfo>;
        };

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

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

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

            static constexpr const char *description{ R"description(The time of frame capture)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() };
            }

            TimeStamp() = default;

            explicit constexpr TimeStamp(std::chrono::system_clock::time_point value)
                : m_value{ value }
            {}

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

            std::string toString() const;

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

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

            bool operator<(const TimeStamp &other) const
            {
                return m_value < other.m_value;
            }

            bool operator>(const TimeStamp &other) const
            {
                return m_value > other.m_value;
            }

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

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

            friend std::ostream &operator<<(std::ostream &stream, const TimeStamp &value)
            {
                return stream << value.toString();
            }
 
        private:
            void setFromString(const std::string &value);
 
            std::chrono::system_clock::time_point m_value{};
 
            friend struct DataModel::Detail::Befriend<TimeStamp>;
        };
 
        using Descendants = std::tuple<
            FrameInfo::Diagnostics,
            FrameInfo::Diagnostics::PacketLoss,
            FrameInfo::Metrics,
            FrameInfo::Metrics::AcquisitionTime,
            FrameInfo::Metrics::CaptureTime,
            FrameInfo::Metrics::KernelComputeTime,
            FrameInfo::Metrics::ReprocessingTime,
            FrameInfo::Metrics::ThrottlingTime,
            FrameInfo::SoftwareVersion,
            FrameInfo::SoftwareVersion::Core,
            FrameInfo::SystemInfo,
            FrameInfo::SystemInfo::CPU,
            FrameInfo::SystemInfo::CPU::Model,
            FrameInfo::SystemInfo::ComputeDevice,
            FrameInfo::SystemInfo::ComputeDevice::Model,
            FrameInfo::SystemInfo::ComputeDevice::Vendor,
            FrameInfo::SystemInfo::OperatingSystem,
            FrameInfo::TimeStamp>;

        FrameInfo();

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

        [[nodiscard]] static FrameInfo 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 FrameInfo(Args &&...args)
        {
            using namespace Zivid::Detail::TypeTraits;
 
            static_assert(
                AllArgsDecayedAreUnique<Args...>::value,
                "Found duplicate types among the arguments passed to FrameInfo(...). "
                "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
        FrameInfo 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 Diagnostics &diagnostics() const
        {
            return m_diagnostics;
        }

        Diagnostics &diagnostics()
        {
            return m_diagnostics;
        }

        FrameInfo &set(const Diagnostics &value)
        {
            m_diagnostics = value;
            return *this;
        }

        FrameInfo &set(const Diagnostics::PacketLoss &value)
        {
            m_diagnostics.set(value);
            return *this;
        }

        const Metrics &metrics() const
        {
            return m_metrics;
        }

        Metrics &metrics()
        {
            return m_metrics;
        }

        FrameInfo &set(const Metrics &value)
        {
            m_metrics = value;
            return *this;
        }

        FrameInfo &set(const Metrics::AcquisitionTime &value)
        {
            m_metrics.set(value);
            return *this;
        }

        FrameInfo &set(const Metrics::CaptureTime &value)
        {
            m_metrics.set(value);
            return *this;
        }

        FrameInfo &set(const Metrics::KernelComputeTime &value)
        {
            m_metrics.set(value);
            return *this;
        }

        FrameInfo &set(const Metrics::ReprocessingTime &value)
        {
            m_metrics.set(value);
            return *this;
        }

        FrameInfo &set(const Metrics::ThrottlingTime &value)
        {
            m_metrics.set(value);
            return *this;
        }

        const SoftwareVersion &softwareVersion() const
        {
            return m_softwareVersion;
        }

        SoftwareVersion &softwareVersion()
        {
            return m_softwareVersion;
        }

        FrameInfo &set(const SoftwareVersion &value)
        {
            m_softwareVersion = value;
            return *this;
        }

        FrameInfo &set(const SoftwareVersion::Core &value)
        {
            m_softwareVersion.set(value);
            return *this;
        }

        const SystemInfo &systemInfo() const
        {
            return m_systemInfo;
        }

        SystemInfo &systemInfo()
        {
            return m_systemInfo;
        }

        FrameInfo &set(const SystemInfo &value)
        {
            m_systemInfo = value;
            return *this;
        }

        FrameInfo &set(const SystemInfo::CPU &value)
        {
            m_systemInfo.set(value);
            return *this;
        }

        FrameInfo &set(const SystemInfo::CPU::Model &value)
        {
            m_systemInfo.set(value);
            return *this;
        }

        FrameInfo &set(const SystemInfo::ComputeDevice &value)
        {
            m_systemInfo.set(value);
            return *this;
        }

        FrameInfo &set(const SystemInfo::ComputeDevice::Model &value)
        {
            m_systemInfo.set(value);
            return *this;
        }

        FrameInfo &set(const SystemInfo::ComputeDevice::Vendor &value)
        {
            m_systemInfo.set(value);
            return *this;
        }

        FrameInfo &set(const SystemInfo::OperatingSystem &value)
        {
            m_systemInfo.set(value);
            return *this;
        }

        const TimeStamp &timeStamp() const
        {
            return m_timeStamp;
        }

        TimeStamp &timeStamp()
        {
            return m_timeStamp;
        }

        FrameInfo &set(const TimeStamp &value)
        {
            m_timeStamp = value;
            return *this;
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, FrameInfo::Diagnostics>::value, int>::type = 0>
        const FrameInfo::Diagnostics &get() const
        {
            return m_diagnostics;
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, FrameInfo::Diagnostics::PacketLoss>::value, int>::type = 0>
        const FrameInfo::Diagnostics::PacketLoss &get() const
        {
            return m_diagnostics.get<FrameInfo::Diagnostics::PacketLoss>();
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, FrameInfo::Metrics>::value, int>::type = 0>
        const FrameInfo::Metrics &get() const
        {
            return m_metrics;
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, FrameInfo::Metrics::AcquisitionTime>::value, int>::type = 0>
        const FrameInfo::Metrics::AcquisitionTime &get() const
        {
            return m_metrics.get<FrameInfo::Metrics::AcquisitionTime>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, FrameInfo::Metrics::CaptureTime>::value, int>::type = 0>
        const FrameInfo::Metrics::CaptureTime &get() const
        {
            return m_metrics.get<FrameInfo::Metrics::CaptureTime>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, FrameInfo::Metrics::KernelComputeTime>::value, int>::type = 0>
        const FrameInfo::Metrics::KernelComputeTime &get() const
        {
            return m_metrics.get<FrameInfo::Metrics::KernelComputeTime>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, FrameInfo::Metrics::ReprocessingTime>::value, int>::type = 0>
        const FrameInfo::Metrics::ReprocessingTime &get() const
        {
            return m_metrics.get<FrameInfo::Metrics::ReprocessingTime>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, FrameInfo::Metrics::ThrottlingTime>::value, int>::type = 0>
        const FrameInfo::Metrics::ThrottlingTime &get() const
        {
            return m_metrics.get<FrameInfo::Metrics::ThrottlingTime>();
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion>::value, int>::type = 0>
        const FrameInfo::SoftwareVersion &get() const
        {
            return m_softwareVersion;
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion::Core>::value, int>::type = 0>
        const FrameInfo::SoftwareVersion::Core &get() const
        {
            return m_softwareVersion.get<FrameInfo::SoftwareVersion::Core>();
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, FrameInfo::SystemInfo>::value, int>::type = 0>
        const FrameInfo::SystemInfo &get() const
        {
            return m_systemInfo;
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, FrameInfo::SystemInfo::CPU>::value, int>::type = 0>
        const FrameInfo::SystemInfo::CPU &get() const
        {
            return m_systemInfo.get<FrameInfo::SystemInfo::CPU>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, FrameInfo::SystemInfo::CPU::Model>::value, int>::type = 0>
        const FrameInfo::SystemInfo::CPU::Model &get() const
        {
            return m_systemInfo.get<FrameInfo::SystemInfo::CPU::Model>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, FrameInfo::SystemInfo::ComputeDevice>::value, int>::type = 0>
        const FrameInfo::SystemInfo::ComputeDevice &get() const
        {
            return m_systemInfo.get<FrameInfo::SystemInfo::ComputeDevice>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, FrameInfo::SystemInfo::ComputeDevice::Model>::value, int>::type = 0>
        const FrameInfo::SystemInfo::ComputeDevice::Model &get() const
        {
            return m_systemInfo.get<FrameInfo::SystemInfo::ComputeDevice::Model>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, FrameInfo::SystemInfo::ComputeDevice::Vendor>::value, int>::type =
                0>
        const FrameInfo::SystemInfo::ComputeDevice::Vendor &get() const
        {
            return m_systemInfo.get<FrameInfo::SystemInfo::ComputeDevice::Vendor>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, FrameInfo::SystemInfo::OperatingSystem>::value, int>::type = 0>
        const FrameInfo::SystemInfo::OperatingSystem &get() const
        {
            return m_systemInfo.get<FrameInfo::SystemInfo::OperatingSystem>();
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, FrameInfo::TimeStamp>::value, int>::type = 0>
        const FrameInfo::TimeStamp &get() const
        {
            return m_timeStamp;
        }
 
        template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
        const FrameInfo::Diagnostics &get() const
        {
            return m_diagnostics;
        }
 
        template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
        const FrameInfo::Metrics &get() const
        {
            return m_metrics;
        }
 
        template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
        const FrameInfo::SoftwareVersion &get() const
        {
            return m_softwareVersion;
        }
 
        template<size_t i, typename std::enable_if<i == 3, int>::type = 0>
        const FrameInfo::SystemInfo &get() const
        {
            return m_systemInfo;
        }
 
        template<size_t i, typename std::enable_if<i == 4, int>::type = 0>
        const FrameInfo::TimeStamp &get() const
        {
            return m_timeStamp;
        }

        template<typename F>
        void forEach(const F &f) const
        {
            f(m_diagnostics);
            f(m_metrics);
            f(m_softwareVersion);
            f(m_systemInfo);
            f(m_timeStamp);
        }

        template<typename F>
        void forEach(const F &f)
        {
            f(m_diagnostics);
            f(m_metrics);
            f(m_softwareVersion);
            f(m_systemInfo);
            f(m_timeStamp);
        }

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

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

        std::string toString() const;

        friend std::ostream &operator<<(std::ostream &stream, const FrameInfo &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;
 
        Diagnostics m_diagnostics;
        Metrics m_metrics;
        SoftwareVersion m_softwareVersion;
        SystemInfo m_systemInfo;
        TimeStamp m_timeStamp;
 
        friend struct DataModel::Detail::Befriend<FrameInfo>;
    };
 
#ifndef NO_DOC
    template<>
    struct FrameInfo::Version<8>
    {
        using Type = FrameInfo;
    };
#endif
 
} // namespace Zivid
 
#ifndef NO_DOC
namespace Zivid::Detail
{
 
    ZIVID_CORE_EXPORT void save(const Zivid::FrameInfo &dataModel, std::ostream &ostream);
    ZIVID_CORE_EXPORT void load(Zivid::FrameInfo &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::FrameInfo::Diagnostics> : integral_constant<size_t, 1>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::FrameInfo::Diagnostics>
    {
        static_assert(i < tuple_size<Zivid::FrameInfo::Diagnostics>::value, "Index must be less than 1");
 
        using type // NOLINT
            = decltype(declval<Zivid::FrameInfo::Diagnostics>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::FrameInfo::Metrics> : integral_constant<size_t, 5>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::FrameInfo::Metrics>
    {
        static_assert(i < tuple_size<Zivid::FrameInfo::Metrics>::value, "Index must be less than 5");
 
        using type // NOLINT
            = decltype(declval<Zivid::FrameInfo::Metrics>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::FrameInfo::SoftwareVersion> : integral_constant<size_t, 1>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::FrameInfo::SoftwareVersion>
    {
        static_assert(i < tuple_size<Zivid::FrameInfo::SoftwareVersion>::value, "Index must be less than 1");
 
        using type // NOLINT
            = decltype(declval<Zivid::FrameInfo::SoftwareVersion>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::FrameInfo::SystemInfo> : integral_constant<size_t, 3>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::FrameInfo::SystemInfo>
    {
        static_assert(i < tuple_size<Zivid::FrameInfo::SystemInfo>::value, "Index must be less than 3");
 
        using type // NOLINT
            = decltype(declval<Zivid::FrameInfo::SystemInfo>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::FrameInfo::SystemInfo::CPU> : integral_constant<size_t, 1>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::FrameInfo::SystemInfo::CPU>
    {
        static_assert(i < tuple_size<Zivid::FrameInfo::SystemInfo::CPU>::value, "Index must be less than 1");
 
        using type // NOLINT
            = decltype(declval<Zivid::FrameInfo::SystemInfo::CPU>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::FrameInfo::SystemInfo::ComputeDevice> : integral_constant<size_t, 2>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::FrameInfo::SystemInfo::ComputeDevice>
    {
        static_assert(i < tuple_size<Zivid::FrameInfo::SystemInfo::ComputeDevice>::value, "Index must be less than 2");
 
        using type // NOLINT
            = decltype(declval<Zivid::FrameInfo::SystemInfo::ComputeDevice>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::FrameInfo> : integral_constant<size_t, 5>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::FrameInfo>
    {
        static_assert(i < tuple_size<Zivid::FrameInfo>::value, "Index must be less than 5");
 
        using type // NOLINT
            = decltype(declval<Zivid::FrameInfo>().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/FrameInfoInternal.h") && __has_include("Zivid/DataModelNodeMetaData.h")
#        include "Zivid/FrameInfoInternal.h"
#    endif
#endif