Settings.h

Go to the documentation of this file.

 
 
/*******************************************************************************
 
 * This file is part of the Zivid 3D Camera API
 
 *
 
 * Copyright 2015-2023 (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 <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/Point.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 Settings
    {
    public:
        static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
        static constexpr const char *path{ "" };
 
        static constexpr const char *name{ "Settings" };
 
        static constexpr const char *description{
            R"description(Settings used when capturing with a Zivid camera)description"
        };
 
        static constexpr size_t version{ 21 };
 
#ifndef NO_DOC
        template<size_t>
        struct Version;
 
        using LatestVersion = Zivid::Settings;
 
        // 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{ 's', 'e', 't' };
 
#endif
 
 
        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
        class ZIVID_CORE_EXPORT Acquisition
        {
        public:
            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
            static constexpr const char *path{ "Acquisition" };
 
            static constexpr const char *name{ "Acquisition" };
 
            static constexpr const char *description{ R"description(Settings for a single acquisition)description" };
 
 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT Aperture
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                static constexpr const char *path{ "Acquisition/Aperture" };
 
                static constexpr const char *name{ "Aperture" };
 
                static constexpr const char *description{
                    R"description(Aperture setting for the camera. Specified as an f-number (the ratio of lens focal length to
the effective aperture diameter).
)description"
                };
 
                using ValueType = double;
 
                static constexpr Range<double> validRange()
                {
                    return { 1.4, 32.0 };
                }
 
                Aperture() = default;
 
                explicit constexpr Aperture(double value)
                    : m_opt{ verifyValue(value) }
                {}
 
                double value() const;
 
                bool hasValue() const;
 
                void reset();
 
                std::string toString() const;
 
                bool operator==(const Aperture &other) const
                {
                    return m_opt == other.m_opt;
                }
 
                bool operator!=(const Aperture &other) const
                {
                    return m_opt != other.m_opt;
                }
 
                bool operator<(const Aperture &other) const
                {
                    return m_opt < other.m_opt;
                }
 
                bool operator>(const Aperture &other) const
                {
                    return m_opt > other.m_opt;
                }
 
                bool operator<=(const Aperture &other) const
                {
                    return m_opt <= other.m_opt;
                }
 
                bool operator>=(const Aperture &other) const
                {
                    return m_opt >= other.m_opt;
                }
 
                friend std::ostream &operator<<(std::ostream &stream, const Aperture &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                constexpr ValueType static verifyValue(const ValueType &value)
                {
                    return validRange().isInRange(value)
                               ? value
                               : throw std::out_of_range{ "Aperture{ " + std::to_string(value) + " } is not in range ["
                                                          + std::to_string(validRange().min()) + ", "
                                                          + std::to_string(validRange().max()) + "]" };
                }
 
                Zivid::DataModel::Detail::Optional<double> m_opt;
 
                friend struct DataModel::Detail::Befriend<Aperture>;
            };
 
 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT Brightness
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                static constexpr const char *path{ "Acquisition/Brightness" };
 
                static constexpr const char *name{ "Brightness" };
 
                static constexpr const char *description{
                    R"description(Brightness controls the light output from the projector.
 
Brightness above 1.0 may be needed when the distance between the camera and the scene is large,
or in case of high levels of ambient lighting.
 
When brightness is above 1.0 the duty cycle of the camera (the percentage of time the camera
can capture) will be reduced. The duty cycle in boost mode is 50%. The duty cycle is calculated
over a 10 second period. This limitation is enforced automatically by the camera. Calling capture
when the duty cycle limit has been reached will cause the camera to first wait (sleep) for a
duration of time to cool down, before capture will start.
)description"
                };
 
                using ValueType = double;
 
                static constexpr Range<double> validRange()
                {
                    return { 0, 2.5 };
                }
 
                Brightness() = default;
 
                explicit constexpr Brightness(double value)
                    : m_opt{ verifyValue(value) }
                {}
 
                double value() const;
 
                bool hasValue() const;
 
                void reset();
 
                std::string toString() const;
 
                bool operator==(const Brightness &other) const
                {
                    return m_opt == other.m_opt;
                }
 
                bool operator!=(const Brightness &other) const
                {
                    return m_opt != other.m_opt;
                }
 
                bool operator<(const Brightness &other) const
                {
                    return m_opt < other.m_opt;
                }
 
                bool operator>(const Brightness &other) const
                {
                    return m_opt > other.m_opt;
                }
 
                bool operator<=(const Brightness &other) const
                {
                    return m_opt <= other.m_opt;
                }
 
                bool operator>=(const Brightness &other) const
                {
                    return m_opt >= other.m_opt;
                }
 
                friend std::ostream &operator<<(std::ostream &stream, const Brightness &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                constexpr ValueType static verifyValue(const ValueType &value)
                {
                    return validRange().isInRange(value)
                               ? value
                               : throw std::out_of_range{ "Brightness{ " + std::to_string(value)
                                                          + " } is not in range [" + std::to_string(validRange().min())
                                                          + ", " + std::to_string(validRange().max()) + "]" };
                }
 
                Zivid::DataModel::Detail::Optional<double> m_opt;
 
                friend struct DataModel::Detail::Befriend<Brightness>;
            };
 
 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT ExposureTime
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                static constexpr const char *path{ "Acquisition/ExposureTime" };
 
                static constexpr const char *name{ "ExposureTime" };
 
                static constexpr const char *description{
                    R"description(Exposure time for each single image in the measurement. Affects frame rate.)description"
                };
 
                using ValueType = std::chrono::microseconds;
 
                static constexpr Range<std::chrono::microseconds> validRange()
                {
                    return { std::chrono::microseconds{ 1677 }, std::chrono::microseconds{ 100000 } };
                }
 
                ExposureTime() = default;
 
                explicit constexpr ExposureTime(std::chrono::microseconds value)
                    : m_opt{ verifyValue(value) }
                {}
 
                std::chrono::microseconds value() const;
 
                bool hasValue() const;
 
                void reset();
 
                std::string toString() const;
 
                bool operator==(const ExposureTime &other) const
                {
                    return m_opt == other.m_opt;
                }
 
                bool operator!=(const ExposureTime &other) const
                {
                    return m_opt != other.m_opt;
                }
 
                bool operator<(const ExposureTime &other) const
                {
                    return m_opt < other.m_opt;
                }
 
                bool operator>(const ExposureTime &other) const
                {
                    return m_opt > other.m_opt;
                }
 
                bool operator<=(const ExposureTime &other) const
                {
                    return m_opt <= other.m_opt;
                }
 
                bool operator>=(const ExposureTime &other) const
                {
                    return m_opt >= other.m_opt;
                }
 
                friend std::ostream &operator<<(std::ostream &stream, const ExposureTime &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                constexpr ValueType static verifyValue(const ValueType &value)
                {
                    return validRange().isInRange(value)
                               ? value
                               : throw std::out_of_range{ "ExposureTime{ " + std::to_string(value.count())
                                                          + " } is not in range ["
                                                          + std::to_string(validRange().min().count()) + ", "
                                                          + std::to_string(validRange().max().count()) + "]" };
                }
 
                Zivid::DataModel::Detail::Optional<std::chrono::microseconds> m_opt;
 
                friend struct DataModel::Detail::Befriend<ExposureTime>;
            };
 
 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT Gain
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                static constexpr const char *path{ "Acquisition/Gain" };
 
                static constexpr const char *name{ "Gain" };
 
                static constexpr const char *description{ R"description(Analog gain in the camera)description" };
 
                using ValueType = double;
 
                static constexpr Range<double> validRange()
                {
                    return { 1, 16 };
                }
 
                Gain() = default;
 
                explicit constexpr Gain(double value)
                    : m_opt{ verifyValue(value) }
                {}
 
                double value() const;
 
                bool hasValue() const;
 
                void reset();
 
                std::string toString() const;
 
                bool operator==(const Gain &other) const
                {
                    return m_opt == other.m_opt;
                }
 
                bool operator!=(const Gain &other) const
                {
                    return m_opt != other.m_opt;
                }
 
                bool operator<(const Gain &other) const
                {
                    return m_opt < other.m_opt;
                }
 
                bool operator>(const Gain &other) const
                {
                    return m_opt > other.m_opt;
                }
 
                bool operator<=(const Gain &other) const
                {
                    return m_opt <= other.m_opt;
                }
 
                bool operator>=(const Gain &other) const
                {
                    return m_opt >= other.m_opt;
                }
 
                friend std::ostream &operator<<(std::ostream &stream, const Gain &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                constexpr ValueType static verifyValue(const ValueType &value)
                {
                    return validRange().isInRange(value)
                               ? value
                               : throw std::out_of_range{ "Gain{ " + std::to_string(value) + " } is not in range ["
                                                          + std::to_string(validRange().min()) + ", "
                                                          + std::to_string(validRange().max()) + "]" };
                }
 
                Zivid::DataModel::Detail::Optional<double> m_opt;
 
                friend struct DataModel::Detail::Befriend<Gain>;
            };
 
            using Descendants = std::tuple<
                Settings::Acquisition::Aperture,
                Settings::Acquisition::Brightness,
                Settings::Acquisition::ExposureTime,
                Settings::Acquisition::Gain>;
 
            Acquisition();
 
#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 Acquisition(Args &&...args)
            {
                using namespace Zivid::Detail::TypeTraits;
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to Acquisition(...). "
                    "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
            Acquisition 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 Aperture &aperture() const
            {
                return m_aperture;
            }
 
            Aperture &aperture()
            {
                return m_aperture;
            }
 
            Acquisition &set(const Aperture &value)
            {
                m_aperture = value;
                return *this;
            }
 
            const Brightness &brightness() const
            {
                return m_brightness;
            }
 
            Brightness &brightness()
            {
                return m_brightness;
            }
 
            Acquisition &set(const Brightness &value)
            {
                m_brightness = value;
                return *this;
            }
 
            const ExposureTime &exposureTime() const
            {
                return m_exposureTime;
            }
 
            ExposureTime &exposureTime()
            {
                return m_exposureTime;
            }
 
            Acquisition &set(const ExposureTime &value)
            {
                m_exposureTime = value;
                return *this;
            }
 
            const Gain &gain() const
            {
                return m_gain;
            }
 
            Gain &gain()
            {
                return m_gain;
            }
 
            Acquisition &set(const Gain &value)
            {
                m_gain = value;
                return *this;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Acquisition::Aperture>::value, int>::type = 0>
            const Settings::Acquisition::Aperture &get() const
            {
                return m_aperture;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Acquisition::Brightness>::value, int>::type = 0>
            const Settings::Acquisition::Brightness &get() const
            {
                return m_brightness;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Acquisition::ExposureTime>::value, int>::type = 0>
            const Settings::Acquisition::ExposureTime &get() const
            {
                return m_exposureTime;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Acquisition::Gain>::value, int>::type = 0>
            const Settings::Acquisition::Gain &get() const
            {
                return m_gain;
            }
 
            template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
            const Settings::Acquisition::Aperture &get() const
            {
                return m_aperture;
            }
 
            template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
            const Settings::Acquisition::Brightness &get() const
            {
                return m_brightness;
            }
 
            template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
            const Settings::Acquisition::ExposureTime &get() const
            {
                return m_exposureTime;
            }
 
            template<size_t i, typename std::enable_if<i == 3, int>::type = 0>
            const Settings::Acquisition::Gain &get() const
            {
                return m_gain;
            }
 
            template<typename F>
            void forEach(const F &f) const
            {
                f(m_aperture);
                f(m_brightness);
                f(m_exposureTime);
                f(m_gain);
            }
 
            template<typename F>
            void forEach(const F &f)
            {
                f(m_aperture);
                f(m_brightness);
                f(m_exposureTime);
                f(m_gain);
            }
 
            bool operator==(const Acquisition &other) const;
 
            bool operator!=(const Acquisition &other) const;
 
            std::string toString() const;
 
            friend std::ostream &operator<<(std::ostream &stream, const Acquisition &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;
 
            Aperture m_aperture;
            Brightness m_brightness;
            ExposureTime m_exposureTime;
            Gain m_gain;
 
            friend struct DataModel::Detail::Befriend<Acquisition>;
        };
 
 
        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
        class ZIVID_CORE_EXPORT Acquisitions
        {
        public:
            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafDataModelList;
 
            static constexpr const char *path{ "Acquisitions" };
 
            static constexpr const char *name{ "Acquisitions" };
 
            static constexpr const char *description{ R"description(List of Acquisition objects)description" };
 
            using ValueType = std::vector<Settings::Acquisition>;
 
            static constexpr Range<ValueType::size_type> validSize()
            {
                return { 0, std::numeric_limits<ValueType::size_type>::max() };
            }
 
            Acquisitions() = default;
 
            explicit Acquisitions(std::vector<Settings::Acquisition> value)
                : m_value{ std::move(value) }
            {}
 
            explicit Acquisitions(std::initializer_list<Settings::Acquisition> value)
                : Acquisitions{ ValueType{ value } }
            {}
 
            const std::vector<Settings::Acquisition> &value() const;
 
            std::string toString() const;
 
            std::size_t size() const noexcept;
 
            bool isEmpty() const noexcept;
 
            template<typename... Args>
            void emplaceBack(Args &&...args)
            {
                m_value.emplace_back(std::forward<Args>(args)...);
            }
 
            Settings::Acquisition &at(std::size_t pos);
 
            const Settings::Acquisition &at(std::size_t pos) const;
 
            Settings::Acquisition &operator[](std::size_t pos);
 
            const Settings::Acquisition &operator[](std::size_t pos) const;
 
            template<typename F>
            void forEach(const F &f)
            {
                for(auto &child : m_value)
                {
                    f(child);
                }
            }
 
            template<typename F>
            void forEach(const F &f) const
            {
                for(const auto &child : m_value)
                {
                    f(child);
                }
            }
 
            using Iterator = std::vector<Settings::Acquisition>::iterator;
 
            Iterator begin() noexcept;
 
            Iterator end() noexcept;
 
            using ConstIterator = std::vector<Settings::Acquisition>::const_iterator;
 
            ConstIterator begin() const noexcept;
 
            ConstIterator end() const noexcept;
 
            ConstIterator cbegin() const noexcept;
 
            ConstIterator cend() const noexcept;
 
            bool operator==(const Acquisitions &other) const
            {
                return m_value == other.m_value;
            }
 
            bool operator!=(const Acquisitions &other) const
            {
                return m_value != other.m_value;
            }
 
            friend std::ostream &operator<<(std::ostream &stream, const Acquisitions &value)
            {
                return stream << value.toString();
            }
 
        private:
            void setFromString(const std::string &value);
 
            std::vector<Settings::Acquisition> m_value{};
 
            friend struct DataModel::Detail::Befriend<Acquisitions>;
        };
 
 
        // 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(When Diagnostics is enabled, extra diagnostic information is recorded during capture. This extra
information is included when saving the frame to a .zdf file, and will help Zivid's support team
to provide better assistance.
 
Enabling Diagnostics increases the capture time and the RAM usage. It will also increase the size of the
.zdf file. It is recommended to enable Diagnostics only when reporting issues to Zivid's support team.
)description"
            };
 
 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT Enabled
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                static constexpr const char *path{ "Diagnostics/Enabled" };
 
                static constexpr const char *name{ "Enabled" };
 
                static constexpr const char *description{ R"description(Enable diagnostics)description" };
 
                using ValueType = bool;
                static const Enabled yes; 
                static const Enabled no;  
 
                static std::set<bool> validValues()
                {
                    return { false, true };
                }
 
                Enabled() = default;
 
                explicit constexpr Enabled(bool value)
                    : m_opt{ value }
                {}
 
                bool value() const;
 
                bool hasValue() const;
 
                void reset();
 
                std::string toString() const;
 
                bool operator==(const Enabled &other) const
                {
                    return m_opt == other.m_opt;
                }
 
                bool operator!=(const Enabled &other) const
                {
                    return m_opt != other.m_opt;
                }
 
                friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                Zivid::DataModel::Detail::Optional<bool> m_opt;
 
                friend struct DataModel::Detail::Befriend<Enabled>;
            };
 
            using Descendants = std::tuple<Settings::Diagnostics::Enabled>;
 
            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 Enabled &isEnabled() const
            {
                return m_enabled;
            }
 
            Enabled &isEnabled()
            {
                return m_enabled;
            }
 
            Diagnostics &set(const Enabled &value)
            {
                m_enabled = value;
                return *this;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Diagnostics::Enabled>::value, int>::type = 0>
            const Settings::Diagnostics::Enabled &get() const
            {
                return m_enabled;
            }
 
            template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
            const Settings::Diagnostics::Enabled &get() const
            {
                return m_enabled;
            }
 
            template<typename F>
            void forEach(const F &f) const
            {
                f(m_enabled);
            }
 
            template<typename F>
            void forEach(const F &f)
            {
                f(m_enabled);
            }
 
            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;
 
            Enabled m_enabled;
 
            friend struct DataModel::Detail::Befriend<Diagnostics>;
        };
 
 
        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
        class ZIVID_CORE_EXPORT Experimental
        {
        public:
            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
            static constexpr const char *path{ "Experimental" };
 
            static constexpr const char *name{ "Experimental" };
 
            static constexpr const char *description{
                R"description(Experimental features. These settings may be changed, renamed, moved or deleted in the future.)description"
            };
 
 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT Engine
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                static constexpr const char *path{ "Experimental/Engine" };
 
                static constexpr const char *name{ "Engine" };
 
                static constexpr const char *description{ R"description(Set the Zivid Vision Engine to use.
 
The Phase Engine is the fastest choice in terms of both acquisition time and total capture
time, and is a good compromise between quality and speed. The Phase Engine is recommended for
objects that are diffuse, opaque, and slightly specular, and is suitable for applications in
logistics such as parcel induction.
 
The Stripe Engine is built for exceptional point cloud quality in scenes with highly specular
reflective objects. This makes the engine suitable for applications such as factory automation,
manufacturing, and bin picking. Additional acquisition and processing time are required for
the Stripe Engine.
 
The Omni Engine is built for exceptional point cloud quality on all scenes, including scenes
with extremely specular reflective objects, as well as transparent objects. This makes the Omni
Engine suitable for applications such as piece picking. Same as for the Stripe Engine, it trades
off speed for quality. The Omni Engine is only available for Zivid 2+.
 
The Stripe and Omni engines are currently experimental, and may be changed and improved
in the future.
)description" };
 
                enum class ValueType
                {
                    phase,
                    stripe,
                    omni
                };
                static const Engine phase;  
                static const Engine stripe; 
                static const Engine omni;   
 
                static std::set<ValueType> validValues()
                {
                    return { ValueType::phase, ValueType::stripe, ValueType::omni };
                }
 
                Engine() = default;
 
                explicit constexpr Engine(ValueType value)
                    : m_opt{ verifyValue(value) }
                {}
 
                ValueType value() const;
 
                bool hasValue() const;
 
                void reset();
 
                std::string toString() const;
 
                friend std::ostream &operator<<(std::ostream &stream, const Engine::ValueType &value)
                {
                    return stream << Engine{ value }.toString();
                }
 
                bool operator==(const Engine &other) const
                {
                    return m_opt == other.m_opt;
                }
 
                bool operator!=(const Engine &other) const
                {
                    return m_opt != other.m_opt;
                }
 
                friend std::ostream &operator<<(std::ostream &stream, const Engine &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                constexpr ValueType static verifyValue(const ValueType &value)
                {
                    return value == ValueType::phase || value == ValueType::stripe || value == ValueType::omni
                               ? value
                               : throw std::invalid_argument{
                                     "Invalid value: Engine{ "
                                     + std::to_string(static_cast<std::underlying_type<ValueType>::type>(value)) + " }"
                                 };
                }
 
                Zivid::DataModel::Detail::Optional<ValueType> m_opt;
 
                friend struct DataModel::Detail::Befriend<Engine>;
            };
 
            using Descendants = std::tuple<Settings::Experimental::Engine>;
 
            Experimental();
 
#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 Experimental(Args &&...args)
            {
                using namespace Zivid::Detail::TypeTraits;
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to Experimental(...). "
                    "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
            Experimental 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 Engine &engine() const
            {
                return m_engine;
            }
 
            Engine &engine()
            {
                return m_engine;
            }
 
            Experimental &set(const Engine &value)
            {
                m_engine = value;
                return *this;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Experimental::Engine>::value, int>::type = 0>
            const Settings::Experimental::Engine &get() const
            {
                return m_engine;
            }
 
            template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
            const Settings::Experimental::Engine &get() const
            {
                return m_engine;
            }
 
            template<typename F>
            void forEach(const F &f) const
            {
                f(m_engine);
            }
 
            template<typename F>
            void forEach(const F &f)
            {
                f(m_engine);
            }
 
            bool operator==(const Experimental &other) const;
 
            bool operator!=(const Experimental &other) const;
 
            std::string toString() const;
 
            friend std::ostream &operator<<(std::ostream &stream, const Experimental &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;
 
            Engine m_engine;
 
            friend struct DataModel::Detail::Befriend<Experimental>;
        };
 
 
        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
        class ZIVID_CORE_EXPORT Processing
        {
        public:
            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
            static constexpr const char *path{ "Processing" };
 
            static constexpr const char *name{ "Processing" };
 
            static constexpr const char *description{
                R"description(Settings related to processing of a capture, including filters and color balance)description"
            };
 
 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT Color
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
                static constexpr const char *path{ "Processing/Color" };
 
                static constexpr const char *name{ "Color" };
 
                static constexpr const char *description{ R"description(Color settings)description" };
 
 
                // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                class ZIVID_CORE_EXPORT Balance
                {
                public:
                    static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
                    static constexpr const char *path{ "Processing/Color/Balance" };
 
                    static constexpr const char *name{ "Balance" };
 
                    static constexpr const char *description{ R"description(Color balance settings)description" };
 
 
                    // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                    class ZIVID_CORE_EXPORT Blue
                    {
                    public:
                        static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                        static constexpr const char *path{ "Processing/Color/Balance/Blue" };
 
                        static constexpr const char *name{ "Blue" };
 
                        static constexpr const char *description{
                            R"description(Digital gain applied to blue channel)description"
                        };
 
                        using ValueType = double;
 
                        static constexpr Range<double> validRange()
                        {
                            return { 1.0, 8.0 };
                        }
 
                        Blue() = default;
 
                        explicit constexpr Blue(double value)
                            : m_opt{ verifyValue(value) }
                        {}
 
                        double value() const;
 
                        bool hasValue() const;
 
                        void reset();
 
                        std::string toString() const;
 
                        bool operator==(const Blue &other) const
                        {
                            return m_opt == other.m_opt;
                        }
 
                        bool operator!=(const Blue &other) const
                        {
                            return m_opt != other.m_opt;
                        }
 
                        bool operator<(const Blue &other) const
                        {
                            return m_opt < other.m_opt;
                        }
 
                        bool operator>(const Blue &other) const
                        {
                            return m_opt > other.m_opt;
                        }
 
                        bool operator<=(const Blue &other) const
                        {
                            return m_opt <= other.m_opt;
                        }
 
                        bool operator>=(const Blue &other) const
                        {
                            return m_opt >= other.m_opt;
                        }
 
                        friend std::ostream &operator<<(std::ostream &stream, const Blue &value)
                        {
                            return stream << value.toString();
                        }
 
                    private:
                        void setFromString(const std::string &value);
 
                        constexpr ValueType static verifyValue(const ValueType &value)
                        {
                            return validRange().isInRange(value)
                                       ? value
                                       : throw std::out_of_range{ "Blue{ " + std::to_string(value)
                                                                  + " } is not in range ["
                                                                  + std::to_string(validRange().min()) + ", "
                                                                  + std::to_string(validRange().max()) + "]" };
                        }
 
                        Zivid::DataModel::Detail::Optional<double> m_opt;
 
                        friend struct DataModel::Detail::Befriend<Blue>;
                    };
 
 
                    // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                    class ZIVID_CORE_EXPORT Green
                    {
                    public:
                        static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                        static constexpr const char *path{ "Processing/Color/Balance/Green" };
 
                        static constexpr const char *name{ "Green" };
 
                        static constexpr const char *description{
                            R"description(Digital gain applied to green channel)description"
                        };
 
                        using ValueType = double;
 
                        static constexpr Range<double> validRange()
                        {
                            return { 1.0, 8.0 };
                        }
 
                        Green() = default;
 
                        explicit constexpr Green(double value)
                            : m_opt{ verifyValue(value) }
                        {}
 
                        double value() const;
 
                        bool hasValue() const;
 
                        void reset();
 
                        std::string toString() const;
 
                        bool operator==(const Green &other) const
                        {
                            return m_opt == other.m_opt;
                        }
 
                        bool operator!=(const Green &other) const
                        {
                            return m_opt != other.m_opt;
                        }
 
                        bool operator<(const Green &other) const
                        {
                            return m_opt < other.m_opt;
                        }
 
                        bool operator>(const Green &other) const
                        {
                            return m_opt > other.m_opt;
                        }
 
                        bool operator<=(const Green &other) const
                        {
                            return m_opt <= other.m_opt;
                        }
 
                        bool operator>=(const Green &other) const
                        {
                            return m_opt >= other.m_opt;
                        }
 
                        friend std::ostream &operator<<(std::ostream &stream, const Green &value)
                        {
                            return stream << value.toString();
                        }
 
                    private:
                        void setFromString(const std::string &value);
 
                        constexpr ValueType static verifyValue(const ValueType &value)
                        {
                            return validRange().isInRange(value)
                                       ? value
                                       : throw std::out_of_range{ "Green{ " + std::to_string(value)
                                                                  + " } is not in range ["
                                                                  + std::to_string(validRange().min()) + ", "
                                                                  + std::to_string(validRange().max()) + "]" };
                        }
 
                        Zivid::DataModel::Detail::Optional<double> m_opt;
 
                        friend struct DataModel::Detail::Befriend<Green>;
                    };
 
 
                    // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                    class ZIVID_CORE_EXPORT Red
                    {
                    public:
                        static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                        static constexpr const char *path{ "Processing/Color/Balance/Red" };
 
                        static constexpr const char *name{ "Red" };
 
                        static constexpr const char *description{
                            R"description(Digital gain applied to red channel)description"
                        };
 
                        using ValueType = double;
 
                        static constexpr Range<double> validRange()
                        {
                            return { 1.0, 8.0 };
                        }
 
                        Red() = default;
 
                        explicit constexpr Red(double value)
                            : m_opt{ verifyValue(value) }
                        {}
 
                        double value() const;
 
                        bool hasValue() const;
 
                        void reset();
 
                        std::string toString() const;
 
                        bool operator==(const Red &other) const
                        {
                            return m_opt == other.m_opt;
                        }
 
                        bool operator!=(const Red &other) const
                        {
                            return m_opt != other.m_opt;
                        }
 
                        bool operator<(const Red &other) const
                        {
                            return m_opt < other.m_opt;
                        }
 
                        bool operator>(const Red &other) const
                        {
                            return m_opt > other.m_opt;
                        }
 
                        bool operator<=(const Red &other) const
                        {
                            return m_opt <= other.m_opt;
                        }
 
                        bool operator>=(const Red &other) const
                        {
                            return m_opt >= other.m_opt;
                        }
 
                        friend std::ostream &operator<<(std::ostream &stream, const Red &value)
                        {
                            return stream << value.toString();
                        }
 
                    private:
                        void setFromString(const std::string &value);
 
                        constexpr ValueType static verifyValue(const ValueType &value)
                        {
                            return validRange().isInRange(value)
                                       ? value
                                       : throw std::out_of_range{ "Red{ " + std::to_string(value)
                                                                  + " } is not in range ["
                                                                  + std::to_string(validRange().min()) + ", "
                                                                  + std::to_string(validRange().max()) + "]" };
                        }
 
                        Zivid::DataModel::Detail::Optional<double> m_opt;
 
                        friend struct DataModel::Detail::Befriend<Red>;
                    };
 
                    using Descendants = std::tuple<
                        Settings::Processing::Color::Balance::Blue,
                        Settings::Processing::Color::Balance::Green,
                        Settings::Processing::Color::Balance::Red>;
 
                    Balance();
 
#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 Balance(Args &&...args)
                    {
                        using namespace Zivid::Detail::TypeTraits;
 
                        static_assert(
                            AllArgsDecayedAreUnique<Args...>::value,
                            "Found duplicate types among the arguments passed to Balance(...). "
                            "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
                    Balance 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 Blue &blue() const
                    {
                        return m_blue;
                    }
 
                    Blue &blue()
                    {
                        return m_blue;
                    }
 
                    Balance &set(const Blue &value)
                    {
                        m_blue = value;
                        return *this;
                    }
 
                    const Green &green() const
                    {
                        return m_green;
                    }
 
                    Green &green()
                    {
                        return m_green;
                    }
 
                    Balance &set(const Green &value)
                    {
                        m_green = value;
                        return *this;
                    }
 
                    const Red &red() const
                    {
                        return m_red;
                    }
 
                    Red &red()
                    {
                        return m_red;
                    }
 
                    Balance &set(const Red &value)
                    {
                        m_red = value;
                        return *this;
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Color::Balance::Blue>::value,
                            int>::type = 0>
                    const Settings::Processing::Color::Balance::Blue &get() const
                    {
                        return m_blue;
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Color::Balance::Green>::value,
                            int>::type = 0>
                    const Settings::Processing::Color::Balance::Green &get() const
                    {
                        return m_green;
                    }
 
                    template<
                        typename T,
                        typename std::
                            enable_if<std::is_same<T, Settings::Processing::Color::Balance::Red>::value, int>::type = 0>
                    const Settings::Processing::Color::Balance::Red &get() const
                    {
                        return m_red;
                    }
 
                    template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                    const Settings::Processing::Color::Balance::Blue &get() const
                    {
                        return m_blue;
                    }
 
                    template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
                    const Settings::Processing::Color::Balance::Green &get() const
                    {
                        return m_green;
                    }
 
                    template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
                    const Settings::Processing::Color::Balance::Red &get() const
                    {
                        return m_red;
                    }
 
                    template<typename F>
                    void forEach(const F &f) const
                    {
                        f(m_blue);
                        f(m_green);
                        f(m_red);
                    }
 
                    template<typename F>
                    void forEach(const F &f)
                    {
                        f(m_blue);
                        f(m_green);
                        f(m_red);
                    }
 
                    bool operator==(const Balance &other) const;
 
                    bool operator!=(const Balance &other) const;
 
                    std::string toString() const;
 
                    friend std::ostream &operator<<(std::ostream &stream, const Balance &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;
 
                    Blue m_blue;
                    Green m_green;
                    Red m_red;
 
                    friend struct DataModel::Detail::Befriend<Balance>;
                };
 
 
                // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                class ZIVID_CORE_EXPORT Experimental
                {
                public:
                    static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
                    static constexpr const char *path{ "Processing/Color/Experimental" };
 
                    static constexpr const char *name{ "Experimental" };
 
                    static constexpr const char *description{
                        R"description(Experimental color settings. These may be renamed, moved or deleted in the future.)description"
                    };
 
 
                    // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                    class ZIVID_CORE_EXPORT Mode
                    {
                    public:
                        static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                        static constexpr const char *path{ "Processing/Color/Experimental/Mode" };
 
                        static constexpr const char *name{ "Mode" };
 
                        static constexpr const char *description{
                            R"description(This setting controls how the color image is computed.
 
`automatic` is the default option. `automatic` is identical to `useFirstAcquisition` for
single-acquisition captures and multi-acquisition captures when all the acquisitions have
identical (duplicated) acquisition settings. `automatic` is identical to `toneMapping` for
multi-acquisition HDR captures with differing acquisition settings.
 
`useFirstAcquisition` uses the color data acquired from the first acquisition provided. If
the capture consists of more than one acquisition, then the remaining acquisitions are not used
for the color image. No tone mapping is performed. This option provides the most control of
the color image, and the color values will be consistent over repeated captures with the same
settings.
 
`toneMapping` uses all the acquisitions to create one merged and normalized color image. For
HDR captures the dynamic range of the captured images is usually higher than the 8-bit color
image range. `toneMapping` will map the HDR color data to the 8-bit color output range by
applying a scaling factor. `toneMapping` can also be used for single-acquisition captures to
normalize the captured color image to the full 8-bit output. Note that when using `toneMapping`
mode the color values can be inconsistent over repeated captures if you move, add or remove
objects in the scene. For the most control over the colors, select the `useFirstAcquisition`
mode.
)description"
                        };
 
                        enum class ValueType
                        {
                            automatic,
                            useFirstAcquisition,
                            toneMapping
                        };
                        static const Mode automatic;           
                        static const Mode useFirstAcquisition; 
                        static const Mode toneMapping;         
 
                        static std::set<ValueType> validValues()
                        {
                            return { ValueType::automatic, ValueType::useFirstAcquisition, ValueType::toneMapping };
                        }
 
                        Mode() = default;
 
                        explicit constexpr Mode(ValueType value)
                            : m_opt{ verifyValue(value) }
                        {}
 
                        ValueType value() const;
 
                        bool hasValue() const;
 
                        void reset();
 
                        std::string toString() const;
 
                        friend std::ostream &operator<<(std::ostream &stream, const Mode::ValueType &value)
                        {
                            return stream << Mode{ value }.toString();
                        }
 
                        bool operator==(const Mode &other) const
                        {
                            return m_opt == other.m_opt;
                        }
 
                        bool operator!=(const Mode &other) const
                        {
                            return m_opt != other.m_opt;
                        }
 
                        friend std::ostream &operator<<(std::ostream &stream, const Mode &value)
                        {
                            return stream << value.toString();
                        }
 
                    private:
                        void setFromString(const std::string &value);
 
                        constexpr ValueType static verifyValue(const ValueType &value)
                        {
                            return value == ValueType::automatic || value == ValueType::useFirstAcquisition
                                           || value == ValueType::toneMapping
                                       ? value
                                       : throw std::invalid_argument{
                                             "Invalid value: Mode{ "
                                             + std::to_string(static_cast<std::underlying_type<ValueType>::type>(value))
                                             + " }"
                                         };
                        }
 
                        Zivid::DataModel::Detail::Optional<ValueType> m_opt;
 
                        friend struct DataModel::Detail::Befriend<Mode>;
                    };
 
                    using Descendants = std::tuple<Settings::Processing::Color::Experimental::Mode>;
 
                    Experimental();
 
#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 Experimental(Args &&...args)
                    {
                        using namespace Zivid::Detail::TypeTraits;
 
                        static_assert(
                            AllArgsDecayedAreUnique<Args...>::value,
                            "Found duplicate types among the arguments passed to Experimental(...). "
                            "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
                    Experimental 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 Mode &mode() const
                    {
                        return m_mode;
                    }
 
                    Mode &mode()
                    {
                        return m_mode;
                    }
 
                    Experimental &set(const Mode &value)
                    {
                        m_mode = value;
                        return *this;
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Color::Experimental::Mode>::value,
                            int>::type = 0>
                    const Settings::Processing::Color::Experimental::Mode &get() const
                    {
                        return m_mode;
                    }
 
                    template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                    const Settings::Processing::Color::Experimental::Mode &get() const
                    {
                        return m_mode;
                    }
 
                    template<typename F>
                    void forEach(const F &f) const
                    {
                        f(m_mode);
                    }
 
                    template<typename F>
                    void forEach(const F &f)
                    {
                        f(m_mode);
                    }
 
                    bool operator==(const Experimental &other) const;
 
                    bool operator!=(const Experimental &other) const;
 
                    std::string toString() const;
 
                    friend std::ostream &operator<<(std::ostream &stream, const Experimental &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;
 
                    Mode m_mode;
 
                    friend struct DataModel::Detail::Befriend<Experimental>;
                };
 
 
                // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                class ZIVID_CORE_EXPORT Gamma
                {
                public:
                    static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                    static constexpr const char *path{ "Processing/Color/Gamma" };
 
                    static constexpr const char *name{ "Gamma" };
 
                    static constexpr const char *description{
                        R"description(Gamma applied to the color values. Gamma less than 1 makes the colors brighter, while gamma
greater than 1 makes the colors darker.
)description"
                    };
 
                    using ValueType = double;
 
                    static constexpr Range<double> validRange()
                    {
                        return { 0.25, 1.5 };
                    }
 
                    Gamma() = default;
 
                    explicit constexpr Gamma(double value)
                        : m_opt{ verifyValue(value) }
                    {}
 
                    double value() const;
 
                    bool hasValue() const;
 
                    void reset();
 
                    std::string toString() const;
 
                    bool operator==(const Gamma &other) const
                    {
                        return m_opt == other.m_opt;
                    }
 
                    bool operator!=(const Gamma &other) const
                    {
                        return m_opt != other.m_opt;
                    }
 
                    bool operator<(const Gamma &other) const
                    {
                        return m_opt < other.m_opt;
                    }
 
                    bool operator>(const Gamma &other) const
                    {
                        return m_opt > other.m_opt;
                    }
 
                    bool operator<=(const Gamma &other) const
                    {
                        return m_opt <= other.m_opt;
                    }
 
                    bool operator>=(const Gamma &other) const
                    {
                        return m_opt >= other.m_opt;
                    }
 
                    friend std::ostream &operator<<(std::ostream &stream, const Gamma &value)
                    {
                        return stream << value.toString();
                    }
 
                private:
                    void setFromString(const std::string &value);
 
                    constexpr ValueType static verifyValue(const ValueType &value)
                    {
                        return validRange().isInRange(value)
                                   ? value
                                   : throw std::out_of_range{ "Gamma{ " + std::to_string(value) + " } is not in range ["
                                                              + std::to_string(validRange().min()) + ", "
                                                              + std::to_string(validRange().max()) + "]" };
                    }
 
                    Zivid::DataModel::Detail::Optional<double> m_opt;
 
                    friend struct DataModel::Detail::Befriend<Gamma>;
                };
 
                using Descendants = std::tuple<
                    Settings::Processing::Color::Balance,
                    Settings::Processing::Color::Balance::Blue,
                    Settings::Processing::Color::Balance::Green,
                    Settings::Processing::Color::Balance::Red,
                    Settings::Processing::Color::Experimental,
                    Settings::Processing::Color::Experimental::Mode,
                    Settings::Processing::Color::Gamma>;
 
                Color();
 
#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 Color(Args &&...args)
                {
                    using namespace Zivid::Detail::TypeTraits;
 
                    static_assert(
                        AllArgsDecayedAreUnique<Args...>::value,
                        "Found duplicate types among the arguments passed to Color(...). "
                        "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
                Color 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 Balance &balance() const
                {
                    return m_balance;
                }
 
                Balance &balance()
                {
                    return m_balance;
                }
 
                Color &set(const Balance &value)
                {
                    m_balance = value;
                    return *this;
                }
 
                Color &set(const Balance::Blue &value)
                {
                    m_balance.set(value);
                    return *this;
                }
 
                Color &set(const Balance::Green &value)
                {
                    m_balance.set(value);
                    return *this;
                }
 
                Color &set(const Balance::Red &value)
                {
                    m_balance.set(value);
                    return *this;
                }
 
                const Experimental &experimental() const
                {
                    return m_experimental;
                }
 
                Experimental &experimental()
                {
                    return m_experimental;
                }
 
                Color &set(const Experimental &value)
                {
                    m_experimental = value;
                    return *this;
                }
 
                Color &set(const Experimental::Mode &value)
                {
                    m_experimental.set(value);
                    return *this;
                }
 
                const Gamma &gamma() const
                {
                    return m_gamma;
                }
 
                Gamma &gamma()
                {
                    return m_gamma;
                }
 
                Color &set(const Gamma &value)
                {
                    m_gamma = value;
                    return *this;
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance>::value, int>::type =
                        0>
                const Settings::Processing::Color::Balance &get() const
                {
                    return m_balance;
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance::Blue>::value, int>::
                        type = 0>
                const Settings::Processing::Color::Balance::Blue &get() const
                {
                    return m_balance.get<Settings::Processing::Color::Balance::Blue>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance::Green>::value, int>::
                        type = 0>
                const Settings::Processing::Color::Balance::Green &get() const
                {
                    return m_balance.get<Settings::Processing::Color::Balance::Green>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance::Red>::value, int>::
                        type = 0>
                const Settings::Processing::Color::Balance::Red &get() const
                {
                    return m_balance.get<Settings::Processing::Color::Balance::Red>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, Settings::Processing::Color::Experimental>::value, int>::
                        type = 0>
                const Settings::Processing::Color::Experimental &get() const
                {
                    return m_experimental;
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<T, Settings::Processing::Color::Experimental::Mode>::value,
                        int>::type = 0>
                const Settings::Processing::Color::Experimental::Mode &get() const
                {
                    return m_experimental.get<Settings::Processing::Color::Experimental::Mode>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, Settings::Processing::Color::Gamma>::value, int>::type = 0>
                const Settings::Processing::Color::Gamma &get() const
                {
                    return m_gamma;
                }
 
                template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                const Settings::Processing::Color::Balance &get() const
                {
                    return m_balance;
                }
 
                template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
                const Settings::Processing::Color::Experimental &get() const
                {
                    return m_experimental;
                }
 
                template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
                const Settings::Processing::Color::Gamma &get() const
                {
                    return m_gamma;
                }
 
                template<typename F>
                void forEach(const F &f) const
                {
                    f(m_balance);
                    f(m_experimental);
                    f(m_gamma);
                }
 
                template<typename F>
                void forEach(const F &f)
                {
                    f(m_balance);
                    f(m_experimental);
                    f(m_gamma);
                }
 
                bool operator==(const Color &other) const;
 
                bool operator!=(const Color &other) const;
 
                std::string toString() const;
 
                friend std::ostream &operator<<(std::ostream &stream, const Color &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;
 
                Balance m_balance;
                Experimental m_experimental;
                Gamma m_gamma;
 
                friend struct DataModel::Detail::Befriend<Color>;
            };
 
 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT Filters
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
                static constexpr const char *path{ "Processing/Filters" };
 
                static constexpr const char *name{ "Filters" };
 
                static constexpr const char *description{ R"description(Filters)description" };
 
 
                // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                class ZIVID_CORE_EXPORT Cluster
                {
                public:
                    static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
                    static constexpr const char *path{ "Processing/Filters/Cluster" };
 
                    static constexpr const char *name{ "Cluster" };
 
                    static constexpr const char *description{
                        R"description(Removes floating points and isolated clusters from the point cloud.
)description"
                    };
 
 
                    // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                    class ZIVID_CORE_EXPORT Removal
                    {
                    public:
                        static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
                        static constexpr const char *path{ "Processing/Filters/Cluster/Removal" };
 
                        static constexpr const char *name{ "Removal" };
 
                        static constexpr const char *description{ R"description(Removal)description" };
 
 
                        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                        class ZIVID_CORE_EXPORT Enabled
                        {
                        public:
                            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                            static constexpr const char *path{ "Processing/Filters/Cluster/Removal/Enabled" };
 
                            static constexpr const char *name{ "Enabled" };
 
                            static constexpr const char *description{ R"description(Enabled)description" };
 
                            using ValueType = bool;
                            static const Enabled yes; 
                            static const Enabled no;  
 
                            static std::set<bool> validValues()
                            {
                                return { false, true };
                            }
 
                            Enabled() = default;
 
                            explicit constexpr Enabled(bool value)
                                : m_opt{ value }
                            {}
 
                            bool value() const;
 
                            bool hasValue() const;
 
                            void reset();
 
                            std::string toString() const;
 
                            bool operator==(const Enabled &other) const
                            {
                                return m_opt == other.m_opt;
                            }
 
                            bool operator!=(const Enabled &other) const
                            {
                                return m_opt != other.m_opt;
                            }
 
                            friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
                            {
                                return stream << value.toString();
                            }
 
                        private:
                            void setFromString(const std::string &value);
 
                            Zivid::DataModel::Detail::Optional<bool> m_opt;
 
                            friend struct DataModel::Detail::Befriend<Enabled>;
                        };
 
 
                        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                        class ZIVID_CORE_EXPORT MaxNeighborDistance
                        {
                        public:
                            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                            static constexpr const char *path{
                                "Processing/Filters/Cluster/Removal/MaxNeighborDistance"
                            };
 
                            static constexpr const char *name{ "MaxNeighborDistance" };
 
                            static constexpr const char *description{
                                R"description(Maximum normalized distance between neighboring points that are still classified as
belonging to the same cluster. The default value is optimal for most scenes. On messy
scenes turning this setting down helps removing more bad points.
)description"
                            };
 
                            using ValueType = double;
 
                            static constexpr Range<double> validRange()
                            {
                                return { 2.0, 10.0 };
                            }
 
                            MaxNeighborDistance() = default;
 
                            explicit constexpr MaxNeighborDistance(double value)
                                : m_opt{ verifyValue(value) }
                            {}
 
                            double value() const;
 
                            bool hasValue() const;
 
                            void reset();
 
                            std::string toString() const;
 
                            bool operator==(const MaxNeighborDistance &other) const
                            {
                                return m_opt == other.m_opt;
                            }
 
                            bool operator!=(const MaxNeighborDistance &other) const
                            {
                                return m_opt != other.m_opt;
                            }
 
                            bool operator<(const MaxNeighborDistance &other) const
                            {
                                return m_opt < other.m_opt;
                            }
 
                            bool operator>(const MaxNeighborDistance &other) const
                            {
                                return m_opt > other.m_opt;
                            }
 
                            bool operator<=(const MaxNeighborDistance &other) const
                            {
                                return m_opt <= other.m_opt;
                            }
 
                            bool operator>=(const MaxNeighborDistance &other) const
                            {
                                return m_opt >= other.m_opt;
                            }
 
                            friend std::ostream &operator<<(std::ostream &stream, const MaxNeighborDistance &value)
                            {
                                return stream << value.toString();
                            }
 
                        private:
                            void setFromString(const std::string &value);
 
                            constexpr ValueType static verifyValue(const ValueType &value)
                            {
                                return validRange().isInRange(value)
                                           ? value
                                           : throw std::out_of_range{ "MaxNeighborDistance{ " + std::to_string(value)
                                                                      + " } is not in range ["
                                                                      + std::to_string(validRange().min()) + ", "
                                                                      + std::to_string(validRange().max()) + "]" };
                            }
 
                            Zivid::DataModel::Detail::Optional<double> m_opt;
 
                            friend struct DataModel::Detail::Befriend<MaxNeighborDistance>;
                        };
 
 
                        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                        class ZIVID_CORE_EXPORT MinArea
                        {
                        public:
                            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                            static constexpr const char *path{ "Processing/Filters/Cluster/Removal/MinArea" };
 
                            static constexpr const char *name{ "MinArea" };
 
                            static constexpr const char *description{
                                R"description(Clusters with area below this threshold are removed by the filter.
The area is given in mm^2.
)description"
                            };
 
                            using ValueType = double;
 
                            static constexpr Range<double> validRange()
                            {
                                return { 0.0, 1500.0 };
                            }
 
                            MinArea() = default;
 
                            explicit constexpr MinArea(double value)
                                : m_opt{ verifyValue(value) }
                            {}
 
                            double value() const;
 
                            bool hasValue() const;
 
                            void reset();
 
                            std::string toString() const;
 
                            bool operator==(const MinArea &other) const
                            {
                                return m_opt == other.m_opt;
                            }
 
                            bool operator!=(const MinArea &other) const
                            {
                                return m_opt != other.m_opt;
                            }
 
                            bool operator<(const MinArea &other) const
                            {
                                return m_opt < other.m_opt;
                            }
 
                            bool operator>(const MinArea &other) const
                            {
                                return m_opt > other.m_opt;
                            }
 
                            bool operator<=(const MinArea &other) const
                            {
                                return m_opt <= other.m_opt;
                            }
 
                            bool operator>=(const MinArea &other) const
                            {
                                return m_opt >= other.m_opt;
                            }
 
                            friend std::ostream &operator<<(std::ostream &stream, const MinArea &value)
                            {
                                return stream << value.toString();
                            }
 
                        private:
                            void setFromString(const std::string &value);
 
                            constexpr ValueType static verifyValue(const ValueType &value)
                            {
                                return validRange().isInRange(value)
                                           ? value
                                           : throw std::out_of_range{ "MinArea{ " + std::to_string(value)
                                                                      + " } is not in range ["
                                                                      + std::to_string(validRange().min()) + ", "
                                                                      + std::to_string(validRange().max()) + "]" };
                            }
 
                            Zivid::DataModel::Detail::Optional<double> m_opt;
 
                            friend struct DataModel::Detail::Befriend<MinArea>;
                        };
 
                        using Descendants = std::tuple<
                            Settings::Processing::Filters::Cluster::Removal::Enabled,
                            Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance,
                            Settings::Processing::Filters::Cluster::Removal::MinArea>;
 
                        Removal();
 
#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 Removal(Args &&...args)
                        {
                            using namespace Zivid::Detail::TypeTraits;
 
                            static_assert(
                                AllArgsDecayedAreUnique<Args...>::value,
                                "Found duplicate types among the arguments passed to Removal(...). "
                                "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
                        Removal 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 Enabled &isEnabled() const
                        {
                            return m_enabled;
                        }
 
                        Enabled &isEnabled()
                        {
                            return m_enabled;
                        }
 
                        Removal &set(const Enabled &value)
                        {
                            m_enabled = value;
                            return *this;
                        }
 
                        const MaxNeighborDistance &maxNeighborDistance() const
                        {
                            return m_maxNeighborDistance;
                        }
 
                        MaxNeighborDistance &maxNeighborDistance()
                        {
                            return m_maxNeighborDistance;
                        }
 
                        Removal &set(const MaxNeighborDistance &value)
                        {
                            m_maxNeighborDistance = value;
                            return *this;
                        }
 
                        const MinArea &minArea() const
                        {
                            return m_minArea;
                        }
 
                        MinArea &minArea()
                        {
                            return m_minArea;
                        }
 
                        Removal &set(const MinArea &value)
                        {
                            m_minArea = value;
                            return *this;
                        }
 
                        template<
                            typename T,
                            typename std::enable_if<
                                std::is_same<T, Settings::Processing::Filters::Cluster::Removal::Enabled>::value,
                                int>::type = 0>
                        const Settings::Processing::Filters::Cluster::Removal::Enabled &get() const
                        {
                            return m_enabled;
                        }
 
                        template<
                            typename T,
                            typename std::enable_if<
                                std::is_same<T, Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance>::
                                    value,
                                int>::type = 0>
                        const Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance &get() const
                        {
                            return m_maxNeighborDistance;
                        }
 
                        template<
                            typename T,
                            typename std::enable_if<
                                std::is_same<T, Settings::Processing::Filters::Cluster::Removal::MinArea>::value,
                                int>::type = 0>
                        const Settings::Processing::Filters::Cluster::Removal::MinArea &get() const
                        {
                            return m_minArea;
                        }
 
                        template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                        const Settings::Processing::Filters::Cluster::Removal::Enabled &get() const
                        {
                            return m_enabled;
                        }
 
                        template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
                        const Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance &get() const
                        {
                            return m_maxNeighborDistance;
                        }
 
                        template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
                        const Settings::Processing::Filters::Cluster::Removal::MinArea &get() const
                        {
                            return m_minArea;
                        }
 
                        template<typename F>
                        void forEach(const F &f) const
                        {
                            f(m_enabled);
                            f(m_maxNeighborDistance);
                            f(m_minArea);
                        }
 
                        template<typename F>
                        void forEach(const F &f)
                        {
                            f(m_enabled);
                            f(m_maxNeighborDistance);
                            f(m_minArea);
                        }
 
                        bool operator==(const Removal &other) const;
 
                        bool operator!=(const Removal &other) const;
 
                        std::string toString() const;
 
                        friend std::ostream &operator<<(std::ostream &stream, const Removal &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;
 
                        Enabled m_enabled;
                        MaxNeighborDistance m_maxNeighborDistance;
                        MinArea m_minArea;
 
                        friend struct DataModel::Detail::Befriend<Removal>;
                    };
 
                    using Descendants = std::tuple<
                        Settings::Processing::Filters::Cluster::Removal,
                        Settings::Processing::Filters::Cluster::Removal::Enabled,
                        Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance,
                        Settings::Processing::Filters::Cluster::Removal::MinArea>;
 
                    Cluster();
 
#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 Cluster(Args &&...args)
                    {
                        using namespace Zivid::Detail::TypeTraits;
 
                        static_assert(
                            AllArgsDecayedAreUnique<Args...>::value,
                            "Found duplicate types among the arguments passed to Cluster(...). "
                            "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
                    Cluster 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 Removal &removal() const
                    {
                        return m_removal;
                    }
 
                    Removal &removal()
                    {
                        return m_removal;
                    }
 
                    Cluster &set(const Removal &value)
                    {
                        m_removal = value;
                        return *this;
                    }
 
                    Cluster &set(const Removal::Enabled &value)
                    {
                        m_removal.set(value);
                        return *this;
                    }
 
                    Cluster &set(const Removal::MaxNeighborDistance &value)
                    {
                        m_removal.set(value);
                        return *this;
                    }
 
                    Cluster &set(const Removal::MinArea &value)
                    {
                        m_removal.set(value);
                        return *this;
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Filters::Cluster::Removal>::value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Cluster::Removal &get() const
                    {
                        return m_removal;
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Filters::Cluster::Removal::Enabled>::value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Cluster::Removal::Enabled &get() const
                    {
                        return m_removal.get<Settings::Processing::Filters::Cluster::Removal::Enabled>();
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance>::
                                value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance &get() const
                    {
                        return m_removal.get<Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance>();
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Filters::Cluster::Removal::MinArea>::value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Cluster::Removal::MinArea &get() const
                    {
                        return m_removal.get<Settings::Processing::Filters::Cluster::Removal::MinArea>();
                    }
 
                    template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                    const Settings::Processing::Filters::Cluster::Removal &get() const
                    {
                        return m_removal;
                    }
 
                    template<typename F>
                    void forEach(const F &f) const
                    {
                        f(m_removal);
                    }
 
                    template<typename F>
                    void forEach(const F &f)
                    {
                        f(m_removal);
                    }
 
                    bool operator==(const Cluster &other) const;
 
                    bool operator!=(const Cluster &other) const;
 
                    std::string toString() const;
 
                    friend std::ostream &operator<<(std::ostream &stream, const Cluster &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;
 
                    Removal m_removal;
 
                    friend struct DataModel::Detail::Befriend<Cluster>;
                };
 
 
                // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                class ZIVID_CORE_EXPORT Experimental
                {
                public:
                    static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
                    static constexpr const char *path{ "Processing/Filters/Experimental" };
 
                    static constexpr const char *name{ "Experimental" };
 
                    static constexpr const char *description{
                        R"description(Experimental filters. These may be renamed, moved or deleted in the future.)description"
                    };
 
 
                    // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                    class ZIVID_CORE_EXPORT ContrastDistortion
                    {
                    public:
                        static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
                        static constexpr const char *path{ "Processing/Filters/Experimental/ContrastDistortion" };
 
                        static constexpr const char *name{ "ContrastDistortion" };
 
                        static constexpr const char *description{
                            R"description(Corrects artifacts that appear when imaging scenes with large texture gradients
or high contrast. These artifacts are caused by blurring in the lens. The filter
works best when aperture values are chosen such that the camera has quite good focus.
The filter also supports removing the points that experience a large correction.
)description"
                        };
 
 
                        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                        class ZIVID_CORE_EXPORT Correction
                        {
                        public:
                            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
                            static constexpr const char *path{
                                "Processing/Filters/Experimental/ContrastDistortion/Correction"
                            };
 
                            static constexpr const char *name{ "Correction" };
 
                            static constexpr const char *description{ R"description(Correction)description" };
 
 
                            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                            class ZIVID_CORE_EXPORT Enabled
                            {
                            public:
                                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                                static constexpr const char *path{
                                    "Processing/Filters/Experimental/ContrastDistortion/Correction/Enabled"
                                };
 
                                static constexpr const char *name{ "Enabled" };
 
                                static constexpr const char *description{ R"description(Enabled)description" };
 
                                using ValueType = bool;
                                static const Enabled yes; 
                                static const Enabled no;  
 
                                static std::set<bool> validValues()
                                {
                                    return { false, true };
                                }
 
                                Enabled() = default;
 
                                explicit constexpr Enabled(bool value)
                                    : m_opt{ value }
                                {}
 
                                bool value() const;
 
                                bool hasValue() const;
 
                                void reset();
 
                                std::string toString() const;
 
                                bool operator==(const Enabled &other) const
                                {
                                    return m_opt == other.m_opt;
                                }
 
                                bool operator!=(const Enabled &other) const
                                {
                                    return m_opt != other.m_opt;
                                }
 
                                friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
                                {
                                    return stream << value.toString();
                                }
 
                            private:
                                void setFromString(const std::string &value);
 
                                Zivid::DataModel::Detail::Optional<bool> m_opt;
 
                                friend struct DataModel::Detail::Befriend<Enabled>;
                            };
 
 
                            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                            class ZIVID_CORE_EXPORT Strength
                            {
                            public:
                                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                                static constexpr const char *path{
                                    "Processing/Filters/Experimental/ContrastDistortion/Correction/Strength"
                                };
 
                                static constexpr const char *name{ "Strength" };
 
                                static constexpr const char *description{
                                    R"description(Higher values gives more correction.)description"
                                };
 
                                using ValueType = double;
 
                                static constexpr Range<double> validRange()
                                {
                                    return { 0.0, 1.0 };
                                }
 
                                Strength() = default;
 
                                explicit constexpr Strength(double value)
                                    : m_opt{ verifyValue(value) }
                                {}
 
                                double value() const;
 
                                bool hasValue() const;
 
                                void reset();
 
                                std::string toString() const;
 
                                bool operator==(const Strength &other) const
                                {
                                    return m_opt == other.m_opt;
                                }
 
                                bool operator!=(const Strength &other) const
                                {
                                    return m_opt != other.m_opt;
                                }
 
                                bool operator<(const Strength &other) const
                                {
                                    return m_opt < other.m_opt;
                                }
 
                                bool operator>(const Strength &other) const
                                {
                                    return m_opt > other.m_opt;
                                }
 
                                bool operator<=(const Strength &other) const
                                {
                                    return m_opt <= other.m_opt;
                                }
 
                                bool operator>=(const Strength &other) const
                                {
                                    return m_opt >= other.m_opt;
                                }
 
                                friend std::ostream &operator<<(std::ostream &stream, const Strength &value)
                                {
                                    return stream << value.toString();
                                }
 
                            private:
                                void setFromString(const std::string &value);
 
                                constexpr ValueType static verifyValue(const ValueType &value)
                                {
                                    return validRange().isInRange(value)
                                               ? value
                                               : throw std::out_of_range{ "Strength{ " + std::to_string(value)
                                                                          + " } is not in range ["
                                                                          + std::to_string(validRange().min()) + ", "
                                                                          + std::to_string(validRange().max()) + "]" };
                                }
 
                                Zivid::DataModel::Detail::Optional<double> m_opt;
 
                                friend struct DataModel::Detail::Befriend<Strength>;
                            };
 
                            using Descendants = std::tuple<
                                Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled,
                                Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength>;
 
                            Correction();
 
#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 Correction(Args &&...args)
                            {
                                using namespace Zivid::Detail::TypeTraits;
 
                                static_assert(
                                    AllArgsDecayedAreUnique<Args...>::value,
                                    "Found duplicate types among the arguments passed to Correction(...). "
                                    "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
                            Correction 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 Enabled &isEnabled() const
                            {
                                return m_enabled;
                            }
 
                            Enabled &isEnabled()
                            {
                                return m_enabled;
                            }
 
                            Correction &set(const Enabled &value)
                            {
                                m_enabled = value;
                                return *this;
                            }
 
                            const Strength &strength() const
                            {
                                return m_strength;
                            }
 
                            Strength &strength()
                            {
                                return m_strength;
                            }
 
                            Correction &set(const Strength &value)
                            {
                                m_strength = value;
                                return *this;
                            }
 
                            template<
                                typename T,
                                typename std::enable_if<
                                    std::is_same<
                                        T,
                                        Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::
                                            Enabled>::value,
                                    int>::type = 0>
                            const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled &
                            get() const
                            {
                                return m_enabled;
                            }
 
                            template<
                                typename T,
                                typename std::enable_if<
                                    std::is_same<
                                        T,
                                        Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::
                                            Strength>::value,
                                    int>::type = 0>
                            const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength
                                &
                                get() const
                            {
                                return m_strength;
                            }
 
                            template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                            const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled &
                            get() const
                            {
                                return m_enabled;
                            }
 
                            template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
                            const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength
                                &
                                get() const
                            {
                                return m_strength;
                            }
 
                            template<typename F>
                            void forEach(const F &f) const
                            {
                                f(m_enabled);
                                f(m_strength);
                            }
 
                            template<typename F>
                            void forEach(const F &f)
                            {
                                f(m_enabled);
                                f(m_strength);
                            }
 
                            bool operator==(const Correction &other) const;
 
                            bool operator!=(const Correction &other) const;
 
                            std::string toString() const;
 
                            friend std::ostream &operator<<(std::ostream &stream, const Correction &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;
 
                            Enabled m_enabled;
                            Strength m_strength;
 
                            friend struct DataModel::Detail::Befriend<Correction>;
                        };
 
 
                        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                        class ZIVID_CORE_EXPORT Removal
                        {
                        public:
                            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
                            static constexpr const char *path{
                                "Processing/Filters/Experimental/ContrastDistortion/Removal"
                            };
 
                            static constexpr const char *name{ "Removal" };
 
                            static constexpr const char *description{ R"description(Removal)description" };
 
 
                            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                            class ZIVID_CORE_EXPORT Enabled
                            {
                            public:
                                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                                static constexpr const char *path{
                                    "Processing/Filters/Experimental/ContrastDistortion/Removal/Enabled"
                                };
 
                                static constexpr const char *name{ "Enabled" };
 
                                static constexpr const char *description{ R"description(Enabled)description" };
 
                                using ValueType = bool;
                                static const Enabled yes; 
                                static const Enabled no;  
 
                                static std::set<bool> validValues()
                                {
                                    return { false, true };
                                }
 
                                Enabled() = default;
 
                                explicit constexpr Enabled(bool value)
                                    : m_opt{ value }
                                {}
 
                                bool value() const;
 
                                bool hasValue() const;
 
                                void reset();
 
                                std::string toString() const;
 
                                bool operator==(const Enabled &other) const
                                {
                                    return m_opt == other.m_opt;
                                }
 
                                bool operator!=(const Enabled &other) const
                                {
                                    return m_opt != other.m_opt;
                                }
 
                                friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
                                {
                                    return stream << value.toString();
                                }
 
                            private:
                                void setFromString(const std::string &value);
 
                                Zivid::DataModel::Detail::Optional<bool> m_opt;
 
                                friend struct DataModel::Detail::Befriend<Enabled>;
                            };
 
 
                            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                            class ZIVID_CORE_EXPORT Threshold
                            {
                            public:
                                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                                static constexpr const char *path{
                                    "Processing/Filters/Experimental/ContrastDistortion/Removal/Threshold"
                                };
 
                                static constexpr const char *name{ "Threshold" };
 
                                static constexpr const char *description{
                                    R"description(Higher values remove more points.)description"
                                };
 
                                using ValueType = double;
 
                                static constexpr Range<double> validRange()
                                {
                                    return { 0.0, 1.0 };
                                }
 
                                Threshold() = default;
 
                                explicit constexpr Threshold(double value)
                                    : m_opt{ verifyValue(value) }
                                {}
 
                                double value() const;
 
                                bool hasValue() const;
 
                                void reset();
 
                                std::string toString() const;
 
                                bool operator==(const Threshold &other) const
                                {
                                    return m_opt == other.m_opt;
                                }
 
                                bool operator!=(const Threshold &other) const
                                {
                                    return m_opt != other.m_opt;
                                }
 
                                bool operator<(const Threshold &other) const
                                {
                                    return m_opt < other.m_opt;
                                }
 
                                bool operator>(const Threshold &other) const
                                {
                                    return m_opt > other.m_opt;
                                }
 
                                bool operator<=(const Threshold &other) const
                                {
                                    return m_opt <= other.m_opt;
                                }
 
                                bool operator>=(const Threshold &other) const
                                {
                                    return m_opt >= other.m_opt;
                                }
 
                                friend std::ostream &operator<<(std::ostream &stream, const Threshold &value)
                                {
                                    return stream << value.toString();
                                }
 
                            private:
                                void setFromString(const std::string &value);
 
                                constexpr ValueType static verifyValue(const ValueType &value)
                                {
                                    return validRange().isInRange(value)
                                               ? value
                                               : throw std::out_of_range{ "Threshold{ " + std::to_string(value)
                                                                          + " } is not in range ["
                                                                          + std::to_string(validRange().min()) + ", "
                                                                          + std::to_string(validRange().max()) + "]" };
                                }
 
                                Zivid::DataModel::Detail::Optional<double> m_opt;
 
                                friend struct DataModel::Detail::Befriend<Threshold>;
                            };
 
                            using Descendants = std::tuple<
                                Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled,
                                Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold>;
 
                            Removal();
 
#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 Removal(Args &&...args)
                            {
                                using namespace Zivid::Detail::TypeTraits;
 
                                static_assert(
                                    AllArgsDecayedAreUnique<Args...>::value,
                                    "Found duplicate types among the arguments passed to Removal(...). "
                                    "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
                            Removal 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 Enabled &isEnabled() const
                            {
                                return m_enabled;
                            }
 
                            Enabled &isEnabled()
                            {
                                return m_enabled;
                            }
 
                            Removal &set(const Enabled &value)
                            {
                                m_enabled = value;
                                return *this;
                            }
 
                            const Threshold &threshold() const
                            {
                                return m_threshold;
                            }
 
                            Threshold &threshold()
                            {
                                return m_threshold;
                            }
 
                            Removal &set(const Threshold &value)
                            {
                                m_threshold = value;
                                return *this;
                            }
 
                            template<
                                typename T,
                                typename std::enable_if<
                                    std::is_same<
                                        T,
                                        Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::
                                            Enabled>::value,
                                    int>::type = 0>
                            const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled &
                            get() const
                            {
                                return m_enabled;
                            }
 
                            template<
                                typename T,
                                typename std::enable_if<
                                    std::is_same<
                                        T,
                                        Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::
                                            Threshold>::value,
                                    int>::type = 0>
                            const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold &
                            get() const
                            {
                                return m_threshold;
                            }
 
                            template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                            const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled &
                            get() const
                            {
                                return m_enabled;
                            }
 
                            template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
                            const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold &
                            get() const
                            {
                                return m_threshold;
                            }
 
                            template<typename F>
                            void forEach(const F &f) const
                            {
                                f(m_enabled);
                                f(m_threshold);
                            }
 
                            template<typename F>
                            void forEach(const F &f)
                            {
                                f(m_enabled);
                                f(m_threshold);
                            }
 
                            bool operator==(const Removal &other) const;
 
                            bool operator!=(const Removal &other) const;
 
                            std::string toString() const;
 
                            friend std::ostream &operator<<(std::ostream &stream, const Removal &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;
 
                            Enabled m_enabled;
                            Threshold m_threshold;
 
                            friend struct DataModel::Detail::Befriend<Removal>;
                        };
 
                        using Descendants = std::tuple<
                            Settings::Processing::Filters::Experimental::ContrastDistortion::Correction,
                            Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled,
                            Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength,
                            Settings::Processing::Filters::Experimental::ContrastDistortion::Removal,
                            Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled,
                            Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold>;
 
                        ContrastDistortion();
 
#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 ContrastDistortion(Args &&...args)
                        {
                            using namespace Zivid::Detail::TypeTraits;
 
                            static_assert(
                                AllArgsDecayedAreUnique<Args...>::value,
                                "Found duplicate types among the arguments passed to ContrastDistortion(...). "
                                "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
                        ContrastDistortion 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 Correction &correction() const
                        {
                            return m_correction;
                        }
 
                        Correction &correction()
                        {
                            return m_correction;
                        }
 
                        ContrastDistortion &set(const Correction &value)
                        {
                            m_correction = value;
                            return *this;
                        }
 
                        ContrastDistortion &set(const Correction::Enabled &value)
                        {
                            m_correction.set(value);
                            return *this;
                        }
 
                        ContrastDistortion &set(const Correction::Strength &value)
                        {
                            m_correction.set(value);
                            return *this;
                        }
 
                        const Removal &removal() const
                        {
                            return m_removal;
                        }
 
                        Removal &removal()
                        {
                            return m_removal;
                        }
 
                        ContrastDistortion &set(const Removal &value)
                        {
                            m_removal = value;
                            return *this;
                        }
 
                        ContrastDistortion &set(const Removal::Enabled &value)
                        {
                            m_removal.set(value);
                            return *this;
                        }
 
                        ContrastDistortion &set(const Removal::Threshold &value)
                        {
                            m_removal.set(value);
                            return *this;
                        }
 
                        template<
                            typename T,
                            typename std::enable_if<
                                std::is_same<
                                    T,
                                    Settings::Processing::Filters::Experimental::ContrastDistortion::Correction>::value,
                                int>::type = 0>
                        const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction &get() const
                        {
                            return m_correction;
                        }
 
                        template<
                            typename T,
                            typename std::enable_if<
                                std::is_same<
                                    T,
                                    Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::
                                        Enabled>::value,
                                int>::type = 0>
                        const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled &
                        get() const
                        {
                            return m_correction.get<
                                Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled>();
                        }
 
                        template<
                            typename T,
                            typename std::enable_if<
                                std::is_same<
                                    T,
                                    Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::
                                        Strength>::value,
                                int>::type = 0>
                        const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength &
                        get() const
                        {
                            return m_correction.get<Settings::Processing::Filters::Experimental::ContrastDistortion::
                                                        Correction::Strength>();
                        }
 
                        template<
                            typename T,
                            typename std::enable_if<
                                std::is_same<
                                    T,
                                    Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>::value,
                                int>::type = 0>
                        const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal &get() const
                        {
                            return m_removal;
                        }
 
                        template<
                            typename T,
                            typename std::enable_if<
                                std::is_same<
                                    T,
                                    Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled>::
                                    value,
                                int>::type = 0>
                        const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled &get()
                            const
                        {
                            return m_removal.get<
                                Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled>();
                        }
 
                        template<
                            typename T,
                            typename std::enable_if<
                                std::is_same<
                                    T,
                                    Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::
                                        Threshold>::value,
                                int>::type = 0>
                        const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold &get()
                            const
                        {
                            return m_removal.get<
                                Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold>();
                        }
 
                        template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                        const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction &get() const
                        {
                            return m_correction;
                        }
 
                        template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
                        const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal &get() const
                        {
                            return m_removal;
                        }
 
                        template<typename F>
                        void forEach(const F &f) const
                        {
                            f(m_correction);
                            f(m_removal);
                        }
 
                        template<typename F>
                        void forEach(const F &f)
                        {
                            f(m_correction);
                            f(m_removal);
                        }
 
                        bool operator==(const ContrastDistortion &other) const;
 
                        bool operator!=(const ContrastDistortion &other) const;
 
                        std::string toString() const;
 
                        friend std::ostream &operator<<(std::ostream &stream, const ContrastDistortion &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;
 
                        Correction m_correction;
                        Removal m_removal;
 
                        friend struct DataModel::Detail::Befriend<ContrastDistortion>;
                    };
 
 
                    // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                    class ZIVID_CORE_EXPORT HoleFilling
                    {
                    public:
                        static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
                        static constexpr const char *path{ "Processing/Filters/Experimental/HoleFilling" };
 
                        static constexpr const char *name{ "HoleFilling" };
 
                        static constexpr const char *description{
                            R"description(Fills in removed points by interpolating remaining surrounding points.
)description"
                        };
 
 
                        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                        class ZIVID_CORE_EXPORT Enabled
                        {
                        public:
                            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                            static constexpr const char *path{ "Processing/Filters/Experimental/HoleFilling/Enabled" };
 
                            static constexpr const char *name{ "Enabled" };
 
                            static constexpr const char *description{ R"description(Enabled)description" };
 
                            using ValueType = bool;
                            static const Enabled yes; 
                            static const Enabled no;  
 
                            static std::set<bool> validValues()
                            {
                                return { false, true };
                            }
 
                            Enabled() = default;
 
                            explicit constexpr Enabled(bool value)
                                : m_opt{ value }
                            {}
 
                            bool value() const;
 
                            bool hasValue() const;
 
                            void reset();
 
                            std::string toString() const;
 
                            bool operator==(const Enabled &other) const
                            {
                                return m_opt == other.m_opt;
                            }
 
                            bool operator!=(const Enabled &other) const
                            {
                                return m_opt != other.m_opt;
                            }
 
                            friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
                            {
                                return stream << value.toString();
                            }
 
                        private:
                            void setFromString(const std::string &value);
 
                            Zivid::DataModel::Detail::Optional<bool> m_opt;
 
                            friend struct DataModel::Detail::Befriend<Enabled>;
                        };
 
 
                        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                        class ZIVID_CORE_EXPORT HoleSize
                        {
                        public:
                            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                            static constexpr const char *path{ "Processing/Filters/Experimental/HoleFilling/HoleSize" };
 
                            static constexpr const char *name{ "HoleSize" };
 
                            static constexpr const char *description{
                                R"description(Relative diameter of holes to fill. Increasing this will fill more points, but require more
computation time. The maximum allowed hole size scales with distance, so that we allow
filling larger holes at greater distances, measured in mm.
)description"
                            };
 
                            using ValueType = double;
 
                            static constexpr Range<double> validRange()
                            {
                                return { 0.0, 1.0 };
                            }
 
                            HoleSize() = default;
 
                            explicit constexpr HoleSize(double value)
                                : m_opt{ verifyValue(value) }
                            {}
 
                            double value() const;
 
                            bool hasValue() const;
 
                            void reset();
 
                            std::string toString() const;
 
                            bool operator==(const HoleSize &other) const
                            {
                                return m_opt == other.m_opt;
                            }
 
                            bool operator!=(const HoleSize &other) const
                            {
                                return m_opt != other.m_opt;
                            }
 
                            bool operator<(const HoleSize &other) const
                            {
                                return m_opt < other.m_opt;
                            }
 
                            bool operator>(const HoleSize &other) const
                            {
                                return m_opt > other.m_opt;
                            }
 
                            bool operator<=(const HoleSize &other) const
                            {
                                return m_opt <= other.m_opt;
                            }
 
                            bool operator>=(const HoleSize &other) const
                            {
                                return m_opt >= other.m_opt;
                            }
 
                            friend std::ostream &operator<<(std::ostream &stream, const HoleSize &value)
                            {
                                return stream << value.toString();
                            }
 
                        private:
                            void setFromString(const std::string &value);
 
                            constexpr ValueType static verifyValue(const ValueType &value)
                            {
                                return validRange().isInRange(value)
                                           ? value
                                           : throw std::out_of_range{ "HoleSize{ " + std::to_string(value)
                                                                      + " } is not in range ["
                                                                      + std::to_string(validRange().min()) + ", "
                                                                      + std::to_string(validRange().max()) + "]" };
                            }
 
                            Zivid::DataModel::Detail::Optional<double> m_opt;
 
                            friend struct DataModel::Detail::Befriend<HoleSize>;
                        };
 
 
                        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                        class ZIVID_CORE_EXPORT Strictness
                        {
                        public:
                            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                            static constexpr const char *path{
                                "Processing/Filters/Experimental/HoleFilling/Strictness"
                            };
 
                            static constexpr const char *name{ "Strictness" };
 
                            static constexpr const char *description{
                                R"description(Level of strictness when considering if a point should be filled. A higher level of
strictness requires a missing point to be surrounded by valid points on more sides in
order to be filled. Increasing this will fill fewer points, but it will be less likely to
fill gaps that are not circular, for example between two edges.
)description"
                            };
 
                            using ValueType = int32_t;
 
                            static constexpr Range<int32_t> validRange()
                            {
                                return { 1, 4 };
                            }
 
                            Strictness() = default;
 
                            explicit constexpr Strictness(int32_t value)
                                : m_opt{ verifyValue(value) }
                            {}
 
                            int32_t value() const;
 
                            bool hasValue() const;
 
                            void reset();
 
                            std::string toString() const;
 
                            bool operator==(const Strictness &other) const
                            {
                                return m_opt == other.m_opt;
                            }
 
                            bool operator!=(const Strictness &other) const
                            {
                                return m_opt != other.m_opt;
                            }
 
                            bool operator<(const Strictness &other) const
                            {
                                return m_opt < other.m_opt;
                            }
 
                            bool operator>(const Strictness &other) const
                            {
                                return m_opt > other.m_opt;
                            }
 
                            bool operator<=(const Strictness &other) const
                            {
                                return m_opt <= other.m_opt;
                            }
 
                            bool operator>=(const Strictness &other) const
                            {
                                return m_opt >= other.m_opt;
                            }
 
                            friend std::ostream &operator<<(std::ostream &stream, const Strictness &value)
                            {
                                return stream << value.toString();
                            }
 
                        private:
                            void setFromString(const std::string &value);
 
                            constexpr ValueType static verifyValue(const ValueType &value)
                            {
                                return validRange().isInRange(value)
                                           ? value
                                           : throw std::out_of_range{ "Strictness{ " + std::to_string(value)
                                                                      + " } is not in range ["
                                                                      + std::to_string(validRange().min()) + ", "
                                                                      + std::to_string(validRange().max()) + "]" };
                            }
 
                            Zivid::DataModel::Detail::Optional<int32_t> m_opt;
 
                            friend struct DataModel::Detail::Befriend<Strictness>;
                        };
 
                        using Descendants = std::tuple<
                            Settings::Processing::Filters::Experimental::HoleFilling::Enabled,
                            Settings::Processing::Filters::Experimental::HoleFilling::HoleSize,
                            Settings::Processing::Filters::Experimental::HoleFilling::Strictness>;
 
                        HoleFilling();
 
#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 HoleFilling(Args &&...args)
                        {
                            using namespace Zivid::Detail::TypeTraits;
 
                            static_assert(
                                AllArgsDecayedAreUnique<Args...>::value,
                                "Found duplicate types among the arguments passed to HoleFilling(...). "
                                "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
                        HoleFilling 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 Enabled &isEnabled() const
                        {
                            return m_enabled;
                        }
 
                        Enabled &isEnabled()
                        {
                            return m_enabled;
                        }
 
                        HoleFilling &set(const Enabled &value)
                        {
                            m_enabled = value;
                            return *this;
                        }
 
                        const HoleSize &holeSize() const
                        {
                            return m_holeSize;
                        }
 
                        HoleSize &holeSize()
                        {
                            return m_holeSize;
                        }
 
                        HoleFilling &set(const HoleSize &value)
                        {
                            m_holeSize = value;
                            return *this;
                        }
 
                        const Strictness &strictness() const
                        {
                            return m_strictness;
                        }
 
                        Strictness &strictness()
                        {
                            return m_strictness;
                        }
 
                        HoleFilling &set(const Strictness &value)
                        {
                            m_strictness = value;
                            return *this;
                        }
 
                        template<
                            typename T,
                            typename std::enable_if<
                                std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling::Enabled>::
                                    value,
                                int>::type = 0>
                        const Settings::Processing::Filters::Experimental::HoleFilling::Enabled &get() const
                        {
                            return m_enabled;
                        }
 
                        template<
                            typename T,
                            typename std::enable_if<
                                std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling::HoleSize>::
                                    value,
                                int>::type = 0>
                        const Settings::Processing::Filters::Experimental::HoleFilling::HoleSize &get() const
                        {
                            return m_holeSize;
                        }
 
                        template<
                            typename T,
                            typename std::enable_if<
                                std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling::Strictness>::
                                    value,
                                int>::type = 0>
                        const Settings::Processing::Filters::Experimental::HoleFilling::Strictness &get() const
                        {
                            return m_strictness;
                        }
 
                        template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                        const Settings::Processing::Filters::Experimental::HoleFilling::Enabled &get() const
                        {
                            return m_enabled;
                        }
 
                        template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
                        const Settings::Processing::Filters::Experimental::HoleFilling::HoleSize &get() const
                        {
                            return m_holeSize;
                        }
 
                        template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
                        const Settings::Processing::Filters::Experimental::HoleFilling::Strictness &get() const
                        {
                            return m_strictness;
                        }
 
                        template<typename F>
                        void forEach(const F &f) const
                        {
                            f(m_enabled);
                            f(m_holeSize);
                            f(m_strictness);
                        }
 
                        template<typename F>
                        void forEach(const F &f)
                        {
                            f(m_enabled);
                            f(m_holeSize);
                            f(m_strictness);
                        }
 
                        bool operator==(const HoleFilling &other) const;
 
                        bool operator!=(const HoleFilling &other) const;
 
                        std::string toString() const;
 
                        friend std::ostream &operator<<(std::ostream &stream, const HoleFilling &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;
 
                        Enabled m_enabled;
                        HoleSize m_holeSize;
                        Strictness m_strictness;
 
                        friend struct DataModel::Detail::Befriend<HoleFilling>;
                    };
 
                    using Descendants = std::tuple<
                        Settings::Processing::Filters::Experimental::ContrastDistortion,
                        Settings::Processing::Filters::Experimental::ContrastDistortion::Correction,
                        Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled,
                        Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength,
                        Settings::Processing::Filters::Experimental::ContrastDistortion::Removal,
                        Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled,
                        Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold,
                        Settings::Processing::Filters::Experimental::HoleFilling,
                        Settings::Processing::Filters::Experimental::HoleFilling::Enabled,
                        Settings::Processing::Filters::Experimental::HoleFilling::HoleSize,
                        Settings::Processing::Filters::Experimental::HoleFilling::Strictness>;
 
                    Experimental();
 
#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 Experimental(Args &&...args)
                    {
                        using namespace Zivid::Detail::TypeTraits;
 
                        static_assert(
                            AllArgsDecayedAreUnique<Args...>::value,
                            "Found duplicate types among the arguments passed to Experimental(...). "
                            "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
                    Experimental 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 ContrastDistortion &contrastDistortion() const
                    {
                        return m_contrastDistortion;
                    }
 
                    ContrastDistortion &contrastDistortion()
                    {
                        return m_contrastDistortion;
                    }
 
                    Experimental &set(const ContrastDistortion &value)
                    {
                        m_contrastDistortion = value;
                        return *this;
                    }
 
                    Experimental &set(const ContrastDistortion::Correction &value)
                    {
                        m_contrastDistortion.set(value);
                        return *this;
                    }
 
                    Experimental &set(const ContrastDistortion::Correction::Enabled &value)
                    {
                        m_contrastDistortion.set(value);
                        return *this;
                    }
 
                    Experimental &set(const ContrastDistortion::Correction::Strength &value)
                    {
                        m_contrastDistortion.set(value);
                        return *this;
                    }
 
                    Experimental &set(const ContrastDistortion::Removal &value)
                    {
                        m_contrastDistortion.set(value);
                        return *this;
                    }
 
                    Experimental &set(const ContrastDistortion::Removal::Enabled &value)
                    {
                        m_contrastDistortion.set(value);
                        return *this;
                    }
 
                    Experimental &set(const ContrastDistortion::Removal::Threshold &value)
                    {
                        m_contrastDistortion.set(value);
                        return *this;
                    }
 
                    const HoleFilling &holeFilling() const
                    {
                        return m_holeFilling;
                    }
 
                    HoleFilling &holeFilling()
                    {
                        return m_holeFilling;
                    }
 
                    Experimental &set(const HoleFilling &value)
                    {
                        m_holeFilling = value;
                        return *this;
                    }
 
                    Experimental &set(const HoleFilling::Enabled &value)
                    {
                        m_holeFilling.set(value);
                        return *this;
                    }
 
                    Experimental &set(const HoleFilling::HoleSize &value)
                    {
                        m_holeFilling.set(value);
                        return *this;
                    }
 
                    Experimental &set(const HoleFilling::Strictness &value)
                    {
                        m_holeFilling.set(value);
                        return *this;
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion>::value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Experimental::ContrastDistortion &get() const
                    {
                        return m_contrastDistortion;
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<
                                T,
                                Settings::Processing::Filters::Experimental::ContrastDistortion::Correction>::value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction &get() const
                    {
                        return m_contrastDistortion
                            .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Correction>();
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<
                                T,
                                Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled>::
                                value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled &get()
                        const
                    {
                        return m_contrastDistortion.get<
                            Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled>();
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<
                                T,
                                Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength>::
                                value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength &get()
                        const
                    {
                        return m_contrastDistortion.get<
                            Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength>();
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>::
                                value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal &get() const
                    {
                        return m_contrastDistortion
                            .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>();
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<
                                T,
                                Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled>::
                                value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled &get() const
                    {
                        return m_contrastDistortion
                            .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled>();
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<
                                T,
                                Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold>::
                                value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold &get()
                        const
                    {
                        return m_contrastDistortion
                            .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold>();
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling>::value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Experimental::HoleFilling &get() const
                    {
                        return m_holeFilling;
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling::Enabled>::value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Experimental::HoleFilling::Enabled &get() const
                    {
                        return m_holeFilling.get<Settings::Processing::Filters::Experimental::HoleFilling::Enabled>();
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling::HoleSize>::value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Experimental::HoleFilling::HoleSize &get() const
                    {
                        return m_holeFilling.get<Settings::Processing::Filters::Experimental::HoleFilling::HoleSize>();
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling::Strictness>::
                                value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Experimental::HoleFilling::Strictness &get() const
                    {
                        return m_holeFilling
                            .get<Settings::Processing::Filters::Experimental::HoleFilling::Strictness>();
                    }
 
                    template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                    const Settings::Processing::Filters::Experimental::ContrastDistortion &get() const
                    {
                        return m_contrastDistortion;
                    }
 
                    template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
                    const Settings::Processing::Filters::Experimental::HoleFilling &get() const
                    {
                        return m_holeFilling;
                    }
 
                    template<typename F>
                    void forEach(const F &f) const
                    {
                        f(m_contrastDistortion);
                        f(m_holeFilling);
                    }
 
                    template<typename F>
                    void forEach(const F &f)
                    {
                        f(m_contrastDistortion);
                        f(m_holeFilling);
                    }
 
                    bool operator==(const Experimental &other) const;
 
                    bool operator!=(const Experimental &other) const;
 
                    std::string toString() const;
 
                    friend std::ostream &operator<<(std::ostream &stream, const Experimental &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;
 
                    ContrastDistortion m_contrastDistortion;
                    HoleFilling m_holeFilling;
 
                    friend struct DataModel::Detail::Befriend<Experimental>;
                };
 
 
                // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                class ZIVID_CORE_EXPORT Noise
                {
                public:
                    static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
                    static constexpr const char *path{ "Processing/Filters/Noise" };
 
                    static constexpr const char *name{ "Noise" };
 
                    static constexpr const char *description{
                        R"description(Contains filters that can be used to clean up a noisy point cloud)description"
                    };
 
 
                    // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                    class ZIVID_CORE_EXPORT Removal
                    {
                    public:
                        static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
                        static constexpr const char *path{ "Processing/Filters/Noise/Removal" };
 
                        static constexpr const char *name{ "Removal" };
 
                        static constexpr const char *description{
                            R"description(Discard points with signal-to-noise ratio (SNR) values below a threshold)description"
                        };
 
 
                        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                        class ZIVID_CORE_EXPORT Enabled
                        {
                        public:
                            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                            static constexpr const char *path{ "Processing/Filters/Noise/Removal/Enabled" };
 
                            static constexpr const char *name{ "Enabled" };
 
                            static constexpr const char *description{
                                R"description(Enable or disable the SNR filter)description"
                            };
 
                            using ValueType = bool;
                            static const Enabled yes; 
                            static const Enabled no;  
 
                            static std::set<bool> validValues()
                            {
                                return { false, true };
                            }
 
                            Enabled() = default;
 
                            explicit constexpr Enabled(bool value)
                                : m_opt{ value }
                            {}
 
                            bool value() const;
 
                            bool hasValue() const;
 
                            void reset();
 
                            std::string toString() const;
 
                            bool operator==(const Enabled &other) const
                            {
                                return m_opt == other.m_opt;
                            }
 
                            bool operator!=(const Enabled &other) const
                            {
                                return m_opt != other.m_opt;
                            }
 
                            friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
                            {
                                return stream << value.toString();
                            }
 
                        private:
                            void setFromString(const std::string &value);
 
                            Zivid::DataModel::Detail::Optional<bool> m_opt;
 
                            friend struct DataModel::Detail::Befriend<Enabled>;
                        };
 
 
                        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                        class ZIVID_CORE_EXPORT Threshold
                        {
                        public:
                            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                            static constexpr const char *path{ "Processing/Filters/Noise/Removal/Threshold" };
 
                            static constexpr const char *name{ "Threshold" };
 
                            static constexpr const char *description{
                                R"description(Discard points with signal-to-noise ratio (SNR) below the given value)description"
                            };
 
                            using ValueType = double;
 
                            static constexpr Range<double> validRange()
                            {
                                return { 0.0, 100.0 };
                            }
 
                            Threshold() = default;
 
                            explicit constexpr Threshold(double value)
                                : m_opt{ verifyValue(value) }
                            {}
 
                            double value() const;
 
                            bool hasValue() const;
 
                            void reset();
 
                            std::string toString() const;
 
                            bool operator==(const Threshold &other) const
                            {
                                return m_opt == other.m_opt;
                            }
 
                            bool operator!=(const Threshold &other) const
                            {
                                return m_opt != other.m_opt;
                            }
 
                            bool operator<(const Threshold &other) const
                            {
                                return m_opt < other.m_opt;
                            }
 
                            bool operator>(const Threshold &other) const
                            {
                                return m_opt > other.m_opt;
                            }
 
                            bool operator<=(const Threshold &other) const
                            {
                                return m_opt <= other.m_opt;
                            }
 
                            bool operator>=(const Threshold &other) const
                            {
                                return m_opt >= other.m_opt;
                            }
 
                            friend std::ostream &operator<<(std::ostream &stream, const Threshold &value)
                            {
                                return stream << value.toString();
                            }
 
                        private:
                            void setFromString(const std::string &value);
 
                            constexpr ValueType static verifyValue(const ValueType &value)
                            {
                                return validRange().isInRange(value)
                                           ? value
                                           : throw std::out_of_range{ "Threshold{ " + std::to_string(value)
                                                                      + " } is not in range ["
                                                                      + std::to_string(validRange().min()) + ", "
                                                                      + std::to_string(validRange().max()) + "]" };
                            }
 
                            Zivid::DataModel::Detail::Optional<double> m_opt;
 
                            friend struct DataModel::Detail::Befriend<Threshold>;
                        };
 
                        using Descendants = std::tuple<
                            Settings::Processing::Filters::Noise::Removal::Enabled,
                            Settings::Processing::Filters::Noise::Removal::Threshold>;
 
                        Removal();
 
#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 Removal(Args &&...args)
                        {
                            using namespace Zivid::Detail::TypeTraits;
 
                            static_assert(
                                AllArgsDecayedAreUnique<Args...>::value,
                                "Found duplicate types among the arguments passed to Removal(...). "
                                "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
                        Removal 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 Enabled &isEnabled() const
                        {
                            return m_enabled;
                        }
 
                        Enabled &isEnabled()
                        {
                            return m_enabled;
                        }
 
                        Removal &set(const Enabled &value)
                        {
                            m_enabled = value;
                            return *this;
                        }
 
                        const Threshold &threshold() const
                        {
                            return m_threshold;
                        }
 
                        Threshold &threshold()
                        {
                            return m_threshold;
                        }
 
                        Removal &set(const Threshold &value)
                        {
                            m_threshold = value;
                            return *this;
                        }
 
                        template<
                            typename T,
                            typename std::enable_if<
                                std::is_same<T, Settings::Processing::Filters::Noise::Removal::Enabled>::value,
                                int>::type = 0>
                        const Settings::Processing::Filters::Noise::Removal::Enabled &get() const
                        {
                            return m_enabled;
                        }
 
                        template<
                            typename T,
                            typename std::enable_if<
                                std::is_same<T, Settings::Processing::Filters::Noise::Removal::Threshold>::value,
                                int>::type = 0>
                        const Settings::Processing::Filters::Noise::Removal::Threshold &get() const
                        {
                            return m_threshold;
                        }
 
                        template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                        const Settings::Processing::Filters::Noise::Removal::Enabled &get() const
                        {
                            return m_enabled;
                        }
 
                        template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
                        const Settings::Processing::Filters::Noise::Removal::Threshold &get() const
                        {
                            return m_threshold;
                        }
 
                        template<typename F>
                        void forEach(const F &f) const
                        {
                            f(m_enabled);
                            f(m_threshold);
                        }
 
                        template<typename F>
                        void forEach(const F &f)
                        {
                            f(m_enabled);
                            f(m_threshold);
                        }
 
                        bool operator==(const Removal &other) const;
 
                        bool operator!=(const Removal &other) const;
 
                        std::string toString() const;
 
                        friend std::ostream &operator<<(std::ostream &stream, const Removal &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;
 
                        Enabled m_enabled;
                        Threshold m_threshold;
 
                        friend struct DataModel::Detail::Befriend<Removal>;
                    };
 
 
                    // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                    class ZIVID_CORE_EXPORT Repair
                    {
                    public:
                        static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
                        static constexpr const char *path{ "Processing/Filters/Noise/Repair" };
 
                        static constexpr const char *name{ "Repair" };
 
                        static constexpr const char *description{
                            R"description(Get better surface coverage by repairing regions of missing data due to noisy points.
Consider disabling this filter if you require all points in your point cloud to be of
high confidence.
)description"
                        };
 
 
                        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                        class ZIVID_CORE_EXPORT Enabled
                        {
                        public:
                            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                            static constexpr const char *path{ "Processing/Filters/Noise/Repair/Enabled" };
 
                            static constexpr const char *name{ "Enabled" };
 
                            static constexpr const char *description{
                                R"description(Enable or disable noise repair)description"
                            };
 
                            using ValueType = bool;
                            static const Enabled yes; 
                            static const Enabled no;  
 
                            static std::set<bool> validValues()
                            {
                                return { false, true };
                            }
 
                            Enabled() = default;
 
                            explicit constexpr Enabled(bool value)
                                : m_opt{ value }
                            {}
 
                            bool value() const;
 
                            bool hasValue() const;
 
                            void reset();
 
                            std::string toString() const;
 
                            bool operator==(const Enabled &other) const
                            {
                                return m_opt == other.m_opt;
                            }
 
                            bool operator!=(const Enabled &other) const
                            {
                                return m_opt != other.m_opt;
                            }
 
                            friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
                            {
                                return stream << value.toString();
                            }
 
                        private:
                            void setFromString(const std::string &value);
 
                            Zivid::DataModel::Detail::Optional<bool> m_opt;
 
                            friend struct DataModel::Detail::Befriend<Enabled>;
                        };
 
                        using Descendants = std::tuple<Settings::Processing::Filters::Noise::Repair::Enabled>;
 
                        Repair();
 
#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 Repair(Args &&...args)
                        {
                            using namespace Zivid::Detail::TypeTraits;
 
                            static_assert(
                                AllArgsDecayedAreUnique<Args...>::value,
                                "Found duplicate types among the arguments passed to Repair(...). "
                                "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
                        Repair 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 Enabled &isEnabled() const
                        {
                            return m_enabled;
                        }
 
                        Enabled &isEnabled()
                        {
                            return m_enabled;
                        }
 
                        Repair &set(const Enabled &value)
                        {
                            m_enabled = value;
                            return *this;
                        }
 
                        template<
                            typename T,
                            typename std::enable_if<
                                std::is_same<T, Settings::Processing::Filters::Noise::Repair::Enabled>::value,
                                int>::type = 0>
                        const Settings::Processing::Filters::Noise::Repair::Enabled &get() const
                        {
                            return m_enabled;
                        }
 
                        template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                        const Settings::Processing::Filters::Noise::Repair::Enabled &get() const
                        {
                            return m_enabled;
                        }
 
                        template<typename F>
                        void forEach(const F &f) const
                        {
                            f(m_enabled);
                        }
 
                        template<typename F>
                        void forEach(const F &f)
                        {
                            f(m_enabled);
                        }
 
                        bool operator==(const Repair &other) const;
 
                        bool operator!=(const Repair &other) const;
 
                        std::string toString() const;
 
                        friend std::ostream &operator<<(std::ostream &stream, const Repair &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;
 
                        Enabled m_enabled;
 
                        friend struct DataModel::Detail::Befriend<Repair>;
                    };
 
 
                    // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                    class ZIVID_CORE_EXPORT Suppression
                    {
                    public:
                        static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
                        static constexpr const char *path{ "Processing/Filters/Noise/Suppression" };
 
                        static constexpr const char *name{ "Suppression" };
 
                        static constexpr const char *description{
                            R"description(Reduce noise and outliers in the point cloud. This filter can also be used to reduce
ripple effects caused by interreflections. Consider disabling this filter if you need to
distinguish very fine details and thus need to avoid any smoothing effects.
)description"
                        };
 
 
                        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                        class ZIVID_CORE_EXPORT Enabled
                        {
                        public:
                            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                            static constexpr const char *path{ "Processing/Filters/Noise/Suppression/Enabled" };
 
                            static constexpr const char *name{ "Enabled" };
 
                            static constexpr const char *description{
                                R"description(Enable or disable noise suppression)description"
                            };
 
                            using ValueType = bool;
                            static const Enabled yes; 
                            static const Enabled no;  
 
                            static std::set<bool> validValues()
                            {
                                return { false, true };
                            }
 
                            Enabled() = default;
 
                            explicit constexpr Enabled(bool value)
                                : m_opt{ value }
                            {}
 
                            bool value() const;
 
                            bool hasValue() const;
 
                            void reset();
 
                            std::string toString() const;
 
                            bool operator==(const Enabled &other) const
                            {
                                return m_opt == other.m_opt;
                            }
 
                            bool operator!=(const Enabled &other) const
                            {
                                return m_opt != other.m_opt;
                            }
 
                            friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
                            {
                                return stream << value.toString();
                            }
 
                        private:
                            void setFromString(const std::string &value);
 
                            Zivid::DataModel::Detail::Optional<bool> m_opt;
 
                            friend struct DataModel::Detail::Befriend<Enabled>;
                        };
 
                        using Descendants = std::tuple<Settings::Processing::Filters::Noise::Suppression::Enabled>;
 
                        Suppression();
 
#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 Suppression(Args &&...args)
                        {
                            using namespace Zivid::Detail::TypeTraits;
 
                            static_assert(
                                AllArgsDecayedAreUnique<Args...>::value,
                                "Found duplicate types among the arguments passed to Suppression(...). "
                                "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
                        Suppression 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 Enabled &isEnabled() const
                        {
                            return m_enabled;
                        }
 
                        Enabled &isEnabled()
                        {
                            return m_enabled;
                        }
 
                        Suppression &set(const Enabled &value)
                        {
                            m_enabled = value;
                            return *this;
                        }
 
                        template<
                            typename T,
                            typename std::enable_if<
                                std::is_same<T, Settings::Processing::Filters::Noise::Suppression::Enabled>::value,
                                int>::type = 0>
                        const Settings::Processing::Filters::Noise::Suppression::Enabled &get() const
                        {
                            return m_enabled;
                        }
 
                        template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                        const Settings::Processing::Filters::Noise::Suppression::Enabled &get() const
                        {
                            return m_enabled;
                        }
 
                        template<typename F>
                        void forEach(const F &f) const
                        {
                            f(m_enabled);
                        }
 
                        template<typename F>
                        void forEach(const F &f)
                        {
                            f(m_enabled);
                        }
 
                        bool operator==(const Suppression &other) const;
 
                        bool operator!=(const Suppression &other) const;
 
                        std::string toString() const;
 
                        friend std::ostream &operator<<(std::ostream &stream, const Suppression &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;
 
                        Enabled m_enabled;
 
                        friend struct DataModel::Detail::Befriend<Suppression>;
                    };
 
                    using Descendants = std::tuple<
                        Settings::Processing::Filters::Noise::Removal,
                        Settings::Processing::Filters::Noise::Removal::Enabled,
                        Settings::Processing::Filters::Noise::Removal::Threshold,
                        Settings::Processing::Filters::Noise::Repair,
                        Settings::Processing::Filters::Noise::Repair::Enabled,
                        Settings::Processing::Filters::Noise::Suppression,
                        Settings::Processing::Filters::Noise::Suppression::Enabled>;
 
                    Noise();
 
#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 Noise(Args &&...args)
                    {
                        using namespace Zivid::Detail::TypeTraits;
 
                        static_assert(
                            AllArgsDecayedAreUnique<Args...>::value,
                            "Found duplicate types among the arguments passed to Noise(...). "
                            "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
                    Noise 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 Removal &removal() const
                    {
                        return m_removal;
                    }
 
                    Removal &removal()
                    {
                        return m_removal;
                    }
 
                    Noise &set(const Removal &value)
                    {
                        m_removal = value;
                        return *this;
                    }
 
                    Noise &set(const Removal::Enabled &value)
                    {
                        m_removal.set(value);
                        return *this;
                    }
 
                    Noise &set(const Removal::Threshold &value)
                    {
                        m_removal.set(value);
                        return *this;
                    }
 
                    const Repair &repair() const
                    {
                        return m_repair;
                    }
 
                    Repair &repair()
                    {
                        return m_repair;
                    }
 
                    Noise &set(const Repair &value)
                    {
                        m_repair = value;
                        return *this;
                    }
 
                    Noise &set(const Repair::Enabled &value)
                    {
                        m_repair.set(value);
                        return *this;
                    }
 
                    const Suppression &suppression() const
                    {
                        return m_suppression;
                    }
 
                    Suppression &suppression()
                    {
                        return m_suppression;
                    }
 
                    Noise &set(const Suppression &value)
                    {
                        m_suppression = value;
                        return *this;
                    }
 
                    Noise &set(const Suppression::Enabled &value)
                    {
                        m_suppression.set(value);
                        return *this;
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Filters::Noise::Removal>::value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Noise::Removal &get() const
                    {
                        return m_removal;
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Filters::Noise::Removal::Enabled>::value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Noise::Removal::Enabled &get() const
                    {
                        return m_removal.get<Settings::Processing::Filters::Noise::Removal::Enabled>();
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Filters::Noise::Removal::Threshold>::value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Noise::Removal::Threshold &get() const
                    {
                        return m_removal.get<Settings::Processing::Filters::Noise::Removal::Threshold>();
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Filters::Noise::Repair>::value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Noise::Repair &get() const
                    {
                        return m_repair;
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Filters::Noise::Repair::Enabled>::value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Noise::Repair::Enabled &get() const
                    {
                        return m_repair.get<Settings::Processing::Filters::Noise::Repair::Enabled>();
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Filters::Noise::Suppression>::value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Noise::Suppression &get() const
                    {
                        return m_suppression;
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Filters::Noise::Suppression::Enabled>::value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Noise::Suppression::Enabled &get() const
                    {
                        return m_suppression.get<Settings::Processing::Filters::Noise::Suppression::Enabled>();
                    }
 
                    template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                    const Settings::Processing::Filters::Noise::Removal &get() const
                    {
                        return m_removal;
                    }
 
                    template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
                    const Settings::Processing::Filters::Noise::Repair &get() const
                    {
                        return m_repair;
                    }
 
                    template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
                    const Settings::Processing::Filters::Noise::Suppression &get() const
                    {
                        return m_suppression;
                    }
 
                    template<typename F>
                    void forEach(const F &f) const
                    {
                        f(m_removal);
                        f(m_repair);
                        f(m_suppression);
                    }
 
                    template<typename F>
                    void forEach(const F &f)
                    {
                        f(m_removal);
                        f(m_repair);
                        f(m_suppression);
                    }
 
                    bool operator==(const Noise &other) const;
 
                    bool operator!=(const Noise &other) const;
 
                    std::string toString() const;
 
                    friend std::ostream &operator<<(std::ostream &stream, const Noise &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;
 
                    Removal m_removal;
                    Repair m_repair;
                    Suppression m_suppression;
 
                    friend struct DataModel::Detail::Befriend<Noise>;
                };
 
 
                // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                class ZIVID_CORE_EXPORT Outlier
                {
                public:
                    static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
                    static constexpr const char *path{ "Processing/Filters/Outlier" };
 
                    static constexpr const char *name{ "Outlier" };
 
                    static constexpr const char *description{
                        R"description(Contains a filter that removes points with large Euclidean distance to neighboring points)description"
                    };
 
 
                    // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                    class ZIVID_CORE_EXPORT Removal
                    {
                    public:
                        static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
                        static constexpr const char *path{ "Processing/Filters/Outlier/Removal" };
 
                        static constexpr const char *name{ "Removal" };
 
                        static constexpr const char *description{
                            R"description(Discard point if Euclidean distance to neighboring points is above a threshold)description"
                        };
 
 
                        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                        class ZIVID_CORE_EXPORT Enabled
                        {
                        public:
                            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                            static constexpr const char *path{ "Processing/Filters/Outlier/Removal/Enabled" };
 
                            static constexpr const char *name{ "Enabled" };
 
                            static constexpr const char *description{
                                R"description(Enable or disable the outlier filter)description"
                            };
 
                            using ValueType = bool;
                            static const Enabled yes; 
                            static const Enabled no;  
 
                            static std::set<bool> validValues()
                            {
                                return { false, true };
                            }
 
                            Enabled() = default;
 
                            explicit constexpr Enabled(bool value)
                                : m_opt{ value }
                            {}
 
                            bool value() const;
 
                            bool hasValue() const;
 
                            void reset();
 
                            std::string toString() const;
 
                            bool operator==(const Enabled &other) const
                            {
                                return m_opt == other.m_opt;
                            }
 
                            bool operator!=(const Enabled &other) const
                            {
                                return m_opt != other.m_opt;
                            }
 
                            friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
                            {
                                return stream << value.toString();
                            }
 
                        private:
                            void setFromString(const std::string &value);
 
                            Zivid::DataModel::Detail::Optional<bool> m_opt;
 
                            friend struct DataModel::Detail::Befriend<Enabled>;
                        };
 
 
                        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                        class ZIVID_CORE_EXPORT Threshold
                        {
                        public:
                            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                            static constexpr const char *path{ "Processing/Filters/Outlier/Removal/Threshold" };
 
                            static constexpr const char *name{ "Threshold" };
 
                            static constexpr const char *description{
                                R"description(Discard point if Euclidean distance to neighboring points is above the given value)description"
                            };
 
                            using ValueType = double;
 
                            static constexpr Range<double> validRange()
                            {
                                return { 0.0, 100.0 };
                            }
 
                            Threshold() = default;
 
                            explicit constexpr Threshold(double value)
                                : m_opt{ verifyValue(value) }
                            {}
 
                            double value() const;
 
                            bool hasValue() const;
 
                            void reset();
 
                            std::string toString() const;
 
                            bool operator==(const Threshold &other) const
                            {
                                return m_opt == other.m_opt;
                            }
 
                            bool operator!=(const Threshold &other) const
                            {
                                return m_opt != other.m_opt;
                            }
 
                            bool operator<(const Threshold &other) const
                            {
                                return m_opt < other.m_opt;
                            }
 
                            bool operator>(const Threshold &other) const
                            {
                                return m_opt > other.m_opt;
                            }
 
                            bool operator<=(const Threshold &other) const
                            {
                                return m_opt <= other.m_opt;
                            }
 
                            bool operator>=(const Threshold &other) const
                            {
                                return m_opt >= other.m_opt;
                            }
 
                            friend std::ostream &operator<<(std::ostream &stream, const Threshold &value)
                            {
                                return stream << value.toString();
                            }
 
                        private:
                            void setFromString(const std::string &value);
 
                            constexpr ValueType static verifyValue(const ValueType &value)
                            {
                                return validRange().isInRange(value)
                                           ? value
                                           : throw std::out_of_range{ "Threshold{ " + std::to_string(value)
                                                                      + " } is not in range ["
                                                                      + std::to_string(validRange().min()) + ", "
                                                                      + std::to_string(validRange().max()) + "]" };
                            }
 
                            Zivid::DataModel::Detail::Optional<double> m_opt;
 
                            friend struct DataModel::Detail::Befriend<Threshold>;
                        };
 
                        using Descendants = std::tuple<
                            Settings::Processing::Filters::Outlier::Removal::Enabled,
                            Settings::Processing::Filters::Outlier::Removal::Threshold>;
 
                        Removal();
 
#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 Removal(Args &&...args)
                        {
                            using namespace Zivid::Detail::TypeTraits;
 
                            static_assert(
                                AllArgsDecayedAreUnique<Args...>::value,
                                "Found duplicate types among the arguments passed to Removal(...). "
                                "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
                        Removal 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 Enabled &isEnabled() const
                        {
                            return m_enabled;
                        }
 
                        Enabled &isEnabled()
                        {
                            return m_enabled;
                        }
 
                        Removal &set(const Enabled &value)
                        {
                            m_enabled = value;
                            return *this;
                        }
 
                        const Threshold &threshold() const
                        {
                            return m_threshold;
                        }
 
                        Threshold &threshold()
                        {
                            return m_threshold;
                        }
 
                        Removal &set(const Threshold &value)
                        {
                            m_threshold = value;
                            return *this;
                        }
 
                        template<
                            typename T,
                            typename std::enable_if<
                                std::is_same<T, Settings::Processing::Filters::Outlier::Removal::Enabled>::value,
                                int>::type = 0>
                        const Settings::Processing::Filters::Outlier::Removal::Enabled &get() const
                        {
                            return m_enabled;
                        }
 
                        template<
                            typename T,
                            typename std::enable_if<
                                std::is_same<T, Settings::Processing::Filters::Outlier::Removal::Threshold>::value,
                                int>::type = 0>
                        const Settings::Processing::Filters::Outlier::Removal::Threshold &get() const
                        {
                            return m_threshold;
                        }
 
                        template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                        const Settings::Processing::Filters::Outlier::Removal::Enabled &get() const
                        {
                            return m_enabled;
                        }
 
                        template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
                        const Settings::Processing::Filters::Outlier::Removal::Threshold &get() const
                        {
                            return m_threshold;
                        }
 
                        template<typename F>
                        void forEach(const F &f) const
                        {
                            f(m_enabled);
                            f(m_threshold);
                        }
 
                        template<typename F>
                        void forEach(const F &f)
                        {
                            f(m_enabled);
                            f(m_threshold);
                        }
 
                        bool operator==(const Removal &other) const;
 
                        bool operator!=(const Removal &other) const;
 
                        std::string toString() const;
 
                        friend std::ostream &operator<<(std::ostream &stream, const Removal &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;
 
                        Enabled m_enabled;
                        Threshold m_threshold;
 
                        friend struct DataModel::Detail::Befriend<Removal>;
                    };
 
                    using Descendants = std::tuple<
                        Settings::Processing::Filters::Outlier::Removal,
                        Settings::Processing::Filters::Outlier::Removal::Enabled,
                        Settings::Processing::Filters::Outlier::Removal::Threshold>;
 
                    Outlier();
 
#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 Outlier(Args &&...args)
                    {
                        using namespace Zivid::Detail::TypeTraits;
 
                        static_assert(
                            AllArgsDecayedAreUnique<Args...>::value,
                            "Found duplicate types among the arguments passed to Outlier(...). "
                            "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
                    Outlier 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 Removal &removal() const
                    {
                        return m_removal;
                    }
 
                    Removal &removal()
                    {
                        return m_removal;
                    }
 
                    Outlier &set(const Removal &value)
                    {
                        m_removal = value;
                        return *this;
                    }
 
                    Outlier &set(const Removal::Enabled &value)
                    {
                        m_removal.set(value);
                        return *this;
                    }
 
                    Outlier &set(const Removal::Threshold &value)
                    {
                        m_removal.set(value);
                        return *this;
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Filters::Outlier::Removal>::value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Outlier::Removal &get() const
                    {
                        return m_removal;
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Filters::Outlier::Removal::Enabled>::value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Outlier::Removal::Enabled &get() const
                    {
                        return m_removal.get<Settings::Processing::Filters::Outlier::Removal::Enabled>();
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Filters::Outlier::Removal::Threshold>::value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Outlier::Removal::Threshold &get() const
                    {
                        return m_removal.get<Settings::Processing::Filters::Outlier::Removal::Threshold>();
                    }
 
                    template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                    const Settings::Processing::Filters::Outlier::Removal &get() const
                    {
                        return m_removal;
                    }
 
                    template<typename F>
                    void forEach(const F &f) const
                    {
                        f(m_removal);
                    }
 
                    template<typename F>
                    void forEach(const F &f)
                    {
                        f(m_removal);
                    }
 
                    bool operator==(const Outlier &other) const;
 
                    bool operator!=(const Outlier &other) const;
 
                    std::string toString() const;
 
                    friend std::ostream &operator<<(std::ostream &stream, const Outlier &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;
 
                    Removal m_removal;
 
                    friend struct DataModel::Detail::Befriend<Outlier>;
                };
 
 
                // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                class ZIVID_CORE_EXPORT Reflection
                {
                public:
                    static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
                    static constexpr const char *path{ "Processing/Filters/Reflection" };
 
                    static constexpr const char *name{ "Reflection" };
 
                    static constexpr const char *description{
                        R"description(Contains a filter that removes points likely introduced by reflections (useful for shiny materials))description"
                    };
 
 
                    // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                    class ZIVID_CORE_EXPORT Removal
                    {
                    public:
                        static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
                        static constexpr const char *path{ "Processing/Filters/Reflection/Removal" };
 
                        static constexpr const char *name{ "Removal" };
 
                        static constexpr const char *description{
                            R"description(Discard points likely introduced by reflections (useful for shiny materials))description"
                        };
 
 
                        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                        class ZIVID_CORE_EXPORT Enabled
                        {
                        public:
                            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                            static constexpr const char *path{ "Processing/Filters/Reflection/Removal/Enabled" };
 
                            static constexpr const char *name{ "Enabled" };
 
                            static constexpr const char *description{
                                R"description(Enable or disable the reflection filter. Note that this filter is computationally intensive and may affect the frame rate)description"
                            };
 
                            using ValueType = bool;
                            static const Enabled yes; 
                            static const Enabled no;  
 
                            static std::set<bool> validValues()
                            {
                                return { false, true };
                            }
 
                            Enabled() = default;
 
                            explicit constexpr Enabled(bool value)
                                : m_opt{ value }
                            {}
 
                            bool value() const;
 
                            bool hasValue() const;
 
                            void reset();
 
                            std::string toString() const;
 
                            bool operator==(const Enabled &other) const
                            {
                                return m_opt == other.m_opt;
                            }
 
                            bool operator!=(const Enabled &other) const
                            {
                                return m_opt != other.m_opt;
                            }
 
                            friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
                            {
                                return stream << value.toString();
                            }
 
                        private:
                            void setFromString(const std::string &value);
 
                            Zivid::DataModel::Detail::Optional<bool> m_opt;
 
                            friend struct DataModel::Detail::Befriend<Enabled>;
                        };
 
 
                        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                        class ZIVID_CORE_EXPORT Experimental
                        {
                        public:
                            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
                            static constexpr const char *path{ "Processing/Filters/Reflection/Removal/Experimental" };
 
                            static constexpr const char *name{ "Experimental" };
 
                            static constexpr const char *description{
                                R"description(Experimental reflection filter related settings)description"
                            };
 
 
                            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                            class ZIVID_CORE_EXPORT Mode
                            {
                            public:
                                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                                static constexpr const char *path{
                                    "Processing/Filters/Reflection/Removal/Experimental/Mode"
                                };
 
                                static constexpr const char *name{ "Mode" };
 
                                static constexpr const char *description{
                                    R"description(The reflection filter has two modes: Local and Global. Local mode preserves more 3D data
on thinner objects, generally removes more reflection artifacts and processes faster than
the Global filter. The Global filter is generally better at removing outlier points in
the point cloud. It is advised to use the Outlier filter together with the Local
Reflection filter.
 
Global mode was introduced in SDK 1.0 and Local mode was introduced in SDK 2.7.
)description"
                                };
 
                                enum class ValueType
                                {
                                    global,
                                    local
                                };
                                static const Mode global; 
                                static const Mode local;  
 
                                static std::set<ValueType> validValues()
                                {
                                    return { ValueType::global, ValueType::local };
                                }
 
                                Mode() = default;
 
                                explicit constexpr Mode(ValueType value)
                                    : m_opt{ verifyValue(value) }
                                {}
 
                                ValueType value() const;
 
                                bool hasValue() const;
 
                                void reset();
 
                                std::string toString() const;
 
                                friend std::ostream &operator<<(std::ostream &stream, const Mode::ValueType &value)
                                {
                                    return stream << Mode{ value }.toString();
                                }
 
                                bool operator==(const Mode &other) const
                                {
                                    return m_opt == other.m_opt;
                                }
 
                                bool operator!=(const Mode &other) const
                                {
                                    return m_opt != other.m_opt;
                                }
 
                                friend std::ostream &operator<<(std::ostream &stream, const Mode &value)
                                {
                                    return stream << value.toString();
                                }
 
                            private:
                                void setFromString(const std::string &value);
 
                                constexpr ValueType static verifyValue(const ValueType &value)
                                {
                                    return value == ValueType::global || value == ValueType::local
                                               ? value
                                               : throw std::invalid_argument{
                                                     "Invalid value: Mode{ "
                                                     + std::to_string(
                                                         static_cast<std::underlying_type<ValueType>::type>(value))
                                                     + " }"
                                                 };
                                }
 
                                Zivid::DataModel::Detail::Optional<ValueType> m_opt;
 
                                friend struct DataModel::Detail::Befriend<Mode>;
                            };
 
                            using Descendants =
                                std::tuple<Settings::Processing::Filters::Reflection::Removal::Experimental::Mode>;
 
                            Experimental();
 
#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 Experimental(Args &&...args)
                            {
                                using namespace Zivid::Detail::TypeTraits;
 
                                static_assert(
                                    AllArgsDecayedAreUnique<Args...>::value,
                                    "Found duplicate types among the arguments passed to Experimental(...). "
                                    "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
                            Experimental 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 Mode &mode() const
                            {
                                return m_mode;
                            }
 
                            Mode &mode()
                            {
                                return m_mode;
                            }
 
                            Experimental &set(const Mode &value)
                            {
                                m_mode = value;
                                return *this;
                            }
 
                            template<
                                typename T,
                                typename std::enable_if<
                                    std::is_same<
                                        T,
                                        Settings::Processing::Filters::Reflection::Removal::Experimental::Mode>::value,
                                    int>::type = 0>
                            const Settings::Processing::Filters::Reflection::Removal::Experimental::Mode &get() const
                            {
                                return m_mode;
                            }
 
                            template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                            const Settings::Processing::Filters::Reflection::Removal::Experimental::Mode &get() const
                            {
                                return m_mode;
                            }
 
                            template<typename F>
                            void forEach(const F &f) const
                            {
                                f(m_mode);
                            }
 
                            template<typename F>
                            void forEach(const F &f)
                            {
                                f(m_mode);
                            }
 
                            bool operator==(const Experimental &other) const;
 
                            bool operator!=(const Experimental &other) const;
 
                            std::string toString() const;
 
                            friend std::ostream &operator<<(std::ostream &stream, const Experimental &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;
 
                            Mode m_mode;
 
                            friend struct DataModel::Detail::Befriend<Experimental>;
                        };
 
                        using Descendants = std::tuple<
                            Settings::Processing::Filters::Reflection::Removal::Enabled,
                            Settings::Processing::Filters::Reflection::Removal::Experimental,
                            Settings::Processing::Filters::Reflection::Removal::Experimental::Mode>;
 
                        Removal();
 
#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 Removal(Args &&...args)
                        {
                            using namespace Zivid::Detail::TypeTraits;
 
                            static_assert(
                                AllArgsDecayedAreUnique<Args...>::value,
                                "Found duplicate types among the arguments passed to Removal(...). "
                                "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
                        Removal 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 Enabled &isEnabled() const
                        {
                            return m_enabled;
                        }
 
                        Enabled &isEnabled()
                        {
                            return m_enabled;
                        }
 
                        Removal &set(const Enabled &value)
                        {
                            m_enabled = value;
                            return *this;
                        }
 
                        const Experimental &experimental() const
                        {
                            return m_experimental;
                        }
 
                        Experimental &experimental()
                        {
                            return m_experimental;
                        }
 
                        Removal &set(const Experimental &value)
                        {
                            m_experimental = value;
                            return *this;
                        }
 
                        Removal &set(const Experimental::Mode &value)
                        {
                            m_experimental.set(value);
                            return *this;
                        }
 
                        template<
                            typename T,
                            typename std::enable_if<
                                std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Enabled>::value,
                                int>::type = 0>
                        const Settings::Processing::Filters::Reflection::Removal::Enabled &get() const
                        {
                            return m_enabled;
                        }
 
                        template<
                            typename T,
                            typename std::enable_if<
                                std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Experimental>::
                                    value,
                                int>::type = 0>
                        const Settings::Processing::Filters::Reflection::Removal::Experimental &get() const
                        {
                            return m_experimental;
                        }
 
                        template<
                            typename T,
                            typename std::enable_if<
                                std::is_same<
                                    T,
                                    Settings::Processing::Filters::Reflection::Removal::Experimental::Mode>::value,
                                int>::type = 0>
                        const Settings::Processing::Filters::Reflection::Removal::Experimental::Mode &get() const
                        {
                            return m_experimental
                                .get<Settings::Processing::Filters::Reflection::Removal::Experimental::Mode>();
                        }
 
                        template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                        const Settings::Processing::Filters::Reflection::Removal::Enabled &get() const
                        {
                            return m_enabled;
                        }
 
                        template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
                        const Settings::Processing::Filters::Reflection::Removal::Experimental &get() const
                        {
                            return m_experimental;
                        }
 
                        template<typename F>
                        void forEach(const F &f) const
                        {
                            f(m_enabled);
                            f(m_experimental);
                        }
 
                        template<typename F>
                        void forEach(const F &f)
                        {
                            f(m_enabled);
                            f(m_experimental);
                        }
 
                        bool operator==(const Removal &other) const;
 
                        bool operator!=(const Removal &other) const;
 
                        std::string toString() const;
 
                        friend std::ostream &operator<<(std::ostream &stream, const Removal &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;
 
                        Enabled m_enabled;
                        Experimental m_experimental;
 
                        friend struct DataModel::Detail::Befriend<Removal>;
                    };
 
                    using Descendants = std::tuple<
                        Settings::Processing::Filters::Reflection::Removal,
                        Settings::Processing::Filters::Reflection::Removal::Enabled,
                        Settings::Processing::Filters::Reflection::Removal::Experimental,
                        Settings::Processing::Filters::Reflection::Removal::Experimental::Mode>;
 
                    Reflection();
 
#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 Reflection(Args &&...args)
                    {
                        using namespace Zivid::Detail::TypeTraits;
 
                        static_assert(
                            AllArgsDecayedAreUnique<Args...>::value,
                            "Found duplicate types among the arguments passed to Reflection(...). "
                            "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
                    Reflection 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 Removal &removal() const
                    {
                        return m_removal;
                    }
 
                    Removal &removal()
                    {
                        return m_removal;
                    }
 
                    Reflection &set(const Removal &value)
                    {
                        m_removal = value;
                        return *this;
                    }
 
                    Reflection &set(const Removal::Enabled &value)
                    {
                        m_removal.set(value);
                        return *this;
                    }
 
                    Reflection &set(const Removal::Experimental &value)
                    {
                        m_removal.set(value);
                        return *this;
                    }
 
                    Reflection &set(const Removal::Experimental::Mode &value)
                    {
                        m_removal.set(value);
                        return *this;
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Filters::Reflection::Removal>::value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Reflection::Removal &get() const
                    {
                        return m_removal;
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Enabled>::value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Reflection::Removal::Enabled &get() const
                    {
                        return m_removal.get<Settings::Processing::Filters::Reflection::Removal::Enabled>();
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Experimental>::value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Reflection::Removal::Experimental &get() const
                    {
                        return m_removal.get<Settings::Processing::Filters::Reflection::Removal::Experimental>();
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Experimental::Mode>::
                                value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Reflection::Removal::Experimental::Mode &get() const
                    {
                        return m_removal.get<Settings::Processing::Filters::Reflection::Removal::Experimental::Mode>();
                    }
 
                    template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                    const Settings::Processing::Filters::Reflection::Removal &get() const
                    {
                        return m_removal;
                    }
 
                    template<typename F>
                    void forEach(const F &f) const
                    {
                        f(m_removal);
                    }
 
                    template<typename F>
                    void forEach(const F &f)
                    {
                        f(m_removal);
                    }
 
                    bool operator==(const Reflection &other) const;
 
                    bool operator!=(const Reflection &other) const;
 
                    std::string toString() const;
 
                    friend std::ostream &operator<<(std::ostream &stream, const Reflection &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;
 
                    Removal m_removal;
 
                    friend struct DataModel::Detail::Befriend<Reflection>;
                };
 
 
                // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                class ZIVID_CORE_EXPORT Smoothing
                {
                public:
                    static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
                    static constexpr const char *path{ "Processing/Filters/Smoothing" };
 
                    static constexpr const char *name{ "Smoothing" };
 
                    static constexpr const char *description{ R"description(Smoothing filters)description" };
 
 
                    // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                    class ZIVID_CORE_EXPORT Gaussian
                    {
                    public:
                        static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
                        static constexpr const char *path{ "Processing/Filters/Smoothing/Gaussian" };
 
                        static constexpr const char *name{ "Gaussian" };
 
                        static constexpr const char *description{
                            R"description(Gaussian smoothing of the point cloud)description"
                        };
 
 
                        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                        class ZIVID_CORE_EXPORT Enabled
                        {
                        public:
                            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                            static constexpr const char *path{ "Processing/Filters/Smoothing/Gaussian/Enabled" };
 
                            static constexpr const char *name{ "Enabled" };
 
                            static constexpr const char *description{
                                R"description(Enable or disable the smoothing filter)description"
                            };
 
                            using ValueType = bool;
                            static const Enabled yes; 
                            static const Enabled no;  
 
                            static std::set<bool> validValues()
                            {
                                return { false, true };
                            }
 
                            Enabled() = default;
 
                            explicit constexpr Enabled(bool value)
                                : m_opt{ value }
                            {}
 
                            bool value() const;
 
                            bool hasValue() const;
 
                            void reset();
 
                            std::string toString() const;
 
                            bool operator==(const Enabled &other) const
                            {
                                return m_opt == other.m_opt;
                            }
 
                            bool operator!=(const Enabled &other) const
                            {
                                return m_opt != other.m_opt;
                            }
 
                            friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
                            {
                                return stream << value.toString();
                            }
 
                        private:
                            void setFromString(const std::string &value);
 
                            Zivid::DataModel::Detail::Optional<bool> m_opt;
 
                            friend struct DataModel::Detail::Befriend<Enabled>;
                        };
 
 
                        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                        class ZIVID_CORE_EXPORT Sigma
                        {
                        public:
                            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                            static constexpr const char *path{ "Processing/Filters/Smoothing/Gaussian/Sigma" };
 
                            static constexpr const char *name{ "Sigma" };
 
                            static constexpr const char *description{
                                R"description(Higher values result in smoother point clouds (Standard deviation of the filter coefficients))description"
                            };
 
                            using ValueType = double;
 
                            static constexpr Range<double> validRange()
                            {
                                return { 0.5, 5 };
                            }
 
                            Sigma() = default;
 
                            explicit constexpr Sigma(double value)
                                : m_opt{ verifyValue(value) }
                            {}
 
                            double value() const;
 
                            bool hasValue() const;
 
                            void reset();
 
                            std::string toString() const;
 
                            bool operator==(const Sigma &other) const
                            {
                                return m_opt == other.m_opt;
                            }
 
                            bool operator!=(const Sigma &other) const
                            {
                                return m_opt != other.m_opt;
                            }
 
                            bool operator<(const Sigma &other) const
                            {
                                return m_opt < other.m_opt;
                            }
 
                            bool operator>(const Sigma &other) const
                            {
                                return m_opt > other.m_opt;
                            }
 
                            bool operator<=(const Sigma &other) const
                            {
                                return m_opt <= other.m_opt;
                            }
 
                            bool operator>=(const Sigma &other) const
                            {
                                return m_opt >= other.m_opt;
                            }
 
                            friend std::ostream &operator<<(std::ostream &stream, const Sigma &value)
                            {
                                return stream << value.toString();
                            }
 
                        private:
                            void setFromString(const std::string &value);
 
                            constexpr ValueType static verifyValue(const ValueType &value)
                            {
                                return validRange().isInRange(value)
                                           ? value
                                           : throw std::out_of_range{ "Sigma{ " + std::to_string(value)
                                                                      + " } is not in range ["
                                                                      + std::to_string(validRange().min()) + ", "
                                                                      + std::to_string(validRange().max()) + "]" };
                            }
 
                            Zivid::DataModel::Detail::Optional<double> m_opt;
 
                            friend struct DataModel::Detail::Befriend<Sigma>;
                        };
 
                        using Descendants = std::tuple<
                            Settings::Processing::Filters::Smoothing::Gaussian::Enabled,
                            Settings::Processing::Filters::Smoothing::Gaussian::Sigma>;
 
                        Gaussian();
 
#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 Gaussian(Args &&...args)
                        {
                            using namespace Zivid::Detail::TypeTraits;
 
                            static_assert(
                                AllArgsDecayedAreUnique<Args...>::value,
                                "Found duplicate types among the arguments passed to Gaussian(...). "
                                "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
                        Gaussian 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 Enabled &isEnabled() const
                        {
                            return m_enabled;
                        }
 
                        Enabled &isEnabled()
                        {
                            return m_enabled;
                        }
 
                        Gaussian &set(const Enabled &value)
                        {
                            m_enabled = value;
                            return *this;
                        }
 
                        const Sigma &sigma() const
                        {
                            return m_sigma;
                        }
 
                        Sigma &sigma()
                        {
                            return m_sigma;
                        }
 
                        Gaussian &set(const Sigma &value)
                        {
                            m_sigma = value;
                            return *this;
                        }
 
                        template<
                            typename T,
                            typename std::enable_if<
                                std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian::Enabled>::value,
                                int>::type = 0>
                        const Settings::Processing::Filters::Smoothing::Gaussian::Enabled &get() const
                        {
                            return m_enabled;
                        }
 
                        template<
                            typename T,
                            typename std::enable_if<
                                std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian::Sigma>::value,
                                int>::type = 0>
                        const Settings::Processing::Filters::Smoothing::Gaussian::Sigma &get() const
                        {
                            return m_sigma;
                        }
 
                        template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                        const Settings::Processing::Filters::Smoothing::Gaussian::Enabled &get() const
                        {
                            return m_enabled;
                        }
 
                        template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
                        const Settings::Processing::Filters::Smoothing::Gaussian::Sigma &get() const
                        {
                            return m_sigma;
                        }
 
                        template<typename F>
                        void forEach(const F &f) const
                        {
                            f(m_enabled);
                            f(m_sigma);
                        }
 
                        template<typename F>
                        void forEach(const F &f)
                        {
                            f(m_enabled);
                            f(m_sigma);
                        }
 
                        bool operator==(const Gaussian &other) const;
 
                        bool operator!=(const Gaussian &other) const;
 
                        std::string toString() const;
 
                        friend std::ostream &operator<<(std::ostream &stream, const Gaussian &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;
 
                        Enabled m_enabled;
                        Sigma m_sigma;
 
                        friend struct DataModel::Detail::Befriend<Gaussian>;
                    };
 
                    using Descendants = std::tuple<
                        Settings::Processing::Filters::Smoothing::Gaussian,
                        Settings::Processing::Filters::Smoothing::Gaussian::Enabled,
                        Settings::Processing::Filters::Smoothing::Gaussian::Sigma>;
 
                    Smoothing();
 
#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 Smoothing(Args &&...args)
                    {
                        using namespace Zivid::Detail::TypeTraits;
 
                        static_assert(
                            AllArgsDecayedAreUnique<Args...>::value,
                            "Found duplicate types among the arguments passed to Smoothing(...). "
                            "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
                    Smoothing 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 Gaussian &gaussian() const
                    {
                        return m_gaussian;
                    }
 
                    Gaussian &gaussian()
                    {
                        return m_gaussian;
                    }
 
                    Smoothing &set(const Gaussian &value)
                    {
                        m_gaussian = value;
                        return *this;
                    }
 
                    Smoothing &set(const Gaussian::Enabled &value)
                    {
                        m_gaussian.set(value);
                        return *this;
                    }
 
                    Smoothing &set(const Gaussian::Sigma &value)
                    {
                        m_gaussian.set(value);
                        return *this;
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian>::value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Smoothing::Gaussian &get() const
                    {
                        return m_gaussian;
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian::Enabled>::value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Smoothing::Gaussian::Enabled &get() const
                    {
                        return m_gaussian.get<Settings::Processing::Filters::Smoothing::Gaussian::Enabled>();
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian::Sigma>::value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Smoothing::Gaussian::Sigma &get() const
                    {
                        return m_gaussian.get<Settings::Processing::Filters::Smoothing::Gaussian::Sigma>();
                    }
 
                    template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                    const Settings::Processing::Filters::Smoothing::Gaussian &get() const
                    {
                        return m_gaussian;
                    }
 
                    template<typename F>
                    void forEach(const F &f) const
                    {
                        f(m_gaussian);
                    }
 
                    template<typename F>
                    void forEach(const F &f)
                    {
                        f(m_gaussian);
                    }
 
                    bool operator==(const Smoothing &other) const;
 
                    bool operator!=(const Smoothing &other) const;
 
                    std::string toString() const;
 
                    friend std::ostream &operator<<(std::ostream &stream, const Smoothing &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;
 
                    Gaussian m_gaussian;
 
                    friend struct DataModel::Detail::Befriend<Smoothing>;
                };
 
                using Descendants = std::tuple<
                    Settings::Processing::Filters::Cluster,
                    Settings::Processing::Filters::Cluster::Removal,
                    Settings::Processing::Filters::Cluster::Removal::Enabled,
                    Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance,
                    Settings::Processing::Filters::Cluster::Removal::MinArea,
                    Settings::Processing::Filters::Experimental,
                    Settings::Processing::Filters::Experimental::ContrastDistortion,
                    Settings::Processing::Filters::Experimental::ContrastDistortion::Correction,
                    Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled,
                    Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength,
                    Settings::Processing::Filters::Experimental::ContrastDistortion::Removal,
                    Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled,
                    Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold,
                    Settings::Processing::Filters::Experimental::HoleFilling,
                    Settings::Processing::Filters::Experimental::HoleFilling::Enabled,
                    Settings::Processing::Filters::Experimental::HoleFilling::HoleSize,
                    Settings::Processing::Filters::Experimental::HoleFilling::Strictness,
                    Settings::Processing::Filters::Noise,
                    Settings::Processing::Filters::Noise::Removal,
                    Settings::Processing::Filters::Noise::Removal::Enabled,
                    Settings::Processing::Filters::Noise::Removal::Threshold,
                    Settings::Processing::Filters::Noise::Repair,
                    Settings::Processing::Filters::Noise::Repair::Enabled,
                    Settings::Processing::Filters::Noise::Suppression,
                    Settings::Processing::Filters::Noise::Suppression::Enabled,
                    Settings::Processing::Filters::Outlier,
                    Settings::Processing::Filters::Outlier::Removal,
                    Settings::Processing::Filters::Outlier::Removal::Enabled,
                    Settings::Processing::Filters::Outlier::Removal::Threshold,
                    Settings::Processing::Filters::Reflection,
                    Settings::Processing::Filters::Reflection::Removal,
                    Settings::Processing::Filters::Reflection::Removal::Enabled,
                    Settings::Processing::Filters::Reflection::Removal::Experimental,
                    Settings::Processing::Filters::Reflection::Removal::Experimental::Mode,
                    Settings::Processing::Filters::Smoothing,
                    Settings::Processing::Filters::Smoothing::Gaussian,
                    Settings::Processing::Filters::Smoothing::Gaussian::Enabled,
                    Settings::Processing::Filters::Smoothing::Gaussian::Sigma>;
 
                Filters();
 
#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 Filters(Args &&...args)
                {
                    using namespace Zivid::Detail::TypeTraits;
 
                    static_assert(
                        AllArgsDecayedAreUnique<Args...>::value,
                        "Found duplicate types among the arguments passed to Filters(...). "
                        "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
                Filters 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 Cluster &cluster() const
                {
                    return m_cluster;
                }
 
                Cluster &cluster()
                {
                    return m_cluster;
                }
 
                Filters &set(const Cluster &value)
                {
                    m_cluster = value;
                    return *this;
                }
 
                Filters &set(const Cluster::Removal &value)
                {
                    m_cluster.set(value);
                    return *this;
                }
 
                Filters &set(const Cluster::Removal::Enabled &value)
                {
                    m_cluster.set(value);
                    return *this;
                }
 
                Filters &set(const Cluster::Removal::MaxNeighborDistance &value)
                {
                    m_cluster.set(value);
                    return *this;
                }
 
                Filters &set(const Cluster::Removal::MinArea &value)
                {
                    m_cluster.set(value);
                    return *this;
                }
 
                const Experimental &experimental() const
                {
                    return m_experimental;
                }
 
                Experimental &experimental()
                {
                    return m_experimental;
                }
 
                Filters &set(const Experimental &value)
                {
                    m_experimental = value;
                    return *this;
                }
 
                Filters &set(const Experimental::ContrastDistortion &value)
                {
                    m_experimental.set(value);
                    return *this;
                }
 
                Filters &set(const Experimental::ContrastDistortion::Correction &value)
                {
                    m_experimental.set(value);
                    return *this;
                }
 
                Filters &set(const Experimental::ContrastDistortion::Correction::Enabled &value)
                {
                    m_experimental.set(value);
                    return *this;
                }
 
                Filters &set(const Experimental::ContrastDistortion::Correction::Strength &value)
                {
                    m_experimental.set(value);
                    return *this;
                }
 
                Filters &set(const Experimental::ContrastDistortion::Removal &value)
                {
                    m_experimental.set(value);
                    return *this;
                }
 
                Filters &set(const Experimental::ContrastDistortion::Removal::Enabled &value)
                {
                    m_experimental.set(value);
                    return *this;
                }
 
                Filters &set(const Experimental::ContrastDistortion::Removal::Threshold &value)
                {
                    m_experimental.set(value);
                    return *this;
                }
 
                Filters &set(const Experimental::HoleFilling &value)
                {
                    m_experimental.set(value);
                    return *this;
                }
 
                Filters &set(const Experimental::HoleFilling::Enabled &value)
                {
                    m_experimental.set(value);
                    return *this;
                }
 
                Filters &set(const Experimental::HoleFilling::HoleSize &value)
                {
                    m_experimental.set(value);
                    return *this;
                }
 
                Filters &set(const Experimental::HoleFilling::Strictness &value)
                {
                    m_experimental.set(value);
                    return *this;
                }
 
                const Noise &noise() const
                {
                    return m_noise;
                }
 
                Noise &noise()
                {
                    return m_noise;
                }
 
                Filters &set(const Noise &value)
                {
                    m_noise = value;
                    return *this;
                }
 
                Filters &set(const Noise::Removal &value)
                {
                    m_noise.set(value);
                    return *this;
                }
 
                Filters &set(const Noise::Removal::Enabled &value)
                {
                    m_noise.set(value);
                    return *this;
                }
 
                Filters &set(const Noise::Removal::Threshold &value)
                {
                    m_noise.set(value);
                    return *this;
                }
 
                Filters &set(const Noise::Repair &value)
                {
                    m_noise.set(value);
                    return *this;
                }
 
                Filters &set(const Noise::Repair::Enabled &value)
                {
                    m_noise.set(value);
                    return *this;
                }
 
                Filters &set(const Noise::Suppression &value)
                {
                    m_noise.set(value);
                    return *this;
                }
 
                Filters &set(const Noise::Suppression::Enabled &value)
                {
                    m_noise.set(value);
                    return *this;
                }
 
                const Outlier &outlier() const
                {
                    return m_outlier;
                }
 
                Outlier &outlier()
                {
                    return m_outlier;
                }
 
                Filters &set(const Outlier &value)
                {
                    m_outlier = value;
                    return *this;
                }
 
                Filters &set(const Outlier::Removal &value)
                {
                    m_outlier.set(value);
                    return *this;
                }
 
                Filters &set(const Outlier::Removal::Enabled &value)
                {
                    m_outlier.set(value);
                    return *this;
                }
 
                Filters &set(const Outlier::Removal::Threshold &value)
                {
                    m_outlier.set(value);
                    return *this;
                }
 
                const Reflection &reflection() const
                {
                    return m_reflection;
                }
 
                Reflection &reflection()
                {
                    return m_reflection;
                }
 
                Filters &set(const Reflection &value)
                {
                    m_reflection = value;
                    return *this;
                }
 
                Filters &set(const Reflection::Removal &value)
                {
                    m_reflection.set(value);
                    return *this;
                }
 
                Filters &set(const Reflection::Removal::Enabled &value)
                {
                    m_reflection.set(value);
                    return *this;
                }
 
                Filters &set(const Reflection::Removal::Experimental &value)
                {
                    m_reflection.set(value);
                    return *this;
                }
 
                Filters &set(const Reflection::Removal::Experimental::Mode &value)
                {
                    m_reflection.set(value);
                    return *this;
                }
 
                const Smoothing &smoothing() const
                {
                    return m_smoothing;
                }
 
                Smoothing &smoothing()
                {
                    return m_smoothing;
                }
 
                Filters &set(const Smoothing &value)
                {
                    m_smoothing = value;
                    return *this;
                }
 
                Filters &set(const Smoothing::Gaussian &value)
                {
                    m_smoothing.set(value);
                    return *this;
                }
 
                Filters &set(const Smoothing::Gaussian::Enabled &value)
                {
                    m_smoothing.set(value);
                    return *this;
                }
 
                Filters &set(const Smoothing::Gaussian::Sigma &value)
                {
                    m_smoothing.set(value);
                    return *this;
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Cluster>::value, int>::type =
                        0>
                const Settings::Processing::Filters::Cluster &get() const
                {
                    return m_cluster;
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<T, Settings::Processing::Filters::Cluster::Removal>::value,
                        int>::type = 0>
                const Settings::Processing::Filters::Cluster::Removal &get() const
                {
                    return m_cluster.get<Settings::Processing::Filters::Cluster::Removal>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<T, Settings::Processing::Filters::Cluster::Removal::Enabled>::value,
                        int>::type = 0>
                const Settings::Processing::Filters::Cluster::Removal::Enabled &get() const
                {
                    return m_cluster.get<Settings::Processing::Filters::Cluster::Removal::Enabled>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<T, Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance>::value,
                        int>::type = 0>
                const Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance &get() const
                {
                    return m_cluster.get<Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<T, Settings::Processing::Filters::Cluster::Removal::MinArea>::value,
                        int>::type = 0>
                const Settings::Processing::Filters::Cluster::Removal::MinArea &get() const
                {
                    return m_cluster.get<Settings::Processing::Filters::Cluster::Removal::MinArea>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Experimental>::value, int>::
                        type = 0>
                const Settings::Processing::Filters::Experimental &get() const
                {
                    return m_experimental;
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion>::value,
                        int>::type = 0>
                const Settings::Processing::Filters::Experimental::ContrastDistortion &get() const
                {
                    return m_experimental.get<Settings::Processing::Filters::Experimental::ContrastDistortion>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Correction>::
                            value,
                        int>::type = 0>
                const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction &get() const
                {
                    return m_experimental
                        .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Correction>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<
                            T,
                            Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled>::
                            value,
                        int>::type = 0>
                const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled &get() const
                {
                    return m_experimental
                        .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<
                            T,
                            Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength>::
                            value,
                        int>::type = 0>
                const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength &get() const
                {
                    return m_experimental
                        .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>::
                            value,
                        int>::type = 0>
                const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal &get() const
                {
                    return m_experimental
                        .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<
                            T,
                            Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled>::value,
                        int>::type = 0>
                const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled &get() const
                {
                    return m_experimental
                        .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<
                            T,
                            Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold>::value,
                        int>::type = 0>
                const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold &get() const
                {
                    return m_experimental
                        .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling>::value,
                        int>::type = 0>
                const Settings::Processing::Filters::Experimental::HoleFilling &get() const
                {
                    return m_experimental.get<Settings::Processing::Filters::Experimental::HoleFilling>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling::Enabled>::value,
                        int>::type = 0>
                const Settings::Processing::Filters::Experimental::HoleFilling::Enabled &get() const
                {
                    return m_experimental.get<Settings::Processing::Filters::Experimental::HoleFilling::Enabled>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling::HoleSize>::value,
                        int>::type = 0>
                const Settings::Processing::Filters::Experimental::HoleFilling::HoleSize &get() const
                {
                    return m_experimental.get<Settings::Processing::Filters::Experimental::HoleFilling::HoleSize>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling::Strictness>::value,
                        int>::type = 0>
                const Settings::Processing::Filters::Experimental::HoleFilling::Strictness &get() const
                {
                    return m_experimental.get<Settings::Processing::Filters::Experimental::HoleFilling::Strictness>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Noise>::value, int>::type =
                        0>
                const Settings::Processing::Filters::Noise &get() const
                {
                    return m_noise;
                }
 
                template<
                    typename T,
                    typename std::
                        enable_if<std::is_same<T, Settings::Processing::Filters::Noise::Removal>::value, int>::type = 0>
                const Settings::Processing::Filters::Noise::Removal &get() const
                {
                    return m_noise.get<Settings::Processing::Filters::Noise::Removal>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<T, Settings::Processing::Filters::Noise::Removal::Enabled>::value,
                        int>::type = 0>
                const Settings::Processing::Filters::Noise::Removal::Enabled &get() const
                {
                    return m_noise.get<Settings::Processing::Filters::Noise::Removal::Enabled>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<T, Settings::Processing::Filters::Noise::Removal::Threshold>::value,
                        int>::type = 0>
                const Settings::Processing::Filters::Noise::Removal::Threshold &get() const
                {
                    return m_noise.get<Settings::Processing::Filters::Noise::Removal::Threshold>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Noise::Repair>::value, int>::
                        type = 0>
                const Settings::Processing::Filters::Noise::Repair &get() const
                {
                    return m_noise.get<Settings::Processing::Filters::Noise::Repair>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<T, Settings::Processing::Filters::Noise::Repair::Enabled>::value,
                        int>::type = 0>
                const Settings::Processing::Filters::Noise::Repair::Enabled &get() const
                {
                    return m_noise.get<Settings::Processing::Filters::Noise::Repair::Enabled>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<T, Settings::Processing::Filters::Noise::Suppression>::value,
                        int>::type = 0>
                const Settings::Processing::Filters::Noise::Suppression &get() const
                {
                    return m_noise.get<Settings::Processing::Filters::Noise::Suppression>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<T, Settings::Processing::Filters::Noise::Suppression::Enabled>::value,
                        int>::type = 0>
                const Settings::Processing::Filters::Noise::Suppression::Enabled &get() const
                {
                    return m_noise.get<Settings::Processing::Filters::Noise::Suppression::Enabled>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Outlier>::value, int>::type =
                        0>
                const Settings::Processing::Filters::Outlier &get() const
                {
                    return m_outlier;
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<T, Settings::Processing::Filters::Outlier::Removal>::value,
                        int>::type = 0>
                const Settings::Processing::Filters::Outlier::Removal &get() const
                {
                    return m_outlier.get<Settings::Processing::Filters::Outlier::Removal>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<T, Settings::Processing::Filters::Outlier::Removal::Enabled>::value,
                        int>::type = 0>
                const Settings::Processing::Filters::Outlier::Removal::Enabled &get() const
                {
                    return m_outlier.get<Settings::Processing::Filters::Outlier::Removal::Enabled>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<T, Settings::Processing::Filters::Outlier::Removal::Threshold>::value,
                        int>::type = 0>
                const Settings::Processing::Filters::Outlier::Removal::Threshold &get() const
                {
                    return m_outlier.get<Settings::Processing::Filters::Outlier::Removal::Threshold>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Reflection>::value, int>::
                        type = 0>
                const Settings::Processing::Filters::Reflection &get() const
                {
                    return m_reflection;
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<T, Settings::Processing::Filters::Reflection::Removal>::value,
                        int>::type = 0>
                const Settings::Processing::Filters::Reflection::Removal &get() const
                {
                    return m_reflection.get<Settings::Processing::Filters::Reflection::Removal>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Enabled>::value,
                        int>::type = 0>
                const Settings::Processing::Filters::Reflection::Removal::Enabled &get() const
                {
                    return m_reflection.get<Settings::Processing::Filters::Reflection::Removal::Enabled>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Experimental>::value,
                        int>::type = 0>
                const Settings::Processing::Filters::Reflection::Removal::Experimental &get() const
                {
                    return m_reflection.get<Settings::Processing::Filters::Reflection::Removal::Experimental>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Experimental::Mode>::value,
                        int>::type = 0>
                const Settings::Processing::Filters::Reflection::Removal::Experimental::Mode &get() const
                {
                    return m_reflection.get<Settings::Processing::Filters::Reflection::Removal::Experimental::Mode>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Smoothing>::value, int>::
                        type = 0>
                const Settings::Processing::Filters::Smoothing &get() const
                {
                    return m_smoothing;
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian>::value,
                        int>::type = 0>
                const Settings::Processing::Filters::Smoothing::Gaussian &get() const
                {
                    return m_smoothing.get<Settings::Processing::Filters::Smoothing::Gaussian>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian::Enabled>::value,
                        int>::type = 0>
                const Settings::Processing::Filters::Smoothing::Gaussian::Enabled &get() const
                {
                    return m_smoothing.get<Settings::Processing::Filters::Smoothing::Gaussian::Enabled>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian::Sigma>::value,
                        int>::type = 0>
                const Settings::Processing::Filters::Smoothing::Gaussian::Sigma &get() const
                {
                    return m_smoothing.get<Settings::Processing::Filters::Smoothing::Gaussian::Sigma>();
                }
 
                template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                const Settings::Processing::Filters::Cluster &get() const
                {
                    return m_cluster;
                }
 
                template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
                const Settings::Processing::Filters::Experimental &get() const
                {
                    return m_experimental;
                }
 
                template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
                const Settings::Processing::Filters::Noise &get() const
                {
                    return m_noise;
                }
 
                template<size_t i, typename std::enable_if<i == 3, int>::type = 0>
                const Settings::Processing::Filters::Outlier &get() const
                {
                    return m_outlier;
                }
 
                template<size_t i, typename std::enable_if<i == 4, int>::type = 0>
                const Settings::Processing::Filters::Reflection &get() const
                {
                    return m_reflection;
                }
 
                template<size_t i, typename std::enable_if<i == 5, int>::type = 0>
                const Settings::Processing::Filters::Smoothing &get() const
                {
                    return m_smoothing;
                }
 
                template<typename F>
                void forEach(const F &f) const
                {
                    f(m_cluster);
                    f(m_experimental);
                    f(m_noise);
                    f(m_outlier);
                    f(m_reflection);
                    f(m_smoothing);
                }
 
                template<typename F>
                void forEach(const F &f)
                {
                    f(m_cluster);
                    f(m_experimental);
                    f(m_noise);
                    f(m_outlier);
                    f(m_reflection);
                    f(m_smoothing);
                }
 
                bool operator==(const Filters &other) const;
 
                bool operator!=(const Filters &other) const;
 
                std::string toString() const;
 
                friend std::ostream &operator<<(std::ostream &stream, const Filters &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;
 
                Cluster m_cluster;
                Experimental m_experimental;
                Noise m_noise;
                Outlier m_outlier;
                Reflection m_reflection;
                Smoothing m_smoothing;
 
                friend struct DataModel::Detail::Befriend<Filters>;
            };
 
            using Descendants = std::tuple<
                Settings::Processing::Color,
                Settings::Processing::Color::Balance,
                Settings::Processing::Color::Balance::Blue,
                Settings::Processing::Color::Balance::Green,
                Settings::Processing::Color::Balance::Red,
                Settings::Processing::Color::Experimental,
                Settings::Processing::Color::Experimental::Mode,
                Settings::Processing::Color::Gamma,
                Settings::Processing::Filters,
                Settings::Processing::Filters::Cluster,
                Settings::Processing::Filters::Cluster::Removal,
                Settings::Processing::Filters::Cluster::Removal::Enabled,
                Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance,
                Settings::Processing::Filters::Cluster::Removal::MinArea,
                Settings::Processing::Filters::Experimental,
                Settings::Processing::Filters::Experimental::ContrastDistortion,
                Settings::Processing::Filters::Experimental::ContrastDistortion::Correction,
                Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled,
                Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength,
                Settings::Processing::Filters::Experimental::ContrastDistortion::Removal,
                Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled,
                Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold,
                Settings::Processing::Filters::Experimental::HoleFilling,
                Settings::Processing::Filters::Experimental::HoleFilling::Enabled,
                Settings::Processing::Filters::Experimental::HoleFilling::HoleSize,
                Settings::Processing::Filters::Experimental::HoleFilling::Strictness,
                Settings::Processing::Filters::Noise,
                Settings::Processing::Filters::Noise::Removal,
                Settings::Processing::Filters::Noise::Removal::Enabled,
                Settings::Processing::Filters::Noise::Removal::Threshold,
                Settings::Processing::Filters::Noise::Repair,
                Settings::Processing::Filters::Noise::Repair::Enabled,
                Settings::Processing::Filters::Noise::Suppression,
                Settings::Processing::Filters::Noise::Suppression::Enabled,
                Settings::Processing::Filters::Outlier,
                Settings::Processing::Filters::Outlier::Removal,
                Settings::Processing::Filters::Outlier::Removal::Enabled,
                Settings::Processing::Filters::Outlier::Removal::Threshold,
                Settings::Processing::Filters::Reflection,
                Settings::Processing::Filters::Reflection::Removal,
                Settings::Processing::Filters::Reflection::Removal::Enabled,
                Settings::Processing::Filters::Reflection::Removal::Experimental,
                Settings::Processing::Filters::Reflection::Removal::Experimental::Mode,
                Settings::Processing::Filters::Smoothing,
                Settings::Processing::Filters::Smoothing::Gaussian,
                Settings::Processing::Filters::Smoothing::Gaussian::Enabled,
                Settings::Processing::Filters::Smoothing::Gaussian::Sigma>;
 
            Processing();
 
#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 Processing(Args &&...args)
            {
                using namespace Zivid::Detail::TypeTraits;
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to Processing(...). "
                    "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
            Processing 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 Color &color() const
            {
                return m_color;
            }
 
            Color &color()
            {
                return m_color;
            }
 
            Processing &set(const Color &value)
            {
                m_color = value;
                return *this;
            }
 
            Processing &set(const Color::Balance &value)
            {
                m_color.set(value);
                return *this;
            }
 
            Processing &set(const Color::Balance::Blue &value)
            {
                m_color.set(value);
                return *this;
            }
 
            Processing &set(const Color::Balance::Green &value)
            {
                m_color.set(value);
                return *this;
            }
 
            Processing &set(const Color::Balance::Red &value)
            {
                m_color.set(value);
                return *this;
            }
 
            Processing &set(const Color::Experimental &value)
            {
                m_color.set(value);
                return *this;
            }
 
            Processing &set(const Color::Experimental::Mode &value)
            {
                m_color.set(value);
                return *this;
            }
 
            Processing &set(const Color::Gamma &value)
            {
                m_color.set(value);
                return *this;
            }
 
            const Filters &filters() const
            {
                return m_filters;
            }
 
            Filters &filters()
            {
                return m_filters;
            }
 
            Processing &set(const Filters &value)
            {
                m_filters = value;
                return *this;
            }
 
            Processing &set(const Filters::Cluster &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Cluster::Removal &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Cluster::Removal::Enabled &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Cluster::Removal::MaxNeighborDistance &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Cluster::Removal::MinArea &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Experimental &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Experimental::ContrastDistortion &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Experimental::ContrastDistortion::Correction &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Experimental::ContrastDistortion::Correction::Enabled &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Experimental::ContrastDistortion::Correction::Strength &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Experimental::ContrastDistortion::Removal &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Experimental::ContrastDistortion::Removal::Enabled &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Experimental::ContrastDistortion::Removal::Threshold &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Experimental::HoleFilling &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Experimental::HoleFilling::Enabled &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Experimental::HoleFilling::HoleSize &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Experimental::HoleFilling::Strictness &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Noise &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Noise::Removal &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Noise::Removal::Enabled &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Noise::Removal::Threshold &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Noise::Repair &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Noise::Repair::Enabled &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Noise::Suppression &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Noise::Suppression::Enabled &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Outlier &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Outlier::Removal &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Outlier::Removal::Enabled &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Outlier::Removal::Threshold &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Reflection &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Reflection::Removal &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Reflection::Removal::Enabled &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Reflection::Removal::Experimental &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Reflection::Removal::Experimental::Mode &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Smoothing &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Smoothing::Gaussian &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Smoothing::Gaussian::Enabled &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Smoothing::Gaussian::Sigma &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Processing::Color>::value, int>::type = 0>
            const Settings::Processing::Color &get() const
            {
                return m_color;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance>::value, int>::type = 0>
            const Settings::Processing::Color::Balance &get() const
            {
                return m_color.get<Settings::Processing::Color::Balance>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance::Blue>::value, int>::type =
                    0>
            const Settings::Processing::Color::Balance::Blue &get() const
            {
                return m_color.get<Settings::Processing::Color::Balance::Blue>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance::Green>::value, int>::
                    type = 0>
            const Settings::Processing::Color::Balance::Green &get() const
            {
                return m_color.get<Settings::Processing::Color::Balance::Green>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance::Red>::value, int>::type =
                    0>
            const Settings::Processing::Color::Balance::Red &get() const
            {
                return m_color.get<Settings::Processing::Color::Balance::Red>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Processing::Color::Experimental>::value, int>::type =
                    0>
            const Settings::Processing::Color::Experimental &get() const
            {
                return m_color.get<Settings::Processing::Color::Experimental>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Processing::Color::Experimental::Mode>::value, int>::
                    type = 0>
            const Settings::Processing::Color::Experimental::Mode &get() const
            {
                return m_color.get<Settings::Processing::Color::Experimental::Mode>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Processing::Color::Gamma>::value, int>::type = 0>
            const Settings::Processing::Color::Gamma &get() const
            {
                return m_color.get<Settings::Processing::Color::Gamma>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Processing::Filters>::value, int>::type = 0>
            const Settings::Processing::Filters &get() const
            {
                return m_filters;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Cluster>::value, int>::type = 0>
            const Settings::Processing::Filters::Cluster &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Cluster>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Cluster::Removal>::value, int>::
                    type = 0>
            const Settings::Processing::Filters::Cluster::Removal &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Cluster::Removal>();
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<T, Settings::Processing::Filters::Cluster::Removal::Enabled>::value,
                    int>::type = 0>
            const Settings::Processing::Filters::Cluster::Removal::Enabled &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Cluster::Removal::Enabled>();
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<T, Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance>::value,
                    int>::type = 0>
            const Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance>();
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<T, Settings::Processing::Filters::Cluster::Removal::MinArea>::value,
                    int>::type = 0>
            const Settings::Processing::Filters::Cluster::Removal::MinArea &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Cluster::Removal::MinArea>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Experimental>::value, int>::
                    type = 0>
            const Settings::Processing::Filters::Experimental &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Experimental>();
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion>::value,
                    int>::type = 0>
            const Settings::Processing::Filters::Experimental::ContrastDistortion &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Experimental::ContrastDistortion>();
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Correction>::value,
                    int>::type = 0>
            const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Experimental::ContrastDistortion::Correction>();
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<
                        T,
                        Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled>::value,
                    int>::type = 0>
            const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled &get() const
            {
                return m_filters
                    .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled>();
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<
                        T,
                        Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength>::value,
                    int>::type = 0>
            const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength &get() const
            {
                return m_filters
                    .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength>();
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>::value,
                    int>::type = 0>
            const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>();
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled>::
                        value,
                    int>::type = 0>
            const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled &get() const
            {
                return m_filters
                    .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled>();
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<
                        T,
                        Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold>::value,
                    int>::type = 0>
            const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold &get() const
            {
                return m_filters
                    .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold>();
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling>::value,
                    int>::type = 0>
            const Settings::Processing::Filters::Experimental::HoleFilling &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Experimental::HoleFilling>();
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling::Enabled>::value,
                    int>::type = 0>
            const Settings::Processing::Filters::Experimental::HoleFilling::Enabled &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Experimental::HoleFilling::Enabled>();
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling::HoleSize>::value,
                    int>::type = 0>
            const Settings::Processing::Filters::Experimental::HoleFilling::HoleSize &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Experimental::HoleFilling::HoleSize>();
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling::Strictness>::value,
                    int>::type = 0>
            const Settings::Processing::Filters::Experimental::HoleFilling::Strictness &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Experimental::HoleFilling::Strictness>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Noise>::value, int>::type = 0>
            const Settings::Processing::Filters::Noise &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Noise>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Noise::Removal>::value, int>::
                    type = 0>
            const Settings::Processing::Filters::Noise::Removal &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Noise::Removal>();
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<T, Settings::Processing::Filters::Noise::Removal::Enabled>::value,
                    int>::type = 0>
            const Settings::Processing::Filters::Noise::Removal::Enabled &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Noise::Removal::Enabled>();
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<T, Settings::Processing::Filters::Noise::Removal::Threshold>::value,
                    int>::type = 0>
            const Settings::Processing::Filters::Noise::Removal::Threshold &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Noise::Removal::Threshold>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Noise::Repair>::value, int>::
                    type = 0>
            const Settings::Processing::Filters::Noise::Repair &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Noise::Repair>();
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<T, Settings::Processing::Filters::Noise::Repair::Enabled>::value,
                    int>::type = 0>
            const Settings::Processing::Filters::Noise::Repair::Enabled &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Noise::Repair::Enabled>();
            }
 
            template<
                typename T,
                typename std::
                    enable_if<std::is_same<T, Settings::Processing::Filters::Noise::Suppression>::value, int>::type = 0>
            const Settings::Processing::Filters::Noise::Suppression &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Noise::Suppression>();
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<T, Settings::Processing::Filters::Noise::Suppression::Enabled>::value,
                    int>::type = 0>
            const Settings::Processing::Filters::Noise::Suppression::Enabled &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Noise::Suppression::Enabled>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Outlier>::value, int>::type = 0>
            const Settings::Processing::Filters::Outlier &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Outlier>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Outlier::Removal>::value, int>::
                    type = 0>
            const Settings::Processing::Filters::Outlier::Removal &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Outlier::Removal>();
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<T, Settings::Processing::Filters::Outlier::Removal::Enabled>::value,
                    int>::type = 0>
            const Settings::Processing::Filters::Outlier::Removal::Enabled &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Outlier::Removal::Enabled>();
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<T, Settings::Processing::Filters::Outlier::Removal::Threshold>::value,
                    int>::type = 0>
            const Settings::Processing::Filters::Outlier::Removal::Threshold &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Outlier::Removal::Threshold>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Reflection>::value, int>::type =
                    0>
            const Settings::Processing::Filters::Reflection &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Reflection>();
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<T, Settings::Processing::Filters::Reflection::Removal>::value,
                    int>::type = 0>
            const Settings::Processing::Filters::Reflection::Removal &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Reflection::Removal>();
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Enabled>::value,
                    int>::type = 0>
            const Settings::Processing::Filters::Reflection::Removal::Enabled &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Reflection::Removal::Enabled>();
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Experimental>::value,
                    int>::type = 0>
            const Settings::Processing::Filters::Reflection::Removal::Experimental &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Reflection::Removal::Experimental>();
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Experimental::Mode>::value,
                    int>::type = 0>
            const Settings::Processing::Filters::Reflection::Removal::Experimental::Mode &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Reflection::Removal::Experimental::Mode>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Smoothing>::value, int>::type =
                    0>
            const Settings::Processing::Filters::Smoothing &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Smoothing>();
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian>::value,
                    int>::type = 0>
            const Settings::Processing::Filters::Smoothing::Gaussian &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Smoothing::Gaussian>();
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian::Enabled>::value,
                    int>::type = 0>
            const Settings::Processing::Filters::Smoothing::Gaussian::Enabled &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Smoothing::Gaussian::Enabled>();
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian::Sigma>::value,
                    int>::type = 0>
            const Settings::Processing::Filters::Smoothing::Gaussian::Sigma &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Smoothing::Gaussian::Sigma>();
            }
 
            template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
            const Settings::Processing::Color &get() const
            {
                return m_color;
            }
 
            template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
            const Settings::Processing::Filters &get() const
            {
                return m_filters;
            }
 
            template<typename F>
            void forEach(const F &f) const
            {
                f(m_color);
                f(m_filters);
            }
 
            template<typename F>
            void forEach(const F &f)
            {
                f(m_color);
                f(m_filters);
            }
 
            bool operator==(const Processing &other) const;
 
            bool operator!=(const Processing &other) const;
 
            std::string toString() const;
 
            friend std::ostream &operator<<(std::ostream &stream, const Processing &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;
 
            Color m_color;
            Filters m_filters;
 
            friend struct DataModel::Detail::Befriend<Processing>;
        };
 
 
        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
        class ZIVID_CORE_EXPORT RegionOfInterest
        {
        public:
            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
            static constexpr const char *path{ "RegionOfInterest" };
 
            static constexpr const char *name{ "RegionOfInterest" };
 
            static constexpr const char *description{ R"description(Removes points outside the region of interest.
)description" };
 
 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT Box
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
                static constexpr const char *path{ "RegionOfInterest/Box" };
 
                static constexpr const char *name{ "Box" };
 
                static constexpr const char *description{ R"description(Removes the points outside the box.
 
The box is defined by three points: O, A and B. These points define two vectors,
OA that goes from PointO to PointA, and OB that goes from PointO to PointB.
This gives 4 points O, A, B and (O + OA + OB), that together form a
parallelogram in 3D.
 
Two extents can be provided, to extrude the parallelogram along the surface
normal vector of the parallelogram plane. This creates a 3D volume (parallelepiped).
The surface normal vector is defined by the cross product OA x OB.
)description" };
 
 
                // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                class ZIVID_CORE_EXPORT Enabled
                {
                public:
                    static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                    static constexpr const char *path{ "RegionOfInterest/Box/Enabled" };
 
                    static constexpr const char *name{ "Enabled" };
 
                    static constexpr const char *description{ R"description(Enabled)description" };
 
                    using ValueType = bool;
                    static const Enabled yes; 
                    static const Enabled no;  
 
                    static std::set<bool> validValues()
                    {
                        return { false, true };
                    }
 
                    Enabled() = default;
 
                    explicit constexpr Enabled(bool value)
                        : m_opt{ value }
                    {}
 
                    bool value() const;
 
                    bool hasValue() const;
 
                    void reset();
 
                    std::string toString() const;
 
                    bool operator==(const Enabled &other) const
                    {
                        return m_opt == other.m_opt;
                    }
 
                    bool operator!=(const Enabled &other) const
                    {
                        return m_opt != other.m_opt;
                    }
 
                    friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
                    {
                        return stream << value.toString();
                    }
 
                private:
                    void setFromString(const std::string &value);
 
                    Zivid::DataModel::Detail::Optional<bool> m_opt;
 
                    friend struct DataModel::Detail::Befriend<Enabled>;
                };
 
 
                // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                class ZIVID_CORE_EXPORT Extents
                {
                public:
                    static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                    static constexpr const char *path{ "RegionOfInterest/Box/Extents" };
 
                    static constexpr const char *name{ "Extents" };
 
                    static constexpr const char *description{
                        R"description(Two points on the normal describing the direction and distance from the plane from which the normal is derived.)description"
                    };
 
                    using ValueType = Zivid::Range<double>;
 
                    Extents() = default;
 
                    explicit constexpr Extents(Zivid::Range<double> value)
                        : m_opt{ value }
                    {}
 
                    const Zivid::Range<double> &value() const;
 
                    bool hasValue() const;
 
                    void reset();
 
                    std::string toString() const;
 
                    explicit constexpr Extents(double minValue, double maxValue)
                        : Extents{ Zivid::Range<double>{ minValue, maxValue } }
                    {}
 
                    bool operator==(const Extents &other) const
                    {
                        return m_opt == other.m_opt;
                    }
 
                    bool operator!=(const Extents &other) const
                    {
                        return m_opt != other.m_opt;
                    }
 
                    friend std::ostream &operator<<(std::ostream &stream, const Extents &value)
                    {
                        return stream << value.toString();
                    }
 
                private:
                    void setFromString(const std::string &value);
 
                    Zivid::DataModel::Detail::Optional<Zivid::Range<double>> m_opt;
 
                    friend struct DataModel::Detail::Befriend<Extents>;
                };
 
 
                // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                class ZIVID_CORE_EXPORT PointA
                {
                public:
                    static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                    static constexpr const char *path{ "RegionOfInterest/Box/PointA" };
 
                    static constexpr const char *name{ "PointA" };
 
                    static constexpr const char *description{
                        R"description(A point such that the vector from PointO to PointA describes the first edge of the parallelogram)description"
                    };
 
                    using ValueType = Zivid::PointXYZ;
 
                    PointA() = default;
 
                    explicit constexpr PointA(Zivid::PointXYZ value)
                        : m_opt{ value }
                    {}
 
                    Zivid::PointXYZ value() const;
 
                    bool hasValue() const;
 
                    void reset();
 
                    std::string toString() const;
 
                    explicit constexpr PointA(float x, float y, float z)
                        : PointA{ Zivid::PointXYZ{ x, y, z } }
                    {}
 
                    bool operator==(const PointA &other) const
                    {
                        return m_opt == other.m_opt;
                    }
 
                    bool operator!=(const PointA &other) const
                    {
                        return m_opt != other.m_opt;
                    }
 
                    friend std::ostream &operator<<(std::ostream &stream, const PointA &value)
                    {
                        return stream << value.toString();
                    }
 
                private:
                    void setFromString(const std::string &value);
 
                    Zivid::DataModel::Detail::Optional<Zivid::PointXYZ> m_opt;
 
                    friend struct DataModel::Detail::Befriend<PointA>;
                };
 
 
                // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                class ZIVID_CORE_EXPORT PointB
                {
                public:
                    static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                    static constexpr const char *path{ "RegionOfInterest/Box/PointB" };
 
                    static constexpr const char *name{ "PointB" };
 
                    static constexpr const char *description{
                        R"description(A point such that the vector from PointO to PointB describes the second edge of the parallelogram)description"
                    };
 
                    using ValueType = Zivid::PointXYZ;
 
                    PointB() = default;
 
                    explicit constexpr PointB(Zivid::PointXYZ value)
                        : m_opt{ value }
                    {}
 
                    Zivid::PointXYZ value() const;
 
                    bool hasValue() const;
 
                    void reset();
 
                    std::string toString() const;
 
                    explicit constexpr PointB(float x, float y, float z)
                        : PointB{ Zivid::PointXYZ{ x, y, z } }
                    {}
 
                    bool operator==(const PointB &other) const
                    {
                        return m_opt == other.m_opt;
                    }
 
                    bool operator!=(const PointB &other) const
                    {
                        return m_opt != other.m_opt;
                    }
 
                    friend std::ostream &operator<<(std::ostream &stream, const PointB &value)
                    {
                        return stream << value.toString();
                    }
 
                private:
                    void setFromString(const std::string &value);
 
                    Zivid::DataModel::Detail::Optional<Zivid::PointXYZ> m_opt;
 
                    friend struct DataModel::Detail::Befriend<PointB>;
                };
 
 
                // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                class ZIVID_CORE_EXPORT PointO
                {
                public:
                    static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                    static constexpr const char *path{ "RegionOfInterest/Box/PointO" };
 
                    static constexpr const char *name{ "PointO" };
 
                    static constexpr const char *description{
                        R"description(The point at the intersection of two adjacent edges defining a parallelogram)description"
                    };
 
                    using ValueType = Zivid::PointXYZ;
 
                    PointO() = default;
 
                    explicit constexpr PointO(Zivid::PointXYZ value)
                        : m_opt{ value }
                    {}
 
                    Zivid::PointXYZ value() const;
 
                    bool hasValue() const;
 
                    void reset();
 
                    std::string toString() const;
 
                    explicit constexpr PointO(float x, float y, float z)
                        : PointO{ Zivid::PointXYZ{ x, y, z } }
                    {}
 
                    bool operator==(const PointO &other) const
                    {
                        return m_opt == other.m_opt;
                    }
 
                    bool operator!=(const PointO &other) const
                    {
                        return m_opt != other.m_opt;
                    }
 
                    friend std::ostream &operator<<(std::ostream &stream, const PointO &value)
                    {
                        return stream << value.toString();
                    }
 
                private:
                    void setFromString(const std::string &value);
 
                    Zivid::DataModel::Detail::Optional<Zivid::PointXYZ> m_opt;
 
                    friend struct DataModel::Detail::Befriend<PointO>;
                };
 
                using Descendants = std::tuple<
                    Settings::RegionOfInterest::Box::Enabled,
                    Settings::RegionOfInterest::Box::Extents,
                    Settings::RegionOfInterest::Box::PointA,
                    Settings::RegionOfInterest::Box::PointB,
                    Settings::RegionOfInterest::Box::PointO>;
 
                Box();
 
#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 Box(Args &&...args)
                {
                    using namespace Zivid::Detail::TypeTraits;
 
                    static_assert(
                        AllArgsDecayedAreUnique<Args...>::value,
                        "Found duplicate types among the arguments passed to Box(...). "
                        "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
                Box 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 Enabled &isEnabled() const
                {
                    return m_enabled;
                }
 
                Enabled &isEnabled()
                {
                    return m_enabled;
                }
 
                Box &set(const Enabled &value)
                {
                    m_enabled = value;
                    return *this;
                }
 
                const Extents &extents() const
                {
                    return m_extents;
                }
 
                Extents &extents()
                {
                    return m_extents;
                }
 
                Box &set(const Extents &value)
                {
                    m_extents = value;
                    return *this;
                }
 
                const PointA &pointA() const
                {
                    return m_pointA;
                }
 
                PointA &pointA()
                {
                    return m_pointA;
                }
 
                Box &set(const PointA &value)
                {
                    m_pointA = value;
                    return *this;
                }
 
                const PointB &pointB() const
                {
                    return m_pointB;
                }
 
                PointB &pointB()
                {
                    return m_pointB;
                }
 
                Box &set(const PointB &value)
                {
                    m_pointB = value;
                    return *this;
                }
 
                const PointO &pointO() const
                {
                    return m_pointO;
                }
 
                PointO &pointO()
                {
                    return m_pointO;
                }
 
                Box &set(const PointO &value)
                {
                    m_pointO = value;
                    return *this;
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box::Enabled>::value, int>::
                        type = 0>
                const Settings::RegionOfInterest::Box::Enabled &get() const
                {
                    return m_enabled;
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box::Extents>::value, int>::
                        type = 0>
                const Settings::RegionOfInterest::Box::Extents &get() const
                {
                    return m_extents;
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box::PointA>::value, int>::
                        type = 0>
                const Settings::RegionOfInterest::Box::PointA &get() const
                {
                    return m_pointA;
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box::PointB>::value, int>::
                        type = 0>
                const Settings::RegionOfInterest::Box::PointB &get() const
                {
                    return m_pointB;
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box::PointO>::value, int>::
                        type = 0>
                const Settings::RegionOfInterest::Box::PointO &get() const
                {
                    return m_pointO;
                }
 
                template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                const Settings::RegionOfInterest::Box::Enabled &get() const
                {
                    return m_enabled;
                }
 
                template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
                const Settings::RegionOfInterest::Box::Extents &get() const
                {
                    return m_extents;
                }
 
                template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
                const Settings::RegionOfInterest::Box::PointA &get() const
                {
                    return m_pointA;
                }
 
                template<size_t i, typename std::enable_if<i == 3, int>::type = 0>
                const Settings::RegionOfInterest::Box::PointB &get() const
                {
                    return m_pointB;
                }
 
                template<size_t i, typename std::enable_if<i == 4, int>::type = 0>
                const Settings::RegionOfInterest::Box::PointO &get() const
                {
                    return m_pointO;
                }
 
                template<typename F>
                void forEach(const F &f) const
                {
                    f(m_enabled);
                    f(m_extents);
                    f(m_pointA);
                    f(m_pointB);
                    f(m_pointO);
                }
 
                template<typename F>
                void forEach(const F &f)
                {
                    f(m_enabled);
                    f(m_extents);
                    f(m_pointA);
                    f(m_pointB);
                    f(m_pointO);
                }
 
                bool operator==(const Box &other) const;
 
                bool operator!=(const Box &other) const;
 
                std::string toString() const;
 
                friend std::ostream &operator<<(std::ostream &stream, const Box &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;
 
                Enabled m_enabled;
                Extents m_extents;
                PointA m_pointA;
                PointB m_pointB;
                PointO m_pointO;
 
                friend struct DataModel::Detail::Befriend<Box>;
            };
 
 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT Depth
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
                static constexpr const char *path{ "RegionOfInterest/Depth" };
 
                static constexpr const char *name{ "Depth" };
 
                static constexpr const char *description{
                    R"description(Removes points that reside outside of a depth range, meaning that their Z coordinate
falls above a given maximum or below a given minimum.
)description"
                };
 
 
                // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                class ZIVID_CORE_EXPORT Enabled
                {
                public:
                    static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                    static constexpr const char *path{ "RegionOfInterest/Depth/Enabled" };
 
                    static constexpr const char *name{ "Enabled" };
 
                    static constexpr const char *description{ R"description(Enabled)description" };
 
                    using ValueType = bool;
                    static const Enabled yes; 
                    static const Enabled no;  
 
                    static std::set<bool> validValues()
                    {
                        return { false, true };
                    }
 
                    Enabled() = default;
 
                    explicit constexpr Enabled(bool value)
                        : m_opt{ value }
                    {}
 
                    bool value() const;
 
                    bool hasValue() const;
 
                    void reset();
 
                    std::string toString() const;
 
                    bool operator==(const Enabled &other) const
                    {
                        return m_opt == other.m_opt;
                    }
 
                    bool operator!=(const Enabled &other) const
                    {
                        return m_opt != other.m_opt;
                    }
 
                    friend std::ostream &operator<<(std::ostream &stream, const Enabled &value)
                    {
                        return stream << value.toString();
                    }
 
                private:
                    void setFromString(const std::string &value);
 
                    Zivid::DataModel::Detail::Optional<bool> m_opt;
 
                    friend struct DataModel::Detail::Befriend<Enabled>;
                };
 
 
                // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                class ZIVID_CORE_EXPORT Range
                {
                public:
                    static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                    static constexpr const char *path{ "RegionOfInterest/Depth/Range" };
 
                    static constexpr const char *name{ "Range" };
 
                    static constexpr const char *description{
                        R"description(Specify the minimum and maximum Z value that will be included.)description"
                    };
 
                    using ValueType = Zivid::Range<double>;
 
                    Range() = default;
 
                    explicit constexpr Range(Zivid::Range<double> value)
                        : m_opt{ value }
                    {}
 
                    const Zivid::Range<double> &value() const;
 
                    bool hasValue() const;
 
                    void reset();
 
                    std::string toString() const;
 
                    explicit constexpr Range(double minValue, double maxValue)
                        : Range{ Zivid::Range<double>{ minValue, maxValue } }
                    {}
 
                    bool operator==(const Range &other) const
                    {
                        return m_opt == other.m_opt;
                    }
 
                    bool operator!=(const Range &other) const
                    {
                        return m_opt != other.m_opt;
                    }
 
                    friend std::ostream &operator<<(std::ostream &stream, const Range &value)
                    {
                        return stream << value.toString();
                    }
 
                private:
                    void setFromString(const std::string &value);
 
                    Zivid::DataModel::Detail::Optional<Zivid::Range<double>> m_opt;
 
                    friend struct DataModel::Detail::Befriend<Range>;
                };
 
                using Descendants =
                    std::tuple<Settings::RegionOfInterest::Depth::Enabled, Settings::RegionOfInterest::Depth::Range>;
 
                Depth();
 
#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 Depth(Args &&...args)
                {
                    using namespace Zivid::Detail::TypeTraits;
 
                    static_assert(
                        AllArgsDecayedAreUnique<Args...>::value,
                        "Found duplicate types among the arguments passed to Depth(...). "
                        "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
                Depth 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 Enabled &isEnabled() const
                {
                    return m_enabled;
                }
 
                Enabled &isEnabled()
                {
                    return m_enabled;
                }
 
                Depth &set(const Enabled &value)
                {
                    m_enabled = value;
                    return *this;
                }
 
                const Range &range() const
                {
                    return m_range;
                }
 
                Range &range()
                {
                    return m_range;
                }
 
                Depth &set(const Range &value)
                {
                    m_range = value;
                    return *this;
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Depth::Enabled>::value, int>::
                        type = 0>
                const Settings::RegionOfInterest::Depth::Enabled &get() const
                {
                    return m_enabled;
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Depth::Range>::value, int>::
                        type = 0>
                const Settings::RegionOfInterest::Depth::Range &get() const
                {
                    return m_range;
                }
 
                template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                const Settings::RegionOfInterest::Depth::Enabled &get() const
                {
                    return m_enabled;
                }
 
                template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
                const Settings::RegionOfInterest::Depth::Range &get() const
                {
                    return m_range;
                }
 
                template<typename F>
                void forEach(const F &f) const
                {
                    f(m_enabled);
                    f(m_range);
                }
 
                template<typename F>
                void forEach(const F &f)
                {
                    f(m_enabled);
                    f(m_range);
                }
 
                bool operator==(const Depth &other) const;
 
                bool operator!=(const Depth &other) const;
 
                std::string toString() const;
 
                friend std::ostream &operator<<(std::ostream &stream, const Depth &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;
 
                Enabled m_enabled;
                Range m_range;
 
                friend struct DataModel::Detail::Befriend<Depth>;
            };
 
            using Descendants = std::tuple<
                Settings::RegionOfInterest::Box,
                Settings::RegionOfInterest::Box::Enabled,
                Settings::RegionOfInterest::Box::Extents,
                Settings::RegionOfInterest::Box::PointA,
                Settings::RegionOfInterest::Box::PointB,
                Settings::RegionOfInterest::Box::PointO,
                Settings::RegionOfInterest::Depth,
                Settings::RegionOfInterest::Depth::Enabled,
                Settings::RegionOfInterest::Depth::Range>;
 
            RegionOfInterest();
 
#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 RegionOfInterest(Args &&...args)
            {
                using namespace Zivid::Detail::TypeTraits;
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to RegionOfInterest(...). "
                    "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
            RegionOfInterest 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 Box &box() const
            {
                return m_box;
            }
 
            Box &box()
            {
                return m_box;
            }
 
            RegionOfInterest &set(const Box &value)
            {
                m_box = value;
                return *this;
            }
 
            RegionOfInterest &set(const Box::Enabled &value)
            {
                m_box.set(value);
                return *this;
            }
 
            RegionOfInterest &set(const Box::Extents &value)
            {
                m_box.set(value);
                return *this;
            }
 
            RegionOfInterest &set(const Box::PointA &value)
            {
                m_box.set(value);
                return *this;
            }
 
            RegionOfInterest &set(const Box::PointB &value)
            {
                m_box.set(value);
                return *this;
            }
 
            RegionOfInterest &set(const Box::PointO &value)
            {
                m_box.set(value);
                return *this;
            }
 
            const Depth &depth() const
            {
                return m_depth;
            }
 
            Depth &depth()
            {
                return m_depth;
            }
 
            RegionOfInterest &set(const Depth &value)
            {
                m_depth = value;
                return *this;
            }
 
            RegionOfInterest &set(const Depth::Enabled &value)
            {
                m_depth.set(value);
                return *this;
            }
 
            RegionOfInterest &set(const Depth::Range &value)
            {
                m_depth.set(value);
                return *this;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box>::value, int>::type = 0>
            const Settings::RegionOfInterest::Box &get() const
            {
                return m_box;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box::Enabled>::value, int>::type =
                    0>
            const Settings::RegionOfInterest::Box::Enabled &get() const
            {
                return m_box.get<Settings::RegionOfInterest::Box::Enabled>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box::Extents>::value, int>::type =
                    0>
            const Settings::RegionOfInterest::Box::Extents &get() const
            {
                return m_box.get<Settings::RegionOfInterest::Box::Extents>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box::PointA>::value, int>::type = 0>
            const Settings::RegionOfInterest::Box::PointA &get() const
            {
                return m_box.get<Settings::RegionOfInterest::Box::PointA>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box::PointB>::value, int>::type = 0>
            const Settings::RegionOfInterest::Box::PointB &get() const
            {
                return m_box.get<Settings::RegionOfInterest::Box::PointB>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box::PointO>::value, int>::type = 0>
            const Settings::RegionOfInterest::Box::PointO &get() const
            {
                return m_box.get<Settings::RegionOfInterest::Box::PointO>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Depth>::value, int>::type = 0>
            const Settings::RegionOfInterest::Depth &get() const
            {
                return m_depth;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Depth::Enabled>::value, int>::type =
                    0>
            const Settings::RegionOfInterest::Depth::Enabled &get() const
            {
                return m_depth.get<Settings::RegionOfInterest::Depth::Enabled>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Depth::Range>::value, int>::type =
                    0>
            const Settings::RegionOfInterest::Depth::Range &get() const
            {
                return m_depth.get<Settings::RegionOfInterest::Depth::Range>();
            }
 
            template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
            const Settings::RegionOfInterest::Box &get() const
            {
                return m_box;
            }
 
            template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
            const Settings::RegionOfInterest::Depth &get() const
            {
                return m_depth;
            }
 
            template<typename F>
            void forEach(const F &f) const
            {
                f(m_box);
                f(m_depth);
            }
 
            template<typename F>
            void forEach(const F &f)
            {
                f(m_box);
                f(m_depth);
            }
 
            bool operator==(const RegionOfInterest &other) const;
 
            bool operator!=(const RegionOfInterest &other) const;
 
            std::string toString() const;
 
            friend std::ostream &operator<<(std::ostream &stream, const RegionOfInterest &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;
 
            Box m_box;
            Depth m_depth;
 
            friend struct DataModel::Detail::Befriend<RegionOfInterest>;
        };
 
 
        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
        class ZIVID_CORE_EXPORT Sampling
        {
        public:
            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
            static constexpr const char *path{ "Sampling" };
 
            static constexpr const char *name{ "Sampling" };
 
            static constexpr const char *description{ R"description(Sampling group
)description" };
 
 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT Color
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                static constexpr const char *path{ "Sampling/Color" };
 
                static constexpr const char *name{ "Color" };
 
                static constexpr const char *description{
                    R"description(Choose how to sample colors for the pointcloud. The `rgb` option gives all
colors for a regular Zivid camera. The `disabled` option gives no colors and
can allow for faster captures. It is also useful if you want to avoid projecting
white light in the subsampling modes under `Sampling::Pixel`.
)description"
                };
 
                enum class ValueType
                {
                    rgb,
                    disabled
                };
                static const Color rgb;      
                static const Color disabled; 
 
                static std::set<ValueType> validValues()
                {
                    return { ValueType::rgb, ValueType::disabled };
                }
 
                Color() = default;
 
                explicit constexpr Color(ValueType value)
                    : m_opt{ verifyValue(value) }
                {}
 
                ValueType value() const;
 
                bool hasValue() const;
 
                void reset();
 
                std::string toString() const;
 
                friend std::ostream &operator<<(std::ostream &stream, const Color::ValueType &value)
                {
                    return stream << Color{ value }.toString();
                }
 
                bool operator==(const Color &other) const
                {
                    return m_opt == other.m_opt;
                }
 
                bool operator!=(const Color &other) const
                {
                    return m_opt != other.m_opt;
                }
 
                friend std::ostream &operator<<(std::ostream &stream, const Color &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                constexpr ValueType static verifyValue(const ValueType &value)
                {
                    return value == ValueType::rgb || value == ValueType::disabled
                               ? value
                               : throw std::invalid_argument{
                                     "Invalid value: Color{ "
                                     + std::to_string(static_cast<std::underlying_type<ValueType>::type>(value)) + " }"
                                 };
                }
 
                Zivid::DataModel::Detail::Optional<ValueType> m_opt;
 
                friend struct DataModel::Detail::Befriend<Color>;
            };
 
 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT Pixel
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                static constexpr const char *path{ "Sampling/Pixel" };
 
                static constexpr const char *name{ "Pixel" };
 
                static constexpr const char *description{
                    R"description(Set whether the full image sensor should be used with white projector light or
only specific color channels with corresponding projector light.
Using only a specific color channel will subsample pixels and give a
smaller resolution.
 
Subsampling decreases the capture time, as less data will be captured and processed.
Picking a specific color channel can also help reduce noise and effects of ambient light.
Projecting blue light will in most cases give better data than red light.
)description"
                };
 
                enum class ValueType
                {
                    all,
                    blueSubsample2x2,
                    redSubsample2x2
                };
                static const Pixel all;              
                static const Pixel blueSubsample2x2; 
                static const Pixel redSubsample2x2;  
 
                static std::set<ValueType> validValues()
                {
                    return { ValueType::all, ValueType::blueSubsample2x2, ValueType::redSubsample2x2 };
                }
 
                Pixel() = default;
 
                explicit constexpr Pixel(ValueType value)
                    : m_opt{ verifyValue(value) }
                {}
 
                ValueType value() const;
 
                bool hasValue() const;
 
                void reset();
 
                std::string toString() const;
 
                friend std::ostream &operator<<(std::ostream &stream, const Pixel::ValueType &value)
                {
                    return stream << Pixel{ value }.toString();
                }
 
                bool operator==(const Pixel &other) const
                {
                    return m_opt == other.m_opt;
                }
 
                bool operator!=(const Pixel &other) const
                {
                    return m_opt != other.m_opt;
                }
 
                friend std::ostream &operator<<(std::ostream &stream, const Pixel &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                constexpr ValueType static verifyValue(const ValueType &value)
                {
                    return value == ValueType::all || value == ValueType::blueSubsample2x2
                                   || value == ValueType::redSubsample2x2
                               ? value
                               : throw std::invalid_argument{
                                     "Invalid value: Pixel{ "
                                     + std::to_string(static_cast<std::underlying_type<ValueType>::type>(value)) + " }"
                                 };
                }
 
                Zivid::DataModel::Detail::Optional<ValueType> m_opt;
 
                friend struct DataModel::Detail::Befriend<Pixel>;
            };
 
            using Descendants = std::tuple<Settings::Sampling::Color, Settings::Sampling::Pixel>;
 
            Sampling();
 
#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 Sampling(Args &&...args)
            {
                using namespace Zivid::Detail::TypeTraits;
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to Sampling(...). "
                    "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
            Sampling 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 Color &color() const
            {
                return m_color;
            }
 
            Color &color()
            {
                return m_color;
            }
 
            Sampling &set(const Color &value)
            {
                m_color = value;
                return *this;
            }
 
            const Pixel &pixel() const
            {
                return m_pixel;
            }
 
            Pixel &pixel()
            {
                return m_pixel;
            }
 
            Sampling &set(const Pixel &value)
            {
                m_pixel = value;
                return *this;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Sampling::Color>::value, int>::type = 0>
            const Settings::Sampling::Color &get() const
            {
                return m_color;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Sampling::Pixel>::value, int>::type = 0>
            const Settings::Sampling::Pixel &get() const
            {
                return m_pixel;
            }
 
            template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
            const Settings::Sampling::Color &get() const
            {
                return m_color;
            }
 
            template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
            const Settings::Sampling::Pixel &get() const
            {
                return m_pixel;
            }
 
            template<typename F>
            void forEach(const F &f) const
            {
                f(m_color);
                f(m_pixel);
            }
 
            template<typename F>
            void forEach(const F &f)
            {
                f(m_color);
                f(m_pixel);
            }
 
            bool operator==(const Sampling &other) const;
 
            bool operator!=(const Sampling &other) const;
 
            std::string toString() const;
 
            friend std::ostream &operator<<(std::ostream &stream, const Sampling &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;
 
            Color m_color;
            Pixel m_pixel;
 
            friend struct DataModel::Detail::Befriend<Sampling>;
        };
 
        using Descendants = std::tuple<
            Settings::Acquisitions,
            Settings::Diagnostics,
            Settings::Diagnostics::Enabled,
            Settings::Experimental,
            Settings::Experimental::Engine,
            Settings::Processing,
            Settings::Processing::Color,
            Settings::Processing::Color::Balance,
            Settings::Processing::Color::Balance::Blue,
            Settings::Processing::Color::Balance::Green,
            Settings::Processing::Color::Balance::Red,
            Settings::Processing::Color::Experimental,
            Settings::Processing::Color::Experimental::Mode,
            Settings::Processing::Color::Gamma,
            Settings::Processing::Filters,
            Settings::Processing::Filters::Cluster,
            Settings::Processing::Filters::Cluster::Removal,
            Settings::Processing::Filters::Cluster::Removal::Enabled,
            Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance,
            Settings::Processing::Filters::Cluster::Removal::MinArea,
            Settings::Processing::Filters::Experimental,
            Settings::Processing::Filters::Experimental::ContrastDistortion,
            Settings::Processing::Filters::Experimental::ContrastDistortion::Correction,
            Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled,
            Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength,
            Settings::Processing::Filters::Experimental::ContrastDistortion::Removal,
            Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled,
            Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold,
            Settings::Processing::Filters::Experimental::HoleFilling,
            Settings::Processing::Filters::Experimental::HoleFilling::Enabled,
            Settings::Processing::Filters::Experimental::HoleFilling::HoleSize,
            Settings::Processing::Filters::Experimental::HoleFilling::Strictness,
            Settings::Processing::Filters::Noise,
            Settings::Processing::Filters::Noise::Removal,
            Settings::Processing::Filters::Noise::Removal::Enabled,
            Settings::Processing::Filters::Noise::Removal::Threshold,
            Settings::Processing::Filters::Noise::Repair,
            Settings::Processing::Filters::Noise::Repair::Enabled,
            Settings::Processing::Filters::Noise::Suppression,
            Settings::Processing::Filters::Noise::Suppression::Enabled,
            Settings::Processing::Filters::Outlier,
            Settings::Processing::Filters::Outlier::Removal,
            Settings::Processing::Filters::Outlier::Removal::Enabled,
            Settings::Processing::Filters::Outlier::Removal::Threshold,
            Settings::Processing::Filters::Reflection,
            Settings::Processing::Filters::Reflection::Removal,
            Settings::Processing::Filters::Reflection::Removal::Enabled,
            Settings::Processing::Filters::Reflection::Removal::Experimental,
            Settings::Processing::Filters::Reflection::Removal::Experimental::Mode,
            Settings::Processing::Filters::Smoothing,
            Settings::Processing::Filters::Smoothing::Gaussian,
            Settings::Processing::Filters::Smoothing::Gaussian::Enabled,
            Settings::Processing::Filters::Smoothing::Gaussian::Sigma,
            Settings::RegionOfInterest,
            Settings::RegionOfInterest::Box,
            Settings::RegionOfInterest::Box::Enabled,
            Settings::RegionOfInterest::Box::Extents,
            Settings::RegionOfInterest::Box::PointA,
            Settings::RegionOfInterest::Box::PointB,
            Settings::RegionOfInterest::Box::PointO,
            Settings::RegionOfInterest::Depth,
            Settings::RegionOfInterest::Depth::Enabled,
            Settings::RegionOfInterest::Depth::Range,
            Settings::Sampling,
            Settings::Sampling::Color,
            Settings::Sampling::Pixel>;
 
        Settings();
 
        explicit Settings(const std::string &fileName);
 
#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 Settings(Args &&...args)
        {
            using namespace Zivid::Detail::TypeTraits;
 
            static_assert(
                AllArgsDecayedAreUnique<Args...>::value,
                "Found duplicate types among the arguments passed to Settings(...). "
                "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
        Settings 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 Acquisitions &acquisitions() const
        {
            return m_acquisitions;
        }
 
        Acquisitions &acquisitions()
        {
            return m_acquisitions;
        }
 
        Settings &set(const Acquisitions &value)
        {
            m_acquisitions = value;
            return *this;
        }
 
        const Diagnostics &diagnostics() const
        {
            return m_diagnostics;
        }
 
        Diagnostics &diagnostics()
        {
            return m_diagnostics;
        }
 
        Settings &set(const Diagnostics &value)
        {
            m_diagnostics = value;
            return *this;
        }
 
        Settings &set(const Diagnostics::Enabled &value)
        {
            m_diagnostics.set(value);
            return *this;
        }
 
        const Experimental &experimental() const
        {
            return m_experimental;
        }
 
        Experimental &experimental()
        {
            return m_experimental;
        }
 
        Settings &set(const Experimental &value)
        {
            m_experimental = value;
            return *this;
        }
 
        Settings &set(const Experimental::Engine &value)
        {
            m_experimental.set(value);
            return *this;
        }
 
        const Processing &processing() const
        {
            return m_processing;
        }
 
        Processing &processing()
        {
            return m_processing;
        }
 
        Settings &set(const Processing &value)
        {
            m_processing = value;
            return *this;
        }
 
        Settings &set(const Processing::Color &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Color::Balance &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Color::Balance::Blue &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Color::Balance::Green &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Color::Balance::Red &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Color::Experimental &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Color::Experimental::Mode &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Color::Gamma &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Cluster &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Cluster::Removal &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Cluster::Removal::Enabled &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Cluster::Removal::MaxNeighborDistance &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Cluster::Removal::MinArea &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Experimental &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Experimental::ContrastDistortion &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Experimental::ContrastDistortion::Correction &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Experimental::ContrastDistortion::Correction::Strength &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Experimental::ContrastDistortion::Removal &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Experimental::HoleFilling &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Experimental::HoleFilling::Enabled &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Experimental::HoleFilling::HoleSize &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Experimental::HoleFilling::Strictness &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Noise &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Noise::Removal &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Noise::Removal::Enabled &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Noise::Removal::Threshold &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Noise::Repair &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Noise::Repair::Enabled &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Noise::Suppression &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Noise::Suppression::Enabled &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Outlier &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Outlier::Removal &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Outlier::Removal::Enabled &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Outlier::Removal::Threshold &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Reflection &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Reflection::Removal &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Reflection::Removal::Enabled &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Reflection::Removal::Experimental &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Reflection::Removal::Experimental::Mode &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Smoothing &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Smoothing::Gaussian &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Smoothing::Gaussian::Enabled &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Smoothing::Gaussian::Sigma &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        const RegionOfInterest &regionOfInterest() const
        {
            return m_regionOfInterest;
        }
 
        RegionOfInterest &regionOfInterest()
        {
            return m_regionOfInterest;
        }
 
        Settings &set(const RegionOfInterest &value)
        {
            m_regionOfInterest = value;
            return *this;
        }
 
        Settings &set(const RegionOfInterest::Box &value)
        {
            m_regionOfInterest.set(value);
            return *this;
        }
 
        Settings &set(const RegionOfInterest::Box::Enabled &value)
        {
            m_regionOfInterest.set(value);
            return *this;
        }
 
        Settings &set(const RegionOfInterest::Box::Extents &value)
        {
            m_regionOfInterest.set(value);
            return *this;
        }
 
        Settings &set(const RegionOfInterest::Box::PointA &value)
        {
            m_regionOfInterest.set(value);
            return *this;
        }
 
        Settings &set(const RegionOfInterest::Box::PointB &value)
        {
            m_regionOfInterest.set(value);
            return *this;
        }
 
        Settings &set(const RegionOfInterest::Box::PointO &value)
        {
            m_regionOfInterest.set(value);
            return *this;
        }
 
        Settings &set(const RegionOfInterest::Depth &value)
        {
            m_regionOfInterest.set(value);
            return *this;
        }
 
        Settings &set(const RegionOfInterest::Depth::Enabled &value)
        {
            m_regionOfInterest.set(value);
            return *this;
        }
 
        Settings &set(const RegionOfInterest::Depth::Range &value)
        {
            m_regionOfInterest.set(value);
            return *this;
        }
 
        const Sampling &sampling() const
        {
            return m_sampling;
        }
 
        Sampling &sampling()
        {
            return m_sampling;
        }
 
        Settings &set(const Sampling &value)
        {
            m_sampling = value;
            return *this;
        }
 
        Settings &set(const Sampling::Color &value)
        {
            m_sampling.set(value);
            return *this;
        }
 
        Settings &set(const Sampling::Pixel &value)
        {
            m_sampling.set(value);
            return *this;
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, Settings::Acquisitions>::value, int>::type = 0>
        const Settings::Acquisitions &get() const
        {
            return m_acquisitions;
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, Settings::Diagnostics>::value, int>::type = 0>
        const Settings::Diagnostics &get() const
        {
            return m_diagnostics;
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::Diagnostics::Enabled>::value, int>::type = 0>
        const Settings::Diagnostics::Enabled &get() const
        {
            return m_diagnostics.get<Settings::Diagnostics::Enabled>();
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, Settings::Experimental>::value, int>::type = 0>
        const Settings::Experimental &get() const
        {
            return m_experimental;
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::Experimental::Engine>::value, int>::type = 0>
        const Settings::Experimental::Engine &get() const
        {
            return m_experimental.get<Settings::Experimental::Engine>();
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, Settings::Processing>::value, int>::type = 0>
        const Settings::Processing &get() const
        {
            return m_processing;
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::Processing::Color>::value, int>::type = 0>
        const Settings::Processing::Color &get() const
        {
            return m_processing.get<Settings::Processing::Color>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance>::value, int>::type = 0>
        const Settings::Processing::Color::Balance &get() const
        {
            return m_processing.get<Settings::Processing::Color::Balance>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance::Blue>::value, int>::type = 0>
        const Settings::Processing::Color::Balance::Blue &get() const
        {
            return m_processing.get<Settings::Processing::Color::Balance::Blue>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance::Green>::value, int>::type = 0>
        const Settings::Processing::Color::Balance::Green &get() const
        {
            return m_processing.get<Settings::Processing::Color::Balance::Green>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::Processing::Color::Balance::Red>::value, int>::type = 0>
        const Settings::Processing::Color::Balance::Red &get() const
        {
            return m_processing.get<Settings::Processing::Color::Balance::Red>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::Processing::Color::Experimental>::value, int>::type = 0>
        const Settings::Processing::Color::Experimental &get() const
        {
            return m_processing.get<Settings::Processing::Color::Experimental>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::Processing::Color::Experimental::Mode>::value, int>::
                type = 0>
        const Settings::Processing::Color::Experimental::Mode &get() const
        {
            return m_processing.get<Settings::Processing::Color::Experimental::Mode>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::Processing::Color::Gamma>::value, int>::type = 0>
        const Settings::Processing::Color::Gamma &get() const
        {
            return m_processing.get<Settings::Processing::Color::Gamma>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::Processing::Filters>::value, int>::type = 0>
        const Settings::Processing::Filters &get() const
        {
            return m_processing.get<Settings::Processing::Filters>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Cluster>::value, int>::type = 0>
        const Settings::Processing::Filters::Cluster &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Cluster>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Cluster::Removal>::value, int>::
                type = 0>
        const Settings::Processing::Filters::Cluster::Removal &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Cluster::Removal>();
        }
 
        template<
            typename T,
            typename std::enable_if<
                std::is_same<T, Settings::Processing::Filters::Cluster::Removal::Enabled>::value,
                int>::type = 0>
        const Settings::Processing::Filters::Cluster::Removal::Enabled &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Cluster::Removal::Enabled>();
        }
 
        template<
            typename T,
            typename std::enable_if<
                std::is_same<T, Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance>::value,
                int>::type = 0>
        const Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Cluster::Removal::MaxNeighborDistance>();
        }
 
        template<
            typename T,
            typename std::enable_if<
                std::is_same<T, Settings::Processing::Filters::Cluster::Removal::MinArea>::value,
                int>::type = 0>
        const Settings::Processing::Filters::Cluster::Removal::MinArea &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Cluster::Removal::MinArea>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Experimental>::value, int>::type = 0>
        const Settings::Processing::Filters::Experimental &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Experimental>();
        }
 
        template<
            typename T,
            typename std::enable_if<
                std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion>::value,
                int>::type = 0>
        const Settings::Processing::Filters::Experimental::ContrastDistortion &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Experimental::ContrastDistortion>();
        }
 
        template<
            typename T,
            typename std::enable_if<
                std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Correction>::value,
                int>::type = 0>
        const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Experimental::ContrastDistortion::Correction>();
        }
 
        template<
            typename T,
            typename std::enable_if<
                std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled>::
                    value,
                int>::type = 0>
        const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled &get() const
        {
            return m_processing
                .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Enabled>();
        }
 
        template<
            typename T,
            typename std::enable_if<
                std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength>::
                    value,
                int>::type = 0>
        const Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength &get() const
        {
            return m_processing
                .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Correction::Strength>();
        }
 
        template<
            typename T,
            typename std::enable_if<
                std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>::value,
                int>::type = 0>
        const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>();
        }
 
        template<
            typename T,
            typename std::enable_if<
                std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled>::
                    value,
                int>::type = 0>
        const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled &get() const
        {
            return m_processing
                .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Enabled>();
        }
 
        template<
            typename T,
            typename std::enable_if<
                std::is_same<T, Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold>::
                    value,
                int>::type = 0>
        const Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold &get() const
        {
            return m_processing
                .get<Settings::Processing::Filters::Experimental::ContrastDistortion::Removal::Threshold>();
        }
 
        template<
            typename T,
            typename std::enable_if<
                std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling>::value,
                int>::type = 0>
        const Settings::Processing::Filters::Experimental::HoleFilling &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Experimental::HoleFilling>();
        }
 
        template<
            typename T,
            typename std::enable_if<
                std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling::Enabled>::value,
                int>::type = 0>
        const Settings::Processing::Filters::Experimental::HoleFilling::Enabled &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Experimental::HoleFilling::Enabled>();
        }
 
        template<
            typename T,
            typename std::enable_if<
                std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling::HoleSize>::value,
                int>::type = 0>
        const Settings::Processing::Filters::Experimental::HoleFilling::HoleSize &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Experimental::HoleFilling::HoleSize>();
        }
 
        template<
            typename T,
            typename std::enable_if<
                std::is_same<T, Settings::Processing::Filters::Experimental::HoleFilling::Strictness>::value,
                int>::type = 0>
        const Settings::Processing::Filters::Experimental::HoleFilling::Strictness &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Experimental::HoleFilling::Strictness>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Noise>::value, int>::type = 0>
        const Settings::Processing::Filters::Noise &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Noise>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Noise::Removal>::value, int>::type =
                0>
        const Settings::Processing::Filters::Noise::Removal &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Noise::Removal>();
        }
 
        template<
            typename T,
            typename std::enable_if<
                std::is_same<T, Settings::Processing::Filters::Noise::Removal::Enabled>::value,
                int>::type = 0>
        const Settings::Processing::Filters::Noise::Removal::Enabled &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Noise::Removal::Enabled>();
        }
 
        template<
            typename T,
            typename std::enable_if<
                std::is_same<T, Settings::Processing::Filters::Noise::Removal::Threshold>::value,
                int>::type = 0>
        const Settings::Processing::Filters::Noise::Removal::Threshold &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Noise::Removal::Threshold>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Noise::Repair>::value, int>::type =
                0>
        const Settings::Processing::Filters::Noise::Repair &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Noise::Repair>();
        }
 
        template<
            typename T,
            typename std::
                enable_if<std::is_same<T, Settings::Processing::Filters::Noise::Repair::Enabled>::value, int>::type = 0>
        const Settings::Processing::Filters::Noise::Repair::Enabled &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Noise::Repair::Enabled>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Noise::Suppression>::value, int>::
                type = 0>
        const Settings::Processing::Filters::Noise::Suppression &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Noise::Suppression>();
        }
 
        template<
            typename T,
            typename std::enable_if<
                std::is_same<T, Settings::Processing::Filters::Noise::Suppression::Enabled>::value,
                int>::type = 0>
        const Settings::Processing::Filters::Noise::Suppression::Enabled &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Noise::Suppression::Enabled>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Outlier>::value, int>::type = 0>
        const Settings::Processing::Filters::Outlier &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Outlier>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Outlier::Removal>::value, int>::
                type = 0>
        const Settings::Processing::Filters::Outlier::Removal &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Outlier::Removal>();
        }
 
        template<
            typename T,
            typename std::enable_if<
                std::is_same<T, Settings::Processing::Filters::Outlier::Removal::Enabled>::value,
                int>::type = 0>
        const Settings::Processing::Filters::Outlier::Removal::Enabled &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Outlier::Removal::Enabled>();
        }
 
        template<
            typename T,
            typename std::enable_if<
                std::is_same<T, Settings::Processing::Filters::Outlier::Removal::Threshold>::value,
                int>::type = 0>
        const Settings::Processing::Filters::Outlier::Removal::Threshold &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Outlier::Removal::Threshold>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Reflection>::value, int>::type = 0>
        const Settings::Processing::Filters::Reflection &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Reflection>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Reflection::Removal>::value, int>::
                type = 0>
        const Settings::Processing::Filters::Reflection::Removal &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Reflection::Removal>();
        }
 
        template<
            typename T,
            typename std::enable_if<
                std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Enabled>::value,
                int>::type = 0>
        const Settings::Processing::Filters::Reflection::Removal::Enabled &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Reflection::Removal::Enabled>();
        }
 
        template<
            typename T,
            typename std::enable_if<
                std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Experimental>::value,
                int>::type = 0>
        const Settings::Processing::Filters::Reflection::Removal::Experimental &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Reflection::Removal::Experimental>();
        }
 
        template<
            typename T,
            typename std::enable_if<
                std::is_same<T, Settings::Processing::Filters::Reflection::Removal::Experimental::Mode>::value,
                int>::type = 0>
        const Settings::Processing::Filters::Reflection::Removal::Experimental::Mode &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Reflection::Removal::Experimental::Mode>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Smoothing>::value, int>::type = 0>
        const Settings::Processing::Filters::Smoothing &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Smoothing>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian>::value, int>::
                type = 0>
        const Settings::Processing::Filters::Smoothing::Gaussian &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Smoothing::Gaussian>();
        }
 
        template<
            typename T,
            typename std::enable_if<
                std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian::Enabled>::value,
                int>::type = 0>
        const Settings::Processing::Filters::Smoothing::Gaussian::Enabled &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Smoothing::Gaussian::Enabled>();
        }
 
        template<
            typename T,
            typename std::enable_if<
                std::is_same<T, Settings::Processing::Filters::Smoothing::Gaussian::Sigma>::value,
                int>::type = 0>
        const Settings::Processing::Filters::Smoothing::Gaussian::Sigma &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Smoothing::Gaussian::Sigma>();
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, Settings::RegionOfInterest>::value, int>::type = 0>
        const Settings::RegionOfInterest &get() const
        {
            return m_regionOfInterest;
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box>::value, int>::type = 0>
        const Settings::RegionOfInterest::Box &get() const
        {
            return m_regionOfInterest.get<Settings::RegionOfInterest::Box>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box::Enabled>::value, int>::type = 0>
        const Settings::RegionOfInterest::Box::Enabled &get() const
        {
            return m_regionOfInterest.get<Settings::RegionOfInterest::Box::Enabled>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box::Extents>::value, int>::type = 0>
        const Settings::RegionOfInterest::Box::Extents &get() const
        {
            return m_regionOfInterest.get<Settings::RegionOfInterest::Box::Extents>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box::PointA>::value, int>::type = 0>
        const Settings::RegionOfInterest::Box::PointA &get() const
        {
            return m_regionOfInterest.get<Settings::RegionOfInterest::Box::PointA>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box::PointB>::value, int>::type = 0>
        const Settings::RegionOfInterest::Box::PointB &get() const
        {
            return m_regionOfInterest.get<Settings::RegionOfInterest::Box::PointB>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Box::PointO>::value, int>::type = 0>
        const Settings::RegionOfInterest::Box::PointO &get() const
        {
            return m_regionOfInterest.get<Settings::RegionOfInterest::Box::PointO>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Depth>::value, int>::type = 0>
        const Settings::RegionOfInterest::Depth &get() const
        {
            return m_regionOfInterest.get<Settings::RegionOfInterest::Depth>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Depth::Enabled>::value, int>::type = 0>
        const Settings::RegionOfInterest::Depth::Enabled &get() const
        {
            return m_regionOfInterest.get<Settings::RegionOfInterest::Depth::Enabled>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::RegionOfInterest::Depth::Range>::value, int>::type = 0>
        const Settings::RegionOfInterest::Depth::Range &get() const
        {
            return m_regionOfInterest.get<Settings::RegionOfInterest::Depth::Range>();
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, Settings::Sampling>::value, int>::type = 0>
        const Settings::Sampling &get() const
        {
            return m_sampling;
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, Settings::Sampling::Color>::value, int>::type = 0>
        const Settings::Sampling::Color &get() const
        {
            return m_sampling.get<Settings::Sampling::Color>();
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, Settings::Sampling::Pixel>::value, int>::type = 0>
        const Settings::Sampling::Pixel &get() const
        {
            return m_sampling.get<Settings::Sampling::Pixel>();
        }
 
        template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
        const Settings::Acquisitions &get() const
        {
            return m_acquisitions;
        }
 
        template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
        const Settings::Diagnostics &get() const
        {
            return m_diagnostics;
        }
 
        template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
        const Settings::Experimental &get() const
        {
            return m_experimental;
        }
 
        template<size_t i, typename std::enable_if<i == 3, int>::type = 0>
        const Settings::Processing &get() const
        {
            return m_processing;
        }
 
        template<size_t i, typename std::enable_if<i == 4, int>::type = 0>
        const Settings::RegionOfInterest &get() const
        {
            return m_regionOfInterest;
        }
 
        template<size_t i, typename std::enable_if<i == 5, int>::type = 0>
        const Settings::Sampling &get() const
        {
            return m_sampling;
        }
 
        template<typename F>
        void forEach(const F &f) const
        {
            f(m_acquisitions);
            f(m_diagnostics);
            f(m_experimental);
            f(m_processing);
            f(m_regionOfInterest);
            f(m_sampling);
        }
 
        template<typename F>
        void forEach(const F &f)
        {
            f(m_acquisitions);
            f(m_diagnostics);
            f(m_experimental);
            f(m_processing);
            f(m_regionOfInterest);
            f(m_sampling);
        }
 
        bool operator==(const Settings &other) const;
 
        bool operator!=(const Settings &other) const;
 
        std::string toString() const;
 
        friend std::ostream &operator<<(std::ostream &stream, const Settings &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;
 
        Acquisitions m_acquisitions;
        Diagnostics m_diagnostics;
        Experimental m_experimental;
        Processing m_processing;
        RegionOfInterest m_regionOfInterest;
        Sampling m_sampling;
 
        friend struct DataModel::Detail::Befriend<Settings>;
    };
 
#ifndef NO_DOC
    namespace Detail
    {
        ZIVID_CORE_EXPORT void save(const Settings &dataModel, std::ostream &ostream);
        ZIVID_CORE_EXPORT void load(Settings &dataModel, std::istream &istream);
    } // namespace Detail
#endif
 
#ifndef NO_DOC
    template<>
    struct Settings::Version<21>
    {
        using Type = Settings;
    };
#endif
 
} // namespace Zivid
 
#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::Settings::Diagnostics> : integral_constant<size_t, 1>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Diagnostics>
    {
        static_assert(i < tuple_size<Zivid::Settings::Diagnostics>::value, "Index must be less than 1");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Diagnostics>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::Experimental> : integral_constant<size_t, 1>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Experimental>
    {
        static_assert(i < tuple_size<Zivid::Settings::Experimental>::value, "Index must be less than 1");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Experimental>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::Processing> : integral_constant<size_t, 2>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Processing>
    {
        static_assert(i < tuple_size<Zivid::Settings::Processing>::value, "Index must be less than 2");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Processing>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::Processing::Color> : integral_constant<size_t, 3>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Processing::Color>
    {
        static_assert(i < tuple_size<Zivid::Settings::Processing::Color>::value, "Index must be less than 3");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Processing::Color>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::Processing::Color::Balance> : integral_constant<size_t, 3>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Processing::Color::Balance>
    {
        static_assert(i < tuple_size<Zivid::Settings::Processing::Color::Balance>::value, "Index must be less than 3");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Processing::Color::Balance>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::Processing::Color::Experimental> : integral_constant<size_t, 1>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Processing::Color::Experimental>
    {
        static_assert(
            i < tuple_size<Zivid::Settings::Processing::Color::Experimental>::value,
            "Index must be less than 1");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Processing::Color::Experimental>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::Processing::Filters> : integral_constant<size_t, 6>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Processing::Filters>
    {
        static_assert(i < tuple_size<Zivid::Settings::Processing::Filters>::value, "Index must be less than 6");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Processing::Filters>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::Processing::Filters::Cluster> : integral_constant<size_t, 1>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Processing::Filters::Cluster>
    {
        static_assert(
            i < tuple_size<Zivid::Settings::Processing::Filters::Cluster>::value,
            "Index must be less than 1");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Processing::Filters::Cluster>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::Processing::Filters::Cluster::Removal> : integral_constant<size_t, 3>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Processing::Filters::Cluster::Removal>
    {
        static_assert(
            i < tuple_size<Zivid::Settings::Processing::Filters::Cluster::Removal>::value,
            "Index must be less than 3");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Processing::Filters::Cluster::Removal>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::Processing::Filters::Experimental> : integral_constant<size_t, 2>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Processing::Filters::Experimental>
    {
        static_assert(
            i < tuple_size<Zivid::Settings::Processing::Filters::Experimental>::value,
            "Index must be less than 2");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Processing::Filters::Experimental>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion>
        : integral_constant<size_t, 2>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion>
    {
        static_assert(
            i < tuple_size<Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion>::value,
            "Index must be less than 2");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction>
        : integral_constant<size_t, 2>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction>
    {
        static_assert(
            i < tuple_size<Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction>::value,
            "Index must be less than 2");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Correction>()
                           .get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>
        : integral_constant<size_t, 2>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>
    {
        static_assert(
            i < tuple_size<Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>::value,
            "Index must be less than 2");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Processing::Filters::Experimental::ContrastDistortion::Removal>()
                           .get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::Processing::Filters::Experimental::HoleFilling> : integral_constant<size_t, 3>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Processing::Filters::Experimental::HoleFilling>
    {
        static_assert(
            i < tuple_size<Zivid::Settings::Processing::Filters::Experimental::HoleFilling>::value,
            "Index must be less than 3");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Processing::Filters::Experimental::HoleFilling>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::Processing::Filters::Noise> : integral_constant<size_t, 3>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Processing::Filters::Noise>
    {
        static_assert(i < tuple_size<Zivid::Settings::Processing::Filters::Noise>::value, "Index must be less than 3");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Processing::Filters::Noise>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::Processing::Filters::Noise::Removal> : integral_constant<size_t, 2>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Processing::Filters::Noise::Removal>
    {
        static_assert(
            i < tuple_size<Zivid::Settings::Processing::Filters::Noise::Removal>::value,
            "Index must be less than 2");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Processing::Filters::Noise::Removal>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::Processing::Filters::Noise::Repair> : integral_constant<size_t, 1>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Processing::Filters::Noise::Repair>
    {
        static_assert(
            i < tuple_size<Zivid::Settings::Processing::Filters::Noise::Repair>::value,
            "Index must be less than 1");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Processing::Filters::Noise::Repair>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::Processing::Filters::Noise::Suppression> : integral_constant<size_t, 1>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Processing::Filters::Noise::Suppression>
    {
        static_assert(
            i < tuple_size<Zivid::Settings::Processing::Filters::Noise::Suppression>::value,
            "Index must be less than 1");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Processing::Filters::Noise::Suppression>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::Processing::Filters::Outlier> : integral_constant<size_t, 1>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Processing::Filters::Outlier>
    {
        static_assert(
            i < tuple_size<Zivid::Settings::Processing::Filters::Outlier>::value,
            "Index must be less than 1");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Processing::Filters::Outlier>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::Processing::Filters::Outlier::Removal> : integral_constant<size_t, 2>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Processing::Filters::Outlier::Removal>
    {
        static_assert(
            i < tuple_size<Zivid::Settings::Processing::Filters::Outlier::Removal>::value,
            "Index must be less than 2");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Processing::Filters::Outlier::Removal>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::Processing::Filters::Reflection> : integral_constant<size_t, 1>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Processing::Filters::Reflection>
    {
        static_assert(
            i < tuple_size<Zivid::Settings::Processing::Filters::Reflection>::value,
            "Index must be less than 1");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Processing::Filters::Reflection>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::Processing::Filters::Reflection::Removal> : integral_constant<size_t, 2>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Processing::Filters::Reflection::Removal>
    {
        static_assert(
            i < tuple_size<Zivid::Settings::Processing::Filters::Reflection::Removal>::value,
            "Index must be less than 2");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Processing::Filters::Reflection::Removal>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::Processing::Filters::Reflection::Removal::Experimental>
        : integral_constant<size_t, 1>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Processing::Filters::Reflection::Removal::Experimental>
    {
        static_assert(
            i < tuple_size<Zivid::Settings::Processing::Filters::Reflection::Removal::Experimental>::value,
            "Index must be less than 1");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Processing::Filters::Reflection::Removal::Experimental>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::Processing::Filters::Smoothing> : integral_constant<size_t, 1>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Processing::Filters::Smoothing>
    {
        static_assert(
            i < tuple_size<Zivid::Settings::Processing::Filters::Smoothing>::value,
            "Index must be less than 1");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Processing::Filters::Smoothing>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::Processing::Filters::Smoothing::Gaussian> : integral_constant<size_t, 2>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Processing::Filters::Smoothing::Gaussian>
    {
        static_assert(
            i < tuple_size<Zivid::Settings::Processing::Filters::Smoothing::Gaussian>::value,
            "Index must be less than 2");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Processing::Filters::Smoothing::Gaussian>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::RegionOfInterest> : integral_constant<size_t, 2>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::RegionOfInterest>
    {
        static_assert(i < tuple_size<Zivid::Settings::RegionOfInterest>::value, "Index must be less than 2");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings::RegionOfInterest>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::RegionOfInterest::Box> : integral_constant<size_t, 5>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::RegionOfInterest::Box>
    {
        static_assert(i < tuple_size<Zivid::Settings::RegionOfInterest::Box>::value, "Index must be less than 5");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings::RegionOfInterest::Box>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::RegionOfInterest::Depth> : integral_constant<size_t, 2>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::RegionOfInterest::Depth>
    {
        static_assert(i < tuple_size<Zivid::Settings::RegionOfInterest::Depth>::value, "Index must be less than 2");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings::RegionOfInterest::Depth>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::Sampling> : integral_constant<size_t, 2>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Sampling>
    {
        static_assert(i < tuple_size<Zivid::Settings::Sampling>::value, "Index must be less than 2");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Sampling>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings> : integral_constant<size_t, 6>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings>
    {
        static_assert(i < tuple_size<Zivid::Settings>::value, "Index must be less than 6");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings>().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/SettingsInternal.h") && __has_include("Zivid/DataModelNodeMetaData.h")
#        include "Zivid/SettingsInternal.h"
#    endif
#endif